Attachment #148087 for bug #287648

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




				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 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




/*
 * 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 29-34 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (+26 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 252-257 Link Here
252	}	263	}
253		264
254	public StringBuffer printExpression(int indent, StringBuffer output){	265	public StringBuffer printExpression(int indent, StringBuffer output){
		266	if (this.annotations != null) {
		267	printAnnotations(this.annotations, output);
		268	}
255	output.append(this.token);	269	output.append(this.token);
256	output.append("<"); //$NON-NLS-1$	270	output.append("<"); //$NON-NLS-1$
257	int max = this.typeArguments.length - 1;	271	int max = this.typeArguments.length - 1;
Lines 263-273 Link Here
263	output.append(">"); //$NON-NLS-1$	277	output.append(">"); //$NON-NLS-1$
264	if ((this.bits & IsVarArgs) != 0) {	278	if ((this.bits & IsVarArgs) != 0) {
265	for (int i= 0 ; i < this.dimensions - 1; i++) {	279	for (int i= 0 ; i < this.dimensions - 1; i++) {
		280	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		281	output.append(" "); //$NON-NLS-1$
		282	printAnnotations(this.annotationsOnDimensions[i], output);
		283	}
266	output.append("[]"); //$NON-NLS-1$	284	output.append("[]"); //$NON-NLS-1$
267	}	285	}
		286	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[this.dimensions - 1] != null) {
		287	output.append(" "); //$NON-NLS-1$
		288	printAnnotations(this.annotationsOnDimensions[this.dimensions - 1], output);
		289	}
268	output.append("..."); //$NON-NLS-1$	290	output.append("..."); //$NON-NLS-1$
269	} else {	291	} else {
270	for (int i= 0 ; i < this.dimensions; i++) {	292	for (int i= 0 ; i < this.dimensions; i++) {
		293	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		294	output.append(" "); //$NON-NLS-1$
		295	printAnnotations(this.annotationsOnDimensions[i], output);
		296	}
271	output.append("[]"); //$NON-NLS-1$	297	output.append("[]"); //$NON-NLS-1$
272	}	298	}
273	}	299	}

Lines 19-24 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayTypeReference.java (+23 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 69-79 Link Here
69	super.printExpression(indent, output);	80	super.printExpression(indent, output);
70	if ((this.bits & IsVarArgs) != 0) {	81	if ((this.bits & IsVarArgs) != 0) {
71	for (int i= 0 ; i < this.dimensions - 1; i++) {	82	for (int i= 0 ; i < this.dimensions - 1; i++) {
		83	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		84	output.append(" "); //$NON-NLS-1$
		85	printAnnotations(this.annotationsOnDimensions[i], output);
		86	}
72	output.append("[]"); //$NON-NLS-1$	87	output.append("[]"); //$NON-NLS-1$
73	}	88	}
		89	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[this.dimensions - 1] != null) {
		90	output.append(" "); //$NON-NLS-1$
		91	printAnnotations(this.annotationsOnDimensions[this.dimensions - 1], output);
		92	}
74	output.append("..."); //$NON-NLS-1$	93	output.append("..."); //$NON-NLS-1$
75	} else {	94	} else {
76	for (int i= 0 ; i < this.dimensions; i++) {	95	for (int i= 0 ; i < this.dimensions; i++) {
		96	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		97	output.append(" "); //$NON-NLS-1$
		98	printAnnotations(this.annotationsOnDimensions[i], output);
		99	}
77	output.append("[]"); //$NON-NLS-1$	100	output.append("[]"); //$NON-NLS-1$
78	}	101	}
79	}	102	}

Lines 33-38 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleTypeReference.java (-1 / +10 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 54-60 Link Here
54	}	61	}
55		62
56	public StringBuffer printExpression(int indent, StringBuffer output){	63	public StringBuffer printExpression(int indent, StringBuffer output){
57		64	if (this.annotations != null) {
		65	printAnnotations(this.annotations, output);
		66	}
58	return output.append(this.token);	67	return output.append(this.token);
59	}	68	}
60		69




/*
 * 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/QualifiedTypeReference.java (-1 / +9 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();
Lines 122-128 Link Here
122	}	128	}
123		129
124	public StringBuffer printExpression(int indent, StringBuffer output) {	130	public StringBuffer printExpression(int indent, StringBuffer output) {
125		131	if (this.annotations != null) {
		132	printAnnotations(this.annotations, output);
		133	}
126	for (int i = 0; i < this.tokens.length; i++) {	134	for (int i = 0; i < this.tokens.length; i++) {
127	if (i > 0) output.append('.');	135	if (i > 0) output.append('.');
128	output.append(this.tokens[i]);	136	output.append(this.tokens[i]);

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 (+26 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	}
62		72
63	/**	73	/**
64	* @return char[][]	74	* @return char[][]
Lines 295-300 Link Here
295	}	305	}
296		306
297	public StringBuffer printExpression(int indent, StringBuffer output) {	307	public StringBuffer printExpression(int indent, StringBuffer output) {
		308	if (this.annotations != null) {
		309	output.append(" "); //$NON-NLS-1$
		310	printAnnotations(this.annotations, output);
		311	}
298	int length = this.tokens.length;	312	int length = this.tokens.length;
299	for (int i = 0; i < length - 1; i++) {	313	for (int i = 0; i < length - 1; i++) {
300	output.append(this.tokens[i]);	314	output.append(this.tokens[i]);
Lines 325-335 Link Here
325	}	339	}
326	if ((this.bits & IsVarArgs) != 0) {	340	if ((this.bits & IsVarArgs) != 0) {
327	for (int i= 0 ; i < this.dimensions - 1; i++) {	341	for (int i= 0 ; i < this.dimensions - 1; i++) {
		342	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		343	output.append(" "); //$NON-NLS-1$
		344	printAnnotations(this.annotationsOnDimensions[i], output);
		345	}
328	output.append("[]"); //$NON-NLS-1$	346	output.append("[]"); //$NON-NLS-1$
329	}	347	}
		348	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[this.dimensions - 1] != null) {
		349	output.append(" "); //$NON-NLS-1$
		350	printAnnotations(this.annotationsOnDimensions[this.dimensions - 1], output);
		351	}
330	output.append("..."); //$NON-NLS-1$	352	output.append("..."); //$NON-NLS-1$
331	} else {	353	} else {
332	for (int i= 0 ; i < this.dimensions; i++) {	354	for (int i= 0 ; i < this.dimensions; i++) {
		355	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		356	output.append(" "); //$NON-NLS-1$
		357	printAnnotations(this.annotationsOnDimensions[i], output);
		358	}
333	output.append("[]"); //$NON-NLS-1$	359	output.append("[]"); //$NON-NLS-1$
334	}	360	}
335	}	361	}

Lines 17-33 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayQualifiedTypeReference.java (+23 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 72-82 Link Here
72	super.printExpression(indent, output);	83	super.printExpression(indent, output);
73	if ((this.bits & IsVarArgs) != 0) {	84	if ((this.bits & IsVarArgs) != 0) {
74	for (int i= 0 ; i < this.dimensions - 1; i++) {	85	for (int i= 0 ; i < this.dimensions - 1; i++) {
		86	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		87	output.append(" "); //$NON-NLS-1$
		88	printAnnotations(this.annotationsOnDimensions[i], output);
		89	}
75	output.append("[]"); //$NON-NLS-1$	90	output.append("[]"); //$NON-NLS-1$
76	}	91	}
		92	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[this.dimensions - 1] != null) {
		93	output.append(" "); //$NON-NLS-1$
		94	printAnnotations(this.annotationsOnDimensions[this.dimensions - 1], output);
		95	}
77	output.append("..."); //$NON-NLS-1$	96	output.append("..."); //$NON-NLS-1$
78	} else {	97	} else {
79	for (int i= 0 ; i < this.dimensions; i++) {	98	for (int i= 0 ; i < this.dimensions; i++) {
		99	if (this.annotationsOnDimensions != null && this.annotationsOnDimensions[i] != null) {
		100	output.append(" "); //$NON-NLS-1$
		101	printAnnotations(this.annotationsOnDimensions[i], output);
		102	}
80	output.append("[]"); //$NON-NLS-1$	103	output.append("[]"); //$NON-NLS-1$
81	}	104	}
82	}	105	}

Lines 67-72 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeParameter.java (+3 lines)
67	* @see org.eclipse.jdt.internal.compiler.ast.AstNode#print(int, java.lang.StringBuffer)	67	* @see org.eclipse.jdt.internal.compiler.ast.AstNode#print(int, java.lang.StringBuffer)
68	*/	68	*/
69	public StringBuffer printStatement(int indent, StringBuffer output) {	69	public StringBuffer printStatement(int indent, StringBuffer output) {
		70	if (this.annotations != null) {
		71	printAnnotations(this.annotations, output);
		72	}
70	output.append(this.name);	73	output.append(this.name);
71	if (this.type != null) {	74	if (this.type != null) {
72	output.append(" extends "); //$NON-NLS-1$	75	output.append(" extends "); //$NON-NLS-1$

Lines 35-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java (+11 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 359-364 Link Here
359	}	360	}
360	}	361	}
361	output.append(')');	362	output.append(')');
		363	if (this.receiverAnnotations != null) {
		364	output.append(" "); //$NON-NLS-1$
		365	printAnnotations(this.receiverAnnotations, output);
		366	}
362	if (this.thrownExceptions != null) {	367	if (this.thrownExceptions != null) {
363	output.append(" throws "); //$NON-NLS-1$	368	output.append(" throws "); //$NON-NLS-1$
364	for (int i = 0; i < this.thrownExceptions.length; i++) {	369	for (int i = 0; i < this.thrownExceptions.length; i++) {
Lines 403-408 Link Here
403	bindThrownExceptions();	408	bindThrownExceptions();
404	resolveJavadoc();	409	resolveJavadoc();
405	resolveAnnotations(this.scope, this.annotations, this.binding);	410	resolveAnnotations(this.scope, this.annotations, this.binding);
		411	// jsr308
		412	if (this.receiverAnnotations != null && this.scope.isStatic) {
		413	int last = this.receiverAnnotations.length - 1;
		414	this.scope.problemReporter().illegalReceiverAnnotations(this.receiverAnnotations[0],
		415	this.receiverAnnotations[last]);
		416	}
406	resolveStatements();	417	resolveStatements();
407	// check @Deprecated annotation presence	418	// check @Deprecated annotation presence
408	if (this.binding != null	419	if (this.binding != null

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);

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




		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 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 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




	}
}

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
	}




	}
}

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*/




			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;

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 11-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java (-514 / +1087 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 3067-3072 Link Here
3067	char[] identifierName = this.identifierStack[this.identifierPtr];	3197	char[] identifierName = this.identifierStack[this.identifierPtr];
3068	long namePosition = this.identifierPositionStack[this.identifierPtr];	3198	long namePosition = this.identifierPositionStack[this.identifierPtr];
3069	int extendedDimension = this.intStack[this.intPtr--];	3199	int extendedDimension = this.intStack[this.intPtr--];
		3200	// pop any annotations on extended dimensions now, so they don't pollute the base dimensions.
		3201	Annotation [][] annotationsOnExtendedDimensions = extendedDimension == 0 ? null : getAnnotationsOnDimensions(extendedDimension);
3070	AbstractVariableDeclaration declaration;	3202	AbstractVariableDeclaration declaration;
3071	// create the ast node	3203	// create the ast node
3072	boolean isLocalDeclaration = this.nestedMethod[this.nestedType] != 0;	3204	boolean isLocalDeclaration = this.nestedMethod[this.nestedType] != 0;
Lines 3100-3113 Link Here
3100	0,	3232	0,
3101	length);	3233	length);
3102	}	3234	}
3103	type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension	3235	type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
3104	if (declaration.declarationSourceStart == -1) {	3236	if (declaration.declarationSourceStart == -1) {
3105	// this is true if there is no modifiers for the local variable declaration	3237	// this is true if there is no modifiers for the local variable declaration
3106	declaration.declarationSourceStart = type.sourceStart;	3238	declaration.declarationSourceStart = type.sourceStart;
3107	}	3239	}
3108	pushOnAstStack(type);	3240	pushOnAstStack(type);
3109	} else {	3241	} else {
3110	type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension	3242	type = getUnannotatedTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
3111	pushOnAstStack(type);	3243	pushOnAstStack(type);
3112	declaration.declarationSourceStart = this.intStack[this.intPtr--];	3244	declaration.declarationSourceStart = this.intStack[this.intPtr--];
3113	declaration.modifiers = this.intStack[this.intPtr--];	3245	declaration.modifiers = this.intStack[this.intPtr--];
Lines 3144-3150 Link Here
3144	declaration.type = type;	3276	declaration.type = type;
3145	} else {	3277	} else {
3146	int dimension = typeDim + extendedDimension;	3278	int dimension = typeDim + extendedDimension;
3147	declaration.type = copyDims(type, dimension);	3279	Annotation [][] annotationsOnAllDimensions = null;
		3280	Annotation[][] annotationsOnDimensions = type.getAnnotationsOnDimensions();
		3281	if (annotationsOnDimensions != null \|\| annotationsOnExtendedDimensions != null) {
		3282	annotationsOnAllDimensions = getMergedAnnotationsOnDimensions(typeDim, annotationsOnDimensions, extendedDimension, annotationsOnExtendedDimensions);
		3283	}
		3284	declaration.type = copyDims(type, dimension, annotationsOnAllDimensions);
3148	}	3285	}
3149	this.variablesCounter[this.nestedType]++;	3286	this.variablesCounter[this.nestedType]++;
3150	pushOnAstStack(declaration);	3287	pushOnAstStack(declaration);
Lines 3171-3176 Link Here
3171	this.lastIgnoredToken = -1;	3308	this.lastIgnoredToken = -1;
3172	}	3309	}
3173	}	3310	}
		3311	private Annotation[][] getMergedAnnotationsOnDimensions(int dims, Annotation[][] annotationsOnDimensions,
		3312	int extendedDims, Annotation[][] annotationsOnExtendedDimensions) {
		3313
		3314	if (annotationsOnDimensions == null && annotationsOnExtendedDimensions == null)
		3315	return null;
		3316
		3317	Annotation [][] mergedAnnotations = new Annotation[dims + extendedDims][];
		3318	for (int i = 0; i < dims; i++) {
		3319	if (annotationsOnDimensions != null) {
		3320	mergedAnnotations[i] = annotationsOnDimensions[i];
		3321	} else {
		3322	mergedAnnotations[i] = null;
		3323	}
		3324	}
		3325	for (int i = dims, j = 0; i < dims + extendedDims; i++, j++) {
		3326	if (annotationsOnExtendedDimensions != null) {
		3327	mergedAnnotations[i] = annotationsOnExtendedDimensions[j];
		3328	} else {
		3329	mergedAnnotations[i] = null;
		3330	}
		3331	}
		3332
		3333	return mergedAnnotations;
		3334	}
3174	protected void consumeEnumBodyNoConstants() {	3335	protected void consumeEnumBodyNoConstants() {
3175	// nothing to do	3336	// nothing to do
3176	// The 0 on the astLengthStack has been pushed by EnumBodyDeclarationsopt	3337	// The 0 on the astLengthStack has been pushed by EnumBodyDeclarationsopt
Lines 3774-3783 Link Here
3774	endOfEllipsis = this.intStack[this.intPtr--];	3935	endOfEllipsis = this.intStack[this.intPtr--];
3775	}	3936	}
3776	int firstDimensions = this.intStack[this.intPtr--];	3937	int firstDimensions = this.intStack[this.intPtr--];
3777	final int typeDimensions = firstDimensions + extendedDimensions;	3938	TypeReference type = getUnannotatedTypeReference(extendedDimensions);
3778	TypeReference type = getTypeReference(typeDimensions);	3939	Annotation [] varArgsAnnotations = null;
		3940	int length;
		3941	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		3942	System.arraycopy(
		3943	this.typeAnnotationStack,
		3944	(this.typeAnnotationPtr -= length) + 1,
		3945	varArgsAnnotations = new Annotation[length],
		3946	0,
		3947	length);
		3948	}
		3949	final int typeDimensions = firstDimensions + extendedDimensions + (isVarArgs ? 1 : 0);
		3950
		3951	if (typeDimensions != extendedDimensions) {
		3952	// jsr308 type annotations management
		3953	Annotation [][] annotationsOnFirstDimensions = firstDimensions == 0 ? null : getAnnotationsOnDimensions(firstDimensions);
		3954	Annotation [][] annotationsOnExtendedDimensions = extendedDimensions == 0 ? null : type.getAnnotationsOnDimensions();
		3955	Annotation [][] annotationsOnAllDimensions = null;
		3956	if (annotationsOnFirstDimensions != null \|\| annotationsOnExtendedDimensions != null \|\| varArgsAnnotations != null) {
		3957	annotationsOnAllDimensions = getMergedAnnotationsOnDimensions(firstDimensions, annotationsOnFirstDimensions, extendedDimensions, annotationsOnExtendedDimensions);
		3958	annotationsOnAllDimensions = getMergedAnnotationsOnDimensions(firstDimensions + extendedDimensions, annotationsOnAllDimensions, isVarArgs ? 1 : 0, isVarArgs ? new Annotation[][]{varArgsAnnotations} : null);
		3959	}
		3960	type = copyDims(type, typeDimensions, annotationsOnAllDimensions);
		3961	type.sourceEnd = type.isParametrizedTypeReference() ? this.endStatementPosition : this.endPosition;
		3962	}
3779	if (isVarArgs) {	3963	if (isVarArgs) {
3780	type = copyDims(type, typeDimensions + 1);
3781	if (extendedDimensions == 0) {	3964	if (extendedDimensions == 0) {
3782	type.sourceEnd = endOfEllipsis;	3965	type.sourceEnd = endOfEllipsis;
3783	}	3966	}
Lines 3793-3799 Link Here
3793	this.intStack[this.intPtr + 1] & ~ClassFileConstants.AccDeprecated); // modifiers	3976	this.intStack[this.intPtr + 1] & ~ClassFileConstants.AccDeprecated); // modifiers
3794	arg.declarationSourceStart = modifierPositions;	3977	arg.declarationSourceStart = modifierPositions;
3795	// consume annotations	3978	// consume annotations
3796	int length;	3979
3797	if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {	3980	if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3798	System.arraycopy(	3981	System.arraycopy(
3799	this.expressionStack,	3982	this.expressionStack,
Lines 3817-3824 Link Here
3817	extendedDimensions > 0) {	4000	extendedDimensions > 0) {
3818	problemReporter().illegalExtendedDimensions(arg);	4001	problemReporter().illegalExtendedDimensions(arg);
3819	}	4002	}
		4003	} else {
		4004	// The grammar allows trailing annotations in FormalParameter as in
		4005	// "int @NonNull[] @Misplaced parameter" in order to allow for constructs such as
		4006	// "Object @NonNull[] @Correct ... objects" -- we prune these here.
		4007	if (varArgsAnnotations != null) {
		4008	problemReporter().misplacedTypeAnnotations(varArgsAnnotations[0],
		4009	varArgsAnnotations[varArgsAnnotations.length-1]);
		4010	}
3820	}	4011	}
3821	}	4012	}
		4013	protected Annotation[][] getAnnotationsOnDimensions(int dimensionsCount) {
		4014	Annotation [][] dimensionsAnnotations = null;
		4015	if (dimensionsCount > 0) {
		4016	for (int i = 0; i < dimensionsCount; i++) {
		4017	Annotation [] annotations = null;
		4018	int length;
		4019	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		4020	System.arraycopy(
		4021	this.typeAnnotationStack,
		4022	(this.typeAnnotationPtr -= length) + 1,
		4023	annotations = new Annotation[length],
		4024	0,
		4025	length);
		4026	if (dimensionsAnnotations == null) {
		4027	dimensionsAnnotations = new Annotation[dimensionsCount][];
		4028	}
		4029	dimensionsAnnotations[dimensionsCount - i - 1] = annotations;
		4030	}
		4031	}
		4032	}
		4033	return dimensionsAnnotations;
		4034	}
3822	protected void consumeFormalParameterList() {	4035	protected void consumeFormalParameterList() {
3823	// FormalParameterList ::= FormalParameterList ',' FormalParameter	4036	// FormalParameterList ::= FormalParameterList ',' FormalParameter
3824	optimizedConcatNodeLists();	4037	optimizedConcatNodeLists();
Lines 4407-4412 Link Here
4407	// MethodHeaderExtendedDims ::= Dimsopt	4620	// MethodHeaderExtendedDims ::= Dimsopt
4408	// now we update the returnType of the method	4621	// now we update the returnType of the method
4409	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];	4622	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
		4623	// jsr308 -- consume receiver annotations
		4624	md.receiverAnnotations = null;
		4625	int length;
		4626	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		4627	System.arraycopy(
		4628	this.typeAnnotationStack,
		4629	(this.typeAnnotationPtr -= length) + 1,
		4630	md.receiverAnnotations = new Annotation[length],
		4631	0,
		4632	length);
		4633	}
