Attachment #148041 for bug #287648

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




		expected13ProblemLog;

	String expected15ProblemLog =
		"----------\n" + 
		"1. WARNING in X.java (at line 1)\n" + 
		"	public class X <T1 extends String, T2 extends Y {\n" + 
		"	                           ^^^^^^\n" + 
		"The type parameter T1 should not be bounded by the final type String. Final types cannot be further extended\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 1)\n" + 
		"	public class X <T1 extends String, T2 extends Y {\n" + 
		"	                                              ^\n" + 
		"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 1)\n" + 
		"	public class X <T1 extends String, T2 extends Y {\n" + 
		"	                                              ^\n" + 
		"Y cannot be resolved to a type\n" + 
		"----------\n";

	runComplianceParserTest(

Lines 71-86 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/ParserTest.java (-25 / +35 lines)
71	" }\n" +	71	" }\n" +
72	"}\n"	72	"}\n"
73	},	73	},
74	"----------\n" +	74	"----------\n" +
75	"1. ERROR in X.java (at line 3)\n" +	75	"1. ERROR in X.java (at line 3)\n" +
76	" throws new X\n" +	76	" throws new X\n" +
77	" ^^^^^^\n" +	77	" ^^^^^^\n" +
78	"Syntax error on token \"throws\", throw expected\n" +	78	"Syntax error on token \"throws\", throw expected\n" +
79	"----------\n" +	79	"----------\n" +
80	"2. ERROR in X.java (at line 3)\n" +	80	"2. ERROR in X.java (at line 3)\n" +
81	" throws new X\n" +	81	" throws new X\n" +
82	" ^\n" +	82	" ^\n" +
83	"Syntax error, unexpected end of method\n" +	83	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
		84	"----------\n" +
		85	"3. ERROR in X.java (at line 3)\n" +
		86	" throws new X\n" +
		87	" ^\n" +
		88	"Syntax error, insert \";\" to complete BlockStatements\n" +
84	"----------\n"	89	"----------\n"
85	);	90	);
86	}	91	}
Lines 130-145 Link Here
130	" }\n" +	135	" }\n" +
131	"}\n"	136	"}\n"
132	},	137	},
133	"----------\n" +	138	"----------\n" +
134	"1. ERROR in X.java (at line 3)\n" +	139	"1. ERROR in X.java (at line 3)\n" +
135	" throws new X\n" +	140	" throws new X\n" +
136	" ^^^^^^\n" +	141	" ^^^^^^\n" +
137	"Syntax error on token \"throws\", throw expected\n" +	142	"Syntax error on token \"throws\", throw expected\n" +
138	"----------\n" +	143	"----------\n" +
139	"2. ERROR in X.java (at line 3)\n" +	144	"2. ERROR in X.java (at line 3)\n" +
140	" throws new X\n" +	145	" throws new X\n" +
141	" ^\n" +	146	" ^\n" +
142	"Syntax error, unexpected end of initializer\n" +	147	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
		148	"----------\n" +
		149	"3. ERROR in X.java (at line 3)\n" +
		150	" throws new X\n" +
		151	" ^\n" +
		152	"Syntax error, insert \";\" to complete BlockStatements\n" +
143	"----------\n"	153	"----------\n"
144	);	154	);
145	}	155	}
Lines 238-248 Link Here
238	" public void bar(){}\n" +	248	" public void bar(){}\n" +
239	"}\n"	249	"}\n"
240	},	250	},
241	"----------\n" +	251	"----------\n" +
242	"1. ERROR in X.java (at line 2)\n" +	252	"1. ERROR in X.java (at line 2)\n" +
243	" public void foo(X, Object o, String s) {\n" +	253	" public void foo(X, Object o, String s) {\n" +
244	" ^\n" +	254	" ^\n" +
245	"Syntax error on token \",\", . expected\n" +	255	"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameterList\n" +
246	"----------\n"	256	"----------\n"
247	);	257	);
248	}	258	}




		"1. ERROR in <parenthesis mismatch> (at line 3)\n" +
		"	[ arg1, 						\n" +
		"	^\n" +
		"Syntax error on token \"[\", boolean expected\n" +
		"----------\n" +
		"2. ERROR in <parenthesis mismatch> (at line 4)\n" +
		"	{ arg2, ]						\n" +
		"	^\n" +
		"Syntax error on token \"{\", boolean expected\n" +
		"----------\n" +
		"3. ERROR in <parenthesis mismatch> (at line 4)\n" +
		"	{ arg2, ]						\n" +
		"	        ^\n" +
		"Syntax error on token \"]\", boolean expected\n" +
		"----------\n" +
		"4. ERROR in <parenthesis mismatch> (at line 5)\n" +
		"	arg3, 						\n" +

		"1. ERROR in <test> (at line 3)\n"+
		"	i; 									\n"+
		"	^\n"+
		"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration\n" +
		"----------\n";

	String testName = "<test>";




				"	A2 a2;\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in test\\X1.java (at line 3)\n" + 
			"	public class X1<A1 extends X2<A2> {\n" + 
			"	                              ^^\n" + 
			"A2 cannot be resolved to a type\n" + 
			"----------\n" + 
			"2. ERROR in test\\X1.java (at line 3)\n" + 
			"	public class X1<A1 extends X2<A2> {\n" + 
			"	                                ^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"3. ERROR in test\\X1.java (at line 7)\n" + 
			"	class X2<A2 {\n" + 
			"	         ^^\n" + 
			"Syntax error, insert \">\" to complete TypeParameter1\n" + 
			"----------\n"		);
		);
	}

	// JSR14-V10[2.4]: Not terminated consecutive declaration

					"class X2<A extends X3<String> {}\n" +
					"class X3<A {}\n"
			},
			"----------\n" + 
			"1. ERROR in test\\X.java (at line 2)\n" + 
			"	public class X<A extends X1<X2<X3<String>>> {}\n" + 
			"	                                        ^^^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"2. ERROR in test\\X.java (at line 3)\n" + 
			"	class X1<A extends X2<X3<String>> {}\n" + 
			"	                               ^^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"3. ERROR in test\\X.java (at line 4)\n" + 
			"	class X2<A extends X3<String> {}\n" + 
			"	                            ^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"4. ERROR in test\\X.java (at line 5)\n" + 
			"	class X3<A {}\n" + 
			"	         ^\n" + 
			"Syntax error, insert \">\" to complete TypeParameter1\n" + 
			"----------\n"
		);
	}

					"class X2<A extends X3<String>> {}\n" +
					"class X3<A> {}\n"
			},
			"----------\n" + 
			"1. ERROR in test\\X.java (at line 2)\n" + 
			"	public class X<A extends X1<X2<X3<String {}\n" + 
			"	                                  ^^^^^^\n" + 
			"Syntax error, insert \">>>\" to complete ReferenceType3\n" + 
			"----------\n" + 
			"2. ERROR in test\\X.java (at line 2)\n" + 
			"	public class X<A extends X1<X2<X3<String {}\n" + 
			"	                                  ^^^^^^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n");
	}
	public void test0084() {





import junit.framework.Test;

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

public class JavadocTestMixed extends JavadocTest {

					+ "		return \"\";\n"
					+ "	}\n"
					+ "}\n" },
					"----------\n" + 
					"1. ERROR in test\\X.java (at line 23)\n" + 
					"	}\n" + 
					"	^\n" + 
					"Syntax error, insert \"}\" to complete ClassBody\n" + 
					"----------\n" + 
					"2. ERROR in test\\X.java (at line 26)\n" + 
					"	* @param list Valid param tag\n" + 
					"	         ^^^^\n" + 
					"Javadoc: Parameter list is not declared\n" + 
					"----------\n" + 
					"3. ERROR in test\\X.java (at line 33)\n" + 
					"	public String foo(java.util.Vector ) {\n" + 
					"	                            ^^^^^^\n" + 
					"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameterList\n" + 
					"----------\n" + 
					"4. ERROR in test\\X.java (at line 36)\n" + 
					"	}\n" + 
					"	^\n" + 
					"Syntax error on token \"}\", delete this token\n" + 
					"----------\n");						
						+ "----------\n"
					: "----------\n"
						+ "1. ERROR in test\\X.java (at line 23)\n"
						+ "	}\n"
						+ "	^\n"
						+ "Syntax error, insert \"}\" to complete ClassBody\n"
						+ "----------\n"
						+ "2. ERROR in test\\X.java (at line 26)\n"
						+ "	* @param list Valid param tag\n"
						+ "	         ^^^^\n"
						+ "Javadoc: Parameter list is not declared\n"
						+ "----------\n"
						+ "3. ERROR in test\\X.java (at line 33)\n"
						+ "	public String foo(java.util.Vector ) {\n"
						+ "	                           ^\n"
						+ "Syntax error on token \".\", ... expected\n"
						+ "----------\n"
						+ "4. ERROR in test\\X.java (at line 36)\n"
						+ "	}\n"
						+ "	^\n"
						+ "Syntax error on token \"}\", delete this token\n"
						+ "----------\n");
	}

	public void test040() {

Lines 36-41 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CastTest.java (+4 lines)
36	return buildAllCompliancesTestSuite(testClass());	36	return buildAllCompliancesTestSuite(testClass());
37	}	37	}
38		38
		39	static {
		40	TESTS_NAMES = new String [] {"test029" };
		41	}
		42
39	/*	43	/*
40	* check extra checkcast (interface->same interface)	44	* check extra checkcast (interface->same interface)
41	*/	45	*/




		expectedProblemAttributes.put("InvalidUsageOfAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfForeachStatements", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfReceiverAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfStaticImports", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfTypeAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfTypeParameters", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfTypeParametersForAnnotationDeclaration", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));

		expectedProblemAttributes.put("MethodRequiresBody", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("MethodReturnsVoid", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("MethodVarargsArgumentNeedCast", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("misplacedTypeAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("MissingArgumentsForParameterizedMemberType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("MissingEnclosingInstance", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", new ProblemAttributes(CategorizedProblem.CAT_TYPE));

		expectedProblemAttributes.put("InvalidUsageOfAnnotations", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfForeachStatements", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfReceiverAnnotations", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfStaticImports", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfTypeAnnotations", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfTypeArguments", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfTypeParameters", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfTypeParametersForAnnotationDeclaration", SKIP);

		expectedProblemAttributes.put("MethodRequiresBody", SKIP);
		expectedProblemAttributes.put("MethodReturnsVoid", SKIP);
		expectedProblemAttributes.put("MethodVarargsArgumentNeedCast", new ProblemAttributes(JavaCore.COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST));
		expectedProblemAttributes.put("misplacedTypeAnnotations", SKIP);
		expectedProblemAttributes.put("MissingArgumentsForParameterizedMemberType", SKIP);
		expectedProblemAttributes.put("MissingEnclosingInstance", SKIP);
		expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", SKIP);

Lines 166-172 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/ErrorsTests.java (-1 / +1 lines)
166	);	166	);
167	fullBuild();	167	fullBuild();
168	Problem[] prob1 = env.getProblemsFor(classTest1);	168	Problem[] prob1 = env.getProblemsFor(classTest1);
169	expectingSpecificProblemFor(classTest1, new Problem("p1", "Syntax error on token \"extends\", Type expected after this token", classTest1, 31, 38, CategorizedProblem.CAT_SYNTAX, IMarker.SEVERITY_ERROR));	169	expectingSpecificProblemFor(classTest1, new Problem("p1", "Syntax error on token \"extends\", ClassType expected after this token", classTest1, 31, 38, CategorizedProblem.CAT_SYNTAX, IMarker.SEVERITY_ERROR));
170	assertEquals(JavaBuilder.SOURCE_ID, prob1[0].getSourceId());	170	assertEquals(JavaBuilder.SOURCE_ID, prob1[0].getSourceId());
171	}	171	}
172		172

Lines 4812-4818 Link Here

(-)Eclipse Java Tests Compiler/org/eclipse/jdt/tests/compiler/regression/NegativeTest.java (-16 / +16 lines)
4812	"1. ERROR in p\\Example3.java (at line 10)\n" +	4812	"1. ERROR in p\\Example3.java (at line 10)\n" +
4813	" int myVal = condition ? x = 7 : x = 3;\n" +	4813	" int myVal = condition ? x = 7 : x = 3;\n" +
4814	" ^\n" +	4814	" ^\n" +
4815	"Syntax error on token \"=\", != expected\n" +	4815	"Syntax error on token \"=\", <= expected\n" +
4816	"----------\n"	4816	"----------\n"
4817	);	4817	);
4818	}	4818	}
Lines 4939-4959 Link Here
4939	" }\n" +	4939	" }\n" +
4940	"}",	4940	"}",
4941	},	4941	},
4942	"----------\n" +	4942	"----------\n" +
4943	"1. ERROR in p\\NA.java (at line 7)\n" +	4943	"1. ERROR in p\\NA.java (at line 7)\n" +
4944	" (new Class1).run();\n" +	4944	" (new Class1).run();\n" +
4945	" ^^^\n" +	4945	" ^^^^^^\n" +
4946	"Syntax error on token \"new\", delete this token\n" +	4946	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4947	"----------\n" +	4947	"----------\n" +
4948	"2. ERROR in p\\NA.java (at line 8)\n" +	4948	"2. ERROR in p\\NA.java (at line 8)\n" +
4949	" (new Class2).run();\n" +	4949	" (new Class2).run();\n" +
4950	" ^^^\n" +	4950	" ^^^^^^\n" +
4951	"Syntax error on token \"new\", delete this token\n" +	4951	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4952	"----------\n" +	4952	"----------\n" +
4953	"3. ERROR in p\\NA.java (at line 9)\n" +	4953	"3. ERROR in p\\NA.java (at line 9)\n" +
4954	" (new Class3).run();\n" +	4954	" (new Class3).run();\n" +
4955	" ^^^\n" +	4955	" ^^^^^^\n" +
4956	"Syntax error on token \"new\", delete this token\n" +	4956	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4957	"----------\n"	4957	"----------\n"
4958	);	4958	);
4959	}	4959	}

Lines 37-43 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchGenericTypeTests.java (-1 / +1 lines)
37	static {	37	static {
38	// org.eclipse.jdt.internal.core.search.matching.MatchLocator.PRINT_BUFFER = false;	38	// org.eclipse.jdt.internal.core.search.matching.MatchLocator.PRINT_BUFFER = false;
39	// TESTS_PREFIX = "testArray";	39	// TESTS_PREFIX = "testArray";
40	// TESTS_NAMES = new String[] { "testParameterizedTypeMultipleArguments01" };	40	// TESTS_NAMES = new String[] { "testParameterizedArrayTypeSingleArgument01" };
41	// TESTS_NUMBERS = new int[] { 8 };	41	// TESTS_NUMBERS = new int[] { 8 };
42	// TESTS_RANGE = new int[] { 6, -1 };	42	// TESTS_RANGE = new int[] { 6, -1 };
43	}	43	}




				true);
			assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
			CompilationUnit unit = (CompilationUnit) node;
			assertProblemsSize(unit, 1, "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
			node = getASTNode(unit, 0, 0, 0);
			assertEquals("Not an expression statement", ASTNode.EXPRESSION_STATEMENT, node.getNodeType());
			assertTrue("Not recovered", isRecovered(node));

			CompilationUnit unit = (CompilationUnit) node;
			assertProblemsSize(
					unit,
					1,
					"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
					"Syntax error, insert \"AssignmentOperator Expression\" to complete Expression");
			node = getASTNode(unit, 0, 0);
			assertEquals("Not a field declaration statement", ASTNode.INITIALIZER, node.getNodeType());
			Initializer initializer = (Initializer) node;

				"}");

		assertASTResult(
				"===== AST =====\n" + 
				"import java.nio.ByteBuffer;\n" + 
				"import java.nio.CharBuffer;\n" + 
				"import java.nio.charset.Charset;\n" + 
				"import java.nio.charset.CharsetDecoder;\n" + 
				"import java.nio.charset.CharsetEncoder;\n" + 
				"import java.nio.charset.CoderResult;\n" + 
				"public class TestCharset extends Charset {\n" + 
				"  public CharsetDecoder newDecoder(){\n" + 
				"    return new CharsetDecoder(this,2.0,2.0){\n" + 
				"      void CharsetDecoder(){\n" + 
				"      }\n" + 
				"      protected CoderResult decodeLoop(      ByteBuffer in,      CharBuffer out){\n" + 
				"        return null;\n" + 
				"      }\n" + 
				"    }\n" + 
				";\n" + 
				"    ;\n" + 
				"  }\n" + 
				"  public CharsetEncoder newEncoder(){\n" + 
				"    return null;\n" + 
				"  }\n" + 
				"}\n" + 
				"\n" + 
				"===== Details =====\n" + 
				"===== Problems =====\n" + 
				"1. ERROR in /Converter/src/TestCharset.java (at line 1)\n" + 
				"	import java.nio.ByteBuffer;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"2. ERROR in /Converter/src/TestCharset.java (at line 2)\n" + 
				"	import java.nio.CharBuffer;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"3. ERROR in /Converter/src/TestCharset.java (at line 3)\n" + 
				"	import java.nio.charset.Charset;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"4. ERROR in /Converter/src/TestCharset.java (at line 4)\n" + 
				"	import java.nio.charset.CharsetDecoder;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"5. ERROR in /Converter/src/TestCharset.java (at line 5)\n" + 
				"	import java.nio.charset.CharsetEncoder;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"6. ERROR in /Converter/src/TestCharset.java (at line 6)\n" + 
				"	import java.nio.charset.CoderResult;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"7. ERROR in /Converter/src/TestCharset.java (at line 7)\n" + 
				"	public class TestCharset extends Charset {\n" + 
				"	                                 ^^^^^^^\n" + 
				"Charset cannot be resolved to a type\n" + 
				"8. ERROR in /Converter/src/TestCharset.java (at line 8)\n" + 
				"	public CharsetDecoder newDecoder() {\n" + 
				"	       ^^^^^^^^^^^^^^\n" + 
				"CharsetDecoder cannot be resolved to a type\n" + 
				"9. ERROR in /Converter/src/TestCharset.java (at line 9)\n" + 
				"	return new CharsetDecoder(this, 2.0, 2.0) {\n" + 
				"	           ^^^^^^^^^^^^^^\n" + 
				"CharsetDecoder cannot be resolved to a type\n" + 
				"10. ERROR in /Converter/src/TestCharset.java (at line 10)\n" + 
				"	CharsetDecoder(CharSet\n" + 
				"	               ^^^^^^^\n" + 
				"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameter\n" + 
				"11. ERROR in /Converter/src/TestCharset.java (at line 10)\n" + 
				"	CharsetDecoder(CharSet\n" + 
				"	               ^^^^^^^\n" + 
				"Syntax error, insert \")\" to complete ConstructorDeclaration\n" + 
				"12. ERROR in /Converter/src/TestCharset.java (at line 10)\n" + 
				"	CharsetDecoder(CharSet\n" + 
				"	               ^^^^^^^\n" + 
				"Syntax error, insert \";\" to complete ClassBodyDeclarations\n" + 
				"13. ERROR in /Converter/src/TestCharset.java (at line 17)\n" + 
				"	public CharsetEncoder newEncoder() {\n" + 
				"	       ^^^^^^^^^^^^^^\n" + 
				"CharsetEncoder cannot be resolved to a type\n",
				result);
		}

Lines 29-34 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (+11 lines)
29	this.originalSourceEnd = this.sourceEnd;	29	this.originalSourceEnd = this.sourceEnd;
30	this.typeArguments = typeArguments;	30	this.typeArguments = typeArguments;
31	}	31	}
		32	public ParameterizedSingleTypeReference(char[] name, TypeReference[] typeArguments, int dim, Annotation[][] annotationsOnDimensions, long pos) {
		33	this(name, typeArguments, dim, pos);
		34	this.annotationsOnDimensions = annotationsOnDimensions;
		35	}
32	public void checkBounds(Scope scope) {	36	public void checkBounds(Scope scope) {
33	if (this.resolvedType == null) return;	37	if (this.resolvedType == null) return;
34		38
Lines 48-53 Link Here
48	public TypeReference copyDims(int dim) {	52	public TypeReference copyDims(int dim) {
49	return new ParameterizedSingleTypeReference(this.token, this.typeArguments, dim, (((long)this.sourceStart)<<32)+this.sourceEnd);	53	return new ParameterizedSingleTypeReference(this.token, this.typeArguments, dim, (((long)this.sourceStart)<<32)+this.sourceEnd);
50	}	54	}
		55	public TypeReference copyDims(int dim, Annotation [][] annotationsOnDims) {
		56	return new ParameterizedSingleTypeReference(this.token, this.typeArguments, dim, annotationsOnDims, (((long)this.sourceStart)<<32)+this.sourceEnd);
		57	}
51		58
52	/**	59	/**
53	* @return char[][]	60	* @return char[][]
Lines 81-86 Link Here
81	protected TypeBinding getTypeBinding(Scope scope) {	88	protected TypeBinding getTypeBinding(Scope scope) {
82	return null; // not supported here - combined with resolveType(...)	89	return null; // not supported here - combined with resolveType(...)
83	}	90	}
		91
		92	public boolean isParametrizedTypeReference() {
		93	return true;
		94	}
84		95
85	/*	96	/*
86	* No need to check for reference to raw type per construction	97	* No need to check for reference to raw type per construction

Lines 19-24 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayTypeReference.java (+11 lines)
19		19
20	public class ArrayTypeReference extends SingleTypeReference {	20	public class ArrayTypeReference extends SingleTypeReference {
21	public int dimensions;	21	public int dimensions;
		22	public Annotation[][] annotationsOnDimensions; // jsr308 style type annotations on dimensions.
22	public int originalSourceEnd;	23	public int originalSourceEnd;
23		24
24	/**	25	/**
Lines 32-43 Link Here
32	super(source, pos);	33	super(source, pos);
33	this.originalSourceEnd = this.sourceEnd;	34	this.originalSourceEnd = this.sourceEnd;
34	this.dimensions = dimensions ;	35	this.dimensions = dimensions ;
		36	this.annotationsOnDimensions = null;
		37	}
		38
		39	public ArrayTypeReference(char[] source, int dimensions, Annotation[][] annotationsOnDimensions, long pos) {
		40	this(source, dimensions, pos);
		41	this.annotationsOnDimensions = annotationsOnDimensions;
35	}	42	}
36		43
37	public int dimensions() {	44	public int dimensions() {
38		45
39	return this.dimensions;	46	return this.dimensions;
40	}	47	}
		48
		49	public Annotation[][] getAnnotationsOnDimensions() {
		50	return this.annotationsOnDimensions;
		51	}
41	/**	52	/**
42	* @return char[][]	53	* @return char[][]
43	*/	54	*/

Lines 33-38 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedTypeReference.java (+6 lines)
33	//warning : the new type ref has a null binding	33	//warning : the new type ref has a null binding
34	return new ArrayQualifiedTypeReference(this.tokens, dim, this.sourcePositions);	34	return new ArrayQualifiedTypeReference(this.tokens, dim, this.sourcePositions);
35	}	35	}
		36
		37	public TypeReference copyDims(int dim, Annotation[][] annotationsOnDimensions) {
		38	//return a type reference copy of me with some dimensions
		39	//warning : the new type ref has a null binding
		40	return new ArrayQualifiedTypeReference(this.tokens, dim, annotationsOnDimensions, this.sourcePositions);
		41	}
36		42
37	protected TypeBinding findNextTypeBinding(int tokenIndex, Scope scope, PackageBinding packageBinding) {	43	protected TypeBinding findNextTypeBinding(int tokenIndex, Scope scope, PackageBinding packageBinding) {
38	LookupEnvironment env = scope.environment();	44	LookupEnvironment env = scope.environment();




/*
 * Answer a base type reference (can be an array of base type).
 */
public static final TypeReference baseTypeReference(int baseType, int dim, Annotation [][] dimAnnotations) {

	if (dim == 0) {
		switch (baseType) {

	}
	switch (baseType) {
		case (TypeIds.T_void) :
			return new ArrayTypeReference(TypeBinding.VOID.simpleName, dim, dimAnnotations, 0);
		case (TypeIds.T_boolean) :
			return new ArrayTypeReference(TypeBinding.BOOLEAN.simpleName, dim, dimAnnotations, 0);
		case (TypeIds.T_char) :
			return new ArrayTypeReference(TypeBinding.CHAR.simpleName, dim, dimAnnotations, 0);
		case (TypeIds.T_float) :
			return new ArrayTypeReference(TypeBinding.FLOAT.simpleName, dim, dimAnnotations, 0);
		case (TypeIds.T_double) :
			return new ArrayTypeReference(TypeBinding.DOUBLE.simpleName, dim, dimAnnotations, 0);
		case (TypeIds.T_byte) :
			return new ArrayTypeReference(TypeBinding.BYTE.simpleName, dim, dimAnnotations, 0);
		case (TypeIds.T_short) :
			return new ArrayTypeReference(TypeBinding.SHORT.simpleName, dim, dimAnnotations, 0);
		case (TypeIds.T_int) :
			return new ArrayTypeReference(TypeBinding.INT.simpleName, dim, dimAnnotations, 0);
		default : //T_long
			return new ArrayTypeReference(TypeBinding.LONG.simpleName, dim, dimAnnotations, 0);
	}
}

// JSR308 type annotations...
public Annotation[] annotations = null;

// allows us to trap completion & selection nodes
public void aboutToResolve(Scope scope) {
	// default implementation: do nothing

	// only parameterized type references have bounds
}
public abstract TypeReference copyDims(int dim);
public abstract TypeReference copyDims(int dim, Annotation[][] annotationsOnDimensions);
public int dimensions() {
	return 0;
}
public Annotation[][] getAnnotationsOnDimensions() {
	return null;
}

public abstract char[] getLastToken();


	return true;
}

public boolean isParametrizedTypeReference() {
	return false;
}

protected void reportDeprecatedType(TypeBinding type, Scope scope) {
	scope.problemReporter().deprecatedType(type, this);
}

Lines 33-38 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleTypeReference.java (+7 lines)
33		33
34	return new ArrayTypeReference(this.token, dim,(((long)this.sourceStart)<<32)+this.sourceEnd);	34	return new ArrayTypeReference(this.token, dim,(((long)this.sourceStart)<<32)+this.sourceEnd);
35	}	35	}
		36
		37	public TypeReference copyDims(int dim, Annotation[][] annotationsOnDimensions){
		38	//return a type reference copy of me with some dimensions
		39	//warning : the new type ref has a null binding
		40
		41	return new ArrayTypeReference(this.token, dim, annotationsOnDimensions, (((long)this.sourceStart)<<32)+this.sourceEnd);
		42	}
36		43
37	public char[] getLastToken() {	44	public char[] getLastToken() {
38	return this.token;	45	return this.token;

Lines 30-35 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/JavadocImplicitTypeReference.java (+4 lines)
30	public TypeReference copyDims(int dim) {	30	public TypeReference copyDims(int dim) {
31	return null;	31	return null;
32	}	32	}
		33
		34	public TypeReference copyDims(int dim, Annotation[][] annotationsOnDimensions) {
		35	return null;
		36	}
33		37
34	/* (non-Javadoc)	38	/* (non-Javadoc)
35	* @see org.eclipse.jdt.internal.compiler.ast.TypeReference#getTypeBinding(org.eclipse.jdt.internal.compiler.lookup.Scope)	39	* @see org.eclipse.jdt.internal.compiler.ast.TypeReference#getTypeBinding(org.eclipse.jdt.internal.compiler.lookup.Scope)

Lines 34-39 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (+11 lines)
34	super(tokens, dim, positions);	34	super(tokens, dim, positions);
35	this.typeArguments = typeArguments;	35	this.typeArguments = typeArguments;
36	}	36	}
		37	public ParameterizedQualifiedTypeReference(char[][] tokens, TypeReference[][] typeArguments, int dim, Annotation[][] annotationsOnDimensions, long[] positions) {
		38	this(tokens, typeArguments, dim, positions);
		39	this.annotationsOnDimensions = annotationsOnDimensions;
		40	}
37	public void checkBounds(Scope scope) {	41	public void checkBounds(Scope scope) {
38	if (this.resolvedType == null) return;	42	if (this.resolvedType == null) return;
39		43
Lines 59-64 Link Here
59	public TypeReference copyDims(int dim){	63	public TypeReference copyDims(int dim){
60	return new ParameterizedQualifiedTypeReference(this.tokens, this.typeArguments, dim, this.sourcePositions);	64	return new ParameterizedQualifiedTypeReference(this.tokens, this.typeArguments, dim, this.sourcePositions);
61	}	65	}
		66	public TypeReference copyDims(int dim, Annotation[][] dimensionAnnotations){
		67	return new ParameterizedQualifiedTypeReference(this.tokens, this.typeArguments, dim, dimensionAnnotations, this.sourcePositions);
		68	}
		69	public boolean isParametrizedTypeReference() {
		70	return true;
		71	}
		72
62		73
63	/**	74	/**
64	* @return char[][]	75	* @return char[][]

Lines 17-33 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayQualifiedTypeReference.java (+11 lines)
17		17
18	public class ArrayQualifiedTypeReference extends QualifiedTypeReference {	18	public class ArrayQualifiedTypeReference extends QualifiedTypeReference {
19	int dimensions;	19	int dimensions;
		20	Annotation[][] annotationsOnDimensions; // jsr308 style type annotations on dimensions
20		21
21	public ArrayQualifiedTypeReference(char[][] sources , int dim, long[] poss) {	22	public ArrayQualifiedTypeReference(char[][] sources , int dim, long[] poss) {
22		23
23	super( sources , poss);	24	super( sources , poss);
24	this.dimensions = dim ;	25	this.dimensions = dim ;
		26	this.annotationsOnDimensions = null;
		27	}
		28
		29	public ArrayQualifiedTypeReference(char[][] sources, int dim, Annotation[][] annotationsOnDimensions, long[] poss) {
		30	this(sources, dim, poss);
		31	this.annotationsOnDimensions = annotationsOnDimensions;
25	}	32	}
26		33
27	public int dimensions() {	34	public int dimensions() {
28		35
29	return this.dimensions;	36	return this.dimensions;
30	}	37	}
		38
		39	public Annotation[][] getAnnotationsOnDimensions() {
		40	return this.annotationsOnDimensions;
		41	}
31		42
32	/**	43	/**
33	* @return char[][]	44	* @return char[][]

Lines 35-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java (+7 lines)
35	public int modifiers;	35	public int modifiers;
36	public int modifiersSourceStart;	36	public int modifiersSourceStart;
37	public Annotation[] annotations;	37	public Annotation[] annotations;
		38	public Annotation[] receiverAnnotations;
38	public Argument[] arguments;	39	public Argument[] arguments;
39	public TypeReference[] thrownExceptions;	40	public TypeReference[] thrownExceptions;
40	public Statement[] statements;	41	public Statement[] statements;
Lines 403-408 Link Here
403	bindThrownExceptions();	404	bindThrownExceptions();
404	resolveJavadoc();	405	resolveJavadoc();
405	resolveAnnotations(this.scope, this.annotations, this.binding);	406	resolveAnnotations(this.scope, this.annotations, this.binding);
		407	// jsr308
		408	if (this.receiverAnnotations != null && this.scope.isStatic) {
		409	int last = this.receiverAnnotations.length - 1;
		410	this.scope.problemReporter().illegalReceiverAnnotations(this.receiverAnnotations[0],
		411	this.receiverAnnotations[last]);
		412	}
406	resolveStatements();	413	resolveStatements();
407	// check @Deprecated annotation presence	414	// check @Deprecated annotation presence
408	if (this.binding != null	415	if (this.binding != null




/*
 * Build specific type reference nodes in case the cursor is located inside the type reference
 */
protected TypeReference getUnannotatedTypeReference(int dim) {

	int index;

	/* no need to take action if not inside completed identifiers */
	if ((index = indexOfAssistIdentifier(true)) < 0) {
		return super.getUnannotatedTypeReference(dim);
	}
	int length = this.identifierLengthStack[this.identifierLengthPtr];
	TypeReference reference;

	this.astLengthPtr = -1;
	this.expressionPtr = -1;
	this.expressionLengthPtr = -1;
	this.unattachedAnnotationPtr = -1;
	this.typeAnnotationLengthPtr = -1;
	this.typeAnnotationPtr = -1;
	this.identifierPtr = -1;
	this.identifierLengthPtr	= -1;
	this.intPtr = -1;

Lines 178-185 Link Here

(-)grammar/java.g (-52 / +247 lines)
178	Goal ::= '>>' Initializer	178	Goal ::= '>>' Initializer
179	-- error recovery	179	-- error recovery
180	-- Modifiersopt is used to properly consume a header and exit the rule reduction at the end of the parse() method	180	-- Modifiersopt is used to properly consume a header and exit the rule reduction at the end of the parse() method
181	Goal ::= '>>>' Header1 Modifiersopt	181	-- 1.7, we now use NonAnnotModifiersopt, since using Modifiersopt here pollutes the follow set of
182	Goal ::= '!' Header2 Modifiersopt	182	-- various non terminals and results in shift/reduce conflicts in various places. (e.g, ConstructorHeader
		183	-- cannot really have Modifiers in its follow set.)
		184	Goal ::= '>>>' Header1 NonAnnotModifiersopt
		185	Goal ::= '!' Header2 NonAnnotModifiersopt
183	Goal ::= '*' BlockStatements	186	Goal ::= '*' BlockStatements
184	Goal ::= '*' CatchHeader	187	Goal ::= '*' CatchHeader
185	-- JDOM	188	-- JDOM
Lines 250-263 Link Here
250		253
251	ClassOrInterface ::= Name	254	ClassOrInterface ::= Name
252	/.$putCase consumeClassOrInterfaceName(); $break ./	255	/.$putCase consumeClassOrInterfaceName(); $break ./
253	ClassOrInterface ::= GenericType '.' Name	256	ClassOrInterface ::= GenericTypeDotName
254	/.$putCase consumeClassOrInterface(); $break ./
255	/:$readableName Type:/	257	/:$readableName Type:/
256		258
257	GenericType ::= ClassOrInterface TypeArguments	259	GenericType ::= ClassOrInterface TypeArguments
258	/.$putCase consumeGenericType(); $break ./	260	/.$putCase consumeGenericType(); $break ./
259	/:$readableName GenericType:/	261	/:$readableName GenericType:/
260		262
		263	GenericTypeDotName ::= GenericType '.' Name
		264	/.$putCase consumeClassOrInterface(); $break ./
		265	/:$readableName GenericTypeDotName:/
		266
261	--	267	--
262	-- These rules have been rewritten to avoid some conflicts introduced	268	-- These rules have been rewritten to avoid some conflicts introduced
263	-- by adding the 1.1 features	269	-- by adding the 1.1 features
Lines 267-274 Link Here
267	-- ArrayType ::= ArrayType '[' ']'	273	-- ArrayType ::= ArrayType '[' ']'
268	--	274	--
269		275
270	ArrayTypeWithTypeArgumentsName ::= GenericType '.' Name	276	ArrayTypeWithTypeArgumentsName ::= GenericTypeDotName
271	/.$putCase consumeArrayTypeWithTypeArgumentsName(); $break ./
272	/:$readableName ArrayTypeWithTypeArgumentsName:/	277	/:$readableName ArrayTypeWithTypeArgumentsName:/
273		278
274	ArrayType ::= PrimitiveType Dims	279	ArrayType ::= PrimitiveType Dims
Lines 281-287 Link Here
281	/.$putCase consumeGenericTypeArrayType(); $break ./	286	/.$putCase consumeGenericTypeArrayType(); $break ./
282	/:$readableName ArrayType:/	287	/:$readableName ArrayType:/
283		288
284	ClassType -> ClassOrInterfaceType	289	ClassType ::= ClassOrInterfaceType
		290	/.$putCase consumeZeroTypeAnnotations(); $break ./
		291	ClassType ::= OneOrMoreAnnotations ClassOrInterfaceType
		292	/:$compliance 1.7:/
285	/:$readableName ClassType:/	293	/:$readableName ClassType:/
286		294
287	--------------------------------------------------------------	295	--------------------------------------------------------------
Lines 422-432 Link Here
422		430
423	--18.7 Only in the LALR(1) Grammar	431	--18.7 Only in the LALR(1) Grammar
424		432
		433	NonAnnotModifiers -> NonAnnotModifier
		434	NonAnnotModifiers -> NonAnnotModifiers NonAnnotModifier
		435	/.$putCase consumeModifiers2(); $break ./
		436	/:$readableName Modifiers:/
		437
425	Modifiers -> Modifier	438	Modifiers -> Modifier
426	Modifiers ::= Modifiers Modifier	439	Modifiers ::= Modifiers Modifier
427	/.$putCase consumeModifiers2(); $break ./	440	/.$putCase consumeModifiers2(); $break ./
428	/:$readableName Modifiers:/	441	/:$readableName Modifiers:/
429		442
		443	NonAnnotModifier -> 'public'
		444	NonAnnotModifier -> 'protected'
		445	NonAnnotModifier -> 'private'
		446	NonAnnotModifier -> 'static'
		447	NonAnnotModifier -> 'abstract'
		448	NonAnnotModifier -> 'final'
		449	NonAnnotModifier -> 'native'
		450	NonAnnotModifier -> 'synchronized'
		451	NonAnnotModifier -> 'transient'
		452	NonAnnotModifier -> 'volatile'
		453	NonAnnotModifier -> 'strictfp'
		454	/:$readableName Modifier:/
		455
430	Modifier -> 'public'	456	Modifier -> 'public'
431	Modifier -> 'protected'	457	Modifier -> 'protected'
432	Modifier -> 'private'	458	Modifier -> 'private'
Lines 483-489 Link Here
483	/.$putCase consumeInterfaceTypeList(); $break ./	509	/.$putCase consumeInterfaceTypeList(); $break ./
484	/:$readableName InterfaceTypeList:/	510	/:$readableName InterfaceTypeList:/
485		511
486	InterfaceType ::= ClassOrInterfaceType	512	InterfaceType ::= PushZeroTypeAnnotations ClassOrInterfaceType
		513	/.$putCase consumeInterfaceType(); $break ./
		514	InterfaceType ::= OneOrMoreAnnotations ClassOrInterfaceType
		515	/:$compliance 1.7:/
487	/.$putCase consumeInterfaceType(); $break ./	516	/.$putCase consumeInterfaceType(); $break ./
488	/:$readableName InterfaceType:/	517	/:$readableName InterfaceType:/
489		518
Lines 618-624 Link Here
618	/:$readableName MethodDeclaration:/	647	/:$readableName MethodDeclaration:/
619		648
620	MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	649	MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
621	/.$putCase consumeMethodHeaderNameWithTypeParameters(false); $break ./	650	/.$putCase consumeMethodHeaderNameWithTypeParameters(false, false); $break ./
		651	MethodHeaderName ::= Modifiersopt TypeParameters OneOrMoreAnnotations Type 'Identifier' '('
		652	/.$putCase consumeMethodHeaderNameWithTypeParameters(false, true); $break ./
		653	/:$compliance 1.7:/
622	MethodHeaderName ::= Modifiersopt Type 'Identifier' '('	654	MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
623	/.$putCase consumeMethodHeaderName(false); $break ./	655	/.$putCase consumeMethodHeaderName(false); $break ./
624	/:$readableName MethodHeaderName:/	656	/:$readableName MethodHeaderName:/
Lines 628-634 Link Here
628	/:$readableName ):/	660	/:$readableName ):/
629	/:$recovery_template ):/	661	/:$recovery_template ):/
630		662
631	MethodHeaderExtendedDims ::= Dimsopt	663	MethodHeaderExtendedDims ::= DimsoptAnnotsopt
632	/.$putCase consumeMethodHeaderExtendedDims(); $break ./	664	/.$putCase consumeMethodHeaderExtendedDims(); $break ./
633	/:$readableName MethodHeaderExtendedDims:/	665	/:$readableName MethodHeaderExtendedDims:/
634		666
Lines 636-642 Link Here
636	/.$putCase consumeMethodHeaderThrowsClause(); $break ./	668	/.$putCase consumeMethodHeaderThrowsClause(); $break ./
637	/:$readableName MethodHeaderThrowsClause:/	669	/:$readableName MethodHeaderThrowsClause:/
638		670
639	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderThrowsClauseopt	671	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen PushZeroTypeAnnotations MethodHeaderThrowsClauseopt
		672	/.$putCase consumeConstructorHeader(); $break ./
		673	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen OneOrMoreAnnotations MethodHeaderThrowsClauseopt
		674	/:$compliance 1.7:/
