[ecj] Patch: FYI: handle other access bits

[Tom Tromey <tromey at redhat dot com>]

I'm checking this in on the gcj-eclipse-merge-branch.

This changes gcj to handle the access bits it was missing.  This is
important for reflection.

Test case included.

Tom

Index: gcc/java/ChangeLog
from  Tom Tromey  <tromey@redhat.com>

	PR java/29495:
	* jcf-parse.c (HANDLE_SYNTHETIC_ATTRIBUTE): Mark fields and
	classes as well.
	* class.c (add_field): Handle ACC_SYNTHETIC.
	(add_method_1): Likewise.  Handle bridge and varargs.
	(get_access_flags_from_decl): Handle synthetic, bridge, varargs,
	annotation.
	(set_class_decl_access_flags): Handle synthetic and annotation.
	* java-tree.h (METHOD_BRIDGE): New macro.
	(METHOD_VARARGS): Likewise.
	(TYPE_SYNTHETIC): Likewise.
	(TYPE_ANNOTATION): Likewise.
	(lang_type): New fields 'synthetic' and 'annotation'.
	(lang_decl_func): New fields 'varargs' and 'bridge'.

Index: libjava/ChangeLog
from  Tom Tromey  <tromey@redhat.com>

	PR java/29495:
	* testsuite/libjava.lang/PR29495.out: New file.
	* testsuite/libjava.lang/PR29495.java: New file.

Index: gcc/java/class.c
===================================================================
--- gcc/java/class.c	(revision 119552)
+++ gcc/java/class.c	(working copy)
@@ -499,6 +499,8 @@
   if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
   if (access_flags & ACC_STRICT)    CLASS_STRICTFP (class_decl) = 1;
   if (access_flags & ACC_ENUM)      CLASS_ENUM (class_decl) = 1;
+  if (access_flags & ACC_SYNTHETIC) CLASS_SYNTHETIC (class_decl) = 1;
+  if (access_flags & ACC_ANNOTATION) CLASS_ANNOTATION (class_decl) = 1;
 }
 
 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
@@ -750,6 +752,9 @@
   if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
   if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
   if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
+  if (access_flags & ACC_SYNTHETIC) DECL_ARTIFICIAL (fndecl) = 1;
+  if (access_flags & ACC_BRIDGE) METHOD_BRIDGE (fndecl) = 1;
+  if (access_flags & ACC_VARARGS) METHOD_VARARGS (fndecl) = 1;
   return fndecl;
 }
 
@@ -795,6 +800,7 @@
     }
   if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
   if (flags & ACC_ENUM) FIELD_ENUM (field) = 1;
+  if (flags & ACC_SYNTHETIC) FIELD_SYNTHETIC (field) = 1;
   if (is_static)
     {
       FIELD_STATIC (field) = 1;
@@ -1225,6 +1231,8 @@
 	access_flags |= ACC_TRANSIENT;
       if (FIELD_ENUM (decl))
 	access_flags |= ACC_ENUM;
+      if (FIELD_SYNTHETIC (decl))
+	access_flags |= ACC_SYNTHETIC;
       return access_flags;
     }
   if (TREE_CODE (decl) == TYPE_DECL)
@@ -1249,6 +1257,10 @@
 	access_flags |= ACC_STRICT;
       if (CLASS_ENUM (decl))
 	access_flags |= ACC_ENUM;
+      if (CLASS_SYNTHETIC (decl))
+	access_flags |= ACC_SYNTHETIC;
+      if (CLASS_ANNOTATION (decl))
+	access_flags |= ACC_ANNOTATION;
       return access_flags;
     }
   if (TREE_CODE (decl) == FUNCTION_DECL)
@@ -1273,6 +1285,12 @@
 	access_flags |= ACC_STRICT;
       if (METHOD_INVISIBLE (decl))
 	access_flags |= ACC_INVISIBLE;
+      if (DECL_ARTIFICIAL (decl))
+	access_flags |= ACC_SYNTHETIC;
+      if (METHOD_BRIDGE (decl))
+	access_flags |= ACC_BRIDGE;
+      if (METHOD_VARARGS (decl))
+	access_flags |= ACC_VARARGS;
       return access_flags;
     }
   gcc_unreachable ();
Index: gcc/java/jcf-parse.c
===================================================================
--- gcc/java/jcf-parse.c	(revision 119552)
+++ gcc/java/jcf-parse.c	(working copy)
@@ -970,11 +970,14 @@
 #define HANDLE_SYNTHETIC_ATTRIBUTE()					\
 {									\
   /* Irrelevant decls should have been nullified by the END macros.	\
-     We only handle the `Synthetic' attribute on method DECLs.		\
      DECL_ARTIFICIAL on fields is used for something else (See		\
      PUSH_FIELD in java-tree.h) */					\
   if (current_method)							\
     DECL_ARTIFICIAL (current_method) = 1;				\
+  else if (current_field)						\
+    FIELD_SYNTHETIC (current_field) = 1;				\
+  else									\
+    CLASS_SYNTHETIC (current_class) = 1;				\
 }
 
 #define HANDLE_GCJCOMPILED_ATTRIBUTE()		\