4410	int extendedDims = this.intStack[this.intPtr--];	4634	int extendedDims = this.intStack[this.intPtr--];
4411	if(md.isAnnotationMethod()) {	4635	if(md.isAnnotationMethod()) {
4412	((AnnotationMethodDeclaration)md).extendedDimensions = extendedDims;	4636	((AnnotationMethodDeclaration)md).extendedDimensions = extendedDims;
Lines 4415-4421 Link Here
4415	TypeReference returnType = md.returnType;	4639	TypeReference returnType = md.returnType;
4416	md.sourceEnd = this.endPosition;	4640	md.sourceEnd = this.endPosition;
4417	int dims = returnType.dimensions() + extendedDims;	4641	int dims = returnType.dimensions() + extendedDims;
4418	md.returnType = copyDims(returnType, dims);	4642	Annotation [][] annotationsOnDimensions = returnType.getAnnotationsOnDimensions();
		4643	Annotation [][] annotationsOnExtendedDimensions = getAnnotationsOnDimensions(extendedDims);
		4644	Annotation [][] annotationsOnAllDimensions = null;
		4645	if (annotationsOnDimensions != null \|\| annotationsOnExtendedDimensions != null) {
		4646	annotationsOnAllDimensions = getMergedAnnotationsOnDimensions(returnType.dimensions(), annotationsOnDimensions, extendedDims, annotationsOnExtendedDimensions);
		4647	}
		4648	md.returnType = copyDims(returnType, dims, annotationsOnAllDimensions);
4419	if (this.currentToken == TokenNameLBRACE){	4649	if (this.currentToken == TokenNameLBRACE){
4420	md.bodyStart = this.endPosition + 1;	4650	md.bodyStart = this.endPosition + 1;
4421	}	4651	}
Lines 4442-4448 Link Here
4442	long selectorSource = this.identifierPositionStack[this.identifierPtr--];	4672	long selectorSource = this.identifierPositionStack[this.identifierPtr--];
4443	this.identifierLengthPtr--;	4673	this.identifierLengthPtr--;
4444	//type	4674	//type
4445	md.returnType = getTypeReference(this.intStack[this.intPtr--]);	4675	md.returnType = getUnannotatedTypeReference(this.intStack[this.intPtr--]);
4446	//modifiers	4676	//modifiers
4447	md.declarationSourceStart = this.intStack[this.intPtr--];	4677	md.declarationSourceStart = this.intStack[this.intPtr--];
4448	md.modifiers = this.intStack[this.intPtr--];	4678	md.modifiers = this.intStack[this.intPtr--];
Lines 4482-4488 Link Here
4482	}	4712	}
4483	}	4713	}
4484	}	4714	}
4485	protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod) {	4715	protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod, boolean hasTypeAnnotations) {
4486	// MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	4716	// MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
4487	// AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	4717	// AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
4488	// RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	4718	// RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
Lines 4499-4505 Link Here
4499	long selectorSource = this.identifierPositionStack[this.identifierPtr--];	4729	long selectorSource = this.identifierPositionStack[this.identifierPtr--];
4500	this.identifierLengthPtr--;	4730	this.identifierLengthPtr--;
4501	//type	4731	//type
4502	md.returnType = getTypeReference(this.intStack[this.intPtr--]);	4732	md.returnType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
4503		4733
4504	// consume type parameters	4734	// consume type parameters
4505	int length = this.genericsLengthStack[this.genericsLengthPtr--];	4735	int length = this.genericsLengthStack[this.genericsLengthPtr--];
Lines 4721-4726 Link Here
4721	protected void consumeModifiers2() {	4951	protected void consumeModifiers2() {
4722	this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];	4952	this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];
4723	}	4953	}
		4954
		4955	protected void consumeOneMoreTypeAnnotation() {
		4956	// OneOrMoreAnnotations ::= OneOrMoreAnnotations Annotation
		4957	this.expressionLengthPtr --;
		4958	Annotation annotation = (Annotation) this.expressionStack[this.expressionPtr--];
		4959	pushOnTypeAnnotationStack(annotation);
		4960	this.typeAnnotationLengthStack[--this.typeAnnotationLengthPtr]++;
		4961	if(!this.statementRecoveryActivated &&
		4962	this.options.sourceLevel < ClassFileConstants.JDK1_7 &&
		4963	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		4964	problemReporter().invalidUsageOfTypeAnnotations(annotation);
		4965	}
		4966	}
		4967
		4968	protected void consumePotentialNameArrayType () {
		4969
		4970	// FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray VariableDeclaratorId
		4971	// FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray '...' VariableDeclaratorId
		4972	// PotentialNameArray -> $empty
		4973	// Dimensions including lack of have been pushed appropriately by action attached to DimsoptAnnotsopt
		4974	pushOnGenericsLengthStack(0); // handle type arguments
		4975	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
		4976	}
		4977
4724	protected void consumeNameArrayType() {	4978	protected void consumeNameArrayType() {
4725	pushOnGenericsLengthStack(0); // handle type arguments	4979	pushOnGenericsLengthStack(0); // handle type arguments
4726	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	4980	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
Lines 4784-4792 Link Here
4784	}	5038	}
4785	this.recordStringLiterals = true;	5039	this.recordStringLiterals = true;
4786	}	5040	}
4787	protected void consumeOneDimLoop() {	5041	protected void consumeOneDimLoop(boolean expressionStackMayHaveAnnotations) {
4788	// OneDimLoop ::= '[' ']'	5042	// OneDimLoop ::= '[' ']'
		5043	// OneDimOrAnnot -> '[' ']'
		5044	this.dimensions++;
		5045	if (!expressionStackMayHaveAnnotations \|\| this.unattachedAnnotationPtr == -1 ) {
		5046	pushOnTypeAnnotationLengthStack(0); // no annotations for the current dimension.
		5047	} else {
		5048	this.unattachedAnnotationPtr = -1; // Leave type annotation stacks they are.
		5049	}
		5050	}
		5051	protected void consumeOneDimLoopWithAnnotations() {
		5052	// OneDimLoop ::= OneOrMoreAnnotations '[' ']'
4789	this.dimensions++;	5053	this.dimensions++;
		5054	// Top of expression stack contains annotations of length specified
		5055	// by top of expression length stack that apply to this dimension.
4790	}	5056	}
4791	protected void consumeOnlySynchronized() {	5057	protected void consumeOnlySynchronized() {
4792	// OnlySynchronized ::= 'synchronized'	5058	// OnlySynchronized ::= 'synchronized'
Lines 4956-4962 Link Here
4956	pushOnGenericsLengthStack(0);	5222	pushOnGenericsLengthStack(0);
4957		5223
4958	pushOnExpressionStack(	5224	pushOnExpressionStack(
4959	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));	5225	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(this.intStack[this.intPtr--])));
4960	}	5226	}
4961	protected void consumePrimaryNoNewArrayName() {	5227	protected void consumePrimaryNoNewArrayName() {
4962	// PrimaryNoNewArray ::= Name '.' 'class'	5228	// PrimaryNoNewArray ::= Name '.' 'class'
Lines 4965-4971 Link Here
4965	// handle type arguments	5231	// handle type arguments
4966	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	5232	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4967	pushOnGenericsLengthStack(0);	5233	pushOnGenericsLengthStack(0);
4968	TypeReference typeReference = getTypeReference(0);	5234	TypeReference typeReference = getUnannotatedTypeReference(0); // TODO (Srikanth) needs fix
4969		5235
4970	pushOnExpressionStack(	5236	pushOnExpressionStack(
4971	new ClassLiteralAccess(this.intStack[this.intPtr--], typeReference));	5237	new ClassLiteralAccess(this.intStack[this.intPtr--], typeReference));
Lines 4975-4981 Link Here
4975	// handle type arguments	5241	// handle type arguments
4976	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	5242	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4977	pushOnGenericsLengthStack(0);	5243	pushOnGenericsLengthStack(0);
4978	TypeReference typeReference = getTypeReference(0);	5244	TypeReference typeReference = getUnannotatedTypeReference(0);
4979		5245
4980	pushOnExpressionStack(	5246	pushOnExpressionStack(
4981	new QualifiedSuperReference(	5247	new QualifiedSuperReference(
Lines 4989-4995 Link Here
4989	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	5255	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4990	pushOnGenericsLengthStack(0); // handle type arguments	5256	pushOnGenericsLengthStack(0); // handle type arguments
4991		5257
4992	TypeReference typeReference = getTypeReference(0);	5258	TypeReference typeReference = getUnannotatedTypeReference(0); // javac complains on annotations here.
4993		5259
4994	pushOnExpressionStack(	5260	pushOnExpressionStack(
4995	new QualifiedThisReference(	5261	new QualifiedThisReference(
Lines 5001-5013 Link Here
5001	// PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class'	5267	// PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class'
5002	this.intPtr--; // remove the class start position	5268	this.intPtr--; // remove the class start position
5003	pushOnExpressionStack(	5269	pushOnExpressionStack(
5004	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));	5270	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(this.intStack[this.intPtr--])));
5005	}	5271	}
5006	protected void consumePrimaryNoNewArrayPrimitiveType() {	5272	protected void consumePrimaryNoNewArrayPrimitiveType() {
5007	// PrimaryNoNewArray ::= PrimitiveType '.' 'class'	5273	// PrimaryNoNewArray ::= PrimitiveType '.' 'class'
5008	this.intPtr--; // remove the class start position	5274	this.intPtr--; // remove the class start position
5009	pushOnExpressionStack(	5275	pushOnExpressionStack(
5010	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(0)));	5276	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(0)));
5011	}	5277	}
5012	protected void consumePrimaryNoNewArrayThis() {	5278	protected void consumePrimaryNoNewArrayThis() {
5013	// PrimaryNoNewArray ::= 'this'	5279	// PrimaryNoNewArray ::= 'this'
Lines 5077-5083 Link Here
5077	}	5343	}
5078	consumeMethodHeaderName(isAnnotationMethod);	5344	consumeMethodHeaderName(isAnnotationMethod);
5079	}	5345	}
5080	protected void consumeRecoveryMethodHeaderNameWithTypeParameters() {	5346	protected void consumeRecoveryMethodHeaderNameWithTypeParameters(boolean hasTypeAnnotations) {
5081	// this method is call only inside recovery	5347	// this method is call only inside recovery
5082	boolean isAnnotationMethod = false;	5348	boolean isAnnotationMethod = false;
5083	if(this.currentElement instanceof RecoveredType) {	5349	if(this.currentElement instanceof RecoveredType) {
Lines 5088-5094 Link Here
5088	isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;	5354	isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;
5089	}	5355	}
5090	}	5356	}
5091	consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);	5357	consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod, hasTypeAnnotations);
5092	}	5358	}
5093	protected void consumeReduceImports() {	5359	protected void consumeReduceImports() {
5094	// Consume imports	5360	// Consume imports
Lines 5106-5119 Link Here
5106	protected void consumeReferenceType() {	5372	protected void consumeReferenceType() {
5107	pushOnIntStack(0); // handle array type	5373	pushOnIntStack(0); // handle array type
5108	}	5374	}
5109	protected void consumeReferenceType1() {	5375	protected void consumeReferenceType1(boolean hasTypeAnnotations) {
5110	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	5376	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
5111	}	5377	}
5112	protected void consumeReferenceType2() {	5378	protected void consumeReferenceType2(boolean hasTypeAnnotations) {
5113	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	5379	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
5114	}	5380	}
5115	protected void consumeReferenceType3() {	5381	protected void consumeReferenceType3(boolean hasTypeAnnotations) {
5116	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	5382	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
5117	}	5383	}
5118	protected void consumeRestoreDiet() {	5384	protected void consumeRestoreDiet() {
5119	// RestoreDiet ::= $empty	5385	// RestoreDiet ::= $empty
Lines 5138-6811 Link Here
5138	consumeClassOrInterfaceName();	5404	consumeClassOrInterfaceName();
5139	break;	5405	break;
5140		5406
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$	5407	case 50 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); } //$NON-NLS-1$
5146	consumeGenericType();	5408	consumeGenericType();
5147	break;	5409	break;
5148		5410
5149	case 51 : if (DEBUG) { System.out.println("ArrayTypeWithTypeArgumentsName ::= GenericType DOT Name"); } //$NON-NLS-1$	5411	case 51 : if (DEBUG) { System.out.println("GenericTypeDotName ::= GenericType DOT Name"); } //$NON-NLS-1$
5150	consumeArrayTypeWithTypeArgumentsName();	5412	consumeClassOrInterface();
5151	break;	5413	break;
5152		5414
5153	case 52 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); } //$NON-NLS-1$	5415	case 53 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); } //$NON-NLS-1$
5154	consumePrimitiveArrayType();	5416	consumePrimitiveArrayType();
5155	break;	5417	break;
5156		5418
5157	case 53 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); } //$NON-NLS-1$	5419	case 54 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); } //$NON-NLS-1$
5158	consumeNameArrayType();	5420	consumeNameArrayType();
5159	break;	5421	break;
5160		5422
5161	case 54 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); } //$NON-NLS-1$	5423	case 55 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); } //$NON-NLS-1$
5162	consumeGenericTypeNameArrayType();	5424	consumeGenericTypeNameArrayType();
5163	break;	5425	break;
5164		5426
5165	case 55 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); } //$NON-NLS-1$	5427	case 56 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); } //$NON-NLS-1$
5166	consumeGenericTypeArrayType();	5428	consumeGenericTypeArrayType();
5167	break;	5429	break;
5168		5430
5169	case 60 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); } //$NON-NLS-1$	5431	case 57 : if (DEBUG) { System.out.println("ClassType ::= ClassOrInterfaceType"); } //$NON-NLS-1$
		5432	consumeZeroTypeAnnotations();
		5433	break;
		5434
		5435	case 62 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); } //$NON-NLS-1$
5170	consumeQualifiedName();	5436	consumeQualifiedName();
5171	break;	5437	break;
5172		5438
5173	case 61 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$	5439	case 63 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$
5174	consumeCompilationUnit();	5440	consumeCompilationUnit();
5175	break;	5441	break;
5176		5442
5177	case 62 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); } //$NON-NLS-1$	5443	case 64 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); } //$NON-NLS-1$
5178	consumeInternalCompilationUnit();	5444	consumeInternalCompilationUnit();
5179	break;	5445	break;
5180		5446
5181	case 63 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5447	case 65 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5182	consumeInternalCompilationUnit();	5448	consumeInternalCompilationUnit();
5183	break;	5449	break;
5184		5450
5185	case 64 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5451	case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5186	consumeInternalCompilationUnitWithTypes();	5452	consumeInternalCompilationUnitWithTypes();
5187	break;	5453	break;
5188		5454
5189	case 65 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5455	case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5190	consumeInternalCompilationUnitWithTypes();	5456	consumeInternalCompilationUnitWithTypes();
5191	break;	5457	break;
5192		5458
5193	case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$	5459	case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$
5194	consumeInternalCompilationUnit();	5460	consumeInternalCompilationUnit();
5195	break;	5461	break;
5196		5462
5197	case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); } //$NON-NLS-1$	5463	case 69 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); } //$NON-NLS-1$
5198	consumeInternalCompilationUnitWithTypes();	5464	consumeInternalCompilationUnitWithTypes();
5199	break;	5465	break;
5200		5466
5201	case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$	5467	case 70 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$
5202	consumeInternalCompilationUnitWithTypes();	5468	consumeInternalCompilationUnitWithTypes();
5203	break;	5469	break;
5204		5470
5205	case 69 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$	5471	case 71 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$
5206	consumeEmptyInternalCompilationUnit();	5472	consumeEmptyInternalCompilationUnit();
5207	break;	5473	break;
5208		5474
5209	case 70 : if (DEBUG) { System.out.println("ReduceImports ::="); } //$NON-NLS-1$	5475	case 72 : if (DEBUG) { System.out.println("ReduceImports ::="); } //$NON-NLS-1$
5210	consumeReduceImports();	5476	consumeReduceImports();
5211	break;	5477	break;
5212		5478
5213	case 71 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$	5479	case 73 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$
5214	consumeEnterCompilationUnit();	5480	consumeEnterCompilationUnit();
5215	break;	5481	break;
5216		5482
5217	case 87 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$	5483	case 89 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
5218	consumeCatchHeader();	5484	consumeCatchHeader();
5219	break;	5485	break;
5220		5486
5221	case 89 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); } //$NON-NLS-1$	5487	case 91 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); } //$NON-NLS-1$
5222	consumeImportDeclarations();	5488	consumeImportDeclarations();
5223	break;	5489	break;
5224		5490
5225	case 91 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); } //$NON-NLS-1$	5491	case 93 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); } //$NON-NLS-1$
5226	consumeTypeDeclarations();	5492	consumeTypeDeclarations();
5227	break;	5493	break;
5228		5494
5229	case 92 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); } //$NON-NLS-1$	5495	case 94 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); } //$NON-NLS-1$
5230	consumePackageDeclaration();	5496	consumePackageDeclaration();
5231	break;	5497	break;
5232		5498
5233	case 93 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); } //$NON-NLS-1$	5499	case 95 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); } //$NON-NLS-1$
5234	consumePackageDeclarationNameWithModifiers();	5500	consumePackageDeclarationNameWithModifiers();
5235	break;	5501	break;
5236		5502
5237	case 94 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); } //$NON-NLS-1$	5503	case 96 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); } //$NON-NLS-1$
5238	consumePackageDeclarationName();	5504	consumePackageDeclarationName();
5239	break;	5505	break;
5240		5506
5241	case 95 : if (DEBUG) { System.out.println("PackageComment ::="); } //$NON-NLS-1$	5507	case 97 : if (DEBUG) { System.out.println("PackageComment ::="); } //$NON-NLS-1$
5242	consumePackageComment();	5508	consumePackageComment();
5243	break;	5509	break;
5244		5510
5245	case 100 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); } //$NON-NLS-1$	5511	case 102 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); } //$NON-NLS-1$
5246	consumeImportDeclaration();	5512	consumeImportDeclaration();
5247	break;	5513	break;
5248		5514
5249	case 101 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); } //$NON-NLS-1$	5515	case 103 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); } //$NON-NLS-1$
5250	consumeSingleTypeImportDeclarationName();	5516	consumeSingleTypeImportDeclarationName();
5251	break;	5517	break;
5252		5518
5253	case 102 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$	5519	case 104 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$
5254	consumeImportDeclaration();	5520	consumeImportDeclaration();
5255	break;	5521	break;
5256		5522
5257	case 103 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); } //$NON-NLS-1$	5523	case 105 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); } //$NON-NLS-1$
5258	consumeTypeImportOnDemandDeclarationName();	5524	consumeTypeImportOnDemandDeclarationName();
5259	break;	5525	break;
5260		5526
5261	case 106 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5527	case 108 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5262	consumeEmptyTypeDeclaration();	5528	consumeEmptyTypeDeclaration();
5263	break;	5529	break;
5264		5530
5265	case 110 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); } //$NON-NLS-1$	5531	case 112 : if (DEBUG) { System.out.println("NonAnnotModifiers ::= NonAnnotModifiers NonAnnotModifier"); } //$NON-NLS-1$
		5532	consumeModifiers2();
		5533	break;
		5534
		5535	case 114 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); } //$NON-NLS-1$
5266	consumeModifiers2();	5536	consumeModifiers2();
5267	break;	5537	break;
5268		5538
5269	case 122 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); } //$NON-NLS-1$	5539	case 137 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); } //$NON-NLS-1$
5270	consumeAnnotationAsModifier();	5540	consumeAnnotationAsModifier();
5271	break;	5541	break;
5272		5542
5273	case 123 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); } //$NON-NLS-1$	5543	case 138 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); } //$NON-NLS-1$
5274	consumeClassDeclaration();	5544	consumeClassDeclaration();
5275	break;	5545	break;
5276		5546
5277	case 124 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); } //$NON-NLS-1$	5547	case 139 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); } //$NON-NLS-1$
5278	consumeClassHeader();	5548	consumeClassHeader();
5279	break;	5549	break;
5280		5550
5281	case 125 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); } //$NON-NLS-1$	5551	case 140 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); } //$NON-NLS-1$
5282	consumeTypeHeaderNameWithTypeParameters();	5552	consumeTypeHeaderNameWithTypeParameters();
5283	break;	5553	break;
5284		5554
5285	case 127 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); } //$NON-NLS-1$	5555	case 142 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); } //$NON-NLS-1$
5286	consumeClassHeaderName1();	5556	consumeClassHeaderName1();
5287	break;	5557	break;
5288		5558
5289	case 128 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); } //$NON-NLS-1$	5559	case 143 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); } //$NON-NLS-1$
5290	consumeClassHeaderExtends();	5560	consumeClassHeaderExtends();
5291	break;	5561	break;
5292		5562
5293	case 129 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); } //$NON-NLS-1$	5563	case 144 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); } //$NON-NLS-1$
5294	consumeClassHeaderImplements();	5564	consumeClassHeaderImplements();
5295	break;	5565	break;
5296		5566
5297	case 131 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); } //$NON-NLS-1$	5567	case 146 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); } //$NON-NLS-1$
5298	consumeInterfaceTypeList();	5568	consumeInterfaceTypeList();
5299	break;	5569	break;
5300		5570
5301	case 132 : if (DEBUG) { System.out.println("InterfaceType ::= ClassOrInterfaceType"); } //$NON-NLS-1$	5571	case 147 : if (DEBUG) { System.out.println("InterfaceType ::= PushZeroTypeAnnotations..."); } //$NON-NLS-1$
		5572	consumeInterfaceType();
		5573	break;
		5574
		5575	case 148 : if (DEBUG) { System.out.println("InterfaceType ::= OneOrMoreAnnotations..."); } //$NON-NLS-1$
5302	consumeInterfaceType();	5576	consumeInterfaceType();
5303	break;	5577	break;
5304		5578
5305	case 135 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); } //$NON-NLS-1$	5579	case 151 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); } //$NON-NLS-1$
5306	consumeClassBodyDeclarations();	5580	consumeClassBodyDeclarations();
5307	break;	5581	break;
5308		5582
5309	case 139 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); } //$NON-NLS-1$	5583	case 155 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); } //$NON-NLS-1$
5310	consumeClassBodyDeclaration();	5584	consumeClassBodyDeclaration();
5311	break;	5585	break;
5312		5586
5313	case 140 : if (DEBUG) { System.out.println("Diet ::="); } //$NON-NLS-1$	5587	case 156 : if (DEBUG) { System.out.println("Diet ::="); } //$NON-NLS-1$
5314	consumeDiet();	5588	consumeDiet();
5315	break;	5589	break;
5316		5590
5317	case 141 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); } //$NON-NLS-1$	5591	case 157 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); } //$NON-NLS-1$
5318	consumeClassBodyDeclaration();	5592	consumeClassBodyDeclaration();
5319	break;	5593	break;
5320		5594
5321	case 142 : if (DEBUG) { System.out.println("CreateInitializer ::="); } //$NON-NLS-1$	5595	case 158 : if (DEBUG) { System.out.println("CreateInitializer ::="); } //$NON-NLS-1$
5322	consumeCreateInitializer();	5596	consumeCreateInitializer();
5323	break;	5597	break;
5324		5598
5325	case 149 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5599	case 165 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5326	consumeEmptyTypeDeclaration();	5600	consumeEmptyTypeDeclaration();
5327	break;	5601	break;
5328		5602
5329	case 152 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type..."); } //$NON-NLS-1$	5603	case 168 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type..."); } //$NON-NLS-1$
5330	consumeFieldDeclaration();	5604	consumeFieldDeclaration();
5331	break;	5605	break;
5332		5606
5333	case 154 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$	5607	case 170 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$
5334	consumeVariableDeclarators();	5608	consumeVariableDeclarators();
5335	break;	5609	break;
5336		5610
5337	case 157 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$	5611	case 173 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$
5338	consumeEnterVariable();	5612	consumeEnterVariable();
5339	break;	5613	break;
5340		5614
5341	case 158 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$	5615	case 174 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$
5342	consumeExitVariableWithInitialization();	5616	consumeExitVariableWithInitialization();
5343	break;	5617	break;
5344		5618
5345	case 159 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$	5619	case 175 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$
5346	consumeExitVariableWithoutInitialization();	5620	consumeExitVariableWithoutInitialization();
5347	break;	5621	break;
5348		5622
5349	case 160 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$	5623	case 176 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$
5350	consumeForceNoDiet();	5624	consumeForceNoDiet();
5351	break;	5625	break;
5352		5626
5353	case 161 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$	5627	case 177 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$
5354	consumeRestoreDiet();	5628	consumeRestoreDiet();
5355	break;	5629	break;
5356		5630
5357	case 166 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$	5631	case 182 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$
5358	// set to true to consume a method with a body	5632	// set to true to consume a method with a body
5359	consumeMethodDeclaration(true);	5633	consumeMethodDeclaration(true);
5360	break;	5634	break;
5361		5635
5362	case 167 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$	5636	case 183 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$
5363	// set to false to consume a method without body	5637	// set to false to consume a method without body
5364	consumeMethodDeclaration(false);	5638	consumeMethodDeclaration(false);
5365	break;	5639	break;
5366		5640
5367	case 168 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$	5641	case 184 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$
5368	consumeMethodHeader();	5642	consumeMethodHeader();
5369	break;	5643	break;
5370		5644
5371	case 169 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); } //$NON-NLS-1$	5645	case 185 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); } //$NON-NLS-1$
5372	consumeMethodHeaderNameWithTypeParameters(false);	5646	consumeMethodHeaderNameWithTypeParameters(false, false);
5373	break;	5647	break;
5374		5648
5375	case 170 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); } //$NON-NLS-1$	5649	case 186 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$
		5650	consumeMethodHeaderNameWithTypeParameters(false, true);
		5651	break;
		5652
		5653	case 187 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); } //$NON-NLS-1$