640	/.$putCase consumeConstructorHeader(); $break ./	675	/.$putCase consumeConstructorHeader(); $break ./
641	/:$readableName ConstructorDeclaration:/	676	/:$readableName ConstructorDeclaration:/
642		677
Lines 651-660 Link Here
651	/.$putCase consumeFormalParameterList(); $break ./	686	/.$putCase consumeFormalParameterList(); $break ./
652	/:$readableName FormalParameterList:/	687	/:$readableName FormalParameterList:/
653		688
		689	PotentialNameArray -> $empty
		690	/.$putCase consumePotentialNameArrayType(); $break ./
		691	/:$readableName PotentialNameArray:/
		692
654	--1.1 feature	693	--1.1 feature
655	FormalParameter ::= Modifiersopt Type VariableDeclaratorId	694	--FormalParameter ::= Modifiersopt Type VariableDeclaratorId
		695	--FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId
		696	--The above rules have been rewritten by inlinng the type subgrammar
		697	--to avoid the conflicts resulting from jsr308 changes.
		698	FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt VariableDeclaratorId
656	/.$putCase consumeFormalParameter(false); $break ./	699	/.$putCase consumeFormalParameter(false); $break ./
657	FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId	700	FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt '...' VariableDeclaratorId
		701	/.$putCase consumeFormalParameter(true); $break ./
		702	/:$compliance 1.5:/
		703	FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray VariableDeclaratorId
		704	/.$putCase consumeFormalParameter(false); $break ./
		705	FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray '...' VariableDeclaratorId
		706	/.$putCase consumeFormalParameter(true); $break ./
		707	/:$compliance 1.5:/
		708	FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt VariableDeclaratorId
		709	/.$putCase consumeFormalParameter(false); $break ./
		710	FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt '...' VariableDeclaratorId
		711	/.$putCase consumeFormalParameter(true); $break ./
		712	/:$compliance 1.5:/
		713	FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt VariableDeclaratorId
		714	/.$putCase consumeFormalParameter(false); $break ./
		715	FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt '...' VariableDeclaratorId
658	/.$putCase consumeFormalParameter(true); $break ./	716	/.$putCase consumeFormalParameter(true); $break ./
659	/:$readableName FormalParameter:/	717	/:$readableName FormalParameter:/
660	/:$compliance 1.5:/	718	/:$compliance 1.5:/
Lines 1217-1254 Link Here
1217	/.$putCase consumeArgumentList(); $break ./	1275	/.$putCase consumeArgumentList(); $break ./
1218	/:$readableName ArgumentList:/	1276	/:$readableName ArgumentList:/
1219		1277
		1278	-- ArrayCreationHeader is used only in recovery and the consume* method is a NOP.
1220	ArrayCreationHeader ::= 'new' PrimitiveType DimWithOrWithOutExprs	1279	ArrayCreationHeader ::= 'new' PrimitiveType DimWithOrWithOutExprs
1221	/.$putCase consumeArrayCreationHeader(); $break ./	1280	/.$putCase consumeArrayCreationHeader(); $break ./
		1281	ArrayCreationHeader ::= 'new' OneOrMoreAnnotations PrimitiveType DimWithOrWithOutExprs
		1282	/:$compliance 1.7:/
		1283	/.$putCase consumeArrayCreationHeader(); $break ./
1222		1284
1223	ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs	1285	ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
1224	/.$putCase consumeArrayCreationHeader(); $break ./	1286	/.$putCase consumeArrayCreationHeader(); $break ./
		1287	ArrayCreationHeader ::= 'new' OneOrMoreAnnotations ClassOrInterfaceType DimWithOrWithOutExprs
		1288	/:$compliance 1.7:/
		1289	/.$putCase consumeArrayCreationHeader(); $break ./
1225	/:$readableName ArrayCreationHeader:/	1290	/:$readableName ArrayCreationHeader:/
1226		1291
1227	ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs	1292	ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs
1228	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./	1293	/.$putCase consumeArrayCreationExpressionWithoutInitializer(false); $break ./
		1294	ArrayCreationWithoutArrayInitializer ::= 'new' OneOrMoreAnnotations PrimitiveType DimWithOrWithOutExprs
		1295	/:$compliance 1.7:/
		1296	/.$putCase consumeArrayCreationExpressionWithoutInitializer(true); $break ./
1229	/:$readableName ArrayCreationWithoutArrayInitializer:/	1297	/:$readableName ArrayCreationWithoutArrayInitializer:/
1230		1298
1231	ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer	1299	ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer
1232	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./	1300	/.$putCase consumeArrayCreationExpressionWithInitializer(false); $break ./
		1301	ArrayCreationWithArrayInitializer ::= 'new' OneOrMoreAnnotations PrimitiveType DimWithOrWithOutExprs ArrayInitializer
		1302	/:$compliance 1.7:/
		1303	/.$putCase consumeArrayCreationExpressionWithInitializer(true); $break ./
1233	/:$readableName ArrayCreationWithArrayInitializer:/	1304	/:$readableName ArrayCreationWithArrayInitializer:/
1234		1305
1235	ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs	1306	ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
1236	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./	1307	/.$putCase consumeArrayCreationExpressionWithoutInitializer(false); $break ./
		1308	ArrayCreationWithoutArrayInitializer ::= 'new' OneOrMoreAnnotations ClassOrInterfaceType DimWithOrWithOutExprs
		1309	/:$compliance 1.7:/
		1310	/.$putCase consumeArrayCreationExpressionWithoutInitializer(true); $break ./
1237		1311
1238	ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer	1312	ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer
1239	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./	1313	/.$putCase consumeArrayCreationExpressionWithInitializer(false); $break ./
		1314	ArrayCreationWithArrayInitializer ::= 'new' OneOrMoreAnnotations ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer
		1315	/:$compliance 1.7:/
		1316	/.$putCase consumeArrayCreationExpressionWithInitializer(true); $break ./
1240		1317
1241	DimWithOrWithOutExprs ::= DimWithOrWithOutExpr	1318	DimWithOrWithOutExprs ::= DimWithOrWithOutExpr
1242	DimWithOrWithOutExprs ::= DimWithOrWithOutExprs DimWithOrWithOutExpr	1319	DimWithOrWithOutExprs ::= DimWithOrWithOutExprs DimWithOrWithOutExpr
1243	/.$putCase consumeDimWithOrWithOutExprs(); $break ./	1320	/.$putCase consumeDimWithOrWithOutExprs(); $break ./
1244	/:$readableName Dimensions:/	1321	/:$readableName Dimensions:/
1245		1322
1246	DimWithOrWithOutExpr ::= '[' Expression ']'	1323	DimWithOrWithOutExpr ::= '[' PushZeroTypeAnnotations Expression ']'
1247	DimWithOrWithOutExpr ::= '[' ']'	1324	DimWithOrWithOutExpr ::= OneOrMoreAnnotations '[' Expression ']'
1248	/. $putCase consumeDimWithOrWithOutExpr(); $break ./	1325	/:$compliance 1.7:/
		1326	DimWithOrWithOutExpr ::= '[' PushZeroTypeAnnotations ']'
		1327	/. $putCase consumeDimWithOutExpr(); $break ./
		1328	DimWithOrWithOutExpr ::= OneOrMoreAnnotations '[' ']'
		1329	/. $putCase consumeDimWithOutExpr(); $break ./
		1330	/:$compliance 1.7:/
1249	/:$readableName Dimension:/	1331	/:$readableName Dimension:/
1250	-- -----------------------------------------------	1332	-- -----------------------------------------------
1251		1333
		1334	-- jsr 308
		1335
		1336	DimsoptAnnotsopt -> $empty
		1337	/. $putCase consumeEmptyDimsoptAnnotsopt(); $break ./
		1338	/:$readableName AnnotationsDimensionsSequence:/
		1339	DimsoptAnnotsopt -> DimsAnnotLoop
		1340	/. $putCase consumeDimsWithTrailingAnnotsopt(); $break ./
		1341	/:$readableName Dimensionsoptannotsopt:/
		1342	DimsAnnotLoop ::= OneDimOrAnnot
		1343	DimsAnnotLoop ::= DimsAnnotLoop OneDimOrAnnot
		1344	/:$readableName DimsAnnotLoop:/
		1345
		1346	OneDimOrAnnot ::= Annotation
		1347	/. $putCase consumeTypeAnnotation(true); $break ./
		1348	-- Complain if source level < 1.7
		1349	/:$compliance 1.7:/
		1350	OneDimOrAnnot -> '[' ']'
		1351	/. $putCase consumeOneDimLoop(true); $break ./
		1352	-- Bump up dimensions && mark zero annotations.
		1353	/:$readableName OneDimensionOrAnnotation:/
		1354
		1355	OneOrMoreAnnotations ::= Annotation
		1356	/. $putCase consumeTypeAnnotation(false); $break ./
		1357	-- Complain if source level < 1.7
		1358	/:$compliance 1.7:/
		1359	OneOrMoreAnnotations ::= OneOrMoreAnnotations Annotation
		1360	/. $putCase consumeOneMoreTypeAnnotation(); $break ./
		1361	-- Complain if source level < 1.7 && adjust the expression length stack.
		1362	/:$compliance 1.7:/
		1363	/:$readableName OneOrMoreAnnotations:/
		1364
1252	Dims ::= DimsLoop	1365	Dims ::= DimsLoop
1253	/. $putCase consumeDims(); $break ./	1366	/. $putCase consumeDims(); $break ./
1254	/:$readableName Dimensions:/	1367	/:$readableName Dimensions:/
Lines 1256-1263 Link Here
1256	DimsLoop ::= DimsLoop OneDimLoop	1369	DimsLoop ::= DimsLoop OneDimLoop
1257	/:$readableName Dimensions:/	1370	/:$readableName Dimensions:/
1258	OneDimLoop ::= '[' ']'	1371	OneDimLoop ::= '[' ']'
1259	/. $putCase consumeOneDimLoop(); $break ./	1372	/. $putCase consumeOneDimLoop(false); $break ./
		1373	-- Bump up dimensions && mark zero annotations.
1260	/:$readableName Dimension:/	1374	/:$readableName Dimension:/
		1375	OneDimLoop ::= OneOrMoreAnnotations '[' ']'
		1376	/:$compliance 1.7:/
		1377	/. $putCase consumeOneDimLoopWithAnnotations(); $break ./
		1378	-- Bump up dimensions
		1379	/:$readableName DimensionWithAnnotations:/
1261		1380
1262	FieldAccess ::= Primary '.' 'Identifier'	1381	FieldAccess ::= Primary '.' 'Identifier'
1263	/.$putCase consumeFieldAccess(false); $break ./	1382	/.$putCase consumeFieldAccess(false); $break ./
Lines 1339-1353 Link Here
1339	/:$readableName Expression:/	1458	/:$readableName Expression:/
1340		1459
1341	CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression	1460	CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression
1342	/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./	1461	/.$putCase consumeCastExpressionWithPrimitiveType(false); $break ./
		1462	CastExpression ::= PushLPAREN OneOrMoreAnnotations PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression
		1463	/:$compliance 1.7:/
		1464	/.$putCase consumeCastExpressionWithPrimitiveType(true); $break ./
1343	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	1465	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
1344	/.$putCase consumeCastExpressionWithGenericsArray(); $break ./	1466	/.$putCase consumeCastExpressionWithGenericsArray(false); $break ./
		1467	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
		1468	/:$compliance 1.7:/
		1469	/.$putCase consumeCastExpressionWithGenericsArray(true); $break ./
1345	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus	1470	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus
1346	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./	1471	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(false); $break ./
		1472	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus
		1473	/:$compliance 1.7:/
		1474	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(true); $break ./
1347	CastExpression ::= PushLPAREN Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus	1475	CastExpression ::= PushLPAREN Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
1348	/.$putCase consumeCastExpressionLL1(); $break ./	1476	/.$putCase consumeCastExpressionLL1(false); $break ./
		1477	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
		1478	/:$compliance 1.7:/
		1479	/.$putCase consumeCastExpressionLL1(true); $break ./
1349	CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	1480	CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
1350	/.$putCase consumeCastExpressionWithNameArray(); $break ./	1481	/.$putCase consumeCastExpressionWithNameArray(false); $break ./
		1482	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
		1483	/:$compliance 1.7:/
		1484	/.$putCase consumeCastExpressionWithNameArray(true); $break ./
1351	/:$readableName CastExpression:/	1485	/:$readableName CastExpression:/
1352		1486
1353	OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments	1487	OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments
Lines 1401-1407 Link Here
1401	/:$readableName Expression:/	1535	/:$readableName Expression:/
1402		1536
1403	InstanceofExpression -> RelationalExpression	1537	InstanceofExpression -> RelationalExpression
1404	InstanceofExpression ::= InstanceofExpression 'instanceof' ReferenceType	1538	InstanceofExpression ::= InstanceofExpression 'instanceof' PushZeroTypeAnnotations ReferenceType
		1539	/.$putCase consumeInstanceOfExpression(); $break ./
		1540	InstanceofExpression ::= InstanceofExpression 'instanceof' OneOrMoreAnnotations ReferenceType
		1541	/:$compliance 1.7:/
1405	/.$putCase consumeInstanceOfExpression(); $break ./	1542	/.$putCase consumeInstanceOfExpression(); $break ./
1406	/:$readableName Expression:/	1543	/:$readableName Expression:/
1407		1544
Lines 1526-1531 Link Here
1526	/.$putCase consumeClassBodyDeclarationsopt(); $break ./	1663	/.$putCase consumeClassBodyDeclarationsopt(); $break ./
1527	/:$readableName ClassBodyDeclarations:/	1664	/:$readableName ClassBodyDeclarations:/
1528		1665
		1666	NonAnnotModifiersopt ::= $empty
		1667	/. $putCase consumeDefaultModifiers(); $break ./
		1668	NonAnnotModifiersopt ::= NonAnnotModifiers
		1669	/.$putCase consumeModifiers(); $break ./
		1670	/:$readableName Modifiers:/
		1671
1529	Modifiersopt ::= $empty	1672	Modifiersopt ::= $empty
1530	/. $putCase consumeDefaultModifiers(); $break ./	1673	/. $putCase consumeDefaultModifiers(); $break ./
1531	Modifiersopt ::= Modifiers	1674	Modifiersopt ::= Modifiers
Lines 1728-1735 Link Here
1728	/:$compliance 1.5:/	1871	/:$compliance 1.5:/
1729		1872
1730	TypeArgument ::= ReferenceType	1873	TypeArgument ::= ReferenceType
1731	/.$putCase consumeTypeArgument(); $break ./	1874	/.$putCase consumeTypeArgument(false); $break ./
1732	/:$compliance 1.5:/	1875	/:$compliance 1.5:/
		1876	TypeArgument ::= OneOrMoreAnnotations ReferenceType
		1877	/:$compliance 1.7:/
		1878	/.$putCase consumeTypeArgument(true); $break ./
1733	TypeArgument -> Wildcard	1879	TypeArgument -> Wildcard
1734	/:$readableName TypeArgument:/	1880	/:$readableName TypeArgument:/
1735	/:$compliance 1.5:/	1881	/:$compliance 1.5:/
Lines 1741-1752 Link Here
1741	/:$compliance 1.5:/	1887	/:$compliance 1.5:/
1742		1888
1743	ReferenceType1 ::= ReferenceType '>'	1889	ReferenceType1 ::= ReferenceType '>'
1744	/.$putCase consumeReferenceType1(); $break ./	1890	/.$putCase consumeReferenceType1(false); $break ./
1745	/:$compliance 1.5:/	1891	/:$compliance 1.5:/
		1892	ReferenceType1 ::= OneOrMoreAnnotations ReferenceType '>'
		1893	/:$compliance 1.7:/
		1894	/.$putCase consumeReferenceType1(true); $break ./
1746	ReferenceType1 ::= ClassOrInterface '<' TypeArgumentList2	1895	ReferenceType1 ::= ClassOrInterface '<' TypeArgumentList2
1747	/.$putCase consumeTypeArgumentReferenceType1(); $break ./	1896	/.$putCase consumeTypeArgumentReferenceType1(false); $break ./
1748	/:$readableName ReferenceType1:/
1749	/:$compliance 1.5:/	1897	/:$compliance 1.5:/
		1898	ReferenceType1 ::= OneOrMoreAnnotations ClassOrInterface '<' TypeArgumentList2
		1899	/:$compliance 1.7:/
		1900	/.$putCase consumeTypeArgumentReferenceType1(true); $break ./
		1901	/:$readableName ReferenceType1:/
1750		1902
1751	TypeArgumentList2 -> TypeArgument2	1903	TypeArgumentList2 -> TypeArgument2
1752	/:$compliance 1.5:/	1904	/:$compliance 1.5:/
Lines 1762-1773 Link Here
1762	/:$compliance 1.5:/	1914	/:$compliance 1.5:/
1763		1915
1764	ReferenceType2 ::= ReferenceType '>>'	1916	ReferenceType2 ::= ReferenceType '>>'
1765	/.$putCase consumeReferenceType2(); $break ./	1917	/.$putCase consumeReferenceType2(false); $break ./
1766	/:$compliance 1.5:/	1918	/:$compliance 1.5:/
		1919	ReferenceType2 ::= OneOrMoreAnnotations ReferenceType '>>'
		1920	/:$compliance 1.7:/
		1921	/.$putCase consumeReferenceType2(true); $break ./
1767	ReferenceType2 ::= ClassOrInterface '<' TypeArgumentList3	1922	ReferenceType2 ::= ClassOrInterface '<' TypeArgumentList3
1768	/.$putCase consumeTypeArgumentReferenceType2(); $break ./	1923	/.$putCase consumeTypeArgumentReferenceType2(false); $break ./
1769	/:$readableName ReferenceType2:/
1770	/:$compliance 1.5:/	1924	/:$compliance 1.5:/
		1925	ReferenceType2 ::= OneOrMoreAnnotations ClassOrInterface '<' TypeArgumentList3
		1926	/:$compliance 1.7:/
		1927	/.$putCase consumeTypeArgumentReferenceType2(true); $break ./
		1928	/:$readableName ReferenceType2:/
1771		1929
1772	TypeArgumentList3 -> TypeArgument3	1930	TypeArgumentList3 -> TypeArgument3
1773	TypeArgumentList3 ::= TypeArgumentList ',' TypeArgument3	1931	TypeArgumentList3 ::= TypeArgumentList ',' TypeArgument3
Lines 1781-1789 Link Here
1781	/:$compliance 1.5:/	1939	/:$compliance 1.5:/
1782		1940
1783	ReferenceType3 ::= ReferenceType '>>>'	1941	ReferenceType3 ::= ReferenceType '>>>'
1784	/.$putCase consumeReferenceType3(); $break ./	1942	/.$putCase consumeReferenceType3(false); $break ./
1785	/:$readableName ReferenceType3:/
1786	/:$compliance 1.5:/	1943	/:$compliance 1.5:/
		1944	ReferenceType3 ::= OneOrMoreAnnotations ReferenceType '>>>'
		1945	/:$compliance 1.7:/
		1946	/.$putCase consumeReferenceType3(true); $break ./
		1947	/:$readableName ReferenceType3:/
1787		1948
1788	Wildcard ::= '?'	1949	Wildcard ::= '?'
1789	/.$putCase consumeWildcard(); $break ./	1950	/.$putCase consumeWildcard(); $break ./
Lines 1794-1805 Link Here
1794	/:$compliance 1.5:/	1955	/:$compliance 1.5:/
1795		1956
1796	WildcardBounds ::= 'extends' ReferenceType	1957	WildcardBounds ::= 'extends' ReferenceType
1797	/.$putCase consumeWildcardBoundsExtends(); $break ./	1958	/.$putCase consumeWildcardBoundsExtends(false); $break ./
1798	/:$compliance 1.5:/	1959	/:$compliance 1.5:/
		1960	WildcardBounds ::= 'extends' OneOrMoreAnnotations ReferenceType
		1961	/:$compliance 1.7:/
		1962	/.$putCase consumeWildcardBoundsExtends(true); $break ./
1799	WildcardBounds ::= 'super' ReferenceType	1963	WildcardBounds ::= 'super' ReferenceType
1800	/.$putCase consumeWildcardBoundsSuper(); $break ./	1964	/.$putCase consumeWildcardBoundsSuper(false); $break ./
1801	/:$readableName WildcardBounds:/
1802	/:$compliance 1.5:/	1965	/:$compliance 1.5:/
		1966	WildcardBounds ::= 'super' OneOrMoreAnnotations ReferenceType
		1967	/:$compliance 1.7:/
		1968	/.$putCase consumeWildcardBoundsSuper(true); $break ./
		1969	/:$readableName WildcardBounds:/
1803		1970
1804	Wildcard1 ::= '?' '>'	1971	Wildcard1 ::= '?' '>'
1805	/.$putCase consumeWildcard1(); $break ./	1972	/.$putCase consumeWildcard1(); $break ./
Lines 1849-1858 Link Here
1849	/:$readableName WildcardBound3:/	2016	/:$readableName WildcardBound3:/
1850	/:$compliance 1.5:/	2017	/:$compliance 1.5:/
1851		2018
1852	TypeParameterHeader ::= Identifier	2019	PushZeroTypeAnnotations ::= $empty
		2020	/.$putCase consumeZeroTypeAnnotations(); $break ./
		2021
		2022	TypeParameterHeader ::= PushZeroTypeAnnotations Identifier
1853	/.$putCase consumeTypeParameterHeader(); $break ./	2023	/.$putCase consumeTypeParameterHeader(); $break ./
1854	/:$readableName TypeParameter:/
1855	/:$compliance 1.5:/	2024	/:$compliance 1.5:/
		2025	TypeParameterHeader ::= OneOrMoreAnnotations Identifier
		2026	/:$compliance 1.7:/
		2027	/.$putCase consumeTypeParameterHeader(); $break ./
		2028	/:$readableName TypeParameter:/
1856		2029
1857	TypeParameters ::= '<' TypeParameterList1	2030	TypeParameters ::= '<' TypeParameterList1
1858	/.$putCase consumeTypeParameters(); $break ./	2031	/.$putCase consumeTypeParameters(); $break ./
Lines 1869-1880 Link Here
1869	TypeParameter -> TypeParameterHeader	2042	TypeParameter -> TypeParameterHeader
1870	/:$compliance 1.5:/	2043	/:$compliance 1.5:/
1871	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType	2044	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType
1872	/.$putCase consumeTypeParameterWithExtends(); $break ./	2045	/.$putCase consumeTypeParameterWithExtends(false); $break ./
1873	/:$compliance 1.5:/	2046	/:$compliance 1.5:/
		2047	TypeParameter ::= TypeParameterHeader 'extends' OneOrMoreAnnotations ReferenceType
		2048	/:$compliance 1.7:/
		2049	/.$putCase consumeTypeParameterWithExtends(true); $break ./
1874	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList	2050	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList
1875	/.$putCase consumeTypeParameterWithExtendsAndBounds(); $break ./	2051	/.$putCase consumeTypeParameterWithExtendsAndBounds(false); $break ./
1876	/:$readableName TypeParameter:/
1877	/:$compliance 1.5:/	2052	/:$compliance 1.5:/
		2053	TypeParameter ::= TypeParameterHeader 'extends' OneOrMoreAnnotations ReferenceType AdditionalBoundList
		2054	/:$compliance 1.7:/
		2055	/.$putCase consumeTypeParameterWithExtendsAndBounds(true); $break ./
		2056	/:$readableName TypeParameter:/
1878		2057
1879	AdditionalBoundList -> AdditionalBound	2058	AdditionalBoundList -> AdditionalBound
1880	/:$compliance 1.5:/	2059	/:$compliance 1.5:/
Lines 1883-1891 Link Here
1883	/:$readableName AdditionalBoundList:/	2062	/:$readableName AdditionalBoundList:/
1884		2063
1885	AdditionalBound ::= '&' ReferenceType	2064	AdditionalBound ::= '&' ReferenceType
1886	/.$putCase consumeAdditionalBound(); $break ./	2065	/.$putCase consumeAdditionalBound(false); $break ./
1887	/:$readableName AdditionalBound:/
1888	/:$compliance 1.5:/	2066	/:$compliance 1.5:/
		2067	AdditionalBound ::= '&' OneOrMoreAnnotations ReferenceType
		2068	/:$compliance 1.7:/
		2069	/.$putCase consumeAdditionalBound(true); $break ./
		2070	/:$readableName AdditionalBound:/
1889		2071
1890	TypeParameterList1 -> TypeParameter1	2072	TypeParameterList1 -> TypeParameter1
1891	/:$compliance 1.5:/	2073	/:$compliance 1.5:/
Lines 1901-1909 Link Here
1901	/.$putCase consumeTypeParameter1WithExtends(); $break ./	2083	/.$putCase consumeTypeParameter1WithExtends(); $break ./
1902	/:$compliance 1.5:/	2084	/:$compliance 1.5:/
1903	TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1	2085	TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1
1904	/.$putCase consumeTypeParameter1WithExtendsAndBounds(); $break ./	2086	/.$putCase consumeTypeParameter1WithExtendsAndBounds(false); $break ./
1905	/:$readableName TypeParameter1:/
1906	/:$compliance 1.5:/	2087	/:$compliance 1.5:/
		2088	TypeParameter1 ::= TypeParameterHeader 'extends' OneOrMoreAnnotations ReferenceType AdditionalBoundList1
		2089	/:$compliance 1.7:/
		2090	/.$putCase consumeTypeParameter1WithExtendsAndBounds(true); $break ./
		2091	/:$readableName TypeParameter1:/
1907		2092
1908	AdditionalBoundList1 -> AdditionalBound1	2093	AdditionalBoundList1 -> AdditionalBound1
1909	/:$compliance 1.5:/	2094	/:$compliance 1.5:/
Lines 2003-2011 Link Here
2003	/:$readableName Expression:/	2188	/:$readableName Expression:/
2004		2189
2005	InstanceofExpression_NotName -> RelationalExpression_NotName	2190	InstanceofExpression_NotName -> RelationalExpression_NotName
2006	InstanceofExpression_NotName ::= Name 'instanceof' ReferenceType	2191	InstanceofExpression_NotName ::= Name 'instanceof' PushZeroTypeAnnotations ReferenceType
2007	/.$putCase consumeInstanceOfExpressionWithName(); $break ./	2192	/.$putCase consumeInstanceOfExpressionWithName(); $break ./
2008	InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' ReferenceType	2193	InstanceofExpression_NotName ::= Name 'instanceof' OneOrMoreAnnotations ReferenceType
		2194	/:$compliance 1.7:/
		2195	/.$putCase consumeInstanceOfExpressionWithName(); $break ./
		2196	InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' PushZeroTypeAnnotations ReferenceType
		2197	/.$putCase consumeInstanceOfExpression(); $break ./
		2198	InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' OneOrMoreAnnotations ReferenceType
		2199	/:$compliance 1.7:/
2009	/.$putCase consumeInstanceOfExpression(); $break ./	2200	/.$putCase consumeInstanceOfExpression(); $break ./
2010	/:$readableName Expression:/	2201	/:$readableName Expression:/
2011		2202
Lines 2118-2124 Link Here
2118	/:$compliance 1.5:/	2309	/:$compliance 1.5:/
2119		2310
2120	AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	2311	AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
2121	/.$putCase consumeMethodHeaderNameWithTypeParameters(true); $break ./	2312	/.$putCase consumeMethodHeaderNameWithTypeParameters(true, false); $break ./
2122	AnnotationMethodHeaderName ::= Modifiersopt Type 'Identifier' '('	2313	AnnotationMethodHeaderName ::= Modifiersopt Type 'Identifier' '('
2123	/.$putCase consumeMethodHeaderName(true); $break ./	2314	/.$putCase consumeMethodHeaderName(true); $break ./
2124	/:$readableName MethodHeaderName:/	2315	/:$readableName MethodHeaderName:/
Lines 2260-2267 Link Here
2260	-- 1.5 features : recovery rules --	2451	-- 1.5 features : recovery rules --
2261	-----------------------------------	2452	-----------------------------------
2262	RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	2453	RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
2263	/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(); $break ./	2454	/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(false); $break ./
2264	/:$compliance 1.5:/	2455	/:$compliance 1.5:/
		2456	RecoveryMethodHeaderName ::= Modifiersopt TypeParameters OneOrMoreAnnotations Type 'Identifier' '('
		2457	/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(true); $break ./
		2458	/:$compliance 1.7:/
2265	RecoveryMethodHeaderName ::= Modifiersopt Type 'Identifier' '('	2459	RecoveryMethodHeaderName ::= Modifiersopt Type 'Identifier' '('
2266	/.$putCase consumeRecoveryMethodHeaderName(); $break ./	2460	/.$putCase consumeRecoveryMethodHeaderName(); $break ./
2267	/:$readableName MethodHeaderName:/	2461	/:$readableName MethodHeaderName:/
Lines 2331-2333 Link Here
2331		2525
2332	$end	2526	$end
2333	-- need a carriage return after the $end	2527	-- need a carriage return after the $end
		2528




			declaration.declarationSourceStart = this.intStack[this.intPtr--];
			declaration.modifiersSourceStart = this.intStack[this.intPtr--];
			declaration.modifiers = this.intStack[this.intPtr--];
			type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
			pushOnAstStack(type);
		} else {
			// field declaration
			type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
			pushOnAstStack(type);
			declaration.declarationSourceStart = this.intStack[this.intPtr--];
			declaration.modifiersSourceStart = this.intStack[this.intPtr--];

	}
	int firstDimensions = this.intStack[this.intPtr--];
	final int typeDimensions = firstDimensions + extendedDimensions;
	TypeReference type = getUnannotatedTypeReference(typeDimensions);
	if (isVarArgs) {
		type = copyDims(type, typeDimensions + 1);
		if (extendedDimensions == 0) {

	// MethodHeaderExtendedDims ::= Dimsopt
	// now we update the returnType of the method
	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
	// jsr308 -- consume receiver annotations
	md.receiverAnnotations = null;
	int length;
	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		System.arraycopy(
			this.typeAnnotationStack,
			(this.typeAnnotationPtr -= length) + 1,
			md.receiverAnnotations = new Annotation[length],
			0,
			length);
	}
	int extendedDims = this.intStack[this.intPtr--];
	this.extendsDim = extendedDims;
	if (extendedDims != 0) {

	this.selectorSourcePositions = this.identifierPositionStack[this.identifierPtr--];
	this.identifierLengthPtr--;
	//type
	md.returnType = getUnannotatedTypeReference(this.typeDims = this.intStack[this.intPtr--]);
	//modifiers
	md.declarationSourceStart = this.intStack[this.intPtr--];
	md.modifiersSourceStart = this.intStack[this.intPtr--];

	 * This variable is a type reference and dim will be its dimensions.
	 * We don't have any side effect on the stacks' pointers.
	 */
	Annotation [][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
	int length;
	TypeReference ref;
	if ((length = this.identifierLengthStack[localIdentifierLengthPtr]) == 1) {

				new ArrayTypeReference(
					this.identifierStack[localIdentifierPtr],
					dim,
					annotationsOnDimensions,
					this.identifierPositionStack[localIdentifierPtr--]);
			ref.sourceEnd = this.endPosition;
		}
	} else {
		if (length < 0) { //flag for precompiled type reference on base types
			ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
			ref.sourceStart = this.intStack[this.localIntPtr--];
			if (dim == 0) {
				ref.sourceEnd = this.intStack[this.localIntPtr--];

			if (dim == 0)
				ref = new QualifiedTypeReference(tokens, positions);
			else
				ref = new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
		}
	}
	return ref;




	}
}

protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod, boolean hasTypeAnnotations) {
	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
	int selectorSourceEnd = (int) selectorSourcePositions;
	int currentAstPtr = this.astPtr;
	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod, hasTypeAnnotations);
	if (this.astPtr > currentAstPtr) // if ast node was pushed on the ast stack
		this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
		rememberCategories();

		return null;
	}
}
public TypeReference getUnannotatedTypeReference(int dim) {
	/* build a Reference on a variable that may be qualified or not
	 * This variable is a type reference and dim will be its dimensions
	 */
	Annotation [][] annotationsOnDimensions = null;
	TypeReference ref;
	int length = this.identifierLengthStack[this.identifierLengthPtr--];
	if (length < 0) { //flag for precompiled type reference on base types
		annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
		ref.sourceStart = this.intStack[this.intPtr--];
		if (dim == 0) {
			ref.sourceEnd = this.intStack[this.intPtr--];

		if (this.reportReferenceInfo){
				this.requestor.acceptTypeReference(ref.getParameterizedTypeName(), ref.sourceStart, ref.sourceEnd);
		}
		return ref;
	} else {
		int numberOfIdentifiers = this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr--];
		if (length != numberOfIdentifiers || this.genericsLengthStack[this.genericsLengthPtr] != 0) {
			// generic type
			ref = getTypeReferenceForGenericType(dim, length, numberOfIdentifiers);
			if (this.reportReferenceInfo) {
				if (length == 1 && numberOfIdentifiers == 1) {
					ParameterizedSingleTypeReference parameterizedSingleTypeReference = (ParameterizedSingleTypeReference) ref;

					this.requestor.acceptTypeReference(parameterizedQualifiedTypeReference.tokens, parameterizedQualifiedTypeReference.sourceStart, parameterizedQualifiedTypeReference.sourceEnd);
				}
			}
			return ref;
		} else if (length == 1) {
			// single variable reference
			this.genericsLengthPtr--; // pop the 0
			if (dim == 0) {
				ref =
					new SingleTypeReference(
						this.identifierStack[this.identifierPtr],
						this.identifierPositionStack[this.identifierPtr--]);
				if (this.reportReferenceInfo) {
					this.requestor.acceptTypeReference(((SingleTypeReference)ref).token, ref.sourceStart);
				}
				return ref;
			} else {
				annotationsOnDimensions = getAnnotationsOnDimensions(dim);
				ref =
					new ArrayTypeReference(
						this.identifierStack[this.identifierPtr],
						dim,
						annotationsOnDimensions,
						this.identifierPositionStack[this.identifierPtr--]);
				ref.sourceEnd = this.endPosition;
				if (this.reportReferenceInfo) {
					this.requestor.acceptTypeReference(((ArrayTypeReference)ref).token, ref.sourceStart);
				}
				return ref;
			}
		} else {//Qualified variable reference
			this.genericsLengthPtr--;

				0,
				length);
			if (dim == 0) {
				ref = new QualifiedTypeReference(tokens, positions);
				if (this.reportReferenceInfo) {
					this.requestor.acceptTypeReference(((QualifiedTypeReference)ref).tokens, ref.sourceStart, ref.sourceEnd);
				}
				return ref;
			} else {
				annotationsOnDimensions = getAnnotationsOnDimensions(dim);
				ref =
					new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
				ref.sourceEnd = this.endPosition;
				if (this.reportReferenceInfo) {
					this.requestor.acceptTypeReference(((ArrayQualifiedTypeReference)ref).tokens, ref.sourceStart, ref.sourceEnd);
				}
				return ref;
			}
		}
	}
	return ref;
}
public NameReference getUnspecifiedReference() {
	/* build a (unspecified) NameReference which may be qualified*/




	}
}

protected void consumeAdditionalBound(boolean hasTypeAnnotations) {
	super.consumeAdditionalBound(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
		TypeReference typeReference = (TypeReference) this.genericsStack[this.genericsPtr];
		this.patternLocator.match(typeReference, this.nodeSet);

	}
}