Index: gcc/java/java-tree.h
===================================================================
--- gcc/java/java-tree.h	(revision 119552)
+++ gcc/java/java-tree.h	(working copy)
@@ -991,6 +991,8 @@
 				   written to the .class file.  */
   unsigned int dummy : 1;
   unsigned int local_cni : 1;	/* Decl needs mangle_local_cni_method.  */
+  unsigned int bridge : 1;	/* Bridge method.  */
+  unsigned int varargs : 1;	/* Varargs method.  */
 };
 
 struct treetreehash_entry GTY(())
@@ -1103,6 +1105,9 @@
 #define TYPE_PROTECTED_INNER_CLASS(T) (TYPE_LANG_SPECIFIC (T)->poic)
 #define TYPE_STRICTFP(T) (TYPE_LANG_SPECIFIC (T)->strictfp)
 #define TYPE_ENUM(T) 		(TYPE_LANG_SPECIFIC (T)->enum_class)
+#define TYPE_SYNTHETIC(T)	(TYPE_LANG_SPECIFIC (T)->synthetic)
+#define TYPE_ANNOTATION(T)	(TYPE_LANG_SPECIFIC (T)->annotation)
+
 #define TYPE_USES_ASSERTIONS(T) (TYPE_LANG_SPECIFIC (T)->assertions)
 
 #define TYPE_ATABLE_METHODS(T)   (TYPE_LANG_SPECIFIC (T)->atable_methods)
@@ -1191,6 +1196,8 @@
   unsigned assertions:1;	/* Any method uses `assert'.  */
   unsigned dummy_class:1;	/* Not a real class, just a placeholder.  */
   unsigned enum_class:1;	/* Class is an enum type.  */
+  unsigned synthetic:1;		/* Class is synthetic.  */
+  unsigned annotation:1;	/* Class is an annotation type.  */
 };
 
 #define JCF_u4 unsigned long
@@ -1468,6 +1475,10 @@
   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.f.strictfp)
 #define METHOD_INVISIBLE(DECL) \
   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.f.invisible)
+#define METHOD_BRIDGE(DECL) \
+  (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.f.bridge)
+#define METHOD_VARARGS(DECL) \
+  (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.f.varargs)
 
 #define CLASS_FILE_P(NODE) TREE_LANG_FLAG_3 (NODE)
 
@@ -1511,6 +1522,8 @@
 #define CLASS_STRICTFP(DECL)	(TYPE_STRICTFP (TREE_TYPE (DECL)))
 #define CLASS_ENUM(DECL)	(TYPE_ENUM (TREE_TYPE (DECL)))
 #define CLASS_USES_ASSERTIONS(DECL) (TYPE_USES_ASSERTIONS (TREE_TYPE (DECL)))
+#define CLASS_SYNTHETIC(DECL)   (TYPE_SYNTHETIC (TREE_TYPE (DECL)))
+#define CLASS_ANNOTATION(DECL)  (TYPE_ANNOTATION (TREE_TYPE (DECL)))
 
 /* @deprecated marker flag on methods, fields and classes */
 
Index: libjava/testsuite/libjava.lang/PR29495.out
===================================================================
Index: libjava/testsuite/libjava.lang/PR29495.java
===================================================================
--- libjava/testsuite/libjava.lang/PR29495.java	(revision 0)
+++ libjava/testsuite/libjava.lang/PR29495.java	(revision 0)
@@ -0,0 +1,56 @@
+// Test various reflection methods.
+
+import java.lang.annotation.Inherited;
+import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+
+public class PR29495
+{
+  public class container<T>
+  {
+    // This class has a synthetic field...
+
+    public T get(T v) { return v; }
+  }
+
+  public class concrete extends container<String>
+  {
+    // This makes us have a synthetic bridge method.
+    public String get(String v) { return "hi" + v; }
+  }
+
+  // varargs method
+  public static void va(Object... args)
+  {
+  }
+
+  public static void check(boolean x, String m)
+  {
+    if (! x)
+      System.out.println("fail: " + m);
+  }
+
+  public static void main(String[] args) throws Throwable
+  {
+    check (Inherited.class.isAnnotation(), "Inherited isAnnotation");
+
+    Method m = PR29495.class.getDeclaredMethod("va", new Class[] { Object[].class });
+    check (m.isVarArgs(), "va isVarArgs");
+
+    m = concrete.class.getDeclaredMethod("get", new Class[] { Object.class });
+    check (m.isSynthetic(), "get isSynthetic");
+    check (m.isBridge(), "get isBridge");
+
+    Field[] fs = container.class.getDeclaredFields();
+    boolean ok = false;
+    for (int i = 0; i < fs.length; ++i)
+      {
+	if (fs[i].isSynthetic())
+	  {
+	    ok = true;
+	    break;
+	  }
+      }
+    check (ok, "container has synthetic field");
+  }
+}