5376	consumeMethodHeaderName(false);	5654	consumeMethodHeaderName(false);
5377	break;	5655	break;
5378		5656
5379	case 171 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$	5657	case 188 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$
5380	consumeMethodHeaderRightParen();	5658	consumeMethodHeaderRightParen();
5381	break;	5659	break;
5382		5660
5383	case 172 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= Dimsopt"); } //$NON-NLS-1$	5661	case 189 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= DimsoptAnnotsopt"); } //$NON-NLS-1$
5384	consumeMethodHeaderExtendedDims();	5662	consumeMethodHeaderExtendedDims();
5385	break;	5663	break;
5386		5664
5387	case 173 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); } //$NON-NLS-1$	5665	case 190 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); } //$NON-NLS-1$
5388	consumeMethodHeaderThrowsClause();	5666	consumeMethodHeaderThrowsClause();
5389	break;	5667	break;
5390		5668
5391	case 174 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$	5669	case 191 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$
5392	consumeConstructorHeader();	5670	consumeConstructorHeader();
5393	break;	5671	break;
5394		5672
5395	case 175 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$	5673	case 192 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$
		5674	consumeConstructorHeader();
		5675	break;
		5676
		5677	case 193 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$
5396	consumeConstructorHeaderNameWithTypeParameters();	5678	consumeConstructorHeaderNameWithTypeParameters();
5397	break;	5679	break;
5398		5680
5399	case 176 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); } //$NON-NLS-1$	5681	case 194 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); } //$NON-NLS-1$
5400	consumeConstructorHeaderName();	5682	consumeConstructorHeaderName();
5401	break;	5683	break;
5402		5684
5403	case 178 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$	5685	case 196 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$
5404	consumeFormalParameterList();	5686	consumeFormalParameterList();
5405	break;	5687	break;
5406		5688
5407	case 179 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type..."); } //$NON-NLS-1$	5689	case 197 : if (DEBUG) { System.out.println("PotentialNameArray ::="); } //$NON-NLS-1$
		5690	consumePotentialNameArrayType();
		5691	break;
		5692
		5693	case 198 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); } //$NON-NLS-1$
5408	consumeFormalParameter(false);	5694	consumeFormalParameter(false);
5409	break;	5695	break;
5410		5696
5411	case 180 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type ELLIPSIS..."); } //$NON-NLS-1$	5697	case 199 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); } //$NON-NLS-1$
5412	consumeFormalParameter(true);	5698	consumeFormalParameter(true);
5413	break;	5699	break;
5414		5700
5415	case 182 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); } //$NON-NLS-1$	5701	case 200 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); } //$NON-NLS-1$
		5702	consumeFormalParameter(false);
		5703	break;
		5704
		5705	case 201 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); } //$NON-NLS-1$
		5706	consumeFormalParameter(true);
		5707	break;
		5708
		5709	case 202 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); } //$NON-NLS-1$
		5710	consumeFormalParameter(false);
		5711	break;
		5712
		5713	case 203 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); } //$NON-NLS-1$
		5714	consumeFormalParameter(true);
		5715	break;
		5716
		5717	case 204 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); } //$NON-NLS-1$
		5718	consumeFormalParameter(false);
		5719	break;
		5720
		5721	case 205 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); } //$NON-NLS-1$
		5722	consumeFormalParameter(true);
		5723	break;
		5724
		5725	case 207 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); } //$NON-NLS-1$
5416	consumeClassTypeList();	5726	consumeClassTypeList();
5417	break;	5727	break;
5418		5728
5419	case 183 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); } //$NON-NLS-1$	5729	case 208 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); } //$NON-NLS-1$
5420	consumeClassTypeElt();	5730	consumeClassTypeElt();
5421	break;	5731	break;
5422		5732
5423	case 184 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); } //$NON-NLS-1$	5733	case 209 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); } //$NON-NLS-1$
5424	consumeMethodBody();	5734	consumeMethodBody();
5425	break;	5735	break;
5426		5736
5427	case 185 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$	5737	case 210 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$
5428	consumeNestedMethod();	5738	consumeNestedMethod();
5429	break;	5739	break;
5430		5740
5431	case 186 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); } //$NON-NLS-1$	5741	case 211 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); } //$NON-NLS-1$
5432	consumeStaticInitializer();	5742	consumeStaticInitializer();
5433	break;	5743	break;
5434		5744
5435	case 187 : if (DEBUG) { System.out.println("StaticOnly ::= static"); } //$NON-NLS-1$	5745	case 212 : if (DEBUG) { System.out.println("StaticOnly ::= static"); } //$NON-NLS-1$
5436	consumeStaticOnly();	5746	consumeStaticOnly();
5437	break;	5747	break;
5438		5748
5439	case 188 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); } //$NON-NLS-1$	5749	case 213 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); } //$NON-NLS-1$
5440	consumeConstructorDeclaration() ;	5750	consumeConstructorDeclaration() ;
5441	break;	5751	break;
5442		5752
5443	case 189 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); } //$NON-NLS-1$	5753	case 214 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); } //$NON-NLS-1$
5444	consumeInvalidConstructorDeclaration() ;	5754	consumeInvalidConstructorDeclaration() ;
5445	break;	5755	break;
5446		5756
5447	case 190 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); } //$NON-NLS-1$	5757	case 215 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); } //$NON-NLS-1$
5448	consumeExplicitConstructorInvocation(0, THIS_CALL);	5758	consumeExplicitConstructorInvocation(0, THIS_CALL);
5449	break;	5759	break;
5450		5760
5451	case 191 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); } //$NON-NLS-1$	5761	case 216 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); } //$NON-NLS-1$
5452	consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);	5762	consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);
5453	break;	5763	break;
5454		5764
5455	case 192 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); } //$NON-NLS-1$	5765	case 217 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); } //$NON-NLS-1$
5456	consumeExplicitConstructorInvocation(0,SUPER_CALL);	5766	consumeExplicitConstructorInvocation(0,SUPER_CALL);
5457	break;	5767	break;
5458		5768
5459	case 193 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); } //$NON-NLS-1$	5769	case 218 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); } //$NON-NLS-1$
5460	consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);	5770	consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);
5461	break;	5771	break;
5462		5772
5463	case 194 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); } //$NON-NLS-1$	5773	case 219 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); } //$NON-NLS-1$
5464	consumeExplicitConstructorInvocation(1, SUPER_CALL);	5774	consumeExplicitConstructorInvocation(1, SUPER_CALL);
5465	break;	5775	break;
5466		5776
5467	case 195 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$	5777	case 220 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$
5468	consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);	5778	consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);
5469	break;	5779	break;
5470		5780
5471	case 196 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); } //$NON-NLS-1$	5781	case 221 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); } //$NON-NLS-1$
5472	consumeExplicitConstructorInvocation(2, SUPER_CALL);	5782	consumeExplicitConstructorInvocation(2, SUPER_CALL);
5473	break;	5783	break;
5474		5784
5475	case 197 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$	5785	case 222 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$
5476	consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);	5786	consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);
5477	break;	5787	break;
5478		5788
5479	case 198 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); } //$NON-NLS-1$	5789	case 223 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); } //$NON-NLS-1$
5480	consumeExplicitConstructorInvocation(1, THIS_CALL);	5790	consumeExplicitConstructorInvocation(1, THIS_CALL);
5481	break;	5791	break;
5482		5792
5483	case 199 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$	5793	case 224 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$
5484	consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);	5794	consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);
5485	break;	5795	break;
5486		5796
5487	case 200 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); } //$NON-NLS-1$	5797	case 225 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); } //$NON-NLS-1$
5488	consumeExplicitConstructorInvocation(2, THIS_CALL);	5798	consumeExplicitConstructorInvocation(2, THIS_CALL);
5489	break;	5799	break;
5490		5800
5491	case 201 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$	5801	case 226 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$
5492	consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);	5802	consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);
5493	break;	5803	break;
5494		5804
5495	case 202 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); } //$NON-NLS-1$	5805	case 227 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); } //$NON-NLS-1$
5496	consumeInterfaceDeclaration();	5806	consumeInterfaceDeclaration();
5497	break;	5807	break;
5498		5808
5499	case 203 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); } //$NON-NLS-1$	5809	case 228 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); } //$NON-NLS-1$
5500	consumeInterfaceHeader();	5810	consumeInterfaceHeader();
5501	break;	5811	break;
5502		5812
5503	case 204 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); } //$NON-NLS-1$	5813	case 229 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); } //$NON-NLS-1$
5504	consumeTypeHeaderNameWithTypeParameters();	5814	consumeTypeHeaderNameWithTypeParameters();
5505	break;	5815	break;
5506		5816
5507	case 206 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); } //$NON-NLS-1$	5817	case 231 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); } //$NON-NLS-1$
5508	consumeInterfaceHeaderName1();	5818	consumeInterfaceHeaderName1();
5509	break;	5819	break;
5510		5820
5511	case 207 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); } //$NON-NLS-1$	5821	case 232 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); } //$NON-NLS-1$
5512	consumeInterfaceHeaderExtends();	5822	consumeInterfaceHeaderExtends();
5513	break;	5823	break;
5514		5824
5515	case 210 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); } //$NON-NLS-1$	5825	case 235 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); } //$NON-NLS-1$
5516	consumeInterfaceMemberDeclarations();	5826	consumeInterfaceMemberDeclarations();
5517	break;	5827	break;
5518		5828
5519	case 211 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5829	case 236 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5520	consumeEmptyTypeDeclaration();	5830	consumeEmptyTypeDeclaration();
5521	break;	5831	break;
5522		5832
5523	case 213 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$	5833	case 238 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$
5524	consumeInvalidMethodDeclaration();	5834	consumeInvalidMethodDeclaration();
5525	break;	5835	break;
5526		5836
5527	case 214 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$	5837	case 239 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$
5528	consumeInvalidConstructorDeclaration(true);	5838	consumeInvalidConstructorDeclaration(true);
5529	break;	5839	break;
5530		5840
5531	case 215 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$	5841	case 240 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$
5532	consumeInvalidConstructorDeclaration(false);	5842	consumeInvalidConstructorDeclaration(false);
5533	break;	5843	break;
5534		5844
5535	case 223 : if (DEBUG) { System.out.println("PushLeftBrace ::="); } //$NON-NLS-1$	5845	case 248 : if (DEBUG) { System.out.println("PushLeftBrace ::="); } //$NON-NLS-1$
5536	consumePushLeftBrace();	5846	consumePushLeftBrace();
5537	break;	5847	break;
5538		5848
5539	case 224 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); } //$NON-NLS-1$	5849	case 249 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); } //$NON-NLS-1$
5540	consumeEmptyArrayInitializer();	5850	consumeEmptyArrayInitializer();
5541	break;	5851	break;
5542		5852
5543	case 225 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$	5853	case 250 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$
5544	consumeArrayInitializer();	5854	consumeArrayInitializer();
5545	break;	5855	break;
5546		5856
5547	case 226 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$	5857	case 251 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$
5548	consumeArrayInitializer();	5858	consumeArrayInitializer();
5549	break;	5859	break;
5550		5860
5551	case 228 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); } //$NON-NLS-1$	5861	case 253 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); } //$NON-NLS-1$
5552	consumeVariableInitializers();	5862	consumeVariableInitializers();
5553	break;	5863	break;
5554		5864
5555	case 229 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$	5865	case 254 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$
5556	consumeBlock();	5866	consumeBlock();
5557	break;	5867	break;
5558		5868
5559	case 230 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$	5869	case 255 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$
5560	consumeOpenBlock() ;	5870	consumeOpenBlock() ;
5561	break;	5871	break;
5562		5872
5563	case 232 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$	5873	case 257 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$
5564	consumeBlockStatements() ;	5874	consumeBlockStatements() ;
5565	break;	5875	break;
5566		5876
5567	case 236 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); } //$NON-NLS-1$	5877	case 261 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); } //$NON-NLS-1$
5568	consumeInvalidInterfaceDeclaration();	5878	consumeInvalidInterfaceDeclaration();
5569	break;	5879	break;
5570		5880
5571	case 237 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); } //$NON-NLS-1$	5881	case 262 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); } //$NON-NLS-1$
5572	consumeInvalidAnnotationTypeDeclaration();	5882	consumeInvalidAnnotationTypeDeclaration();
5573	break;	5883	break;
5574		5884
5575	case 238 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); } //$NON-NLS-1$	5885	case 263 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); } //$NON-NLS-1$
5576	consumeInvalidEnumDeclaration();	5886	consumeInvalidEnumDeclaration();
5577	break;	5887	break;
5578		5888
5579	case 239 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$	5889	case 264 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$
5580	consumeLocalVariableDeclarationStatement();	5890	consumeLocalVariableDeclarationStatement();
5581	break;	5891	break;
5582		5892
5583	case 240 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); } //$NON-NLS-1$	5893	case 265 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); } //$NON-NLS-1$
5584	consumeLocalVariableDeclaration();	5894	consumeLocalVariableDeclaration();
5585	break;	5895	break;
5586		5896
5587	case 241 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); } //$NON-NLS-1$	5897	case 266 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); } //$NON-NLS-1$
5588	consumeLocalVariableDeclaration();	5898	consumeLocalVariableDeclaration();
5589	break;	5899	break;
5590		5900
5591	case 242 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$	5901	case 267 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$
5592	consumePushModifiers();	5902	consumePushModifiers();
5593	break;	5903	break;
5594		5904
5595	case 243 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); } //$NON-NLS-1$	5905	case 268 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); } //$NON-NLS-1$
5596	consumePushModifiersForHeader();	5906	consumePushModifiersForHeader();
5597	break;	5907	break;
5598		5908
5599	case 244 : if (DEBUG) { System.out.println("PushRealModifiers ::="); } //$NON-NLS-1$	5909	case 269 : if (DEBUG) { System.out.println("PushRealModifiers ::="); } //$NON-NLS-1$
5600	consumePushRealModifiers();	5910	consumePushRealModifiers();
5601	break;	5911	break;
5602		5912
5603	case 270 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); } //$NON-NLS-1$	5913	case 295 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); } //$NON-NLS-1$
5604	consumeEmptyStatement();	5914	consumeEmptyStatement();
5605	break;	5915	break;
5606		5916
5607	case 271 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$	5917	case 296 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$
5608	consumeStatementLabel() ;	5918	consumeStatementLabel() ;
5609	break;	5919	break;
5610		5920
5611	case 272 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$	5921	case 297 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$
5612	consumeStatementLabel() ;	5922	consumeStatementLabel() ;
5613	break;	5923	break;
5614		5924
5615	case 273 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$	5925	case 298 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$
5616	consumeLabel() ;	5926	consumeLabel() ;
5617	break;	5927	break;
5618		5928
5619	case 274 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$	5929	case 299 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$
5620	consumeExpressionStatement();	5930	consumeExpressionStatement();
5621	break;	5931	break;
5622		5932
5623	case 283 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5933	case 308 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5624	consumeStatementIfNoElse();	5934	consumeStatementIfNoElse();
5625	break;	5935	break;
5626		5936
5627	case 284 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5937	case 309 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5628	consumeStatementIfWithElse();	5938	consumeStatementIfWithElse();
5629	break;	5939	break;
5630		5940
5631	case 285 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$	5941	case 310 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$
5632	consumeStatementIfWithElse();	5942	consumeStatementIfWithElse();
5633	break;	5943	break;
5634		5944
5635	case 286 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5945	case 311 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5636	consumeStatementSwitch() ;	5946	consumeStatementSwitch() ;
5637	break;	5947	break;
5638		5948
5639	case 287 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$	5949	case 312 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$
5640	consumeEmptySwitchBlock() ;	5950	consumeEmptySwitchBlock() ;
5641	break;	5951	break;
5642		5952
5643	case 290 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$	5953	case 315 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$
5644	consumeSwitchBlock() ;	5954	consumeSwitchBlock() ;
5645	break;	5955	break;
5646		5956
5647	case 292 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$	5957	case 317 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$
5648	consumeSwitchBlockStatements() ;	5958	consumeSwitchBlockStatements() ;
5649	break;	5959	break;
5650		5960
5651	case 293 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$	5961	case 318 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$
5652	consumeSwitchBlockStatement() ;	5962	consumeSwitchBlockStatement() ;
5653	break;	5963	break;
5654		5964
5655	case 295 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$	5965	case 320 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$
5656	consumeSwitchLabels() ;	5966	consumeSwitchLabels() ;
5657	break;	5967	break;
5658		5968
5659	case 296 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$	5969	case 321 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$
5660	consumeCaseLabel();	5970	consumeCaseLabel();
5661	break;	5971	break;
5662		5972
5663	case 297 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$	5973	case 322 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$
5664	consumeDefaultLabel();	5974	consumeDefaultLabel();
5665	break;	5975	break;
5666		5976
5667	case 298 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$	5977	case 323 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5668	consumeStatementWhile() ;	5978	consumeStatementWhile() ;
5669	break;	5979	break;
5670		5980
5671	case 299 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$	5981	case 324 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$
5672	consumeStatementWhile() ;	5982	consumeStatementWhile() ;
5673	break;	5983	break;
5674		5984
5675	case 300 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$	5985	case 325 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$
5676	consumeStatementDo() ;	5986	consumeStatementDo() ;
5677	break;	5987	break;
5678		5988
5679	case 301 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$	5989	case 326 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$
5680	consumeStatementFor() ;	5990	consumeStatementFor() ;
5681	break;	5991	break;
5682		5992
5683	case 302 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$	5993	case 327 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$
5684	consumeStatementFor() ;	5994	consumeStatementFor() ;
5685	break;	5995	break;
5686		5996
5687	case 303 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); } //$NON-NLS-1$	5997	case 328 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); } //$NON-NLS-1$
5688	consumeForInit() ;	5998	consumeForInit() ;
5689	break;	5999	break;
5690		6000
5691	case 307 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$	6001	case 332 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$
5692	consumeStatementExpressionList() ;	6002	consumeStatementExpressionList() ;
5693	break;	6003	break;
5694		6004
5695	case 308 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); } //$NON-NLS-1$	6005	case 333 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); } //$NON-NLS-1$
5696	consumeSimpleAssertStatement() ;	6006	consumeSimpleAssertStatement() ;
5697	break;	6007	break;
5698		6008
5699	case 309 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); } //$NON-NLS-1$	6009	case 334 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); } //$NON-NLS-1$
5700	consumeAssertStatement() ;	6010	consumeAssertStatement() ;
5701	break;	6011	break;
5702		6012
5703	case 310 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$	6013	case 335 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$
5704	consumeStatementBreak() ;	6014	consumeStatementBreak() ;
5705	break;	6015	break;
5706		6016
5707	case 311 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$	6017	case 336 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$
5708	consumeStatementBreakWithLabel() ;	6018	consumeStatementBreakWithLabel() ;
5709	break;	6019	break;
5710		6020
5711	case 312 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$	6021	case 337 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$
5712	consumeStatementContinue() ;	6022	consumeStatementContinue() ;
5713	break;	6023	break;
5714		6024
5715	case 313 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$	6025	case 338 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$
5716	consumeStatementContinueWithLabel() ;	6026	consumeStatementContinueWithLabel() ;
5717	break;	6027	break;
5718		6028
5719	case 314 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$	6029	case 339 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$
5720	consumeStatementReturn() ;	6030	consumeStatementReturn() ;
5721	break;	6031	break;
5722		6032
5723	case 315 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$	6033	case 340 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$
5724	consumeStatementThrow();	6034	consumeStatementThrow();
5725	break;	6035	break;
5726		6036
5727	case 316 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); } //$NON-NLS-1$	6037	case 341 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); } //$NON-NLS-1$
5728	consumeStatementSynchronized();	6038	consumeStatementSynchronized();
5729	break;	6039	break;
5730		6040
5731	case 317 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); } //$NON-NLS-1$	6041	case 342 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); } //$NON-NLS-1$
5732	consumeOnlySynchronized();	6042	consumeOnlySynchronized();
5733	break;	6043	break;
5734		6044
5735	case 318 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$	6045	case 343 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$
5736	consumeStatementTry(false);	6046	consumeStatementTry(false);
5737	break;	6047	break;
5738		6048
5739	case 319 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$	6049	case 344 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$
5740	consumeStatementTry(true);	6050	consumeStatementTry(true);
5741	break;	6051	break;
5742		6052
5743	case 321 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$	6053	case 346 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$
5744	consumeExitTryBlock();	6054	consumeExitTryBlock();
5745	break;	6055	break;
5746		6056
5747	case 323 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$	6057	case 348 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$
5748	consumeCatches();	6058	consumeCatches();
5749	break;	6059	break;
5750		6060
5751	case 324 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$	6061	case 349 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
5752	consumeStatementCatch() ;	6062	consumeStatementCatch() ;
5753	break;	6063	break;
5754		6064
5755	case 326 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$	6065	case 351 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$
5756	consumeLeftParen();	6066	consumeLeftParen();
5757	break;	6067	break;
5758		6068
5759	case 327 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$	6069	case 352 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$
5760	consumeRightParen();	6070	consumeRightParen();
5761	break;	6071	break;
5762		6072
5763	case 332 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$	6073	case 357 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$
5764	consumePrimaryNoNewArrayThis();	6074	consumePrimaryNoNewArrayThis();
5765	break;	6075	break;
5766		6076
5767	case 333 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); } //$NON-NLS-1$	6077	case 358 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); } //$NON-NLS-1$
5768	consumePrimaryNoNewArray();	6078	consumePrimaryNoNewArray();
5769	break;	6079	break;
5770		6080
5771	case 334 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); } //$NON-NLS-1$	6081	case 359 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); } //$NON-NLS-1$
5772	consumePrimaryNoNewArrayWithName();	6082	consumePrimaryNoNewArrayWithName();
5773	break;	6083	break;
5774		6084
5775	case 337 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); } //$NON-NLS-1$	6085	case 362 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); } //$NON-NLS-1$
5776	consumePrimaryNoNewArrayNameThis();	6086	consumePrimaryNoNewArrayNameThis();
5777	break;	6087	break;
5778		6088
5779	case 338 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); } //$NON-NLS-1$	6089	case 363 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); } //$NON-NLS-1$
5780	consumePrimaryNoNewArrayNameSuper();	6090	consumePrimaryNoNewArrayNameSuper();
5781	break;	6091	break;
5782		6092
5783	case 339 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); } //$NON-NLS-1$	6093	case 364 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); } //$NON-NLS-1$
5784	consumePrimaryNoNewArrayName();	6094	consumePrimaryNoNewArrayName();
5785	break;	6095	break;
5786		6096
5787	case 340 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); } //$NON-NLS-1$	6097	case 365 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); } //$NON-NLS-1$
5788	consumePrimaryNoNewArrayArrayType();	6098	consumePrimaryNoNewArrayArrayType();
5789	break;	6099	break;
5790		6100
5791	case 341 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); } //$NON-NLS-1$	6101	case 366 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); } //$NON-NLS-1$
5792	consumePrimaryNoNewArrayPrimitiveArrayType();	6102	consumePrimaryNoNewArrayPrimitiveArrayType();
5793	break;	6103	break;
5794		6104
5795	case 342 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); } //$NON-NLS-1$	6105	case 367 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); } //$NON-NLS-1$
5796	consumePrimaryNoNewArrayPrimitiveType();	6106	consumePrimaryNoNewArrayPrimitiveType();
5797	break;	6107	break;
5798		6108
5799	case 345 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); } //$NON-NLS-1$	6109	case 370 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); } //$NON-NLS-1$
5800	consumeAllocationHeader();	6110	consumeAllocationHeader();
5801	break;	6111	break;
5802		6112
5803	case 346 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); } //$NON-NLS-1$	6113	case 371 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); } //$NON-NLS-1$
5804	consumeClassInstanceCreationExpressionWithTypeArguments();	6114	consumeClassInstanceCreationExpressionWithTypeArguments();
5805	break;	6115	break;
5806		6116
5807	case 347 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); } //$NON-NLS-1$	6117	case 372 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); } //$NON-NLS-1$
5808	consumeClassInstanceCreationExpression();	6118	consumeClassInstanceCreationExpression();
5809	break;	6119	break;
5810		6120
5811	case 348 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$	6121	case 373 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$
5812	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;	6122	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5813	break;	6123	break;
5814		6124
5815	case 349 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$	6125	case 374 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$
5816	consumeClassInstanceCreationExpressionQualified() ;	6126	consumeClassInstanceCreationExpressionQualified() ;
5817	break;	6127	break;
5818		6128
5819	case 350 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$	6129	case 375 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$
5820	consumeClassInstanceCreationExpressionQualified() ;	6130	consumeClassInstanceCreationExpressionQualified() ;
5821	break;	6131	break;
5822		6132
5823	case 351 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$	6133	case 376 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$
5824	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;	6134	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5825	break;	6135	break;
5826		6136
5827	case 352 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); } //$NON-NLS-1$	6137	case 377 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); } //$NON-NLS-1$
5828	consumeClassInstanceCreationExpressionName() ;	6138	consumeClassInstanceCreationExpressionName() ;
5829	break;	6139	break;
5830		6140
5831	case 353 : if (DEBUG) { System.out.println("UnqualifiedClassBodyopt ::="); } //$NON-NLS-1$	6141	case 378 : if (DEBUG) { System.out.println("UnqualifiedClassBodyopt ::="); } //$NON-NLS-1$
5832	consumeClassBodyopt();	6142	consumeClassBodyopt();
5833	break;	6143	break;
5834		6144
5835	case 355 : if (DEBUG) { System.out.println("UnqualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$	6145	case 380 : if (DEBUG) { System.out.println("UnqualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$
5836	consumeEnterAnonymousClassBody(false);	6146	consumeEnterAnonymousClassBody(false);
5837	break;	6147	break;
5838		6148
5839	case 356 : if (DEBUG) { System.out.println("QualifiedClassBodyopt ::="); } //$NON-NLS-1$	6149	case 381 : if (DEBUG) { System.out.println("QualifiedClassBodyopt ::="); } //$NON-NLS-1$
5840	consumeClassBodyopt();	6150	consumeClassBodyopt();
5841	break;	6151	break;
5842		6152
5843	case 358 : if (DEBUG) { System.out.println("QualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$	6153	case 383 : if (DEBUG) { System.out.println("QualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$
5844	consumeEnterAnonymousClassBody(true);	6154	consumeEnterAnonymousClassBody(true);
5845	break;	6155	break;
5846		6156
5847	case 360 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); } //$NON-NLS-1$	6157	case 385 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); } //$NON-NLS-1$
5848	consumeArgumentList();	6158	consumeArgumentList();
5849	break;	6159	break;
5850		6160
5851	case 361 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); } //$NON-NLS-1$	6161	case 386 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); } //$NON-NLS-1$
		6162	consumeArrayCreationHeader();
		6163	break;
		6164
		6165	case 387 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6166	consumeArrayCreationHeader();
		6167	break;
		6168
		6169	case 388 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); } //$NON-NLS-1$