protected void consumeCastExpressionLL1(boolean hasTypeAnnotations) {
	super.consumeCastExpressionLL1(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
		CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
		if (castExpression.type instanceof Reference) {

        }
	}
}
protected void consumeCastExpressionWithGenericsArray(boolean hasTypeAnnotations) {
	super.consumeCastExpressionWithGenericsArray(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
		CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
		if (castExpression.type instanceof Reference) {

        }
	}
}
protected void consumeCastExpressionWithNameArray(boolean hasTypeAnnotations) {
	super.consumeCastExpressionWithNameArray(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
		CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
		if (castExpression.type instanceof Reference) {

        }
	}
}
protected void consumeCastExpressionWithPrimitiveType(boolean hasTypeAnnotations) {
	super.consumeCastExpressionWithPrimitiveType(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
		CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
		if (castExpression.type instanceof Reference) {

        }
	}
}
protected void consumeCastExpressionWithQualifiedGenericsArray(boolean hasTypeAnnotations) {
	super.consumeCastExpressionWithQualifiedGenericsArray(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
		CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
		if (castExpression.type instanceof Reference) {

	}
}

protected void consumeTypeArgumentReferenceType1(boolean hasTypeAnnotations) {
	super.consumeTypeArgumentReferenceType1(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_ARGUMENT_TYPE_REFERENCE) != 0) {
		int length = this.genericsLengthStack[this.genericsLengthPtr];
		if (length == 1) {

	}
}

protected void consumeTypeArgumentReferenceType2(boolean hasTypeAnnotations) {
	super.consumeTypeArgumentReferenceType2(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_ARGUMENT_TYPE_REFERENCE) != 0) {
		int length = this.genericsLengthStack[this.genericsLengthPtr];
		if (length == 1) {

	}
}

protected void consumeTypeParameter1WithExtendsAndBounds(boolean hasTypeAnnotations) {
	super.consumeTypeParameter1WithExtendsAndBounds(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
		TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
		this.patternLocator.match(typeParameter.type, this.nodeSet);

	this.patternLocator.match((TypeParameter)this.genericsStack[this.genericsPtr], this.nodeSet);
}

protected void consumeTypeParameterWithExtends(boolean hasTypeAnnotations) {
	super.consumeTypeParameterWithExtends(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
		TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
		this.patternLocator.match(typeParameter.type, this.nodeSet);
	}
}

protected void consumeTypeParameterWithExtendsAndBounds(boolean hasTypeAnnotations) {
	super.consumeTypeParameterWithExtendsAndBounds(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
		TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
		this.patternLocator.match(typeParameter.type, this.nodeSet);

	}
}

protected void consumeWildcardBoundsExtends(boolean hasTypeAnnotations) {
	super.consumeWildcardBoundsExtends(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.WILDCARD_BOUND_TYPE_REFERENCE) != 0) {
		Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];
		this.patternLocator.match(wildcard.bound, this.nodeSet);
	}
}

protected void consumeWildcardBoundsSuper(boolean hasTypeAnnotations) {
	super.consumeWildcardBoundsSuper(hasTypeAnnotations);
	if ((this.patternFineGrain & IJavaSearchConstants.WILDCARD_BOUND_TYPE_REFERENCE) != 0) {
		Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];
		this.patternLocator.match(wildcard.bound, this.nodeSet);

		this.nodeSet.addTrustedMatch(result, true);
	return result;
}
protected TypeReference getUnannotatedTypeReference(int dim) {
	TypeReference typeRef = super.getUnannotatedTypeReference(dim);
	if (this.patternFineGrain == 0) {
		this.patternLocator.match(typeRef, this.nodeSet); // NB: Don't check container since type reference can happen anywhere
	}

Lines 166-173 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/CodeFormatterVisitor.java (-2 / +2 lines)
166	};	166	};
167	private static final int[] CLOSING_GENERICS_EXPECTEDTOKENS = new int[] {	167	private static final int[] CLOSING_GENERICS_EXPECTEDTOKENS = new int[] {
168	TerminalTokens.TokenNameRIGHT_SHIFT,	168	TerminalTokens.TokenNameRIGHT_SHIFT,
169	TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT,	169	TerminalTokens.TokenNameGREATER,
170	TerminalTokens.TokenNameGREATER	170	TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT
171	};	171	};
172	private int chunkKind;	172	private int chunkKind;
173	public int lastLocalDeclarationSourceStart;	173	public int lastLocalDeclarationSourceStart;

Lines 55-60 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnSingleTypeReference.java (+6 lines)
55	public TypeReference copyDims(int dim){	55	public TypeReference copyDims(int dim){
56	return this;	56	return this;
57	}	57	}
		58	/*
		59	* No expansion of the completion reference into an array one
		60	*/
		61	public TypeReference copyDims(int dim, Annotation[][] annotationsOnDimensions){
		62	return this;
		63	}
58	protected TypeBinding getTypeBinding(Scope scope) {	64	protected TypeBinding getTypeBinding(Scope scope) {
59	if (this.fieldTypeCompletionNode != null) {	65	if (this.fieldTypeCompletionNode != null) {
60	throw new CompletionNodeFound(this.fieldTypeCompletionNode, scope);	66	throw new CompletionNodeFound(this.fieldTypeCompletionNode, scope);




		if ((length = this.identifierLengthStack[this.identifierLengthPtr-1]) < 0) {
			// build the primitive type node
			int dim = isAfterArrayType() ? this.intStack[this.intPtr--] : 0;
			Annotation [][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
			SingleTypeReference typeRef = (SingleTypeReference)TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
			typeRef.sourceStart = this.intStack[this.intPtr--];
			if (dim == 0) {
				typeRef.sourceEnd = this.intStack[this.intPtr--];

	if (checkLabelStatement()) return;
	if (checkNameCompletion()) return;
}
protected void consumeArrayCreationExpressionWithInitializer(boolean hasTypeAnnotations) {
	super.consumeArrayCreationExpressionWithInitializer(hasTypeAnnotations);
	popElement(K_ARRAY_CREATION);
}
protected void consumeArrayCreationExpressionWithoutInitializer(boolean hasTypeAnnotations) {
	super.consumeArrayCreationExpressionWithoutInitializer(hasTypeAnnotations);
	popElement(K_ARRAY_CREATION);
}
protected void consumeArrayCreationHeader() {

		pushOnElementStack(K_SWITCH_LABEL);
	}
}
protected void consumeCastExpressionWithPrimitiveType(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);

	Expression exp, cast, castType;

	cast.sourceStart = castType.sourceStart - 1;
	cast.sourceEnd = exp.sourceEnd;
}
protected void consumeCastExpressionWithGenericsArray(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);

	Expression exp, cast, castType;

	cast.sourceEnd = exp.sourceEnd;
}

protected void consumeCastExpressionWithQualifiedGenericsArray(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);

	Expression exp, cast, castType;

	cast.sourceStart = castType.sourceStart - 1;
	cast.sourceEnd = exp.sourceEnd;
}
protected void consumeCastExpressionWithNameArray(boolean hasTypeAnnotations) {
	// CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
	popElement(K_CAST_STATEMENT);


	cast.sourceStart = castType.sourceStart - 1;
	cast.sourceEnd = exp.sourceEnd;
}
protected void consumeCastExpressionLL1(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);
	super.consumeCastExpressionLL1(hasTypeAnnotations);
}
protected void consumeClassBodyDeclaration() {
	popElement(K_BLOCK_DELIMITER);

				long selectorSource = this.identifierPositionStack[this.identifierPtr + 1];

				//type
				TypeReference type = getUnannotatedTypeReference(this.intStack[this.intPtr--]);
				((CompletionOnSingleTypeReference)type).isCompletionNode = false;
				//modifiers
				int declarationSourceStart = this.intStack[this.intPtr--];

		long selectorSource = this.identifierPositionStack[this.identifierPtr--];
		this.identifierLengthPtr--;
		//type
		md.returnType = getUnannotatedTypeReference(this.intStack[this.intPtr--]);
		//modifiers
		md.declarationSourceStart = this.intStack[this.intPtr--];
		md.modifiers = this.intStack[this.intPtr--];

		}
	}
}
protected void consumeMethodHeaderNameWithTypeParameters( boolean isAnnotationMethod, boolean hasTypeAnnotations) {
	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
	int selectorSourceEnd = (int) selectorSourcePositions;
	int currentAstPtr = this.astPtr;
	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod, hasTypeAnnotations);
	if (this.sourceEnds != null && this.astPtr > currentAstPtr) {// if ast node was pushed on the ast stack
		this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
	}

		this.hasUnusedModifiers = true;
	}
}
protected void consumeAdditionalBound(boolean hasTypeAnnotations) {
	super.consumeAdditionalBound(hasTypeAnnotations);
	ASTNode node = this.genericsStack[this.genericsPtr];
	if (node instanceof CompletionOnSingleTypeReference) {
		((CompletionOnSingleTypeReference) node).setKind(CompletionOnQualifiedTypeReference.K_INTERFACE);

protected void consumeRightParen() {
	super.consumeRightParen();
}
protected void consumeReferenceType1(boolean hasTypeAnnotations) {
	super.consumeReferenceType1(hasTypeAnnotations);
	popElement(K_BINARY_OPERATOR);
}
protected void consumeReferenceType2(boolean hasTypeAnnotations) {
	super.consumeReferenceType2(hasTypeAnnotations);
	popElement(K_BINARY_OPERATOR);
}
protected void consumeReferenceType3(boolean hasTypeAnnotations) {
	super.consumeReferenceType3(hasTypeAnnotations);
	popElement(K_BINARY_OPERATOR);
}
protected void consumeTypeArgumentReferenceType1(boolean hasTypeAnnotations) {
	super.consumeTypeArgumentReferenceType1(hasTypeAnnotations);
	popElement(K_BINARY_OPERATOR);
}
protected void consumeTypeArgumentReferenceType2(boolean hasTypeAnnotations) {
	super.consumeTypeArgumentReferenceType2(hasTypeAnnotations);
	popElement(K_BINARY_OPERATOR);
}
protected void consumeTypeArguments() {

	super.consumeTypeParameter1();
	popElement(K_BINARY_OPERATOR);
}
protected void consumeTypeParameterWithExtends(boolean hasTypeAnnotations) {
	super.consumeTypeParameterWithExtends(hasTypeAnnotations);
	if (this.assistNode != null && this.assistNodeParent == null) {
		TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
		if (typeParameter != null && typeParameter.type == this.assistNode)

	}
	popElement(K_EXTENDS_KEYWORD);
}
protected void consumeTypeParameterWithExtendsAndBounds(boolean hasTypeAnnotations) {
	super.consumeTypeParameterWithExtendsAndBounds(hasTypeAnnotations);
	if (this.assistNode != null && this.assistNodeParent == null) {
		TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
		if (typeParameter != null && typeParameter.type == this.assistNode)

	}
	popElement(K_EXTENDS_KEYWORD);
}
protected void consumeTypeParameter1WithExtendsAndBounds(boolean hasTypeAnnotations) {
	super.consumeTypeParameter1WithExtendsAndBounds(hasTypeAnnotations);
	if (this.assistNode != null && this.assistNodeParent == null) {
		TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
		if (typeParameter != null && typeParameter.type == this.assistNode)

	super.consumeWildcard3();
	popElement(K_BINARY_OPERATOR);
}
protected void consumeWildcardBoundsExtends(boolean hasTypeAnnotations) {
	super.consumeWildcardBoundsExtends(hasTypeAnnotations);
	if (this.assistNode != null && this.assistNodeParent == null) {
		Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];
		if (wildcard != null && wildcard.bound == this.assistNode)

Lines 55-60 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnQualifiedTypeReference.java (+3 lines)
55	public TypeReference copyDims(int dim){	55	public TypeReference copyDims(int dim){
56	return this;	56	return this;
57	}	57	}
		58	public TypeReference copyDims(int dim, Annotation[][] annotationsOnDimensions){
		59	return this;
		60	}
58	protected TypeBinding getTypeBinding(Scope scope) {	61	protected TypeBinding getTypeBinding(Scope scope) {
59	// it can be a package, type or member type	62	// it can be a package, type or member type
60	Binding binding = scope.parent.getTypeOrPackage(this.tokens); // step up from the ClassScope	63	Binding binding = scope.parent.getTypeOrPackage(this.tokens); // step up from the ClassScope

Lines 11-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java (-512 / +1061 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.parser;	12	package org.eclipse.jdt.internal.compiler.parser;
13		13
14	import java.io.*;	14	import java.io.BufferedInputStream;
		15	import java.io.BufferedWriter;
		16	import java.io.File;
		17	import java.io.FileWriter;
		18	import java.io.IOException;
		19	import java.io.InputStream;
15	import java.util.ArrayList;	20	import java.util.ArrayList;
16	import java.util.Collections;	21	import java.util.Collections;
17	import java.util.Iterator;	22	import java.util.Iterator;
Lines 24-37 Link Here
24	import org.eclipse.jdt.core.compiler.InvalidInputException;	29	import org.eclipse.jdt.core.compiler.InvalidInputException;
25	import org.eclipse.jdt.internal.compiler.ASTVisitor;	30	import org.eclipse.jdt.internal.compiler.ASTVisitor;
26	import org.eclipse.jdt.internal.compiler.CompilationResult;	31	import org.eclipse.jdt.internal.compiler.CompilationResult;
27	import org.eclipse.jdt.internal.compiler.ast.*;	32	import org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression;
		33	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
		34	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
		35	import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
		36	import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
		37	import org.eclipse.jdt.internal.compiler.ast.Annotation;
		38	import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration;
		39	import org.eclipse.jdt.internal.compiler.ast.Argument;
		40	import org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression;
		41	import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
		42	import org.eclipse.jdt.internal.compiler.ast.ArrayQualifiedTypeReference;
		43	import org.eclipse.jdt.internal.compiler.ast.ArrayReference;
		44	import org.eclipse.jdt.internal.compiler.ast.ArrayTypeReference;
		45	import org.eclipse.jdt.internal.compiler.ast.AssertStatement;
		46	import org.eclipse.jdt.internal.compiler.ast.Assignment;
		47	import org.eclipse.jdt.internal.compiler.ast.BinaryExpression;
		48	import org.eclipse.jdt.internal.compiler.ast.Block;
		49	import org.eclipse.jdt.internal.compiler.ast.BreakStatement;
		50	import org.eclipse.jdt.internal.compiler.ast.CaseStatement;
		51	import org.eclipse.jdt.internal.compiler.ast.CastExpression;
		52	import org.eclipse.jdt.internal.compiler.ast.CharLiteral;
		53	import org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess;
		54	import org.eclipse.jdt.internal.compiler.ast.CombinedBinaryExpression;
		55	import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
		56	import org.eclipse.jdt.internal.compiler.ast.CompoundAssignment;
		57	import org.eclipse.jdt.internal.compiler.ast.ConditionalExpression;
		58	import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
		59	import org.eclipse.jdt.internal.compiler.ast.ContinueStatement;
		60	import org.eclipse.jdt.internal.compiler.ast.DoStatement;
		61	import org.eclipse.jdt.internal.compiler.ast.DoubleLiteral;
		62	import org.eclipse.jdt.internal.compiler.ast.EmptyStatement;
		63	import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
		64	import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
		65	import org.eclipse.jdt.internal.compiler.ast.Expression;
		66	import org.eclipse.jdt.internal.compiler.ast.FalseLiteral;
		67	import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
		68	import org.eclipse.jdt.internal.compiler.ast.FieldReference;
		69	import org.eclipse.jdt.internal.compiler.ast.FloatLiteral;
		70	import org.eclipse.jdt.internal.compiler.ast.ForStatement;
		71	import org.eclipse.jdt.internal.compiler.ast.ForeachStatement;
		72	import org.eclipse.jdt.internal.compiler.ast.IfStatement;
		73	import org.eclipse.jdt.internal.compiler.ast.ImportReference;
		74	import org.eclipse.jdt.internal.compiler.ast.Initializer;
		75	import org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression;
		76	import org.eclipse.jdt.internal.compiler.ast.IntLiteral;
		77	import org.eclipse.jdt.internal.compiler.ast.IntLiteralMinValue;
		78	import org.eclipse.jdt.internal.compiler.ast.Javadoc;
		79	import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
		80	import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
		81	import org.eclipse.jdt.internal.compiler.ast.LongLiteral;
		82	import org.eclipse.jdt.internal.compiler.ast.LongLiteralMinValue;
		83	import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;
		84	import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
		85	import org.eclipse.jdt.internal.compiler.ast.MessageSend;
		86	import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
		87	import org.eclipse.jdt.internal.compiler.ast.NameReference;
		88	import org.eclipse.jdt.internal.compiler.ast.NormalAnnotation;
		89	import org.eclipse.jdt.internal.compiler.ast.NullLiteral;
		90	import org.eclipse.jdt.internal.compiler.ast.OR_OR_Expression;
		91	import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
		92	import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
		93	import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;
		94	import org.eclipse.jdt.internal.compiler.ast.PostfixExpression;
		95	import org.eclipse.jdt.internal.compiler.ast.PrefixExpression;
		96	import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
97	import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
98	import org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference;
99	import org.eclipse.jdt.internal.compiler.ast.QualifiedThisReference;
100	import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
101	import org.eclipse.jdt.internal.compiler.ast.Reference;
102	import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;
103	import org.eclipse.jdt.internal.compiler.ast.SingleMemberAnnotation;
104	import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
105	import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
106	import org.eclipse.jdt.internal.compiler.ast.Statement;
107	import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
108	import org.eclipse.jdt.internal.compiler.ast.SuperReference;
109	import org.eclipse.jdt.internal.compiler.ast.SwitchStatement;
110	import org.eclipse.jdt.internal.compiler.ast.SynchronizedStatement;
111	import org.eclipse.jdt.internal.compiler.ast.ThisReference;
112	import org.eclipse.jdt.internal.compiler.ast.ThrowStatement;
113	import org.eclipse.jdt.internal.compiler.ast.TrueLiteral;
114	import org.eclipse.jdt.internal.compiler.ast.TryStatement;
115	import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
116	import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
117	import org.eclipse.jdt.internal.compiler.ast.TypeReference;
118	import org.eclipse.jdt.internal.compiler.ast.UnaryExpression;
119	import org.eclipse.jdt.internal.compiler.ast.WhileStatement;
120	import org.eclipse.jdt.internal.compiler.ast.Wildcard;
28	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	121	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
29	import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;	122	import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
30	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	123	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
31	import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;	124	import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
		125	import org.eclipse.jdt.internal.compiler.lookup.Binding;
32	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	126	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
33	import org.eclipse.jdt.internal.compiler.lookup.ClassScope;	127	import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
34	import org.eclipse.jdt.internal.compiler.lookup.Binding;
35	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;	128	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
36	import org.eclipse.jdt.internal.compiler.lookup.MethodScope;	129	import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
37	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	130	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
Lines 64-70 Link Here
64	private static final String ERROR_TOKEN = "$error" ; //$NON-NLS-1$	157	private static final String ERROR_TOKEN = "$error" ; //$NON-NLS-1$
65	//expression stack	158	//expression stack
66	protected final static int ExpressionStackIncrement = 100;	159	protected final static int ExpressionStackIncrement = 100;
67		160
		161	// annotation stack
		162	protected final static int TypeAnnotationStackIncrement = 100;
		163
68	protected final static int GenericsStackIncrement = 10;	164	protected final static int GenericsStackIncrement = 10;
69		165
70	private final static String FILEPREFIX = "parser"; //$NON-NLS-1$	166	private final static String FILEPREFIX = "parser"; //$NON-NLS-1$
Lines 786-792 Link Here
786	protected int[] expressionLengthStack;	882	protected int[] expressionLengthStack;
787	protected int expressionPtr;	883	protected int expressionPtr;
788	protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];	884	protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];
		885	protected int unattachedAnnotationPtr; // used for figuring out whether some set of annotations are annotating a dimension or not.
789	public int firstToken ; // handle for multiple parsing goals	886	public int firstToken ; // handle for multiple parsing goals
		887
		888	/* jsr308 -- Type annotation management, we now maintain type annotations in a separate stack
		889	as otherwise they get interspersed with other expressions and some of the code is not prepared
		890	to handle such interleaving and will look ugly if changed.
		891
		892	See consumeArrayCreationExpressionWithoutInitializer for example.
		893
		894	See that annotations gets pushed into expression stack the moment an annotation is discovered and
		895	get moved to the new type annotations stack only later when the annotation is recognized to be a
		896	type annotation. Where ambiguities exist (i.e 1.7 annotation occurs in a place sanctioned for an
		897	1.5 type annotation, the annotation continues to stay in the expression stack, but in these case
		898	interleaving is not an issue.
		899	*/
		900	protected int typeAnnotationPtr;
		901	protected int typeAnnotationLengthPtr;
		902	protected Annotation [] typeAnnotationStack = new Annotation[TypeAnnotationStackIncrement];
		903	protected int [] typeAnnotationLengthStack;
790	// generics management	904	// generics management
791	protected int genericsIdentifiersLengthPtr;	905	protected int genericsIdentifiersLengthPtr;
792	protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];	906	protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];
Lines 877-882 Link Here
877	initializeScanner();	991	initializeScanner();
878	this.astLengthStack = new int[50];	992	this.astLengthStack = new int[50];
879	this.expressionLengthStack = new int[30];	993	this.expressionLengthStack = new int[30];
		994	this.typeAnnotationLengthStack = new int[30];
880	this.intStack = new int[50];	995	this.intStack = new int[50];
881	this.identifierStack = new char[30][];	996	this.identifierStack = new char[30][];
882	this.identifierLengthStack = new int[30];	997	this.identifierLengthStack = new int[30];
Lines 1271-1278 Link Here
1271		1386
1272	this.astLengthStack[this.astLengthPtr - 1] += this.astLengthStack[this.astLengthPtr--];	1387	this.astLengthStack[this.astLengthPtr - 1] += this.astLengthStack[this.astLengthPtr--];
1273	}	1388	}
1274	protected void consumeAdditionalBound() {	1389	protected void consumeAdditionalBound(boolean hasTypeAnnotations) {
1275	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	1390	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
1276	}	1391	}
1277	protected void consumeAdditionalBound1() {	1392	protected void consumeAdditionalBound1() {
1278	// nothing to be done.	1393	// nothing to be done.
Lines 1581-1587 Link Here
1581	}	1696	}
1582	exp.sourceEnd = this.endStatementPosition;	1697	exp.sourceEnd = this.endStatementPosition;
1583	}	1698	}
1584	protected void consumeArrayCreationExpressionWithInitializer() {	1699	protected void consumeArrayCreationExpressionWithInitializer(boolean hasTypeAnnotations) {
1585	// ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer	1700	// ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer
1586	// ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer	1701	// ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer
1587		1702
Lines 1590-1596 Link Here
1590	this.expressionLengthPtr -- ;	1705	this.expressionLengthPtr -- ;
1591	arrayAllocation.initializer = (ArrayInitializer) this.expressionStack[this.expressionPtr--];	1706	arrayAllocation.initializer = (ArrayInitializer) this.expressionStack[this.expressionPtr--];
1592		1707
1593	arrayAllocation.type = getTypeReference(0);	1708	arrayAllocation.type = hasTypeAnnotations ? getTypeReference(0) : getUnannotatedTypeReference(0);
1594	arrayAllocation.type.bits \|= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage	1709	arrayAllocation.type.bits \|= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage
1595	length = (this.expressionLengthStack[this.expressionLengthPtr--]);	1710	length = (this.expressionLengthStack[this.expressionLengthPtr--]);
1596	this.expressionPtr -= length ;	1711	this.expressionPtr -= length ;
Lines 1608-1620 Link Here
1608	}	1723	}
1609	pushOnExpressionStack(arrayAllocation);	1724	pushOnExpressionStack(arrayAllocation);
1610	}	1725	}
1611	protected void consumeArrayCreationExpressionWithoutInitializer() {	1726	protected void consumeArrayCreationExpressionWithoutInitializer(boolean hasTypeAnnotations) {
1612	// ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs	1727	// ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
1613	// ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs	1728	// ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs
1614		1729
1615	int length;	1730	int length;
1616	ArrayAllocationExpression arrayAllocation = new ArrayAllocationExpression();	1731	ArrayAllocationExpression arrayAllocation = new ArrayAllocationExpression();
1617	arrayAllocation.type = getTypeReference(0);	1732	arrayAllocation.type = hasTypeAnnotations ? getTypeReference(0) : getUnannotatedTypeReference(0);
1618	arrayAllocation.type.bits \|= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage	1733	arrayAllocation.type.bits \|= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage
1619	length = (this.expressionLengthStack[this.expressionLengthPtr--]);	1734	length = (this.expressionLengthStack[this.expressionLengthPtr--]);
1620	this.expressionPtr -= length ;	1735	this.expressionPtr -= length ;
Lines 2016-2022 Link Here
2016	}	2131	}
2017	pushOnAstStack(caseStatement);	2132	pushOnAstStack(caseStatement);
2018	}	2133	}
2019	protected void consumeCastExpressionLL1() {	2134	protected void consumeCastExpressionLL1(boolean hasTypeAnnotations) {
2020	//CastExpression ::= '(' Expression ')' InsideCastExpressionLL1 UnaryExpressionNotPlusMinus	2135	//CastExpression ::= '(' Expression ')' InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
2021	// Expression is used in order to make the grammar LL1	2136	// Expression is used in order to make the grammar LL1
2022		2137
Lines 2027-2038 Link Here
2027	this.expressionStack[this.expressionPtr] =	2142	this.expressionStack[this.expressionPtr] =
2028	cast = new CastExpression(	2143	cast = new CastExpression(
2029	exp=this.expressionStack[this.expressionPtr+1] ,	2144	exp=this.expressionStack[this.expressionPtr+1] ,
2030	getTypeReference(this.expressionStack[this.expressionPtr]));	2145	getTypeReference(this.expressionStack[this.expressionPtr])); // TODO (Srikanth)
2031	this.expressionLengthPtr -- ;	2146	this.expressionLengthPtr -- ;
2032	updateSourcePosition(cast);	2147	updateSourcePosition(cast);
2033	cast.sourceEnd=exp.sourceEnd;	2148	cast.sourceEnd=exp.sourceEnd;
2034	}	2149	}
2035	protected void consumeCastExpressionWithGenericsArray() {	2150	protected void consumeCastExpressionWithGenericsArray(boolean hasTypeAnnotations) {
2036	// CastExpression ::= PushLPAREN Name TypeArguments Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	2151	// CastExpression ::= PushLPAREN Name TypeArguments Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
2037		2152
2038	Expression exp, cast, castType;	2153	Expression exp, cast, castType;
Lines 2041-2053 Link Here
2041	int dim = this.intStack[this.intPtr--];	2156	int dim = this.intStack[this.intPtr--];
2042	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	2157	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
2043		2158
2044	this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(dim));	2159	this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = hasTypeAnnotations ? getTypeReference(dim) : getUnannotatedTypeReference(dim));
2045	this.intPtr--;	2160	this.intPtr--;
2046	castType.sourceEnd = end - 1;	2161	castType.sourceEnd = end - 1;
2047	castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;	2162	castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
2048	cast.sourceEnd = exp.sourceEnd;	2163	cast.sourceEnd = exp.sourceEnd;
2049	}	2164	}
2050	protected void consumeCastExpressionWithNameArray() {	2165	protected void consumeCastExpressionWithNameArray(boolean hasTypeAnnotations) {
2051	// CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	2166	// CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
2052		2167
2053	Expression exp, cast, castType;	2168	Expression exp, cast, castType;
Lines 2057-2068 Link Here
2057	pushOnGenericsLengthStack(0);	2172	pushOnGenericsLengthStack(0);
2058	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	2173	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
2059		2174
2060	this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(this.intStack[this.intPtr--]));	2175	this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
2061	castType.sourceEnd = end - 1;	2176	castType.sourceEnd = end - 1;
2062	castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;	2177	castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
2063	cast.sourceEnd = exp.sourceEnd;	2178	cast.sourceEnd = exp.sourceEnd;
2064	}	2179	}
2065	protected void consumeCastExpressionWithPrimitiveType() {	2180	protected void consumeCastExpressionWithPrimitiveType(boolean hasTypeAnnotations) {
2066	// CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression	2181	// CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression
2067		2182
2068	//this.intStack : posOfLeftParen dim posOfRightParen	2183	//this.intStack : posOfLeftParen dim posOfRightParen
Lines 2071-2088 Link Here
2071		2186
2072	Expression exp, cast, castType;	2187	Expression exp, cast, castType;
2073	int end = this.intStack[this.intPtr--];	2188	int end = this.intStack[this.intPtr--];
2074	this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(this.intStack[this.intPtr--]));	2189	this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
2075	castType.sourceEnd = end - 1;	2190	castType.sourceEnd = end - 1;
2076	castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;	2191	castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
2077	cast.sourceEnd = exp.sourceEnd;	2192	cast.sourceEnd = exp.sourceEnd;
2078	}	2193	}
2079	protected void consumeCastExpressionWithQualifiedGenericsArray() {	2194	protected void consumeCastExpressionWithQualifiedGenericsArray(boolean hasTypeAnnotations) {
2080	// CastExpression ::= PushLPAREN Name OnlyTypeArguments '.' ClassOrInterfaceType Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	2195	// CastExpression ::= PushLPAREN Name OnlyTypeArguments '.' ClassOrInterfaceType Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
2081	Expression exp, cast, castType;	2196	Expression exp, cast, castType;
2082	int end = this.intStack[this.intPtr--];	2197	int end = this.intStack[this.intPtr--];
2083		2198
2084	int dim = this.intStack[this.intPtr--];	2199	int dim = this.intStack[this.intPtr--];
2085	TypeReference rightSide = getTypeReference(0);	2200	TypeReference rightSide = hasTypeAnnotations ? getTypeReference(0) : getUnannotatedTypeReference(0);
2086		2201
2087	ParameterizedQualifiedTypeReference qualifiedParameterizedTypeReference = computeQualifiedGenericsFromRightSide(rightSide, dim);	2202	ParameterizedQualifiedTypeReference qualifiedParameterizedTypeReference = computeQualifiedGenericsFromRightSide(rightSide, dim);
2088	this.intPtr--;	2203	this.intPtr--;
Lines 2610-2615 Link Here
2610		2725
2611	AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];	2726	AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];
2612		2727
		2728	// jsr308 -- consume receiver annotations
		2729	method.receiverAnnotations = null;
		2730	int length;
		2731	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		2732	System.arraycopy(
		2733	this.typeAnnotationStack,
		2734	(this.typeAnnotationPtr -= length) + 1,
		2735	method.receiverAnnotations = new Annotation[length],
		2736	0,
		2737	length);
		2738	}
		2739
		2740
2613	if (this.currentToken == TokenNameLBRACE){	2741	if (this.currentToken == TokenNameLBRACE){
2614	method.bodyStart = this.scanner.currentPosition;	2742	method.bodyStart = this.scanner.currentPosition;
2615	}	2743	}
Lines 2768-2775 Link Here
2768	pushOnIntStack(this.dimensions);	2896	pushOnIntStack(this.dimensions);
2769	this.dimensions = 0;	2897	this.dimensions = 0;
2770	}	2898	}
2771	protected void consumeDimWithOrWithOutExpr() {	2899
2772	// DimWithOrWithOutExpr ::= '[' ']'	2900	protected void consumeDimWithOutExpr() {
		2901	// DimWithOrWithOutExpr ::= '[' ']'
		2902	// DimWithOrWithOutExpr ::= OneOrMoreAnnotations '[' ']'
2773	pushOnExpressionStack(null);	2903	pushOnExpressionStack(null);
2774		2904
2775	if(this.currentElement != null && this.currentToken == TokenNameLBRACE) {	2905	if(this.currentElement != null && this.currentToken == TokenNameLBRACE) {
Lines 2959-2965 Link Here
2959	this.intPtr-=2;	3089	this.intPtr-=2;
2960	}	3090	}
2961		3091
2962	type = getTypeReference(this.intStack[this.intPtr--] + extraDims); // type dimension	3092	type = getUnannotatedTypeReference(this.intStack[this.intPtr--] + extraDims); // type dimension // TODO (Srikanth)
2963		3093
2964	// consume annotations	3094	// consume annotations
2965	int length;	3095	int length;
Lines 3100-3113 Link Here
3100	0,	3230	0,
3101	length);	3231	length);
3102	}	3232	}
3103	type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension	3233	type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
3104	if (declaration.declarationSourceStart == -1) {	3234	if (declaration.declarationSourceStart == -1) {
3105	// this is true if there is no modifiers for the local variable declaration	3235	// this is true if there is no modifiers for the local variable declaration
3106	declaration.declarationSourceStart = type.sourceStart;	3236	declaration.declarationSourceStart = type.sourceStart;
3107	}	3237	}
3108	pushOnAstStack(type);	3238	pushOnAstStack(type);
3109	} else {	3239	} else {
3110	type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension	3240	type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
3111	pushOnAstStack(type);	3241	pushOnAstStack(type);
3112	declaration.declarationSourceStart = this.intStack[this.intPtr--];	3242	declaration.declarationSourceStart = this.intStack[this.intPtr--];
3113	declaration.modifiers = this.intStack[this.intPtr--];	3243	declaration.modifiers = this.intStack[this.intPtr--];
Lines 3774-3783 Link Here
3774	endOfEllipsis = this.intStack[this.intPtr--];	3904	endOfEllipsis = this.intStack[this.intPtr--];
3775	}	3905	}
3776	int firstDimensions = this.intStack[this.intPtr--];	3906	int firstDimensions = this.intStack[this.intPtr--];
3777	final int typeDimensions = firstDimensions + extendedDimensions;	3907	TypeReference type = getUnannotatedTypeReference(extendedDimensions);
3778	TypeReference type = getTypeReference(typeDimensions);	3908	Annotation [] varArgsAnnotations = null;
		3909	int length;
		3910	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		3911	System.arraycopy(
		3912	this.typeAnnotationStack,
		3913	(this.typeAnnotationPtr -= length) + 1,
		3914	varArgsAnnotations = new Annotation[length],
		3915	0,
		3916	length);
		3917	}
		3918	final int typeDimensions = firstDimensions + extendedDimensions + (isVarArgs ? 1 : 0);
		3919
		3920	// jsr308 type annotations management
		3921	Annotation[][] annotationsOnFirstDimensions = firstDimensions == 0 ? null : getAnnotationsOnDimensions(firstDimensions);
		3922	Annotation [][] annotationsOnExtendedDimensions = extendedDimensions == 0 ? null : type.getAnnotationsOnDimensions();
		3923	Annotation [][] annotationsOnAllDimensions = null;
		3924	if (annotationsOnFirstDimensions != null \|\| annotationsOnExtendedDimensions != null \|\| varArgsAnnotations != null) {
		3925	// Merge the three into one.
		3926	annotationsOnAllDimensions = new Annotation[typeDimensions][];
		3927	int index;
		3928	for (index = 0; index < firstDimensions; index++) {
		3929	annotationsOnAllDimensions[index] = annotationsOnFirstDimensions == null ? null : annotationsOnFirstDimensions[index];
		3930	}
		3931	// copy over the annotations on extended dimensions...
		3932	for (int j = 0; j < extendedDimensions; j++, index++) {
		3933	annotationsOnAllDimensions[index] = annotationsOnExtendedDimensions == null ? null : annotationsOnExtendedDimensions[j];
		3934	}
		3935	// copy over the varargs annotations, never mind that varargs and extended dimensions don't coexist.
		3936	if (isVarArgs) {
		3937	annotationsOnAllDimensions[index] = varArgsAnnotations;
		3938	}
		3939	}
		3940
		3941	if (typeDimensions != extendedDimensions) {
		3942	type = copyDims(type, typeDimensions, annotationsOnAllDimensions);
		3943	type.sourceEnd = type.isParametrizedTypeReference() ? this.endStatementPosition : this.endPosition;
		3944	}
3779	if (isVarArgs) {	3945	if (isVarArgs) {
3780	type = copyDims(type, typeDimensions + 1);
3781	if (extendedDimensions == 0) {	3946	if (extendedDimensions == 0) {
3782	type.sourceEnd = endOfEllipsis;	3947	type.sourceEnd = endOfEllipsis;
3783	}	3948	}
Lines 3793-3799 Link Here
3793	this.intStack[this.intPtr + 1] & ~ClassFileConstants.AccDeprecated); // modifiers	3958	this.intStack[this.intPtr + 1] & ~ClassFileConstants.AccDeprecated); // modifiers
3794	arg.declarationSourceStart = modifierPositions;	3959	arg.declarationSourceStart = modifierPositions;
3795	// consume annotations	3960	// consume annotations
3796	int length;	3961
3797	if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {	3962	if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3798	System.arraycopy(	3963	System.arraycopy(
3799	this.expressionStack,	3964	this.expressionStack,
Lines 3817-3824 Link Here
3817	extendedDimensions > 0) {	3982	extendedDimensions > 0) {
3818	problemReporter().illegalExtendedDimensions(arg);	3983	problemReporter().illegalExtendedDimensions(arg);
3819	}	3984	}
		3985	} else {
		3986	// The grammar allows trailing annotations in FormalParameter as in
		3987	// "int @NonNull[] @Misplaced parameter" in order to allow for constructs such as
		3988	// "Object @NonNull[] @Correct ... objects" -- we prune these here.
		3989	if (varArgsAnnotations != null) {
		3990	problemReporter().misplacedTypeAnnotations(varArgsAnnotations[0],
		3991	varArgsAnnotations[varArgsAnnotations.length-1]);
		3992	}
3820	}	3993	}
3821	}	3994	}
		3995	protected Annotation[][] getAnnotationsOnDimensions(int dimensionsCount) {
		3996	Annotation [][] dimensionsAnnotations = null;
		3997	if (dimensionsCount > 0) {
		3998	for (int i = 0; i < dimensionsCount; i++) {
		3999	Annotation [] annotations = null;
		4000	int length;
		4001	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		4002	System.arraycopy(
		4003	this.typeAnnotationStack,
		4004	(this.typeAnnotationPtr -= length) + 1,
		4005	annotations = new Annotation[length],
		4006	0,
		4007	length);
		4008	if (dimensionsAnnotations == null) {
		4009	dimensionsAnnotations = new Annotation[dimensionsCount][];
		4010	}
		4011	dimensionsAnnotations[dimensionsCount - i - 1] = annotations;
		4012	}
		4013	}
		4014	}
		4015	return dimensionsAnnotations;
		4016	}
3822	protected void consumeFormalParameterList() {	4017	protected void consumeFormalParameterList() {
3823	// FormalParameterList ::= FormalParameterList ',' FormalParameter	4018	// FormalParameterList ::= FormalParameterList ',' FormalParameter
3824	optimizedConcatNodeLists();	4019	optimizedConcatNodeLists();
Lines 4407-4412 Link Here
4407	// MethodHeaderExtendedDims ::= Dimsopt	4602	// MethodHeaderExtendedDims ::= Dimsopt
4408	// now we update the returnType of the method	4603	// now we update the returnType of the method
4409	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];	4604	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
		4605	// jsr308 -- consume receiver annotations
		4606	md.receiverAnnotations = null;
		4607	int length;
		4608	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		4609	System.arraycopy(
		4610	this.typeAnnotationStack,
		4611	(this.typeAnnotationPtr -= length) + 1,
		4612	md.receiverAnnotations = new Annotation[length],
		4613	0,
		4614	length);
		4615	}
4410	int extendedDims = this.intStack[this.intPtr--];	4616	int extendedDims = this.intStack[this.intPtr--];
4411	if(md.isAnnotationMethod()) {	4617	if(md.isAnnotationMethod()) {
4412	((AnnotationMethodDeclaration)md).extendedDimensions = extendedDims;	4618	((AnnotationMethodDeclaration)md).extendedDimensions = extendedDims;
Lines 4442-4448 Link Here
4442	long selectorSource = this.identifierPositionStack[this.identifierPtr--];	4648	long selectorSource = this.identifierPositionStack[this.identifierPtr--];
4443	this.identifierLengthPtr--;	4649	this.identifierLengthPtr--;
4444	//type	4650	//type
4445	md.returnType = getTypeReference(this.intStack[this.intPtr--]);	4651	md.returnType = getUnannotatedTypeReference(this.intStack[this.intPtr--]);
4446	//modifiers	4652	//modifiers
4447	md.declarationSourceStart = this.intStack[this.intPtr--];	4653	md.declarationSourceStart = this.intStack[this.intPtr--];
4448	md.modifiers = this.intStack[this.intPtr--];	4654	md.modifiers = this.intStack[this.intPtr--];
Lines 4482-4488 Link Here
4482	}	4688	}
4483	}	4689	}
4484	}	4690	}
4485	protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod) {	4691	protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod, boolean hasTypeAnnotations) {
4486	// MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	4692	// MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
4487	// AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	4693	// AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
4488	// RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	4694	// RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
Lines 4499-4505 Link Here
4499	long selectorSource = this.identifierPositionStack[this.identifierPtr--];	4705	long selectorSource = this.identifierPositionStack[this.identifierPtr--];
4500	this.identifierLengthPtr--;	4706	this.identifierLengthPtr--;
4501	//type	4707	//type
4502	md.returnType = getTypeReference(this.intStack[this.intPtr--]);	4708	md.returnType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
4503		4709
4504	// consume type parameters	4710	// consume type parameters
4505	int length = this.genericsLengthStack[this.genericsLengthPtr--];	4711	int length = this.genericsLengthStack[this.genericsLengthPtr--];
Lines 4721-4726 Link Here
4721	protected void consumeModifiers2() {	4927	protected void consumeModifiers2() {
4722	this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];	4928	this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];
4723	}	4929	}
		4930
		4931	protected void consumeOneMoreTypeAnnotation() {
		4932	// OneOrMoreAnnotations ::= OneOrMoreAnnotations Annotation
		4933	this.expressionLengthPtr --;
		4934	Annotation annotation = (Annotation) this.expressionStack[this.expressionPtr--];
		4935	pushOnTypeAnnotationStack(annotation);
		4936	this.typeAnnotationLengthStack[--this.typeAnnotationLengthPtr]++;
		4937	if(!this.statementRecoveryActivated &&
		4938	this.options.sourceLevel < ClassFileConstants.JDK1_7 &&
		4939	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		4940	problemReporter().invalidUsageOfTypeAnnotations(annotation);
		4941	}
		4942	}
		4943
		4944	protected void consumePotentialNameArrayType () {
		4945
		4946	// FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray VariableDeclaratorId
		4947	// FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray '...' VariableDeclaratorId
		4948	// PotentialNameArray -> $empty
		4949	// Dimensions including lack of have been pushed appropriately by action attached to DimsoptAnnotsopt
		4950	pushOnGenericsLengthStack(0); // handle type arguments
		4951	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
		4952	}
		4953
4724	protected void consumeNameArrayType() {	4954	protected void consumeNameArrayType() {
4725	pushOnGenericsLengthStack(0); // handle type arguments	4955	pushOnGenericsLengthStack(0); // handle type arguments
4726	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	4956	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
Lines 4784-4792 Link Here
4784	}	5014	}
4785	this.recordStringLiterals = true;	5015	this.recordStringLiterals = true;
4786	}	5016	}
4787	protected void consumeOneDimLoop() {	5017	protected void consumeOneDimLoop(boolean expressionStackMayHaveAnnotations) {
4788	// OneDimLoop ::= '[' ']'	5018	// OneDimLoop ::= '[' ']'
		5019	// OneDimOrAnnot -> '[' ']'
4789	this.dimensions++;	5020	this.dimensions++;
		5021	if (!expressionStackMayHaveAnnotations \|\| this.unattachedAnnotationPtr == -1 ) {
		5022	pushOnTypeAnnotationLengthStack(0); // no annotations for the current dimension.
		5023	} else {
		5024	this.unattachedAnnotationPtr = -1; // Leave type annotation stacks they are.
		5025	}
		5026	}
		5027	protected void consumeOneDimLoopWithAnnotations() {
		5028	// OneDimLoop ::= OneOrMoreAnnotations '[' ']'
		5029	this.dimensions++;
		5030	// Top of expression stack contains annotations of length specified
		5031	// by top of expression length stack that apply to this dimension.
4790	}	5032	}
4791	protected void consumeOnlySynchronized() {	5033	protected void consumeOnlySynchronized() {
4792	// OnlySynchronized ::= 'synchronized'	5034	// OnlySynchronized ::= 'synchronized'
Lines 4956-4962 Link Here
4956	pushOnGenericsLengthStack(0);	5198	pushOnGenericsLengthStack(0);
4957		5199
4958	pushOnExpressionStack(	5200	pushOnExpressionStack(
4959	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));	5201	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(this.intStack[this.intPtr--])));
4960	}	5202	}
4961	protected void consumePrimaryNoNewArrayName() {	5203	protected void consumePrimaryNoNewArrayName() {
4962	// PrimaryNoNewArray ::= Name '.' 'class'	5204	// PrimaryNoNewArray ::= Name '.' 'class'
Lines 4965-4971 Link Here
4965	// handle type arguments	5207	// handle type arguments
4966	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	5208	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4967	pushOnGenericsLengthStack(0);	5209	pushOnGenericsLengthStack(0);
4968	TypeReference typeReference = getTypeReference(0);	5210	TypeReference typeReference = getUnannotatedTypeReference(0); // TODO (Srikanth) needs fix
4969		5211
4970	pushOnExpressionStack(	5212	pushOnExpressionStack(
4971	new ClassLiteralAccess(this.intStack[this.intPtr--], typeReference));	5213	new ClassLiteralAccess(this.intStack[this.intPtr--], typeReference));
Lines 4975-4981 Link Here
4975	// handle type arguments	5217	// handle type arguments
4976	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	5218	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4977	pushOnGenericsLengthStack(0);	5219	pushOnGenericsLengthStack(0);
4978	TypeReference typeReference = getTypeReference(0);	5220	TypeReference typeReference = getUnannotatedTypeReference(0);
4979		5221
4980	pushOnExpressionStack(	5222	pushOnExpressionStack(
4981	new QualifiedSuperReference(	5223	new QualifiedSuperReference(
Lines 4989-4995 Link Here
4989	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	5231	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4990	pushOnGenericsLengthStack(0); // handle type arguments	5232	pushOnGenericsLengthStack(0); // handle type arguments
4991		5233
4992	TypeReference typeReference = getTypeReference(0);	5234	TypeReference typeReference = getUnannotatedTypeReference(0); // javac complains on annotations here.
4993		5235
4994	pushOnExpressionStack(	5236	pushOnExpressionStack(
4995	new QualifiedThisReference(	5237	new QualifiedThisReference(
Lines 5001-5013 Link Here
5001	// PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class'	5243	// PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class'
5002	this.intPtr--; // remove the class start position	5244	this.intPtr--; // remove the class start position
5003	pushOnExpressionStack(	5245	pushOnExpressionStack(
5004	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));	5246	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(this.intStack[this.intPtr--])));
5005	}	5247	}
5006	protected void consumePrimaryNoNewArrayPrimitiveType() {	5248	protected void consumePrimaryNoNewArrayPrimitiveType() {
5007	// PrimaryNoNewArray ::= PrimitiveType '.' 'class'	5249	// PrimaryNoNewArray ::= PrimitiveType '.' 'class'
5008	this.intPtr--; // remove the class start position	5250	this.intPtr--; // remove the class start position
5009	pushOnExpressionStack(	5251	pushOnExpressionStack(
5010	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(0)));	5252	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(0)));
5011	}	5253	}
5012	protected void consumePrimaryNoNewArrayThis() {	5254	protected void consumePrimaryNoNewArrayThis() {
5013	// PrimaryNoNewArray ::= 'this'	5255	// PrimaryNoNewArray ::= 'this'
Lines 5077-5083 Link Here
5077	}	5319	}
5078	consumeMethodHeaderName(isAnnotationMethod);	5320	consumeMethodHeaderName(isAnnotationMethod);
5079	}	5321	}
5080	protected void consumeRecoveryMethodHeaderNameWithTypeParameters() {	5322	protected void consumeRecoveryMethodHeaderNameWithTypeParameters(boolean hasTypeAnnotations) {
5081	// this method is call only inside recovery	5323	// this method is call only inside recovery
5082	boolean isAnnotationMethod = false;	5324	boolean isAnnotationMethod = false;
5083	if(this.currentElement instanceof RecoveredType) {	5325	if(this.currentElement instanceof RecoveredType) {
Lines 5088-5094 Link Here
5088	isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;	5330	isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;
5089	}	5331	}
5090	}	5332	}
5091	consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);	5333	consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod, hasTypeAnnotations);
5092	}	5334	}
5093	protected void consumeReduceImports() {	5335	protected void consumeReduceImports() {
5094	// Consume imports	5336	// Consume imports
Lines 5106-5119 Link Here
5106	protected void consumeReferenceType() {	5348	protected void consumeReferenceType() {
5107	pushOnIntStack(0); // handle array type	5349	pushOnIntStack(0); // handle array type
5108	}	5350	}
5109	protected void consumeReferenceType1() {	5351	protected void consumeReferenceType1(boolean hasTypeAnnotations) {
5110	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	5352	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
5111	}	5353	}
5112	protected void consumeReferenceType2() {	5354	protected void consumeReferenceType2(boolean hasTypeAnnotations) {
5113	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	5355	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
5114	}	5356	}
5115	protected void consumeReferenceType3() {	5357	protected void consumeReferenceType3(boolean hasTypeAnnotations) {
5116	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	5358	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
5117	}	5359	}
5118	protected void consumeRestoreDiet() {	5360	protected void consumeRestoreDiet() {
5119	// RestoreDiet ::= $empty	5361	// RestoreDiet ::= $empty
Lines 5138-6811 Link Here
5138	consumeClassOrInterfaceName();	5380	consumeClassOrInterfaceName();
5139	break;	5381	break;
5140		5382
5141	case 49 : if (DEBUG) { System.out.println("ClassOrInterface ::= GenericType DOT Name"); } //$NON-NLS-1$
5142	consumeClassOrInterface();
5143	break;
5144
5145	case 50 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); } //$NON-NLS-1$	5383	case 50 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); } //$NON-NLS-1$
5146	consumeGenericType();	5384	consumeGenericType();
5147	break;	5385	break;
5148		5386
5149	case 51 : if (DEBUG) { System.out.println("ArrayTypeWithTypeArgumentsName ::= GenericType DOT Name"); } //$NON-NLS-1$	5387	case 51 : if (DEBUG) { System.out.println("GenericTypeDotName ::= GenericType DOT Name"); } //$NON-NLS-1$
5150	consumeArrayTypeWithTypeArgumentsName();	5388	consumeClassOrInterface();
5151	break;	5389	break;
5152		5390
5153	case 52 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); } //$NON-NLS-1$	5391	case 53 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); } //$NON-NLS-1$
5154	consumePrimitiveArrayType();	5392	consumePrimitiveArrayType();
5155	break;	5393	break;
5156		5394
5157	case 53 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); } //$NON-NLS-1$	5395	case 54 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); } //$NON-NLS-1$
5158	consumeNameArrayType();	5396	consumeNameArrayType();
5159	break;	5397	break;
5160		5398
5161	case 54 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); } //$NON-NLS-1$	5399	case 55 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); } //$NON-NLS-1$
5162	consumeGenericTypeNameArrayType();	5400	consumeGenericTypeNameArrayType();
5163	break;	5401	break;
5164		5402
5165	case 55 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); } //$NON-NLS-1$	5403	case 56 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); } //$NON-NLS-1$
5166	consumeGenericTypeArrayType();	5404	consumeGenericTypeArrayType();
5167	break;	5405	break;
5168		5406
5169	case 60 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); } //$NON-NLS-1$	5407	case 57 : if (DEBUG) { System.out.println("ClassType ::= ClassOrInterfaceType"); } //$NON-NLS-1$
		5408	consumeZeroTypeAnnotations();
		5409	break;
		5410
		5411	case 62 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); } //$NON-NLS-1$
5170	consumeQualifiedName();	5412	consumeQualifiedName();
5171	break;	5413	break;
5172		5414
5173	case 61 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$	5415	case 63 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$
5174	consumeCompilationUnit();	5416	consumeCompilationUnit();
5175	break;	5417	break;
5176		5418
5177	case 62 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); } //$NON-NLS-1$	5419	case 64 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); } //$NON-NLS-1$
5178	consumeInternalCompilationUnit();	5420	consumeInternalCompilationUnit();
5179	break;	5421	break;
5180		5422
5181	case 63 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5423	case 65 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5182	consumeInternalCompilationUnit();	5424	consumeInternalCompilationUnit();
5183	break;	5425	break;
5184		5426
5185	case 64 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5427	case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5186	consumeInternalCompilationUnitWithTypes();	5428	consumeInternalCompilationUnitWithTypes();
5187	break;	5429	break;
5188		5430
5189	case 65 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5431	case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5190	consumeInternalCompilationUnitWithTypes();	5432	consumeInternalCompilationUnitWithTypes();
5191	break;	5433	break;
5192		5434
5193	case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$	5435	case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$
5194	consumeInternalCompilationUnit();	5436	consumeInternalCompilationUnit();
5195	break;	5437	break;
5196		5438
5197	case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); } //$NON-NLS-1$	5439	case 69 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); } //$NON-NLS-1$
5198	consumeInternalCompilationUnitWithTypes();	5440	consumeInternalCompilationUnitWithTypes();
5199	break;	5441	break;
5200		5442
5201	case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$	5443	case 70 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$
5202	consumeInternalCompilationUnitWithTypes();	5444	consumeInternalCompilationUnitWithTypes();
5203	break;	5445	break;
5204		5446
5205	case 69 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$	5447	case 71 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$
5206	consumeEmptyInternalCompilationUnit();	5448	consumeEmptyInternalCompilationUnit();
5207	break;	5449	break;
5208		5450
5209	case 70 : if (DEBUG) { System.out.println("ReduceImports ::="); } //$NON-NLS-1$	5451	case 72 : if (DEBUG) { System.out.println("ReduceImports ::="); } //$NON-NLS-1$
5210	consumeReduceImports();	5452	consumeReduceImports();
5211	break;	5453	break;
5212		5454
5213	case 71 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$	5455	case 73 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$
5214	consumeEnterCompilationUnit();	5456	consumeEnterCompilationUnit();
5215	break;	5457	break;
5216		5458
5217	case 87 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$	5459	case 89 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
5218	consumeCatchHeader();	5460	consumeCatchHeader();
5219	break;	5461	break;
5220		5462
5221	case 89 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); } //$NON-NLS-1$	5463	case 91 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); } //$NON-NLS-1$
5222	consumeImportDeclarations();	5464	consumeImportDeclarations();
5223	break;	5465	break;
5224		5466
5225	case 91 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); } //$NON-NLS-1$	5467	case 93 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); } //$NON-NLS-1$
5226	consumeTypeDeclarations();	5468	consumeTypeDeclarations();
5227	break;	5469	break;
5228		5470
5229	case 92 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); } //$NON-NLS-1$	5471	case 94 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); } //$NON-NLS-1$
5230	consumePackageDeclaration();	5472	consumePackageDeclaration();
5231	break;	5473	break;
5232		5474
5233	case 93 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); } //$NON-NLS-1$	5475	case 95 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); } //$NON-NLS-1$
5234	consumePackageDeclarationNameWithModifiers();	5476	consumePackageDeclarationNameWithModifiers();
5235	break;	5477	break;
5236		5478
5237	case 94 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); } //$NON-NLS-1$	5479	case 96 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); } //$NON-NLS-1$
5238	consumePackageDeclarationName();	5480	consumePackageDeclarationName();
5239	break;	5481	break;
5240		5482
5241	case 95 : if (DEBUG) { System.out.println("PackageComment ::="); } //$NON-NLS-1$	5483	case 97 : if (DEBUG) { System.out.println("PackageComment ::="); } //$NON-NLS-1$
5242	consumePackageComment();	5484	consumePackageComment();
5243	break;	5485	break;
5244		5486
5245	case 100 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); } //$NON-NLS-1$	5487	case 102 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); } //$NON-NLS-1$
5246	consumeImportDeclaration();	5488	consumeImportDeclaration();
5247	break;	5489	break;
5248		5490
5249	case 101 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); } //$NON-NLS-1$	5491	case 103 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); } //$NON-NLS-1$
5250	consumeSingleTypeImportDeclarationName();	5492	consumeSingleTypeImportDeclarationName();
5251	break;	5493	break;
5252		5494
5253	case 102 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$	5495	case 104 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$
5254	consumeImportDeclaration();	5496	consumeImportDeclaration();
5255	break;	5497	break;
5256		5498
5257	case 103 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); } //$NON-NLS-1$	5499	case 105 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); } //$NON-NLS-1$
5258	consumeTypeImportOnDemandDeclarationName();	5500	consumeTypeImportOnDemandDeclarationName();
5259	break;	5501	break;
5260		5502
5261	case 106 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5503	case 108 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5262	consumeEmptyTypeDeclaration();	5504	consumeEmptyTypeDeclaration();
5263	break;	5505	break;
5264		5506
5265	case 110 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); } //$NON-NLS-1$	5507	case 112 : if (DEBUG) { System.out.println("NonAnnotModifiers ::= NonAnnotModifiers NonAnnotModifier"); } //$NON-NLS-1$
5266	consumeModifiers2();	5508	consumeModifiers2();
5267	break;	5509	break;
5268		5510
5269	case 122 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); } //$NON-NLS-1$	5511	case 114 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); } //$NON-NLS-1$
		5512	consumeModifiers2();
		5513	break;
		5514
		5515	case 137 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); } //$NON-NLS-1$
5270	consumeAnnotationAsModifier();	5516	consumeAnnotationAsModifier();
5271	break;	5517	break;
5272		5518
5273	case 123 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); } //$NON-NLS-1$	5519	case 138 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); } //$NON-NLS-1$
5274	consumeClassDeclaration();	5520	consumeClassDeclaration();
5275	break;	5521	break;
5276		5522
5277	case 124 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); } //$NON-NLS-1$	5523	case 139 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); } //$NON-NLS-1$
5278	consumeClassHeader();	5524	consumeClassHeader();
5279	break;	5525	break;
5280		5526
5281	case 125 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); } //$NON-NLS-1$	5527	case 140 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); } //$NON-NLS-1$
5282	consumeTypeHeaderNameWithTypeParameters();	5528	consumeTypeHeaderNameWithTypeParameters();
5283	break;	5529	break;
5284		5530
5285	case 127 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); } //$NON-NLS-1$	5531	case 142 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); } //$NON-NLS-1$
5286	consumeClassHeaderName1();	5532	consumeClassHeaderName1();
5287	break;	5533	break;
5288		5534
5289	case 128 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); } //$NON-NLS-1$	5535	case 143 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); } //$NON-NLS-1$
5290	consumeClassHeaderExtends();	5536	consumeClassHeaderExtends();
5291	break;	5537	break;
5292		5538
5293	case 129 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); } //$NON-NLS-1$	5539	case 144 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); } //$NON-NLS-1$
5294	consumeClassHeaderImplements();	5540	consumeClassHeaderImplements();
5295	break;	5541	break;
5296		5542
5297	case 131 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); } //$NON-NLS-1$	5543	case 146 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); } //$NON-NLS-1$
5298	consumeInterfaceTypeList();	5544	consumeInterfaceTypeList();
5299	break;	5545	break;
5300		5546
5301	case 132 : if (DEBUG) { System.out.println("InterfaceType ::= ClassOrInterfaceType"); } //$NON-NLS-1$	5547	case 147 : if (DEBUG) { System.out.println("InterfaceType ::= PushZeroTypeAnnotations..."); } //$NON-NLS-1$
		5548	consumeInterfaceType();
		5549	break;
		5550
		5551	case 148 : if (DEBUG) { System.out.println("InterfaceType ::= OneOrMoreAnnotations..."); } //$NON-NLS-1$
5302	consumeInterfaceType();	5552	consumeInterfaceType();
5303	break;	5553	break;
5304		5554
5305	case 135 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); } //$NON-NLS-1$	5555	case 151 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); } //$NON-NLS-1$
5306	consumeClassBodyDeclarations();	5556	consumeClassBodyDeclarations();
5307	break;	5557	break;
5308		5558
5309	case 139 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); } //$NON-NLS-1$	5559	case 155 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); } //$NON-NLS-1$
5310	consumeClassBodyDeclaration();	5560	consumeClassBodyDeclaration();
5311	break;	5561	break;
5312		5562
5313	case 140 : if (DEBUG) { System.out.println("Diet ::="); } //$NON-NLS-1$	5563	case 156 : if (DEBUG) { System.out.println("Diet ::="); } //$NON-NLS-1$
5314	consumeDiet();	5564	consumeDiet();
5315	break;	5565	break;
5316		5566
5317	case 141 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); } //$NON-NLS-1$	5567	case 157 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); } //$NON-NLS-1$
5318	consumeClassBodyDeclaration();	5568	consumeClassBodyDeclaration();
5319	break;	5569	break;
5320		5570
5321	case 142 : if (DEBUG) { System.out.println("CreateInitializer ::="); } //$NON-NLS-1$	5571	case 158 : if (DEBUG) { System.out.println("CreateInitializer ::="); } //$NON-NLS-1$
5322	consumeCreateInitializer();	5572	consumeCreateInitializer();
5323	break;	5573	break;
5324		5574
5325	case 149 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5575	case 165 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5326	consumeEmptyTypeDeclaration();	5576	consumeEmptyTypeDeclaration();
5327	break;	5577	break;
5328		5578
5329	case 152 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type..."); } //$NON-NLS-1$	5579	case 168 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type..."); } //$NON-NLS-1$
5330	consumeFieldDeclaration();	5580	consumeFieldDeclaration();
5331	break;	5581	break;
5332		5582
5333	case 154 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$	5583	case 170 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$
5334	consumeVariableDeclarators();	5584	consumeVariableDeclarators();
5335	break;	5585	break;
5336		5586
5337	case 157 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$	5587	case 173 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$
5338	consumeEnterVariable();	5588	consumeEnterVariable();
5339	break;	5589	break;
5340		5590
5341	case 158 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$	5591	case 174 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$
5342	consumeExitVariableWithInitialization();	5592	consumeExitVariableWithInitialization();
5343	break;	5593	break;
5344		5594
5345	case 159 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$	5595	case 175 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$
5346	consumeExitVariableWithoutInitialization();	5596	consumeExitVariableWithoutInitialization();
5347	break;	5597	break;
5348		5598
5349	case 160 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$	5599	case 176 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$
5350	consumeForceNoDiet();	5600	consumeForceNoDiet();
5351	break;	5601	break;
5352		5602
5353	case 161 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$	5603	case 177 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$
5354	consumeRestoreDiet();	5604	consumeRestoreDiet();
5355	break;	5605	break;
5356		5606
5357	case 166 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$	5607	case 182 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$
5358	// set to true to consume a method with a body	5608	// set to true to consume a method with a body
5359	consumeMethodDeclaration(true);	5609	consumeMethodDeclaration(true);
5360	break;	5610	break;
5361		5611
5362	case 167 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$	5612	case 183 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$
5363	// set to false to consume a method without body	5613	// set to false to consume a method without body
5364	consumeMethodDeclaration(false);	5614	consumeMethodDeclaration(false);
5365	break;	5615	break;
5366		5616
5367	case 168 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$	5617	case 184 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$
5368	consumeMethodHeader();	5618	consumeMethodHeader();
5369	break;	5619	break;
5370		5620
5371	case 169 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); } //$NON-NLS-1$	5621	case 185 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); } //$NON-NLS-1$
5372	consumeMethodHeaderNameWithTypeParameters(false);	5622	consumeMethodHeaderNameWithTypeParameters(false, false);
		5623	break;
		5624
		5625	case 186 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$
		5626	consumeMethodHeaderNameWithTypeParameters(false, true);
5373	break;	5627	break;
5374		5628
5375	case 170 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); } //$NON-NLS-1$	5629	case 187 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); } //$NON-NLS-1$
5376	consumeMethodHeaderName(false);	5630	consumeMethodHeaderName(false);
5377	break;	5631	break;
5378		5632
5379	case 171 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$	5633	case 188 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$
5380	consumeMethodHeaderRightParen();	5634	consumeMethodHeaderRightParen();
5381	break;	5635	break;
5382		5636
5383	case 172 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= Dimsopt"); } //$NON-NLS-1$	5637	case 189 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= DimsoptAnnotsopt"); } //$NON-NLS-1$
5384	consumeMethodHeaderExtendedDims();	5638	consumeMethodHeaderExtendedDims();
5385	break;	5639	break;
5386		5640
5387	case 173 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); } //$NON-NLS-1$	5641	case 190 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); } //$NON-NLS-1$
5388	consumeMethodHeaderThrowsClause();	5642	consumeMethodHeaderThrowsClause();
5389	break;	5643	break;
5390		5644
5391	case 174 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$	5645	case 191 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$
5392	consumeConstructorHeader();	5646	consumeConstructorHeader();
5393	break;	5647	break;
5394		5648
5395	case 175 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$	5649	case 192 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$
		5650	consumeConstructorHeader();
		5651	break;
		5652
		5653	case 193 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$
5396	consumeConstructorHeaderNameWithTypeParameters();	5654	consumeConstructorHeaderNameWithTypeParameters();
5397	break;	5655	break;
5398		5656
5399	case 176 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); } //$NON-NLS-1$	5657	case 194 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); } //$NON-NLS-1$
5400	consumeConstructorHeaderName();	5658	consumeConstructorHeaderName();
5401	break;	5659	break;
5402		5660
5403	case 178 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$	5661	case 196 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$
5404	consumeFormalParameterList();	5662	consumeFormalParameterList();
5405	break;	5663	break;
5406		5664
5407	case 179 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type..."); } //$NON-NLS-1$	5665	case 197 : if (DEBUG) { System.out.println("PotentialNameArray ::="); } //$NON-NLS-1$
		5666	consumePotentialNameArrayType();
		5667	break;
		5668
		5669	case 198 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); } //$NON-NLS-1$
		5670	consumeFormalParameter(false);
		5671	break;
		5672
		5673	case 199 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); } //$NON-NLS-1$
		5674	consumeFormalParameter(true);
		5675	break;
		5676
		5677	case 200 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); } //$NON-NLS-1$
5408	consumeFormalParameter(false);	5678	consumeFormalParameter(false);
5409	break;	5679	break;
5410		5680
5411	case 180 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type ELLIPSIS..."); } //$NON-NLS-1$	5681	case 201 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); } //$NON-NLS-1$
5412	consumeFormalParameter(true);	5682	consumeFormalParameter(true);
5413	break;	5683	break;
5414		5684
5415	case 182 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); } //$NON-NLS-1$	5685	case 202 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); } //$NON-NLS-1$
		5686	consumeFormalParameter(false);
		5687	break;
		5688
		5689	case 203 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); } //$NON-NLS-1$
		5690	consumeFormalParameter(true);
		5691	break;
		5692
		5693	case 204 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); } //$NON-NLS-1$
		5694	consumeFormalParameter(false);
		5695	break;
		5696
		5697	case 205 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); } //$NON-NLS-1$
		5698	consumeFormalParameter(true);
		5699	break;
		5700
		5701	case 207 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); } //$NON-NLS-1$