5852	consumeArrayCreationHeader();	6170	consumeArrayCreationHeader();
5853	break;	6171	break;
5854		6172
5855	case 362 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); } //$NON-NLS-1$	6173	case 389 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new OneOrMoreAnnotations..."); } //$NON-NLS-1$
5856	consumeArrayCreationHeader();	6174	consumeArrayCreationHeader();
5857	break;	6175	break;
5858		6176
5859	case 363 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$	6177	case 390 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
5860	consumeArrayCreationExpressionWithoutInitializer();	6178	consumeArrayCreationExpressionWithoutInitializer(false);
		6179	break;
		6180
		6181	case 391 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
		6182	consumeArrayCreationExpressionWithoutInitializer(true);
		6183	break;
		6184
		6185	case 392 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); } //$NON-NLS-1$
		6186	consumeArrayCreationExpressionWithInitializer(false);
		6187	break;
		6188
		6189	case 393 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
		6190	consumeArrayCreationExpressionWithInitializer(true);
		6191	break;
		6192
		6193	case 394 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
		6194	consumeArrayCreationExpressionWithoutInitializer(false);
5861	break;	6195	break;
5862		6196
5863	case 364 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); } //$NON-NLS-1$	6197	case 395 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
5864	consumeArrayCreationExpressionWithInitializer();	6198	consumeArrayCreationExpressionWithoutInitializer(true);
5865	break;	6199	break;
5866		6200
5867	case 365 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$	6201	case 396 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
5868	consumeArrayCreationExpressionWithoutInitializer();	6202	consumeArrayCreationExpressionWithInitializer(false);
5869	break;	6203	break;
5870		6204
5871	case 366 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$	6205	case 397 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
5872	consumeArrayCreationExpressionWithInitializer();	6206	consumeArrayCreationExpressionWithInitializer(true);
5873	break;	6207	break;
5874		6208
5875	case 368 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); } //$NON-NLS-1$	6209	case 399 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); } //$NON-NLS-1$
5876	consumeDimWithOrWithOutExprs();	6210	consumeDimWithOrWithOutExprs();
5877	break;	6211	break;
5878		6212
5879	case 370 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET RBRACKET"); } //$NON-NLS-1$	6213	case 402 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET..."); } //$NON-NLS-1$
5880	consumeDimWithOrWithOutExpr();	6214	consumeDimWithOutExpr();
		6215	break;
		6216
		6217	case 403 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= OneOrMoreAnnotations LBRACKET"); } //$NON-NLS-1$
		6218	consumeDimWithOutExpr();
		6219	break;
		6220
		6221	case 404 : if (DEBUG) { System.out.println("DimsoptAnnotsopt ::="); } //$NON-NLS-1$
		6222	consumeEmptyDimsoptAnnotsopt();
		6223	break;
		6224
		6225	case 405 : if (DEBUG) { System.out.println("DimsoptAnnotsopt -> DimsAnnotLoop"); } //$NON-NLS-1$
		6226	consumeDimsWithTrailingAnnotsopt();
		6227	break;
		6228
		6229	case 408 : if (DEBUG) { System.out.println("OneDimOrAnnot ::= Annotation"); } //$NON-NLS-1$
		6230	consumeTypeAnnotation(true);
		6231	break;
		6232
		6233	case 409 : if (DEBUG) { System.out.println("OneDimOrAnnot ::= LBRACKET RBRACKET"); } //$NON-NLS-1$
		6234	consumeOneDimLoop(true);
		6235	break;
		6236
		6237	case 410 : if (DEBUG) { System.out.println("OneOrMoreAnnotations ::= Annotation"); } //$NON-NLS-1$
		6238	consumeTypeAnnotation(false);
5881	break;	6239	break;
5882		6240
5883	case 371 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); } //$NON-NLS-1$	6241	case 411 : if (DEBUG) { System.out.println("OneOrMoreAnnotations ::= OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6242	consumeOneMoreTypeAnnotation();
		6243	break;
		6244
		6245	case 412 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); } //$NON-NLS-1$
5884	consumeDims();	6246	consumeDims();
5885	break;	6247	break;
5886		6248
5887	case 374 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); } //$NON-NLS-1$	6249	case 415 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); } //$NON-NLS-1$
5888	consumeOneDimLoop();	6250	consumeOneDimLoop(false);
		6251	break;
		6252
		6253	case 416 : if (DEBUG) { System.out.println("OneDimLoop ::= OneOrMoreAnnotations LBRACKET RBRACKET"); } //$NON-NLS-1$
		6254	consumeOneDimLoopWithAnnotations();
5889	break;	6255	break;
5890		6256
5891	case 375 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); } //$NON-NLS-1$	6257	case 417 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); } //$NON-NLS-1$
5892	consumeFieldAccess(false);	6258	consumeFieldAccess(false);
5893	break;	6259	break;
5894		6260
5895	case 376 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); } //$NON-NLS-1$	6261	case 418 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); } //$NON-NLS-1$
5896	consumeFieldAccess(true);	6262	consumeFieldAccess(true);
5897	break;	6263	break;
5898		6264
5899	case 377 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$	6265	case 419 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
5900	consumeMethodInvocationName();	6266	consumeMethodInvocationName();
5901	break;	6267	break;
5902		6268
5903	case 378 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6269	case 420 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5904	consumeMethodInvocationNameWithTypeArguments();	6270	consumeMethodInvocationNameWithTypeArguments();
5905	break;	6271	break;
5906		6272
5907	case 379 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6273	case 421 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5908	consumeMethodInvocationPrimaryWithTypeArguments();	6274	consumeMethodInvocationPrimaryWithTypeArguments();
5909	break;	6275	break;
5910		6276
5911	case 380 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); } //$NON-NLS-1$	6277	case 422 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); } //$NON-NLS-1$
5912	consumeMethodInvocationPrimary();	6278	consumeMethodInvocationPrimary();
5913	break;	6279	break;
5914		6280
5915	case 381 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6281	case 423 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5916	consumeMethodInvocationSuperWithTypeArguments();	6282	consumeMethodInvocationSuperWithTypeArguments();
5917	break;	6283	break;
5918		6284
5919	case 382 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); } //$NON-NLS-1$	6285	case 424 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); } //$NON-NLS-1$
5920	consumeMethodInvocationSuper();	6286	consumeMethodInvocationSuper();
5921	break;	6287	break;
5922		6288
5923	case 383 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); } //$NON-NLS-1$	6289	case 425 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); } //$NON-NLS-1$
5924	consumeArrayAccess(true);	6290	consumeArrayAccess(true);
5925	break;	6291	break;
5926		6292
5927	case 384 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); } //$NON-NLS-1$	6293	case 426 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); } //$NON-NLS-1$
5928	consumeArrayAccess(false);	6294	consumeArrayAccess(false);
5929	break;	6295	break;
5930		6296
5931	case 385 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); } //$NON-NLS-1$	6297	case 427 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); } //$NON-NLS-1$
5932	consumeArrayAccess(false);	6298	consumeArrayAccess(false);
5933	break;	6299	break;
5934		6300
5935	case 387 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); } //$NON-NLS-1$	6301	case 429 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); } //$NON-NLS-1$
5936	consumePostfixExpression();	6302	consumePostfixExpression();
5937	break;	6303	break;
5938		6304
5939	case 390 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); } //$NON-NLS-1$	6305	case 432 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); } //$NON-NLS-1$
5940	consumeUnaryExpression(OperatorIds.PLUS,true);	6306	consumeUnaryExpression(OperatorIds.PLUS,true);
5941	break;	6307	break;
5942		6308
5943	case 391 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); } //$NON-NLS-1$	6309	case 433 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); } //$NON-NLS-1$
5944	consumeUnaryExpression(OperatorIds.MINUS,true);	6310	consumeUnaryExpression(OperatorIds.MINUS,true);
5945	break;	6311	break;
5946		6312
5947	case 392 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$	6313	case 434 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$
5948	consumePushPosition();	6314	consumePushPosition();
5949	break;	6315	break;
5950		6316
5951	case 395 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$	6317	case 437 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$
5952	consumeUnaryExpression(OperatorIds.PLUS);	6318	consumeUnaryExpression(OperatorIds.PLUS);
5953	break;	6319	break;
5954		6320
5955	case 396 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$	6321	case 438 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$
5956	consumeUnaryExpression(OperatorIds.MINUS);	6322	consumeUnaryExpression(OperatorIds.MINUS);
5957	break;	6323	break;
5958		6324
5959	case 398 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$	6325	case 440 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$
5960	consumeUnaryExpression(OperatorIds.PLUS,false);	6326	consumeUnaryExpression(OperatorIds.PLUS,false);
5961	break;	6327	break;
5962		6328
5963	case 399 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$	6329	case 441 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$
5964	consumeUnaryExpression(OperatorIds.MINUS,false);	6330	consumeUnaryExpression(OperatorIds.MINUS,false);
5965	break;	6331	break;
5966		6332
5967	case 401 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$	6333	case 443 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$
5968	consumeUnaryExpression(OperatorIds.TWIDDLE);	6334	consumeUnaryExpression(OperatorIds.TWIDDLE);
5969	break;	6335	break;
5970		6336
5971	case 402 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$	6337	case 444 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$
5972	consumeUnaryExpression(OperatorIds.NOT);	6338	consumeUnaryExpression(OperatorIds.NOT);
5973	break;	6339	break;
5974		6340
5975	case 404 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); } //$NON-NLS-1$	6341	case 446 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); } //$NON-NLS-1$
5976	consumeCastExpressionWithPrimitiveType();	6342	consumeCastExpressionWithPrimitiveType(false);
		6343	break;
		6344
		6345	case 447 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6346	consumeCastExpressionWithPrimitiveType(true);
		6347	break;
		6348
		6349	case 448 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$
		6350	consumeCastExpressionWithGenericsArray(false);
5977	break;	6351	break;
5978		6352
5979	case 405 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$	6353	case 449 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
5980	consumeCastExpressionWithGenericsArray();	6354	consumeCastExpressionWithGenericsArray(true);
5981	break;	6355	break;
5982		6356
5983	case 406 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$	6357	case 450 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$
5984	consumeCastExpressionWithQualifiedGenericsArray();	6358	consumeCastExpressionWithQualifiedGenericsArray(false);
5985	break;	6359	break;
5986		6360
5987	case 407 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); } //$NON-NLS-1$	6361	case 451 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
5988	consumeCastExpressionLL1();	6362	consumeCastExpressionWithQualifiedGenericsArray(true);
5989	break;	6363	break;
5990		6364
5991	case 408 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); } //$NON-NLS-1$	6365	case 452 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); } //$NON-NLS-1$
5992	consumeCastExpressionWithNameArray();	6366	consumeCastExpressionLL1(false);
5993	break;	6367	break;
5994		6368
5995	case 409 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); } //$NON-NLS-1$	6369	case 453 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
		6370	consumeCastExpressionLL1(true);
		6371	break;
		6372
		6373	case 454 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); } //$NON-NLS-1$
		6374	consumeCastExpressionWithNameArray(false);
		6375	break;
		6376
		6377	case 455 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); } //$NON-NLS-1$
		6378	consumeCastExpressionWithNameArray(true);
		6379	break;
		6380
		6381	case 456 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); } //$NON-NLS-1$
5996	consumeOnlyTypeArgumentsForCastExpression();	6382	consumeOnlyTypeArgumentsForCastExpression();
5997	break;	6383	break;
5998		6384
5999	case 410 : if (DEBUG) { System.out.println("InsideCastExpression ::="); } //$NON-NLS-1$	6385	case 457 : if (DEBUG) { System.out.println("InsideCastExpression ::="); } //$NON-NLS-1$
6000	consumeInsideCastExpression();	6386	consumeInsideCastExpression();
6001	break;	6387	break;
6002		6388
6003	case 411 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); } //$NON-NLS-1$	6389	case 458 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); } //$NON-NLS-1$
6004	consumeInsideCastExpressionLL1();	6390	consumeInsideCastExpressionLL1();
6005	break;	6391	break;
6006		6392
6007	case 412 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); } //$NON-NLS-1$	6393	case 459 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); } //$NON-NLS-1$
6008	consumeInsideCastExpressionWithQualifiedGenerics();	6394	consumeInsideCastExpressionWithQualifiedGenerics();
6009	break;	6395	break;
6010		6396
6011	case 414 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6397	case 461 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6012	consumeBinaryExpression(OperatorIds.MULTIPLY);	6398	consumeBinaryExpression(OperatorIds.MULTIPLY);
6013	break;	6399	break;
6014		6400
6015	case 415 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6401	case 462 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6016	consumeBinaryExpression(OperatorIds.DIVIDE);	6402	consumeBinaryExpression(OperatorIds.DIVIDE);
6017	break;	6403	break;
6018		6404
6019	case 416 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6405	case 463 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6020	consumeBinaryExpression(OperatorIds.REMAINDER);	6406	consumeBinaryExpression(OperatorIds.REMAINDER);
6021	break;	6407	break;
6022		6408
6023	case 418 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$	6409	case 465 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$
6024	consumeBinaryExpression(OperatorIds.PLUS);	6410	consumeBinaryExpression(OperatorIds.PLUS);
6025	break;	6411	break;
6026		6412
6027	case 419 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$	6413	case 466 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$
6028	consumeBinaryExpression(OperatorIds.MINUS);	6414	consumeBinaryExpression(OperatorIds.MINUS);
6029	break;	6415	break;
6030		6416
6031	case 421 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$	6417	case 468 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$
6032	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);	6418	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
6033	break;	6419	break;
6034		6420
6035	case 422 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$	6421	case 469 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$
6036	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);	6422	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
6037	break;	6423	break;
6038		6424
6039	case 423 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6425	case 470 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6040	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);	6426	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6041	break;	6427	break;
6042		6428
6043	case 425 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$	6429	case 472 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$
6044	consumeBinaryExpression(OperatorIds.LESS);	6430	consumeBinaryExpression(OperatorIds.LESS);
6045	break;	6431	break;
6046		6432
6047	case 426 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$	6433	case 473 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$
6048	consumeBinaryExpression(OperatorIds.GREATER);	6434	consumeBinaryExpression(OperatorIds.GREATER);
6049	break;	6435	break;
6050		6436
6051	case 427 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$	6437	case 474 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$
6052	consumeBinaryExpression(OperatorIds.LESS_EQUAL);	6438	consumeBinaryExpression(OperatorIds.LESS_EQUAL);
6053	break;	6439	break;
6054		6440
6055	case 428 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$	6441	case 475 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$
6056	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);	6442	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
6057	break;	6443	break;
6058		6444
6059	case 430 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$	6445	case 477 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$
6060	consumeInstanceOfExpression();	6446	consumeInstanceOfExpression();
6061	break;	6447	break;
6062		6448
6063	case 432 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$	6449	case 478 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$
		6450	consumeInstanceOfExpression();
		6451	break;
		6452
		6453	case 480 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$