5416	consumeClassTypeList();	5702	consumeClassTypeList();
5417	break;	5703	break;
5418		5704
5419	case 183 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); } //$NON-NLS-1$	5705	case 208 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); } //$NON-NLS-1$
5420	consumeClassTypeElt();	5706	consumeClassTypeElt();
5421	break;	5707	break;
5422		5708
5423	case 184 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); } //$NON-NLS-1$	5709	case 209 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); } //$NON-NLS-1$
5424	consumeMethodBody();	5710	consumeMethodBody();
5425	break;	5711	break;
5426		5712
5427	case 185 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$	5713	case 210 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$
5428	consumeNestedMethod();	5714	consumeNestedMethod();
5429	break;	5715	break;
5430		5716
5431	case 186 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); } //$NON-NLS-1$	5717	case 211 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); } //$NON-NLS-1$
5432	consumeStaticInitializer();	5718	consumeStaticInitializer();
5433	break;	5719	break;
5434		5720
5435	case 187 : if (DEBUG) { System.out.println("StaticOnly ::= static"); } //$NON-NLS-1$	5721	case 212 : if (DEBUG) { System.out.println("StaticOnly ::= static"); } //$NON-NLS-1$
5436	consumeStaticOnly();	5722	consumeStaticOnly();
5437	break;	5723	break;
5438		5724
5439	case 188 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); } //$NON-NLS-1$	5725	case 213 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); } //$NON-NLS-1$
5440	consumeConstructorDeclaration() ;	5726	consumeConstructorDeclaration() ;
5441	break;	5727	break;
5442		5728
5443	case 189 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); } //$NON-NLS-1$	5729	case 214 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); } //$NON-NLS-1$
5444	consumeInvalidConstructorDeclaration() ;	5730	consumeInvalidConstructorDeclaration() ;
5445	break;	5731	break;
5446		5732
5447	case 190 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); } //$NON-NLS-1$	5733	case 215 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); } //$NON-NLS-1$
5448	consumeExplicitConstructorInvocation(0, THIS_CALL);	5734	consumeExplicitConstructorInvocation(0, THIS_CALL);
5449	break;	5735	break;
5450		5736
5451	case 191 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); } //$NON-NLS-1$	5737	case 216 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); } //$NON-NLS-1$
5452	consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);	5738	consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);
5453	break;	5739	break;
5454		5740
5455	case 192 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); } //$NON-NLS-1$	5741	case 217 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); } //$NON-NLS-1$
5456	consumeExplicitConstructorInvocation(0,SUPER_CALL);	5742	consumeExplicitConstructorInvocation(0,SUPER_CALL);
5457	break;	5743	break;
5458		5744
5459	case 193 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); } //$NON-NLS-1$	5745	case 218 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); } //$NON-NLS-1$
5460	consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);	5746	consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);
5461	break;	5747	break;
5462		5748
5463	case 194 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); } //$NON-NLS-1$	5749	case 219 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); } //$NON-NLS-1$
5464	consumeExplicitConstructorInvocation(1, SUPER_CALL);	5750	consumeExplicitConstructorInvocation(1, SUPER_CALL);
5465	break;	5751	break;
5466		5752
5467	case 195 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$	5753	case 220 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$
5468	consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);	5754	consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);
5469	break;	5755	break;
5470		5756
5471	case 196 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); } //$NON-NLS-1$	5757	case 221 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); } //$NON-NLS-1$
5472	consumeExplicitConstructorInvocation(2, SUPER_CALL);	5758	consumeExplicitConstructorInvocation(2, SUPER_CALL);
5473	break;	5759	break;
5474		5760
5475	case 197 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$	5761	case 222 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$
5476	consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);	5762	consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);
5477	break;	5763	break;
5478		5764
5479	case 198 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); } //$NON-NLS-1$	5765	case 223 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); } //$NON-NLS-1$
5480	consumeExplicitConstructorInvocation(1, THIS_CALL);	5766	consumeExplicitConstructorInvocation(1, THIS_CALL);
5481	break;	5767	break;
5482		5768
5483	case 199 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$	5769	case 224 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$
5484	consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);	5770	consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);
5485	break;	5771	break;
5486		5772
5487	case 200 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); } //$NON-NLS-1$	5773	case 225 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); } //$NON-NLS-1$
5488	consumeExplicitConstructorInvocation(2, THIS_CALL);	5774	consumeExplicitConstructorInvocation(2, THIS_CALL);
5489	break;	5775	break;
5490		5776
5491	case 201 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$	5777	case 226 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$
5492	consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);	5778	consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);
5493	break;	5779	break;
5494		5780
5495	case 202 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); } //$NON-NLS-1$	5781	case 227 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); } //$NON-NLS-1$
5496	consumeInterfaceDeclaration();	5782	consumeInterfaceDeclaration();
5497	break;	5783	break;
5498		5784
5499	case 203 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); } //$NON-NLS-1$	5785	case 228 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); } //$NON-NLS-1$
5500	consumeInterfaceHeader();	5786	consumeInterfaceHeader();
5501	break;	5787	break;
5502		5788
5503	case 204 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); } //$NON-NLS-1$	5789	case 229 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); } //$NON-NLS-1$
5504	consumeTypeHeaderNameWithTypeParameters();	5790	consumeTypeHeaderNameWithTypeParameters();
5505	break;	5791	break;
5506		5792
5507	case 206 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); } //$NON-NLS-1$	5793	case 231 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); } //$NON-NLS-1$
5508	consumeInterfaceHeaderName1();	5794	consumeInterfaceHeaderName1();
5509	break;	5795	break;
5510		5796
5511	case 207 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); } //$NON-NLS-1$	5797	case 232 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); } //$NON-NLS-1$
5512	consumeInterfaceHeaderExtends();	5798	consumeInterfaceHeaderExtends();
5513	break;	5799	break;
5514		5800
5515	case 210 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); } //$NON-NLS-1$	5801	case 235 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); } //$NON-NLS-1$
5516	consumeInterfaceMemberDeclarations();	5802	consumeInterfaceMemberDeclarations();
5517	break;	5803	break;
5518		5804
5519	case 211 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5805	case 236 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5520	consumeEmptyTypeDeclaration();	5806	consumeEmptyTypeDeclaration();
5521	break;	5807	break;
5522		5808
5523	case 213 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$	5809	case 238 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$
5524	consumeInvalidMethodDeclaration();	5810	consumeInvalidMethodDeclaration();
5525	break;	5811	break;
5526		5812
5527	case 214 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$	5813	case 239 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$
5528	consumeInvalidConstructorDeclaration(true);	5814	consumeInvalidConstructorDeclaration(true);
5529	break;	5815	break;
5530		5816
5531	case 215 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$	5817	case 240 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$
5532	consumeInvalidConstructorDeclaration(false);	5818	consumeInvalidConstructorDeclaration(false);
5533	break;	5819	break;
5534		5820
5535	case 223 : if (DEBUG) { System.out.println("PushLeftBrace ::="); } //$NON-NLS-1$	5821	case 248 : if (DEBUG) { System.out.println("PushLeftBrace ::="); } //$NON-NLS-1$
5536	consumePushLeftBrace();	5822	consumePushLeftBrace();
5537	break;	5823	break;
5538		5824
5539	case 224 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); } //$NON-NLS-1$	5825	case 249 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); } //$NON-NLS-1$
5540	consumeEmptyArrayInitializer();	5826	consumeEmptyArrayInitializer();
5541	break;	5827	break;
5542		5828
5543	case 225 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$	5829	case 250 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$
5544	consumeArrayInitializer();	5830	consumeArrayInitializer();
5545	break;	5831	break;
5546		5832
5547	case 226 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$	5833	case 251 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$
5548	consumeArrayInitializer();	5834	consumeArrayInitializer();
5549	break;	5835	break;
5550		5836
5551	case 228 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); } //$NON-NLS-1$	5837	case 253 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); } //$NON-NLS-1$
5552	consumeVariableInitializers();	5838	consumeVariableInitializers();
5553	break;	5839	break;
5554		5840
5555	case 229 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$	5841	case 254 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$
5556	consumeBlock();	5842	consumeBlock();
5557	break;	5843	break;
5558		5844
5559	case 230 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$	5845	case 255 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$
5560	consumeOpenBlock() ;	5846	consumeOpenBlock() ;
5561	break;	5847	break;
5562		5848
5563	case 232 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$	5849	case 257 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$
5564	consumeBlockStatements() ;	5850	consumeBlockStatements() ;
5565	break;	5851	break;
5566		5852
5567	case 236 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); } //$NON-NLS-1$	5853	case 261 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); } //$NON-NLS-1$
5568	consumeInvalidInterfaceDeclaration();	5854	consumeInvalidInterfaceDeclaration();
5569	break;	5855	break;
5570		5856
5571	case 237 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); } //$NON-NLS-1$	5857	case 262 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); } //$NON-NLS-1$
5572	consumeInvalidAnnotationTypeDeclaration();	5858	consumeInvalidAnnotationTypeDeclaration();
5573	break;	5859	break;
5574		5860
5575	case 238 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); } //$NON-NLS-1$	5861	case 263 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); } //$NON-NLS-1$
5576	consumeInvalidEnumDeclaration();	5862	consumeInvalidEnumDeclaration();
5577	break;	5863	break;
5578		5864
5579	case 239 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$	5865	case 264 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$
5580	consumeLocalVariableDeclarationStatement();	5866	consumeLocalVariableDeclarationStatement();
5581	break;	5867	break;
5582		5868
5583	case 240 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); } //$NON-NLS-1$	5869	case 265 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); } //$NON-NLS-1$
5584	consumeLocalVariableDeclaration();	5870	consumeLocalVariableDeclaration();
5585	break;	5871	break;
5586		5872
5587	case 241 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); } //$NON-NLS-1$	5873	case 266 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); } //$NON-NLS-1$
5588	consumeLocalVariableDeclaration();	5874	consumeLocalVariableDeclaration();
5589	break;	5875	break;
5590		5876
5591	case 242 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$	5877	case 267 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$
5592	consumePushModifiers();	5878	consumePushModifiers();
5593	break;	5879	break;
5594		5880
5595	case 243 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); } //$NON-NLS-1$	5881	case 268 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); } //$NON-NLS-1$
5596	consumePushModifiersForHeader();	5882	consumePushModifiersForHeader();
5597	break;	5883	break;
5598		5884
5599	case 244 : if (DEBUG) { System.out.println("PushRealModifiers ::="); } //$NON-NLS-1$	5885	case 269 : if (DEBUG) { System.out.println("PushRealModifiers ::="); } //$NON-NLS-1$
5600	consumePushRealModifiers();	5886	consumePushRealModifiers();
5601	break;	5887	break;
5602		5888
5603	case 270 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); } //$NON-NLS-1$	5889	case 295 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); } //$NON-NLS-1$
5604	consumeEmptyStatement();	5890	consumeEmptyStatement();
5605	break;	5891	break;
5606		5892
5607	case 271 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$	5893	case 296 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$
5608	consumeStatementLabel() ;	5894	consumeStatementLabel() ;
5609	break;	5895	break;
5610		5896
5611	case 272 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$	5897	case 297 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$
5612	consumeStatementLabel() ;	5898	consumeStatementLabel() ;
5613	break;	5899	break;
5614		5900
5615	case 273 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$	5901	case 298 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$
5616	consumeLabel() ;	5902	consumeLabel() ;
5617	break;	5903	break;
5618		5904
5619	case 274 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$	5905	case 299 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$
5620	consumeExpressionStatement();	5906	consumeExpressionStatement();
5621	break;	5907	break;
5622		5908
5623	case 283 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5909	case 308 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5624	consumeStatementIfNoElse();	5910	consumeStatementIfNoElse();
5625	break;	5911	break;
5626		5912
5627	case 284 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5913	case 309 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5628	consumeStatementIfWithElse();	5914	consumeStatementIfWithElse();
5629	break;	5915	break;
5630		5916
5631	case 285 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$	5917	case 310 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$
5632	consumeStatementIfWithElse();	5918	consumeStatementIfWithElse();
5633	break;	5919	break;
5634		5920
5635	case 286 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5921	case 311 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5636	consumeStatementSwitch() ;	5922	consumeStatementSwitch() ;
5637	break;	5923	break;
5638		5924
5639	case 287 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$	5925	case 312 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$
5640	consumeEmptySwitchBlock() ;	5926	consumeEmptySwitchBlock() ;
5641	break;	5927	break;
5642		5928
5643	case 290 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$	5929	case 315 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$
5644	consumeSwitchBlock() ;	5930	consumeSwitchBlock() ;
5645	break;	5931	break;
5646		5932
5647	case 292 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$	5933	case 317 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$
5648	consumeSwitchBlockStatements() ;	5934	consumeSwitchBlockStatements() ;
5649	break;	5935	break;
5650		5936
5651	case 293 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$	5937	case 318 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$
5652	consumeSwitchBlockStatement() ;	5938	consumeSwitchBlockStatement() ;
5653	break;	5939	break;
5654		5940
5655	case 295 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$	5941	case 320 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$
5656	consumeSwitchLabels() ;	5942	consumeSwitchLabels() ;
5657	break;	5943	break;
5658		5944
5659	case 296 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$	5945	case 321 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$
5660	consumeCaseLabel();	5946	consumeCaseLabel();
5661	break;	5947	break;
5662		5948
5663	case 297 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$	5949	case 322 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$
5664	consumeDefaultLabel();	5950	consumeDefaultLabel();
5665	break;	5951	break;
5666		5952
5667	case 298 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5953	case 323 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5668	consumeStatementWhile() ;	5954	consumeStatementWhile() ;
5669	break;	5955	break;
5670		5956
5671	case 299 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$	5957	case 324 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$
5672	consumeStatementWhile() ;	5958	consumeStatementWhile() ;
5673	break;	5959	break;
5674		5960
5675	case 300 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$	5961	case 325 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$
5676	consumeStatementDo() ;	5962	consumeStatementDo() ;
5677	break;	5963	break;
5678		5964
5679	case 301 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$	5965	case 326 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$
5680	consumeStatementFor() ;	5966	consumeStatementFor() ;
5681	break;	5967	break;
5682		5968
5683	case 302 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$	5969	case 327 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$
5684	consumeStatementFor() ;	5970	consumeStatementFor() ;
5685	break;	5971	break;
5686		5972
5687	case 303 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); } //$NON-NLS-1$	5973	case 328 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); } //$NON-NLS-1$
5688	consumeForInit() ;	5974	consumeForInit() ;
5689	break;	5975	break;
5690		5976
5691	case 307 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$	5977	case 332 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$
5692	consumeStatementExpressionList() ;	5978	consumeStatementExpressionList() ;
5693	break;	5979	break;
5694		5980
5695	case 308 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); } //$NON-NLS-1$	5981	case 333 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); } //$NON-NLS-1$
5696	consumeSimpleAssertStatement() ;	5982	consumeSimpleAssertStatement() ;
5697	break;	5983	break;
5698		5984
5699	case 309 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); } //$NON-NLS-1$	5985	case 334 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); } //$NON-NLS-1$
5700	consumeAssertStatement() ;	5986	consumeAssertStatement() ;
5701	break;	5987	break;
5702		5988
5703	case 310 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$	5989	case 335 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$
5704	consumeStatementBreak() ;	5990	consumeStatementBreak() ;
5705	break;	5991	break;
5706		5992
5707	case 311 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$	5993	case 336 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$
5708	consumeStatementBreakWithLabel() ;	5994	consumeStatementBreakWithLabel() ;
5709	break;	5995	break;
5710		5996
5711	case 312 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$	5997	case 337 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$
5712	consumeStatementContinue() ;	5998	consumeStatementContinue() ;
5713	break;	5999	break;
5714		6000
5715	case 313 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$	6001	case 338 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$
5716	consumeStatementContinueWithLabel() ;	6002	consumeStatementContinueWithLabel() ;
5717	break;	6003	break;
5718		6004
5719	case 314 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$	6005	case 339 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$
5720	consumeStatementReturn() ;	6006	consumeStatementReturn() ;
5721	break;	6007	break;
5722		6008
5723	case 315 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$	6009	case 340 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$
5724	consumeStatementThrow();	6010	consumeStatementThrow();
5725	break;	6011	break;
5726		6012
5727	case 316 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); } //$NON-NLS-1$	6013	case 341 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); } //$NON-NLS-1$
5728	consumeStatementSynchronized();	6014	consumeStatementSynchronized();
5729	break;	6015	break;
5730		6016
5731	case 317 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); } //$NON-NLS-1$	6017	case 342 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); } //$NON-NLS-1$
5732	consumeOnlySynchronized();	6018	consumeOnlySynchronized();
5733	break;	6019	break;
5734		6020
5735	case 318 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$	6021	case 343 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$
5736	consumeStatementTry(false);	6022	consumeStatementTry(false);
5737	break;	6023	break;
5738		6024
5739	case 319 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$	6025	case 344 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$
5740	consumeStatementTry(true);	6026	consumeStatementTry(true);
5741	break;	6027	break;
5742		6028
5743	case 321 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$	6029	case 346 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$
5744	consumeExitTryBlock();	6030	consumeExitTryBlock();
5745	break;	6031	break;
5746		6032
5747	case 323 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$	6033	case 348 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$
5748	consumeCatches();	6034	consumeCatches();
5749	break;	6035	break;
5750		6036
5751	case 324 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$	6037	case 349 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
5752	consumeStatementCatch() ;	6038	consumeStatementCatch() ;
5753	break;	6039	break;
5754		6040
5755	case 326 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$	6041	case 351 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$
5756	consumeLeftParen();	6042	consumeLeftParen();
5757	break;	6043	break;
5758		6044
5759	case 327 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$	6045	case 352 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$
5760	consumeRightParen();	6046	consumeRightParen();
5761	break;	6047	break;
5762		6048
5763	case 332 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$	6049	case 357 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$
5764	consumePrimaryNoNewArrayThis();	6050	consumePrimaryNoNewArrayThis();
5765	break;	6051	break;
5766		6052
5767	case 333 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); } //$NON-NLS-1$	6053	case 358 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); } //$NON-NLS-1$
5768	consumePrimaryNoNewArray();	6054	consumePrimaryNoNewArray();
5769	break;	6055	break;
5770		6056
5771	case 334 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); } //$NON-NLS-1$	6057	case 359 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); } //$NON-NLS-1$
5772	consumePrimaryNoNewArrayWithName();	6058	consumePrimaryNoNewArrayWithName();
5773	break;	6059	break;
5774		6060
5775	case 337 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); } //$NON-NLS-1$	6061	case 362 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); } //$NON-NLS-1$
5776	consumePrimaryNoNewArrayNameThis();	6062	consumePrimaryNoNewArrayNameThis();
5777	break;	6063	break;
5778		6064
5779	case 338 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); } //$NON-NLS-1$	6065	case 363 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); } //$NON-NLS-1$
5780	consumePrimaryNoNewArrayNameSuper();	6066	consumePrimaryNoNewArrayNameSuper();
5781	break;	6067	break;
5782		6068
5783	case 339 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); } //$NON-NLS-1$	6069	case 364 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); } //$NON-NLS-1$
5784	consumePrimaryNoNewArrayName();	6070	consumePrimaryNoNewArrayName();
5785	break;	6071	break;
5786		6072
5787	case 340 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); } //$NON-NLS-1$	6073	case 365 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); } //$NON-NLS-1$
5788	consumePrimaryNoNewArrayArrayType();	6074	consumePrimaryNoNewArrayArrayType();
5789	break;	6075	break;
5790		6076
5791	case 341 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); } //$NON-NLS-1$	6077	case 366 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); } //$NON-NLS-1$
5792	consumePrimaryNoNewArrayPrimitiveArrayType();	6078	consumePrimaryNoNewArrayPrimitiveArrayType();
5793	break;	6079	break;
5794		6080
5795	case 342 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); } //$NON-NLS-1$	6081	case 367 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); } //$NON-NLS-1$
5796	consumePrimaryNoNewArrayPrimitiveType();	6082	consumePrimaryNoNewArrayPrimitiveType();
5797	break;	6083	break;
5798		6084
5799	case 345 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); } //$NON-NLS-1$	6085	case 370 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); } //$NON-NLS-1$
5800	consumeAllocationHeader();	6086	consumeAllocationHeader();
5801	break;	6087	break;
5802		6088
5803	case 346 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); } //$NON-NLS-1$	6089	case 371 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); } //$NON-NLS-1$
5804	consumeClassInstanceCreationExpressionWithTypeArguments();	6090	consumeClassInstanceCreationExpressionWithTypeArguments();
5805	break;	6091	break;
5806		6092
5807	case 347 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); } //$NON-NLS-1$	6093	case 372 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); } //$NON-NLS-1$
5808	consumeClassInstanceCreationExpression();	6094	consumeClassInstanceCreationExpression();
5809	break;	6095	break;
5810		6096
5811	case 348 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$	6097	case 373 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$
5812	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;	6098	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5813	break;	6099	break;
5814		6100
5815	case 349 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$	6101	case 374 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$
5816	consumeClassInstanceCreationExpressionQualified() ;	6102	consumeClassInstanceCreationExpressionQualified() ;
5817	break;	6103	break;
5818		6104
5819	case 350 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$	6105	case 375 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$
5820	consumeClassInstanceCreationExpressionQualified() ;	6106	consumeClassInstanceCreationExpressionQualified() ;
5821	break;	6107	break;
5822		6108
5823	case 351 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$	6109	case 376 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$
5824	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;	6110	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5825	break;	6111	break;
5826		6112
5827	case 352 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); } //$NON-NLS-1$	6113	case 377 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); } //$NON-NLS-1$
5828	consumeClassInstanceCreationExpressionName() ;	6114	consumeClassInstanceCreationExpressionName() ;
5829	break;	6115	break;
5830		6116
5831	case 353 : if (DEBUG) { System.out.println("UnqualifiedClassBodyopt ::="); } //$NON-NLS-1$	6117	case 378 : if (DEBUG) { System.out.println("UnqualifiedClassBodyopt ::="); } //$NON-NLS-1$
5832	consumeClassBodyopt();	6118	consumeClassBodyopt();
5833	break;	6119	break;
5834		6120
5835	case 355 : if (DEBUG) { System.out.println("UnqualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$	6121	case 380 : if (DEBUG) { System.out.println("UnqualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$
5836	consumeEnterAnonymousClassBody(false);	6122	consumeEnterAnonymousClassBody(false);
5837	break;	6123	break;
5838		6124
5839	case 356 : if (DEBUG) { System.out.println("QualifiedClassBodyopt ::="); } //$NON-NLS-1$	6125	case 381 : if (DEBUG) { System.out.println("QualifiedClassBodyopt ::="); } //$NON-NLS-1$
5840	consumeClassBodyopt();	6126	consumeClassBodyopt();
5841	break;	6127	break;
5842		6128
5843	case 358 : if (DEBUG) { System.out.println("QualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$	6129	case 383 : if (DEBUG) { System.out.println("QualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$
5844	consumeEnterAnonymousClassBody(true);	6130	consumeEnterAnonymousClassBody(true);
5845	break;	6131	break;
5846		6132
5847	case 360 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); } //$NON-NLS-1$	6133	case 385 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); } //$NON-NLS-1$
5848	consumeArgumentList();	6134	consumeArgumentList();
5849	break;	6135	break;
5850		6136
5851	case 361 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); } //$NON-NLS-1$	6137	case 386 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); } //$NON-NLS-1$
		6138	consumeArrayCreationHeader();
		6139	break;
		6140
		6141	case 387 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6142	consumeArrayCreationHeader();
		6143	break;
		6144
		6145	case 388 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); } //$NON-NLS-1$
5852	consumeArrayCreationHeader();	6146	consumeArrayCreationHeader();
5853	break;	6147	break;
5854		6148
5855	case 362 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); } //$NON-NLS-1$	6149	case 389 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new OneOrMoreAnnotations..."); } //$NON-NLS-1$
5856	consumeArrayCreationHeader();	6150	consumeArrayCreationHeader();
5857	break;	6151	break;
5858		6152
5859	case 363 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$	6153	case 390 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
5860	consumeArrayCreationExpressionWithoutInitializer();	6154	consumeArrayCreationExpressionWithoutInitializer(false);
		6155	break;
		6156
		6157	case 391 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
		6158	consumeArrayCreationExpressionWithoutInitializer(true);
		6159	break;
		6160
		6161	case 392 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); } //$NON-NLS-1$
		6162	consumeArrayCreationExpressionWithInitializer(false);
		6163	break;
		6164
		6165	case 393 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
		6166	consumeArrayCreationExpressionWithInitializer(true);
5861	break;	6167	break;
5862		6168
5863	case 364 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); } //$NON-NLS-1$	6169	case 394 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
5864	consumeArrayCreationExpressionWithInitializer();	6170	consumeArrayCreationExpressionWithoutInitializer(false);
5865	break;	6171	break;
5866		6172
5867	case 365 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$	6173	case 395 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
5868	consumeArrayCreationExpressionWithoutInitializer();	6174	consumeArrayCreationExpressionWithoutInitializer(true);
5869	break;	6175	break;
5870		6176
5871	case 366 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$	6177	case 396 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
5872	consumeArrayCreationExpressionWithInitializer();	6178	consumeArrayCreationExpressionWithInitializer(false);
5873	break;	6179	break;
5874		6180
5875	case 368 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); } //$NON-NLS-1$	6181	case 397 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
		6182	consumeArrayCreationExpressionWithInitializer(true);
		6183	break;
		6184
		6185	case 399 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); } //$NON-NLS-1$
5876	consumeDimWithOrWithOutExprs();	6186	consumeDimWithOrWithOutExprs();
5877	break;	6187	break;
5878		6188
5879	case 370 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET RBRACKET"); } //$NON-NLS-1$	6189	case 402 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET..."); } //$NON-NLS-1$
5880	consumeDimWithOrWithOutExpr();	6190	consumeDimWithOutExpr();
		6191	break;
		6192
		6193	case 403 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= OneOrMoreAnnotations LBRACKET"); } //$NON-NLS-1$
		6194	consumeDimWithOutExpr();
5881	break;	6195	break;
5882		6196
5883	case 371 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); } //$NON-NLS-1$	6197	case 404 : if (DEBUG) { System.out.println("DimsoptAnnotsopt ::="); } //$NON-NLS-1$
		6198	consumeEmptyDimsoptAnnotsopt();
		6199	break;
		6200
		6201	case 405 : if (DEBUG) { System.out.println("DimsoptAnnotsopt -> DimsAnnotLoop"); } //$NON-NLS-1$
		6202	consumeDimsWithTrailingAnnotsopt();
		6203	break;
		6204
		6205	case 408 : if (DEBUG) { System.out.println("OneDimOrAnnot ::= Annotation"); } //$NON-NLS-1$
		6206	consumeTypeAnnotation(true);
		6207	break;
		6208
		6209	case 409 : if (DEBUG) { System.out.println("OneDimOrAnnot ::= LBRACKET RBRACKET"); } //$NON-NLS-1$
		6210	consumeOneDimLoop(true);
		6211	break;
		6212
		6213	case 410 : if (DEBUG) { System.out.println("OneOrMoreAnnotations ::= Annotation"); } //$NON-NLS-1$
		6214	consumeTypeAnnotation(false);
		6215	break;
		6216
		6217	case 411 : if (DEBUG) { System.out.println("OneOrMoreAnnotations ::= OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6218	consumeOneMoreTypeAnnotation();
		6219	break;
		6220
		6221	case 412 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); } //$NON-NLS-1$
5884	consumeDims();	6222	consumeDims();
5885	break;	6223	break;
5886		6224
5887	case 374 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); } //$NON-NLS-1$	6225	case 415 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); } //$NON-NLS-1$
5888	consumeOneDimLoop();	6226	consumeOneDimLoop(false);
5889	break;	6227	break;
5890		6228
5891	case 375 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); } //$NON-NLS-1$	6229	case 416 : if (DEBUG) { System.out.println("OneDimLoop ::= OneOrMoreAnnotations LBRACKET RBRACKET"); } //$NON-NLS-1$
		6230	consumeOneDimLoopWithAnnotations();
		6231	break;
		6232
		6233	case 417 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); } //$NON-NLS-1$
5892	consumeFieldAccess(false);	6234	consumeFieldAccess(false);
5893	break;	6235	break;
5894		6236
5895	case 376 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); } //$NON-NLS-1$	6237	case 418 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); } //$NON-NLS-1$
5896	consumeFieldAccess(true);	6238	consumeFieldAccess(true);
5897	break;	6239	break;
5898		6240
5899	case 377 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$	6241	case 419 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
5900	consumeMethodInvocationName();	6242	consumeMethodInvocationName();
5901	break;	6243	break;
5902		6244
5903	case 378 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6245	case 420 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5904	consumeMethodInvocationNameWithTypeArguments();	6246	consumeMethodInvocationNameWithTypeArguments();
5905	break;	6247	break;
5906		6248
5907	case 379 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6249	case 421 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5908	consumeMethodInvocationPrimaryWithTypeArguments();	6250	consumeMethodInvocationPrimaryWithTypeArguments();
5909	break;	6251	break;
5910		6252
5911	case 380 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); } //$NON-NLS-1$	6253	case 422 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); } //$NON-NLS-1$
5912	consumeMethodInvocationPrimary();	6254	consumeMethodInvocationPrimary();
5913	break;	6255	break;
5914		6256
5915	case 381 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6257	case 423 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5916	consumeMethodInvocationSuperWithTypeArguments();	6258	consumeMethodInvocationSuperWithTypeArguments();
5917	break;	6259	break;
5918		6260
5919	case 382 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); } //$NON-NLS-1$	6261	case 424 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); } //$NON-NLS-1$
5920	consumeMethodInvocationSuper();	6262	consumeMethodInvocationSuper();
5921	break;	6263	break;
5922		6264
5923	case 383 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); } //$NON-NLS-1$	6265	case 425 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); } //$NON-NLS-1$
5924	consumeArrayAccess(true);	6266	consumeArrayAccess(true);
5925	break;	6267	break;
5926		6268
5927	case 384 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); } //$NON-NLS-1$	6269	case 426 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); } //$NON-NLS-1$
5928	consumeArrayAccess(false);	6270	consumeArrayAccess(false);
5929	break;	6271	break;
5930		6272
5931	case 385 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); } //$NON-NLS-1$	6273	case 427 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); } //$NON-NLS-1$
5932	consumeArrayAccess(false);	6274	consumeArrayAccess(false);
5933	break;	6275	break;
5934		6276
5935	case 387 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); } //$NON-NLS-1$	6277	case 429 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); } //$NON-NLS-1$
5936	consumePostfixExpression();	6278	consumePostfixExpression();
5937	break;	6279	break;
5938		6280
5939	case 390 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); } //$NON-NLS-1$	6281	case 432 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); } //$NON-NLS-1$
5940	consumeUnaryExpression(OperatorIds.PLUS,true);	6282	consumeUnaryExpression(OperatorIds.PLUS,true);
5941	break;	6283	break;
5942		6284
5943	case 391 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); } //$NON-NLS-1$	6285	case 433 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); } //$NON-NLS-1$
5944	consumeUnaryExpression(OperatorIds.MINUS,true);	6286	consumeUnaryExpression(OperatorIds.MINUS,true);
5945	break;	6287	break;
5946		6288
5947	case 392 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$	6289	case 434 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$
5948	consumePushPosition();	6290	consumePushPosition();
5949	break;	6291	break;
5950		6292
5951	case 395 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$	6293	case 437 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$
5952	consumeUnaryExpression(OperatorIds.PLUS);	6294	consumeUnaryExpression(OperatorIds.PLUS);
5953	break;	6295	break;
5954		6296
5955	case 396 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$	6297	case 438 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$
5956	consumeUnaryExpression(OperatorIds.MINUS);	6298	consumeUnaryExpression(OperatorIds.MINUS);
5957	break;	6299	break;
5958		6300
5959	case 398 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$	6301	case 440 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$
5960	consumeUnaryExpression(OperatorIds.PLUS,false);	6302	consumeUnaryExpression(OperatorIds.PLUS,false);
5961	break;	6303	break;
5962		6304
5963	case 399 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$	6305	case 441 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$
5964	consumeUnaryExpression(OperatorIds.MINUS,false);	6306	consumeUnaryExpression(OperatorIds.MINUS,false);
5965	break;	6307	break;
5966		6308
5967	case 401 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$	6309	case 443 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$
5968	consumeUnaryExpression(OperatorIds.TWIDDLE);	6310	consumeUnaryExpression(OperatorIds.TWIDDLE);
5969	break;	6311	break;
5970		6312
5971	case 402 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$	6313	case 444 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$
5972	consumeUnaryExpression(OperatorIds.NOT);	6314	consumeUnaryExpression(OperatorIds.NOT);
5973	break;	6315	break;
5974		6316
5975	case 404 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); } //$NON-NLS-1$	6317	case 446 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); } //$NON-NLS-1$
5976	consumeCastExpressionWithPrimitiveType();	6318	consumeCastExpressionWithPrimitiveType(false);
5977	break;	6319	break;
5978		6320
5979	case 405 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$	6321	case 447 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations..."); } //$NON-NLS-1$
5980	consumeCastExpressionWithGenericsArray();	6322	consumeCastExpressionWithPrimitiveType(true);
5981	break;	6323	break;
5982		6324
5983	case 406 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$	6325	case 448 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$
5984	consumeCastExpressionWithQualifiedGenericsArray();	6326	consumeCastExpressionWithGenericsArray(false);
5985	break;	6327	break;
5986		6328
5987	case 407 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); } //$NON-NLS-1$	6329	case 449 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
5988	consumeCastExpressionLL1();	6330	consumeCastExpressionWithGenericsArray(true);
5989	break;	6331	break;
5990		6332
5991	case 408 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); } //$NON-NLS-1$	6333	case 450 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$
5992	consumeCastExpressionWithNameArray();	6334	consumeCastExpressionWithQualifiedGenericsArray(false);
5993	break;	6335	break;
5994		6336
5995	case 409 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); } //$NON-NLS-1$	6337	case 451 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
		6338	consumeCastExpressionWithQualifiedGenericsArray(true);
		6339	break;
		6340
		6341	case 452 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); } //$NON-NLS-1$
		6342	consumeCastExpressionLL1(false);
		6343	break;
		6344
		6345	case 453 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
		6346	consumeCastExpressionLL1(true);
		6347	break;
		6348
		6349	case 454 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); } //$NON-NLS-1$
		6350	consumeCastExpressionWithNameArray(false);
		6351	break;
		6352
		6353	case 455 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
		6354	consumeCastExpressionWithNameArray(true);
		6355	break;
		6356
		6357	case 456 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); } //$NON-NLS-1$
5996	consumeOnlyTypeArgumentsForCastExpression();	6358	consumeOnlyTypeArgumentsForCastExpression();
5997	break;	6359	break;
5998		6360
5999	case 410 : if (DEBUG) { System.out.println("InsideCastExpression ::="); } //$NON-NLS-1$	6361	case 457 : if (DEBUG) { System.out.println("InsideCastExpression ::="); } //$NON-NLS-1$
6000	consumeInsideCastExpression();	6362	consumeInsideCastExpression();
6001	break;	6363	break;
6002		6364
6003	case 411 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); } //$NON-NLS-1$	6365	case 458 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); } //$NON-NLS-1$
6004	consumeInsideCastExpressionLL1();	6366	consumeInsideCastExpressionLL1();
6005	break;	6367	break;
6006		6368
6007	case 412 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); } //$NON-NLS-1$	6369	case 459 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); } //$NON-NLS-1$
6008	consumeInsideCastExpressionWithQualifiedGenerics();	6370	consumeInsideCastExpressionWithQualifiedGenerics();
6009	break;	6371	break;
6010		6372
6011	case 414 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6373	case 461 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6012	consumeBinaryExpression(OperatorIds.MULTIPLY);	6374	consumeBinaryExpression(OperatorIds.MULTIPLY);
6013	break;	6375	break;
6014		6376
6015	case 415 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6377	case 462 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6016	consumeBinaryExpression(OperatorIds.DIVIDE);	6378	consumeBinaryExpression(OperatorIds.DIVIDE);
6017	break;	6379	break;
6018		6380
6019	case 416 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6381	case 463 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6020	consumeBinaryExpression(OperatorIds.REMAINDER);	6382	consumeBinaryExpression(OperatorIds.REMAINDER);
6021	break;	6383	break;
6022		6384
6023	case 418 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$	6385	case 465 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$
6024	consumeBinaryExpression(OperatorIds.PLUS);	6386	consumeBinaryExpression(OperatorIds.PLUS);
6025	break;	6387	break;
6026		6388
6027	case 419 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$	6389	case 466 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$
6028	consumeBinaryExpression(OperatorIds.MINUS);	6390	consumeBinaryExpression(OperatorIds.MINUS);
6029	break;	6391	break;
6030		6392
6031	case 421 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$	6393	case 468 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$
6032	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);	6394	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
6033	break;	6395	break;
6034		6396
6035	case 422 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$	6397	case 469 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$
6036	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);	6398	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
6037	break;	6399	break;
6038		6400
6039	case 423 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6401	case 470 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6040	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);	6402	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6041	break;	6403	break;
6042		6404
6043	case 425 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$	6405	case 472 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$
6044	consumeBinaryExpression(OperatorIds.LESS);	6406	consumeBinaryExpression(OperatorIds.LESS);
6045	break;	6407	break;
6046		6408
6047	case 426 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$	6409	case 473 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$
6048	consumeBinaryExpression(OperatorIds.GREATER);	6410	consumeBinaryExpression(OperatorIds.GREATER);
6049	break;	6411	break;
6050		6412
6051	case 427 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$	6413	case 474 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$
6052	consumeBinaryExpression(OperatorIds.LESS_EQUAL);	6414	consumeBinaryExpression(OperatorIds.LESS_EQUAL);
6053	break;	6415	break;
6054		6416
6055	case 428 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$	6417	case 475 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$
6056	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);	6418	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
6057	break;	6419	break;
6058		6420
6059	case 430 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$	6421	case 477 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$
6060	consumeInstanceOfExpression();	6422	consumeInstanceOfExpression();
6061	break;	6423	break;
6062		6424
6063	case 432 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$	6425	case 478 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$
		6426	consumeInstanceOfExpression();
		6427	break;
		6428
		6429	case 480 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$
6064	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);	6430	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
6065	break;	6431	break;
6066		6432
6067	case 433 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$	6433	case 481 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$
6068	consumeEqualityExpression(OperatorIds.NOT_EQUAL);	6434	consumeEqualityExpression(OperatorIds.NOT_EQUAL);
6069	break;	6435	break;
6070		6436
6071	case 435 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$	6437	case 483 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$
6072	consumeBinaryExpression(OperatorIds.AND);	6438	consumeBinaryExpression(OperatorIds.AND);
6073	break;	6439	break;
6074		6440
6075	case 437 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$	6441	case 485 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$
6076	consumeBinaryExpression(OperatorIds.XOR);	6442	consumeBinaryExpression(OperatorIds.XOR);
6077	break;	6443	break;
6078		6444
6079	case 439 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$	6445	case 487 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$
6080	consumeBinaryExpression(OperatorIds.OR);	6446	consumeBinaryExpression(OperatorIds.OR);
6081	break;	6447	break;
6082		6448
6083	case 441 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$	6449	case 489 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$
6084	consumeBinaryExpression(OperatorIds.AND_AND);	6450	consumeBinaryExpression(OperatorIds.AND_AND);
6085	break;	6451	break;
6086		6452
6087	case 443 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$	6453	case 491 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
6088	consumeBinaryExpression(OperatorIds.OR_OR);	6454	consumeBinaryExpression(OperatorIds.OR_OR);
6089	break;	6455	break;
6090		6456
6091	case 445 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$	6457	case 493 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
6092	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;	6458	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
6093	break;	6459	break;
6094		6460
6095	case 448 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$	6461	case 496 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$
6096	consumeAssignment();	6462	consumeAssignment();
6097	break;	6463	break;
6098		6464
6099	case 450 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); } //$NON-NLS-1$	6465	case 498 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); } //$NON-NLS-1$
6100	ignoreExpressionAssignment();	6466	ignoreExpressionAssignment();
6101	break;	6467	break;
6102		6468
6103	case 451 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$	6469	case 499 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$
6104	consumeAssignmentOperator(EQUAL);	6470	consumeAssignmentOperator(EQUAL);
6105	break;	6471	break;
6106		6472
6107	case 452 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$	6473	case 500 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$
6108	consumeAssignmentOperator(MULTIPLY);	6474	consumeAssignmentOperator(MULTIPLY);
6109	break;	6475	break;
6110		6476
6111	case 453 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$	6477	case 501 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$
6112	consumeAssignmentOperator(DIVIDE);	6478	consumeAssignmentOperator(DIVIDE);
6113	break;	6479	break;
6114		6480
6115	case 454 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$	6481	case 502 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$
6116	consumeAssignmentOperator(REMAINDER);	6482	consumeAssignmentOperator(REMAINDER);
6117	break;	6483	break;
6118		6484
6119	case 455 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$	6485	case 503 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$
6120	consumeAssignmentOperator(PLUS);	6486	consumeAssignmentOperator(PLUS);
6121	break;	6487	break;
6122		6488
6123	case 456 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$	6489	case 504 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$
6124	consumeAssignmentOperator(MINUS);	6490	consumeAssignmentOperator(MINUS);
6125	break;	6491	break;
6126		6492
6127	case 457 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$	6493	case 505 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$
6128	consumeAssignmentOperator(LEFT_SHIFT);	6494	consumeAssignmentOperator(LEFT_SHIFT);
6129	break;	6495	break;
6130		6496
6131	case 458 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$	6497	case 506 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
6132	consumeAssignmentOperator(RIGHT_SHIFT);	6498	consumeAssignmentOperator(RIGHT_SHIFT);
6133	break;	6499	break;
6134		6500
6135	case 459 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$	6501	case 507 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
6136	consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);	6502	consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);
6137	break;	6503	break;
6138		6504
6139	case 460 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$	6505	case 508 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$
6140	consumeAssignmentOperator(AND);	6506	consumeAssignmentOperator(AND);
6141	break;	6507	break;
6142		6508
6143	case 461 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$	6509	case 509 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$
6144	consumeAssignmentOperator(XOR);	6510	consumeAssignmentOperator(XOR);
6145	break;	6511	break;
6146		6512
6147	case 462 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$	6513	case 510 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$
6148	consumeAssignmentOperator(OR);	6514	consumeAssignmentOperator(OR);
6149	break;	6515	break;
6150		6516
6151	case 466 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$	6517	case 514 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$
6152	consumeEmptyExpression();	6518	consumeEmptyExpression();
6153	break;	6519	break;
6154		6520
6155	case 471 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); } //$NON-NLS-1$	6521	case 519 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); } //$NON-NLS-1$
6156	consumeEmptyClassBodyDeclarationsopt();	6522	consumeEmptyClassBodyDeclarationsopt();
6157	break;	6523	break;
6158		6524
6159	case 472 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	6525	case 520 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6160	consumeClassBodyDeclarationsopt();	6526	consumeClassBodyDeclarationsopt();
6161	break;	6527	break;
6162		6528
6163	case 473 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$	6529	case 521 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::="); } //$NON-NLS-1$
6164	consumeDefaultModifiers();	6530	consumeDefaultModifiers();
6165	break;	6531	break;
6166		6532
6167	case 474 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); } //$NON-NLS-1$	6533	case 522 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::= NonAnnotModifiers"); } //$NON-NLS-1$
6168	consumeModifiers();	6534	consumeModifiers();
6169	break;	6535	break;
6170		6536
6171	case 475 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$	6537	case 523 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$
		6538	consumeDefaultModifiers();
		6539	break;
		6540
		6541	case 524 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); } //$NON-NLS-1$
		6542	consumeModifiers();
		6543	break;
		6544
		6545	case 525 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$