6064	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);	6454	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
6065	break;	6455	break;
6066		6456
6067	case 433 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$	6457	case 481 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$
6068	consumeEqualityExpression(OperatorIds.NOT_EQUAL);	6458	consumeEqualityExpression(OperatorIds.NOT_EQUAL);
6069	break;	6459	break;
6070		6460
6071	case 435 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$	6461	case 483 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$
6072	consumeBinaryExpression(OperatorIds.AND);	6462	consumeBinaryExpression(OperatorIds.AND);
6073	break;	6463	break;
6074		6464
6075	case 437 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$	6465	case 485 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$
6076	consumeBinaryExpression(OperatorIds.XOR);	6466	consumeBinaryExpression(OperatorIds.XOR);
6077	break;	6467	break;
6078		6468
6079	case 439 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$	6469	case 487 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$
6080	consumeBinaryExpression(OperatorIds.OR);	6470	consumeBinaryExpression(OperatorIds.OR);
6081	break;	6471	break;
6082		6472
6083	case 441 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$	6473	case 489 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$
6084	consumeBinaryExpression(OperatorIds.AND_AND);	6474	consumeBinaryExpression(OperatorIds.AND_AND);
6085	break;	6475	break;
6086		6476
6087	case 443 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$	6477	case 491 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
6088	consumeBinaryExpression(OperatorIds.OR_OR);	6478	consumeBinaryExpression(OperatorIds.OR_OR);
6089	break;	6479	break;
6090		6480
6091	case 445 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$	6481	case 493 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
6092	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;	6482	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
6093	break;	6483	break;
6094		6484
6095	case 448 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$	6485	case 496 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$
6096	consumeAssignment();	6486	consumeAssignment();
6097	break;	6487	break;
6098		6488
6099	case 450 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); } //$NON-NLS-1$	6489	case 498 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); } //$NON-NLS-1$
6100	ignoreExpressionAssignment();	6490	ignoreExpressionAssignment();
6101	break;	6491	break;
6102		6492
6103	case 451 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$	6493	case 499 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$
6104	consumeAssignmentOperator(EQUAL);	6494	consumeAssignmentOperator(EQUAL);
6105	break;	6495	break;
6106		6496
6107	case 452 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$	6497	case 500 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$
6108	consumeAssignmentOperator(MULTIPLY);	6498	consumeAssignmentOperator(MULTIPLY);
6109	break;	6499	break;
6110		6500
6111	case 453 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$	6501	case 501 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$
6112	consumeAssignmentOperator(DIVIDE);	6502	consumeAssignmentOperator(DIVIDE);
6113	break;	6503	break;
6114		6504
6115	case 454 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$	6505	case 502 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$
6116	consumeAssignmentOperator(REMAINDER);	6506	consumeAssignmentOperator(REMAINDER);
6117	break;	6507	break;
6118		6508
6119	case 455 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$	6509	case 503 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$
6120	consumeAssignmentOperator(PLUS);	6510	consumeAssignmentOperator(PLUS);
6121	break;	6511	break;
6122		6512
6123	case 456 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$	6513	case 504 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$
6124	consumeAssignmentOperator(MINUS);	6514	consumeAssignmentOperator(MINUS);
6125	break;	6515	break;
6126		6516
6127	case 457 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$	6517	case 505 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$
6128	consumeAssignmentOperator(LEFT_SHIFT);	6518	consumeAssignmentOperator(LEFT_SHIFT);
6129	break;	6519	break;
6130		6520
6131	case 458 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$	6521	case 506 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
6132	consumeAssignmentOperator(RIGHT_SHIFT);	6522	consumeAssignmentOperator(RIGHT_SHIFT);
6133	break;	6523	break;
6134		6524
6135	case 459 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$	6525	case 507 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
6136	consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);	6526	consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);
6137	break;	6527	break;
6138		6528
6139	case 460 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$	6529	case 508 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$
6140	consumeAssignmentOperator(AND);	6530	consumeAssignmentOperator(AND);
6141	break;	6531	break;
6142		6532
6143	case 461 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$	6533	case 509 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$
6144	consumeAssignmentOperator(XOR);	6534	consumeAssignmentOperator(XOR);
6145	break;	6535	break;
6146		6536
6147	case 462 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$	6537	case 510 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$
6148	consumeAssignmentOperator(OR);	6538	consumeAssignmentOperator(OR);
6149	break;	6539	break;
6150		6540
6151	case 466 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$	6541	case 514 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$
6152	consumeEmptyExpression();	6542	consumeEmptyExpression();
6153	break;	6543	break;
6154		6544
6155	case 471 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); } //$NON-NLS-1$	6545	case 519 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); } //$NON-NLS-1$
6156	consumeEmptyClassBodyDeclarationsopt();	6546	consumeEmptyClassBodyDeclarationsopt();
6157	break;	6547	break;
6158		6548
6159	case 472 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	6549	case 520 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6160	consumeClassBodyDeclarationsopt();	6550	consumeClassBodyDeclarationsopt();
6161	break;	6551	break;
6162		6552
6163	case 473 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$	6553	case 521 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::="); } //$NON-NLS-1$
		6554	consumeDefaultModifiers();
		6555	break;
		6556
		6557	case 522 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::= NonAnnotModifiers"); } //$NON-NLS-1$
		6558	consumeModifiers();
		6559	break;
		6560
		6561	case 523 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$
6164	consumeDefaultModifiers();	6562	consumeDefaultModifiers();
6165	break;	6563	break;
6166		6564
6167	case 474 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); } //$NON-NLS-1$	6565	case 524 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); } //$NON-NLS-1$
6168	consumeModifiers();	6566	consumeModifiers();
6169	break;	6567	break;
6170		6568
6171	case 475 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$	6569	case 525 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$
6172	consumeEmptyBlockStatementsopt();	6570	consumeEmptyBlockStatementsopt();
6173	break;	6571	break;
6174		6572
6175	case 477 : if (DEBUG) { System.out.println("Dimsopt ::="); } //$NON-NLS-1$	6573	case 527 : if (DEBUG) { System.out.println("Dimsopt ::="); } //$NON-NLS-1$
6176	consumeEmptyDimsopt();	6574	consumeEmptyDimsopt();
6177	break;	6575	break;
6178		6576
6179	case 479 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$	6577	case 529 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$
6180	consumeEmptyArgumentListopt();	6578	consumeEmptyArgumentListopt();
6181	break;	6579	break;
6182		6580
6183	case 483 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$	6581	case 533 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$
6184	consumeFormalParameterListopt();	6582	consumeFormalParameterListopt();
6185	break;	6583	break;
6186		6584
6187	case 487 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); } //$NON-NLS-1$	6585	case 537 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); } //$NON-NLS-1$
6188	consumeEmptyInterfaceMemberDeclarationsopt();	6586	consumeEmptyInterfaceMemberDeclarationsopt();
6189	break;	6587	break;
6190		6588
6191	case 488 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	6589	case 538 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6192	consumeInterfaceMemberDeclarationsopt();	6590	consumeInterfaceMemberDeclarationsopt();
6193	break;	6591	break;
6194		6592
6195	case 489 : if (DEBUG) { System.out.println("NestedType ::="); } //$NON-NLS-1$	6593	case 539 : if (DEBUG) { System.out.println("NestedType ::="); } //$NON-NLS-1$
6196	consumeNestedType();	6594	consumeNestedType();
6197	break;	6595	break;
6198		6596
6199	case 490 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$	6597	case 540 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$
6200	consumeEmptyForInitopt();	6598	consumeEmptyForInitopt();
6201	break;	6599	break;
6202		6600
6203	case 492 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$	6601	case 542 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$
6204	consumeEmptyForUpdateopt();	6602	consumeEmptyForUpdateopt();
6205	break;	6603	break;
6206		6604
6207	case 496 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$	6605	case 546 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$
6208	consumeEmptyCatchesopt();	6606	consumeEmptyCatchesopt();
6209	break;	6607	break;
6210		6608
6211	case 498 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); } //$NON-NLS-1$	6609	case 548 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); } //$NON-NLS-1$
6212	consumeEnumDeclaration();	6610	consumeEnumDeclaration();
6213	break;	6611	break;
6214		6612
6215	case 499 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); } //$NON-NLS-1$	6613	case 549 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); } //$NON-NLS-1$
6216	consumeEnumHeader();	6614	consumeEnumHeader();
6217	break;	6615	break;
6218		6616
6219	case 500 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); } //$NON-NLS-1$	6617	case 550 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); } //$NON-NLS-1$
6220	consumeEnumHeaderName();	6618	consumeEnumHeaderName();
6221	break;	6619	break;
6222		6620
6223	case 501 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); } //$NON-NLS-1$	6621	case 551 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); } //$NON-NLS-1$
6224	consumeEnumHeaderNameWithTypeParameters();	6622	consumeEnumHeaderNameWithTypeParameters();
6225	break;	6623	break;
6226		6624
6227	case 502 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); } //$NON-NLS-1$	6625	case 552 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); } //$NON-NLS-1$
6228	consumeEnumBodyNoConstants();	6626	consumeEnumBodyNoConstants();
6229	break;	6627	break;
6230		6628
6231	case 503 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); } //$NON-NLS-1$	6629	case 553 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); } //$NON-NLS-1$
6232	consumeEnumBodyNoConstants();	6630	consumeEnumBodyNoConstants();
6233	break;	6631	break;
6234		6632
6235	case 504 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); } //$NON-NLS-1$	6633	case 554 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); } //$NON-NLS-1$
6236	consumeEnumBodyWithConstants();	6634	consumeEnumBodyWithConstants();
6237	break;	6635	break;
6238		6636
6239	case 505 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); } //$NON-NLS-1$	6637	case 555 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); } //$NON-NLS-1$
6240	consumeEnumBodyWithConstants();	6638	consumeEnumBodyWithConstants();
6241	break;	6639	break;
6242		6640
6243	case 507 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); } //$NON-NLS-1$	6641	case 557 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); } //$NON-NLS-1$
6244	consumeEnumConstants();	6642	consumeEnumConstants();
6245	break;	6643	break;
6246		6644
6247	case 508 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); } //$NON-NLS-1$	6645	case 558 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); } //$NON-NLS-1$
6248	consumeEnumConstantHeaderName();	6646	consumeEnumConstantHeaderName();
6249	break;	6647	break;
6250		6648
6251	case 509 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); } //$NON-NLS-1$	6649	case 559 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); } //$NON-NLS-1$
6252	consumeEnumConstantHeader();	6650	consumeEnumConstantHeader();
6253	break;	6651	break;
6254		6652
6255	case 510 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); } //$NON-NLS-1$	6653	case 560 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); } //$NON-NLS-1$
6256	consumeEnumConstantWithClassBody();	6654	consumeEnumConstantWithClassBody();
6257	break;	6655	break;
6258		6656
6259	case 511 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); } //$NON-NLS-1$	6657	case 561 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); } //$NON-NLS-1$
6260	consumeEnumConstantNoClassBody();	6658	consumeEnumConstantNoClassBody();
6261	break;	6659	break;
6262		6660
6263	case 512 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$	6661	case 562 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
6264	consumeArguments();	6662	consumeArguments();
6265	break;	6663	break;
6266		6664
6267	case 513 : if (DEBUG) { System.out.println("Argumentsopt ::="); } //$NON-NLS-1$	6665	case 563 : if (DEBUG) { System.out.println("Argumentsopt ::="); } //$NON-NLS-1$
6268	consumeEmptyArguments();	6666	consumeEmptyArguments();
6269	break;	6667	break;
6270		6668
6271	case 515 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); } //$NON-NLS-1$	6669	case 565 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); } //$NON-NLS-1$
6272	consumeEnumDeclarations();	6670	consumeEnumDeclarations();
6273	break;	6671	break;
6274		6672
6275	case 516 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); } //$NON-NLS-1$	6673	case 566 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); } //$NON-NLS-1$
6276	consumeEmptyEnumDeclarations();	6674	consumeEmptyEnumDeclarations();
6277	break;	6675	break;
6278		6676
6279	case 518 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); } //$NON-NLS-1$	6677	case 568 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); } //$NON-NLS-1$
6280	consumeEnhancedForStatement();	6678	consumeEnhancedForStatement();
6281	break;	6679	break;
6282		6680
6283	case 519 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); } //$NON-NLS-1$	6681	case 569 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); } //$NON-NLS-1$
6284	consumeEnhancedForStatement();	6682	consumeEnhancedForStatement();
6285	break;	6683	break;
6286		6684
6287	case 520 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); } //$NON-NLS-1$	6685	case 570 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); } //$NON-NLS-1$
6288	consumeEnhancedForStatementHeaderInit(false);	6686	consumeEnhancedForStatementHeaderInit(false);
6289	break;	6687	break;
6290		6688
6291	case 521 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } //$NON-NLS-1$	6689	case 571 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } //$NON-NLS-1$
6292	consumeEnhancedForStatementHeaderInit(true);	6690	consumeEnhancedForStatementHeaderInit(true);
6293	break;	6691	break;
6294		6692
6295	case 522 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } //$NON-NLS-1$	6693	case 572 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } //$NON-NLS-1$
6296	consumeEnhancedForStatementHeader();	6694	consumeEnhancedForStatementHeader();
6297	break;	6695	break;
6298		6696
6299	case 523 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } //$NON-NLS-1$	6697	case 573 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } //$NON-NLS-1$
6300	consumeImportDeclaration();	6698	consumeImportDeclaration();
6301	break;	6699	break;
6302		6700
6303	case 524 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } //$NON-NLS-1$	6701	case 574 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } //$NON-NLS-1$
6304	consumeSingleStaticImportDeclarationName();	6702	consumeSingleStaticImportDeclarationName();
6305	break;	6703	break;
6306		6704
6307	case 525 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$	6705	case 575 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$
6308	consumeImportDeclaration();	6706	consumeImportDeclaration();
6309	break;	6707	break;
6310		6708
6311	case 526 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } //$NON-NLS-1$	6709	case 576 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } //$NON-NLS-1$
6312	consumeStaticImportOnDemandDeclarationName();	6710	consumeStaticImportOnDemandDeclarationName();
6313	break;	6711	break;
6314		6712
6315	case 527 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$	6713	case 577 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$
6316	consumeTypeArguments();	6714	consumeTypeArguments();
6317	break;	6715	break;
6318		6716
6319	case 528 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$	6717	case 578 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$
6320	consumeOnlyTypeArguments();	6718	consumeOnlyTypeArguments();
6321	break;	6719	break;
6322		6720
6323	case 530 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6721	case 580 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6324	consumeTypeArgumentList1();	6722	consumeTypeArgumentList1();
6325	break;	6723	break;
6326		6724
6327	case 532 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } //$NON-NLS-1$	6725	case 582 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } //$NON-NLS-1$
6328	consumeTypeArgumentList();	6726	consumeTypeArgumentList();
6329	break;	6727	break;
6330		6728
6331	case 533 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } //$NON-NLS-1$	6729	case 583 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } //$NON-NLS-1$
6332	consumeTypeArgument();	6730	consumeTypeArgument(false);
6333	break;	6731	break;
6334		6732
6335	case 537 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } //$NON-NLS-1$	6733	case 584 : if (DEBUG) { System.out.println("TypeArgument ::= OneOrMoreAnnotations ReferenceType"); } //$NON-NLS-1$
6336	consumeReferenceType1();	6734	consumeTypeArgument(true);
6337	break;	6735	break;
6338		6736
6339	case 538 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$	6737	case 588 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } //$NON-NLS-1$
6340	consumeTypeArgumentReferenceType1();	6738	consumeReferenceType1(false);
6341	break;	6739	break;
6342		6740
6343	case 540 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6741	case 589 : if (DEBUG) { System.out.println("ReferenceType1 ::= OneOrMoreAnnotations ReferenceType..."); } //$NON-NLS-1$
		6742	consumeReferenceType1(true);
		6743	break;
		6744
		6745	case 590 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$
		6746	consumeTypeArgumentReferenceType1(false);
		6747	break;
		6748
		6749	case 591 : if (DEBUG) { System.out.println("ReferenceType1 ::= OneOrMoreAnnotations ClassOrInterface"); } //$NON-NLS-1$
		6750	consumeTypeArgumentReferenceType1(true);
		6751	break;
		6752
		6753	case 593 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6344	consumeTypeArgumentList2();	6754	consumeTypeArgumentList2();
6345	break;	6755	break;
6346		6756
6347	case 543 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } //$NON-NLS-1$	6757	case 596 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } //$NON-NLS-1$
6348	consumeReferenceType2();	6758	consumeReferenceType2(false);
6349	break;	6759	break;
6350		6760
6351	case 544 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$	6761	case 597 : if (DEBUG) { System.out.println("ReferenceType2 ::= OneOrMoreAnnotations ReferenceType..."); } //$NON-NLS-1$
6352	consumeTypeArgumentReferenceType2();	6762	consumeReferenceType2(true);
6353	break;	6763	break;
6354		6764
6355	case 546 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6765	case 598 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$
		6766	consumeTypeArgumentReferenceType2(false);
		6767	break;
		6768
		6769	case 599 : if (DEBUG) { System.out.println("ReferenceType2 ::= OneOrMoreAnnotations ClassOrInterface"); } //$NON-NLS-1$
		6770	consumeTypeArgumentReferenceType2(true);
		6771	break;
		6772
		6773	case 601 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6356	consumeTypeArgumentList3();	6774	consumeTypeArgumentList3();
6357	break;	6775	break;
6358		6776
6359	case 549 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6777	case 604 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6360	consumeReferenceType3();	6778	consumeReferenceType3(false);
6361	break;	6779	break;
6362		6780
6363	case 550 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } //$NON-NLS-1$	6781	case 605 : if (DEBUG) { System.out.println("ReferenceType3 ::= OneOrMoreAnnotations ReferenceType..."); } //$NON-NLS-1$
		6782	consumeReferenceType3(true);
		6783	break;
		6784
		6785	case 606 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } //$NON-NLS-1$
6364	consumeWildcard();	6786	consumeWildcard();
6365	break;	6787	break;
6366		6788
6367	case 551 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } //$NON-NLS-1$	6789	case 607 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } //$NON-NLS-1$
6368	consumeWildcardWithBounds();	6790	consumeWildcardWithBounds();
6369	break;	6791	break;
6370		6792
6371	case 552 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } //$NON-NLS-1$	6793	case 608 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } //$NON-NLS-1$
6372	consumeWildcardBoundsExtends();	6794	consumeWildcardBoundsExtends(false);
		6795	break;
		6796
		6797	case 609 : if (DEBUG) { System.out.println("WildcardBounds ::= extends OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6798	consumeWildcardBoundsExtends(true);
6373	break;	6799	break;
6374		6800
6375	case 553 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } //$NON-NLS-1$	6801	case 610 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } //$NON-NLS-1$
6376	consumeWildcardBoundsSuper();	6802	consumeWildcardBoundsSuper(false);
6377	break;	6803	break;
6378		6804
6379	case 554 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } //$NON-NLS-1$	6805	case 611 : if (DEBUG) { System.out.println("WildcardBounds ::= super OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6806	consumeWildcardBoundsSuper(true);
		6807	break;
		6808
		6809	case 612 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } //$NON-NLS-1$
6380	consumeWildcard1();	6810	consumeWildcard1();
6381	break;	6811	break;
6382		6812
6383	case 555 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } //$NON-NLS-1$	6813	case 613 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } //$NON-NLS-1$
6384	consumeWildcard1WithBounds();	6814	consumeWildcard1WithBounds();
6385	break;	6815	break;
6386		6816
6387	case 556 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } //$NON-NLS-1$	6817	case 614 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } //$NON-NLS-1$
6388	consumeWildcardBounds1Extends();	6818	consumeWildcardBounds1Extends();
6389	break;	6819	break;
6390		6820
6391	case 557 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } //$NON-NLS-1$	6821	case 615 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } //$NON-NLS-1$
6392	consumeWildcardBounds1Super();	6822	consumeWildcardBounds1Super();
6393	break;	6823	break;
6394		6824
6395	case 558 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } //$NON-NLS-1$	6825	case 616 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } //$NON-NLS-1$
6396	consumeWildcard2();	6826	consumeWildcard2();
6397	break;	6827	break;
6398		6828
6399	case 559 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } //$NON-NLS-1$	6829	case 617 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } //$NON-NLS-1$
6400	consumeWildcard2WithBounds();	6830	consumeWildcard2WithBounds();
6401	break;	6831	break;
6402		6832
6403	case 560 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } //$NON-NLS-1$	6833	case 618 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } //$NON-NLS-1$
6404	consumeWildcardBounds2Extends();	6834	consumeWildcardBounds2Extends();
6405	break;	6835	break;
6406		6836
6407	case 561 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } //$NON-NLS-1$	6837	case 619 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } //$NON-NLS-1$
6408	consumeWildcardBounds2Super();	6838	consumeWildcardBounds2Super();
6409	break;	6839	break;
6410		6840
6411	case 562 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6841	case 620 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6412	consumeWildcard3();	6842	consumeWildcard3();
6413	break;	6843	break;
6414		6844
6415	case 563 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } //$NON-NLS-1$	6845	case 621 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } //$NON-NLS-1$
6416	consumeWildcard3WithBounds();	6846	consumeWildcard3WithBounds();
6417	break;	6847	break;
6418		6848
6419	case 564 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } //$NON-NLS-1$	6849	case 622 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } //$NON-NLS-1$
6420	consumeWildcardBounds3Extends();	6850	consumeWildcardBounds3Extends();
6421	break;	6851	break;
6422		6852
6423	case 565 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } //$NON-NLS-1$	6853	case 623 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } //$NON-NLS-1$
6424	consumeWildcardBounds3Super();	6854	consumeWildcardBounds3Super();
6425	break;	6855	break;
6426		6856
6427	case 566 : if (DEBUG) { System.out.println("TypeParameterHeader ::= Identifier"); } //$NON-NLS-1$	6857	case 624 : if (DEBUG) { System.out.println("PushZeroTypeAnnotations ::="); } //$NON-NLS-1$
		6858	consumeZeroTypeAnnotations();
		6859	break;
		6860
		6861	case 625 : if (DEBUG) { System.out.println("TypeParameterHeader ::= PushZeroTypeAnnotations..."); } //$NON-NLS-1$
		6862	consumeTypeParameterHeader();
		6863	break;
		6864
		6865	case 626 : if (DEBUG) { System.out.println("TypeParameterHeader ::= OneOrMoreAnnotations Identifier"); } //$NON-NLS-1$
6428	consumeTypeParameterHeader();	6866	consumeTypeParameterHeader();
6429	break;	6867	break;
6430		6868
6431	case 567 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } //$NON-NLS-1$	6869	case 627 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } //$NON-NLS-1$
6432	consumeTypeParameters();	6870	consumeTypeParameters();
6433	break;	6871	break;
6434		6872
6435	case 569 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } //$NON-NLS-1$	6873	case 629 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } //$NON-NLS-1$
6436	consumeTypeParameterList();	6874	consumeTypeParameterList();
6437	break;	6875	break;
6438		6876
6439	case 571 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6877	case 631 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6440	consumeTypeParameterWithExtends();	6878	consumeTypeParameterWithExtends(false);
6441	break;	6879	break;
6442		6880
6443	case 572 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6881	case 632 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6444	consumeTypeParameterWithExtendsAndBounds();	6882	consumeTypeParameterWithExtends(true);
6445	break;	6883	break;
6446		6884
6447	case 574 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } //$NON-NLS-1$	6885	case 633 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
		6886	consumeTypeParameterWithExtendsAndBounds(false);
		6887	break;
		6888
		6889	case 634 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
		6890	consumeTypeParameterWithExtendsAndBounds(true);
		6891	break;
		6892
		6893	case 636 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } //$NON-NLS-1$
6448	consumeAdditionalBoundList();	6894	consumeAdditionalBoundList();
6449	break;	6895	break;
6450		6896
6451	case 575 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } //$NON-NLS-1$	6897	case 637 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } //$NON-NLS-1$
6452	consumeAdditionalBound();	6898	consumeAdditionalBound(false);
6453	break;	6899	break;
6454		6900
6455	case 577 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } //$NON-NLS-1$	6901	case 638 : if (DEBUG) { System.out.println("AdditionalBound ::= AND OneOrMoreAnnotations..."); } //$NON-NLS-1$
		6902	consumeAdditionalBound(true);
		6903	break;
		6904
		6905	case 640 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } //$NON-NLS-1$
6456	consumeTypeParameterList1();	6906	consumeTypeParameterList1();
6457	break;	6907	break;
6458		6908
6459	case 578 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } //$NON-NLS-1$	6909	case 641 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } //$NON-NLS-1$
6460	consumeTypeParameter1();	6910	consumeTypeParameter1();
6461	break;	6911	break;
6462		6912
6463	case 579 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6913	case 642 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6464	consumeTypeParameter1WithExtends();	6914	consumeTypeParameter1WithExtends();
6465	break;	6915	break;
6466		6916
6467	case 580 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6917	case 643 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6468	consumeTypeParameter1WithExtendsAndBounds();	6918	consumeTypeParameter1WithExtendsAndBounds(false);
		6919	break;
		6920
		6921	case 644 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
		6922	consumeTypeParameter1WithExtendsAndBounds(true);
6469	break;	6923	break;
6470		6924
6471	case 582 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } //$NON-NLS-1$	6925	case 646 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } //$NON-NLS-1$
6472	consumeAdditionalBoundList1();	6926	consumeAdditionalBoundList1();
6473	break;	6927	break;
6474		6928
6475	case 583 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } //$NON-NLS-1$	6929	case 647 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } //$NON-NLS-1$
6476	consumeAdditionalBound1();	6930	consumeAdditionalBound1();
6477	break;	6931	break;
6478		6932
6479	case 589 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } //$NON-NLS-1$	6933	case 653 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } //$NON-NLS-1$
6480	consumeUnaryExpression(OperatorIds.PLUS);	6934	consumeUnaryExpression(OperatorIds.PLUS);
6481	break;	6935	break;
6482		6936
6483	case 590 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } //$NON-NLS-1$	6937	case 654 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } //$NON-NLS-1$
6484	consumeUnaryExpression(OperatorIds.MINUS);	6938	consumeUnaryExpression(OperatorIds.MINUS);
6485	break;	6939	break;
6486		6940
6487	case 593 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } //$NON-NLS-1$	6941	case 657 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } //$NON-NLS-1$
6488	consumeUnaryExpression(OperatorIds.TWIDDLE);	6942	consumeUnaryExpression(OperatorIds.TWIDDLE);
6489	break;	6943	break;
6490		6944
6491	case 594 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } //$NON-NLS-1$	6945	case 658 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } //$NON-NLS-1$
6492	consumeUnaryExpression(OperatorIds.NOT);	6946	consumeUnaryExpression(OperatorIds.NOT);
6493	break;	6947	break;
6494		6948
6495	case 597 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6949	case 661 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6496	consumeBinaryExpression(OperatorIds.MULTIPLY);	6950	consumeBinaryExpression(OperatorIds.MULTIPLY);
6497	break;	6951	break;
6498		6952
6499	case 598 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } //$NON-NLS-1$	6953	case 662 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } //$NON-NLS-1$
6500	consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);	6954	consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);
6501	break;	6955	break;
6502		6956
6503	case 599 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6957	case 663 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6504	consumeBinaryExpression(OperatorIds.DIVIDE);	6958	consumeBinaryExpression(OperatorIds.DIVIDE);
6505	break;	6959	break;
6506		6960
6507	case 600 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } //$NON-NLS-1$	6961	case 664 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } //$NON-NLS-1$
6508	consumeBinaryExpressionWithName(OperatorIds.DIVIDE);	6962	consumeBinaryExpressionWithName(OperatorIds.DIVIDE);
6509	break;	6963	break;
6510		6964
6511	case 601 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6965	case 665 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6512	consumeBinaryExpression(OperatorIds.REMAINDER);	6966	consumeBinaryExpression(OperatorIds.REMAINDER);
6513	break;	6967	break;
6514		6968
6515	case 602 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } //$NON-NLS-1$	6969	case 666 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } //$NON-NLS-1$
6516	consumeBinaryExpressionWithName(OperatorIds.REMAINDER);	6970	consumeBinaryExpressionWithName(OperatorIds.REMAINDER);
6517	break;	6971	break;
6518		6972
6519	case 604 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$	6973	case 668 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$
6520	consumeBinaryExpression(OperatorIds.PLUS);	6974	consumeBinaryExpression(OperatorIds.PLUS);
6521	break;	6975	break;
6522		6976
6523	case 605 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } //$NON-NLS-1$	6977	case 669 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } //$NON-NLS-1$
6524	consumeBinaryExpressionWithName(OperatorIds.PLUS);	6978	consumeBinaryExpressionWithName(OperatorIds.PLUS);
6525	break;	6979	break;
6526		6980
6527	case 606 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$	6981	case 670 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$
6528	consumeBinaryExpression(OperatorIds.MINUS);	6982	consumeBinaryExpression(OperatorIds.MINUS);
6529	break;	6983	break;
6530		6984
6531	case 607 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } //$NON-NLS-1$	6985	case 671 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } //$NON-NLS-1$
6532	consumeBinaryExpressionWithName(OperatorIds.MINUS);	6986	consumeBinaryExpressionWithName(OperatorIds.MINUS);
6533	break;	6987	break;
6534		6988
6535	case 609 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	6989	case 673 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6536	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);	6990	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
6537	break;	6991	break;
6538		6992
6539	case 610 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } //$NON-NLS-1$	6993	case 674 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } //$NON-NLS-1$
6540	consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);	6994	consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);
6541	break;	6995	break;
6542		6996
6543	case 611 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	6997	case 675 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6544	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);	6998	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
6545	break;	6999	break;
6546		7000
6547	case 612 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } //$NON-NLS-1$	7001	case 676 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } //$NON-NLS-1$
6548	consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);	7002	consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);
6549	break;	7003	break;
6550		7004
6551	case 613 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	7005	case 677 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6552	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);	7006	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6553	break;	7007	break;
6554		7008
6555	case 614 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } //$NON-NLS-1$	7009	case 678 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } //$NON-NLS-1$
6556	consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);	7010	consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6557	break;	7011	break;
6558		7012
6559	case 616 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$	7013	case 680 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$
6560	consumeBinaryExpression(OperatorIds.LESS);	7014	consumeBinaryExpression(OperatorIds.LESS);
6561	break;	7015	break;
6562		7016
6563	case 617 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } //$NON-NLS-1$	7017	case 681 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } //$NON-NLS-1$
6564	consumeBinaryExpressionWithName(OperatorIds.LESS);	7018	consumeBinaryExpressionWithName(OperatorIds.LESS);
6565	break;	7019	break;
6566		7020
6567	case 618 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$	7021	case 682 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$
6568	consumeBinaryExpression(OperatorIds.GREATER);	7022	consumeBinaryExpression(OperatorIds.GREATER);
6569	break;	7023	break;
6570		7024
6571	case 619 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } //$NON-NLS-1$	7025	case 683 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } //$NON-NLS-1$
6572	consumeBinaryExpressionWithName(OperatorIds.GREATER);	7026	consumeBinaryExpressionWithName(OperatorIds.GREATER);
6573	break;	7027	break;
6574		7028
6575	case 620 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$	7029	case 684 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$
6576	consumeBinaryExpression(OperatorIds.LESS_EQUAL);	7030	consumeBinaryExpression(OperatorIds.LESS_EQUAL);
6577	break;	7031	break;
6578		7032
6579	case 621 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } //$NON-NLS-1$	7033	case 685 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } //$NON-NLS-1$
6580	consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);	7034	consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);
6581	break;	7035	break;
6582		7036
6583	case 622 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$	7037	case 686 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$
6584	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);	7038	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
6585	break;	7039	break;
6586		7040
6587	case 623 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } //$NON-NLS-1$	7041	case 687 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } //$NON-NLS-1$
6588	consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);	7042	consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);
6589	break;	7043	break;
6590		7044
6591	case 625 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$	7045	case 689 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$
6592	consumeInstanceOfExpressionWithName();	7046	consumeInstanceOfExpressionWithName();
6593	break;	7047	break;
6594		7048
6595	case 626 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$	7049	case 690 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$
		7050	consumeInstanceOfExpressionWithName();
		7051	break;
		7052
		7053	case 691 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$
6596	consumeInstanceOfExpression();	7054	consumeInstanceOfExpression();
6597	break;	7055	break;
6598		7056
6599	case 628 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$	7057	case 692 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$
		7058	consumeInstanceOfExpression();
		7059	break;
		7060
		7061	case 694 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$
6600	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);	7062	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
6601	break;	7063	break;
6602		7064
6603	case 629 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } //$NON-NLS-1$	7065	case 695 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } //$NON-NLS-1$
6604	consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);	7066	consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);
6605	break;	7067	break;
6606		7068
6607	case 630 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$	7069	case 696 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$
6608	consumeEqualityExpression(OperatorIds.NOT_EQUAL);	7070	consumeEqualityExpression(OperatorIds.NOT_EQUAL);
6609	break;	7071	break;
6610		7072
6611	case 631 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } //$NON-NLS-1$	7073	case 697 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } //$NON-NLS-1$
6612	consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);	7074	consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);
6613	break;	7075	break;
6614		7076
6615	case 633 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } //$NON-NLS-1$	7077	case 699 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } //$NON-NLS-1$
6616	consumeBinaryExpression(OperatorIds.AND);	7078	consumeBinaryExpression(OperatorIds.AND);
6617	break;	7079	break;
6618		7080
6619	case 634 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } //$NON-NLS-1$	7081	case 700 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } //$NON-NLS-1$
6620	consumeBinaryExpressionWithName(OperatorIds.AND);	7082	consumeBinaryExpressionWithName(OperatorIds.AND);
6621	break;	7083	break;
6622		7084
6623	case 636 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$	7085	case 702 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$
6624	consumeBinaryExpression(OperatorIds.XOR);	7086	consumeBinaryExpression(OperatorIds.XOR);
6625	break;	7087	break;
6626		7088
6627	case 637 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } //$NON-NLS-1$	7089	case 703 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } //$NON-NLS-1$
6628	consumeBinaryExpressionWithName(OperatorIds.XOR);	7090	consumeBinaryExpressionWithName(OperatorIds.XOR);
6629	break;	7091	break;
6630		7092
6631	case 639 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$	7093	case 705 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$
6632	consumeBinaryExpression(OperatorIds.OR);	7094	consumeBinaryExpression(OperatorIds.OR);
6633	break;	7095	break;
6634		7096
6635	case 640 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } //$NON-NLS-1$	7097	case 706 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } //$NON-NLS-1$
6636	consumeBinaryExpressionWithName(OperatorIds.OR);	7098	consumeBinaryExpressionWithName(OperatorIds.OR);
6637	break;	7099	break;
6638		7100
6639	case 642 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } //$NON-NLS-1$	7101	case 708 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } //$NON-NLS-1$
6640	consumeBinaryExpression(OperatorIds.AND_AND);	7102	consumeBinaryExpression(OperatorIds.AND_AND);
6641	break;	7103	break;
6642		7104
6643	case 643 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } //$NON-NLS-1$	7105	case 709 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } //$NON-NLS-1$
6644	consumeBinaryExpressionWithName(OperatorIds.AND_AND);	7106	consumeBinaryExpressionWithName(OperatorIds.AND_AND);
6645	break;	7107	break;
6646		7108
6647	case 645 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } //$NON-NLS-1$	7109	case 711 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } //$NON-NLS-1$
6648	consumeBinaryExpression(OperatorIds.OR_OR);	7110	consumeBinaryExpression(OperatorIds.OR_OR);
6649	break;	7111	break;
6650		7112
6651	case 646 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } //$NON-NLS-1$	7113	case 712 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } //$NON-NLS-1$
6652	consumeBinaryExpressionWithName(OperatorIds.OR_OR);	7114	consumeBinaryExpressionWithName(OperatorIds.OR_OR);
6653	break;	7115	break;
6654		7116
6655	case 648 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } //$NON-NLS-1$	7117	case 714 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } //$NON-NLS-1$
6656	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;	7118	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
6657	break;	7119	break;
6658		7120
6659	case 649 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } //$NON-NLS-1$	7121	case 715 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } //$NON-NLS-1$
6660	consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;	7122	consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;
6661	break;	7123	break;
6662		7124
6663	case 653 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$	7125	case 719 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$
6664	consumeAnnotationTypeDeclarationHeaderName() ;	7126	consumeAnnotationTypeDeclarationHeaderName() ;
6665	break;	7127	break;
6666		7128
6667	case 654 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$	7129	case 720 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$
6668	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;	7130	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;
6669	break;	7131	break;
6670		7132
6671	case 655 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$	7133	case 721 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$
6672	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;	7134	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;
6673	break;	7135	break;
6674		7136
6675	case 656 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$	7137	case 722 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$
6676	consumeAnnotationTypeDeclarationHeaderName() ;	7138	consumeAnnotationTypeDeclarationHeaderName() ;
6677	break;	7139	break;
6678		7140
6679	case 657 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } //$NON-NLS-1$	7141	case 723 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } //$NON-NLS-1$
6680	consumeAnnotationTypeDeclarationHeader() ;	7142	consumeAnnotationTypeDeclarationHeader() ;
6681	break;	7143	break;
6682		7144
6683	case 658 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } //$NON-NLS-1$	7145	case 724 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } //$NON-NLS-1$
6684	consumeAnnotationTypeDeclaration() ;	7146	consumeAnnotationTypeDeclaration() ;
6685	break;	7147	break;
6686		7148
6687	case 660 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } //$NON-NLS-1$	7149	case 726 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } //$NON-NLS-1$
6688	consumeEmptyAnnotationTypeMemberDeclarationsopt() ;	7150	consumeEmptyAnnotationTypeMemberDeclarationsopt() ;
6689	break;	7151	break;
6690		7152
6691	case 661 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	7153	case 727 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6692	consumeAnnotationTypeMemberDeclarationsopt() ;	7154	consumeAnnotationTypeMemberDeclarationsopt() ;
6693	break;	7155	break;
6694		7156
6695	case 663 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } //$NON-NLS-1$	7157	case 729 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } //$NON-NLS-1$
6696	consumeAnnotationTypeMemberDeclarations() ;	7158	consumeAnnotationTypeMemberDeclarations() ;
6697	break;	7159	break;
6698		7160
6699	case 664 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } //$NON-NLS-1$	7161	case 730 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } //$NON-NLS-1$
6700	consumeMethodHeaderNameWithTypeParameters(true);	7162	consumeMethodHeaderNameWithTypeParameters(true, false);
6701	break;	7163	break;
6702		7164
6703	case 665 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$	7165	case 731 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$
6704	consumeMethodHeaderName(true);	7166	consumeMethodHeaderName(true);
6705	break;	7167	break;
6706		7168
6707	case 666 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } //$NON-NLS-1$	7169	case 732 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } //$NON-NLS-1$
6708	consumeEmptyMethodHeaderDefaultValue() ;	7170	consumeEmptyMethodHeaderDefaultValue() ;
6709	break;	7171	break;
6710		7172
6711	case 667 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } //$NON-NLS-1$	7173	case 733 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } //$NON-NLS-1$
6712	consumeMethodHeaderDefaultValue();	7174	consumeMethodHeaderDefaultValue();
6713	break;	7175	break;
6714		7176
6715	case 668 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } //$NON-NLS-1$	7177	case 734 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } //$NON-NLS-1$
6716	consumeMethodHeader();	7178	consumeMethodHeader();
6717	break;	7179	break;
6718		7180
6719	case 669 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } //$NON-NLS-1$	7181	case 735 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } //$NON-NLS-1$
6720	consumeAnnotationTypeMemberDeclaration() ;	7182	consumeAnnotationTypeMemberDeclaration() ;
6721	break;	7183	break;
6722		7184
6723	case 677 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } //$NON-NLS-1$	7185	case 743 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } //$NON-NLS-1$
6724	consumeAnnotationName() ;	7186	consumeAnnotationName() ;
6725	break;	7187	break;
6726		7188
6727	case 678 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$	7189	case 744 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$
6728	consumeNormalAnnotation() ;	7190	consumeNormalAnnotation() ;
6729	break;	7191	break;
6730		7192
6731	case 679 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } //$NON-NLS-1$	7193	case 745 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } //$NON-NLS-1$
6732	consumeEmptyMemberValuePairsopt() ;	7194	consumeEmptyMemberValuePairsopt() ;
6733	break;	7195	break;
6734		7196
6735	case 682 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } //$NON-NLS-1$	7197	case 748 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } //$NON-NLS-1$
6736	consumeMemberValuePairs() ;	7198	consumeMemberValuePairs() ;
6737	break;	7199	break;
6738		7200
6739	case 683 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } //$NON-NLS-1$	7201	case 749 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } //$NON-NLS-1$
6740	consumeMemberValuePair() ;	7202	consumeMemberValuePair() ;
6741	break;	7203	break;
6742		7204
6743	case 684 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } //$NON-NLS-1$	7205	case 750 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } //$NON-NLS-1$
6744	consumeEnterMemberValue() ;	7206	consumeEnterMemberValue() ;
6745	break;	7207	break;
6746		7208
6747	case 685 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } //$NON-NLS-1$	7209	case 751 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } //$NON-NLS-1$
6748	consumeExitMemberValue() ;	7210	consumeExitMemberValue() ;
6749	break;	7211	break;
6750		7212
6751	case 687 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } //$NON-NLS-1$	7213	case 753 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } //$NON-NLS-1$
6752	consumeMemberValueAsName() ;	7214	consumeMemberValueAsName() ;
6753	break;	7215	break;
6754		7216
6755	case 690 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7217	case 756 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6756	consumeMemberValueArrayInitializer() ;	7218	consumeMemberValueArrayInitializer() ;
6757	break;	7219	break;
6758		7220
6759	case 691 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7221	case 757 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6760	consumeMemberValueArrayInitializer() ;	7222	consumeMemberValueArrayInitializer() ;
6761	break;	7223	break;
6762		7224
6763	case 692 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7225	case 758 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6764	consumeEmptyMemberValueArrayInitializer() ;	7226	consumeEmptyMemberValueArrayInitializer() ;
6765	break;	7227	break;
6766		7228
6767	case 693 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7229	case 759 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6768	consumeEmptyMemberValueArrayInitializer() ;	7230	consumeEmptyMemberValueArrayInitializer() ;
6769	break;	7231	break;
6770		7232
6771	case 694 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); } //$NON-NLS-1$	7233	case 760 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); } //$NON-NLS-1$
6772	consumeEnterMemberValueArrayInitializer() ;	7234	consumeEnterMemberValueArrayInitializer() ;
6773	break;	7235	break;
6774		7236
6775	case 696 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } //$NON-NLS-1$	7237	case 762 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } //$NON-NLS-1$
6776	consumeMemberValues() ;	7238	consumeMemberValues() ;
6777	break;	7239	break;
6778		7240
6779	case 697 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } //$NON-NLS-1$	7241	case 763 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } //$NON-NLS-1$
6780	consumeMarkerAnnotation() ;	7242	consumeMarkerAnnotation() ;
6781	break;	7243	break;
6782		7244
6783	case 698 : if (DEBUG) { System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); } //$NON-NLS-1$	7245	case 764 : if (DEBUG) { System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); } //$NON-NLS-1$
6784	consumeSingleMemberAnnotationMemberValue() ;	7246	consumeSingleMemberAnnotationMemberValue() ;
6785	break;	7247	break;
6786		7248
6787	case 699 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$	7249	case 765 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$
6788	consumeSingleMemberAnnotation() ;	7250	consumeSingleMemberAnnotation() ;
6789	break;	7251	break;
6790		7252
6791	case 700 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$	7253	case 766 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$
6792	consumeRecoveryMethodHeaderNameWithTypeParameters();	7254	consumeRecoveryMethodHeaderNameWithTypeParameters(false);
		7255	break;
		7256
		7257	case 767 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$
		7258	consumeRecoveryMethodHeaderNameWithTypeParameters(true);
6793	break;	7259	break;
6794		7260
6795	case 701 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$	7261	case 768 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$
6796	consumeRecoveryMethodHeaderName();	7262	consumeRecoveryMethodHeaderName();
6797	break;	7263	break;
6798		7264
6799	case 702 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$	7265	case 769 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
6800	consumeMethodHeader();	7266	consumeMethodHeader();
6801	break;	7267	break;
6802		7268
6803	case 703 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$	7269	case 770 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
6804	consumeMethodHeader();	7270	consumeMethodHeader();
6805	break;	7271	break;
6806		7272
6807	}	7273	}
6808	}	7274	}
		7275	protected void consumeTypeAnnotation (boolean markAsUnattached) {
		7276	if(!this.statementRecoveryActivated &&
		7277	this.options.sourceLevel < ClassFileConstants.JDK1_7 &&
		7278	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		7279	problemReporter().invalidUsageOfTypeAnnotations((Annotation) this.expressionStack[this.expressionPtr]);
		7280	}
		7281	this.expressionLengthPtr --;
		7282	Annotation annotation = (Annotation) this.expressionStack[this.expressionPtr--];
		7283	pushOnTypeAnnotationStack(annotation);
		7284	if (markAsUnattached) {
		7285	if (this.unattachedAnnotationPtr == -1) {
		7286	this.unattachedAnnotationPtr = this.typeAnnotationPtr;
		7287	} else {
		7288	this.typeAnnotationLengthStack[--this.typeAnnotationLengthPtr]++;
		7289	}
		7290	}
		7291	}
		7292	protected void consumeDimsWithTrailingAnnotsopt() {
		7293	// DimsoptAnnotsopt -> DimsAnnotLoop
		7294	pushOnIntStack(this.dimensions);
		7295	this.dimensions = 0;
		7296	if (this.unattachedAnnotationPtr == -1) {
		7297	pushOnTypeAnnotationLengthStack(0); // no trailing annotations (receiver/vararg)
		7298	} else {
		7299	this.unattachedAnnotationPtr = -1; // reset this and leave the annotation stacks as they are.
		7300	}
		7301	}
		7302	protected void consumeZeroTypeAnnotations() {
		7303	pushOnTypeAnnotationLengthStack(0);
		7304	}
		7305	protected void consumeEmptyDimsoptAnnotsopt() {
		7306	// DimsoptAnnotsopt ::= $empty
		7307	pushOnIntStack(0); // signal a non array
		7308	pushOnTypeAnnotationLengthStack(0); // no trailing annotations (receiver/vararg)
		7309	}