6172	consumeEmptyBlockStatementsopt();	6546	consumeEmptyBlockStatementsopt();
6173	break;	6547	break;
6174		6548
6175	case 477 : if (DEBUG) { System.out.println("Dimsopt ::="); } //$NON-NLS-1$	6549	case 527 : if (DEBUG) { System.out.println("Dimsopt ::="); } //$NON-NLS-1$
6176	consumeEmptyDimsopt();	6550	consumeEmptyDimsopt();
6177	break;	6551	break;
6178		6552
6179	case 479 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$	6553	case 529 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$
6180	consumeEmptyArgumentListopt();	6554	consumeEmptyArgumentListopt();
6181	break;	6555	break;
6182		6556
6183	case 483 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$	6557	case 533 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$
6184	consumeFormalParameterListopt();	6558	consumeFormalParameterListopt();
6185	break;	6559	break;
6186		6560
6187	case 487 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); } //$NON-NLS-1$	6561	case 537 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); } //$NON-NLS-1$
6188	consumeEmptyInterfaceMemberDeclarationsopt();	6562	consumeEmptyInterfaceMemberDeclarationsopt();
6189	break;	6563	break;
6190		6564
6191	case 488 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	6565	case 538 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6192	consumeInterfaceMemberDeclarationsopt();	6566	consumeInterfaceMemberDeclarationsopt();
6193	break;	6567	break;
6194		6568
6195	case 489 : if (DEBUG) { System.out.println("NestedType ::="); } //$NON-NLS-1$	6569	case 539 : if (DEBUG) { System.out.println("NestedType ::="); } //$NON-NLS-1$
6196	consumeNestedType();	6570	consumeNestedType();
6197	break;	6571	break;
6198		6572
6199	case 490 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$	6573	case 540 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$
6200	consumeEmptyForInitopt();	6574	consumeEmptyForInitopt();
6201	break;	6575	break;
6202		6576
6203	case 492 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$	6577	case 542 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$
6204	consumeEmptyForUpdateopt();	6578	consumeEmptyForUpdateopt();
6205	break;	6579	break;
6206		6580
6207	case 496 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$	6581	case 546 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$
6208	consumeEmptyCatchesopt();	6582	consumeEmptyCatchesopt();
6209	break;	6583	break;
6210		6584
6211	case 498 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); } //$NON-NLS-1$	6585	case 548 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); } //$NON-NLS-1$
6212	consumeEnumDeclaration();	6586	consumeEnumDeclaration();
6213	break;	6587	break;
6214		6588
6215	case 499 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); } //$NON-NLS-1$	6589	case 549 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); } //$NON-NLS-1$
6216	consumeEnumHeader();	6590	consumeEnumHeader();
6217	break;	6591	break;
6218		6592
6219	case 500 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); } //$NON-NLS-1$	6593	case 550 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); } //$NON-NLS-1$
6220	consumeEnumHeaderName();	6594	consumeEnumHeaderName();
6221	break;	6595	break;
6222		6596
6223	case 501 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); } //$NON-NLS-1$	6597	case 551 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); } //$NON-NLS-1$
6224	consumeEnumHeaderNameWithTypeParameters();	6598	consumeEnumHeaderNameWithTypeParameters();
6225	break;	6599	break;
6226		6600
6227	case 502 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); } //$NON-NLS-1$	6601	case 552 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); } //$NON-NLS-1$
6228	consumeEnumBodyNoConstants();	6602	consumeEnumBodyNoConstants();
6229	break;	6603	break;
6230		6604
6231	case 503 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); } //$NON-NLS-1$	6605	case 553 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); } //$NON-NLS-1$
6232	consumeEnumBodyNoConstants();	6606	consumeEnumBodyNoConstants();
6233	break;	6607	break;
6234		6608
6235	case 504 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); } //$NON-NLS-1$	6609	case 554 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); } //$NON-NLS-1$
6236	consumeEnumBodyWithConstants();	6610	consumeEnumBodyWithConstants();
6237	break;	6611	break;
6238		6612
6239	case 505 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); } //$NON-NLS-1$	6613	case 555 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); } //$NON-NLS-1$
6240	consumeEnumBodyWithConstants();	6614	consumeEnumBodyWithConstants();
6241	break;	6615	break;
6242		6616
6243	case 507 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); } //$NON-NLS-1$	6617	case 557 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); } //$NON-NLS-1$
6244	consumeEnumConstants();	6618	consumeEnumConstants();
6245	break;	6619	break;
6246		6620
6247	case 508 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); } //$NON-NLS-1$	6621	case 558 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); } //$NON-NLS-1$
6248	consumeEnumConstantHeaderName();	6622	consumeEnumConstantHeaderName();
6249	break;	6623	break;
6250		6624
6251	case 509 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); } //$NON-NLS-1$	6625	case 559 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); } //$NON-NLS-1$
6252	consumeEnumConstantHeader();	6626	consumeEnumConstantHeader();
6253	break;	6627	break;
6254		6628
6255	case 510 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); } //$NON-NLS-1$	6629	case 560 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); } //$NON-NLS-1$
6256	consumeEnumConstantWithClassBody();	6630	consumeEnumConstantWithClassBody();
6257	break;	6631	break;
6258		6632
6259	case 511 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); } //$NON-NLS-1$	6633	case 561 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); } //$NON-NLS-1$
6260	consumeEnumConstantNoClassBody();	6634	consumeEnumConstantNoClassBody();
6261	break;	6635	break;
6262		6636
6263	case 512 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$	6637	case 562 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
6264	consumeArguments();	6638	consumeArguments();
6265	break;	6639	break;
6266		6640
6267	case 513 : if (DEBUG) { System.out.println("Argumentsopt ::="); } //$NON-NLS-1$	6641	case 563 : if (DEBUG) { System.out.println("Argumentsopt ::="); } //$NON-NLS-1$
6268	consumeEmptyArguments();	6642	consumeEmptyArguments();
6269	break;	6643	break;
6270		6644
6271	case 515 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); } //$NON-NLS-1$	6645	case 565 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); } //$NON-NLS-1$
6272	consumeEnumDeclarations();	6646	consumeEnumDeclarations();
6273	break;	6647	break;
6274		6648
6275	case 516 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); } //$NON-NLS-1$	6649	case 566 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); } //$NON-NLS-1$
6276	consumeEmptyEnumDeclarations();	6650	consumeEmptyEnumDeclarations();
6277	break;	6651	break;
6278		6652
6279	case 518 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); } //$NON-NLS-1$	6653	case 568 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); } //$NON-NLS-1$
6280	consumeEnhancedForStatement();	6654	consumeEnhancedForStatement();
6281	break;	6655	break;
6282		6656
6283	case 519 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); } //$NON-NLS-1$	6657	case 569 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); } //$NON-NLS-1$
6284	consumeEnhancedForStatement();	6658	consumeEnhancedForStatement();
6285	break;	6659	break;
6286		6660
6287	case 520 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); } //$NON-NLS-1$	6661	case 570 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); } //$NON-NLS-1$
6288	consumeEnhancedForStatementHeaderInit(false);	6662	consumeEnhancedForStatementHeaderInit(false);
6289	break;	6663	break;
6290		6664
6291	case 521 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } //$NON-NLS-1$	6665	case 571 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } //$NON-NLS-1$
6292	consumeEnhancedForStatementHeaderInit(true);	6666	consumeEnhancedForStatementHeaderInit(true);
6293	break;	6667	break;
6294		6668
6295	case 522 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } //$NON-NLS-1$	6669	case 572 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } //$NON-NLS-1$
6296	consumeEnhancedForStatementHeader();	6670	consumeEnhancedForStatementHeader();
6297	break;	6671	break;
6298		6672
6299	case 523 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } //$NON-NLS-1$	6673	case 573 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } //$NON-NLS-1$
6300	consumeImportDeclaration();	6674	consumeImportDeclaration();
6301	break;	6675	break;
6302		6676
6303	case 524 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } //$NON-NLS-1$	6677	case 574 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } //$NON-NLS-1$
6304	consumeSingleStaticImportDeclarationName();	6678	consumeSingleStaticImportDeclarationName();
6305	break;	6679	break;
6306		6680
6307	case 525 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$	6681	case 575 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$
6308	consumeImportDeclaration();	6682	consumeImportDeclaration();
6309	break;	6683	break;
6310		6684
6311	case 526 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } //$NON-NLS-1$	6685	case 576 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } //$NON-NLS-1$
6312	consumeStaticImportOnDemandDeclarationName();	6686	consumeStaticImportOnDemandDeclarationName();
6313	break;	6687	break;
6314		6688
6315	case 527 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$	6689	case 577 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$
6316	consumeTypeArguments();	6690	consumeTypeArguments();
6317	break;	6691	break;
6318		6692
6319	case 528 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$	6693	case 578 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$
6320	consumeOnlyTypeArguments();	6694	consumeOnlyTypeArguments();
6321	break;	6695	break;
6322		6696
6323	case 530 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6697	case 580 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6324	consumeTypeArgumentList1();	6698	consumeTypeArgumentList1();
6325	break;	6699	break;
6326		6700
6327	case 532 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } //$NON-NLS-1$	6701	case 582 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } //$NON-NLS-1$
6328	consumeTypeArgumentList();	6702	consumeTypeArgumentList();
6329	break;	6703	break;
6330		6704
6331	case 533 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } //$NON-NLS-1$	6705	case 583 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } //$NON-NLS-1$
6332	consumeTypeArgument();	6706	consumeTypeArgument(false);
		6707	break;
		6708
		6709	case 584 : if (DEBUG) { System.out.println("TypeArgument ::= OneOrMoreAnnotations ReferenceType"); } //$NON-NLS-1$
		6710	consumeTypeArgument(true);
		6711	break;
		6712
		6713	case 588 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } //$NON-NLS-1$
		6714	consumeReferenceType1(false);
		6715	break;
		6716
		6717	case 589 : if (DEBUG) { System.out.println("ReferenceType1 ::= OneOrMoreAnnotations ReferenceType..."); } //$NON-NLS-1$
		6718	consumeReferenceType1(true);
6333	break;	6719	break;
6334		6720
6335	case 537 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } //$NON-NLS-1$	6721	case 590 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$
6336	consumeReferenceType1();	6722	consumeTypeArgumentReferenceType1(false);
6337	break;	6723	break;
6338		6724
6339	case 538 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$	6725	case 591 : if (DEBUG) { System.out.println("ReferenceType1 ::= OneOrMoreAnnotations ClassOrInterface"); } //$NON-NLS-1$
6340	consumeTypeArgumentReferenceType1();	6726	consumeTypeArgumentReferenceType1(true);
6341	break;	6727	break;
6342		6728
6343	case 540 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6729	case 593 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6344	consumeTypeArgumentList2();	6730	consumeTypeArgumentList2();
6345	break;	6731	break;
6346		6732
6347	case 543 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } //$NON-NLS-1$	6733	case 596 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } //$NON-NLS-1$
6348	consumeReferenceType2();	6734	consumeReferenceType2(false);
		6735	break;
		6736
		6737	case 597 : if (DEBUG) { System.out.println("ReferenceType2 ::= OneOrMoreAnnotations ReferenceType..."); } //$NON-NLS-1$
		6738	consumeReferenceType2(true);
		6739	break;
		6740
		6741	case 598 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$
		6742	consumeTypeArgumentReferenceType2(false);
6349	break;	6743	break;
6350		6744
6351	case 544 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$	6745	case 599 : if (DEBUG) { System.out.println("ReferenceType2 ::= OneOrMoreAnnotations ClassOrInterface"); } //$NON-NLS-1$
6352	consumeTypeArgumentReferenceType2();	6746	consumeTypeArgumentReferenceType2(true);
6353	break;	6747	break;
6354		6748
6355	case 546 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6749	case 601 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6356	consumeTypeArgumentList3();	6750	consumeTypeArgumentList3();
6357	break;	6751	break;
6358		6752
6359	case 549 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6753	case 604 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6360	consumeReferenceType3();	6754	consumeReferenceType3(false);
6361	break;	6755	break;
6362		6756
6363	case 550 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } //$NON-NLS-1$	6757	case 605 : if (DEBUG) { System.out.println("ReferenceType3 ::= OneOrMoreAnnotations ReferenceType..."); } //$NON-NLS-1$
		6758	consumeReferenceType3(true);
		6759	break;
		6760
		6761	case 606 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } //$NON-NLS-1$
6364	consumeWildcard();	6762	consumeWildcard();
6365	break;	6763	break;
6366		6764
6367	case 551 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } //$NON-NLS-1$	6765	case 607 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } //$NON-NLS-1$
6368	consumeWildcardWithBounds();	6766	consumeWildcardWithBounds();
6369	break;	6767	break;
6370		6768
6371	case 552 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } //$NON-NLS-1$	6769	case 608 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } //$NON-NLS-1$
6372	consumeWildcardBoundsExtends();	6770	consumeWildcardBoundsExtends(false);
		6771	break;
		6772
		6773	case 609 : if (DEBUG) { System.out.println("WildcardBounds ::= extends OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6774	consumeWildcardBoundsExtends(true);
6373	break;	6775	break;
6374		6776
6375	case 553 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } //$NON-NLS-1$	6777	case 610 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } //$NON-NLS-1$
6376	consumeWildcardBoundsSuper();	6778	consumeWildcardBoundsSuper(false);
6377	break;	6779	break;
6378		6780
6379	case 554 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } //$NON-NLS-1$	6781	case 611 : if (DEBUG) { System.out.println("WildcardBounds ::= super OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6782	consumeWildcardBoundsSuper(true);
		6783	break;
		6784
		6785	case 612 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } //$NON-NLS-1$
6380	consumeWildcard1();	6786	consumeWildcard1();
6381	break;	6787	break;
6382		6788
6383	case 555 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } //$NON-NLS-1$	6789	case 613 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } //$NON-NLS-1$
6384	consumeWildcard1WithBounds();	6790	consumeWildcard1WithBounds();
6385	break;	6791	break;
6386		6792
6387	case 556 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } //$NON-NLS-1$	6793	case 614 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } //$NON-NLS-1$
6388	consumeWildcardBounds1Extends();	6794	consumeWildcardBounds1Extends();
6389	break;	6795	break;
6390		6796
6391	case 557 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } //$NON-NLS-1$	6797	case 615 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } //$NON-NLS-1$
6392	consumeWildcardBounds1Super();	6798	consumeWildcardBounds1Super();
6393	break;	6799	break;
6394		6800
6395	case 558 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } //$NON-NLS-1$	6801	case 616 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } //$NON-NLS-1$
6396	consumeWildcard2();	6802	consumeWildcard2();
6397	break;	6803	break;
6398		6804
6399	case 559 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } //$NON-NLS-1$	6805	case 617 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } //$NON-NLS-1$
6400	consumeWildcard2WithBounds();	6806	consumeWildcard2WithBounds();
6401	break;	6807	break;
6402		6808
6403	case 560 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } //$NON-NLS-1$	6809	case 618 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } //$NON-NLS-1$
6404	consumeWildcardBounds2Extends();	6810	consumeWildcardBounds2Extends();
6405	break;	6811	break;
6406		6812
6407	case 561 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } //$NON-NLS-1$	6813	case 619 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } //$NON-NLS-1$
6408	consumeWildcardBounds2Super();	6814	consumeWildcardBounds2Super();
6409	break;	6815	break;
6410		6816
6411	case 562 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6817	case 620 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6412	consumeWildcard3();	6818	consumeWildcard3();
6413	break;	6819	break;
6414		6820
6415	case 563 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } //$NON-NLS-1$	6821	case 621 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } //$NON-NLS-1$
6416	consumeWildcard3WithBounds();	6822	consumeWildcard3WithBounds();
6417	break;	6823	break;
6418		6824
6419	case 564 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } //$NON-NLS-1$	6825	case 622 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } //$NON-NLS-1$
6420	consumeWildcardBounds3Extends();	6826	consumeWildcardBounds3Extends();
6421	break;	6827	break;
6422		6828
6423	case 565 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } //$NON-NLS-1$	6829	case 623 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } //$NON-NLS-1$
6424	consumeWildcardBounds3Super();	6830	consumeWildcardBounds3Super();
6425	break;	6831	break;
6426		6832
6427	case 566 : if (DEBUG) { System.out.println("TypeParameterHeader ::= Identifier"); } //$NON-NLS-1$	6833	case 624 : if (DEBUG) { System.out.println("PushZeroTypeAnnotations ::="); } //$NON-NLS-1$
		6834	consumeZeroTypeAnnotations();
		6835	break;
		6836
		6837	case 625 : if (DEBUG) { System.out.println("TypeParameterHeader ::= PushZeroTypeAnnotations..."); } //$NON-NLS-1$
		6838	consumeTypeParameterHeader();
		6839	break;
		6840
		6841	case 626 : if (DEBUG) { System.out.println("TypeParameterHeader ::= OneOrMoreAnnotations Identifier"); } //$NON-NLS-1$
6428	consumeTypeParameterHeader();	6842	consumeTypeParameterHeader();
6429	break;	6843	break;
6430		6844
6431	case 567 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } //$NON-NLS-1$	6845	case 627 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } //$NON-NLS-1$
6432	consumeTypeParameters();	6846	consumeTypeParameters();
6433	break;	6847	break;
6434		6848
6435	case 569 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } //$NON-NLS-1$	6849	case 629 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } //$NON-NLS-1$
6436	consumeTypeParameterList();	6850	consumeTypeParameterList();
6437	break;	6851	break;
6438		6852
6439	case 571 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6853	case 631 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6440	consumeTypeParameterWithExtends();	6854	consumeTypeParameterWithExtends(false);
6441	break;	6855	break;
6442		6856
6443	case 572 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6857	case 632 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6444	consumeTypeParameterWithExtendsAndBounds();	6858	consumeTypeParameterWithExtends(true);
6445	break;	6859	break;
6446		6860
6447	case 574 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } //$NON-NLS-1$	6861	case 633 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
		6862	consumeTypeParameterWithExtendsAndBounds(false);
		6863	break;
		6864
		6865	case 634 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
		6866	consumeTypeParameterWithExtendsAndBounds(true);
		6867	break;
		6868
		6869	case 636 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } //$NON-NLS-1$
6448	consumeAdditionalBoundList();	6870	consumeAdditionalBoundList();
6449	break;	6871	break;
6450		6872
6451	case 575 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } //$NON-NLS-1$	6873	case 637 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } //$NON-NLS-1$
6452	consumeAdditionalBound();	6874	consumeAdditionalBound(false);
		6875	break;
		6876
		6877	case 638 : if (DEBUG) { System.out.println("AdditionalBound ::= AND OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6878	consumeAdditionalBound(true);
6453	break;	6879	break;
6454		6880
6455	case 577 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } //$NON-NLS-1$	6881	case 640 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } //$NON-NLS-1$
6456	consumeTypeParameterList1();	6882	consumeTypeParameterList1();
6457	break;	6883	break;
6458		6884
6459	case 578 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } //$NON-NLS-1$	6885	case 641 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } //$NON-NLS-1$
6460	consumeTypeParameter1();	6886	consumeTypeParameter1();
6461	break;	6887	break;
6462		6888
6463	case 579 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6889	case 642 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6464	consumeTypeParameter1WithExtends();	6890	consumeTypeParameter1WithExtends();
6465	break;	6891	break;
6466		6892
6467	case 580 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6893	case 643 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6468	consumeTypeParameter1WithExtendsAndBounds();	6894	consumeTypeParameter1WithExtendsAndBounds(false);
6469	break;	6895	break;
6470		6896
6471	case 582 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } //$NON-NLS-1$	6897	case 644 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
		6898	consumeTypeParameter1WithExtendsAndBounds(true);
		6899	break;
		6900
		6901	case 646 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } //$NON-NLS-1$
6472	consumeAdditionalBoundList1();	6902	consumeAdditionalBoundList1();
6473	break;	6903	break;
6474		6904
6475	case 583 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } //$NON-NLS-1$	6905	case 647 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } //$NON-NLS-1$
6476	consumeAdditionalBound1();	6906	consumeAdditionalBound1();
6477	break;	6907	break;
6478		6908
6479	case 589 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } //$NON-NLS-1$	6909	case 653 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } //$NON-NLS-1$
6480	consumeUnaryExpression(OperatorIds.PLUS);	6910	consumeUnaryExpression(OperatorIds.PLUS);
6481	break;	6911	break;
6482		6912
6483	case 590 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } //$NON-NLS-1$	6913	case 654 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } //$NON-NLS-1$
6484	consumeUnaryExpression(OperatorIds.MINUS);	6914	consumeUnaryExpression(OperatorIds.MINUS);
6485	break;	6915	break;
6486		6916
6487	case 593 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } //$NON-NLS-1$	6917	case 657 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } //$NON-NLS-1$
6488	consumeUnaryExpression(OperatorIds.TWIDDLE);	6918	consumeUnaryExpression(OperatorIds.TWIDDLE);
6489	break;	6919	break;
6490		6920
6491	case 594 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } //$NON-NLS-1$	6921	case 658 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } //$NON-NLS-1$
6492	consumeUnaryExpression(OperatorIds.NOT);	6922	consumeUnaryExpression(OperatorIds.NOT);
6493	break;	6923	break;
6494		6924
6495	case 597 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6925	case 661 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6496	consumeBinaryExpression(OperatorIds.MULTIPLY);	6926	consumeBinaryExpression(OperatorIds.MULTIPLY);
6497	break;	6927	break;
6498		6928
6499	case 598 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } //$NON-NLS-1$	6929	case 662 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } //$NON-NLS-1$
6500	consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);	6930	consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);
6501	break;	6931	break;
6502		6932
6503	case 599 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6933	case 663 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6504	consumeBinaryExpression(OperatorIds.DIVIDE);	6934	consumeBinaryExpression(OperatorIds.DIVIDE);
6505	break;	6935	break;
6506		6936
6507	case 600 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } //$NON-NLS-1$	6937	case 664 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } //$NON-NLS-1$
6508	consumeBinaryExpressionWithName(OperatorIds.DIVIDE);	6938	consumeBinaryExpressionWithName(OperatorIds.DIVIDE);
6509	break;	6939	break;
6510		6940
6511	case 601 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6941	case 665 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6512	consumeBinaryExpression(OperatorIds.REMAINDER);	6942	consumeBinaryExpression(OperatorIds.REMAINDER);
6513	break;	6943	break;
6514		6944
6515	case 602 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } //$NON-NLS-1$	6945	case 666 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } //$NON-NLS-1$
6516	consumeBinaryExpressionWithName(OperatorIds.REMAINDER);	6946	consumeBinaryExpressionWithName(OperatorIds.REMAINDER);
6517	break;	6947	break;
6518		6948
6519	case 604 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$	6949	case 668 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$
6520	consumeBinaryExpression(OperatorIds.PLUS);	6950	consumeBinaryExpression(OperatorIds.PLUS);
6521	break;	6951	break;
6522		6952
6523	case 605 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } //$NON-NLS-1$	6953	case 669 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } //$NON-NLS-1$
6524	consumeBinaryExpressionWithName(OperatorIds.PLUS);	6954	consumeBinaryExpressionWithName(OperatorIds.PLUS);
6525	break;	6955	break;
6526		6956
6527	case 606 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$	6957	case 670 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$
6528	consumeBinaryExpression(OperatorIds.MINUS);	6958	consumeBinaryExpression(OperatorIds.MINUS);
6529	break;	6959	break;
6530		6960
6531	case 607 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } //$NON-NLS-1$	6961	case 671 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } //$NON-NLS-1$
6532	consumeBinaryExpressionWithName(OperatorIds.MINUS);	6962	consumeBinaryExpressionWithName(OperatorIds.MINUS);
6533	break;	6963	break;
6534		6964
6535	case 609 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	6965	case 673 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6536	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);	6966	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
6537	break;	6967	break;
6538		6968
6539	case 610 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } //$NON-NLS-1$	6969	case 674 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } //$NON-NLS-1$
6540	consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);	6970	consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);
6541	break;	6971	break;
6542		6972
6543	case 611 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	6973	case 675 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6544	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);	6974	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
6545	break;	6975	break;
6546		6976
6547	case 612 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } //$NON-NLS-1$	6977	case 676 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } //$NON-NLS-1$
6548	consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);	6978	consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);
6549	break;	6979	break;
6550		6980
6551	case 613 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	6981	case 677 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6552	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);	6982	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6553	break;	6983	break;
6554		6984
6555	case 614 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } //$NON-NLS-1$	6985	case 678 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } //$NON-NLS-1$
6556	consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);	6986	consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6557	break;	6987	break;
6558		6988
6559	case 616 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$	6989	case 680 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$
6560	consumeBinaryExpression(OperatorIds.LESS);	6990	consumeBinaryExpression(OperatorIds.LESS);
6561	break;	6991	break;
6562		6992
6563	case 617 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } //$NON-NLS-1$	6993	case 681 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } //$NON-NLS-1$
6564	consumeBinaryExpressionWithName(OperatorIds.LESS);	6994	consumeBinaryExpressionWithName(OperatorIds.LESS);
6565	break;	6995	break;
6566		6996
6567	case 618 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$	6997	case 682 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$
6568	consumeBinaryExpression(OperatorIds.GREATER);	6998	consumeBinaryExpression(OperatorIds.GREATER);
6569	break;	6999	break;
6570		7000
6571	case 619 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } //$NON-NLS-1$	7001	case 683 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } //$NON-NLS-1$
6572	consumeBinaryExpressionWithName(OperatorIds.GREATER);	7002	consumeBinaryExpressionWithName(OperatorIds.GREATER);
6573	break;	7003	break;
6574		7004
6575	case 620 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$	7005	case 684 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$
6576	consumeBinaryExpression(OperatorIds.LESS_EQUAL);	7006	consumeBinaryExpression(OperatorIds.LESS_EQUAL);
6577	break;	7007	break;
6578		7008
6579	case 621 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } //$NON-NLS-1$	7009	case 685 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } //$NON-NLS-1$
6580	consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);	7010	consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);
6581	break;	7011	break;
6582		7012
6583	case 622 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$	7013	case 686 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$
6584	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);	7014	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
6585	break;	7015	break;
6586		7016
6587	case 623 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } //$NON-NLS-1$	7017	case 687 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } //$NON-NLS-1$
6588	consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);	7018	consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);
6589	break;	7019	break;
6590		7020
6591	case 625 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$	7021	case 689 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$
		7022	consumeInstanceOfExpressionWithName();
		7023	break;
		7024
		7025	case 690 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$
6592	consumeInstanceOfExpressionWithName();	7026	consumeInstanceOfExpressionWithName();
6593	break;	7027	break;
6594		7028
6595	case 626 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$	7029	case 691 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$
		7030	consumeInstanceOfExpression();
		7031	break;
		7032
		7033	case 692 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$
6596	consumeInstanceOfExpression();	7034	consumeInstanceOfExpression();
6597	break;	7035	break;
6598		7036
6599	case 628 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$	7037	case 694 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$
6600	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);	7038	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
6601	break;	7039	break;
6602		7040
6603	case 629 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } //$NON-NLS-1$	7041	case 695 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } //$NON-NLS-1$
6604	consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);	7042	consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);
6605	break;	7043	break;
6606		7044
6607	case 630 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$	7045	case 696 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$
6608	consumeEqualityExpression(OperatorIds.NOT_EQUAL);	7046	consumeEqualityExpression(OperatorIds.NOT_EQUAL);
6609	break;	7047	break;
6610		7048
6611	case 631 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } //$NON-NLS-1$	7049	case 697 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } //$NON-NLS-1$
6612	consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);	7050	consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);
6613	break;	7051	break;
6614		7052
6615	case 633 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } //$NON-NLS-1$	7053	case 699 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } //$NON-NLS-1$
6616	consumeBinaryExpression(OperatorIds.AND);	7054	consumeBinaryExpression(OperatorIds.AND);
6617	break;	7055	break;
6618		7056
6619	case 634 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } //$NON-NLS-1$	7057	case 700 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } //$NON-NLS-1$
6620	consumeBinaryExpressionWithName(OperatorIds.AND);	7058	consumeBinaryExpressionWithName(OperatorIds.AND);
6621	break;	7059	break;
6622		7060
6623	case 636 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$	7061	case 702 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$
6624	consumeBinaryExpression(OperatorIds.XOR);	7062	consumeBinaryExpression(OperatorIds.XOR);
6625	break;	7063	break;
6626		7064
6627	case 637 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } //$NON-NLS-1$	7065	case 703 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } //$NON-NLS-1$
6628	consumeBinaryExpressionWithName(OperatorIds.XOR);	7066	consumeBinaryExpressionWithName(OperatorIds.XOR);
6629	break;	7067	break;
6630		7068
6631	case 639 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$	7069	case 705 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$
6632	consumeBinaryExpression(OperatorIds.OR);	7070	consumeBinaryExpression(OperatorIds.OR);
6633	break;	7071	break;
6634		7072
6635	case 640 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } //$NON-NLS-1$	7073	case 706 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } //$NON-NLS-1$
6636	consumeBinaryExpressionWithName(OperatorIds.OR);	7074	consumeBinaryExpressionWithName(OperatorIds.OR);
6637	break;	7075	break;
6638		7076
6639	case 642 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } //$NON-NLS-1$	7077	case 708 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } //$NON-NLS-1$
6640	consumeBinaryExpression(OperatorIds.AND_AND);	7078	consumeBinaryExpression(OperatorIds.AND_AND);
6641	break;	7079	break;
6642		7080
6643	case 643 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } //$NON-NLS-1$	7081	case 709 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } //$NON-NLS-1$
6644	consumeBinaryExpressionWithName(OperatorIds.AND_AND);	7082	consumeBinaryExpressionWithName(OperatorIds.AND_AND);
6645	break;	7083	break;
6646		7084
6647	case 645 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } //$NON-NLS-1$	7085	case 711 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } //$NON-NLS-1$
6648	consumeBinaryExpression(OperatorIds.OR_OR);	7086	consumeBinaryExpression(OperatorIds.OR_OR);
6649	break;	7087	break;
6650		7088
6651	case 646 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } //$NON-NLS-1$	7089	case 712 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } //$NON-NLS-1$
6652	consumeBinaryExpressionWithName(OperatorIds.OR_OR);	7090	consumeBinaryExpressionWithName(OperatorIds.OR_OR);
6653	break;	7091	break;
6654		7092
6655	case 648 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } //$NON-NLS-1$	7093	case 714 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } //$NON-NLS-1$
6656	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;	7094	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
6657	break;	7095	break;
6658		7096
6659	case 649 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } //$NON-NLS-1$	7097	case 715 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } //$NON-NLS-1$
6660	consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;	7098	consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;
6661	break;	7099	break;
6662		7100
6663	case 653 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$	7101	case 719 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$
6664	consumeAnnotationTypeDeclarationHeaderName() ;	7102	consumeAnnotationTypeDeclarationHeaderName() ;
6665	break;	7103	break;
6666		7104
6667	case 654 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$	7105	case 720 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$
6668	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;	7106	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;
6669	break;	7107	break;
6670		7108
6671	case 655 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$	7109	case 721 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$
6672	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;	7110	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;
6673	break;	7111	break;
6674		7112
6675	case 656 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$	7113	case 722 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$
6676	consumeAnnotationTypeDeclarationHeaderName() ;	7114	consumeAnnotationTypeDeclarationHeaderName() ;
6677	break;	7115	break;
6678		7116
6679	case 657 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } //$NON-NLS-1$	7117	case 723 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } //$NON-NLS-1$
6680	consumeAnnotationTypeDeclarationHeader() ;	7118	consumeAnnotationTypeDeclarationHeader() ;
6681	break;	7119	break;
6682		7120
6683	case 658 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } //$NON-NLS-1$	7121	case 724 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } //$NON-NLS-1$
6684	consumeAnnotationTypeDeclaration() ;	7122	consumeAnnotationTypeDeclaration() ;
6685	break;	7123	break;
6686		7124
6687	case 660 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } //$NON-NLS-1$	7125	case 726 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } //$NON-NLS-1$
6688	consumeEmptyAnnotationTypeMemberDeclarationsopt() ;	7126	consumeEmptyAnnotationTypeMemberDeclarationsopt() ;
6689	break;	7127	break;
6690		7128
6691	case 661 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	7129	case 727 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6692	consumeAnnotationTypeMemberDeclarationsopt() ;	7130	consumeAnnotationTypeMemberDeclarationsopt() ;
6693	break;	7131	break;
6694		7132
6695	case 663 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } //$NON-NLS-1$	7133	case 729 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } //$NON-NLS-1$
6696	consumeAnnotationTypeMemberDeclarations() ;	7134	consumeAnnotationTypeMemberDeclarations() ;
6697	break;	7135	break;
6698		7136
6699	case 664 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } //$NON-NLS-1$	7137	case 730 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } //$NON-NLS-1$
6700	consumeMethodHeaderNameWithTypeParameters(true);	7138	consumeMethodHeaderNameWithTypeParameters(true, false);
6701	break;	7139	break;
6702		7140
6703	case 665 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$	7141	case 731 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$
6704	consumeMethodHeaderName(true);	7142	consumeMethodHeaderName(true);
6705	break;	7143	break;
6706		7144
6707	case 666 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } //$NON-NLS-1$	7145	case 732 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } //$NON-NLS-1$
6708	consumeEmptyMethodHeaderDefaultValue() ;	7146	consumeEmptyMethodHeaderDefaultValue() ;
6709	break;	7147	break;
6710		7148
6711	case 667 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } //$NON-NLS-1$	7149	case 733 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } //$NON-NLS-1$
6712	consumeMethodHeaderDefaultValue();	7150	consumeMethodHeaderDefaultValue();
6713	break;	7151	break;
6714		7152
6715	case 668 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } //$NON-NLS-1$	7153	case 734 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } //$NON-NLS-1$
6716	consumeMethodHeader();	7154	consumeMethodHeader();
6717	break;	7155	break;
6718		7156
6719	case 669 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } //$NON-NLS-1$	7157	case 735 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } //$NON-NLS-1$
6720	consumeAnnotationTypeMemberDeclaration() ;	7158	consumeAnnotationTypeMemberDeclaration() ;
6721	break;	7159	break;
6722		7160
6723	case 677 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } //$NON-NLS-1$	7161	case 743 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } //$NON-NLS-1$
6724	consumeAnnotationName() ;	7162	consumeAnnotationName() ;
6725	break;	7163	break;
6726		7164
6727	case 678 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$	7165	case 744 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$
6728	consumeNormalAnnotation() ;	7166	consumeNormalAnnotation() ;
6729	break;	7167	break;
6730		7168
6731	case 679 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } //$NON-NLS-1$	7169	case 745 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } //$NON-NLS-1$
6732	consumeEmptyMemberValuePairsopt() ;	7170	consumeEmptyMemberValuePairsopt() ;
6733	break;	7171	break;
6734		7172
6735	case 682 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } //$NON-NLS-1$	7173	case 748 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } //$NON-NLS-1$
6736	consumeMemberValuePairs() ;	7174	consumeMemberValuePairs() ;
6737	break;	7175	break;
6738		7176
6739	case 683 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } //$NON-NLS-1$	7177	case 749 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } //$NON-NLS-1$
6740	consumeMemberValuePair() ;	7178	consumeMemberValuePair() ;
6741	break;	7179	break;
6742		7180
6743	case 684 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } //$NON-NLS-1$	7181	case 750 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } //$NON-NLS-1$
6744	consumeEnterMemberValue() ;	7182	consumeEnterMemberValue() ;
6745	break;	7183	break;
6746		7184
6747	case 685 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } //$NON-NLS-1$	7185	case 751 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } //$NON-NLS-1$
6748	consumeExitMemberValue() ;	7186	consumeExitMemberValue() ;
6749	break;	7187	break;
6750		7188
6751	case 687 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } //$NON-NLS-1$	7189	case 753 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } //$NON-NLS-1$
6752	consumeMemberValueAsName() ;	7190	consumeMemberValueAsName() ;
6753	break;	7191	break;
6754		7192
6755	case 690 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7193	case 756 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6756	consumeMemberValueArrayInitializer() ;	7194	consumeMemberValueArrayInitializer() ;
6757	break;	7195	break;
6758		7196
6759	case 691 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7197	case 757 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6760	consumeMemberValueArrayInitializer() ;	7198	consumeMemberValueArrayInitializer() ;
6761	break;	7199	break;
6762		7200
6763	case 692 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7201	case 758 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6764	consumeEmptyMemberValueArrayInitializer() ;	7202	consumeEmptyMemberValueArrayInitializer() ;
6765	break;	7203	break;
6766		7204
6767	case 693 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7205	case 759 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6768	consumeEmptyMemberValueArrayInitializer() ;	7206	consumeEmptyMemberValueArrayInitializer() ;
6769	break;	7207	break;
6770		7208
6771	case 694 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); } //$NON-NLS-1$	7209	case 760 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); } //$NON-NLS-1$
6772	consumeEnterMemberValueArrayInitializer() ;	7210	consumeEnterMemberValueArrayInitializer() ;
6773	break;	7211	break;
6774		7212
6775	case 696 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } //$NON-NLS-1$	7213	case 762 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } //$NON-NLS-1$
6776	consumeMemberValues() ;	7214	consumeMemberValues() ;
6777	break;	7215	break;
6778		7216
6779	case 697 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } //$NON-NLS-1$	7217	case 763 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } //$NON-NLS-1$
6780	consumeMarkerAnnotation() ;	7218	consumeMarkerAnnotation() ;
6781	break;	7219	break;
6782		7220
6783	case 698 : if (DEBUG) { System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); } //$NON-NLS-1$	7221	case 764 : if (DEBUG) { System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); } //$NON-NLS-1$
6784	consumeSingleMemberAnnotationMemberValue() ;	7222	consumeSingleMemberAnnotationMemberValue() ;
6785	break;	7223	break;
6786		7224
6787	case 699 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$	7225	case 765 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$
6788	consumeSingleMemberAnnotation() ;	7226	consumeSingleMemberAnnotation() ;
6789	break;	7227	break;
6790		7228
6791	case 700 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$	7229	case 766 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$
6792	consumeRecoveryMethodHeaderNameWithTypeParameters();	7230	consumeRecoveryMethodHeaderNameWithTypeParameters(false);
6793	break;	7231	break;
6794		7232
6795	case 701 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$	7233	case 767 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$
		7234	consumeRecoveryMethodHeaderNameWithTypeParameters(true);
		7235	break;
		7236
		7237	case 768 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$
6796	consumeRecoveryMethodHeaderName();	7238	consumeRecoveryMethodHeaderName();
6797	break;	7239	break;
6798		7240
6799	case 702 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$	7241	case 769 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
6800	consumeMethodHeader();	7242	consumeMethodHeader();
6801	break;	7243	break;
6802		7244
6803	case 703 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$	7245	case 770 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
6804	consumeMethodHeader();	7246	consumeMethodHeader();
6805	break;	7247	break;
6806		7248
6807	}	7249	}
6808	}	7250	}
		7251	protected void consumeTypeAnnotation (boolean markAsUnattached) {
		7252	if(!this.statementRecoveryActivated &&
		7253	this.options.sourceLevel < ClassFileConstants.JDK1_7 &&
		7254	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		7255	problemReporter().invalidUsageOfTypeAnnotations((Annotation) this.expressionStack[this.expressionPtr]);
		7256	}
		7257	this.expressionLengthPtr --;
		7258	Annotation annotation = (Annotation) this.expressionStack[this.expressionPtr--];
		7259	pushOnTypeAnnotationStack(annotation);
		7260	if (markAsUnattached) {
		7261	if (this.unattachedAnnotationPtr == -1) {
		7262	this.unattachedAnnotationPtr = this.typeAnnotationPtr;
		7263	} else {
		7264	this.typeAnnotationLengthStack[--this.typeAnnotationLengthPtr]++;
		7265	}
		7266	}
		7267	}
		7268	protected void consumeDimsWithTrailingAnnotsopt() {
		7269	// DimsoptAnnotsopt -> DimsAnnotLoop
		7270	pushOnIntStack(this.dimensions);
		7271	this.dimensions = 0;
		7272	if (this.unattachedAnnotationPtr == -1) {
		7273	pushOnTypeAnnotationLengthStack(0); // no trailing annotations (receiver/vararg)
		7274	} else {
		7275	this.unattachedAnnotationPtr = -1; // reset this and leave the annotation stacks as they are.
		7276	}
		7277	}
		7278	protected void consumeZeroTypeAnnotations() {
		7279	pushOnTypeAnnotationLengthStack(0);
		7280	}
		7281	protected void consumeEmptyDimsoptAnnotsopt() {
		7282	// DimsoptAnnotsopt ::= $empty
		7283	pushOnIntStack(0); // signal a non array
		7284	pushOnTypeAnnotationLengthStack(0); // no trailing annotations (receiver/vararg)
		7285	}