6809	protected void consumeSimpleAssertStatement() {	7310	protected void consumeSimpleAssertStatement() {
6810	// AssertStatement ::= 'assert' Expression ';'	7311	// AssertStatement ::= 'assert' Expression ';'
6811	this.expressionLengthPtr--;	7312	this.expressionLengthPtr--;
Lines 7673-7680 Link Here
7673	// case TokenNameGREATER :	8174	// case TokenNameGREATER :
7674	}	8175	}
7675	}	8176	}
7676	protected void consumeTypeArgument() {	8177	protected void consumeTypeArgument(boolean hasTypeAnnotations) {
7677	pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));	8178	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]));
7678	}	8179	}
7679	protected void consumeTypeArgumentList() {	8180	protected void consumeTypeArgumentList() {
7680	concatGenericsLists();	8181	concatGenericsLists();
Lines 7688-7701 Link Here
7688	protected void consumeTypeArgumentList3() {	8189	protected void consumeTypeArgumentList3() {
7689	concatGenericsLists();	8190	concatGenericsLists();
7690	}	8191	}
7691	protected void consumeTypeArgumentReferenceType1() {	8192	protected void consumeTypeArgumentReferenceType1(boolean hasTypeAnnotations) {
7692	concatGenericsLists();	8193	concatGenericsLists();
7693	pushOnGenericsStack(getTypeReference(0));	8194	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(0) : getUnannotatedTypeReference(0));
7694	this.intPtr--;	8195	this.intPtr--;
7695	}	8196	}
7696	protected void consumeTypeArgumentReferenceType2() {	8197	protected void consumeTypeArgumentReferenceType2(boolean hasTypeAnnotations) {
7697	concatGenericsLists();	8198	concatGenericsLists();
7698	pushOnGenericsStack(getTypeReference(0));	8199	pushOnGenericsStack(hasTypeAnnotations ? getTypeReference(0) : getUnannotatedTypeReference(0));
7699	this.intPtr--;	8200	this.intPtr--;
7700	}	8201	}
7701	protected void consumeTypeArguments() {	8202	protected void consumeTypeArguments() {
Lines 7780-7792 Link Here
7780	superType.bits \|= ASTNode.IsSuperType;	8281	superType.bits \|= ASTNode.IsSuperType;
7781	this.genericsStack[this.genericsPtr] = typeParameter;	8282	this.genericsStack[this.genericsPtr] = typeParameter;
7782	}	8283	}
7783	protected void consumeTypeParameter1WithExtendsAndBounds() {	8284	protected void consumeTypeParameter1WithExtendsAndBounds(boolean hasTypeAnnotations) {
7784	//TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1	8285	//TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1
7785	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];	8286	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];
7786	TypeReference[] bounds = new TypeReference[additionalBoundsLength];	8287	TypeReference[] bounds = new TypeReference[additionalBoundsLength];
7787	this.genericsPtr -= additionalBoundsLength;	8288	this.genericsPtr -= additionalBoundsLength;
7788	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);	8289	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);
7789	TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);	8290	TypeReference superType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
7790	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	8291	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
7791	typeParameter.declarationSourceEnd = bounds[additionalBoundsLength - 1].sourceEnd;	8292	typeParameter.declarationSourceEnd = bounds[additionalBoundsLength - 1].sourceEnd;
7792	typeParameter.type = superType;	8293	typeParameter.type = superType;
Lines 7799-7804 Link Here
7799	protected void consumeTypeParameterHeader() {	8300	protected void consumeTypeParameterHeader() {
7800	//TypeParameterHeader ::= Identifier	8301	//TypeParameterHeader ::= Identifier
7801	TypeParameter typeParameter = new TypeParameter();	8302	TypeParameter typeParameter = new TypeParameter();
		8303	int length;
		8304	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		8305	System.arraycopy(
		8306	this.typeAnnotationStack,
		8307	(this.typeAnnotationPtr -= length) + 1,
		8308	typeParameter.annotations = new Annotation[length],
		8309	0,
		8310	length);
		8311	}
7802	long pos = this.identifierPositionStack[this.identifierPtr];	8312	long pos = this.identifierPositionStack[this.identifierPtr];
7803	final int end = (int) pos;	8313	final int end = (int) pos;
7804	typeParameter.declarationSourceEnd = end;	8314	typeParameter.declarationSourceEnd = end;
Lines 7844-7864 Link Here
7844	(TypeParameter) this.genericsStack[this.genericsPtr]);	8354	(TypeParameter) this.genericsStack[this.genericsPtr]);
7845	}	8355	}
7846	}	8356	}
7847	protected void consumeTypeParameterWithExtends() {	8357	protected void consumeTypeParameterWithExtends(boolean hasTypeAnnotations) {
7848	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType	8358	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType
7849	TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);	8359	TypeReference superType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
7850	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	8360	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
7851	typeParameter.declarationSourceEnd = superType.sourceEnd;	8361	typeParameter.declarationSourceEnd = superType.sourceEnd;
7852	typeParameter.type = superType;	8362	typeParameter.type = superType;
7853	superType.bits \|= ASTNode.IsSuperType;	8363	superType.bits \|= ASTNode.IsSuperType;
7854	}	8364	}
7855	protected void consumeTypeParameterWithExtendsAndBounds() {	8365	protected void consumeTypeParameterWithExtendsAndBounds(boolean hasTypeAnnotations) {
7856	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList	8366	//TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList
7857	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];	8367	int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];
7858	TypeReference[] bounds = new TypeReference[additionalBoundsLength];	8368	TypeReference[] bounds = new TypeReference[additionalBoundsLength];
7859	this.genericsPtr -= additionalBoundsLength;	8369	this.genericsPtr -= additionalBoundsLength;
7860	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);	8370	System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);
7861	TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);	8371	TypeReference superType = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
7862	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	8372	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
7863	typeParameter.type = superType;	8373	typeParameter.type = superType;
7864	superType.bits \|= ASTNode.IsSuperType;	8374	superType.bits \|= ASTNode.IsSuperType;
Lines 8030-8046 Link Here
8030	wildcard.sourceStart = this.intStack[this.intPtr--];	8540	wildcard.sourceStart = this.intStack[this.intPtr--];
8031	this.genericsStack[this.genericsPtr] = wildcard;	8541	this.genericsStack[this.genericsPtr] = wildcard;
8032	}	8542	}
8033	protected void consumeWildcardBoundsExtends() {	8543	protected void consumeWildcardBoundsExtends(boolean hasTypeAnnotations) {
8034	Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);	8544	Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
8035	wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);	8545	wildcard.bound = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
8036	wildcard.sourceEnd = wildcard.bound.sourceEnd;	8546	wildcard.sourceEnd = wildcard.bound.sourceEnd;
8037	this.intPtr--; // remove end position of the '?'	8547	this.intPtr--; // remove end position of the '?'
8038	wildcard.sourceStart = this.intStack[this.intPtr--];	8548	wildcard.sourceStart = this.intStack[this.intPtr--];
8039	pushOnGenericsStack(wildcard);	8549	pushOnGenericsStack(wildcard);
8040	}	8550	}
8041	protected void consumeWildcardBoundsSuper() {	8551	protected void consumeWildcardBoundsSuper(boolean hasTypeAnnotations) {
8042	Wildcard wildcard = new Wildcard(Wildcard.SUPER);	8552	Wildcard wildcard = new Wildcard(Wildcard.SUPER);
8043	wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);	8553	wildcard.bound = hasTypeAnnotations ? getTypeReference(this.intStack[this.intPtr--]) : getUnannotatedTypeReference(this.intStack[this.intPtr--]);
8044	this.intPtr--; // remove the starting position of the super keyword	8554	this.intPtr--; // remove the starting position of the super keyword
8045	wildcard.sourceEnd = wildcard.bound.sourceEnd;	8555	wildcard.sourceEnd = wildcard.bound.sourceEnd;
8046	this.intPtr--; // remove end position of the '?'	8556	this.intPtr--; // remove end position of the '?'
Lines 8096-8101 Link Here
8096	protected TypeReference copyDims(TypeReference typeRef, int dim) {	8606	protected TypeReference copyDims(TypeReference typeRef, int dim) {
8097	return typeRef.copyDims(dim);	8607	return typeRef.copyDims(dim);
8098	}	8608	}
		8609
		8610	protected TypeReference copyDims(TypeReference typeRef, int dim, Annotation[][]annotationsOnDimensions) {
		8611	return typeRef.copyDims(dim, annotationsOnDimensions);
		8612	}
		8613
8099	protected FieldDeclaration createFieldDeclaration(char[] fieldDeclarationName, int sourceStart, int sourceEnd) {	8614	protected FieldDeclaration createFieldDeclaration(char[] fieldDeclarationName, int sourceStart, int sourceEnd) {
8100	return new FieldDeclaration(fieldDeclarationName, sourceStart, sourceEnd);	8615	return new FieldDeclaration(fieldDeclarationName, sourceStart, sourceEnd);
8101	}	8616	}
Lines 8576-8588 Link Here
8576	return exp;	9091	return exp;
8577	}	9092	}
8578	protected TypeReference getTypeReference(int dim) {	9093	protected TypeReference getTypeReference(int dim) {
		9094	TypeReference ref = getUnannotatedTypeReference(dim);
		9095	int length;
		9096	if (this.typeAnnotationLengthPtr >= 0 && (length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		9097	System.arraycopy(
		9098	this.typeAnnotationStack,
		9099	(this.typeAnnotationPtr -= length) + 1,
		9100	ref.annotations = new Annotation[length],
		9101	0,
		9102	length);
		9103	}
		9104	return ref;
		9105	}
		9106	protected TypeReference getUnannotatedTypeReference(int dim) {
8579	/* build a Reference on a variable that may be qualified or not	9107	/* 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*/	9108	This variable is a type reference and dim will be its dimensions*/
8581		9109
8582	TypeReference ref;	9110	TypeReference ref;
		9111	Annotation [][] annotationsOnDimensions = null;
8583	int length = this.identifierLengthStack[this.identifierLengthPtr--];	9112	int length = this.identifierLengthStack[this.identifierLengthPtr--];
8584	if (length < 0) { //flag for precompiled type reference on base types	9113	if (length < 0) { //flag for precompiled type reference on base types
8585	ref = TypeReference.baseTypeReference(-length, dim);	9114	if (dim > 0) {
		9115	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		9116	}
		9117	ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
8586	ref.sourceStart = this.intStack[this.intPtr--];	9118	ref.sourceStart = this.intStack[this.intPtr--];
8587	if (dim == 0) {	9119	if (dim == 0) {
8588	ref.sourceEnd = this.intStack[this.intPtr--];	9120	ref.sourceEnd = this.intStack[this.intPtr--];
Lines 8604-8613 Link Here
8604	this.identifierStack[this.identifierPtr],	9136	this.identifierStack[this.identifierPtr],
8605	this.identifierPositionStack[this.identifierPtr--]);	9137	this.identifierPositionStack[this.identifierPtr--]);
8606	} else {	9138	} else {
		9139	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
8607	ref =	9140	ref =
8608	new ArrayTypeReference(	9141	new ArrayTypeReference(
8609	this.identifierStack[this.identifierPtr],	9142	this.identifierStack[this.identifierPtr],
8610	dim,	9143	dim,
		9144	annotationsOnDimensions,
8611	this.identifierPositionStack[this.identifierPtr--]);	9145	this.identifierPositionStack[this.identifierPtr--]);
8612	ref.sourceEnd = this.endPosition;	9146	ref.sourceEnd = this.endPosition;
8613	}	9147	}
Lines 8627-8633 Link Here
8627	if (dim == 0) {	9161	if (dim == 0) {
8628	ref = new QualifiedTypeReference(tokens, positions);	9162	ref = new QualifiedTypeReference(tokens, positions);
8629	} else {	9163	} else {
8630	ref = new ArrayQualifiedTypeReference(tokens, dim, positions);	9164	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		9165	ref = new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
8631	ref.sourceEnd = this.endPosition;	9166	ref.sourceEnd = this.endPosition;
8632	}	9167	}
8633	}	9168	}
Lines 8635-8646 Link Here
8635	return ref;	9170	return ref;
8636	}	9171	}
8637	protected TypeReference getTypeReferenceForGenericType(int dim, int identifierLength, int numberOfIdentifiers) {	9172	protected TypeReference getTypeReferenceForGenericType(int dim, int identifierLength, int numberOfIdentifiers) {
		9173	Annotation[][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
8638	if (identifierLength == 1 && numberOfIdentifiers == 1) {	9174	if (identifierLength == 1 && numberOfIdentifiers == 1) {
8639	int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];	9175	int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];
8640	TypeReference[] typeArguments = new TypeReference[currentTypeArgumentsLength];	9176	TypeReference[] typeArguments = new TypeReference[currentTypeArgumentsLength];
8641	this.genericsPtr -= currentTypeArgumentsLength;	9177	this.genericsPtr -= currentTypeArgumentsLength;
8642	System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeArguments, 0, currentTypeArgumentsLength);	9178	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--]);	9179	ParameterizedSingleTypeReference parameterizedSingleTypeReference = new ParameterizedSingleTypeReference(this.identifierStack[this.identifierPtr], typeArguments, dim, annotationsOnDimensions, this.identifierPositionStack[this.identifierPtr--]);
8644	if (dim != 0) {	9180	if (dim != 0) {
8645	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;	9181	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;
8646	}	9182	}
Lines 8674-8680 Link Here
8674	currentIdentifiersLength = this.identifierLengthStack[this.identifierLengthPtr--];	9210	currentIdentifiersLength = this.identifierLengthStack[this.identifierLengthPtr--];
8675	}	9211	}
8676	}	9212	}
8677	ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference = new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, positions);	9213	ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference = new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, annotationsOnDimensions, positions);
8678	if (dim != 0) {	9214	if (dim != 0) {
8679	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;	9215	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;
8680	}	9216	}
Lines 8895-8900 Link Here
8895	this.astLengthPtr = -1;	9431	this.astLengthPtr = -1;
8896	this.expressionPtr = -1;	9432	this.expressionPtr = -1;
8897	this.expressionLengthPtr = -1;	9433	this.expressionLengthPtr = -1;
		9434	this.unattachedAnnotationPtr = -1;
		9435	this.typeAnnotationLengthPtr = -1;
		9436	this.typeAnnotationPtr = -1;
8898	this.identifierPtr = -1;	9437	this.identifierPtr = -1;
8899	this.identifierLengthPtr = -1;	9438	this.identifierLengthPtr = -1;
8900	this.intPtr = -1;	9439	this.intPtr = -1;
Lines 10025-10030 Link Here
10025	}	10564	}
10026	this.astLengthStack[this.astLengthPtr] = 1;	10565	this.astLengthStack[this.astLengthPtr] = 1;
10027	}	10566	}
		10567	protected void pushOnTypeAnnotationStack(Annotation annotation) {
		10568
		10569	int stackLength = this.typeAnnotationStack.length;
		10570	if (++this.typeAnnotationPtr >= stackLength) {
		10571	System.arraycopy(
		10572	this.typeAnnotationStack, 0,
		10573	this.typeAnnotationStack = new Annotation[stackLength + TypeAnnotationStackIncrement], 0,
		10574	stackLength);
		10575	}
		10576	this.typeAnnotationStack[this.typeAnnotationPtr] = annotation;
		10577
		10578	stackLength = this.typeAnnotationLengthStack.length;
		10579	if (++this.typeAnnotationLengthPtr >= stackLength) {
		10580	System.arraycopy(
		10581	this.typeAnnotationLengthStack, 0,
		10582	this.typeAnnotationLengthStack = new int[stackLength + TypeAnnotationStackIncrement], 0,
		10583	stackLength);
		10584	}
		10585	this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr] = 1;
		10586	}
		10587	protected void pushOnTypeAnnotationLengthStack(int pos) {
		10588
		10589	int stackLength = this.typeAnnotationLengthStack.length;
		10590	if (++this.typeAnnotationLengthPtr >= stackLength) {
		10591	System.arraycopy(
		10592	this.typeAnnotationLengthStack, 0,
		10593	this.typeAnnotationLengthStack = new int[stackLength + TypeAnnotationStackIncrement], 0,
		10594	stackLength);
		10595	}
		10596	this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr] = pos;
		10597	}
10028	protected void pushOnExpressionStack(Expression expr) {	10598	protected void pushOnExpressionStack(Expression expr) {
10029		10599
10030	int stackLength = this.expressionStack.length;	10600	int stackLength = this.expressionStack.length;
Lines 10445-10450 Link Here
10445	this.astLengthPtr = -1;	11015	this.astLengthPtr = -1;
10446	this.expressionPtr = -1;	11016	this.expressionPtr = -1;
10447	this.expressionLengthPtr = -1;	11017	this.expressionLengthPtr = -1;
		11018	this.unattachedAnnotationPtr = -1;
		11019	this.typeAnnotationLengthPtr = -1;
		11020	this.typeAnnotationPtr = -1;
10448	this.identifierPtr = -1;	11021	this.identifierPtr = -1;
10449	this.identifierLengthPtr = -1;	11022	this.identifierLengthPtr = -1;
10450	this.intPtr = -1;	11023	this.intPtr = -1;




		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) {

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

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	}




	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;

	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
	String completionIdentifier = "zzz";
	String expectedReplacedSource = "zzz";
	String expectedUnitDisplayString =
			"package p;\n" +
			"public class X {\n" +
			"  Object o = new X[]{<CompleteOnName:zzz>};\n" +
			"  {\n" +
			"    <CompleteOnName:zzz>;\n" +
			"  }\n" +
			"  public X() {\n" +
			"  }\n" +
			"}\n";




		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>";





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() {




				"	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() {




		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);

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 4150-4165 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java (-5 / +2 lines)
4150	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4150	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4151		4151
4152	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	4152	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4153	String expectedParentNodeToString = "<NONE>";	4153	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
4154	String completionIdentifier = "zzz";	4154	String completionIdentifier = "zzz";
4155	String expectedReplacedSource = "zzz";	4155	String expectedReplacedSource = "zzz";
4156	String expectedUnitDisplayString =	4156	String expectedUnitDisplayString =
4157	"package p;\n" +	4157	"package p;\n" +
4158	"public class X {\n" +	4158	"public class X {\n" +
4159	" Object o;\n" +	4159	" Object o = new X[]{<CompleteOnName:zzz>};\n" +
4160	" {\n" +
4161	" <CompleteOnName:zzz>;\n" +
4162	" }\n" +
4163	" public X() {\n" +	4160	" public X() {\n" +
4164	" }\n" +	4161	" }\n" +
4165	"}\n";	4162	"}\n";

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 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 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 1280-1286 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (-35 / +36 lines)
1280	if ((length = this.identifierLengthStack[this.identifierLengthPtr-1]) < 0) {	1280	if ((length = this.identifierLengthStack[this.identifierLengthPtr-1]) < 0) {
1281	// build the primitive type node	1281	// build the primitive type node
1282	int dim = isAfterArrayType() ? this.intStack[this.intPtr--] : 0;	1282	int dim = isAfterArrayType() ? this.intStack[this.intPtr--] : 0;
1283	SingleTypeReference typeRef = (SingleTypeReference)TypeReference.baseTypeReference(-length, dim);	1283	Annotation [][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
		1284	SingleTypeReference typeRef = (SingleTypeReference)TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
1284	typeRef.sourceStart = this.intStack[this.intPtr--];	1285	typeRef.sourceStart = this.intStack[this.intPtr--];
1285	if (dim == 0) {	1286	if (dim == 0) {
1286	typeRef.sourceEnd = this.intStack[this.intPtr--];	1287	typeRef.sourceEnd = this.intStack[this.intPtr--];
Lines 1951-1962 Link Here
1951	if (checkLabelStatement()) return;	1952	if (checkLabelStatement()) return;
1952	if (checkNameCompletion()) return;	1953	if (checkNameCompletion()) return;
1953	}	1954	}
1954	protected void consumeArrayCreationExpressionWithInitializer() {	1955	protected void consumeArrayCreationExpressionWithInitializer(boolean hasTypeAnnotations) {
1955	super.consumeArrayCreationExpressionWithInitializer();	1956	super.consumeArrayCreationExpressionWithInitializer(hasTypeAnnotations);
1956	popElement(K_ARRAY_CREATION);	1957	popElement(K_ARRAY_CREATION);
1957	}	1958	}
1958	protected void consumeArrayCreationExpressionWithoutInitializer() {	1959	protected void consumeArrayCreationExpressionWithoutInitializer(boolean hasTypeAnnotations) {
1959	super.consumeArrayCreationExpressionWithoutInitializer();	1960	super.consumeArrayCreationExpressionWithoutInitializer(hasTypeAnnotations);
1960	popElement(K_ARRAY_CREATION);	1961	popElement(K_ARRAY_CREATION);
1961	}	1962	}
1962	protected void consumeArrayCreationHeader() {	1963	protected void consumeArrayCreationHeader() {
Lines 1998-2004 Link Here
1998	pushOnElementStack(K_SWITCH_LABEL);	1999	pushOnElementStack(K_SWITCH_LABEL);
1999	}	2000	}
2000	}	2001	}
2001	protected void consumeCastExpressionWithPrimitiveType() {	2002	protected void consumeCastExpressionWithPrimitiveType(boolean hasTypeAnnotations) {
2002	popElement(K_CAST_STATEMENT);	2003	popElement(K_CAST_STATEMENT);
2003		2004
2004	Expression exp, cast, castType;	2005	Expression exp, cast, castType;
Lines 2008-2014 Link Here
2008	cast.sourceStart = castType.sourceStart - 1;	2009	cast.sourceStart = castType.sourceStart - 1;
2009	cast.sourceEnd = exp.sourceEnd;	2010	cast.sourceEnd = exp.sourceEnd;
2010	}	2011	}
2011	protected void consumeCastExpressionWithGenericsArray() {	2012	protected void consumeCastExpressionWithGenericsArray(boolean hasTypeAnnotations) {
2012	popElement(K_CAST_STATEMENT);	2013	popElement(K_CAST_STATEMENT);
2013		2014
2014	Expression exp, cast, castType;	2015	Expression exp, cast, castType;
Lines 2019-2025 Link Here
2019	cast.sourceEnd = exp.sourceEnd;	2020	cast.sourceEnd = exp.sourceEnd;
2020	}	2021	}
2021		2022
2022	protected void consumeCastExpressionWithQualifiedGenericsArray() {	2023	protected void consumeCastExpressionWithQualifiedGenericsArray(boolean hasTypeAnnotations) {
2023	popElement(K_CAST_STATEMENT);	2024	popElement(K_CAST_STATEMENT);
2024		2025
2025	Expression exp, cast, castType;	2026	Expression exp, cast, castType;
Lines 2029-2035 Link Here
2029	cast.sourceStart = castType.sourceStart - 1;	2030	cast.sourceStart = castType.sourceStart - 1;
2030	cast.sourceEnd = exp.sourceEnd;	2031	cast.sourceEnd = exp.sourceEnd;
2031	}	2032	}
2032	protected void consumeCastExpressionWithNameArray() {	2033	protected void consumeCastExpressionWithNameArray(boolean hasTypeAnnotations) {
2033	// CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	2034	// CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
2034	popElement(K_CAST_STATEMENT);	2035	popElement(K_CAST_STATEMENT);
2035		2036
Lines 2041-2049 Link Here
2041	cast.sourceStart = castType.sourceStart - 1;	2042	cast.sourceStart = castType.sourceStart - 1;
2042	cast.sourceEnd = exp.sourceEnd;	2043	cast.sourceEnd = exp.sourceEnd;
2043	}	2044	}
2044	protected void consumeCastExpressionLL1() {	2045	protected void consumeCastExpressionLL1(boolean hasTypeAnnotations) {
2045	popElement(K_CAST_STATEMENT);	2046	popElement(K_CAST_STATEMENT);
2046	super.consumeCastExpressionLL1();	2047	super.consumeCastExpressionLL1(hasTypeAnnotations);
2047	}	2048	}
2048	protected void consumeClassBodyDeclaration() {	2049	protected void consumeClassBodyDeclaration() {
2049	popElement(K_BLOCK_DELIMITER);	2050	popElement(K_BLOCK_DELIMITER);
Lines 2678-2684 Link Here
2678	long selectorSource = this.identifierPositionStack[this.identifierPtr + 1];	2679	long selectorSource = this.identifierPositionStack[this.identifierPtr + 1];
2679		2680
2680	//type	2681	//type
2681	TypeReference type = getTypeReference(this.intStack[this.intPtr--]);	2682	TypeReference type = getUnannotatedTypeReference(this.intStack[this.intPtr--]);
2682	((CompletionOnSingleTypeReference)type).isCompletionNode = false;	2683	((CompletionOnSingleTypeReference)type).isCompletionNode = false;
2683	//modifiers	2684	//modifiers
2684	int declarationSourceStart = this.intStack[this.intPtr--];	2685	int declarationSourceStart = this.intStack[this.intPtr--];
Lines 2738-2744 Link Here
2738	long selectorSource = this.identifierPositionStack[this.identifierPtr--];	2739	long selectorSource = this.identifierPositionStack[this.identifierPtr--];
2739	this.identifierLengthPtr--;	2740	this.identifierLengthPtr--;
2740	//type	2741	//type
2741	md.returnType = getTypeReference(this.intStack[this.intPtr--]);	2742	md.returnType = getUnannotatedTypeReference(this.intStack[this.intPtr--]);
2742	//modifiers	2743	//modifiers
2743	md.declarationSourceStart = this.intStack[this.intPtr--];	2744	md.declarationSourceStart = this.intStack[this.intPtr--];
2744	md.modifiers = this.intStack[this.intPtr--];	2745	md.modifiers = this.intStack[this.intPtr--];
Lines 2782-2792 Link Here
2782	}	2783	}
2783	}	2784	}
2784	}	2785	}
2785	protected void consumeMethodHeaderNameWithTypeParameters( boolean isAnnotationMethod) {	2786	protected void consumeMethodHeaderNameWithTypeParameters( boolean isAnnotationMethod, boolean hasTypeAnnotations) {
2786	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];	2787	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
2787	int selectorSourceEnd = (int) selectorSourcePositions;	2788	int selectorSourceEnd = (int) selectorSourcePositions;
2788	int currentAstPtr = this.astPtr;	2789	int currentAstPtr = this.astPtr;
2789	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);	2790	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod, hasTypeAnnotations);
2790	if (this.sourceEnds != null && this.astPtr > currentAstPtr) {// if ast node was pushed on the ast stack	2791	if (this.sourceEnds != null && this.astPtr > currentAstPtr) {// if ast node was pushed on the ast stack
2791	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);	2792	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
2792	}	2793	}
Lines 2866-2873 Link Here
2866	this.hasUnusedModifiers = true;	2867	this.hasUnusedModifiers = true;
2867	}	2868	}
2868	}	2869	}
2869	protected void consumeAdditionalBound() {	2870	protected void consumeAdditionalBound(boolean hasTypeAnnotations) {
2870	super.consumeAdditionalBound();	2871	super.consumeAdditionalBound(hasTypeAnnotations);
2871	ASTNode node = this.genericsStack[this.genericsPtr];	2872	ASTNode node = this.genericsStack[this.genericsPtr];
2872	if (node instanceof CompletionOnSingleTypeReference) {	2873	if (node instanceof CompletionOnSingleTypeReference) {
2873	((CompletionOnSingleTypeReference) node).setKind(CompletionOnQualifiedTypeReference.K_INTERFACE);	2874	((CompletionOnSingleTypeReference) node).setKind(CompletionOnQualifiedTypeReference.K_INTERFACE);
Lines 3707-3730 Link Here
3707	protected void consumeRightParen() {	3708	protected void consumeRightParen() {
3708	super.consumeRightParen();	3709	super.consumeRightParen();
3709	}	3710	}
3710	protected void consumeReferenceType1() {	3711	protected void consumeReferenceType1(boolean hasTypeAnnotations) {
3711	super.consumeReferenceType1();	3712	super.consumeReferenceType1(hasTypeAnnotations);
3712	popElement(K_BINARY_OPERATOR);	3713	popElement(K_BINARY_OPERATOR);
3713	}	3714	}
3714	protected void consumeReferenceType2() {	3715	protected void consumeReferenceType2(boolean hasTypeAnnotations) {
3715	super.consumeReferenceType2();	3716	super.consumeReferenceType2(hasTypeAnnotations);
3716	popElement(K_BINARY_OPERATOR);	3717	popElement(K_BINARY_OPERATOR);
3717	}	3718	}
3718	protected void consumeReferenceType3() {	3719	protected void consumeReferenceType3(boolean hasTypeAnnotations) {
3719	super.consumeReferenceType3();	3720	super.consumeReferenceType3(hasTypeAnnotations);
3720	popElement(K_BINARY_OPERATOR);	3721	popElement(K_BINARY_OPERATOR);
3721	}	3722	}
3722	protected void consumeTypeArgumentReferenceType1() {	3723	protected void consumeTypeArgumentReferenceType1(boolean hasTypeAnnotations) {
3723	super.consumeTypeArgumentReferenceType1();	3724	super.consumeTypeArgumentReferenceType1(hasTypeAnnotations);
3724	popElement(K_BINARY_OPERATOR);	3725	popElement(K_BINARY_OPERATOR);
3725	}	3726	}
3726	protected void consumeTypeArgumentReferenceType2() {	3727	protected void consumeTypeArgumentReferenceType2(boolean hasTypeAnnotations) {
3727	super.consumeTypeArgumentReferenceType2();	3728	super.consumeTypeArgumentReferenceType2(hasTypeAnnotations);
3728	popElement(K_BINARY_OPERATOR);	3729	popElement(K_BINARY_OPERATOR);
3729	}	3730	}
3730	protected void consumeTypeArguments() {	3731	protected void consumeTypeArguments() {
Lines 3779-3786 Link Here
3779	super.consumeTypeParameter1();	3780	super.consumeTypeParameter1();
3780	popElement(K_BINARY_OPERATOR);	3781	popElement(K_BINARY_OPERATOR);
3781	}	3782	}
3782	protected void consumeTypeParameterWithExtends() {	3783	protected void consumeTypeParameterWithExtends(boolean hasTypeAnnotations) {
3783	super.consumeTypeParameterWithExtends();	3784	super.consumeTypeParameterWithExtends(hasTypeAnnotations);
3784	if (this.assistNode != null && this.assistNodeParent == null) {	3785	if (this.assistNode != null && this.assistNodeParent == null) {
3785	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	3786	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
3786	if (typeParameter != null && typeParameter.type == this.assistNode)	3787	if (typeParameter != null && typeParameter.type == this.assistNode)
Lines 3788-3795 Link Here
3788	}	3789	}
3789	popElement(K_EXTENDS_KEYWORD);	3790	popElement(K_EXTENDS_KEYWORD);
3790	}	3791	}
3791	protected void consumeTypeParameterWithExtendsAndBounds() {	3792	protected void consumeTypeParameterWithExtendsAndBounds(boolean hasTypeAnnotations) {
3792	super.consumeTypeParameterWithExtendsAndBounds();	3793	super.consumeTypeParameterWithExtendsAndBounds(hasTypeAnnotations);
3793	if (this.assistNode != null && this.assistNodeParent == null) {	3794	if (this.assistNode != null && this.assistNodeParent == null) {
3794	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	3795	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
3795	if (typeParameter != null && typeParameter.type == this.assistNode)	3796	if (typeParameter != null && typeParameter.type == this.assistNode)
Lines 3806-3813 Link Here
3806	}	3807	}
3807	popElement(K_EXTENDS_KEYWORD);	3808	popElement(K_EXTENDS_KEYWORD);
3808	}	3809	}
3809	protected void consumeTypeParameter1WithExtendsAndBounds() {	3810	protected void consumeTypeParameter1WithExtendsAndBounds(boolean hasTypeAnnotations) {
3810	super.consumeTypeParameter1WithExtendsAndBounds();	3811	super.consumeTypeParameter1WithExtendsAndBounds(hasTypeAnnotations);
3811	if (this.assistNode != null && this.assistNodeParent == null) {	3812	if (this.assistNode != null && this.assistNodeParent == null) {
3812	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];	3813	TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
3813	if (typeParameter != null && typeParameter.type == this.assistNode)	3814	if (typeParameter != null && typeParameter.type == this.assistNode)
Lines 3855-3862 Link Here
3855	super.consumeWildcard3();	3856	super.consumeWildcard3();
3856	popElement(K_BINARY_OPERATOR);	3857	popElement(K_BINARY_OPERATOR);
3857	}	3858	}
3858	protected void consumeWildcardBoundsExtends() {	3859	protected void consumeWildcardBoundsExtends(boolean hasTypeAnnotations) {
3859	super.consumeWildcardBoundsExtends();	3860	super.consumeWildcardBoundsExtends(hasTypeAnnotations);
3860	if (this.assistNode != null && this.assistNodeParent == null) {	3861	if (this.assistNode != null && this.assistNodeParent == null) {
3861	Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];	3862	Wildcard wildcard = (Wildcard) this.genericsStack[this.genericsPtr];
3862	if (wildcard != null && wildcard.bound == this.assistNode)	3863	if (wildcard != null && wildcard.bound == this.assistNode)

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 412-422 Link Here

(-)model/org/eclipse/jdt/internal/compiler/SourceElementParser.java (-20 / +21 lines)
412	}	412	}
413	}	413	}
414		414
415	protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod) {	415	protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod, boolean hasTypeAnnotations) {
416	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];	416	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
417	int selectorSourceEnd = (int) selectorSourcePositions;	417	int selectorSourceEnd = (int) selectorSourcePositions;
418	int currentAstPtr = this.astPtr;	418	int currentAstPtr = this.astPtr;
419	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);	419	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod, hasTypeAnnotations);
420	if (this.astPtr > currentAstPtr) // if ast node was pushed on the ast stack	420	if (this.astPtr > currentAstPtr) // if ast node was pushed on the ast stack
421	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);	421	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
422	rememberCategories();	422	rememberCategories();
Lines 717-729 Link Here
717	return null;	717	return null;
718	}	718	}
719	}	719	}
720	public TypeReference getTypeReference(int dim) {	720	public TypeReference getUnannotatedTypeReference(int dim) {
721	/* build a Reference on a variable that may be qualified or not	721	/* build a Reference on a variable that may be qualified or not
722	* This variable is a type reference and dim will be its dimensions	722	* This variable is a type reference and dim will be its dimensions
723	*/	723	*/
		724	Annotation [][] annotationsOnDimensions = null;
		725	TypeReference ref;
724	int length = this.identifierLengthStack[this.identifierLengthPtr--];	726	int length = this.identifierLengthStack[this.identifierLengthPtr--];
725	if (length < 0) { //flag for precompiled type reference on base types	727	if (length < 0) { //flag for precompiled type reference on base types
726	TypeReference ref = TypeReference.baseTypeReference(-length, dim);	728	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		729	ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
727	ref.sourceStart = this.intStack[this.intPtr--];	730	ref.sourceStart = this.intStack[this.intPtr--];
728	if (dim == 0) {	731	if (dim == 0) {
729	ref.sourceEnd = this.intStack[this.intPtr--];	732	ref.sourceEnd = this.intStack[this.intPtr--];
Lines 734-745 Link Here
734	if (this.reportReferenceInfo){	737	if (this.reportReferenceInfo){
735	this.requestor.acceptTypeReference(ref.getParameterizedTypeName(), ref.sourceStart, ref.sourceEnd);	738	this.requestor.acceptTypeReference(ref.getParameterizedTypeName(), ref.sourceStart, ref.sourceEnd);
736	}	739	}
737	return ref;
738	} else {	740	} else {
739	int numberOfIdentifiers = this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr--];	741	int numberOfIdentifiers = this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr--];
740	if (length != numberOfIdentifiers \|\| this.genericsLengthStack[this.genericsLengthPtr] != 0) {	742	if (length != numberOfIdentifiers \|\| this.genericsLengthStack[this.genericsLengthPtr] != 0) {
741	// generic type	743	// generic type
742	TypeReference ref = getTypeReferenceForGenericType(dim, length, numberOfIdentifiers);	744	ref = getTypeReferenceForGenericType(dim, length, numberOfIdentifiers);
743	if (this.reportReferenceInfo) {	745	if (this.reportReferenceInfo) {
744	if (length == 1 && numberOfIdentifiers == 1) {	746	if (length == 1 && numberOfIdentifiers == 1) {
745	ParameterizedSingleTypeReference parameterizedSingleTypeReference = (ParameterizedSingleTypeReference) ref;	747	ParameterizedSingleTypeReference parameterizedSingleTypeReference = (ParameterizedSingleTypeReference) ref;
Lines 749-778 Link Here
749	this.requestor.acceptTypeReference(parameterizedQualifiedTypeReference.tokens, parameterizedQualifiedTypeReference.sourceStart, parameterizedQualifiedTypeReference.sourceEnd);	751	this.requestor.acceptTypeReference(parameterizedQualifiedTypeReference.tokens, parameterizedQualifiedTypeReference.sourceStart, parameterizedQualifiedTypeReference.sourceEnd);
750	}	752	}
751	}	753	}
752	return ref;
753	} else if (length == 1) {	754	} else if (length == 1) {
754	// single variable reference	755	// single variable reference
755	this.genericsLengthPtr--; // pop the 0	756	this.genericsLengthPtr--; // pop the 0
756	if (dim == 0) {	757	if (dim == 0) {
757	SingleTypeReference ref =	758	ref =
758	new SingleTypeReference(	759	new SingleTypeReference(
759	this.identifierStack[this.identifierPtr],	760	this.identifierStack[this.identifierPtr],
760	this.identifierPositionStack[this.identifierPtr--]);	761	this.identifierPositionStack[this.identifierPtr--]);
761	if (this.reportReferenceInfo) {	762	if (this.reportReferenceInfo) {
762	this.requestor.acceptTypeReference(ref.token, ref.sourceStart);	763	this.requestor.acceptTypeReference(((SingleTypeReference)ref).token, ref.sourceStart);
763	}	764	}
764	return ref;
765	} else {	765	} else {
766	ArrayTypeReference ref =	766	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		767	ref =
767	new ArrayTypeReference(	768	new ArrayTypeReference(
768	this.identifierStack[this.identifierPtr],	769	this.identifierStack[this.identifierPtr],
769	dim,	770	dim,
		771	annotationsOnDimensions,
770	this.identifierPositionStack[this.identifierPtr--]);	772	this.identifierPositionStack[this.identifierPtr--]);
771	ref.sourceEnd = this.endPosition;	773	ref.sourceEnd = this.endPosition;
772	if (this.reportReferenceInfo) {	774	if (this.reportReferenceInfo) {
773	this.requestor.acceptTypeReference(ref.token, ref.sourceStart);	775	this.requestor.acceptTypeReference(((ArrayTypeReference)ref).token, ref.sourceStart);
774	}	776	}
775	return ref;
776	}	777	}
777	} else {//Qualified variable reference	778	} else {//Qualified variable reference
778	this.genericsLengthPtr--;	779	this.genericsLengthPtr--;
Lines 787-808 Link Here
787	0,	788	0,
788	length);	789	length);
789	if (dim == 0) {	790	if (dim == 0) {
790	QualifiedTypeReference ref = new QualifiedTypeReference(tokens, positions);	791	ref = new QualifiedTypeReference(tokens, positions);
791	if (this.reportReferenceInfo) {	792	if (this.reportReferenceInfo) {
792	this.requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);	793	this.requestor.acceptTypeReference(((QualifiedTypeReference)ref).tokens, ref.sourceStart, ref.sourceEnd);
793	}	794	}
794	return ref;
795	} else {	795	} else {
796	ArrayQualifiedTypeReference ref =	796	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
797	new ArrayQualifiedTypeReference(tokens, dim, positions);	797	ref =
		798	new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
798	ref.sourceEnd = this.endPosition;	799	ref.sourceEnd = this.endPosition;
799	if (this.reportReferenceInfo) {	800	if (this.reportReferenceInfo) {
800	this.requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);	801	this.requestor.acceptTypeReference(((ArrayQualifiedTypeReference)ref).tokens, ref.sourceStart, ref.sourceEnd);
801	}	802	}
802	return ref;
803	}	803	}
804	}	804	}
805	}	805	}
		806	return ref;
806	}	807	}
807	public NameReference getUnspecifiedReference() {	808	public NameReference getUnspecifiedReference() {
808	/* build a (unspecified) NameReference which may be qualified*/	809	/* build a (unspecified) NameReference which may be qualified*/

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) {

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 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 1876-1898 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (-47 / +46 lines)
1876	" A2 a2;\n" +	1876	" A2 a2;\n" +
1877	"}\n"	1877	"}\n"
1878	},	1878	},
1879	"----------\n" +	1879	"----------\n" +
1880	"1. ERROR in test\\X1.java (at line 3)\n" +	1880	"1. ERROR in test\\X1.java (at line 3)\n" +
1881	" public class X1<A1 extends X2<A2> {\n" +	1881	" public class X1<A1 extends X2<A2> {\n" +
1882	" ^^\n" +	1882	" ^^\n" +
1883	"A2 cannot be resolved to a type\n" +	1883	"A2 cannot be resolved to a type\n" +
1884	"----------\n" +	1884	"----------\n" +
1885	"2. ERROR in test\\X1.java (at line 3)\n" +	1885	"2. ERROR in test\\X1.java (at line 3)\n" +
1886	" public class X1<A1 extends X2<A2> {\n" +	1886	" public class X1<A1 extends X2<A2> {\n" +
1887	" ^\n" +	1887	" ^\n" +
1888	"Syntax error, insert \">\" to complete ReferenceType1\n" +	1888	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
1889	"----------\n" +	1889	"----------\n" +
1890	"3. ERROR in test\\X1.java (at line 7)\n" +	1890	"3. ERROR in test\\X1.java (at line 7)\n" +
1891	" class X2<A2 {\n" +	1891	" class X2<A2 {\n" +
1892	" ^^\n" +	1892	" ^^\n" +
1893	"Syntax error on token \"A2\", > expected after this token\n" +	1893	"Syntax error, insert \">\" to complete TypeParameter1\n" +
1894	"----------\n"	1894	"----------\n" );
1895	);
1896	}	1895	}
1897		1896
1898	// JSR14-V10[2.4]: Not terminated consecutive declaration	1897	// JSR14-V10[2.4]: Not terminated consecutive declaration
Lines 2317-2342 Link Here
2317	"class X2<A extends X3<String> {}\n" +	2316	"class X2<A extends X3<String> {}\n" +
2318	"class X3<A {}\n"	2317	"class X3<A {}\n"
2319	},	2318	},
2320	"----------\n" +	2319	"----------\n" +
2321	"1. ERROR in test\\X.java (at line 2)\n" +	2320	"1. ERROR in test\\X.java (at line 2)\n" +
2322	" public class X<A extends X1<X2<X3<String>>> {}\n" +	2321	" public class X<A extends X1<X2<X3<String>>> {}\n" +
2323	" ^^^\n" +	2322	" ^^^\n" +
2324	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2323	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2325	"----------\n" +	2324	"----------\n" +
2326	"2. ERROR in test\\X.java (at line 3)\n" +	2325	"2. ERROR in test\\X.java (at line 3)\n" +
2327	" class X1<A extends X2<X3<String>> {}\n" +	2326	" class X1<A extends X2<X3<String>> {}\n" +
2328	" ^^\n" +	2327	" ^^\n" +
2329	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2328	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2330	"----------\n" +	2329	"----------\n" +
2331	"3. ERROR in test\\X.java (at line 4)\n" +	2330	"3. ERROR in test\\X.java (at line 4)\n" +
2332	" class X2<A extends X3<String> {}\n" +	2331	" class X2<A extends X3<String> {}\n" +
2333	" ^\n" +	2332	" ^\n" +
2334	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2333	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2335	"----------\n" +	2334	"----------\n" +
2336	"4. ERROR in test\\X.java (at line 5)\n" +	2335	"4. ERROR in test\\X.java (at line 5)\n" +
2337	" class X3<A {}\n" +	2336	" class X3<A {}\n" +
2338	" ^\n" +	2337	" ^\n" +
2339	"Syntax error on token \"A\", > expected after this token\n" +	2338	"Syntax error, insert \">\" to complete TypeParameter1\n" +
2340	"----------\n"	2339	"----------\n"
2341	);	2340	);
2342	}	2341	}
Lines 2404-2419 Link Here
2404	"class X2<A extends X3<String>> {}\n" +	2403	"class X2<A extends X3<String>> {}\n" +
2405	"class X3<A> {}\n"	2404	"class X3<A> {}\n"
2406	},	2405	},
2407	"----------\n" +	2406	"----------\n" +
2408	"1. ERROR in test\\X.java (at line 2)\n" +	2407	"1. ERROR in test\\X.java (at line 2)\n" +
2409	" public class X<A extends X1<X2<X3<String {}\n" +	2408	" public class X<A extends X1<X2<X3<String {}\n" +
2410	" ^^^^^^\n" +	2409	" ^^^^^^\n" +
2411	"Syntax error, insert \">>>\" to complete ReferenceType3\n" +	2410	"Syntax error, insert \">>>\" to complete ReferenceType3\n" +
2412	"----------\n" +	2411	"----------\n" +
2413	"2. ERROR in test\\X.java (at line 2)\n" +	2412	"2. ERROR in test\\X.java (at line 2)\n" +
2414	" public class X<A extends X1<X2<X3<String {}\n" +	2413	" public class X<A extends X1<X2<X3<String {}\n" +
2415	" ^^^^^^\n" +	2414	" ^^^^^^\n" +
2416	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2415	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2417	"----------\n");	2416	"----------\n");
2418	}	2417	}
2419	public void test0084() {	2418	public void test0084() {

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);