6809	protected void consumeSimpleAssertStatement() {	7286	protected void consumeSimpleAssertStatement() {
6810	// AssertStatement ::= 'assert' Expression ';'	7287	// AssertStatement ::= 'assert' Expression ';'
6811	this.expressionLengthPtr--;	7288	this.expressionLengthPtr--;
Lines 7673-7680 Link Here
7673	// case TokenNameGREATER :	8150	// case TokenNameGREATER :
7674	}	8151	}
7675	}	8152	}
7676	protected void consumeTypeArgument() {	8153	protected void consumeTypeArgument(boolean hasTypeAnnotations) {
7677	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	8154	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
7678	}	8155	}
7679	protected void consumeTypeArgumentList() {	8156	protected void consumeTypeArgumentList() {
7680	concatGenericsLists();	8157	concatGenericsLists();
Lines 7688-7701 Link Here
7688	protected void consumeTypeArgumentList3() {	8165	protected void consumeTypeArgumentList3() {
7689	concatGenericsLists();	8166	concatGenericsLists();
7690	}	8167	}
7691	protected void consumeTypeArgumentReferenceType1() {	8168	protected void consumeTypeArgumentReferenceType1(boolean hasTypeAnnotations) {
7692	concatGenericsLists();	8169	concatGenericsLists();
7693	pushOnGenericsStack(getTypeReference(0));	8170	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(0) : getUnannotatedTypeReference(0));
7694	this.intPtr--;	8171	this.intPtr--;
7695	}	8172	}
7696	protected void consumeTypeArgumentReferenceType2() {	8173	protected void consumeTypeArgumentReferenceType2(boolean hasTypeAnnotations) {
7697	concatGenericsLists();	8174	concatGenericsLists();
7698	pushOnGenericsStack(getTypeReference(0));	8175	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(0) : getUnannotatedTypeReference(0));
7699	this.intPtr--;	8176	this.intPtr--;
7700	}	8177	}
7701	protected void consumeTypeArguments() {	8178	protected void consumeTypeArguments() {
Lines 7780-7792 Link Here
7780	superType.bits \|= ASTNode.IsSuperType;	8257	superType.bits \|= ASTNode.IsSuperType;
7781	this.genericsStack[this.genericsPtr] = typeParameter;	8258	this.genericsStack[this.genericsPtr] = typeParameter;
7782	}	8259	}
7783	protected void consumeTypeParameter1WithExtendsAndBounds() {	8260	protected void consumeTypeParameter1WithExtendsAndBounds(boolean hasTypeAnnotations) {
7784	//TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1	8261	//TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1
7785	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];	8262	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];
7786	TypeReference[] bounds = new TypeReference[additionalBoundsLength];	8263	TypeReference[] bounds = new TypeReference[additionalBoundsLength];
7787	this.genericsPtr -= additionalBoundsLength;	8264	this.genericsPtr -= additionalBoundsLength;
7788	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);	8265	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);
7789	TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);	8266	TypeReference superType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
7790	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	8267	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
7791	typeParameter.declarationSourceEnd = bounds[additionalBoundsLength - 1].sourceEnd;	8268	typeParameter.declarationSourceEnd = bounds[additionalBoundsLength - 1].sourceEnd;
7792	typeParameter.type = superType;	8269	typeParameter.type = superType;
Lines 7799-7804 Link Here
7799	protected void consumeTypeParameterHeader() {	8276	protected void consumeTypeParameterHeader() {
7800	//TypeParameterHeader ::= Identifier	8277	//TypeParameterHeader ::= Identifier
7801	TypeParameter typeParameter = new TypeParameter();	8278	TypeParameter typeParameter = new TypeParameter();
		8279	int length;
		8280	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		8281	System.arraycopy(
		8282	this.typeAnnotationStack,
		8283	(this.typeAnnotationPtr -= length) + 1,
		8284	typeParameter.annotations = new Annotation[length],
		8285	0,
		8286	length);
		8287	}
7802	long pos = this.identifierPositionStack[this.identifierPtr];	8288	long pos = this.identifierPositionStack[this.identifierPtr];
7803	final int end = (int) pos;	8289	final int end = (int) pos;
7804	typeParameter.declarationSourceEnd = end;	8290	typeParameter.declarationSourceEnd = end;
Lines 7844-7864 Link Here
7844	(TypeParameter) this.genericsStack[this.genericsPtr]);	8330	(TypeParameter) this.genericsStack[this.genericsPtr]);
7845	}	8331	}
7846	}	8332	}
7847	protected void consumeTypeParameterWithExtends() {	8333	protected void consumeTypeParameterWithExtends(boolean hasTypeAnnotations) {
7848	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType	8334	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType
7849	TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);	8335	TypeReference superType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
7850	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	8336	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
7851	typeParameter.declarationSourceEnd = superType.sourceEnd;	8337	typeParameter.declarationSourceEnd = superType.sourceEnd;
7852	typeParameter.type = superType;	8338	typeParameter.type = superType;
7853	superType.bits \|= ASTNode.IsSuperType;	8339	superType.bits \|= ASTNode.IsSuperType;
7854	}	8340	}
7855	protected void consumeTypeParameterWithExtendsAndBounds() {	8341	protected void consumeTypeParameterWithExtendsAndBounds(boolean hasTypeAnnotations) {
7856	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList	8342	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList
7857	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];	8343	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];
7858	TypeReference[] bounds = new TypeReference[additionalBoundsLength];	8344	TypeReference[] bounds = new TypeReference[additionalBoundsLength];
7859	this.genericsPtr -= additionalBoundsLength;	8345	this.genericsPtr -= additionalBoundsLength;
7860	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);	8346	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);
7861	TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);	8347	TypeReference superType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
7862	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	8348	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
7863	typeParameter.type = superType;	8349	typeParameter.type = superType;
7864	superType.bits \|= ASTNode.IsSuperType;	8350	superType.bits \|= ASTNode.IsSuperType;
Lines 8030-8046 Link Here
8030	wildcard.sourceStart = this.intStack[this.intPtr--];	8516	wildcard.sourceStart = this.intStack[this.intPtr--];
8031	this.genericsStack[this.genericsPtr] = wildcard;	8517	this.genericsStack[this.genericsPtr] = wildcard;
8032	}	8518	}
8033	protected void consumeWildcardBoundsExtends() {	8519	protected void consumeWildcardBoundsExtends(boolean hasTypeAnnotations) {
8034	Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);	8520	Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
8035	wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);	8521	wildcard.bound = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
8036	wildcard.sourceEnd = wildcard.bound.sourceEnd;	8522	wildcard.sourceEnd = wildcard.bound.sourceEnd;
8037	this.intPtr--; // remove end position of the '?'	8523	this.intPtr--; // remove end position of the '?'
8038	wildcard.sourceStart = this.intStack[this.intPtr--];	8524	wildcard.sourceStart = this.intStack[this.intPtr--];
8039	pushOnGenericsStack(wildcard);	8525	pushOnGenericsStack(wildcard);
8040	}	8526	}
8041	protected void consumeWildcardBoundsSuper() {	8527	protected void consumeWildcardBoundsSuper(boolean hasTypeAnnotations) {
8042	Wildcard wildcard = new Wildcard(Wildcard.SUPER);	8528	Wildcard wildcard = new Wildcard(Wildcard.SUPER);
8043	wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);	8529	wildcard.bound = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
8044	this.intPtr--; // remove the starting position of the super keyword	8530	this.intPtr--; // remove the starting position of the super keyword
8045	wildcard.sourceEnd = wildcard.bound.sourceEnd;	8531	wildcard.sourceEnd = wildcard.bound.sourceEnd;
8046	this.intPtr--; // remove end position of the '?'	8532	this.intPtr--; // remove end position of the '?'
Lines 8096-8101 Link Here
8096	protected TypeReference copyDims(TypeReference typeRef, int dim) {	8582	protected TypeReference copyDims(TypeReference typeRef, int dim) {
8097	return typeRef.copyDims(dim);	8583	return typeRef.copyDims(dim);
8098	}	8584	}
		8585
		8586	protected TypeReference copyDims(TypeReference typeRef, int dim, Annotation[][]annotationsOnDimensions) {
		8587	return typeRef.copyDims(dim, annotationsOnDimensions);
		8588	}
		8589
8099	protected FieldDeclaration createFieldDeclaration(char[] fieldDeclarationName, int sourceStart, int sourceEnd) {	8590	protected FieldDeclaration createFieldDeclaration(char[] fieldDeclarationName, int sourceStart, int sourceEnd) {
8100	return new FieldDeclaration(fieldDeclarationName, sourceStart, sourceEnd);	8591	return new FieldDeclaration(fieldDeclarationName, sourceStart, sourceEnd);
8101	}	8592	}
Lines 8576-8588 Link Here
8576	return exp;	9067	return exp;
8577	}	9068	}
8578	protected TypeReference getTypeReference(int dim) {	9069	protected TypeReference getTypeReference(int dim) {
		9070	TypeReference ref = getUnannotatedTypeReference(dim);
		9071	int length;
		9072	if (this.typeAnnotationLengthPtr >= 0 && (length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		9073	System.arraycopy(
		9074	this.typeAnnotationStack,
		9075	(this.typeAnnotationPtr -= length) + 1,
		9076	ref.annotations = new Annotation[length],
		9077	0,
		9078	length);
		9079	}
		9080	return ref;
		9081	}
		9082	protected TypeReference getUnannotatedTypeReference(int dim) {
8579	/* build a Reference on a variable that may be qualified or not	9083	/* build a Reference on a variable that may be qualified or not
8580	This variable is a type reference and dim will be its dimensions*/	9084	This variable is a type reference and dim will be its dimensions*/
8581		9085
8582	TypeReference ref;	9086	TypeReference ref;
		9087	Annotation [][] annotationsOnDimensions = null;
8583	int length = this.identifierLengthStack[this.identifierLengthPtr--];	9088	int length = this.identifierLengthStack[this.identifierLengthPtr--];
8584	if (length < 0) { //flag for precompiled type reference on base types	9089	if (length < 0) { //flag for precompiled type reference on base types
8585	ref = TypeReference.baseTypeReference(-length, dim);	9090	if (dim > 0) {
		9091	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		9092	}
		9093	ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
8586	ref.sourceStart = this.intStack[this.intPtr--];	9094	ref.sourceStart = this.intStack[this.intPtr--];
8587	if (dim == 0) {	9095	if (dim == 0) {
8588	ref.sourceEnd = this.intStack[this.intPtr--];	9096	ref.sourceEnd = this.intStack[this.intPtr--];
Lines 8604-8613 Link Here
8604	this.identifierStack[this.identifierPtr],	9112	this.identifierStack[this.identifierPtr],
8605	this.identifierPositionStack[this.identifierPtr--]);	9113	this.identifierPositionStack[this.identifierPtr--]);
8606	} else {	9114	} else {
		9115	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
8607	ref =	9116	ref =
8608	new ArrayTypeReference(	9117	new ArrayTypeReference(
8609	this.identifierStack[this.identifierPtr],	9118	this.identifierStack[this.identifierPtr],
8610	dim,	9119	dim,
		9120	annotationsOnDimensions,
8611	this.identifierPositionStack[this.identifierPtr--]);	9121	this.identifierPositionStack[this.identifierPtr--]);
8612	ref.sourceEnd = this.endPosition;	9122	ref.sourceEnd = this.endPosition;
8613	}	9123	}
Lines 8627-8633 Link Here
8627	if (dim == 0) {	9137	if (dim == 0) {
8628	ref = new QualifiedTypeReference(tokens, positions);	9138	ref = new QualifiedTypeReference(tokens, positions);
8629	} else {	9139	} else {
8630	ref = new ArrayQualifiedTypeReference(tokens, dim, positions);	9140	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		9141	ref = new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
8631	ref.sourceEnd = this.endPosition;	9142	ref.sourceEnd = this.endPosition;
8632	}	9143	}
8633	}	9144	}
Lines 8635-8646 Link Here
8635	return ref;	9146	return ref;
8636	}	9147	}
8637	protected TypeReference getTypeReferenceForGenericType(int dim, int identifierLength, int numberOfIdentifiers) {	9148	protected TypeReference getTypeReferenceForGenericType(int dim, int identifierLength, int numberOfIdentifiers) {
		9149	Annotation[][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
8638	if (identifierLength == 1 && numberOfIdentifiers == 1) {	9150	if (identifierLength == 1 && numberOfIdentifiers == 1) {
8639	int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];	9151	int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];
8640	TypeReference[] typeArguments = new TypeReference[currentTypeArgumentsLength];	9152	TypeReference[] typeArguments = new TypeReference[currentTypeArgumentsLength];
8641	this.genericsPtr -= currentTypeArgumentsLength;	9153	this.genericsPtr -= currentTypeArgumentsLength;
8642	System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeArguments, 0, currentTypeArgumentsLength);	9154	System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeArguments, 0, currentTypeArgumentsLength);
8643	ParameterizedSingleTypeReference parameterizedSingleTypeReference = new ParameterizedSingleTypeReference(this.identifierStack[this.identifierPtr], typeArguments, dim, this.identifierPositionStack[this.identifierPtr--]);	9155	ParameterizedSingleTypeReference parameterizedSingleTypeReference = new ParameterizedSingleTypeReference(this.identifierStack[this.identifierPtr], typeArguments, dim, annotationsOnDimensions, this.identifierPositionStack[this.identifierPtr--]);
8644	if (dim != 0) {	9156	if (dim != 0) {
8645	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;	9157	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;
8646	}	9158	}
Lines 8674-8680 Link Here
8674	currentIdentifiersLength = this.identifierLengthStack[this.identifierLengthPtr--];	9186	currentIdentifiersLength = this.identifierLengthStack[this.identifierLengthPtr--];
8675	}	9187	}
8676	}	9188	}
8677	ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference = new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, positions);	9189	ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference = new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, annotationsOnDimensions, positions);
8678	if (dim != 0) {	9190	if (dim != 0) {
8679	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;	9191	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;
8680	}	9192	}
Lines 8895-8900 Link Here
8895	this.astLengthPtr = -1;	9407	this.astLengthPtr = -1;
8896	this.expressionPtr = -1;	9408	this.expressionPtr = -1;
8897	this.expressionLengthPtr = -1;	9409	this.expressionLengthPtr = -1;
		9410	this.unattachedAnnotationPtr = -1;
		9411	this.typeAnnotationLengthPtr = -1;
		9412	this.typeAnnotationPtr = -1;
8898	this.identifierPtr = -1;	9413	this.identifierPtr = -1;
8899	this.identifierLengthPtr = -1;	9414	this.identifierLengthPtr = -1;
8900	this.intPtr = -1;	9415	this.intPtr = -1;
Lines 10025-10030 Link Here
10025	}	10540	}
10026	this.astLengthStack[this.astLengthPtr] = 1;	10541	this.astLengthStack[this.astLengthPtr] = 1;
10027	}	10542	}
		10543	protected void pushOnTypeAnnotationStack(Annotation annotation) {
		10544
		10545	int stackLength = this.typeAnnotationStack.length;
		10546	if (++this.typeAnnotationPtr >= stackLength) {
		10547	System.arraycopy(
		10548	this.typeAnnotationStack, 0,
		10549	this.typeAnnotationStack = new Annotation[stackLength + TypeAnnotationStackIncrement], 0,
		10550	stackLength);
		10551	}
		10552	this.typeAnnotationStack[this.typeAnnotationPtr] = annotation;
		10553
		10554	stackLength = this.typeAnnotationLengthStack.length;
		10555	if (++this.typeAnnotationLengthPtr >= stackLength) {
		10556	System.arraycopy(
		10557	this.typeAnnotationLengthStack, 0,
		10558	this.typeAnnotationLengthStack = new int[stackLength + TypeAnnotationStackIncrement], 0,
		10559	stackLength);
		10560	}
		10561	this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr] = 1;
		10562	}
		10563	protected void pushOnTypeAnnotationLengthStack(int pos) {
		10564
		10565	int stackLength = this.typeAnnotationLengthStack.length;
		10566	if (++this.typeAnnotationLengthPtr >= stackLength) {
		10567	System.arraycopy(
		10568	this.typeAnnotationLengthStack, 0,
		10569	this.typeAnnotationLengthStack = new int[stackLength + TypeAnnotationStackIncrement], 0,
		10570	stackLength);
		10571	}
		10572	this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr] = pos;
		10573	}
10028	protected void pushOnExpressionStack(Expression expr) {	10574	protected void pushOnExpressionStack(Expression expr) {
10029		10575
10030	int stackLength = this.expressionStack.length;	10576	int stackLength = this.expressionStack.length;
Lines 10445-10450 Link Here
10445	this.astLengthPtr = -1;	10991	this.astLengthPtr = -1;
10446	this.expressionPtr = -1;	10992	this.expressionPtr = -1;
10447	this.expressionLengthPtr = -1;	10993	this.expressionLengthPtr = -1;
		10994	this.unattachedAnnotationPtr = -1;
		10995	this.typeAnnotationLengthPtr = -1;
		10996	this.typeAnnotationPtr = -1;
10448	this.identifierPtr = -1;	10997	this.identifierPtr = -1;
10449	this.identifierLengthPtr = -1;	10998	this.identifierLengthPtr = -1;
10450	this.intPtr = -1;	10999	this.intPtr = -1;

Lines 1227-1232 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+6 lines)
1227	int UnusedWarningToken = Internal + 635;	1227	int UnusedWarningToken = Internal + 635;
1228	/** @since 3.6 */	1228	/** @since 3.6 */
1229	int MissingOverrideAnnotationForInterfaceMethodImplementation = MethodRelated + 636;	1229	int MissingOverrideAnnotationForInterfaceMethodImplementation = MethodRelated + 636;
		1230	/** @since 3.6 */
		1231	int InvalidUsageOfTypeAnnotations = Syntax + Internal + 637;
		1232	/** @since 3.6 */
		1233	int InvalidUsageOfReceiverAnnotations = Syntax + Internal + 638;
		1234	/** @since 3.6 */
		1235	int misplacedTypeAnnotations = Syntax + Internal + 639;
1230		1236
1231	/**	1237	/**
1232	* More problems in generics	1238	* More problems in generics

Lines 561-567 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (-1 / +3 lines)
561	634 = The method {0}({1}) of type {2} must override or implement a supertype method	561	634 = The method {0}({1}) of type {2} must override or implement a supertype method
562	635 = Unnecessary @SuppressWarnings("{0}")	562	635 = Unnecessary @SuppressWarnings("{0}")
563	636 = The method {0}({1}) of type {2} should be tagged with @Override since it actually overrides a superinterface method	563	636 = The method {0}({1}) of type {2} should be tagged with @Override since it actually overrides a superinterface method
564		564	637 = Syntax error, type annotations are available only when source level is at least 1.7
		565	638 = Receiver annotations are illegal in a static method context
		566	639 = Syntax error, type annotations are illegal here
565	### MORE GENERICS	567	### MORE GENERICS
566	660 = Unused type arguments for the non generic constructor {0}({1}) of type {2}; it should not be parameterized with arguments <{3}>	568	660 = Unused type arguments for the non generic constructor {0}({1}) of type {2}; it should not be parameterized with arguments <{3}>
567		569




		typeRef.sourceStart,
		typeRef.sourceEnd);
}

public void invalidUsageOfTypeAnnotations(Annotation annotation) {
	this.handle(
			IProblem.InvalidUsageOfTypeAnnotations,
			NoArgument,
			NoArgument,
			annotation.sourceStart,
			annotation.sourceEnd);
}

public void illegalReceiverAnnotations(Annotation first, Annotation last) {
	this.handle(
			IProblem.InvalidUsageOfReceiverAnnotations,
			NoArgument,
			NoArgument,
			first.sourceStart,
			last.sourceEnd);	
}

public void misplacedTypeAnnotations(Annotation first, Annotation last) {
	this.handle(
			IProblem.misplacedTypeAnnotations,
			NoArgument,
			NoArgument,
			first.sourceStart,
			last.sourceEnd);	
}
}

Lines 721-726 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetParser.java (+3 lines)
721		721
722	// reset stacks in consistent state	722	// reset stacks in consistent state
723	this.expressionPtr = -1;	723	this.expressionPtr = -1;
		724	this.unattachedAnnotationPtr = -1;
		725	this.typeAnnotationLengthPtr = -1;
		726	this.typeAnnotationPtr = -1;
724	this.identifierPtr = -1;	727	this.identifierPtr = -1;
725	this.identifierLengthPtr = -1;	728	this.identifierLengthPtr = -1;
726		729




		super.classInstanceCreation(hasClassBody);
	}
}
protected void consumeArrayCreationExpressionWithoutInitializer(boolean hasTypeAnnotations) {
	// ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs
	// ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs

	super.consumeArrayCreationExpressionWithoutInitializer(hasTypeAnnotations);

	ArrayAllocationExpression alloc = (ArrayAllocationExpression)this.expressionStack[this.expressionPtr];
	if (alloc.type == this.assistNode){

		this.isOrphanCompletionNode = true;
	}
}
protected void consumeArrayCreationExpressionWithInitializer(boolean hasTypeAnnotations) {
	// ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer

	super.consumeArrayCreationExpressionWithInitializer(hasTypeAnnotations);

	ArrayAllocationExpression alloc = (ArrayAllocationExpression)this.expressionStack[this.expressionPtr];
	if (alloc.type == this.assistNode){

		this.isOrphanCompletionNode = true;
	}
}
protected void consumeCastExpressionLL1(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);
	super.consumeCastExpressionLL1(hasTypeAnnotations);
}
protected void consumeCastExpressionWithGenericsArray(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);
	super.consumeCastExpressionWithGenericsArray(hasTypeAnnotations);
}
protected void consumeCastExpressionWithNameArray(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);
	super.consumeCastExpressionWithNameArray(hasTypeAnnotations);
}
protected void consumeCastExpressionWithPrimitiveType(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);
	super.consumeCastExpressionWithPrimitiveType(hasTypeAnnotations);
}
protected void consumeCastExpressionWithQualifiedGenericsArray(boolean hasTypeAnnotations) {
	popElement(K_CAST_STATEMENT);
	super.consumeCastExpressionWithQualifiedGenericsArray(hasTypeAnnotations);
}
protected void consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() {
	// ClassInstanceCreationExpression ::= Primary '.' 'new' TypeArguments SimpleName '(' ArgumentListopt ')' ClassBodyopt

		}
		int firstDimensions = this.intStack[this.intPtr--];
		final int typeDimensions = firstDimensions + extendedDimensions;
		TypeReference type = getUnannotatedTypeReference(typeDimensions);
		if (isVarArgs) {
			type = copyDims(type, typeDimensions + 1);
			if (extendedDimensions == 0) {

Return to bug 287648

Lines 7422-7425 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (+27 lines)
7422	typeRef.sourceStart,	7422	typeRef.sourceStart,
7423	typeRef.sourceEnd);	7423	typeRef.sourceEnd);
7424	}	7424	}
		7425
		7426	public void invalidUsageOfTypeAnnotations(Annotation annotation) {
		7427	this.handle(
		7428	IProblem.InvalidUsageOfTypeAnnotations,
		7429	NoArgument,
		7430	NoArgument,
		7431	annotation.sourceStart,
		7432	annotation.sourceEnd);
		7433	}
		7434
		7435	public void illegalReceiverAnnotations(Annotation first, Annotation last) {
		7436	this.handle(
		7437	IProblem.InvalidUsageOfReceiverAnnotations,
		7438	NoArgument,
		7439	NoArgument,
		7440	first.sourceStart,
		7441	last.sourceEnd);
		7442	}
		7443
		7444	public void misplacedTypeAnnotations(Annotation first, Annotation last) {
		7445	this.handle(
		7446	IProblem.misplacedTypeAnnotations,
		7447	NoArgument,
		7448	NoArgument,
		7449	first.sourceStart,
		7450	last.sourceEnd);
		7451	}
7425	}	7452	}

Lines 1456-1476 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java (-15 / +15 lines)
1456	expected13ProblemLog;	1456	expected13ProblemLog;
1457		1457
1458	String expected15ProblemLog =	1458	String expected15ProblemLog =
1459	"----------\n" +	1459	"----------\n" +
1460	"1. WARNING in X.java (at line 1)\n" +	1460	"1. WARNING in X.java (at line 1)\n" +
1461	" public class X <T1 extends String, T2 extends Y {\n" +	1461	" public class X <T1 extends String, T2 extends Y {\n" +
1462	" ^^^^^^\n" +	1462	" ^^^^^^\n" +
1463	"The type parameter T1 should not be bounded by the final type String. Final types cannot be further extended\n" +	1463	"The type parameter T1 should not be bounded by the final type String. Final types cannot be further extended\n" +
1464	"----------\n" +	1464	"----------\n" +
1465	"2. ERROR in X.java (at line 1)\n" +	1465	"2. ERROR in X.java (at line 1)\n" +
1466	" public class X <T1 extends String, T2 extends Y {\n" +	1466	" public class X <T1 extends String, T2 extends Y {\n" +
1467	" ^\n" +	1467	" ^\n" +
1468	"Syntax error, insert \">\" to complete ReferenceType1\n" +	1468	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
1469	"----------\n" +	1469	"----------\n" +
1470	"3. ERROR in X.java (at line 1)\n" +	1470	"3. ERROR in X.java (at line 1)\n" +
1471	" public class X <T1 extends String, T2 extends Y {\n" +	1471	" public class X <T1 extends String, T2 extends Y {\n" +
1472	" ^\n" +	1472	" ^\n" +
1473	"Y cannot be resolved to a type\n" +	1473	"Y cannot be resolved to a type\n" +
1474	"----------\n";	1474	"----------\n";
1475		1475
1476	runComplianceParserTest(	1476	runComplianceParserTest(

Lines 166-182 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/SyntaxErrorTest.java (-4 / +4 lines)
166	"1. ERROR in <parenthesis mismatch> (at line 3)\n" +	166	"1. ERROR in <parenthesis mismatch> (at line 3)\n" +
167	" [ arg1, \n" +	167	" [ arg1, \n" +
168	" ^\n" +	168	" ^\n" +
169	"Syntax error on token \"[\", invalid Type\n" +	169	"Syntax error on token \"[\", boolean expected\n" +
170	"----------\n" +	170	"----------\n" +
171	"2. ERROR in <parenthesis mismatch> (at line 4)\n" +	171	"2. ERROR in <parenthesis mismatch> (at line 4)\n" +
172	" { arg2, ] \n" +	172	" { arg2, ] \n" +
173	" ^\n" +	173	" ^\n" +
174	"Syntax error on token \"{\", invalid Type\n" +	174	"Syntax error on token \"{\", boolean expected\n" +
175	"----------\n" +	175	"----------\n" +
176	"3. ERROR in <parenthesis mismatch> (at line 4)\n" +	176	"3. ERROR in <parenthesis mismatch> (at line 4)\n" +
177	" { arg2, ] \n" +	177	" { arg2, ] \n" +
178	" ^\n" +	178	" ^\n" +
179	"Syntax error on token \"]\", invalid Type\n" +	179	"Syntax error on token \"]\", boolean expected\n" +
180	"----------\n" +	180	"----------\n" +
181	"4. ERROR in <parenthesis mismatch> (at line 5)\n" +	181	"4. ERROR in <parenthesis mismatch> (at line 5)\n" +
182	" arg3, \n" +	182	" arg3, \n" +
Lines 273-279 Link Here
273	"1. ERROR in <test> (at line 3)\n"+	273	"1. ERROR in <test> (at line 3)\n"+
274	" i; \n"+	274	" i; \n"+
275	" ^\n"+	275	" ^\n"+
276	"Syntax error, insert \"AssignmentOperator Expression\" to complete Expression\n"+	276	"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration\n" +
277	"----------\n";	277	"----------\n";
278		278
279	String testName = "<test>";	279	String testName = "<test>";

Lines 1870-1892 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (-47 / +46 lines)
1870	" A2 a2;\n" +	1870	" A2 a2;\n" +
1871	"}\n"	1871	"}\n"
1872	},	1872	},
1873	"----------\n" +	1873	"----------\n" +
1874	"1. ERROR in test\\X1.java (at line 3)\n" +	1874	"1. ERROR in test\\X1.java (at line 3)\n" +
1875	" public class X1<A1 extends X2<A2> {\n" +	1875	" public class X1<A1 extends X2<A2> {\n" +
1876	" ^^\n" +	1876	" ^^\n" +
1877	"A2 cannot be resolved to a type\n" +	1877	"A2 cannot be resolved to a type\n" +
1878	"----------\n" +	1878	"----------\n" +
1879	"2. ERROR in test\\X1.java (at line 3)\n" +	1879	"2. ERROR in test\\X1.java (at line 3)\n" +
1880	" public class X1<A1 extends X2<A2> {\n" +	1880	" public class X1<A1 extends X2<A2> {\n" +
1881	" ^\n" +	1881	" ^\n" +
1882	"Syntax error, insert \">\" to complete ReferenceType1\n" +	1882	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
1883	"----------\n" +	1883	"----------\n" +
1884	"3. ERROR in test\\X1.java (at line 7)\n" +	1884	"3. ERROR in test\\X1.java (at line 7)\n" +
1885	" class X2<A2 {\n" +	1885	" class X2<A2 {\n" +
1886	" ^^\n" +	1886	" ^^\n" +
1887	"Syntax error on token \"A2\", > expected after this token\n" +	1887	"Syntax error, insert \">\" to complete TypeParameter1\n" +
1888	"----------\n"	1888	"----------\n" );
1889	);
1890	}	1889	}
1891		1890
1892	// JSR14-V10[2.4]: Not terminated consecutive declaration	1891	// JSR14-V10[2.4]: Not terminated consecutive declaration
Lines 2311-2336 Link Here
2311	"class X2<A extends X3<String> {}\n" +	2310	"class X2<A extends X3<String> {}\n" +
2312	"class X3<A {}\n"	2311	"class X3<A {}\n"
2313	},	2312	},
2314	"----------\n" +	2313	"----------\n" +
2315	"1. ERROR in test\\X.java (at line 2)\n" +	2314	"1. ERROR in test\\X.java (at line 2)\n" +
2316	" public class X<A extends X1<X2<X3<String>>> {}\n" +	2315	" public class X<A extends X1<X2<X3<String>>> {}\n" +
2317	" ^^^\n" +	2316	" ^^^\n" +
2318	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2317	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2319	"----------\n" +	2318	"----------\n" +
2320	"2. ERROR in test\\X.java (at line 3)\n" +	2319	"2. ERROR in test\\X.java (at line 3)\n" +
2321	" class X1<A extends X2<X3<String>> {}\n" +	2320	" class X1<A extends X2<X3<String>> {}\n" +
2322	" ^^\n" +	2321	" ^^\n" +
2323	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2322	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2324	"----------\n" +	2323	"----------\n" +
2325	"3. ERROR in test\\X.java (at line 4)\n" +	2324	"3. ERROR in test\\X.java (at line 4)\n" +
2326	" class X2<A extends X3<String> {}\n" +	2325	" class X2<A extends X3<String> {}\n" +
2327	" ^\n" +	2326	" ^\n" +
2328	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2327	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2329	"----------\n" +	2328	"----------\n" +
2330	"4. ERROR in test\\X.java (at line 5)\n" +	2329	"4. ERROR in test\\X.java (at line 5)\n" +
2331	" class X3<A {}\n" +	2330	" class X3<A {}\n" +
2332	" ^\n" +	2331	" ^\n" +
2333	"Syntax error on token \"A\", > expected after this token\n" +	2332	"Syntax error, insert \">\" to complete TypeParameter1\n" +
2334	"----------\n"	2333	"----------\n"
2335	);	2334	);
2336	}	2335	}
Lines 2398-2413 Link Here
2398	"class X2<A extends X3<String>> {}\n" +	2397	"class X2<A extends X3<String>> {}\n" +
2399	"class X3<A> {}\n"	2398	"class X3<A> {}\n"
2400	},	2399	},
2401	"----------\n" +	2400	"----------\n" +
2402	"1. ERROR in test\\X.java (at line 2)\n" +	2401	"1. ERROR in test\\X.java (at line 2)\n" +
2403	" public class X<A extends X1<X2<X3<String {}\n" +	2402	" public class X<A extends X1<X2<X3<String {}\n" +
2404	" ^^^^^^\n" +	2403	" ^^^^^^\n" +
2405	"Syntax error, insert \">>>\" to complete ReferenceType3\n" +	2404	"Syntax error, insert \">>>\" to complete ReferenceType3\n" +
2406	"----------\n" +	2405	"----------\n" +
2407	"2. ERROR in test\\X.java (at line 2)\n" +	2406	"2. ERROR in test\\X.java (at line 2)\n" +
2408	" public class X<A extends X1<X2<X3<String {}\n" +	2407	" public class X<A extends X1<X2<X3<String {}\n" +
2409	" ^^^^^^\n" +	2408	" ^^^^^^\n" +
2410	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2409	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2411	"----------\n");	2410	"----------\n");
2412	}	2411	}
2413	public void test0084() {	2412	public void test0084() {

Lines 14-20 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestMixed.java (-44 / +21 lines)
14		14
15	import junit.framework.Test;	15	import junit.framework.Test;
16		16
17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
18	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	17	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
19		18
20	public class JavadocTestMixed extends JavadocTest {	19	public class JavadocTestMixed extends JavadocTest {
Lines 779-827 Link Here
779	+ " return \"\";\n"	778	+ " return \"\";\n"
780	+ " }\n"	779	+ " }\n"
781	+ "}\n" },	780	+ "}\n" },
782	this.complianceLevel < ClassFileConstants.JDK1_5	781	"----------\n" +
783	? "----------\n"	782	"1. ERROR in test\\X.java (at line 23)\n" +
784	+ "1. ERROR in test\\X.java (at line 23)\n"	783	" }\n" +
785	+ " }\n"	784	" ^\n" +
786	+ " ^\n"	785	"Syntax error, insert \"}\" to complete ClassBody\n" +
787	+ "Syntax error, insert \"}\" to complete ClassBody\n"	786	"----------\n" +
788	+ "----------\n"	787	"2. ERROR in test\\X.java (at line 26)\n" +
789	+ "2. ERROR in test\\X.java (at line 26)\n"	788	" * @param list Valid param tag\n" +
790	+ " * @param list Valid param tag\n"	789	" ^^^^\n" +
791	+ " ^^^^\n"	790	"Javadoc: Parameter list is not declared\n" +
792	+ "Javadoc: Parameter list is not declared\n"	791	"----------\n" +
793	+ "----------\n"	792	"3. ERROR in test\\X.java (at line 33)\n" +
794	+ "3. ERROR in test\\X.java (at line 33)\n"	793	" public String foo(java.util.Vector ) {\n" +
795	+ " public String foo(java.util.Vector ) {\n"	794	" ^^^^^^\n" +
796	+ " ^^^^^^\n"	795	"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameterList\n" +
797	+ "Syntax error on token \"Vector\", VariableDeclaratorId expected after this token\n"	796	"----------\n" +
798	+ "----------\n"	797	"4. ERROR in test\\X.java (at line 36)\n" +
799	+ "4. ERROR in test\\X.java (at line 36)\n"	798	" }\n" +
800	+ " }\n"	799	" ^\n" +
801	+ " ^\n"	800	"Syntax error on token \"}\", delete this token\n" +
802	+ "Syntax error on token \"}\", delete this token\n"	801	"----------\n");
803	+ "----------\n"
804	: "----------\n"
805	+ "1. ERROR in test\\X.java (at line 23)\n"
806	+ " }\n"
807	+ " ^\n"
808	+ "Syntax error, insert \"}\" to complete ClassBody\n"
809	+ "----------\n"
810	+ "2. ERROR in test\\X.java (at line 26)\n"
811	+ " * @param list Valid param tag\n"
812	+ " ^^^^\n"
813	+ "Javadoc: Parameter list is not declared\n"
814	+ "----------\n"
815	+ "3. ERROR in test\\X.java (at line 33)\n"
816	+ " public String foo(java.util.Vector ) {\n"
817	+ " ^\n"
818	+ "Syntax error on token \".\", ... expected\n"
819	+ "----------\n"
820	+ "4. ERROR in test\\X.java (at line 36)\n"
821	+ " }\n"
822	+ " ^\n"
823	+ "Syntax error on token \"}\", delete this token\n"
824	+ "----------\n");
825	}	802	}
826		803
827	public void test040() {	804	public void test040() {

Lines 568-574 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (+6 lines)
568	expectedProblemAttributes.put("InvalidUsageOfAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	568	expectedProblemAttributes.put("InvalidUsageOfAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
569	expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	569	expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
570	expectedProblemAttributes.put("InvalidUsageOfForeachStatements", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	570	expectedProblemAttributes.put("InvalidUsageOfForeachStatements", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		571	expectedProblemAttributes.put("InvalidUsageOfReceiverAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
571	expectedProblemAttributes.put("InvalidUsageOfStaticImports", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	572	expectedProblemAttributes.put("InvalidUsageOfStaticImports", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		573	expectedProblemAttributes.put("InvalidUsageOfTypeAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
572	expectedProblemAttributes.put("InvalidUsageOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	574	expectedProblemAttributes.put("InvalidUsageOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
573	expectedProblemAttributes.put("InvalidUsageOfTypeParameters", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	575	expectedProblemAttributes.put("InvalidUsageOfTypeParameters", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
574	expectedProblemAttributes.put("InvalidUsageOfTypeParametersForAnnotationDeclaration", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	576	expectedProblemAttributes.put("InvalidUsageOfTypeParametersForAnnotationDeclaration", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
Lines 661-666 Link Here
661	expectedProblemAttributes.put("MethodRequiresBody", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	663	expectedProblemAttributes.put("MethodRequiresBody", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
662	expectedProblemAttributes.put("MethodReturnsVoid", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	664	expectedProblemAttributes.put("MethodReturnsVoid", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
663	expectedProblemAttributes.put("MethodVarargsArgumentNeedCast", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	665	expectedProblemAttributes.put("MethodVarargsArgumentNeedCast", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		666	expectedProblemAttributes.put("misplacedTypeAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
664	expectedProblemAttributes.put("MissingArgumentsForParameterizedMemberType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	667	expectedProblemAttributes.put("MissingArgumentsForParameterizedMemberType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
665	expectedProblemAttributes.put("MissingEnclosingInstance", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	668	expectedProblemAttributes.put("MissingEnclosingInstance", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
666	expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	669	expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
Lines 1199-1205 Link Here
1199	expectedProblemAttributes.put("InvalidUsageOfAnnotations", SKIP);	1202	expectedProblemAttributes.put("InvalidUsageOfAnnotations", SKIP);
1200	expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", SKIP);	1203	expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", SKIP);
1201	expectedProblemAttributes.put("InvalidUsageOfForeachStatements", SKIP);	1204	expectedProblemAttributes.put("InvalidUsageOfForeachStatements", SKIP);
		1205	expectedProblemAttributes.put("InvalidUsageOfReceiverAnnotations", SKIP);
1202	expectedProblemAttributes.put("InvalidUsageOfStaticImports", SKIP);	1206	expectedProblemAttributes.put("InvalidUsageOfStaticImports", SKIP);
		1207	expectedProblemAttributes.put("InvalidUsageOfTypeAnnotations", SKIP);
1203	expectedProblemAttributes.put("InvalidUsageOfTypeArguments", SKIP);	1208	expectedProblemAttributes.put("InvalidUsageOfTypeArguments", SKIP);
1204	expectedProblemAttributes.put("InvalidUsageOfTypeParameters", SKIP);	1209	expectedProblemAttributes.put("InvalidUsageOfTypeParameters", SKIP);
1205	expectedProblemAttributes.put("InvalidUsageOfTypeParametersForAnnotationDeclaration", SKIP);	1210	expectedProblemAttributes.put("InvalidUsageOfTypeParametersForAnnotationDeclaration", SKIP);
Lines 1292-1297 Link Here
1292	expectedProblemAttributes.put("MethodRequiresBody", SKIP);	1297	expectedProblemAttributes.put("MethodRequiresBody", SKIP);
1293	expectedProblemAttributes.put("MethodReturnsVoid", SKIP);	1298	expectedProblemAttributes.put("MethodReturnsVoid", SKIP);
1294	expectedProblemAttributes.put("MethodVarargsArgumentNeedCast", new ProblemAttributes(JavaCore.COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST));	1299	expectedProblemAttributes.put("MethodVarargsArgumentNeedCast", new ProblemAttributes(JavaCore.COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST));
		1300	expectedProblemAttributes.put("misplacedTypeAnnotations", SKIP);
1295	expectedProblemAttributes.put("MissingArgumentsForParameterizedMemberType", SKIP);	1301	expectedProblemAttributes.put("MissingArgumentsForParameterizedMemberType", SKIP);
1296	expectedProblemAttributes.put("MissingEnclosingInstance", SKIP);	1302	expectedProblemAttributes.put("MissingEnclosingInstance", SKIP);
1297	expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", SKIP);	1303	expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", SKIP);

Lines 7622-7628 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterTestAST3_2.java (-73 / +80 lines)
7622	true);	7622	true);
7623	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());	7623	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
7624	CompilationUnit unit = (CompilationUnit) node;	7624	CompilationUnit unit = (CompilationUnit) node;
7625	assertProblemsSize(unit, 1, "Syntax error, insert \"AssignmentOperator Expression\" to complete Expression");	7625	assertProblemsSize(unit, 1, "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
7626	node = getASTNode(unit, 0, 0, 0);	7626	node = getASTNode(unit, 0, 0, 0);
7627	assertEquals("Not an expression statement", ASTNode.EXPRESSION_STATEMENT, node.getNodeType());	7627	assertEquals("Not an expression statement", ASTNode.EXPRESSION_STATEMENT, node.getNodeType());
7628	assertTrue("Not recovered", isRecovered(node));	7628	assertTrue("Not recovered", isRecovered(node));
Lines 7731-7739 Link Here
7731	CompilationUnit unit = (CompilationUnit) node;	7731	CompilationUnit unit = (CompilationUnit) node;
7732	assertProblemsSize(	7732	assertProblemsSize(
7733	unit,	7733	unit,
7734	2,	7734	1,
7735	"Object.equ cannot be resolved to a variable\n" +	7735	"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
7736	"Syntax error, insert \"AssignmentOperator Expression\" to complete Expression");
7737	node = getASTNode(unit, 0, 0);	7736	node = getASTNode(unit, 0, 0);
7738	assertEquals("Not a field declaration statement", ASTNode.INITIALIZER, node.getNodeType());	7737	assertEquals("Not a field declaration statement", ASTNode.INITIALIZER, node.getNodeType());
7739	Initializer initializer = (Initializer) node;	7738	Initializer initializer = (Initializer) node;
Lines 7999-8073 Link Here
7999	"}");	7998	"}");
8000		7999
8001	assertASTResult(	8000	assertASTResult(
8002	"===== AST =====\n" +	8001	"===== AST =====\n" +
8003	"import java.nio.ByteBuffer;\n" +	8002	"import java.nio.ByteBuffer;\n" +
8004	"import java.nio.CharBuffer;\n" +	8003	"import java.nio.CharBuffer;\n" +
8005	"import java.nio.charset.Charset;\n" +	8004	"import java.nio.charset.Charset;\n" +
8006	"import java.nio.charset.CharsetDecoder;\n" +	8005	"import java.nio.charset.CharsetDecoder;\n" +
8007	"import java.nio.charset.CharsetEncoder;\n" +	8006	"import java.nio.charset.CharsetEncoder;\n" +
8008	"import java.nio.charset.CoderResult;\n" +	8007	"import java.nio.charset.CoderResult;\n" +
8009	"public class TestCharset extends Charset {\n" +	8008	"public class TestCharset extends Charset {\n" +
8010	" public CharsetDecoder newDecoder(){\n" +	8009	" public CharsetDecoder newDecoder(){\n" +
8011	" return new CharsetDecoder(this,2.0,2.0){\n" +	8010	" return new CharsetDecoder(this,2.0,2.0){\n" +
8012	" void CharsetDecoder(){\n" +	8011	" void CharsetDecoder(){\n" +
8013	" }\n" +	8012	" }\n" +
8014	" protected CoderResult decodeLoop( ByteBuffer in, CharBuffer out){\n" +	8013	" protected CoderResult decodeLoop( ByteBuffer in, CharBuffer out){\n" +
8015	" return null;\n" +	8014	" return null;\n" +
8016	" }\n" +	8015	" }\n" +
8017	" }\n" +	8016	" }\n" +
8018	";\n" +	8017	";\n" +
8019	" ;\n" +	8018	" ;\n" +
8020	" }\n" +	8019	" }\n" +
8021	" public CharsetEncoder newEncoder(){\n" +	8020	" public CharsetEncoder newEncoder(){\n" +
8022	" return null;\n" +	8021	" return null;\n" +
8023	" }\n" +	8022	" }\n" +
8024	"}\n" +	8023	"}\n" +
8025	"\n" +	8024	"\n" +
8026	"===== Details =====\n" +	8025	"===== Details =====\n" +
8027	"===== Problems =====\n" +	8026	"===== Problems =====\n" +
8028	"1. ERROR in /Converter/src/TestCharset.java (at line 1)\n" +	8027	"1. ERROR in /Converter/src/TestCharset.java (at line 1)\n" +
8029	" import java.nio.ByteBuffer;\n" +	8028	" import java.nio.ByteBuffer;\n" +
8030	" ^^^^^^^^\n" +	8029	" ^^^^^^^^\n" +
8031	"The import java.nio cannot be resolved\n" +	8030	"The import java.nio cannot be resolved\n" +
8032	"2. ERROR in /Converter/src/TestCharset.java (at line 2)\n" +	8031	"2. ERROR in /Converter/src/TestCharset.java (at line 2)\n" +
8033	" import java.nio.CharBuffer;\n" +	8032	" import java.nio.CharBuffer;\n" +
8034	" ^^^^^^^^\n" +	8033	" ^^^^^^^^\n" +
8035	"The import java.nio cannot be resolved\n" +	8034	"The import java.nio cannot be resolved\n" +
8036	"3. ERROR in /Converter/src/TestCharset.java (at line 3)\n" +	8035	"3. ERROR in /Converter/src/TestCharset.java (at line 3)\n" +
8037	" import java.nio.charset.Charset;\n" +	8036	" import java.nio.charset.Charset;\n" +
8038	" ^^^^^^^^\n" +	8037	" ^^^^^^^^\n" +
8039	"The import java.nio cannot be resolved\n" +	8038	"The import java.nio cannot be resolved\n" +
8040	"4. ERROR in /Converter/src/TestCharset.java (at line 4)\n" +	8039	"4. ERROR in /Converter/src/TestCharset.java (at line 4)\n" +
8041	" import java.nio.charset.CharsetDecoder;\n" +	8040	" import java.nio.charset.CharsetDecoder;\n" +
8042	" ^^^^^^^^\n" +	8041	" ^^^^^^^^\n" +
8043	"The import java.nio cannot be resolved\n" +	8042	"The import java.nio cannot be resolved\n" +
8044	"5. ERROR in /Converter/src/TestCharset.java (at line 5)\n" +	8043	"5. ERROR in /Converter/src/TestCharset.java (at line 5)\n" +
8045	" import java.nio.charset.CharsetEncoder;\n" +	8044	" import java.nio.charset.CharsetEncoder;\n" +
8046	" ^^^^^^^^\n" +	8045	" ^^^^^^^^\n" +
8047	"The import java.nio cannot be resolved\n" +	8046	"The import java.nio cannot be resolved\n" +
8048	"6. ERROR in /Converter/src/TestCharset.java (at line 6)\n" +	8047	"6. ERROR in /Converter/src/TestCharset.java (at line 6)\n" +
8049	" import java.nio.charset.CoderResult;\n" +	8048	" import java.nio.charset.CoderResult;\n" +
8050	" ^^^^^^^^\n" +	8049	" ^^^^^^^^\n" +
8051	"The import java.nio cannot be resolved\n" +	8050	"The import java.nio cannot be resolved\n" +
8052	"7. ERROR in /Converter/src/TestCharset.java (at line 7)\n" +	8051	"7. ERROR in /Converter/src/TestCharset.java (at line 7)\n" +
8053	" public class TestCharset extends Charset {\n" +	8052	" public class TestCharset extends Charset {\n" +
8054	" ^^^^^^^\n" +	8053	" ^^^^^^^\n" +
8055	"Charset cannot be resolved to a type\n" +	8054	"Charset cannot be resolved to a type\n" +
8056	"8. ERROR in /Converter/src/TestCharset.java (at line 8)\n" +	8055	"8. ERROR in /Converter/src/TestCharset.java (at line 8)\n" +
8057	" public CharsetDecoder newDecoder() {\n" +	8056	" public CharsetDecoder newDecoder() {\n" +
8058	" ^^^^^^^^^^^^^^\n" +	8057	" ^^^^^^^^^^^^^^\n" +
8059	"CharsetDecoder cannot be resolved to a type\n" +	8058	"CharsetDecoder cannot be resolved to a type\n" +
8060	"9. ERROR in /Converter/src/TestCharset.java (at line 9)\n" +	8059	"9. ERROR in /Converter/src/TestCharset.java (at line 9)\n" +
8061	" return new CharsetDecoder(this, 2.0, 2.0) {\n" +	8060	" return new CharsetDecoder(this, 2.0, 2.0) {\n" +
8062	" ^^^^^^^^^^^^^^\n" +	8061	" ^^^^^^^^^^^^^^\n" +
8063	"CharsetDecoder cannot be resolved to a type\n" +	8062	"CharsetDecoder cannot be resolved to a type\n" +
8064	"10. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +	8063	"10. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +
8065	" CharsetDecoder(CharSet\n" +	8064	" CharsetDecoder(CharSet\n" +
8066	" ^^^^^^^^^^^^^^^^^^^^^^\n" +	8065	" ^^^^^^^\n" +
8067	"Syntax error on token(s), misplaced construct(s)\n" +	8066	"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameter\n" +
8068	"11. ERROR in /Converter/src/TestCharset.java (at line 17)\n" +	8067	"11. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +
8069	" public CharsetEncoder newEncoder() {\n" +	8068	" CharsetDecoder(CharSet\n" +
8070	" ^^^^^^^^^^^^^^\n" +	8069	" ^^^^^^^\n" +
		8070	"Syntax error, insert \")\" to complete ConstructorDeclaration\n" +
		8071	"12. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +
		8072	" CharsetDecoder(CharSet\n" +
		8073	" ^^^^^^^\n" +
		8074	"Syntax error, insert \";\" to complete ClassBodyDeclarations\n" +
		8075	"13. ERROR in /Converter/src/TestCharset.java (at line 17)\n" +
		8076	" public CharsetEncoder newEncoder() {\n" +
		8077	" ^^^^^^^^^^^^^^\n" +
8071	"CharsetEncoder cannot be resolved to a type\n",	8078	"CharsetEncoder cannot be resolved to a type\n",
8072	result);	8079	result);
8073	}	8080	}

Lines 31-37 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java (-10 / +21 lines)
31	/*	31	/*
32	* Answer a base type reference (can be an array of base type).	32	* Answer a base type reference (can be an array of base type).
33	*/	33	*/
34	public static final TypeReference baseTypeReference(int baseType, int dim) {	34	public static final TypeReference baseTypeReference(int baseType, int dim, Annotation [][] dimAnnotations) {
35		35
36	if (dim == 0) {	36	if (dim == 0) {
37	switch (baseType) {	37	switch (baseType) {
Lines 57-82 Link Here
57	}	57	}
58	switch (baseType) {	58	switch (baseType) {
59	case (TypeIds.T_void) :	59	case (TypeIds.T_void) :
60	return new ArrayTypeReference(TypeBinding.VOID.simpleName, dim, 0);	60	return new ArrayTypeReference(TypeBinding.VOID.simpleName, dim, dimAnnotations, 0);
61	case (TypeIds.T_boolean) :	61	case (TypeIds.T_boolean) :
62	return new ArrayTypeReference(TypeBinding.BOOLEAN.simpleName, dim, 0);	62	return new ArrayTypeReference(TypeBinding.BOOLEAN.simpleName, dim, dimAnnotations, 0);
63	case (TypeIds.T_char) :	63	case (TypeIds.T_char) :
64	return new ArrayTypeReference(TypeBinding.CHAR.simpleName, dim, 0);	64	return new ArrayTypeReference(TypeBinding.CHAR.simpleName, dim, dimAnnotations, 0);
65	case (TypeIds.T_float) :	65	case (TypeIds.T_float) :
66	return new ArrayTypeReference(TypeBinding.FLOAT.simpleName, dim, 0);	66	return new ArrayTypeReference(TypeBinding.FLOAT.simpleName, dim, dimAnnotations, 0);
67	case (TypeIds.T_double) :	67	case (TypeIds.T_double) :
68	return new ArrayTypeReference(TypeBinding.DOUBLE.simpleName, dim, 0);	68	return new ArrayTypeReference(TypeBinding.DOUBLE.simpleName, dim, dimAnnotations, 0);
69	case (TypeIds.T_byte) :	69	case (TypeIds.T_byte) :
70	return new ArrayTypeReference(TypeBinding.BYTE.simpleName, dim, 0);	70	return new ArrayTypeReference(TypeBinding.BYTE.simpleName, dim, dimAnnotations, 0);
71	case (TypeIds.T_short) :	71	case (TypeIds.T_short) :
72	return new ArrayTypeReference(TypeBinding.SHORT.simpleName, dim, 0);	72	return new ArrayTypeReference(TypeBinding.SHORT.simpleName, dim, dimAnnotations, 0);
73	case (TypeIds.T_int) :	73	case (TypeIds.T_int) :
74	return new ArrayTypeReference(TypeBinding.INT.simpleName, dim, 0);	74	return new ArrayTypeReference(TypeBinding.INT.simpleName, dim, dimAnnotations, 0);
75	default : //T_long	75	default : //T_long
76	return new ArrayTypeReference(TypeBinding.LONG.simpleName, dim, 0);	76	return new ArrayTypeReference(TypeBinding.LONG.simpleName, dim, dimAnnotations, 0);
77	}	77	}
78	}	78	}
79		79
		80	// JSR308 type annotations...
		81	public Annotation[] annotations = null;
		82
80	// allows us to trap completion & selection nodes	83	// allows us to trap completion & selection nodes
81	public void aboutToResolve(Scope scope) {	84	public void aboutToResolve(Scope scope) {
82	// default implementation: do nothing	85	// default implementation: do nothing
Lines 88-96 Link Here
88	// only parameterized type references have bounds	91	// only parameterized type references have bounds
89	}	92	}
90	public abstract TypeReference copyDims(int dim);	93	public abstract TypeReference copyDims(int dim);
		94	public abstract TypeReference copyDims(int dim, Annotation[][] annotationsOnDimensions);
91	public int dimensions() {	95	public int dimensions() {
92	return 0;	96	return 0;
93	}	97	}
		98	public Annotation[][] getAnnotationsOnDimensions() {
		99	return null;
		100	}
94		101
95	public abstract char[] getLastToken();	102	public abstract char[] getLastToken();
96		103
Lines 166-171 Link Here
166	return true;	173	return true;
167	}	174	}
168		175
		176	public boolean isParametrizedTypeReference() {
		177	return false;
		178	}
		179
169	protected void reportDeprecatedType(TypeBinding type, Scope scope) {	180	protected void reportDeprecatedType(TypeBinding type, Scope scope) {
170	scope.problemReporter().deprecatedType(type, this);	181	scope.problemReporter().deprecatedType(type, this);
171	}	182	}

Lines 889-901 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistParser.java (-2 / +5 lines)
889	/*	889	/*
890	* Build specific type reference nodes in case the cursor is located inside the type reference	890	* Build specific type reference nodes in case the cursor is located inside the type reference
891	*/	891	*/
892	protected TypeReference getTypeReference(int dim) {	892	protected TypeReference getUnannotatedTypeReference(int dim) {
893		893
894	int index;	894	int index;
895		895
896	/* no need to take action if not inside completed identifiers */	896	/* no need to take action if not inside completed identifiers */
897	if ((index = indexOfAssistIdentifier(true)) < 0) {	897	if ((index = indexOfAssistIdentifier(true)) < 0) {
898	return super.getTypeReference(dim);	898	return super.getUnannotatedTypeReference(dim);
899	}	899	}
900	int length = this.identifierLengthStack[this.identifierLengthPtr];	900	int length = this.identifierLengthStack[this.identifierLengthPtr];
901	TypeReference reference;	901	TypeReference reference;
Lines 1602-1607 Link Here
1602	this.astLengthPtr = -1;	1602	this.astLengthPtr = -1;
1603	this.expressionPtr = -1;	1603	this.expressionPtr = -1;
1604	this.expressionLengthPtr = -1;	1604	this.expressionLengthPtr = -1;
		1605	this.unattachedAnnotationPtr = -1;
		1606	this.typeAnnotationLengthPtr = -1;
		1607	this.typeAnnotationPtr = -1;
1605	this.identifierPtr = -1;	1608	this.identifierPtr = -1;
1606	this.identifierLengthPtr = -1;	1609	this.identifierLengthPtr = -1;
1607	this.intPtr = -1;	1610	this.intPtr = -1;

Lines 433-443 Link Here

(-)model/org/eclipse/jdt/internal/compiler/DocumentElementParser.java (-7 / +19 lines)
433	declaration.declarationSourceStart = this.intStack[this.intPtr--];	433	declaration.declarationSourceStart = this.intStack[this.intPtr--];
434	declaration.modifiersSourceStart = this.intStack[this.intPtr--];	434	declaration.modifiersSourceStart = this.intStack[this.intPtr--];
435	declaration.modifiers = this.intStack[this.intPtr--];	435	declaration.modifiers = this.intStack[this.intPtr--];
436	type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension	436	type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
437	pushOnAstStack(type);	437	pushOnAstStack(type);
438	} else {	438	} else {
439	// field declaration	439	// field declaration
440	type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension	440	type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
441	pushOnAstStack(type);	441	pushOnAstStack(type);
442	declaration.declarationSourceStart = this.intStack[this.intPtr--];	442	declaration.declarationSourceStart = this.intStack[this.intPtr--];
443	declaration.modifiersSourceStart = this.intStack[this.intPtr--];	443	declaration.modifiersSourceStart = this.intStack[this.intPtr--];
Lines 560-566 Link Here
560	}	560	}
561	int firstDimensions = this.intStack[this.intPtr--];	561	int firstDimensions = this.intStack[this.intPtr--];
562	final int typeDimensions = firstDimensions + extendedDimensions;	562	final int typeDimensions = firstDimensions + extendedDimensions;
563	TypeReference type = getTypeReference(typeDimensions);	563	TypeReference type = getUnannotatedTypeReference(typeDimensions);
564	if (isVarArgs) {	564	if (isVarArgs) {
565	type = copyDims(type, typeDimensions + 1);	565	type = copyDims(type, typeDimensions + 1);
566	if (extendedDimensions == 0) {	566	if (extendedDimensions == 0) {
Lines 830-835 Link Here
830	// MethodHeaderExtendedDims ::= Dimsopt	830	// MethodHeaderExtendedDims ::= Dimsopt
831	// now we update the returnType of the method	831	// now we update the returnType of the method
832	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];	832	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
		833	// jsr308 -- consume receiver annotations
		834	md.receiverAnnotations = null;
		835	int length;
		836	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		837	System.arraycopy(
		838	this.typeAnnotationStack,
		839	(this.typeAnnotationPtr -= length) + 1,
		840	md.receiverAnnotations = new Annotation[length],
		841	0,
		842	length);
		843	}
833	int extendedDims = this.intStack[this.intPtr--];	844	int extendedDims = this.intStack[this.intPtr--];
834	this.extendsDim = extendedDims;	845	this.extendsDim = extendedDims;
835	if (extendedDims != 0) {	846	if (extendedDims != 0) {
Lines 855-861 Link Here
855	this.selectorSourcePositions = this.identifierPositionStack[this.identifierPtr--];	866	this.selectorSourcePositions = this.identifierPositionStack[this.identifierPtr--];
856	this.identifierLengthPtr--;	867	this.identifierLengthPtr--;
857	//type	868	//type
858	md.returnType = getTypeReference(this.typeDims = this.intStack[this.intPtr--]);	869	md.returnType = getUnannotatedTypeReference(this.typeDims = this.intStack[this.intPtr--]);
859	//modifiers	870	//modifiers
860	md.declarationSourceStart = this.intStack[this.intPtr--];	871	md.declarationSourceStart = this.intStack[this.intPtr--];
861	md.modifiersSourceStart = this.intStack[this.intPtr--];	872	md.modifiersSourceStart = this.intStack[this.intPtr--];
Lines 1357-1363 Link Here
1357	* This variable is a type reference and dim will be its dimensions.	1368	* This variable is a type reference and dim will be its dimensions.
1358	* We don't have any side effect on the stacks' pointers.	1369	* We don't have any side effect on the stacks' pointers.
1359	*/	1370	*/
1360		1371	Annotation [][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
1361	int length;	1372	int length;
1362	TypeReference ref;	1373	TypeReference ref;
1363	if ((length = this.identifierLengthStack[localIdentifierLengthPtr]) == 1) {	1374	if ((length = this.identifierLengthStack[localIdentifierLengthPtr]) == 1) {
Lines 1372-1383 Link Here
1372	new ArrayTypeReference(	1383	new ArrayTypeReference(
1373	this.identifierStack[localIdentifierPtr],	1384	this.identifierStack[localIdentifierPtr],
1374	dim,	1385	dim,
		1386	annotationsOnDimensions,
1375	this.identifierPositionStack[localIdentifierPtr--]);	1387	this.identifierPositionStack[localIdentifierPtr--]);
1376	ref.sourceEnd = this.endPosition;	1388	ref.sourceEnd = this.endPosition;
1377	}	1389	}
1378	} else {	1390	} else {
1379	if (length < 0) { //flag for precompiled type reference on base types	1391	if (length < 0) { //flag for precompiled type reference on base types
1380	ref = TypeReference.baseTypeReference(-length, dim);	1392	ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
1381	ref.sourceStart = this.intStack[this.localIntPtr--];	1393	ref.sourceStart = this.intStack[this.localIntPtr--];
1382	if (dim == 0) {	1394	if (dim == 0) {
1383	ref.sourceEnd = this.intStack[this.localIntPtr--];	1395	ref.sourceEnd = this.intStack[this.localIntPtr--];
Lines 1399-1405 Link Here
1399	if (dim == 0)	1411	if (dim == 0)
1400	ref = new QualifiedTypeReference(tokens, positions);	1412	ref = new QualifiedTypeReference(tokens, positions);
1401	else	1413	else
1402	ref = new ArrayQualifiedTypeReference(tokens, dim, positions);	1414	ref = new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
1403	}	1415	}
1404	}	1416	}
1405	return ref;	1417	return ref;

Lines 194-201 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MatchLocatorParser.java (-28 / +28 lines)
194	}	194	}
195	}	195	}
196		196
197	protected void consumeAdditionalBound() {	197	protected void consumeAdditionalBound(boolean hasTypeAnnotations) {
198	super.consumeAdditionalBound();	198	super.consumeAdditionalBound(hasTypeAnnotations);
199	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {	199	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
200	TypeReference typeReference = (TypeReference) this.genericsStack[this.genericsPtr];	200	TypeReference typeReference = (TypeReference) this.genericsStack[this.genericsPtr];
201	this.patternLocator.match(typeReference, this.nodeSet);	201	this.patternLocator.match(typeReference, this.nodeSet);
Lines 209-216 Link Here
209	}	209	}
210	}	210	}
211		211
212	protected void consumeCastExpressionLL1() {	212	protected void consumeCastExpressionLL1(boolean hasTypeAnnotations) {
213	super.consumeCastExpressionLL1();	213	super.consumeCastExpressionLL1(hasTypeAnnotations);
214	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {	214	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
215	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];	215	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
216	if (castExpression.type instanceof Reference) {	216	if (castExpression.type instanceof Reference) {
Lines 218-225 Link Here
218	}	218	}
219	}	219	}
220	}	220	}
221	protected void consumeCastExpressionWithGenericsArray() {	221	protected void consumeCastExpressionWithGenericsArray(boolean hasTypeAnnotations) {
222	super.consumeCastExpressionWithGenericsArray();	222	super.consumeCastExpressionWithGenericsArray(hasTypeAnnotations);
223	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {	223	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
224	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];	224	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
225	if (castExpression.type instanceof Reference) {	225	if (castExpression.type instanceof Reference) {
Lines 227-234 Link Here
227	}	227	}
228	}	228	}
229	}	229	}
230	protected void consumeCastExpressionWithNameArray() {	230	protected void consumeCastExpressionWithNameArray(boolean hasTypeAnnotations) {
231	super.consumeCastExpressionWithNameArray();	231	super.consumeCastExpressionWithNameArray(hasTypeAnnotations);
232	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {	232	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
233	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];	233	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
234	if (castExpression.type instanceof Reference) {	234	if (castExpression.type instanceof Reference) {
Lines 236-243 Link Here
236	}	236	}
237	}	237	}
238	}	238	}
239	protected void consumeCastExpressionWithPrimitiveType() {	239	protected void consumeCastExpressionWithPrimitiveType(boolean hasTypeAnnotations) {
240	super.consumeCastExpressionWithPrimitiveType();	240	super.consumeCastExpressionWithPrimitiveType(hasTypeAnnotations);
241	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {	241	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
242	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];	242	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
243	if (castExpression.type instanceof Reference) {	243	if (castExpression.type instanceof Reference) {
Lines 245-252 Link Here
245	}	245	}
246	}	246	}
247	}	247	}
248	protected void consumeCastExpressionWithQualifiedGenericsArray() {	248	protected void consumeCastExpressionWithQualifiedGenericsArray(boolean hasTypeAnnotations) {
249	super.consumeCastExpressionWithQualifiedGenericsArray();	249	super.consumeCastExpressionWithQualifiedGenericsArray(hasTypeAnnotations);
250	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {	250	if ((this.patternFineGrain & IJavaSearchConstants.CAST_TYPE_REFERENCE) != 0) {
251	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];	251	CastExpression castExpression = (CastExpression) this.expressionStack[this.expressionPtr];
252	if (castExpression.type instanceof Reference) {	252	if (castExpression.type instanceof Reference) {
Lines 554-561 Link Here
554	}	554	}
555	}	555	}
556		556
557	protected void consumeTypeArgumentReferenceType1() {	557	protected void consumeTypeArgumentReferenceType1(boolean hasTypeAnnotations) {
558	super.consumeTypeArgumentReferenceType1();	558	super.consumeTypeArgumentReferenceType1(hasTypeAnnotations);
559	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_ARGUMENT_TYPE_REFERENCE) != 0) {	559	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_ARGUMENT_TYPE_REFERENCE) != 0) {
560	int length = this.genericsLengthStack[this.genericsLengthPtr];	560	int length = this.genericsLengthStack[this.genericsLengthPtr];
561	if (length == 1) {	561	if (length == 1) {
Lines 578-585 Link Here
578	}	578	}
579	}	579	}
580		580
581	protected void consumeTypeArgumentReferenceType2() {	581	protected void consumeTypeArgumentReferenceType2(boolean hasTypeAnnotations) {
582	super.consumeTypeArgumentReferenceType2();	582	super.consumeTypeArgumentReferenceType2(hasTypeAnnotations);
583	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_ARGUMENT_TYPE_REFERENCE) != 0) {	583	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_ARGUMENT_TYPE_REFERENCE) != 0) {
584	int length = this.genericsLengthStack[this.genericsLengthPtr];	584	int length = this.genericsLengthStack[this.genericsLengthPtr];
585	if (length == 1) {	585	if (length == 1) {
Lines 623-630 Link Here
623	}	623	}
624	}	624	}
625		625
626	protected void consumeTypeParameter1WithExtendsAndBounds() {	626	protected void consumeTypeParameter1WithExtendsAndBounds(boolean hasTypeAnnotations) {
627	super.consumeTypeParameter1WithExtendsAndBounds();	627	super.consumeTypeParameter1WithExtendsAndBounds(hasTypeAnnotations);
628	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {	628	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
629	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	629	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
630	this.patternLocator.match(typeParameter.type, this.nodeSet);	630	this.patternLocator.match(typeParameter.type, this.nodeSet);
Lines 636-651 Link Here
636	this.patternLocator.match((TypeParameter)this.genericsStack[this.genericsPtr], this.nodeSet);	636	this.patternLocator.match((TypeParameter)this.genericsStack[this.genericsPtr], this.nodeSet);
637	}	637	}
638		638
639	protected void consumeTypeParameterWithExtends() {	639	protected void consumeTypeParameterWithExtends(boolean hasTypeAnnotations) {
640	super.consumeTypeParameterWithExtends();	640	super.consumeTypeParameterWithExtends(hasTypeAnnotations);
641	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {	641	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
642	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	642	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
643	this.patternLocator.match(typeParameter.type, this.nodeSet);	643	this.patternLocator.match(typeParameter.type, this.nodeSet);
644	}	644	}
645	}	645	}
646		646
647	protected void consumeTypeParameterWithExtendsAndBounds() {	647	protected void consumeTypeParameterWithExtendsAndBounds(boolean hasTypeAnnotations) {
648	super.consumeTypeParameterWithExtendsAndBounds();	648	super.consumeTypeParameterWithExtendsAndBounds(hasTypeAnnotations);
649	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {	649	if ((this.patternFineGrain & IJavaSearchConstants.TYPE_VARIABLE_BOUND_TYPE_REFERENCE) != 0) {
650	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	650	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
651	this.patternLocator.match(typeParameter.type, this.nodeSet);	651	this.patternLocator.match(typeParameter.type, this.nodeSet);
Lines 705-720 Link Here
705	}	705	}
706	}	706	}
707		707
708	protected void consumeWildcardBoundsExtends() {	708	protected void consumeWildcardBoundsExtends(boolean hasTypeAnnotations) {
709	super.consumeWildcardBoundsExtends();	709	super.consumeWildcardBoundsExtends(hasTypeAnnotations);
710	if ((this.patternFineGrain & IJavaSearchConstants.WILDCARD_BOUND_TYPE_REFERENCE) != 0) {	710	if ((this.patternFineGrain & IJavaSearchConstants.WILDCARD_BOUND_TYPE_REFERENCE) != 0) {
711	Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];	711	Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];
712	this.patternLocator.match(wildcard.bound, this.nodeSet);	712	this.patternLocator.match(wildcard.bound, this.nodeSet);
713	}	713	}
714	}	714	}
715		715
716	protected void consumeWildcardBoundsSuper() {	716	protected void consumeWildcardBoundsSuper(boolean hasTypeAnnotations) {
717	super.consumeWildcardBoundsSuper();	717	super.consumeWildcardBoundsSuper(hasTypeAnnotations);
718	if ((this.patternFineGrain & IJavaSearchConstants.WILDCARD_BOUND_TYPE_REFERENCE) != 0) {	718	if ((this.patternFineGrain & IJavaSearchConstants.WILDCARD_BOUND_TYPE_REFERENCE) != 0) {
719	Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];	719	Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];
720	this.patternLocator.match(wildcard.bound, this.nodeSet);	720	this.patternLocator.match(wildcard.bound, this.nodeSet);
Lines 729-736 Link Here
729	this.nodeSet.addTrustedMatch(result, true);	729	this.nodeSet.addTrustedMatch(result, true);
730	return result;	730	return result;
731	}	731	}
732	protected TypeReference getTypeReference(int dim) {	732	protected TypeReference getUnannotatedTypeReference(int dim) {
733	TypeReference typeRef = super.getTypeReference(dim);	733	TypeReference typeRef = super.getUnannotatedTypeReference(dim);
734	if (this.patternFineGrain == 0) {	734	if (this.patternFineGrain == 0) {
735	this.patternLocator.match(typeRef, this.nodeSet); // NB: Don't check container since type reference can happen anywhere	735	this.patternLocator.match(typeRef, this.nodeSet); // NB: Don't check container since type reference can happen anywhere
736	}	736	}

Lines 233-243 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/select/SelectionParser.java (-15 / +15 lines)
233	super.classInstanceCreation(hasClassBody);	233	super.classInstanceCreation(hasClassBody);
234	}	234	}
235	}	235	}
236	protected void consumeArrayCreationExpressionWithoutInitializer() {	236	protected void consumeArrayCreationExpressionWithoutInitializer(boolean hasTypeAnnotations) {
237	// ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs	237	// ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs
238	// ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs	238	// ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
239		239
240	super.consumeArrayCreationExpressionWithoutInitializer();	240	super.consumeArrayCreationExpressionWithoutInitializer(hasTypeAnnotations);
241		241
242	ArrayAllocationExpression alloc = (ArrayAllocationExpression)this.expressionStack[this.expressionPtr];	242	ArrayAllocationExpression alloc = (ArrayAllocationExpression)this.expressionStack[this.expressionPtr];
243	if (alloc.type == this.assistNode){	243	if (alloc.type == this.assistNode){
Lines 248-257 Link Here
248	this.isOrphanCompletionNode = true;	248	this.isOrphanCompletionNode = true;
249	}	249	}
250	}	250	}
251	protected void consumeArrayCreationExpressionWithInitializer() {	251	protected void consumeArrayCreationExpressionWithInitializer(boolean hasTypeAnnotations) {
252	// ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer	252	// ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer
253		253
254	super.consumeArrayCreationExpressionWithInitializer();	254	super.consumeArrayCreationExpressionWithInitializer(hasTypeAnnotations);
255		255
256	ArrayAllocationExpression alloc = (ArrayAllocationExpression)this.expressionStack[this.expressionPtr];	256	ArrayAllocationExpression alloc = (ArrayAllocationExpression)this.expressionStack[this.expressionPtr];
257	if (alloc.type == this.assistNode){	257	if (alloc.type == this.assistNode){
Lines 262-286 Link Here
262	this.isOrphanCompletionNode = true;	262	this.isOrphanCompletionNode = true;
263	}	263	}
264	}	264	}
265	protected void consumeCastExpressionLL1() {	265	protected void consumeCastExpressionLL1(boolean hasTypeAnnotations) {
266	popElement(K_CAST_STATEMENT);	266	popElement(K_CAST_STATEMENT);
267	super.consumeCastExpressionLL1();	267	super.consumeCastExpressionLL1(hasTypeAnnotations);
268	}	268	}
269	protected void consumeCastExpressionWithGenericsArray() {	269	protected void consumeCastExpressionWithGenericsArray(boolean hasTypeAnnotations) {
270	popElement(K_CAST_STATEMENT);	270	popElement(K_CAST_STATEMENT);
271	super.consumeCastExpressionWithGenericsArray();	271	super.consumeCastExpressionWithGenericsArray(hasTypeAnnotations);
272	}	272	}
273	protected void consumeCastExpressionWithNameArray() {	273	protected void consumeCastExpressionWithNameArray(boolean hasTypeAnnotations) {
274	popElement(K_CAST_STATEMENT);	274	popElement(K_CAST_STATEMENT);
275	super.consumeCastExpressionWithNameArray();	275	super.consumeCastExpressionWithNameArray(hasTypeAnnotations);
276	}	276	}
277	protected void consumeCastExpressionWithPrimitiveType() {	277	protected void consumeCastExpressionWithPrimitiveType(boolean hasTypeAnnotations) {
278	popElement(K_CAST_STATEMENT);	278	popElement(K_CAST_STATEMENT);
279	super.consumeCastExpressionWithPrimitiveType();	279	super.consumeCastExpressionWithPrimitiveType(hasTypeAnnotations);
280	}	280	}
281	protected void consumeCastExpressionWithQualifiedGenericsArray() {	281	protected void consumeCastExpressionWithQualifiedGenericsArray(boolean hasTypeAnnotations) {
282	popElement(K_CAST_STATEMENT);	282	popElement(K_CAST_STATEMENT);
283	super.consumeCastExpressionWithQualifiedGenericsArray();	283	super.consumeCastExpressionWithQualifiedGenericsArray(hasTypeAnnotations);
284	}	284	}
285	protected void consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() {	285	protected void consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() {
286	// ClassInstanceCreationExpression ::= Primary '.' 'new' TypeArguments SimpleName '(' ArgumentListopt ')' ClassBodyopt	286	// ClassInstanceCreationExpression ::= Primary '.' 'new' TypeArguments SimpleName '(' ArgumentListopt ')' ClassBodyopt
Lines 550-556 Link Here
550	}	550	}
551	int firstDimensions = this.intStack[this.intPtr--];	551	int firstDimensions = this.intStack[this.intPtr--];
552	final int typeDimensions = firstDimensions + extendedDimensions;	552	final int typeDimensions = firstDimensions + extendedDimensions;
553	TypeReference type = getTypeReference(typeDimensions);	553	TypeReference type = getUnannotatedTypeReference(typeDimensions);
554	if (isVarArgs) {	554	if (isVarArgs) {
555	type = copyDims(type, typeDimensions + 1);	555	type = copyDims(type, typeDimensions + 1);
556	if (extendedDimensions == 0) {	556	if (extendedDimensions == 0) {