Attachment #149501 for bug #287648

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

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




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

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

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

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

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

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

public abstract char[] getLastToken();


	return true;
}

public boolean isParametrizedTypeReference() {
	return false;
}

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

Lines 33-38 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleTypeReference.java (-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

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




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

	int index;

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

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

Lines 178-185 Link Here

(-)grammar/java.g (-6 / +54 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 213-221 Link Here
213	BooleanLiteral -> false	216	BooleanLiteral -> false
214	/:$readableName BooleanLiteral:/	217	/:$readableName BooleanLiteral:/
215		218
216	Type ::= PrimitiveType	219	-- Type is a wrapper that automatically allows for jsr308 style
		220	-- annotations to prefix a (Java5/6) Type. If type annotations
		221	-- are illegal in a certain place, use TypeInternal instead.
		222	-- If type annotations are legal, but so are java5/6 style
		223	-- declaration annotations, use Type0 instead.
		224
		225	Type ::= TypeInternal
		226	-- consumeUnannotatedType inserts 0 at the suitable place in the type
		227	-- annotation stacks, so that the TOS(typeAnnotationsLengthStack) is the right
		228	-- length of the type annotations 0 or otherwise.
		229	/.$putCase consumeUnannotatedType(); $break ./
		230	Type ::= TypeAnnotations TypeInternal
		231	/:$compliance 1.7:/
		232	/:$readableName Type:/
		233
		234	-- Type0 is to be used in places where type annotations are legal
		235	-- but are not consumed as TypeAnnotations, but as modifiers. This
		236	-- is because from the parser's point of view there are places where
		237	-- java5/6 style declarations annotations can occur in the same place
		238	-- and it is too early to tell which is which.
		239	Type0 ::= TypeInternal
		240	-- consumeUnannotatedType inserts 0 at the suitable place in the type
		241	-- annotation stacks, so that the TOS(typeAnnotationsLengthStack) is the right
		242	-- length of the type annotations 0 or otherwise.
		243	/.$putCase consumeUnannotatedType(); $break ./
		244	/:$readableName Type:/
		245
		246	-- TypeInternal is the Java5/6 Type
		247	TypeInternal ::= PrimitiveType
217	/.$putCase consumePrimitiveType(); $break ./	248	/.$putCase consumePrimitiveType(); $break ./
218	Type -> ReferenceType	249	TypeInternal -> ReferenceType0
219	/:$readableName Type:/	250	/:$readableName Type:/
220		251
221	PrimitiveType -> NumericType	252	PrimitiveType -> NumericType
Lines 236-263 Link Here
236	FloatingPointType -> 'double'	267	FloatingPointType -> 'double'
237	/:$readableName FloatingPointType:/	268	/:$readableName FloatingPointType:/
238		269
239	ReferenceType ::= ClassOrInterfaceType	270	---------------------------- JSR308-------------------------------------------
		271	-- ReferenceType has been wrapped now, so that it can be used by itself without
		272	-- having to spell out the rule once with TypeAnnotations & once without.
		273	-- Or alternately without prefixing it with Annotationsopt (which in many contexts
		274	-- will lead to shift/reduce conflicts.) If type annotations are not legal prefixes
		275	-- to ReferenceType at some point, use ReferenceType0 instead. Otherwise reject the
		276	-- annotations in the parser.
		277
		278	ReferenceType ::= ReferenceType0
		279	-- consumeUnannotatedType inserts 0 at the suitable place in the type
		280	-- annotation stacks, so that the TOS(typeAnnotationsLengthStack) is the right
		281	-- length of the type annotations 0 or otherwise.
		282	/.$putCase consumeUnannotatedType(); $break ./
		283	ReferenceType ::= TypeAnnotations ReferenceType0
		284	/:$compliance 1.7:/
		285	/:$readableName ReferenceType:/
		286
		287	ReferenceType0 ::= ClassOrInterfaceType0
240	/.$putCase consumeReferenceType(); $break ./	288	/.$putCase consumeReferenceType(); $break ./
241	ReferenceType -> ArrayType	289	ReferenceType0 -> ArrayType
242	/:$readableName ReferenceType:/	290	/:$readableName ReferenceType:/
243		291

Lines 267-274 Link Here

(-)------------------------------------------------------------- (-30 / +159 lines)
267	-- ArrayType ::= ArrayType '[' ']'	344	-- ArrayType ::= ArrayType '[' ']'
268	--	345	--
269		346
270	ArrayTypeWithTypeArgumentsName ::= GenericType '.' Name	347	ArrayTypeWithTypeArgumentsName ::= GenericTypeDotName
271	/.$putCase consumeArrayTypeWithTypeArgumentsName(); $break ./
272	/:$readableName ArrayTypeWithTypeArgumentsName:/	348	/:$readableName ArrayTypeWithTypeArgumentsName:/
273		349
274	ArrayType ::= PrimitiveType Dims	350	ArrayType ::= PrimitiveType Dims
Lines 422-432 Link Here
422		498
423	--18.7 Only in the LALR(1) Grammar	499	--18.7 Only in the LALR(1) Grammar
424		500
		501	NonAnnotModifiers -> NonAnnotModifier
		502	NonAnnotModifiers -> NonAnnotModifiers NonAnnotModifier
		503	/.$putCase consumeModifiers2(); $break ./
		504	/:$readableName Modifiers:/
		505
425	Modifiers -> Modifier	506	Modifiers -> Modifier
426	Modifiers ::= Modifiers Modifier	507	Modifiers ::= Modifiers Modifier
427	/.$putCase consumeModifiers2(); $break ./	508	/.$putCase consumeModifiers2(); $break ./
428	/:$readableName Modifiers:/	509	/:$readableName Modifiers:/
429		510
		511	NonAnnotModifier -> 'public'
		512	NonAnnotModifier -> 'protected'
		513	NonAnnotModifier -> 'private'
		514	NonAnnotModifier -> 'static'
		515	NonAnnotModifier -> 'abstract'
		516	NonAnnotModifier -> 'final'
		517	NonAnnotModifier -> 'native'
		518	NonAnnotModifier -> 'synchronized'
		519	NonAnnotModifier -> 'transient'
		520	NonAnnotModifier -> 'volatile'
		521	NonAnnotModifier -> 'strictfp'
		522	/:$readableName Modifier:/
		523
430	Modifier -> 'public'	524	Modifier -> 'public'
431	Modifier -> 'protected'	525	Modifier -> 'protected'
432	Modifier -> 'private'	526	Modifier -> 'private'
Lines 548-554 Link Here
548	-- \| 'transient'	642	-- \| 'transient'
549	-- \| 'volatile'	643	-- \| 'volatile'
550		644
551	FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'	645	FieldDeclaration ::= Modifiersopt Type0 VariableDeclarators ';'
552	/.$putCase consumeFieldDeclaration(); $break ./	646	/.$putCase consumeFieldDeclaration(); $break ./
553	/:$readableName FieldDeclaration:/	647	/:$readableName FieldDeclaration:/
554		648
Lines 619-625 Link Here
619		713
620	MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	714	MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
621	/.$putCase consumeMethodHeaderNameWithTypeParameters(false); $break ./	715	/.$putCase consumeMethodHeaderNameWithTypeParameters(false); $break ./
622	MethodHeaderName ::= Modifiersopt Type 'Identifier' '('	716	MethodHeaderName ::= Modifiersopt Type0 'Identifier' '('
623	/.$putCase consumeMethodHeaderName(false); $break ./	717	/.$putCase consumeMethodHeaderName(false); $break ./
624	/:$readableName MethodHeaderName:/	718	/:$readableName MethodHeaderName:/
625		719
Lines 628-634 Link Here
628	/:$readableName ):/	722	/:$readableName ):/
629	/:$recovery_template ):/	723	/:$recovery_template ):/
630		724
631	MethodHeaderExtendedDims ::= Dimsopt	725	MethodHeaderExtendedDims ::= DimsoptAnnotsopt
632	/.$putCase consumeMethodHeaderExtendedDims(); $break ./	726	/.$putCase consumeMethodHeaderExtendedDims(); $break ./
633	/:$readableName MethodHeaderExtendedDims:/	727	/:$readableName MethodHeaderExtendedDims:/
634		728
Lines 636-642 Link Here
636	/.$putCase consumeMethodHeaderThrowsClause(); $break ./	730	/.$putCase consumeMethodHeaderThrowsClause(); $break ./
637	/:$readableName MethodHeaderThrowsClause:/	731	/:$readableName MethodHeaderThrowsClause:/
638		732
639	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderThrowsClauseopt	733	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen Annotationsopt MethodHeaderThrowsClauseopt
640	/.$putCase consumeConstructorHeader(); $break ./	734	/.$putCase consumeConstructorHeader(); $break ./
641	/:$readableName ConstructorDeclaration:/	735	/:$readableName ConstructorDeclaration:/
642		736
Lines 651-660 Link Here
651	/.$putCase consumeFormalParameterList(); $break ./	745	/.$putCase consumeFormalParameterList(); $break ./
652	/:$readableName FormalParameterList:/	746	/:$readableName FormalParameterList:/
653		747
		748	PotentialNameArray -> $empty
		749	/.$putCase consumePotentialNameArrayType(); $break ./
		750	/:$readableName PotentialNameArray:/
		751
654	--1.1 feature	752	--1.1 feature
655	FormalParameter ::= Modifiersopt Type VariableDeclaratorId	753	--FormalParameter ::= Modifiersopt Type VariableDeclaratorId
		754	--FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId
		755	--The above rules have been rewritten by inlinng the type subgrammar
		756	--to avoid the conflicts resulting from jsr308 changes.
		757	FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt VariableDeclaratorId
		758	/.$putCase consumeFormalParameter(false); $break ./
		759	FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt '...' VariableDeclaratorId
		760	/.$putCase consumeFormalParameter(true); $break ./
		761	/:$compliance 1.5:/
		762	FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray VariableDeclaratorId
		763	/.$putCase consumeFormalParameter(false); $break ./
		764	FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray '...' VariableDeclaratorId
		765	/.$putCase consumeFormalParameter(true); $break ./
		766	/:$compliance 1.5:/
		767	FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt VariableDeclaratorId
		768	/.$putCase consumeFormalParameter(false); $break ./
		769	FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt '...' VariableDeclaratorId
		770	/.$putCase consumeFormalParameter(true); $break ./
		771	/:$compliance 1.5:/
		772	FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt VariableDeclaratorId
656	/.$putCase consumeFormalParameter(false); $break ./	773	/.$putCase consumeFormalParameter(false); $break ./
657	FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId	774	FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt '...' VariableDeclaratorId
658	/.$putCase consumeFormalParameter(true); $break ./	775	/.$putCase consumeFormalParameter(true); $break ./
659	/:$readableName FormalParameter:/	776	/:$readableName FormalParameter:/
660	/:$compliance 1.5:/	777	/:$compliance 1.5:/
Lines 865-877 Link Here
865	/.$putCase consumeLocalVariableDeclarationStatement(); $break ./	982	/.$putCase consumeLocalVariableDeclarationStatement(); $break ./
866	/:$readableName LocalVariableDeclarationStatement:/	983	/:$readableName LocalVariableDeclarationStatement:/
867		984
868	LocalVariableDeclaration ::= Type PushModifiers VariableDeclarators	985	LocalVariableDeclaration ::= Type0 PushModifiers VariableDeclarators
869	/.$putCase consumeLocalVariableDeclaration(); $break ./	986	/.$putCase consumeLocalVariableDeclaration(); $break ./
870	-- 1.1 feature	987	-- 1.1 feature
871	-- The modifiers part of this rule makes the grammar more permissive.	988	-- The modifiers part of this rule makes the grammar more permissive.
872	-- The only modifier here is final. We put Modifiers to allow multiple modifiers	989	-- The only modifier here is final. We put Modifiers to allow multiple modifiers
873	-- This will require to check the validity of the modifier	990	-- This will require to check the validity of the modifier
874	LocalVariableDeclaration ::= Modifiers Type PushRealModifiers VariableDeclarators	991	LocalVariableDeclaration ::= Modifiers Type0 PushRealModifiers VariableDeclarators
875	/.$putCase consumeLocalVariableDeclaration(); $break ./	992	/.$putCase consumeLocalVariableDeclaration(); $break ./
876	/:$readableName LocalVariableDeclaration:/	993	/:$readableName LocalVariableDeclaration:/
877		994
Lines 1108-1113 Link Here
1108	/.$putCase consumeLeftParen(); $break ./	1225	/.$putCase consumeLeftParen(); $break ./
1109	/:$readableName (:/	1226	/:$readableName (:/
1110	/:$recovery_template (:/	1227	/:$recovery_template (:/
		1228	PushRPARENForUnannotatedTypeCast ::= ')'
		1229	/.$putCase consumeRightParenForUnannotatedTypeCast(); $break ./
		1230	/:$readableName ):/
		1231	/:$recovery_template ):/
1111	PushRPAREN ::= ')'	1232	PushRPAREN ::= ')'
1112	/.$putCase consumeRightParen(); $break ./	1233	/.$putCase consumeRightParen(); $break ./
1113	/:$readableName ):/	1234	/:$readableName ):/
Lines 1131-1136 Link Here
1131	PrimaryNoNewArray -> ClassInstanceCreationExpression	1252	PrimaryNoNewArray -> ClassInstanceCreationExpression
1132	PrimaryNoNewArray -> FieldAccess	1253	PrimaryNoNewArray -> FieldAccess
1133	--1.1 feature	1254	--1.1 feature
		1255	-- javac doesn't permit type annotations here.
1134	PrimaryNoNewArray ::= Name '.' 'this'	1256	PrimaryNoNewArray ::= Name '.' 'this'
1135	/.$putCase consumePrimaryNoNewArrayNameThis(); $break ./	1257	/.$putCase consumePrimaryNoNewArrayNameThis(); $break ./
1136	PrimaryNoNewArray ::= Name '.' 'super'	1258	PrimaryNoNewArray ::= Name '.' 'super'
Lines 1217-1234 Link Here
1217	/.$putCase consumeArgumentList(); $break ./	1339	/.$putCase consumeArgumentList(); $break ./
1218	/:$readableName ArgumentList:/	1340	/:$readableName ArgumentList:/
1219		1341
		1342	-- ArrayCreationHeader is used only in recovery and the consume* method is a NOP.
1220	ArrayCreationHeader ::= 'new' PrimitiveType DimWithOrWithOutExprs	1343	ArrayCreationHeader ::= 'new' PrimitiveType DimWithOrWithOutExprs
1221	/.$putCase consumeArrayCreationHeader(); $break ./	1344	/.$putCase consumeArrayCreationHeader(); $break ./
1222		1345	ArrayCreationHeader ::= 'new' TypeAnnotations PrimitiveType DimWithOrWithOutExprs
		1346	/:$compliance 1.7:/
		1347	/.$putCase consumeArrayCreationHeader(); $break ./
1223	ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs	1348	ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
1224	/.$putCase consumeArrayCreationHeader(); $break ./	1349	/.$putCase consumeArrayCreationHeader(); $break ./
1225	/:$readableName ArrayCreationHeader:/	1350	/:$readableName ArrayCreationHeader:/
1226		1351
1227	ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs	1352	ArrayCreationWithoutArrayInitializer ::= 'new' PushZeroTypeAnnotations PrimitiveType DimWithOrWithOutExprs
		1353	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./
		1354	ArrayCreationWithoutArrayInitializer ::= 'new' TypeAnnotations PrimitiveType DimWithOrWithOutExprs
		1355	/:$compliance 1.7:/
1228	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./	1356	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./
1229	/:$readableName ArrayCreationWithoutArrayInitializer:/	1357	/:$readableName ArrayCreationWithoutArrayInitializer:/
1230		1358
1231	ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer	1359	ArrayCreationWithArrayInitializer ::= 'new' PushZeroTypeAnnotations PrimitiveType DimWithOrWithOutExprs ArrayInitializer
		1360	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./
		1361	ArrayCreationWithArrayInitializer ::= 'new' TypeAnnotations PrimitiveType DimWithOrWithOutExprs ArrayInitializer
		1362	/:$compliance 1.7:/
1232	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./	1363	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./
1233	/:$readableName ArrayCreationWithArrayInitializer:/	1364	/:$readableName ArrayCreationWithArrayInitializer:/
1234		1365
Lines 1243-1254 Link Here
1243	/.$putCase consumeDimWithOrWithOutExprs(); $break ./	1374	/.$putCase consumeDimWithOrWithOutExprs(); $break ./
1244	/:$readableName Dimensions:/	1375	/:$readableName Dimensions:/
1245		1376
1246	DimWithOrWithOutExpr ::= '[' Expression ']'	1377	DimWithOrWithOutExpr ::= '[' PushZeroTypeAnnotations Expression ']'
1247	DimWithOrWithOutExpr ::= '[' ']'	1378	DimWithOrWithOutExpr ::= TypeAnnotations '[' Expression ']'
1248	/. $putCase consumeDimWithOrWithOutExpr(); $break ./	1379	/:$compliance 1.7:/
		1380	DimWithOrWithOutExpr ::= '[' PushZeroTypeAnnotations ']'
		1381	/. $putCase consumeDimWithOutExpr(); $break ./
		1382	DimWithOrWithOutExpr ::= TypeAnnotations '[' ']'
		1383	/. $putCase consumeDimWithOutExpr(); $break ./
		1384	/:$compliance 1.7:/
1249	/:$readableName Dimension:/	1385	/:$readableName Dimension:/
1250	-- -----------------------------------------------	1386	-- -----------------------------------------------
1251		1387
		1388	-- jsr 308
		1389
		1390	DimsoptAnnotsopt -> $empty
		1391	/. $putCase consumeEmptyDimsoptAnnotsopt(); $break ./
		1392	/:$readableName AnnotationsDimensionsSequence:/
		1393	DimsoptAnnotsopt -> DimsAnnotLoop
		1394	/. $putCase consumeDimsWithTrailingAnnotsopt(); $break ./
		1395	/:$readableName Dimensionsoptannotsopt:/
		1396	DimsAnnotLoop ::= OneDimOrAnnot
		1397	DimsAnnotLoop ::= DimsAnnotLoop OneDimOrAnnot
		1398	/:$readableName DimsAnnotLoop:/
		1399
		1400	OneDimOrAnnot ::= Annotation
		1401	/. $putCase consumeTypeAnnotation(true); $break ./
		1402	-- Complain if source level < 1.7
		1403	/:$compliance 1.7:/
		1404	OneDimOrAnnot -> '[' ']'
		1405	/. $putCase consumeOneDimLoop(true); $break ./
		1406	-- Bump up dimensions && mark zero annotations.
		1407	/:$readableName OneDimensionOrAnnotation:/
		1408
		1409	TypeAnnotations ::= Annotation
		1410	/. $putCase consumeTypeAnnotation(false); $break ./
		1411	/:$compliance 1.7:/
		1412	TypeAnnotations ::= TypeAnnotations Annotation
		1413	/. $putCase consumeOneMoreTypeAnnotation(); $break ./
		1414	/:$compliance 1.7:/
		1415	/:$readableName TypeAnnotations:/
		1416
1252	Dims ::= DimsLoop	1417	Dims ::= DimsLoop
1253	/. $putCase consumeDims(); $break ./	1418	/. $putCase consumeDims(); $break ./
1254	/:$readableName Dimensions:/	1419	/:$readableName Dimensions:/
Lines 1256-1263 Link Here
1256	DimsLoop ::= DimsLoop OneDimLoop	1421	DimsLoop ::= DimsLoop OneDimLoop
1257	/:$readableName Dimensions:/	1422	/:$readableName Dimensions:/
1258	OneDimLoop ::= '[' ']'	1423	OneDimLoop ::= '[' ']'
1259	/. $putCase consumeOneDimLoop(); $break ./	1424	/. $putCase consumeOneDimLoop(false); $break ./
		1425	-- Bump up dimensions && mark zero annotations.
1260	/:$readableName Dimension:/	1426	/:$readableName Dimension:/
		1427	OneDimLoop ::= TypeAnnotations '[' ']'
		1428	/:$compliance 1.7:/
		1429	/. $putCase consumeOneDimLoopWithAnnotations(); $break ./
		1430	-- Bump up dimensions
		1431	/:$readableName DimensionWithAnnotations:/
1261		1432
1262	FieldAccess ::= Primary '.' 'Identifier'	1433	FieldAccess ::= Primary '.' 'Identifier'
1263	/.$putCase consumeFieldAccess(false); $break ./	1434	/.$putCase consumeFieldAccess(false); $break ./
Lines 1338-1352 Link Here
1338	UnaryExpressionNotPlusMinus -> CastExpression	1509	UnaryExpressionNotPlusMinus -> CastExpression
1339	/:$readableName Expression:/	1510	/:$readableName Expression:/
1340		1511
1341	CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression	1512	CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPARENForUnannotatedTypeCast InsideCastExpression UnaryExpression
1342	/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./	1513	/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./
1343	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	1514	CastExpression ::= PushLPAREN TypeAnnotations PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression
		1515	/:$compliance 1.7:/
		1516	/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./
		1517	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPARENForUnannotatedTypeCast InsideCastExpression UnaryExpressionNotPlusMinus
		1518	/.$putCase consumeCastExpressionWithGenericsArray(); $break ./
		1519	CastExpression ::= PushLPAREN TypeAnnotations Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
		1520	/:$compliance 1.7:/
1344	/.$putCase consumeCastExpressionWithGenericsArray(); $break ./	1521	/.$putCase consumeCastExpressionWithGenericsArray(); $break ./
1345	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus	1522	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType0 Dimsopt PushRPARENForUnannotatedTypeCast InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus
1346	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./	1523	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./
1347	CastExpression ::= PushLPAREN Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus	1524	CastExpression ::= PushLPAREN TypeAnnotations Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType0 Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus
		1525	/:$compliance 1.7:/
		1526	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./
		1527	CastExpression ::= PushLPAREN Name PushRPAREN PushZeroTypeAnnotations InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
		1528	/.$putCase consumeCastExpressionLL1(); $break ./
		1529	CastExpression ::= PushLPAREN TypeAnnotations Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
		1530	/:$compliance 1.7:/
1348	/.$putCase consumeCastExpressionLL1(); $break ./	1531	/.$putCase consumeCastExpressionLL1(); $break ./
1349	CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	1532	CastExpression ::= PushLPAREN Name Dims PushRPARENForUnannotatedTypeCast InsideCastExpression UnaryExpressionNotPlusMinus
		1533	/.$putCase consumeCastExpressionWithNameArray(); $break ./
		1534	CastExpression ::= PushLPAREN TypeAnnotations Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
		1535	/:$compliance 1.7:/
1350	/.$putCase consumeCastExpressionWithNameArray(); $break ./	1536	/.$putCase consumeCastExpressionWithNameArray(); $break ./
1351	/:$readableName CastExpression:/	1537	/:$readableName CastExpression:/
1352		1538
Lines 1526-1531 Link Here
1526	/.$putCase consumeClassBodyDeclarationsopt(); $break ./	1712	/.$putCase consumeClassBodyDeclarationsopt(); $break ./
1527	/:$readableName ClassBodyDeclarations:/	1713	/:$readableName ClassBodyDeclarations:/
1528		1714
		1715	NonAnnotModifiersopt ::= $empty
		1716	/. $putCase consumeDefaultModifiers(); $break ./
		1717	NonAnnotModifiersopt ::= NonAnnotModifiers
		1718	/.$putCase consumeModifiers(); $break ./
		1719	/:$readableName Modifiers:/
		1720
1529	Modifiersopt ::= $empty	1721	Modifiersopt ::= $empty
1530	/. $putCase consumeDefaultModifiers(); $break ./	1722	/. $putCase consumeDefaultModifiers(); $break ./
1531	Modifiersopt ::= Modifiers	1723	Modifiersopt ::= Modifiers
Lines 1666-1676 Link Here
1666	/.$putCase consumeEnhancedForStatement(); $break ./	1858	/.$putCase consumeEnhancedForStatement(); $break ./
1667	/:$readableName EnhancedForStatementNoShortIf:/	1859	/:$readableName EnhancedForStatementNoShortIf:/
1668		1860
1669	EnhancedForStatementHeaderInit ::= 'for' '(' Type PushModifiers Identifier Dimsopt	1861	EnhancedForStatementHeaderInit ::= 'for' '(' Type0 PushModifiers Identifier Dimsopt
1670	/.$putCase consumeEnhancedForStatementHeaderInit(false); $break ./	1862	/.$putCase consumeEnhancedForStatementHeaderInit(false); $break ./
1671	/:$readableName EnhancedForStatementHeaderInit:/	1863	/:$readableName EnhancedForStatementHeaderInit:/
1672		1864
1673	EnhancedForStatementHeaderInit ::= 'for' '(' Modifiers Type PushRealModifiers Identifier Dimsopt	1865	EnhancedForStatementHeaderInit ::= 'for' '(' Modifiers Type0 PushRealModifiers Identifier Dimsopt
1674	/.$putCase consumeEnhancedForStatementHeaderInit(true); $break ./	1866	/.$putCase consumeEnhancedForStatementHeaderInit(true); $break ./
1675	/:$readableName EnhancedForStatementHeaderInit:/	1867	/:$readableName EnhancedForStatementHeaderInit:/
1676		1868
Lines 1745-1752 Link Here
1745	/:$compliance 1.5:/	1937	/:$compliance 1.5:/
1746	ReferenceType1 ::= ClassOrInterface '<' TypeArgumentList2	1938	ReferenceType1 ::= ClassOrInterface '<' TypeArgumentList2
1747	/.$putCase consumeTypeArgumentReferenceType1(); $break ./	1939	/.$putCase consumeTypeArgumentReferenceType1(); $break ./
1748	/:$readableName ReferenceType1:/
1749	/:$compliance 1.5:/	1940	/:$compliance 1.5:/
		1941	ReferenceType1 ::= TypeAnnotations ClassOrInterface '<' TypeArgumentList2 PopZeroTypeAnnotations
		1942	/:$compliance 1.7:/
		1943	/.$putCase consumeTypeArgumentReferenceType1(); $break ./
		1944	/:$readableName ReferenceType1:/
1750		1945
1751	TypeArgumentList2 -> TypeArgument2	1946	TypeArgumentList2 -> TypeArgument2
1752	/:$compliance 1.5:/	1947	/:$compliance 1.5:/
Lines 1766-1773 Link Here
1766	/:$compliance 1.5:/	1961	/:$compliance 1.5:/
1767	ReferenceType2 ::= ClassOrInterface '<' TypeArgumentList3	1962	ReferenceType2 ::= ClassOrInterface '<' TypeArgumentList3
1768	/.$putCase consumeTypeArgumentReferenceType2(); $break ./	1963	/.$putCase consumeTypeArgumentReferenceType2(); $break ./
1769	/:$readableName ReferenceType2:/
1770	/:$compliance 1.5:/	1964	/:$compliance 1.5:/
		1965	ReferenceType2 ::= TypeAnnotations ClassOrInterface '<' TypeArgumentList3 PopZeroTypeAnnotations
		1966	/:$compliance 1.7:/
		1967	/.$putCase consumeTypeArgumentReferenceType2(); $break ./
		1968	/:$readableName ReferenceType2:/
1771		1969
1772	TypeArgumentList3 -> TypeArgument3	1970	TypeArgumentList3 -> TypeArgument3
1773	TypeArgumentList3 ::= TypeArgumentList ',' TypeArgument3	1971	TypeArgumentList3 ::= TypeArgumentList ',' TypeArgument3
Lines 1849-1858 Link Here
1849	/:$readableName WildcardBound3:/	2047	/:$readableName WildcardBound3:/
1850	/:$compliance 1.5:/	2048	/:$compliance 1.5:/
1851		2049
1852	TypeParameterHeader ::= Identifier	2050	PushZeroTypeAnnotations ::= $empty
		2051	/.$putCase consumeZeroTypeAnnotations(true); $break ./
		2052	/:$readableName ZeroTypeAnnotations:/
		2053
		2054	TypeParameterHeader ::= PushZeroTypeAnnotations Identifier
1853	/.$putCase consumeTypeParameterHeader(); $break ./	2055	/.$putCase consumeTypeParameterHeader(); $break ./
1854	/:$readableName TypeParameter:/
1855	/:$compliance 1.5:/	2056	/:$compliance 1.5:/
		2057	TypeParameterHeader ::= TypeAnnotations Identifier
		2058	/:$compliance 1.7:/
		2059	/.$putCase consumeTypeParameterHeader(); $break ./
		2060	/:$readableName TypeParameter:/
1856		2061
1857	TypeParameters ::= '<' TypeParameterList1	2062	TypeParameters ::= '<' TypeParameterList1
1858	/.$putCase consumeTypeParameters(); $break ./	2063	/.$putCase consumeTypeParameters(); $break ./
Lines 2119-2125 Link Here
2119		2324
2120	AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	2325	AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
2121	/.$putCase consumeMethodHeaderNameWithTypeParameters(true); $break ./	2326	/.$putCase consumeMethodHeaderNameWithTypeParameters(true); $break ./
2122	AnnotationMethodHeaderName ::= Modifiersopt Type 'Identifier' '('	2327	AnnotationMethodHeaderName ::= Modifiersopt Type0 'Identifier' '('
2123	/.$putCase consumeMethodHeaderName(true); $break ./	2328	/.$putCase consumeMethodHeaderName(true); $break ./
2124	/:$readableName MethodHeaderName:/	2329	/:$readableName MethodHeaderName:/
2125	/:$compliance 1.5:/	2330	/:$compliance 1.5:/
Lines 2262-2268 Link Here
2262	RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	2467	RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
2263	/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(); $break ./	2468	/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(); $break ./
2264	/:$compliance 1.5:/	2469	/:$compliance 1.5:/
2265	RecoveryMethodHeaderName ::= Modifiersopt Type 'Identifier' '('	2470	RecoveryMethodHeaderName ::= Modifiersopt Type0 'Identifier' '('
2266	/.$putCase consumeRecoveryMethodHeaderName(); $break ./	2471	/.$putCase consumeRecoveryMethodHeaderName(); $break ./
2267	/:$readableName MethodHeaderName:/	2472	/:$readableName MethodHeaderName:/
2268		2473
Lines 2331-2333 Link Here
2331		2536
2332	$end	2537	$end
2333	-- need a carriage return after the $end	2538	-- need a carriage return after the $end
		2539




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

Lines 830-835 Link Here

(-)model/org/eclipse/jdt/internal/compiler/DocumentElementParser.java (-3 / +15 lines)
830	// MethodHeaderExtendedDims ::= Dimsopt	830	// MethodHeaderExtendedDims ::= Dimsopt
831	// now we update the returnType of the method	831	// now we update the returnType of the method
832	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];	832	MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
		833	// jsr308 -- consume receiver annotations
		834	md.receiverAnnotations = null;
		835	int length;
		836	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		837	System.arraycopy(
		838	this.typeAnnotationStack,
		839	(this.typeAnnotationPtr -= length) + 1,
		840	md.receiverAnnotations = new Annotation[length],
		841	0,
		842	length);
		843	}
833	int extendedDims = this.intStack[this.intPtr--];	844	int extendedDims = this.intStack[this.intPtr--];
834	this.extendsDim = extendedDims;	845	this.extendsDim = extendedDims;
835	if (extendedDims != 0) {	846	if (extendedDims != 0) {
Lines 1357-1363 Link Here
1357	* This variable is a type reference and dim will be its dimensions.	1368	* This variable is a type reference and dim will be its dimensions.
1358	* We don't have any side effect on the stacks' pointers.	1369	* We don't have any side effect on the stacks' pointers.
1359	*/	1370	*/
1360		1371	Annotation [][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
1361	int length;	1372	int length;
1362	TypeReference ref;	1373	TypeReference ref;
1363	if ((length = this.identifierLengthStack[localIdentifierLengthPtr]) == 1) {	1374	if ((length = this.identifierLengthStack[localIdentifierLengthPtr]) == 1) {
Lines 1372-1383 Link Here
1372	new ArrayTypeReference(	1383	new ArrayTypeReference(
1373	this.identifierStack[localIdentifierPtr],	1384	this.identifierStack[localIdentifierPtr],
1374	dim,	1385	dim,
		1386	annotationsOnDimensions,
1375	this.identifierPositionStack[localIdentifierPtr--]);	1387	this.identifierPositionStack[localIdentifierPtr--]);
1376	ref.sourceEnd = this.endPosition;	1388	ref.sourceEnd = this.endPosition;
1377	}	1389	}
1378	} else {	1390	} else {
1379	if (length < 0) { //flag for precompiled type reference on base types	1391	if (length < 0) { //flag for precompiled type reference on base types
1380	ref = TypeReference.baseTypeReference(-length, dim);	1392	ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
1381	ref.sourceStart = this.intStack[this.localIntPtr--];	1393	ref.sourceStart = this.intStack[this.localIntPtr--];
1382	if (dim == 0) {	1394	if (dim == 0) {
1383	ref.sourceEnd = this.intStack[this.localIntPtr--];	1395	ref.sourceEnd = this.intStack[this.localIntPtr--];
Lines 1399-1405 Link Here
1399	if (dim == 0)	1411	if (dim == 0)
1400	ref = new QualifiedTypeReference(tokens, positions);	1412	ref = new QualifiedTypeReference(tokens, positions);
1401	else	1413	else
1402	ref = new ArrayQualifiedTypeReference(tokens, dim, positions);	1414	ref = new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
1403	}	1415	}
1404	}	1416	}
1405	return ref;	1417	return ref;




		this.nodeSet.addTrustedMatch(result, true);
	return result;
}
protected TypeReference copyDims(TypeReference typeRef, int dim, Annotation [][] annotationsOnDimensions) {
	TypeReference result = super.copyDims(typeRef, dim, annotationsOnDimensions);
	 if (this.nodeSet.removePossibleMatch(typeRef) != null)
		this.nodeSet.addPossibleMatch(result);
	 else if (this.nodeSet.removeTrustedMatch(typeRef) != null)
		this.nodeSet.addTrustedMatch(result, true);
	return result;
}
protected TypeReference getUnannotatedTypeReference(int dim) {
	TypeReference typeRef = super.getUnannotatedTypeReference(dim);
	if (this.patternFineGrain == 0) {
		this.patternLocator.match(typeRef, this.nodeSet); // NB: Don't check container since type reference can happen anywhere
	}

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

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (-1 / +16 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 2441-2446 Link Here
2441	}	2442	}
2442	}	2443	}
2443	protected void consumeFormalParameter(boolean isVarArgs) {	2444	protected void consumeFormalParameter(boolean isVarArgs) {
		2445
		2446	this.invocationType = NO_RECEIVER;
		2447	this.qualifier = -1;
		2448
2444	if (this.indexOfAssistIdentifier() < 0) {	2449	if (this.indexOfAssistIdentifier() < 0) {
2445	super.consumeFormalParameter(isVarArgs);	2450	super.consumeFormalParameter(isVarArgs);
2446	if (this.pendingAnnotation != null) {	2451	if (this.pendingAnnotation != null) {
Lines 4200-4205 Link Here
4200	}	4205	}
4201	return result;	4206	return result;
4202	}	4207	}
		4208	protected TypeReference copyDims(TypeReference typeRef, int dim, Annotation[][] annotationsOnDimensions) {
		4209	if (this.assistNode == typeRef) {
		4210	return typeRef;
		4211	}
		4212	TypeReference result = super.copyDims(typeRef, dim, annotationsOnDimensions);
		4213	if (this.assistNodeParent == typeRef) {
		4214	this.assistNodeParent = result;
		4215	}
		4216	return result;
		4217	}
4203	public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int cursorLoc) {	4218	public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int cursorLoc) {
4204		4219
4205	this.cursorLocation = cursorLoc;	4220	this.cursorLocation = cursorLoc;

Lines 55-60 Link Here

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

Lines 11-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java (-446 / +991 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 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 = getTypeReference(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 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-3823 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	}
		4011	}
		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	}
3820	}	4032	}
		4033	return dimensionsAnnotations;
3821	}	4034	}
3822	protected void consumeFormalParameterList() {	4035	protected void consumeFormalParameterList() {
3823	// FormalParameterList ::= FormalParameterList ',' FormalParameter	4036	// FormalParameterList ::= FormalParameterList ',' FormalParameter
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 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 -> '[' ']'
4789	this.dimensions++;	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 '[' ']'
		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-4980 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);
		5244	pushOnTypeAnnotationLengthStack(0); // javac complains on annotations here.
4978	TypeReference typeReference = getTypeReference(0);	5245	TypeReference typeReference = getTypeReference(0);
4979		5246
4980	pushOnExpressionStack(	5247	pushOnExpressionStack(
Lines 4988-4994 Link Here
4988	// handle type arguments	5255	// handle type arguments
4989	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);	5256	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4990	pushOnGenericsLengthStack(0); // handle type arguments	5257	pushOnGenericsLengthStack(0); // handle type arguments
4991		5258	pushOnTypeAnnotationLengthStack(0); // javac complains on annotations here.
4992	TypeReference typeReference = getTypeReference(0);	5259	TypeReference typeReference = getTypeReference(0);
4993		5260
4994	pushOnExpressionStack(	5261	pushOnExpressionStack(
Lines 5001-5013 Link Here
5001	// PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class'	5268	// PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class'
5002	this.intPtr--; // remove the class start position	5269	this.intPtr--; // remove the class start position
5003	pushOnExpressionStack(	5270	pushOnExpressionStack(
5004	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));	5271	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(this.intStack[this.intPtr--])));
5005	}	5272	}
5006	protected void consumePrimaryNoNewArrayPrimitiveType() {	5273	protected void consumePrimaryNoNewArrayPrimitiveType() {
5007	// PrimaryNoNewArray ::= PrimitiveType '.' 'class'	5274	// PrimaryNoNewArray ::= PrimitiveType '.' 'class'
5008	this.intPtr--; // remove the class start position	5275	this.intPtr--; // remove the class start position
5009	pushOnExpressionStack(	5276	pushOnExpressionStack(
5010	new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(0)));	5277	new ClassLiteralAccess(this.intStack[this.intPtr--], getUnannotatedTypeReference(0)));
5011	}	5278	}
5012	protected void consumePrimaryNoNewArrayThis() {	5279	protected void consumePrimaryNoNewArrayThis() {
5013	// PrimaryNoNewArray ::= 'this'	5280	// PrimaryNoNewArray ::= 'this'
Lines 5123-6806 Link Here
5123	// PushRPAREN ::= ')'	5390	// PushRPAREN ::= ')'
5124	pushOnIntStack(this.rParenPos);	5391	pushOnIntStack(this.rParenPos);
5125	}	5392	}
		5393	protected void consumeUnannotatedType() {
		5394	/* We go through some song & dance here to get the type annotations stacks
		5395	to reflect the fact that this type was unannotated. Using a dummy non-terminal
		5396	with an empty rhs leads to conflicts in many places :-(
		5397	*/
		5398	pushOnTypeAnnotationLengthStack(0); // either done or else made room.
		5399	int dims = this.intStack[this.intPtr];
		5400	if (dims != 0) {
		5401	System.arraycopy(this.typeAnnotationLengthStack,
		5402	this.typeAnnotationLengthPtr - dims,
		5403	this.typeAnnotationLengthStack,
		5404	this.typeAnnotationLengthPtr - dims + 1,
		5405	dims);
		5406	this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr - dims] = 0; // tag type as unannotated
		5407	}
		5408	}
		5409	protected void consumeTypeAnnotation (boolean markAsUnattached) {
		5410	if(!this.statementRecoveryActivated &&
		5411	this.options.sourceLevel < ClassFileConstants.JDK1_7 &&
		5412	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		5413	problemReporter().invalidUsageOfTypeAnnotations((Annotation) this.expressionStack[this.expressionPtr]);
		5414	}
		5415	this.expressionLengthPtr --;
		5416	Annotation annotation = (Annotation) this.expressionStack[this.expressionPtr--];
		5417	pushOnTypeAnnotationStack(annotation);
		5418	if (markAsUnattached) {
		5419	if (this.unattachedAnnotationPtr == -1) {
		5420	this.unattachedAnnotationPtr = this.typeAnnotationPtr;
		5421	} else {
		5422	this.typeAnnotationLengthStack[--this.typeAnnotationLengthPtr]++;
		5423	}
		5424	}
		5425	}
		5426	protected void consumeDimsWithTrailingAnnotsopt() {
		5427	// DimsoptAnnotsopt -> DimsAnnotLoop
		5428	pushOnIntStack(this.dimensions);
		5429	this.dimensions = 0;
		5430	if (this.unattachedAnnotationPtr == -1) {
		5431	pushOnTypeAnnotationLengthStack(0); // no trailing annotations (receiver/vararg)
		5432	} else {
		5433	this.unattachedAnnotationPtr = -1; // reset this and leave the annotation stacks as they are.
		5434	}
		5435	}
		5436	protected void consumeZeroTypeAnnotations(boolean shouldPush) {
		5437	if (shouldPush) {
		5438	pushOnTypeAnnotationLengthStack(0);
		5439	} else {
		5440	this.typeAnnotationLengthPtr --; // pop the 0 from the length stack
		5441	}
		5442	}
		5443	protected void consumeEmptyDimsoptAnnotsopt() {
		5444	// DimsoptAnnotsopt ::= $empty
		5445	pushOnIntStack(0); // signal a non array
		5446	pushOnTypeAnnotationLengthStack(0); // no trailing annotations (receiver/vararg)
		5447	}
		5448	protected void consumeRightParenForUnannotatedTypeCast() {
		5449	consumeUnannotatedType();
		5450	// PushRPAREN ::= ')'
		5451	pushOnIntStack(this.rParenPos);
		5452	}
5126	// This method is part of an automatic generation : do NOT edit-modify	5453	// This method is part of an automatic generation : do NOT edit-modify
5127	protected void consumeRule(int act) {	5454	protected void consumeRule(int act) {
5128	switch ( act ) {	5455	switch ( act ) {
5129	case 30 : if (DEBUG) { System.out.println("Type ::= PrimitiveType"); } //$NON-NLS-1$	5456	case 30 : if (DEBUG) { System.out.println("Type ::= TypeInternal"); } //$NON-NLS-1$
		5457	consumeUnannotatedType();
		5458	break;
		5459
		5460	case 32 : if (DEBUG) { System.out.println("Type0 ::= TypeInternal"); } //$NON-NLS-1$
		5461	consumeUnannotatedType();
		5462	break;
		5463
		5464	case 33 : if (DEBUG) { System.out.println("TypeInternal ::= PrimitiveType"); } //$NON-NLS-1$
5130	consumePrimitiveType();	5465	consumePrimitiveType();
5131	break;	5466	break;
5132		5467
5133	case 44 : if (DEBUG) { System.out.println("ReferenceType ::= ClassOrInterfaceType"); } //$NON-NLS-1$	5468	case 47 : if (DEBUG) { System.out.println("ReferenceType ::= ReferenceType0"); } //$NON-NLS-1$
		5469	consumeUnannotatedType();
		5470	break;
		5471
		5472	case 49 : if (DEBUG) { System.out.println("ReferenceType0 ::= ClassOrInterfaceType0"); } //$NON-NLS-1$
5134	consumeReferenceType();	5473	consumeReferenceType();
5135	break;	5474	break;
5136		5475
5137	case 48 : if (DEBUG) { System.out.println("ClassOrInterface ::= Name"); } //$NON-NLS-1$	5476	case 51 : if (DEBUG) { System.out.println("Annotationsopt ::="); } //$NON-NLS-1$
		5477	consumeZeroTypeAnnotations(true);
		5478	break;
		5479
		5480	case 56 : if (DEBUG) { System.out.println("ClassOrInterface ::= ClassOrInterface0"); } //$NON-NLS-1$
		5481	consumeZeroTypeAnnotations(true);
		5482	break;
		5483
		5484	case 57 : if (DEBUG) { System.out.println("ClassOrInterface0 ::= Name"); } //$NON-NLS-1$
5138	consumeClassOrInterfaceName();	5485	consumeClassOrInterfaceName();
5139	break;	5486	break;
5140		5487
5141	case 49 : if (DEBUG) { System.out.println("ClassOrInterface ::= GenericType DOT Name"); } //$NON-NLS-1$	5488	case 59 : if (DEBUG) { System.out.println("PopZeroTypeAnnotations ::="); } //$NON-NLS-1$
5142	consumeClassOrInterface();	5489	consumeZeroTypeAnnotations(false);
5143	break;	5490	break;
5144		5491
5145	case 50 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); } //$NON-NLS-1$	5492	case 60 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments..."); } //$NON-NLS-1$
5146	consumeGenericType();	5493	consumeGenericType();
5147	break;	5494	break;
5148		5495
5149	case 51 : if (DEBUG) { System.out.println("ArrayTypeWithTypeArgumentsName ::= GenericType DOT Name"); } //$NON-NLS-1$	5496	case 61 : if (DEBUG) { System.out.println("GenericTypeDotName ::= GenericType DOT Name"); } //$NON-NLS-1$
5150	consumeArrayTypeWithTypeArgumentsName();	5497	consumeClassOrInterface();
5151	break;	5498	break;
5152		5499
5153	case 52 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); } //$NON-NLS-1$	5500	case 63 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); } //$NON-NLS-1$
5154	consumePrimitiveArrayType();	5501	consumePrimitiveArrayType();
5155	break;	5502	break;
5156		5503
5157	case 53 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); } //$NON-NLS-1$	5504	case 64 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); } //$NON-NLS-1$
5158	consumeNameArrayType();	5505	consumeNameArrayType();
5159	break;	5506	break;
5160		5507
5161	case 54 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); } //$NON-NLS-1$	5508	case 65 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); } //$NON-NLS-1$
5162	consumeGenericTypeNameArrayType();	5509	consumeGenericTypeNameArrayType();
5163	break;	5510	break;
5164		5511
5165	case 55 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); } //$NON-NLS-1$	5512	case 66 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); } //$NON-NLS-1$
5166	consumeGenericTypeArrayType();	5513	consumeGenericTypeArrayType();
5167	break;	5514	break;
5168		5515
5169	case 60 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); } //$NON-NLS-1$	5516	case 71 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); } //$NON-NLS-1$
5170	consumeQualifiedName();	5517	consumeQualifiedName();
5171	break;	5518	break;
5172		5519
5173	case 61 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$	5520	case 72 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$
5174	consumeCompilationUnit();	5521	consumeCompilationUnit();
5175	break;	5522	break;
5176		5523
5177	case 62 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); } //$NON-NLS-1$	5524	case 73 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); } //$NON-NLS-1$
5178	consumeInternalCompilationUnit();	5525	consumeInternalCompilationUnit();
5179	break;	5526	break;
5180		5527
5181	case 63 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5528	case 74 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5182	consumeInternalCompilationUnit();	5529	consumeInternalCompilationUnit();
5183	break;	5530	break;
5184		5531
5185	case 64 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5532	case 75 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5186	consumeInternalCompilationUnitWithTypes();	5533	consumeInternalCompilationUnitWithTypes();
5187	break;	5534	break;
5188		5535
5189	case 65 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$	5536	case 76 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } //$NON-NLS-1$
5190	consumeInternalCompilationUnitWithTypes();	5537	consumeInternalCompilationUnitWithTypes();
5191	break;	5538	break;
5192		5539
5193	case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$	5540	case 77 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$
5194	consumeInternalCompilationUnit();	5541	consumeInternalCompilationUnit();
5195	break;	5542	break;
5196		5543
5197	case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); } //$NON-NLS-1$	5544	case 78 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); } //$NON-NLS-1$
5198	consumeInternalCompilationUnitWithTypes();	5545	consumeInternalCompilationUnitWithTypes();
5199	break;	5546	break;
5200		5547
5201	case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$	5548	case 79 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } //$NON-NLS-1$
5202	consumeInternalCompilationUnitWithTypes();	5549	consumeInternalCompilationUnitWithTypes();
5203	break;	5550	break;
5204		5551
5205	case 69 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$	5552	case 80 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$
5206	consumeEmptyInternalCompilationUnit();	5553	consumeEmptyInternalCompilationUnit();
5207	break;	5554	break;
5208		5555
5209	case 70 : if (DEBUG) { System.out.println("ReduceImports ::="); } //$NON-NLS-1$	5556	case 81 : if (DEBUG) { System.out.println("ReduceImports ::="); } //$NON-NLS-1$
5210	consumeReduceImports();	5557	consumeReduceImports();
5211	break;	5558	break;
5212		5559
5213	case 71 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$	5560	case 82 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$
5214	consumeEnterCompilationUnit();	5561	consumeEnterCompilationUnit();
5215	break;	5562	break;
5216		5563
5217	case 87 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$	5564	case 98 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
5218	consumeCatchHeader();	5565	consumeCatchHeader();
5219	break;	5566	break;
5220		5567
5221	case 89 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); } //$NON-NLS-1$	5568	case 100 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); } //$NON-NLS-1$
5222	consumeImportDeclarations();	5569	consumeImportDeclarations();
5223	break;	5570	break;
5224		5571
5225	case 91 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); } //$NON-NLS-1$	5572	case 102 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); } //$NON-NLS-1$
5226	consumeTypeDeclarations();	5573	consumeTypeDeclarations();
5227	break;	5574	break;
5228		5575
5229	case 92 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); } //$NON-NLS-1$	5576	case 103 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); } //$NON-NLS-1$
5230	consumePackageDeclaration();	5577	consumePackageDeclaration();
5231	break;	5578	break;
5232		5579
5233	case 93 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); } //$NON-NLS-1$	5580	case 104 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); } //$NON-NLS-1$
5234	consumePackageDeclarationNameWithModifiers();	5581	consumePackageDeclarationNameWithModifiers();
5235	break;	5582	break;
5236		5583
5237	case 94 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); } //$NON-NLS-1$	5584	case 105 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); } //$NON-NLS-1$
5238	consumePackageDeclarationName();	5585	consumePackageDeclarationName();
5239	break;	5586	break;
5240		5587
5241	case 95 : if (DEBUG) { System.out.println("PackageComment ::="); } //$NON-NLS-1$	5588	case 106 : if (DEBUG) { System.out.println("PackageComment ::="); } //$NON-NLS-1$
5242	consumePackageComment();	5589	consumePackageComment();
5243	break;	5590	break;
5244		5591
5245	case 100 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); } //$NON-NLS-1$	5592	case 111 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); } //$NON-NLS-1$
5246	consumeImportDeclaration();	5593	consumeImportDeclaration();
5247	break;	5594	break;
5248		5595
5249	case 101 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); } //$NON-NLS-1$	5596	case 112 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); } //$NON-NLS-1$
5250	consumeSingleTypeImportDeclarationName();	5597	consumeSingleTypeImportDeclarationName();
5251	break;	5598	break;
5252		5599
5253	case 102 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$	5600	case 113 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$
5254	consumeImportDeclaration();	5601	consumeImportDeclaration();
5255	break;	5602	break;
5256		5603
5257	case 103 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); } //$NON-NLS-1$	5604	case 114 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); } //$NON-NLS-1$
5258	consumeTypeImportOnDemandDeclarationName();	5605	consumeTypeImportOnDemandDeclarationName();
5259	break;	5606	break;
5260		5607
5261	case 106 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5608	case 117 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5262	consumeEmptyTypeDeclaration();	5609	consumeEmptyTypeDeclaration();
5263	break;	5610	break;
5264		5611
5265	case 110 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); } //$NON-NLS-1$	5612	case 121 : if (DEBUG) { System.out.println("NonAnnotModifiers ::= NonAnnotModifiers NonAnnotModifier"); } //$NON-NLS-1$
5266	consumeModifiers2();	5613	consumeModifiers2();
5267	break;	5614	break;
5268		5615
5269	case 122 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); } //$NON-NLS-1$	5616	case 123 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); } //$NON-NLS-1$
		5617	consumeModifiers2();
		5618	break;
		5619
		5620	case 146 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); } //$NON-NLS-1$
5270	consumeAnnotationAsModifier();	5621	consumeAnnotationAsModifier();
5271	break;	5622	break;
5272		5623
5273	case 123 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); } //$NON-NLS-1$	5624	case 147 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); } //$NON-NLS-1$
5274	consumeClassDeclaration();	5625	consumeClassDeclaration();
5275	break;	5626	break;
5276		5627
5277	case 124 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); } //$NON-NLS-1$	5628	case 148 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); } //$NON-NLS-1$
5278	consumeClassHeader();	5629	consumeClassHeader();
5279	break;	5630	break;
5280		5631
5281	case 125 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); } //$NON-NLS-1$	5632	case 149 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); } //$NON-NLS-1$
5282	consumeTypeHeaderNameWithTypeParameters();	5633	consumeTypeHeaderNameWithTypeParameters();
5283	break;	5634	break;
5284		5635
5285	case 127 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); } //$NON-NLS-1$	5636	case 151 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); } //$NON-NLS-1$
5286	consumeClassHeaderName1();	5637	consumeClassHeaderName1();
5287	break;	5638	break;
5288		5639
5289	case 128 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); } //$NON-NLS-1$	5640	case 152 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); } //$NON-NLS-1$
5290	consumeClassHeaderExtends();	5641	consumeClassHeaderExtends();
5291	break;	5642	break;
5292		5643
5293	case 129 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); } //$NON-NLS-1$	5644	case 153 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); } //$NON-NLS-1$
5294	consumeClassHeaderImplements();	5645	consumeClassHeaderImplements();
5295	break;	5646	break;
5296		5647
5297	case 131 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); } //$NON-NLS-1$	5648	case 155 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); } //$NON-NLS-1$
5298	consumeInterfaceTypeList();	5649	consumeInterfaceTypeList();
5299	break;	5650	break;
5300		5651
5301	case 132 : if (DEBUG) { System.out.println("InterfaceType ::= ClassOrInterfaceType"); } //$NON-NLS-1$	5652	case 156 : if (DEBUG) { System.out.println("InterfaceType ::= ClassOrInterfaceType"); } //$NON-NLS-1$
5302	consumeInterfaceType();	5653	consumeInterfaceType();
5303	break;	5654	break;
5304		5655
5305	case 135 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); } //$NON-NLS-1$	5656	case 159 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); } //$NON-NLS-1$
5306	consumeClassBodyDeclarations();	5657	consumeClassBodyDeclarations();
5307	break;	5658	break;
5308		5659
5309	case 139 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); } //$NON-NLS-1$	5660	case 163 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); } //$NON-NLS-1$
5310	consumeClassBodyDeclaration();	5661	consumeClassBodyDeclaration();
5311	break;	5662	break;
5312		5663
5313	case 140 : if (DEBUG) { System.out.println("Diet ::="); } //$NON-NLS-1$	5664	case 164 : if (DEBUG) { System.out.println("Diet ::="); } //$NON-NLS-1$
5314	consumeDiet();	5665	consumeDiet();
5315	break;	5666	break;
5316		5667
5317	case 141 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); } //$NON-NLS-1$	5668	case 165 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); } //$NON-NLS-1$
5318	consumeClassBodyDeclaration();	5669	consumeClassBodyDeclaration();
5319	break;	5670	break;
5320		5671
5321	case 142 : if (DEBUG) { System.out.println("CreateInitializer ::="); } //$NON-NLS-1$	5672	case 166 : if (DEBUG) { System.out.println("CreateInitializer ::="); } //$NON-NLS-1$
5322	consumeCreateInitializer();	5673	consumeCreateInitializer();
5323	break;	5674	break;
5324		5675
5325	case 149 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5676	case 173 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5326	consumeEmptyTypeDeclaration();	5677	consumeEmptyTypeDeclaration();
5327	break;	5678	break;
5328		5679
5329	case 152 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type..."); } //$NON-NLS-1$	5680	case 176 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type0..."); } //$NON-NLS-1$
5330	consumeFieldDeclaration();	5681	consumeFieldDeclaration();
5331	break;	5682	break;
5332		5683
5333	case 154 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$	5684	case 178 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$
5334	consumeVariableDeclarators();	5685	consumeVariableDeclarators();
5335	break;	5686	break;
5336		5687
5337	case 157 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$	5688	case 181 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$
5338	consumeEnterVariable();	5689	consumeEnterVariable();
5339	break;	5690	break;
5340		5691
5341	case 158 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$	5692	case 182 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$
5342	consumeExitVariableWithInitialization();	5693	consumeExitVariableWithInitialization();
5343	break;	5694	break;
5344		5695
5345	case 159 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$	5696	case 183 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$
5346	consumeExitVariableWithoutInitialization();	5697	consumeExitVariableWithoutInitialization();
5347	break;	5698	break;
5348		5699
5349	case 160 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$	5700	case 184 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$
5350	consumeForceNoDiet();	5701	consumeForceNoDiet();
5351	break;	5702	break;
5352		5703
5353	case 161 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$	5704	case 185 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$
5354	consumeRestoreDiet();	5705	consumeRestoreDiet();
5355	break;	5706	break;
5356		5707
5357	case 166 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$	5708	case 190 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$
5358	// set to true to consume a method with a body	5709	// set to true to consume a method with a body
5359	consumeMethodDeclaration(true);	5710	consumeMethodDeclaration(true);
5360	break;	5711	break;
5361		5712
5362	case 167 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$	5713	case 191 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$
5363	// set to false to consume a method without body	5714	// set to false to consume a method without body
5364	consumeMethodDeclaration(false);	5715	consumeMethodDeclaration(false);
5365	break;	5716	break;
5366		5717
5367	case 168 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$	5718	case 192 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$
5368	consumeMethodHeader();	5719	consumeMethodHeader();
5369	break;	5720	break;
5370		5721
5371	case 169 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); } //$NON-NLS-1$	5722	case 193 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); } //$NON-NLS-1$
5372	consumeMethodHeaderNameWithTypeParameters(false);	5723	consumeMethodHeaderNameWithTypeParameters(false);
5373	break;	5724	break;
5374		5725
5375	case 170 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); } //$NON-NLS-1$	5726	case 194 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type0 Identifier..."); } //$NON-NLS-1$
5376	consumeMethodHeaderName(false);	5727	consumeMethodHeaderName(false);
5377	break;	5728	break;
5378		5729
5379	case 171 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$	5730	case 195 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$
5380	consumeMethodHeaderRightParen();	5731	consumeMethodHeaderRightParen();
5381	break;	5732	break;
5382		5733
5383	case 172 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= Dimsopt"); } //$NON-NLS-1$	5734	case 196 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= DimsoptAnnotsopt"); } //$NON-NLS-1$
5384	consumeMethodHeaderExtendedDims();	5735	consumeMethodHeaderExtendedDims();
5385	break;	5736	break;
5386		5737
5387	case 173 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); } //$NON-NLS-1$	5738	case 197 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); } //$NON-NLS-1$
5388	consumeMethodHeaderThrowsClause();	5739	consumeMethodHeaderThrowsClause();
5389	break;	5740	break;
5390		5741
5391	case 174 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$	5742	case 198 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } //$NON-NLS-1$
5392	consumeConstructorHeader();	5743	consumeConstructorHeader();
5393	break;	5744	break;
5394		5745
5395	case 175 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$	5746	case 199 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); } //$NON-NLS-1$
5396	consumeConstructorHeaderNameWithTypeParameters();	5747	consumeConstructorHeaderNameWithTypeParameters();
5397	break;	5748	break;
5398		5749
5399	case 176 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); } //$NON-NLS-1$	5750	case 200 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); } //$NON-NLS-1$
5400	consumeConstructorHeaderName();	5751	consumeConstructorHeaderName();
5401	break;	5752	break;
5402		5753
5403	case 178 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$	5754	case 202 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$
5404	consumeFormalParameterList();	5755	consumeFormalParameterList();
5405	break;	5756	break;
5406		5757
5407	case 179 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type..."); } //$NON-NLS-1$	5758	case 203 : if (DEBUG) { System.out.println("PotentialNameArray ::="); } //$NON-NLS-1$
		5759	consumePotentialNameArrayType();
		5760	break;
		5761
		5762	case 204 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); } //$NON-NLS-1$
5408	consumeFormalParameter(false);	5763	consumeFormalParameter(false);
5409	break;	5764	break;
5410		5765
5411	case 180 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type ELLIPSIS..."); } //$NON-NLS-1$	5766	case 205 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); } //$NON-NLS-1$
5412	consumeFormalParameter(true);	5767	consumeFormalParameter(true);
5413	break;	5768	break;
5414		5769
5415	case 182 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); } //$NON-NLS-1$	5770	case 206 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); } //$NON-NLS-1$
		5771	consumeFormalParameter(false);
		5772	break;
		5773
		5774	case 207 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); } //$NON-NLS-1$
		5775	consumeFormalParameter(true);
		5776	break;
		5777
		5778	case 208 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); } //$NON-NLS-1$
		5779	consumeFormalParameter(false);
		5780	break;
		5781
		5782	case 209 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); } //$NON-NLS-1$
		5783	consumeFormalParameter(true);
		5784	break;
		5785
		5786	case 210 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); } //$NON-NLS-1$
		5787	consumeFormalParameter(false);
		5788	break;
		5789
		5790	case 211 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); } //$NON-NLS-1$
		5791	consumeFormalParameter(true);
		5792	break;
		5793
		5794	case 213 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); } //$NON-NLS-1$
5416	consumeClassTypeList();	5795	consumeClassTypeList();
5417	break;	5796	break;
5418		5797
5419	case 183 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); } //$NON-NLS-1$	5798	case 214 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); } //$NON-NLS-1$
5420	consumeClassTypeElt();	5799	consumeClassTypeElt();
5421	break;	5800	break;
5422		5801
5423	case 184 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); } //$NON-NLS-1$	5802	case 215 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); } //$NON-NLS-1$
5424	consumeMethodBody();	5803	consumeMethodBody();
5425	break;	5804	break;
5426		5805
5427	case 185 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$	5806	case 216 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$
5428	consumeNestedMethod();	5807	consumeNestedMethod();
5429	break;	5808	break;
5430		5809
5431	case 186 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); } //$NON-NLS-1$	5810	case 217 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); } //$NON-NLS-1$
5432	consumeStaticInitializer();	5811	consumeStaticInitializer();
5433	break;	5812	break;
5434		5813
5435	case 187 : if (DEBUG) { System.out.println("StaticOnly ::= static"); } //$NON-NLS-1$	5814	case 218 : if (DEBUG) { System.out.println("StaticOnly ::= static"); } //$NON-NLS-1$
5436	consumeStaticOnly();	5815	consumeStaticOnly();
5437	break;	5816	break;
5438		5817
5439	case 188 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); } //$NON-NLS-1$	5818	case 219 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); } //$NON-NLS-1$
5440	consumeConstructorDeclaration() ;	5819	consumeConstructorDeclaration() ;
5441	break;	5820	break;
5442		5821
5443	case 189 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); } //$NON-NLS-1$	5822	case 220 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); } //$NON-NLS-1$
5444	consumeInvalidConstructorDeclaration() ;	5823	consumeInvalidConstructorDeclaration() ;
5445	break;	5824	break;
5446		5825
5447	case 190 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); } //$NON-NLS-1$	5826	case 221 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); } //$NON-NLS-1$
5448	consumeExplicitConstructorInvocation(0, THIS_CALL);	5827	consumeExplicitConstructorInvocation(0, THIS_CALL);
5449	break;	5828	break;
5450		5829
5451	case 191 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); } //$NON-NLS-1$	5830	case 222 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); } //$NON-NLS-1$
5452	consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);	5831	consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);
5453	break;	5832	break;
5454		5833
5455	case 192 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); } //$NON-NLS-1$	5834	case 223 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); } //$NON-NLS-1$
5456	consumeExplicitConstructorInvocation(0,SUPER_CALL);	5835	consumeExplicitConstructorInvocation(0,SUPER_CALL);
5457	break;	5836	break;
5458		5837
5459	case 193 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); } //$NON-NLS-1$	5838	case 224 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); } //$NON-NLS-1$
5460	consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);	5839	consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);
5461	break;	5840	break;
5462		5841
5463	case 194 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); } //$NON-NLS-1$	5842	case 225 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); } //$NON-NLS-1$
5464	consumeExplicitConstructorInvocation(1, SUPER_CALL);	5843	consumeExplicitConstructorInvocation(1, SUPER_CALL);
5465	break;	5844	break;
5466		5845
5467	case 195 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$	5846	case 226 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$
5468	consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);	5847	consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);
5469	break;	5848	break;
5470		5849
5471	case 196 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); } //$NON-NLS-1$	5850	case 227 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); } //$NON-NLS-1$
5472	consumeExplicitConstructorInvocation(2, SUPER_CALL);	5851	consumeExplicitConstructorInvocation(2, SUPER_CALL);
5473	break;	5852	break;
5474		5853
5475	case 197 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$	5854	case 228 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$
5476	consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);	5855	consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);
5477	break;	5856	break;
5478		5857
5479	case 198 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); } //$NON-NLS-1$	5858	case 229 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); } //$NON-NLS-1$
5480	consumeExplicitConstructorInvocation(1, THIS_CALL);	5859	consumeExplicitConstructorInvocation(1, THIS_CALL);
5481	break;	5860	break;
5482		5861
5483	case 199 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$	5862	case 230 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } //$NON-NLS-1$
5484	consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);	5863	consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);
5485	break;	5864	break;
5486		5865
5487	case 200 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); } //$NON-NLS-1$	5866	case 231 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); } //$NON-NLS-1$
5488	consumeExplicitConstructorInvocation(2, THIS_CALL);	5867	consumeExplicitConstructorInvocation(2, THIS_CALL);
5489	break;	5868	break;
5490		5869
5491	case 201 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$	5870	case 232 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } //$NON-NLS-1$
5492	consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);	5871	consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);
5493	break;	5872	break;
5494		5873
5495	case 202 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); } //$NON-NLS-1$	5874	case 233 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); } //$NON-NLS-1$
5496	consumeInterfaceDeclaration();	5875	consumeInterfaceDeclaration();
5497	break;	5876	break;
5498		5877
5499	case 203 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); } //$NON-NLS-1$	5878	case 234 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); } //$NON-NLS-1$
5500	consumeInterfaceHeader();	5879	consumeInterfaceHeader();
5501	break;	5880	break;
5502		5881
5503	case 204 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); } //$NON-NLS-1$	5882	case 235 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); } //$NON-NLS-1$
5504	consumeTypeHeaderNameWithTypeParameters();	5883	consumeTypeHeaderNameWithTypeParameters();
5505	break;	5884	break;
5506		5885
5507	case 206 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); } //$NON-NLS-1$	5886	case 237 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); } //$NON-NLS-1$
5508	consumeInterfaceHeaderName1();	5887	consumeInterfaceHeaderName1();
5509	break;	5888	break;
5510		5889
5511	case 207 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); } //$NON-NLS-1$	5890	case 238 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); } //$NON-NLS-1$
5512	consumeInterfaceHeaderExtends();	5891	consumeInterfaceHeaderExtends();
5513	break;	5892	break;
5514		5893
5515	case 210 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); } //$NON-NLS-1$	5894	case 241 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); } //$NON-NLS-1$
5516	consumeInterfaceMemberDeclarations();	5895	consumeInterfaceMemberDeclarations();
5517	break;	5896	break;
5518		5897
5519	case 211 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$	5898	case 242 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); } //$NON-NLS-1$
5520	consumeEmptyTypeDeclaration();	5899	consumeEmptyTypeDeclaration();
5521	break;	5900	break;
5522		5901
5523	case 213 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$	5902	case 244 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$
5524	consumeInvalidMethodDeclaration();	5903	consumeInvalidMethodDeclaration();
5525	break;	5904	break;
5526		5905
5527	case 214 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$	5906	case 245 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$
5528	consumeInvalidConstructorDeclaration(true);	5907	consumeInvalidConstructorDeclaration(true);
5529	break;	5908	break;
5530		5909
5531	case 215 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$	5910	case 246 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } //$NON-NLS-1$
5532	consumeInvalidConstructorDeclaration(false);	5911	consumeInvalidConstructorDeclaration(false);
5533	break;	5912	break;
5534		5913
5535	case 223 : if (DEBUG) { System.out.println("PushLeftBrace ::="); } //$NON-NLS-1$	5914	case 254 : if (DEBUG) { System.out.println("PushLeftBrace ::="); } //$NON-NLS-1$
5536	consumePushLeftBrace();	5915	consumePushLeftBrace();
5537	break;	5916	break;
5538		5917
5539	case 224 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); } //$NON-NLS-1$	5918	case 255 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); } //$NON-NLS-1$
5540	consumeEmptyArrayInitializer();	5919	consumeEmptyArrayInitializer();
5541	break;	5920	break;
5542		5921
5543	case 225 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$	5922	case 256 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$
5544	consumeArrayInitializer();	5923	consumeArrayInitializer();
5545	break;	5924	break;
5546		5925
5547	case 226 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$	5926	case 257 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$
5548	consumeArrayInitializer();	5927	consumeArrayInitializer();
5549	break;	5928	break;
5550		5929
5551	case 228 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); } //$NON-NLS-1$	5930	case 259 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); } //$NON-NLS-1$
5552	consumeVariableInitializers();	5931	consumeVariableInitializers();
5553	break;	5932	break;
5554		5933
5555	case 229 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$	5934	case 260 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$
5556	consumeBlock();	5935	consumeBlock();
5557	break;	5936	break;
5558		5937
5559	case 230 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$	5938	case 261 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$
5560	consumeOpenBlock() ;	5939	consumeOpenBlock() ;
5561	break;	5940	break;
5562		5941
5563	case 232 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$	5942	case 263 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$
5564	consumeBlockStatements() ;	5943	consumeBlockStatements() ;
5565	break;	5944	break;
5566		5945
5567	case 236 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); } //$NON-NLS-1$	5946	case 267 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); } //$NON-NLS-1$
5568	consumeInvalidInterfaceDeclaration();	5947	consumeInvalidInterfaceDeclaration();
5569	break;	5948	break;
5570		5949
5571	case 237 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); } //$NON-NLS-1$	5950	case 268 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); } //$NON-NLS-1$
5572	consumeInvalidAnnotationTypeDeclaration();	5951	consumeInvalidAnnotationTypeDeclaration();
5573	break;	5952	break;
5574		5953
5575	case 238 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); } //$NON-NLS-1$	5954	case 269 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); } //$NON-NLS-1$
5576	consumeInvalidEnumDeclaration();	5955	consumeInvalidEnumDeclaration();
5577	break;	5956	break;
5578		5957
5579	case 239 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$	5958	case 270 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$
5580	consumeLocalVariableDeclarationStatement();	5959	consumeLocalVariableDeclarationStatement();
5581	break;	5960	break;
5582		5961
5583	case 240 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); } //$NON-NLS-1$	5962	case 271 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type0 PushModifiers..."); } //$NON-NLS-1$
5584	consumeLocalVariableDeclaration();	5963	consumeLocalVariableDeclaration();
5585	break;	5964	break;
5586		5965
5587	case 241 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); } //$NON-NLS-1$	5966	case 272 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type0..."); } //$NON-NLS-1$
5588	consumeLocalVariableDeclaration();	5967	consumeLocalVariableDeclaration();
5589	break;	5968	break;
5590		5969
5591	case 242 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$	5970	case 273 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$
5592	consumePushModifiers();	5971	consumePushModifiers();
5593	break;	5972	break;
5594		5973
5595	case 243 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); } //$NON-NLS-1$	5974	case 274 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); } //$NON-NLS-1$
5596	consumePushModifiersForHeader();	5975	consumePushModifiersForHeader();
5597	break;	5976	break;
5598		5977
5599	case 244 : if (DEBUG) { System.out.println("PushRealModifiers ::="); } //$NON-NLS-1$	5978	case 275 : if (DEBUG) { System.out.println("PushRealModifiers ::="); } //$NON-NLS-1$
5600	consumePushRealModifiers();	5979	consumePushRealModifiers();
5601	break;	5980	break;
5602		5981
5603	case 270 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); } //$NON-NLS-1$	5982	case 301 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); } //$NON-NLS-1$
5604	consumeEmptyStatement();	5983	consumeEmptyStatement();
5605	break;	5984	break;
5606		5985
5607	case 271 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$	5986	case 302 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$
5608	consumeStatementLabel() ;	5987	consumeStatementLabel() ;
5609	break;	5988	break;
5610		5989
5611	case 272 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$	5990	case 303 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$
5612	consumeStatementLabel() ;	5991	consumeStatementLabel() ;
5613	break;	5992	break;
5614		5993
5615	case 273 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$	5994	case 304 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$
5616	consumeLabel() ;	5995	consumeLabel() ;
5617	break;	5996	break;
5618		5997
5619	case 274 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$	5998	case 305 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$
5620	consumeExpressionStatement();	5999	consumeExpressionStatement();
5621	break;	6000	break;
5622		6001
5623	case 283 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$	6002	case 314 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5624	consumeStatementIfNoElse();	6003	consumeStatementIfNoElse();
5625	break;	6004	break;
5626		6005
5627	case 284 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$	6006	case 315 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5628	consumeStatementIfWithElse();	6007	consumeStatementIfWithElse();
5629	break;	6008	break;
5630		6009
5631	case 285 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$	6010	case 316 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$
5632	consumeStatementIfWithElse();	6011	consumeStatementIfWithElse();
5633	break;	6012	break;
5634		6013
5635	case 286 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$	6014	case 317 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5636	consumeStatementSwitch() ;	6015	consumeStatementSwitch() ;
5637	break;	6016	break;
5638		6017
5639	case 287 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$	6018	case 318 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$
5640	consumeEmptySwitchBlock() ;	6019	consumeEmptySwitchBlock() ;
5641	break;	6020	break;
5642		6021
5643	case 290 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$	6022	case 321 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$
5644	consumeSwitchBlock() ;	6023	consumeSwitchBlock() ;
5645	break;	6024	break;
5646		6025
5647	case 292 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$	6026	case 323 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$
5648	consumeSwitchBlockStatements() ;	6027	consumeSwitchBlockStatements() ;
5649	break;	6028	break;
5650		6029
5651	case 293 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$	6030	case 324 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$
5652	consumeSwitchBlockStatement() ;	6031	consumeSwitchBlockStatement() ;
5653	break;	6032	break;
5654		6033
5655	case 295 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$	6034	case 326 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$
5656	consumeSwitchLabels() ;	6035	consumeSwitchLabels() ;
5657	break;	6036	break;
5658		6037
5659	case 296 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$	6038	case 327 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$
5660	consumeCaseLabel();	6039	consumeCaseLabel();
5661	break;	6040	break;
5662		6041
5663	case 297 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$	6042	case 328 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$
5664	consumeDefaultLabel();	6043	consumeDefaultLabel();
5665	break;	6044	break;
5666		6045
5667	case 298 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$	6046	case 329 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$
5668	consumeStatementWhile() ;	6047	consumeStatementWhile() ;
5669	break;	6048	break;
5670		6049
5671	case 299 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$	6050	case 330 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$
5672	consumeStatementWhile() ;	6051	consumeStatementWhile() ;
5673	break;	6052	break;
5674		6053
5675	case 300 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$	6054	case 331 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$
5676	consumeStatementDo() ;	6055	consumeStatementDo() ;
5677	break;	6056	break;
5678		6057
5679	case 301 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$	6058	case 332 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$
5680	consumeStatementFor() ;	6059	consumeStatementFor() ;
5681	break;	6060	break;
5682		6061
5683	case 302 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$	6062	case 333 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$
5684	consumeStatementFor() ;	6063	consumeStatementFor() ;
5685	break;	6064	break;
5686		6065
5687	case 303 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); } //$NON-NLS-1$	6066	case 334 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); } //$NON-NLS-1$
5688	consumeForInit() ;	6067	consumeForInit() ;
5689	break;	6068	break;
5690		6069
5691	case 307 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$	6070	case 338 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$
5692	consumeStatementExpressionList() ;	6071	consumeStatementExpressionList() ;
5693	break;	6072	break;
5694		6073
5695	case 308 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); } //$NON-NLS-1$	6074	case 339 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); } //$NON-NLS-1$
5696	consumeSimpleAssertStatement() ;	6075	consumeSimpleAssertStatement() ;
5697	break;	6076	break;
5698		6077
5699	case 309 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); } //$NON-NLS-1$	6078	case 340 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); } //$NON-NLS-1$
5700	consumeAssertStatement() ;	6079	consumeAssertStatement() ;
5701	break;	6080	break;
5702		6081
5703	case 310 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$	6082	case 341 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$
5704	consumeStatementBreak() ;	6083	consumeStatementBreak() ;
5705	break;	6084	break;
5706		6085
5707	case 311 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$	6086	case 342 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$
5708	consumeStatementBreakWithLabel() ;	6087	consumeStatementBreakWithLabel() ;
5709	break;	6088	break;
5710		6089
5711	case 312 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$	6090	case 343 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$
5712	consumeStatementContinue() ;	6091	consumeStatementContinue() ;
5713	break;	6092	break;
5714		6093
5715	case 313 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$	6094	case 344 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$
5716	consumeStatementContinueWithLabel() ;	6095	consumeStatementContinueWithLabel() ;
5717	break;	6096	break;
5718		6097
5719	case 314 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$	6098	case 345 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$
5720	consumeStatementReturn() ;	6099	consumeStatementReturn() ;
5721	break;	6100	break;
5722		6101
5723	case 315 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$	6102	case 346 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$
5724	consumeStatementThrow();	6103	consumeStatementThrow();
5725	break;	6104	break;
5726		6105
5727	case 316 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); } //$NON-NLS-1$	6106	case 347 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); } //$NON-NLS-1$
5728	consumeStatementSynchronized();	6107	consumeStatementSynchronized();
5729	break;	6108	break;
5730		6109
5731	case 317 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); } //$NON-NLS-1$	6110	case 348 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); } //$NON-NLS-1$
5732	consumeOnlySynchronized();	6111	consumeOnlySynchronized();
5733	break;	6112	break;
5734		6113
5735	case 318 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$	6114	case 349 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$
5736	consumeStatementTry(false);	6115	consumeStatementTry(false);
5737	break;	6116	break;
5738		6117
5739	case 319 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$	6118	case 350 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$
5740	consumeStatementTry(true);	6119	consumeStatementTry(true);
5741	break;	6120	break;
5742		6121
5743	case 321 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$	6122	case 352 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$
5744	consumeExitTryBlock();	6123	consumeExitTryBlock();
5745	break;	6124	break;
5746		6125
5747	case 323 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$	6126	case 354 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$
5748	consumeCatches();	6127	consumeCatches();
5749	break;	6128	break;
5750		6129
5751	case 324 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$	6130	case 355 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
5752	consumeStatementCatch() ;	6131	consumeStatementCatch() ;
5753	break;	6132	break;
5754		6133
5755	case 326 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$	6134	case 357 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$
5756	consumeLeftParen();	6135	consumeLeftParen();
5757	break;	6136	break;
5758		6137
5759	case 327 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$	6138	case 358 : if (DEBUG) { System.out.println("PushRPARENForUnannotatedTypeCast ::= RPAREN"); } //$NON-NLS-1$
		6139	consumeRightParenForUnannotatedTypeCast();
		6140	break;
		6141
		6142	case 359 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$
5760	consumeRightParen();	6143	consumeRightParen();
5761	break;	6144	break;
5762		6145
5763	case 332 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$	6146	case 364 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$
5764	consumePrimaryNoNewArrayThis();	6147	consumePrimaryNoNewArrayThis();
5765	break;	6148	break;
5766		6149
5767	case 333 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); } //$NON-NLS-1$	6150	case 365 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); } //$NON-NLS-1$
5768	consumePrimaryNoNewArray();	6151	consumePrimaryNoNewArray();
5769	break;	6152	break;
5770		6153
5771	case 334 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); } //$NON-NLS-1$	6154	case 366 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); } //$NON-NLS-1$
5772	consumePrimaryNoNewArrayWithName();	6155	consumePrimaryNoNewArrayWithName();
5773	break;	6156	break;
5774		6157
5775	case 337 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); } //$NON-NLS-1$	6158	case 369 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); } //$NON-NLS-1$
5776	consumePrimaryNoNewArrayNameThis();	6159	consumePrimaryNoNewArrayNameThis();
5777	break;	6160	break;
5778		6161
5779	case 338 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); } //$NON-NLS-1$	6162	case 370 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); } //$NON-NLS-1$
5780	consumePrimaryNoNewArrayNameSuper();	6163	consumePrimaryNoNewArrayNameSuper();
5781	break;	6164	break;
5782		6165
5783	case 339 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); } //$NON-NLS-1$	6166	case 371 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); } //$NON-NLS-1$
5784	consumePrimaryNoNewArrayName();	6167	consumePrimaryNoNewArrayName();
5785	break;	6168	break;
5786		6169
5787	case 340 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); } //$NON-NLS-1$	6170	case 372 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); } //$NON-NLS-1$
5788	consumePrimaryNoNewArrayArrayType();	6171	consumePrimaryNoNewArrayArrayType();
5789	break;	6172	break;
5790		6173
5791	case 341 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); } //$NON-NLS-1$	6174	case 373 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); } //$NON-NLS-1$
5792	consumePrimaryNoNewArrayPrimitiveArrayType();	6175	consumePrimaryNoNewArrayPrimitiveArrayType();
5793	break;	6176	break;
5794		6177
5795	case 342 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); } //$NON-NLS-1$	6178	case 374 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); } //$NON-NLS-1$
5796	consumePrimaryNoNewArrayPrimitiveType();	6179	consumePrimaryNoNewArrayPrimitiveType();
5797	break;	6180	break;
5798		6181
5799	case 345 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); } //$NON-NLS-1$	6182	case 377 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); } //$NON-NLS-1$
5800	consumeAllocationHeader();	6183	consumeAllocationHeader();
5801	break;	6184	break;
5802		6185
5803	case 346 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); } //$NON-NLS-1$	6186	case 378 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); } //$NON-NLS-1$
5804	consumeClassInstanceCreationExpressionWithTypeArguments();	6187	consumeClassInstanceCreationExpressionWithTypeArguments();
5805	break;	6188	break;
5806		6189
5807	case 347 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); } //$NON-NLS-1$	6190	case 379 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); } //$NON-NLS-1$
5808	consumeClassInstanceCreationExpression();	6191	consumeClassInstanceCreationExpression();
5809	break;	6192	break;
5810		6193
5811	case 348 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$	6194	case 380 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$
5812	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;	6195	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5813	break;	6196	break;
5814		6197
5815	case 349 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$	6198	case 381 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } //$NON-NLS-1$
5816	consumeClassInstanceCreationExpressionQualified() ;	6199	consumeClassInstanceCreationExpressionQualified() ;
5817	break;	6200	break;
5818		6201
5819	case 350 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$	6202	case 382 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$
5820	consumeClassInstanceCreationExpressionQualified() ;	6203	consumeClassInstanceCreationExpressionQualified() ;
5821	break;	6204	break;
5822		6205
5823	case 351 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$	6206	case 383 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } //$NON-NLS-1$
5824	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;	6207	consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5825	break;	6208	break;
5826		6209
5827	case 352 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); } //$NON-NLS-1$	6210	case 384 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); } //$NON-NLS-1$
5828	consumeClassInstanceCreationExpressionName() ;	6211	consumeClassInstanceCreationExpressionName() ;
5829	break;	6212	break;
5830		6213
5831	case 353 : if (DEBUG) { System.out.println("UnqualifiedClassBodyopt ::="); } //$NON-NLS-1$	6214	case 385 : if (DEBUG) { System.out.println("UnqualifiedClassBodyopt ::="); } //$NON-NLS-1$
5832	consumeClassBodyopt();	6215	consumeClassBodyopt();
5833	break;	6216	break;
5834		6217
5835	case 355 : if (DEBUG) { System.out.println("UnqualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$	6218	case 387 : if (DEBUG) { System.out.println("UnqualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$
5836	consumeEnterAnonymousClassBody(false);	6219	consumeEnterAnonymousClassBody(false);
5837	break;	6220	break;
5838		6221
5839	case 356 : if (DEBUG) { System.out.println("QualifiedClassBodyopt ::="); } //$NON-NLS-1$	6222	case 388 : if (DEBUG) { System.out.println("QualifiedClassBodyopt ::="); } //$NON-NLS-1$
5840	consumeClassBodyopt();	6223	consumeClassBodyopt();
5841	break;	6224	break;
5842		6225
5843	case 358 : if (DEBUG) { System.out.println("QualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$	6226	case 390 : if (DEBUG) { System.out.println("QualifiedEnterAnonymousClassBody ::="); } //$NON-NLS-1$
5844	consumeEnterAnonymousClassBody(true);	6227	consumeEnterAnonymousClassBody(true);
5845	break;	6228	break;
5846		6229
5847	case 360 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); } //$NON-NLS-1$	6230	case 392 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); } //$NON-NLS-1$
5848	consumeArgumentList();	6231	consumeArgumentList();
5849	break;	6232	break;
5850		6233
5851	case 361 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); } //$NON-NLS-1$	6234	case 393 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); } //$NON-NLS-1$
5852	consumeArrayCreationHeader();	6235	consumeArrayCreationHeader();
5853	break;	6236	break;
5854		6237
5855	case 362 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); } //$NON-NLS-1$	6238	case 394 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new TypeAnnotations..."); } //$NON-NLS-1$
5856	consumeArrayCreationHeader();	6239	consumeArrayCreationHeader();
5857	break;	6240	break;
5858		6241
5859	case 363 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$	6242	case 395 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); } //$NON-NLS-1$
		6243	consumeArrayCreationHeader();
		6244	break;
		6245
		6246	case 396 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
5860	consumeArrayCreationExpressionWithoutInitializer();	6247	consumeArrayCreationExpressionWithoutInitializer();
5861	break;	6248	break;
5862		6249
5863	case 364 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); } //$NON-NLS-1$	6250	case 397 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
		6251	consumeArrayCreationExpressionWithoutInitializer();
		6252	break;
		6253
		6254	case 398 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
		6255	consumeArrayCreationExpressionWithInitializer();
		6256	break;
		6257
		6258	case 399 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
5864	consumeArrayCreationExpressionWithInitializer();	6259	consumeArrayCreationExpressionWithInitializer();
5865	break;	6260	break;
5866		6261
5867	case 365 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$	6262	case 400 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } //$NON-NLS-1$
5868	consumeArrayCreationExpressionWithoutInitializer();	6263	consumeArrayCreationExpressionWithoutInitializer();
5869	break;	6264	break;
5870		6265
5871	case 366 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$	6266	case 401 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } //$NON-NLS-1$
5872	consumeArrayCreationExpressionWithInitializer();	6267	consumeArrayCreationExpressionWithInitializer();
5873	break;	6268	break;
5874		6269
5875	case 368 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); } //$NON-NLS-1$	6270	case 403 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); } //$NON-NLS-1$
5876	consumeDimWithOrWithOutExprs();	6271	consumeDimWithOrWithOutExprs();
5877	break;	6272	break;
5878		6273
5879	case 370 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET RBRACKET"); } //$NON-NLS-1$	6274	case 406 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET..."); } //$NON-NLS-1$
5880	consumeDimWithOrWithOutExpr();	6275	consumeDimWithOutExpr();
5881	break;	6276	break;
5882		6277
5883	case 371 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); } //$NON-NLS-1$	6278	case 407 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= TypeAnnotations LBRACKET..."); } //$NON-NLS-1$
		6279	consumeDimWithOutExpr();
		6280	break;
		6281
		6282	case 408 : if (DEBUG) { System.out.println("DimsoptAnnotsopt ::="); } //$NON-NLS-1$
		6283	consumeEmptyDimsoptAnnotsopt();
		6284	break;
		6285
		6286	case 409 : if (DEBUG) { System.out.println("DimsoptAnnotsopt -> DimsAnnotLoop"); } //$NON-NLS-1$
		6287	consumeDimsWithTrailingAnnotsopt();
		6288	break;
		6289
		6290	case 412 : if (DEBUG) { System.out.println("OneDimOrAnnot ::= Annotation"); } //$NON-NLS-1$
		6291	consumeTypeAnnotation(true);
		6292	break;
		6293
		6294	case 413 : if (DEBUG) { System.out.println("OneDimOrAnnot ::= LBRACKET RBRACKET"); } //$NON-NLS-1$
		6295	consumeOneDimLoop(true);
		6296	break;
		6297
		6298	case 414 : if (DEBUG) { System.out.println("TypeAnnotations ::= Annotation"); } //$NON-NLS-1$
		6299	consumeTypeAnnotation(false);
		6300	break;
		6301
		6302	case 415 : if (DEBUG) { System.out.println("TypeAnnotations ::= TypeAnnotations Annotation"); } //$NON-NLS-1$
		6303	consumeOneMoreTypeAnnotation();
		6304	break;
		6305
		6306	case 416 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); } //$NON-NLS-1$
5884	consumeDims();	6307	consumeDims();
5885	break;	6308	break;
5886		6309
5887	case 374 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); } //$NON-NLS-1$	6310	case 419 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); } //$NON-NLS-1$
5888	consumeOneDimLoop();	6311	consumeOneDimLoop(false);
5889	break;	6312	break;
5890		6313
5891	case 375 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); } //$NON-NLS-1$	6314	case 420 : if (DEBUG) { System.out.println("OneDimLoop ::= TypeAnnotations LBRACKET RBRACKET"); } //$NON-NLS-1$
		6315	consumeOneDimLoopWithAnnotations();
		6316	break;
		6317
		6318	case 421 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); } //$NON-NLS-1$
5892	consumeFieldAccess(false);	6319	consumeFieldAccess(false);
5893	break;	6320	break;
5894		6321
5895	case 376 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); } //$NON-NLS-1$	6322	case 422 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); } //$NON-NLS-1$
5896	consumeFieldAccess(true);	6323	consumeFieldAccess(true);
5897	break;	6324	break;
5898		6325
5899	case 377 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$	6326	case 423 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
5900	consumeMethodInvocationName();	6327	consumeMethodInvocationName();
5901	break;	6328	break;
5902		6329
5903	case 378 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6330	case 424 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5904	consumeMethodInvocationNameWithTypeArguments();	6331	consumeMethodInvocationNameWithTypeArguments();
5905	break;	6332	break;
5906		6333
5907	case 379 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6334	case 425 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5908	consumeMethodInvocationPrimaryWithTypeArguments();	6335	consumeMethodInvocationPrimaryWithTypeArguments();
5909	break;	6336	break;
5910		6337
5911	case 380 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); } //$NON-NLS-1$	6338	case 426 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); } //$NON-NLS-1$
5912	consumeMethodInvocationPrimary();	6339	consumeMethodInvocationPrimary();
5913	break;	6340	break;
5914		6341
5915	case 381 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); } //$NON-NLS-1$	6342	case 427 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); } //$NON-NLS-1$
5916	consumeMethodInvocationSuperWithTypeArguments();	6343	consumeMethodInvocationSuperWithTypeArguments();
5917	break;	6344	break;
5918		6345
5919	case 382 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); } //$NON-NLS-1$	6346	case 428 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); } //$NON-NLS-1$
5920	consumeMethodInvocationSuper();	6347	consumeMethodInvocationSuper();
5921	break;	6348	break;
5922		6349
5923	case 383 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); } //$NON-NLS-1$	6350	case 429 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); } //$NON-NLS-1$
5924	consumeArrayAccess(true);	6351	consumeArrayAccess(true);
5925	break;	6352	break;
5926		6353
5927	case 384 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); } //$NON-NLS-1$	6354	case 430 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); } //$NON-NLS-1$
5928	consumeArrayAccess(false);	6355	consumeArrayAccess(false);
5929	break;	6356	break;
5930		6357
5931	case 385 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); } //$NON-NLS-1$	6358	case 431 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); } //$NON-NLS-1$
5932	consumeArrayAccess(false);	6359	consumeArrayAccess(false);
5933	break;	6360	break;
5934		6361
5935	case 387 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); } //$NON-NLS-1$	6362	case 433 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); } //$NON-NLS-1$
5936	consumePostfixExpression();	6363	consumePostfixExpression();
5937	break;	6364	break;
5938		6365
5939	case 390 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); } //$NON-NLS-1$	6366	case 436 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); } //$NON-NLS-1$
5940	consumeUnaryExpression(OperatorIds.PLUS,true);	6367	consumeUnaryExpression(OperatorIds.PLUS,true);
5941	break;	6368	break;
5942		6369
5943	case 391 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); } //$NON-NLS-1$	6370	case 437 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); } //$NON-NLS-1$
5944	consumeUnaryExpression(OperatorIds.MINUS,true);	6371	consumeUnaryExpression(OperatorIds.MINUS,true);
5945	break;	6372	break;
5946		6373
5947	case 392 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$	6374	case 438 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$
5948	consumePushPosition();	6375	consumePushPosition();
5949	break;	6376	break;
5950		6377
5951	case 395 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$	6378	case 441 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$
5952	consumeUnaryExpression(OperatorIds.PLUS);	6379	consumeUnaryExpression(OperatorIds.PLUS);
5953	break;	6380	break;
5954		6381
5955	case 396 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$	6382	case 442 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$
5956	consumeUnaryExpression(OperatorIds.MINUS);	6383	consumeUnaryExpression(OperatorIds.MINUS);
5957	break;	6384	break;
5958		6385
5959	case 398 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$	6386	case 444 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$
5960	consumeUnaryExpression(OperatorIds.PLUS,false);	6387	consumeUnaryExpression(OperatorIds.PLUS,false);
5961	break;	6388	break;
5962		6389
5963	case 399 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$	6390	case 445 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$
5964	consumeUnaryExpression(OperatorIds.MINUS,false);	6391	consumeUnaryExpression(OperatorIds.MINUS,false);
5965	break;	6392	break;
5966		6393
5967	case 401 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$	6394	case 447 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$
5968	consumeUnaryExpression(OperatorIds.TWIDDLE);	6395	consumeUnaryExpression(OperatorIds.TWIDDLE);
5969	break;	6396	break;
5970		6397
5971	case 402 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$	6398	case 448 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$
5972	consumeUnaryExpression(OperatorIds.NOT);	6399	consumeUnaryExpression(OperatorIds.NOT);
5973	break;	6400	break;
5974		6401
5975	case 404 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); } //$NON-NLS-1$	6402	case 450 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); } //$NON-NLS-1$
5976	consumeCastExpressionWithPrimitiveType();	6403	consumeCastExpressionWithPrimitiveType();
5977	break;	6404	break;
5978		6405
5979	case 405 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$	6406	case 451 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN TypeAnnotations..."); } //$NON-NLS-1$
		6407	consumeCastExpressionWithPrimitiveType();
		6408	break;
		6409
		6410	case 452 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$
5980	consumeCastExpressionWithGenericsArray();	6411	consumeCastExpressionWithGenericsArray();
5981	break;	6412	break;
5982		6413
5983	case 406 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$	6414	case 453 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN TypeAnnotations Name..."); } //$NON-NLS-1$
		6415	consumeCastExpressionWithGenericsArray();
		6416	break;
		6417
		6418	case 454 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } //$NON-NLS-1$
		6419	consumeCastExpressionWithQualifiedGenericsArray();
		6420	break;
		6421
		6422	case 455 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN TypeAnnotations Name..."); } //$NON-NLS-1$
5984	consumeCastExpressionWithQualifiedGenericsArray();	6423	consumeCastExpressionWithQualifiedGenericsArray();
5985	break;	6424	break;
5986		6425
5987	case 407 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); } //$NON-NLS-1$	6426	case 456 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); } //$NON-NLS-1$
5988	consumeCastExpressionLL1();	6427	consumeCastExpressionLL1();
5989	break;	6428	break;
5990		6429
5991	case 408 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); } //$NON-NLS-1$	6430	case 457 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN TypeAnnotations Name..."); } //$NON-NLS-1$
		6431	consumeCastExpressionLL1();
		6432	break;
		6433
		6434	case 458 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims..."); } //$NON-NLS-1$
		6435	consumeCastExpressionWithNameArray();
		6436	break;
		6437
		6438	case 459 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN TypeAnnotations Name Dims"); } //$NON-NLS-1$
5992	consumeCastExpressionWithNameArray();	6439	consumeCastExpressionWithNameArray();
5993	break;	6440	break;
5994		6441
5995	case 409 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); } //$NON-NLS-1$	6442	case 460 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); } //$NON-NLS-1$
5996	consumeOnlyTypeArgumentsForCastExpression();	6443	consumeOnlyTypeArgumentsForCastExpression();
5997	break;	6444	break;
5998		6445
5999	case 410 : if (DEBUG) { System.out.println("InsideCastExpression ::="); } //$NON-NLS-1$	6446	case 461 : if (DEBUG) { System.out.println("InsideCastExpression ::="); } //$NON-NLS-1$
6000	consumeInsideCastExpression();	6447	consumeInsideCastExpression();
6001	break;	6448	break;
6002		6449
6003	case 411 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); } //$NON-NLS-1$	6450	case 462 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); } //$NON-NLS-1$
6004	consumeInsideCastExpressionLL1();	6451	consumeInsideCastExpressionLL1();
6005	break;	6452	break;
6006		6453
6007	case 412 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); } //$NON-NLS-1$	6454	case 463 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); } //$NON-NLS-1$
6008	consumeInsideCastExpressionWithQualifiedGenerics();	6455	consumeInsideCastExpressionWithQualifiedGenerics();
6009	break;	6456	break;
6010		6457
6011	case 414 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6458	case 465 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6012	consumeBinaryExpression(OperatorIds.MULTIPLY);	6459	consumeBinaryExpression(OperatorIds.MULTIPLY);
6013	break;	6460	break;
6014		6461
6015	case 415 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6462	case 466 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6016	consumeBinaryExpression(OperatorIds.DIVIDE);	6463	consumeBinaryExpression(OperatorIds.DIVIDE);
6017	break;	6464	break;
6018		6465
6019	case 416 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$	6466	case 467 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
6020	consumeBinaryExpression(OperatorIds.REMAINDER);	6467	consumeBinaryExpression(OperatorIds.REMAINDER);
6021	break;	6468	break;
6022		6469
6023	case 418 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$	6470	case 469 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$
6024	consumeBinaryExpression(OperatorIds.PLUS);	6471	consumeBinaryExpression(OperatorIds.PLUS);
6025	break;	6472	break;
6026		6473
6027	case 419 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$	6474	case 470 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$
6028	consumeBinaryExpression(OperatorIds.MINUS);	6475	consumeBinaryExpression(OperatorIds.MINUS);
6029	break;	6476	break;
6030		6477
6031	case 421 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$	6478	case 472 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$
6032	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);	6479	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
6033	break;	6480	break;
6034		6481
6035	case 422 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$	6482	case 473 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$
6036	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);	6483	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
6037	break;	6484	break;
6038		6485
6039	case 423 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6486	case 474 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6040	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);	6487	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6041	break;	6488	break;
6042		6489
6043	case 425 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$	6490	case 476 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$
6044	consumeBinaryExpression(OperatorIds.LESS);	6491	consumeBinaryExpression(OperatorIds.LESS);
6045	break;	6492	break;
6046		6493
6047	case 426 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$	6494	case 477 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$
6048	consumeBinaryExpression(OperatorIds.GREATER);	6495	consumeBinaryExpression(OperatorIds.GREATER);
6049	break;	6496	break;
6050		6497
6051	case 427 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$	6498	case 478 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$
6052	consumeBinaryExpression(OperatorIds.LESS_EQUAL);	6499	consumeBinaryExpression(OperatorIds.LESS_EQUAL);
6053	break;	6500	break;
6054		6501
6055	case 428 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$	6502	case 479 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$
6056	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);	6503	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
6057	break;	6504	break;
6058		6505
6059	case 430 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$	6506	case 481 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } //$NON-NLS-1$
6060	consumeInstanceOfExpression();	6507	consumeInstanceOfExpression();
6061	break;	6508	break;
6062		6509
6063	case 432 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$	6510	case 483 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$
6064	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);	6511	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
6065	break;	6512	break;
6066		6513
6067	case 433 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$	6514	case 484 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$
6068	consumeEqualityExpression(OperatorIds.NOT_EQUAL);	6515	consumeEqualityExpression(OperatorIds.NOT_EQUAL);
6069	break;	6516	break;
6070		6517
6071	case 435 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$	6518	case 486 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$
6072	consumeBinaryExpression(OperatorIds.AND);	6519	consumeBinaryExpression(OperatorIds.AND);
6073	break;	6520	break;
6074		6521
6075	case 437 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$	6522	case 488 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$
6076	consumeBinaryExpression(OperatorIds.XOR);	6523	consumeBinaryExpression(OperatorIds.XOR);
6077	break;	6524	break;
6078		6525
6079	case 439 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$	6526	case 490 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$
6080	consumeBinaryExpression(OperatorIds.OR);	6527	consumeBinaryExpression(OperatorIds.OR);
6081	break;	6528	break;
6082		6529
6083	case 441 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$	6530	case 492 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$
6084	consumeBinaryExpression(OperatorIds.AND_AND);	6531	consumeBinaryExpression(OperatorIds.AND_AND);
6085	break;	6532	break;
6086		6533
6087	case 443 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$	6534	case 494 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
6088	consumeBinaryExpression(OperatorIds.OR_OR);	6535	consumeBinaryExpression(OperatorIds.OR_OR);
6089	break;	6536	break;
6090		6537
6091	case 445 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$	6538	case 496 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
6092	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;	6539	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
6093	break;	6540	break;
6094		6541
6095	case 448 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$	6542	case 499 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$
6096	consumeAssignment();	6543	consumeAssignment();
6097	break;	6544	break;
6098		6545
6099	case 450 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); } //$NON-NLS-1$	6546	case 501 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); } //$NON-NLS-1$
6100	ignoreExpressionAssignment();	6547	ignoreExpressionAssignment();
6101	break;	6548	break;
6102		6549
6103	case 451 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$	6550	case 502 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$
6104	consumeAssignmentOperator(EQUAL);	6551	consumeAssignmentOperator(EQUAL);
6105	break;	6552	break;
6106		6553
6107	case 452 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$	6554	case 503 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$
6108	consumeAssignmentOperator(MULTIPLY);	6555	consumeAssignmentOperator(MULTIPLY);
6109	break;	6556	break;
6110		6557
6111	case 453 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$	6558	case 504 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$
6112	consumeAssignmentOperator(DIVIDE);	6559	consumeAssignmentOperator(DIVIDE);
6113	break;	6560	break;
6114		6561
6115	case 454 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$	6562	case 505 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$
6116	consumeAssignmentOperator(REMAINDER);	6563	consumeAssignmentOperator(REMAINDER);
6117	break;	6564	break;
6118		6565
6119	case 455 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$	6566	case 506 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$
6120	consumeAssignmentOperator(PLUS);	6567	consumeAssignmentOperator(PLUS);
6121	break;	6568	break;
6122		6569
6123	case 456 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$	6570	case 507 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$
6124	consumeAssignmentOperator(MINUS);	6571	consumeAssignmentOperator(MINUS);
6125	break;	6572	break;
6126		6573
6127	case 457 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$	6574	case 508 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$
6128	consumeAssignmentOperator(LEFT_SHIFT);	6575	consumeAssignmentOperator(LEFT_SHIFT);
6129	break;	6576	break;
6130		6577
6131	case 458 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$	6578	case 509 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
6132	consumeAssignmentOperator(RIGHT_SHIFT);	6579	consumeAssignmentOperator(RIGHT_SHIFT);
6133	break;	6580	break;
6134		6581
6135	case 459 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$	6582	case 510 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
6136	consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);	6583	consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);
6137	break;	6584	break;
6138		6585
6139	case 460 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$	6586	case 511 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$
6140	consumeAssignmentOperator(AND);	6587	consumeAssignmentOperator(AND);
6141	break;	6588	break;
6142		6589
6143	case 461 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$	6590	case 512 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$
6144	consumeAssignmentOperator(XOR);	6591	consumeAssignmentOperator(XOR);
6145	break;	6592	break;
6146		6593
6147	case 462 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$	6594	case 513 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$
6148	consumeAssignmentOperator(OR);	6595	consumeAssignmentOperator(OR);
6149	break;	6596	break;
6150		6597
6151	case 466 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$	6598	case 517 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$
6152	consumeEmptyExpression();	6599	consumeEmptyExpression();
6153	break;	6600	break;
6154		6601
6155	case 471 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); } //$NON-NLS-1$	6602	case 522 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); } //$NON-NLS-1$
6156	consumeEmptyClassBodyDeclarationsopt();	6603	consumeEmptyClassBodyDeclarationsopt();
6157	break;	6604	break;
6158		6605
6159	case 472 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	6606	case 523 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6160	consumeClassBodyDeclarationsopt();	6607	consumeClassBodyDeclarationsopt();
6161	break;	6608	break;
6162		6609
6163	case 473 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$	6610	case 524 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::="); } //$NON-NLS-1$
6164	consumeDefaultModifiers();	6611	consumeDefaultModifiers();
6165	break;	6612	break;
6166		6613
6167	case 474 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); } //$NON-NLS-1$	6614	case 525 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::= NonAnnotModifiers"); } //$NON-NLS-1$
6168	consumeModifiers();	6615	consumeModifiers();
6169	break;	6616	break;
6170		6617
6171	case 475 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$	6618	case 526 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$
		6619	consumeDefaultModifiers();
		6620	break;
		6621
		6622	case 527 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); } //$NON-NLS-1$
		6623	consumeModifiers();
		6624	break;
		6625
		6626	case 528 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$
6172	consumeEmptyBlockStatementsopt();	6627	consumeEmptyBlockStatementsopt();
6173	break;	6628	break;
6174		6629
6175	case 477 : if (DEBUG) { System.out.println("Dimsopt ::="); } //$NON-NLS-1$	6630	case 530 : if (DEBUG) { System.out.println("Dimsopt ::="); } //$NON-NLS-1$
6176	consumeEmptyDimsopt();	6631	consumeEmptyDimsopt();
6177	break;	6632	break;
6178		6633
6179	case 479 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$	6634	case 532 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$
6180	consumeEmptyArgumentListopt();	6635	consumeEmptyArgumentListopt();
6181	break;	6636	break;
6182		6637
6183	case 483 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$	6638	case 536 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$
6184	consumeFormalParameterListopt();	6639	consumeFormalParameterListopt();
6185	break;	6640	break;
6186		6641
6187	case 487 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); } //$NON-NLS-1$	6642	case 540 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); } //$NON-NLS-1$
6188	consumeEmptyInterfaceMemberDeclarationsopt();	6643	consumeEmptyInterfaceMemberDeclarationsopt();
6189	break;	6644	break;
6190		6645
6191	case 488 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	6646	case 541 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6192	consumeInterfaceMemberDeclarationsopt();	6647	consumeInterfaceMemberDeclarationsopt();
6193	break;	6648	break;
6194		6649
6195	case 489 : if (DEBUG) { System.out.println("NestedType ::="); } //$NON-NLS-1$	6650	case 542 : if (DEBUG) { System.out.println("NestedType ::="); } //$NON-NLS-1$
6196	consumeNestedType();	6651	consumeNestedType();
6197	break;	6652	break;
6198		6653
6199	case 490 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$	6654	case 543 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$
6200	consumeEmptyForInitopt();	6655	consumeEmptyForInitopt();
6201	break;	6656	break;
6202		6657
6203	case 492 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$	6658	case 545 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$
6204	consumeEmptyForUpdateopt();	6659	consumeEmptyForUpdateopt();
6205	break;	6660	break;
6206		6661
6207	case 496 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$	6662	case 549 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$
6208	consumeEmptyCatchesopt();	6663	consumeEmptyCatchesopt();
6209	break;	6664	break;
6210		6665
6211	case 498 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); } //$NON-NLS-1$	6666	case 551 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); } //$NON-NLS-1$
6212	consumeEnumDeclaration();	6667	consumeEnumDeclaration();
6213	break;	6668	break;
6214		6669
6215	case 499 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); } //$NON-NLS-1$	6670	case 552 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); } //$NON-NLS-1$
6216	consumeEnumHeader();	6671	consumeEnumHeader();
6217	break;	6672	break;
6218		6673
6219	case 500 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); } //$NON-NLS-1$	6674	case 553 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); } //$NON-NLS-1$
6220	consumeEnumHeaderName();	6675	consumeEnumHeaderName();
6221	break;	6676	break;
6222		6677
6223	case 501 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); } //$NON-NLS-1$	6678	case 554 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); } //$NON-NLS-1$
6224	consumeEnumHeaderNameWithTypeParameters();	6679	consumeEnumHeaderNameWithTypeParameters();
6225	break;	6680	break;
6226		6681
6227	case 502 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); } //$NON-NLS-1$	6682	case 555 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); } //$NON-NLS-1$
6228	consumeEnumBodyNoConstants();	6683	consumeEnumBodyNoConstants();
6229	break;	6684	break;
6230		6685
6231	case 503 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); } //$NON-NLS-1$	6686	case 556 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); } //$NON-NLS-1$
6232	consumeEnumBodyNoConstants();	6687	consumeEnumBodyNoConstants();
6233	break;	6688	break;
6234		6689
6235	case 504 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); } //$NON-NLS-1$	6690	case 557 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); } //$NON-NLS-1$
6236	consumeEnumBodyWithConstants();	6691	consumeEnumBodyWithConstants();
6237	break;	6692	break;
6238		6693
6239	case 505 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); } //$NON-NLS-1$	6694	case 558 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); } //$NON-NLS-1$
6240	consumeEnumBodyWithConstants();	6695	consumeEnumBodyWithConstants();
6241	break;	6696	break;
6242		6697
6243	case 507 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); } //$NON-NLS-1$	6698	case 560 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); } //$NON-NLS-1$
6244	consumeEnumConstants();	6699	consumeEnumConstants();
6245	break;	6700	break;
6246		6701
6247	case 508 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); } //$NON-NLS-1$	6702	case 561 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); } //$NON-NLS-1$
6248	consumeEnumConstantHeaderName();	6703	consumeEnumConstantHeaderName();
6249	break;	6704	break;
6250		6705
6251	case 509 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); } //$NON-NLS-1$	6706	case 562 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); } //$NON-NLS-1$
6252	consumeEnumConstantHeader();	6707	consumeEnumConstantHeader();
6253	break;	6708	break;
6254		6709
6255	case 510 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); } //$NON-NLS-1$	6710	case 563 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); } //$NON-NLS-1$
6256	consumeEnumConstantWithClassBody();	6711	consumeEnumConstantWithClassBody();
6257	break;	6712	break;
6258		6713
6259	case 511 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); } //$NON-NLS-1$	6714	case 564 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); } //$NON-NLS-1$
6260	consumeEnumConstantNoClassBody();	6715	consumeEnumConstantNoClassBody();
6261	break;	6716	break;
6262		6717
6263	case 512 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$	6718	case 565 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
6264	consumeArguments();	6719	consumeArguments();
6265	break;	6720	break;
6266		6721
6267	case 513 : if (DEBUG) { System.out.println("Argumentsopt ::="); } //$NON-NLS-1$	6722	case 566 : if (DEBUG) { System.out.println("Argumentsopt ::="); } //$NON-NLS-1$
6268	consumeEmptyArguments();	6723	consumeEmptyArguments();
6269	break;	6724	break;
6270		6725
6271	case 515 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); } //$NON-NLS-1$	6726	case 568 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); } //$NON-NLS-1$
6272	consumeEnumDeclarations();	6727	consumeEnumDeclarations();
6273	break;	6728	break;
6274		6729
6275	case 516 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); } //$NON-NLS-1$	6730	case 569 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); } //$NON-NLS-1$
6276	consumeEmptyEnumDeclarations();	6731	consumeEmptyEnumDeclarations();
6277	break;	6732	break;
6278		6733
6279	case 518 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); } //$NON-NLS-1$	6734	case 571 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); } //$NON-NLS-1$
6280	consumeEnhancedForStatement();	6735	consumeEnhancedForStatement();
6281	break;	6736	break;
6282		6737
6283	case 519 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); } //$NON-NLS-1$	6738	case 572 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); } //$NON-NLS-1$
6284	consumeEnhancedForStatement();	6739	consumeEnhancedForStatement();
6285	break;	6740	break;
6286		6741
6287	case 520 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); } //$NON-NLS-1$	6742	case 573 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type0..."); } //$NON-NLS-1$
6288	consumeEnhancedForStatementHeaderInit(false);	6743	consumeEnhancedForStatementHeaderInit(false);
6289	break;	6744	break;
6290		6745
6291	case 521 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } //$NON-NLS-1$	6746	case 574 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } //$NON-NLS-1$
6292	consumeEnhancedForStatementHeaderInit(true);	6747	consumeEnhancedForStatementHeaderInit(true);
6293	break;	6748	break;
6294		6749
6295	case 522 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } //$NON-NLS-1$	6750	case 575 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } //$NON-NLS-1$
6296	consumeEnhancedForStatementHeader();	6751	consumeEnhancedForStatementHeader();
6297	break;	6752	break;
6298		6753
6299	case 523 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } //$NON-NLS-1$	6754	case 576 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } //$NON-NLS-1$
6300	consumeImportDeclaration();	6755	consumeImportDeclaration();
6301	break;	6756	break;
6302		6757
6303	case 524 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } //$NON-NLS-1$	6758	case 577 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } //$NON-NLS-1$
6304	consumeSingleStaticImportDeclarationName();	6759	consumeSingleStaticImportDeclarationName();
6305	break;	6760	break;
6306		6761
6307	case 525 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$	6762	case 578 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$
6308	consumeImportDeclaration();	6763	consumeImportDeclaration();
6309	break;	6764	break;
6310		6765
6311	case 526 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } //$NON-NLS-1$	6766	case 579 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } //$NON-NLS-1$
6312	consumeStaticImportOnDemandDeclarationName();	6767	consumeStaticImportOnDemandDeclarationName();
6313	break;	6768	break;
6314		6769
6315	case 527 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$	6770	case 580 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$
6316	consumeTypeArguments();	6771	consumeTypeArguments();
6317	break;	6772	break;
6318		6773
6319	case 528 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$	6774	case 581 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$
6320	consumeOnlyTypeArguments();	6775	consumeOnlyTypeArguments();
6321	break;	6776	break;
6322		6777
6323	case 530 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6778	case 583 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6324	consumeTypeArgumentList1();	6779	consumeTypeArgumentList1();
6325	break;	6780	break;
6326		6781
6327	case 532 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } //$NON-NLS-1$	6782	case 585 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } //$NON-NLS-1$
6328	consumeTypeArgumentList();	6783	consumeTypeArgumentList();
6329	break;	6784	break;
6330		6785
6331	case 533 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } //$NON-NLS-1$	6786	case 586 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } //$NON-NLS-1$
6332	consumeTypeArgument();	6787	consumeTypeArgument();
6333	break;	6788	break;
6334		6789
6335	case 537 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } //$NON-NLS-1$	6790	case 590 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } //$NON-NLS-1$
6336	consumeReferenceType1();	6791	consumeReferenceType1();
6337	break;	6792	break;
6338		6793
6339	case 538 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$	6794	case 591 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$
		6795	consumeTypeArgumentReferenceType1();
		6796	break;
		6797
		6798	case 592 : if (DEBUG) { System.out.println("ReferenceType1 ::= TypeAnnotations ClassOrInterface LESS"); } //$NON-NLS-1$
6340	consumeTypeArgumentReferenceType1();	6799	consumeTypeArgumentReferenceType1();
6341	break;	6800	break;
6342		6801
6343	case 540 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6802	case 594 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6344	consumeTypeArgumentList2();	6803	consumeTypeArgumentList2();
6345	break;	6804	break;
6346		6805
6347	case 543 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } //$NON-NLS-1$	6806	case 597 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } //$NON-NLS-1$
6348	consumeReferenceType2();	6807	consumeReferenceType2();
6349	break;	6808	break;
6350		6809
6351	case 544 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$	6810	case 598 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$
6352	consumeTypeArgumentReferenceType2();	6811	consumeTypeArgumentReferenceType2();
6353	break;	6812	break;
6354		6813
6355	case 546 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$	6814	case 599 : if (DEBUG) { System.out.println("ReferenceType2 ::= TypeAnnotations ClassOrInterface LESS"); } //$NON-NLS-1$
		6815	consumeTypeArgumentReferenceType2();
		6816	break;
		6817
		6818	case 601 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$
6356	consumeTypeArgumentList3();	6819	consumeTypeArgumentList3();
6357	break;	6820	break;
6358		6821
6359	case 549 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6822	case 604 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6360	consumeReferenceType3();	6823	consumeReferenceType3();
6361	break;	6824	break;
6362		6825
6363	case 550 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } //$NON-NLS-1$	6826	case 605 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } //$NON-NLS-1$
6364	consumeWildcard();	6827	consumeWildcard();
6365	break;	6828	break;
6366		6829
6367	case 551 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } //$NON-NLS-1$	6830	case 606 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } //$NON-NLS-1$
6368	consumeWildcardWithBounds();	6831	consumeWildcardWithBounds();
6369	break;	6832	break;
6370		6833
6371	case 552 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } //$NON-NLS-1$	6834	case 607 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } //$NON-NLS-1$
6372	consumeWildcardBoundsExtends();	6835	consumeWildcardBoundsExtends();
6373	break;	6836	break;
6374		6837
6375	case 553 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } //$NON-NLS-1$	6838	case 608 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } //$NON-NLS-1$
6376	consumeWildcardBoundsSuper();	6839	consumeWildcardBoundsSuper();
6377	break;	6840	break;
6378		6841
6379	case 554 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } //$NON-NLS-1$	6842	case 609 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } //$NON-NLS-1$
6380	consumeWildcard1();	6843	consumeWildcard1();
6381	break;	6844	break;
6382		6845
6383	case 555 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } //$NON-NLS-1$	6846	case 610 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } //$NON-NLS-1$
6384	consumeWildcard1WithBounds();	6847	consumeWildcard1WithBounds();
6385	break;	6848	break;
6386		6849
6387	case 556 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } //$NON-NLS-1$	6850	case 611 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } //$NON-NLS-1$
6388	consumeWildcardBounds1Extends();	6851	consumeWildcardBounds1Extends();
6389	break;	6852	break;
6390		6853
6391	case 557 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } //$NON-NLS-1$	6854	case 612 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } //$NON-NLS-1$
6392	consumeWildcardBounds1Super();	6855	consumeWildcardBounds1Super();
6393	break;	6856	break;
6394		6857
6395	case 558 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } //$NON-NLS-1$	6858	case 613 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } //$NON-NLS-1$
6396	consumeWildcard2();	6859	consumeWildcard2();
6397	break;	6860	break;
6398		6861
6399	case 559 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } //$NON-NLS-1$	6862	case 614 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } //$NON-NLS-1$
6400	consumeWildcard2WithBounds();	6863	consumeWildcard2WithBounds();
6401	break;	6864	break;
6402		6865
6403	case 560 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } //$NON-NLS-1$	6866	case 615 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } //$NON-NLS-1$
6404	consumeWildcardBounds2Extends();	6867	consumeWildcardBounds2Extends();
6405	break;	6868	break;
6406		6869
6407	case 561 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } //$NON-NLS-1$	6870	case 616 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } //$NON-NLS-1$
6408	consumeWildcardBounds2Super();	6871	consumeWildcardBounds2Super();
6409	break;	6872	break;
6410		6873
6411	case 562 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$	6874	case 617 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
6412	consumeWildcard3();	6875	consumeWildcard3();
6413	break;	6876	break;
6414		6877
6415	case 563 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } //$NON-NLS-1$	6878	case 618 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } //$NON-NLS-1$
6416	consumeWildcard3WithBounds();	6879	consumeWildcard3WithBounds();
6417	break;	6880	break;
6418		6881
6419	case 564 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } //$NON-NLS-1$	6882	case 619 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } //$NON-NLS-1$
6420	consumeWildcardBounds3Extends();	6883	consumeWildcardBounds3Extends();
6421	break;	6884	break;
6422		6885
6423	case 565 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } //$NON-NLS-1$	6886	case 620 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } //$NON-NLS-1$
6424	consumeWildcardBounds3Super();	6887	consumeWildcardBounds3Super();
6425	break;	6888	break;
6426		6889
6427	case 566 : if (DEBUG) { System.out.println("TypeParameterHeader ::= Identifier"); } //$NON-NLS-1$	6890	case 621 : if (DEBUG) { System.out.println("PushZeroTypeAnnotations ::="); } //$NON-NLS-1$
		6891	consumeZeroTypeAnnotations(true);
		6892	break;
		6893
		6894	case 622 : if (DEBUG) { System.out.println("TypeParameterHeader ::= PushZeroTypeAnnotations..."); } //$NON-NLS-1$
6428	consumeTypeParameterHeader();	6895	consumeTypeParameterHeader();
6429	break;	6896	break;
6430		6897
6431	case 567 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } //$NON-NLS-1$	6898	case 623 : if (DEBUG) { System.out.println("TypeParameterHeader ::= TypeAnnotations Identifier"); } //$NON-NLS-1$
		6899	consumeTypeParameterHeader();
		6900	break;
		6901
		6902	case 624 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } //$NON-NLS-1$
6432	consumeTypeParameters();	6903	consumeTypeParameters();
6433	break;	6904	break;
6434		6905
6435	case 569 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } //$NON-NLS-1$	6906	case 626 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } //$NON-NLS-1$
6436	consumeTypeParameterList();	6907	consumeTypeParameterList();
6437	break;	6908	break;
6438		6909
6439	case 571 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6910	case 628 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6440	consumeTypeParameterWithExtends();	6911	consumeTypeParameterWithExtends();
6441	break;	6912	break;
6442		6913
6443	case 572 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6914	case 629 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6444	consumeTypeParameterWithExtendsAndBounds();	6915	consumeTypeParameterWithExtendsAndBounds();
6445	break;	6916	break;
6446		6917
6447	case 574 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } //$NON-NLS-1$	6918	case 631 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } //$NON-NLS-1$
6448	consumeAdditionalBoundList();	6919	consumeAdditionalBoundList();
6449	break;	6920	break;
6450		6921
6451	case 575 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } //$NON-NLS-1$	6922	case 632 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } //$NON-NLS-1$
6452	consumeAdditionalBound();	6923	consumeAdditionalBound();
6453	break;	6924	break;
6454		6925
6455	case 577 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } //$NON-NLS-1$	6926	case 634 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } //$NON-NLS-1$
6456	consumeTypeParameterList1();	6927	consumeTypeParameterList1();
6457	break;	6928	break;
6458		6929
6459	case 578 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } //$NON-NLS-1$	6930	case 635 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } //$NON-NLS-1$
6460	consumeTypeParameter1();	6931	consumeTypeParameter1();
6461	break;	6932	break;
6462		6933
6463	case 579 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6934	case 636 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6464	consumeTypeParameter1WithExtends();	6935	consumeTypeParameter1WithExtends();
6465	break;	6936	break;
6466		6937
6467	case 580 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$	6938	case 637 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$
6468	consumeTypeParameter1WithExtendsAndBounds();	6939	consumeTypeParameter1WithExtendsAndBounds();
6469	break;	6940	break;
6470		6941
6471	case 582 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } //$NON-NLS-1$	6942	case 639 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } //$NON-NLS-1$
6472	consumeAdditionalBoundList1();	6943	consumeAdditionalBoundList1();
6473	break;	6944	break;
6474		6945
6475	case 583 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } //$NON-NLS-1$	6946	case 640 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } //$NON-NLS-1$
6476	consumeAdditionalBound1();	6947	consumeAdditionalBound1();
6477	break;	6948	break;
6478		6949
6479	case 589 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } //$NON-NLS-1$	6950	case 646 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } //$NON-NLS-1$
6480	consumeUnaryExpression(OperatorIds.PLUS);	6951	consumeUnaryExpression(OperatorIds.PLUS);
6481	break;	6952	break;
6482		6953
6483	case 590 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } //$NON-NLS-1$	6954	case 647 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } //$NON-NLS-1$
6484	consumeUnaryExpression(OperatorIds.MINUS);	6955	consumeUnaryExpression(OperatorIds.MINUS);
6485	break;	6956	break;
6486		6957
6487	case 593 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } //$NON-NLS-1$	6958	case 650 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } //$NON-NLS-1$
6488	consumeUnaryExpression(OperatorIds.TWIDDLE);	6959	consumeUnaryExpression(OperatorIds.TWIDDLE);
6489	break;	6960	break;
6490		6961
6491	case 594 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } //$NON-NLS-1$	6962	case 651 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } //$NON-NLS-1$
6492	consumeUnaryExpression(OperatorIds.NOT);	6963	consumeUnaryExpression(OperatorIds.NOT);
6493	break;	6964	break;
6494		6965
6495	case 597 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6966	case 654 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6496	consumeBinaryExpression(OperatorIds.MULTIPLY);	6967	consumeBinaryExpression(OperatorIds.MULTIPLY);
6497	break;	6968	break;
6498		6969
6499	case 598 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } //$NON-NLS-1$	6970	case 655 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } //$NON-NLS-1$
6500	consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);	6971	consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);
6501	break;	6972	break;
6502		6973
6503	case 599 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6974	case 656 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6504	consumeBinaryExpression(OperatorIds.DIVIDE);	6975	consumeBinaryExpression(OperatorIds.DIVIDE);
6505	break;	6976	break;
6506		6977
6507	case 600 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } //$NON-NLS-1$	6978	case 657 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } //$NON-NLS-1$
6508	consumeBinaryExpressionWithName(OperatorIds.DIVIDE);	6979	consumeBinaryExpressionWithName(OperatorIds.DIVIDE);
6509	break;	6980	break;
6510		6981
6511	case 601 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$	6982	case 658 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$
6512	consumeBinaryExpression(OperatorIds.REMAINDER);	6983	consumeBinaryExpression(OperatorIds.REMAINDER);
6513	break;	6984	break;
6514		6985
6515	case 602 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } //$NON-NLS-1$	6986	case 659 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } //$NON-NLS-1$
6516	consumeBinaryExpressionWithName(OperatorIds.REMAINDER);	6987	consumeBinaryExpressionWithName(OperatorIds.REMAINDER);
6517	break;	6988	break;
6518		6989
6519	case 604 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$	6990	case 661 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$
6520	consumeBinaryExpression(OperatorIds.PLUS);	6991	consumeBinaryExpression(OperatorIds.PLUS);
6521	break;	6992	break;
6522		6993
6523	case 605 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } //$NON-NLS-1$	6994	case 662 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } //$NON-NLS-1$
6524	consumeBinaryExpressionWithName(OperatorIds.PLUS);	6995	consumeBinaryExpressionWithName(OperatorIds.PLUS);
6525	break;	6996	break;
6526		6997
6527	case 606 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$	6998	case 663 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$
6528	consumeBinaryExpression(OperatorIds.MINUS);	6999	consumeBinaryExpression(OperatorIds.MINUS);
6529	break;	7000	break;
6530		7001
6531	case 607 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } //$NON-NLS-1$	7002	case 664 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } //$NON-NLS-1$
6532	consumeBinaryExpressionWithName(OperatorIds.MINUS);	7003	consumeBinaryExpressionWithName(OperatorIds.MINUS);
6533	break;	7004	break;
6534		7005
6535	case 609 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	7006	case 666 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6536	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);	7007	consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
6537	break;	7008	break;
6538		7009
6539	case 610 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } //$NON-NLS-1$	7010	case 667 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } //$NON-NLS-1$
6540	consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);	7011	consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);
6541	break;	7012	break;
6542		7013
6543	case 611 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	7014	case 668 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6544	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);	7015	consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
6545	break;	7016	break;
6546		7017
6547	case 612 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } //$NON-NLS-1$	7018	case 669 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } //$NON-NLS-1$
6548	consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);	7019	consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);
6549	break;	7020	break;
6550		7021
6551	case 613 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$	7022	case 670 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$
6552	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);	7023	consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6553	break;	7024	break;
6554		7025
6555	case 614 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } //$NON-NLS-1$	7026	case 671 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } //$NON-NLS-1$
6556	consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);	7027	consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6557	break;	7028	break;
6558		7029
6559	case 616 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$	7030	case 673 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$
6560	consumeBinaryExpression(OperatorIds.LESS);	7031	consumeBinaryExpression(OperatorIds.LESS);
6561	break;	7032	break;
6562		7033
6563	case 617 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } //$NON-NLS-1$	7034	case 674 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } //$NON-NLS-1$
6564	consumeBinaryExpressionWithName(OperatorIds.LESS);	7035	consumeBinaryExpressionWithName(OperatorIds.LESS);
6565	break;	7036	break;
6566		7037
6567	case 618 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$	7038	case 675 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$
6568	consumeBinaryExpression(OperatorIds.GREATER);	7039	consumeBinaryExpression(OperatorIds.GREATER);
6569	break;	7040	break;
6570		7041
6571	case 619 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } //$NON-NLS-1$	7042	case 676 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } //$NON-NLS-1$
6572	consumeBinaryExpressionWithName(OperatorIds.GREATER);	7043	consumeBinaryExpressionWithName(OperatorIds.GREATER);
6573	break;	7044	break;
6574		7045
6575	case 620 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$	7046	case 677 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$
6576	consumeBinaryExpression(OperatorIds.LESS_EQUAL);	7047	consumeBinaryExpression(OperatorIds.LESS_EQUAL);
6577	break;	7048	break;
6578		7049
6579	case 621 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } //$NON-NLS-1$	7050	case 678 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } //$NON-NLS-1$
6580	consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);	7051	consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);
6581	break;	7052	break;
6582		7053
6583	case 622 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$	7054	case 679 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$
6584	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);	7055	consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
6585	break;	7056	break;
6586		7057
6587	case 623 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } //$NON-NLS-1$	7058	case 680 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } //$NON-NLS-1$
6588	consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);	7059	consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);
6589	break;	7060	break;
6590		7061
6591	case 625 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$	7062	case 682 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$
6592	consumeInstanceOfExpressionWithName();	7063	consumeInstanceOfExpressionWithName();
6593	break;	7064	break;
6594		7065
6595	case 626 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$	7066	case 683 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$
6596	consumeInstanceOfExpression();	7067	consumeInstanceOfExpression();
6597	break;	7068	break;
6598		7069
6599	case 628 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$	7070	case 685 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$
6600	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);	7071	consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
6601	break;	7072	break;
6602		7073
6603	case 629 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } //$NON-NLS-1$	7074	case 686 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } //$NON-NLS-1$
6604	consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);	7075	consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);
6605	break;	7076	break;
6606		7077
6607	case 630 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$	7078	case 687 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$
6608	consumeEqualityExpression(OperatorIds.NOT_EQUAL);	7079	consumeEqualityExpression(OperatorIds.NOT_EQUAL);
6609	break;	7080	break;
6610		7081
6611	case 631 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } //$NON-NLS-1$	7082	case 688 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } //$NON-NLS-1$
6612	consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);	7083	consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);
6613	break;	7084	break;
6614		7085
6615	case 633 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } //$NON-NLS-1$	7086	case 690 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } //$NON-NLS-1$
6616	consumeBinaryExpression(OperatorIds.AND);	7087	consumeBinaryExpression(OperatorIds.AND);
6617	break;	7088	break;
6618		7089
6619	case 634 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } //$NON-NLS-1$	7090	case 691 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } //$NON-NLS-1$
6620	consumeBinaryExpressionWithName(OperatorIds.AND);	7091	consumeBinaryExpressionWithName(OperatorIds.AND);
6621	break;	7092	break;
6622		7093
6623	case 636 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$	7094	case 693 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$
6624	consumeBinaryExpression(OperatorIds.XOR);	7095	consumeBinaryExpression(OperatorIds.XOR);
6625	break;	7096	break;
6626		7097
6627	case 637 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } //$NON-NLS-1$	7098	case 694 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } //$NON-NLS-1$
6628	consumeBinaryExpressionWithName(OperatorIds.XOR);	7099	consumeBinaryExpressionWithName(OperatorIds.XOR);
6629	break;	7100	break;
6630		7101
6631	case 639 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$	7102	case 696 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$
6632	consumeBinaryExpression(OperatorIds.OR);	7103	consumeBinaryExpression(OperatorIds.OR);
6633	break;	7104	break;
6634		7105
6635	case 640 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } //$NON-NLS-1$	7106	case 697 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } //$NON-NLS-1$
6636	consumeBinaryExpressionWithName(OperatorIds.OR);	7107	consumeBinaryExpressionWithName(OperatorIds.OR);
6637	break;	7108	break;
6638		7109
6639	case 642 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } //$NON-NLS-1$	7110	case 699 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } //$NON-NLS-1$
6640	consumeBinaryExpression(OperatorIds.AND_AND);	7111	consumeBinaryExpression(OperatorIds.AND_AND);
6641	break;	7112	break;
6642		7113
6643	case 643 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } //$NON-NLS-1$	7114	case 700 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } //$NON-NLS-1$
6644	consumeBinaryExpressionWithName(OperatorIds.AND_AND);	7115	consumeBinaryExpressionWithName(OperatorIds.AND_AND);
6645	break;	7116	break;
6646		7117
6647	case 645 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } //$NON-NLS-1$	7118	case 702 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } //$NON-NLS-1$
6648	consumeBinaryExpression(OperatorIds.OR_OR);	7119	consumeBinaryExpression(OperatorIds.OR_OR);
6649	break;	7120	break;
6650		7121
6651	case 646 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } //$NON-NLS-1$	7122	case 703 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } //$NON-NLS-1$
6652	consumeBinaryExpressionWithName(OperatorIds.OR_OR);	7123	consumeBinaryExpressionWithName(OperatorIds.OR_OR);
6653	break;	7124	break;
6654		7125
6655	case 648 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } //$NON-NLS-1$	7126	case 705 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } //$NON-NLS-1$
6656	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;	7127	consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
6657	break;	7128	break;
6658		7129
6659	case 649 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } //$NON-NLS-1$	7130	case 706 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } //$NON-NLS-1$
6660	consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;	7131	consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;
6661	break;	7132	break;
6662		7133
6663	case 653 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$	7134	case 710 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$
6664	consumeAnnotationTypeDeclarationHeaderName() ;	7135	consumeAnnotationTypeDeclarationHeaderName() ;
6665	break;	7136	break;
6666		7137
6667	case 654 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$	7138	case 711 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$
6668	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;	7139	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;
6669	break;	7140	break;
6670		7141
6671	case 655 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$	7142	case 712 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$
6672	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;	7143	consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;
6673	break;	7144	break;
6674		7145
6675	case 656 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$	7146	case 713 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$
6676	consumeAnnotationTypeDeclarationHeaderName() ;	7147	consumeAnnotationTypeDeclarationHeaderName() ;
6677	break;	7148	break;
6678		7149
6679	case 657 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } //$NON-NLS-1$	7150	case 714 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } //$NON-NLS-1$
6680	consumeAnnotationTypeDeclarationHeader() ;	7151	consumeAnnotationTypeDeclarationHeader() ;
6681	break;	7152	break;
6682		7153
6683	case 658 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } //$NON-NLS-1$	7154	case 715 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } //$NON-NLS-1$
6684	consumeAnnotationTypeDeclaration() ;	7155	consumeAnnotationTypeDeclaration() ;
6685	break;	7156	break;
6686		7157
6687	case 660 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } //$NON-NLS-1$	7158	case 717 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } //$NON-NLS-1$
6688	consumeEmptyAnnotationTypeMemberDeclarationsopt() ;	7159	consumeEmptyAnnotationTypeMemberDeclarationsopt() ;
6689	break;	7160	break;
6690		7161
6691	case 661 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$	7162	case 718 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$
6692	consumeAnnotationTypeMemberDeclarationsopt() ;	7163	consumeAnnotationTypeMemberDeclarationsopt() ;
6693	break;	7164	break;
6694		7165
6695	case 663 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } //$NON-NLS-1$	7166	case 720 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } //$NON-NLS-1$
6696	consumeAnnotationTypeMemberDeclarations() ;	7167	consumeAnnotationTypeMemberDeclarations() ;
6697	break;	7168	break;
6698		7169
6699	case 664 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } //$NON-NLS-1$	7170	case 721 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } //$NON-NLS-1$
6700	consumeMethodHeaderNameWithTypeParameters(true);	7171	consumeMethodHeaderNameWithTypeParameters(true);
6701	break;	7172	break;
6702		7173
6703	case 665 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$	7174	case 722 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type0..."); } //$NON-NLS-1$
6704	consumeMethodHeaderName(true);	7175	consumeMethodHeaderName(true);
6705	break;	7176	break;
6706		7177
6707	case 666 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } //$NON-NLS-1$	7178	case 723 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } //$NON-NLS-1$
6708	consumeEmptyMethodHeaderDefaultValue() ;	7179	consumeEmptyMethodHeaderDefaultValue() ;
6709	break;	7180	break;
6710		7181
6711	case 667 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } //$NON-NLS-1$	7182	case 724 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } //$NON-NLS-1$
6712	consumeMethodHeaderDefaultValue();	7183	consumeMethodHeaderDefaultValue();
6713	break;	7184	break;
6714		7185
6715	case 668 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } //$NON-NLS-1$	7186	case 725 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } //$NON-NLS-1$
6716	consumeMethodHeader();	7187	consumeMethodHeader();
6717	break;	7188	break;
6718		7189
6719	case 669 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } //$NON-NLS-1$	7190	case 726 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } //$NON-NLS-1$
6720	consumeAnnotationTypeMemberDeclaration() ;	7191	consumeAnnotationTypeMemberDeclaration() ;
6721	break;	7192	break;
6722		7193
6723	case 677 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } //$NON-NLS-1$	7194	case 734 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } //$NON-NLS-1$
6724	consumeAnnotationName() ;	7195	consumeAnnotationName() ;
6725	break;	7196	break;
6726		7197
6727	case 678 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$	7198	case 735 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$
6728	consumeNormalAnnotation() ;	7199	consumeNormalAnnotation() ;
6729	break;	7200	break;
6730		7201
6731	case 679 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } //$NON-NLS-1$	7202	case 736 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } //$NON-NLS-1$
6732	consumeEmptyMemberValuePairsopt() ;	7203	consumeEmptyMemberValuePairsopt() ;
6733	break;	7204	break;
6734		7205
6735	case 682 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } //$NON-NLS-1$	7206	case 739 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } //$NON-NLS-1$
6736	consumeMemberValuePairs() ;	7207	consumeMemberValuePairs() ;
6737	break;	7208	break;
6738		7209
6739	case 683 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } //$NON-NLS-1$	7210	case 740 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } //$NON-NLS-1$
6740	consumeMemberValuePair() ;	7211	consumeMemberValuePair() ;
6741	break;	7212	break;
6742		7213
6743	case 684 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } //$NON-NLS-1$	7214	case 741 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } //$NON-NLS-1$
6744	consumeEnterMemberValue() ;	7215	consumeEnterMemberValue() ;
6745	break;	7216	break;
6746		7217
6747	case 685 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } //$NON-NLS-1$	7218	case 742 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } //$NON-NLS-1$
6748	consumeExitMemberValue() ;	7219	consumeExitMemberValue() ;
6749	break;	7220	break;
6750		7221
6751	case 687 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } //$NON-NLS-1$	7222	case 744 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } //$NON-NLS-1$
6752	consumeMemberValueAsName() ;	7223	consumeMemberValueAsName() ;
6753	break;	7224	break;
6754		7225
6755	case 690 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7226	case 747 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6756	consumeMemberValueArrayInitializer() ;	7227	consumeMemberValueArrayInitializer() ;
6757	break;	7228	break;
6758		7229
6759	case 691 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7230	case 748 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6760	consumeMemberValueArrayInitializer() ;	7231	consumeMemberValueArrayInitializer() ;
6761	break;	7232	break;
6762		7233
6763	case 692 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7234	case 749 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6764	consumeEmptyMemberValueArrayInitializer() ;	7235	consumeEmptyMemberValueArrayInitializer() ;
6765	break;	7236	break;
6766		7237
6767	case 693 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$	7238	case 750 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } //$NON-NLS-1$
6768	consumeEmptyMemberValueArrayInitializer() ;	7239	consumeEmptyMemberValueArrayInitializer() ;
6769	break;	7240	break;
6770		7241
6771	case 694 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); } //$NON-NLS-1$	7242	case 751 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); } //$NON-NLS-1$
6772	consumeEnterMemberValueArrayInitializer() ;	7243	consumeEnterMemberValueArrayInitializer() ;
6773	break;	7244	break;
6774		7245
6775	case 696 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } //$NON-NLS-1$	7246	case 753 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } //$NON-NLS-1$
6776	consumeMemberValues() ;	7247	consumeMemberValues() ;
6777	break;	7248	break;
6778		7249
6779	case 697 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } //$NON-NLS-1$	7250	case 754 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } //$NON-NLS-1$
6780	consumeMarkerAnnotation() ;	7251	consumeMarkerAnnotation() ;
6781	break;	7252	break;
6782		7253
6783	case 698 : if (DEBUG) { System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); } //$NON-NLS-1$	7254	case 755 : if (DEBUG) { System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); } //$NON-NLS-1$
6784	consumeSingleMemberAnnotationMemberValue() ;	7255	consumeSingleMemberAnnotationMemberValue() ;
6785	break;	7256	break;
6786		7257
6787	case 699 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$	7258	case 756 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$
6788	consumeSingleMemberAnnotation() ;	7259	consumeSingleMemberAnnotation() ;
6789	break;	7260	break;
6790		7261
6791	case 700 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$	7262	case 757 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$
6792	consumeRecoveryMethodHeaderNameWithTypeParameters();	7263	consumeRecoveryMethodHeaderNameWithTypeParameters();
6793	break;	7264	break;
6794		7265
6795	case 701 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$	7266	case 758 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type0..."); } //$NON-NLS-1$
6796	consumeRecoveryMethodHeaderName();	7267	consumeRecoveryMethodHeaderName();
6797	break;	7268	break;
6798		7269
6799	case 702 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$	7270	case 759 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
6800	consumeMethodHeader();	7271	consumeMethodHeader();
6801	break;	7272	break;
6802		7273
6803	case 703 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$	7274	case 760 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
6804	consumeMethodHeader();	7275	consumeMethodHeader();
6805	break;	7276	break;
6806		7277
Lines 7799-7804 Link Here
7799	protected void consumeTypeParameterHeader() {	8270	protected void consumeTypeParameterHeader() {
7800	//TypeParameterHeader ::= Identifier	8271	//TypeParameterHeader ::= Identifier
7801	TypeParameter typeParameter = new TypeParameter();	8272	TypeParameter typeParameter = new TypeParameter();
		8273	int length;
		8274	if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		8275	System.arraycopy(
		8276	this.typeAnnotationStack,
		8277	(this.typeAnnotationPtr -= length) + 1,
		8278	typeParameter.annotations = new Annotation[length],
		8279	0,
		8280	length);
		8281	}
7802	long pos = this.identifierPositionStack[this.identifierPtr];	8282	long pos = this.identifierPositionStack[this.identifierPtr];
7803	final int end = (int) pos;	8283	final int end = (int) pos;
7804	typeParameter.declarationSourceEnd = end;	8284	typeParameter.declarationSourceEnd = end;
Lines 8096-8101 Link Here
8096	protected TypeReference copyDims(TypeReference typeRef, int dim) {	8576	protected TypeReference copyDims(TypeReference typeRef, int dim) {
8097	return typeRef.copyDims(dim);	8577	return typeRef.copyDims(dim);
8098	}	8578	}
		8579
		8580	protected TypeReference copyDims(TypeReference typeRef, int dim, Annotation[][]annotationsOnDimensions) {
		8581	return typeRef.copyDims(dim, annotationsOnDimensions);
		8582	}
		8583
8099	protected FieldDeclaration createFieldDeclaration(char[] fieldDeclarationName, int sourceStart, int sourceEnd) {	8584	protected FieldDeclaration createFieldDeclaration(char[] fieldDeclarationName, int sourceStart, int sourceEnd) {
8100	return new FieldDeclaration(fieldDeclarationName, sourceStart, sourceEnd);	8585	return new FieldDeclaration(fieldDeclarationName, sourceStart, sourceEnd);
8101	}	8586	}
Lines 8576-8588 Link Here
8576	return exp;	9061	return exp;
8577	}	9062	}
8578	protected TypeReference getTypeReference(int dim) {	9063	protected TypeReference getTypeReference(int dim) {
		9064	TypeReference ref = getUnannotatedTypeReference(dim);
		9065	int length;
		9066	if (this.typeAnnotationLengthPtr >= 0 && (length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		9067	// if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
		9068
		9069	System.arraycopy(
		9070	this.typeAnnotationStack,
		9071	(this.typeAnnotationPtr -= length) + 1,
		9072	ref.annotations = new Annotation[length],
		9073	0,
		9074	length);
		9075	}
		9076	return ref;
		9077	}
		9078	protected TypeReference getUnannotatedTypeReference(int dim) {
8579	/* build a Reference on a variable that may be qualified or not	9079	/* 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*/	9080	This variable is a type reference and dim will be its dimensions*/
8581		9081
8582	TypeReference ref;	9082	TypeReference ref;
		9083	Annotation [][] annotationsOnDimensions = null;
8583	int length = this.identifierLengthStack[this.identifierLengthPtr--];	9084	int length = this.identifierLengthStack[this.identifierLengthPtr--];
8584	if (length < 0) { //flag for precompiled type reference on base types	9085	if (length < 0) { //flag for precompiled type reference on base types
8585	ref = TypeReference.baseTypeReference(-length, dim);	9086	if (dim > 0) {
		9087	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		9088	}
		9089	ref = TypeReference.baseTypeReference(-length, dim, annotationsOnDimensions);
8586	ref.sourceStart = this.intStack[this.intPtr--];	9090	ref.sourceStart = this.intStack[this.intPtr--];
8587	if (dim == 0) {	9091	if (dim == 0) {
8588	ref.sourceEnd = this.intStack[this.intPtr--];	9092	ref.sourceEnd = this.intStack[this.intPtr--];
Lines 8604-8613 Link Here
8604	this.identifierStack[this.identifierPtr],	9108	this.identifierStack[this.identifierPtr],
8605	this.identifierPositionStack[this.identifierPtr--]);	9109	this.identifierPositionStack[this.identifierPtr--]);
8606	} else {	9110	} else {
		9111	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
8607	ref =	9112	ref =
8608	new ArrayTypeReference(	9113	new ArrayTypeReference(
8609	this.identifierStack[this.identifierPtr],	9114	this.identifierStack[this.identifierPtr],
8610	dim,	9115	dim,
		9116	annotationsOnDimensions,
8611	this.identifierPositionStack[this.identifierPtr--]);	9117	this.identifierPositionStack[this.identifierPtr--]);
8612	ref.sourceEnd = this.endPosition;	9118	ref.sourceEnd = this.endPosition;
8613	}	9119	}
Lines 8627-8633 Link Here
8627	if (dim == 0) {	9133	if (dim == 0) {
8628	ref = new QualifiedTypeReference(tokens, positions);	9134	ref = new QualifiedTypeReference(tokens, positions);
8629	} else {	9135	} else {
8630	ref = new ArrayQualifiedTypeReference(tokens, dim, positions);	9136	annotationsOnDimensions = getAnnotationsOnDimensions(dim);
		9137	ref = new ArrayQualifiedTypeReference(tokens, dim, annotationsOnDimensions, positions);
8631	ref.sourceEnd = this.endPosition;	9138	ref.sourceEnd = this.endPosition;
8632	}	9139	}
8633	}	9140	}
Lines 8635-8646 Link Here
8635	return ref;	9142	return ref;
8636	}	9143	}
8637	protected TypeReference getTypeReferenceForGenericType(int dim, int identifierLength, int numberOfIdentifiers) {	9144	protected TypeReference getTypeReferenceForGenericType(int dim, int identifierLength, int numberOfIdentifiers) {
		9145	Annotation[][] annotationsOnDimensions = dim == 0 ? null : getAnnotationsOnDimensions(dim);
8638	if (identifierLength == 1 && numberOfIdentifiers == 1) {	9146	if (identifierLength == 1 && numberOfIdentifiers == 1) {
8639	int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];	9147	int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];
8640	TypeReference[] typeArguments = new TypeReference[currentTypeArgumentsLength];	9148	TypeReference[] typeArguments = new TypeReference[currentTypeArgumentsLength];
8641	this.genericsPtr -= currentTypeArgumentsLength;	9149	this.genericsPtr -= currentTypeArgumentsLength;
8642	System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeArguments, 0, currentTypeArgumentsLength);	9150	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--]);	9151	ParameterizedSingleTypeReference parameterizedSingleTypeReference = new ParameterizedSingleTypeReference(this.identifierStack[this.identifierPtr], typeArguments, dim, annotationsOnDimensions, this.identifierPositionStack[this.identifierPtr--]);
8644	if (dim != 0) {	9152	if (dim != 0) {
8645	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;	9153	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;
8646	}	9154	}
Lines 8674-8680 Link Here
8674	currentIdentifiersLength = this.identifierLengthStack[this.identifierLengthPtr--];	9182	currentIdentifiersLength = this.identifierLengthStack[this.identifierLengthPtr--];
8675	}	9183	}
8676	}	9184	}
8677	ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference = new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, positions);	9185	ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference = new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, annotationsOnDimensions, positions);
8678	if (dim != 0) {	9186	if (dim != 0) {
8679	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;	9187	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;
8680	}	9188	}
Lines 8895-8900 Link Here
8895	this.astLengthPtr = -1;	9403	this.astLengthPtr = -1;
8896	this.expressionPtr = -1;	9404	this.expressionPtr = -1;
8897	this.expressionLengthPtr = -1;	9405	this.expressionLengthPtr = -1;
		9406	this.unattachedAnnotationPtr = -1;
		9407	this.typeAnnotationLengthPtr = -1;
		9408	this.typeAnnotationPtr = -1;
8898	this.identifierPtr = -1;	9409	this.identifierPtr = -1;
8899	this.identifierLengthPtr = -1;	9410	this.identifierLengthPtr = -1;
8900	this.intPtr = -1;	9411	this.intPtr = -1;
Lines 10025-10030 Link Here
10025	}	10536	}
10026	this.astLengthStack[this.astLengthPtr] = 1;	10537	this.astLengthStack[this.astLengthPtr] = 1;
10027	}	10538	}
		10539	protected void pushOnTypeAnnotationStack(Annotation annotation) {
		10540
		10541	int stackLength = this.typeAnnotationStack.length;
		10542	if (++this.typeAnnotationPtr >= stackLength) {
		10543	System.arraycopy(
		10544	this.typeAnnotationStack, 0,
		10545	this.typeAnnotationStack = new Annotation[stackLength + TypeAnnotationStackIncrement], 0,
		10546	stackLength);
		10547	}
		10548	this.typeAnnotationStack[this.typeAnnotationPtr] = annotation;
		10549
		10550	stackLength = this.typeAnnotationLengthStack.length;
		10551	if (++this.typeAnnotationLengthPtr >= stackLength) {
		10552	System.arraycopy(
		10553	this.typeAnnotationLengthStack, 0,
		10554	this.typeAnnotationLengthStack = new int[stackLength + TypeAnnotationStackIncrement], 0,
		10555	stackLength);
		10556	}
		10557	this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr] = 1;
		10558	}
		10559	protected void pushOnTypeAnnotationLengthStack(int pos) {
		10560
		10561	int stackLength = this.typeAnnotationLengthStack.length;
		10562	if (++this.typeAnnotationLengthPtr >= stackLength) {
		10563	System.arraycopy(
		10564	this.typeAnnotationLengthStack, 0,
		10565	this.typeAnnotationLengthStack = new int[stackLength + TypeAnnotationStackIncrement], 0,
		10566	stackLength);
		10567	}
		10568	this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr] = pos;
		10569	}
10028	protected void pushOnExpressionStack(Expression expr) {	10570	protected void pushOnExpressionStack(Expression expr) {
10029		10571
10030	int stackLength = this.expressionStack.length;	10572	int stackLength = this.expressionStack.length;
Lines 10445-10450 Link Here
10445	this.astLengthPtr = -1;	10987	this.astLengthPtr = -1;
10446	this.expressionPtr = -1;	10988	this.expressionPtr = -1;
10447	this.expressionLengthPtr = -1;	10989	this.expressionLengthPtr = -1;
		10990	this.unattachedAnnotationPtr = -1;
		10991	this.typeAnnotationLengthPtr = -1;
		10992	this.typeAnnotationPtr = -1;
10448	this.identifierPtr = -1;	10993	this.identifierPtr = -1;
10449	this.identifierLengthPtr = -1;	10994	this.identifierLengthPtr = -1;
10450	this.intPtr = -1;	10995	this.intPtr = -1;

Lines 1227-1232 Link Here

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

Lines 561-567 Link Here

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




		typeRef.sourceStart,
		typeRef.sourceEnd);
}

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

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

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

Lines 721-726 Link Here

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

Lines 2174-2184 Link Here

(-)Eclipse Java Tests Compiler/org/eclipse/jdt/tests/compiler/regression/NegativeTest.java (-21 / +26 lines)
2174	" public static final x;\n" +	2174	" public static final x;\n" +
2175	"}",	2175	"}",
2176	},	2176	},
2177	"----------\n" +	2177	"----------\n" +
2178	"1. ERROR in p\\X.java (at line 3)\n" +	2178	"1. ERROR in p\\X.java (at line 3)\n" +
2179	" public static final x;\n" +	2179	" public static final x;\n" +
2180	" ^^^^^\n" +	2180	" ^\n" +
2181	"Syntax error on token \"final\", invalid Type\n" +	2181	"Syntax error, insert \"Identifier (\" to complete MethodHeaderName\n" +
		2182	"----------\n" +
		2183	"2. ERROR in p\\X.java (at line 3)\n" +
		2184	" public static final x;\n" +
		2185	" ^\n" +
		2186	"Syntax error, insert \")\" to complete MethodDeclaration\n" +
2182	"----------\n"	2187	"----------\n"
2183	);	2188	);
2184	}	2189	}
Lines 4812-4818 Link Here
4812	"1. ERROR in p\\Example3.java (at line 10)\n" +	4817	"1. ERROR in p\\Example3.java (at line 10)\n" +
4813	" int myVal = condition ? x = 7 : x = 3;\n" +	4818	" int myVal = condition ? x = 7 : x = 3;\n" +
4814	" ^\n" +	4819	" ^\n" +
4815	"Syntax error on token \"=\", != expected\n" +	4820	"Syntax error on token \"=\", <= expected\n" +
4816	"----------\n"	4821	"----------\n"
4817	);	4822	);
4818	}	4823	}
Lines 4939-4959 Link Here
4939	" }\n" +	4944	" }\n" +
4940	"}",	4945	"}",
4941	},	4946	},
4942	"----------\n" +	4947	"----------\n" +
4943	"1. ERROR in p\\NA.java (at line 7)\n" +	4948	"1. ERROR in p\\NA.java (at line 7)\n" +
4944	" (new Class1).run();\n" +	4949	" (new Class1).run();\n" +
4945	" ^^^\n" +	4950	" ^^^^^^\n" +
4946	"Syntax error on token \"new\", delete this token\n" +	4951	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4947	"----------\n" +	4952	"----------\n" +
4948	"2. ERROR in p\\NA.java (at line 8)\n" +	4953	"2. ERROR in p\\NA.java (at line 8)\n" +
4949	" (new Class2).run();\n" +	4954	" (new Class2).run();\n" +
4950	" ^^^\n" +	4955	" ^^^^^^\n" +
4951	"Syntax error on token \"new\", delete this token\n" +	4956	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4952	"----------\n" +	4957	"----------\n" +
4953	"3. ERROR in p\\NA.java (at line 9)\n" +	4958	"3. ERROR in p\\NA.java (at line 9)\n" +
4954	" (new Class3).run();\n" +	4959	" (new Class3).run();\n" +
4955	" ^^^\n" +	4960	" ^^^^^^\n" +
4956	"Syntax error on token \"new\", delete this token\n" +	4961	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4957	"----------\n"	4962	"----------\n"
4958	);	4963	);
4959	}	4964	}

Lines 3067-3073 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest2.java (-98 / +53 lines)
3067	String completeBehind = "zzz";	3067	String completeBehind = "zzz";
3068	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	3068	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
3069		3069
3070	String expectedCompletionNodeToString = "<NONE>";	3070	// With the recent grammar changes, expectedCompletionNodeToString comes out as non-null
		3071	// since error recovery causes ForceNoDiet to be called without the corresponding
		3072	// RestoreDiet.
		3073	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
3071	String expectedParentNodeToString = "<NONE>";	3074	String expectedParentNodeToString = "<NONE>";
3072	String completionIdentifier = "zzz";	3075	String completionIdentifier = "zzz";
3073	String expectedReplacedSource = "zzz";	3076	String expectedReplacedSource = "zzz";
Lines 3246-3252 Link Here
3246	String completeBehind = "zzz";	3249	String completeBehind = "zzz";
3247	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	3250	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
3248		3251
3249	String expectedCompletionNodeToString = "<NONE>";	3252	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
3250	String expectedParentNodeToString = "<NONE>";	3253	String expectedParentNodeToString = "<NONE>";
3251	String completionIdentifier = "zzz";	3254	String completionIdentifier = "zzz";
3252	String expectedReplacedSource = "zzz";	3255	String expectedReplacedSource = "zzz";
Lines 4115-4130 Link Here
4115	String completeBehind = "zzz";	4118	String completeBehind = "zzz";
4116	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4119	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4117		4120
4118	String expectedCompletionNodeToString = "<NONE>";	4121	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4119	String expectedParentNodeToString = "<NONE>";	4122	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
4120	String completionIdentifier = "zzz";	4123	String completionIdentifier = "zzz";
4121	String expectedReplacedSource = "zzz";	4124	String expectedReplacedSource = "zzz";
4122	String expectedUnitDisplayString =	4125	String expectedUnitDisplayString =
4123	"package p;\n" +	4126	"package p;\n" +
4124	"public class X {\n" +	4127	"public class X {\n" +
4125	" Object o;\n" +	4128	" Object o = new X[]{<CompleteOnName:zzz>};\n" +
4126	" {\n" +
4127	" }\n" +
4128	" public X() {\n" +	4129	" public X() {\n" +
4129	" }\n" +	4130	" }\n" +
4130	"}\n";	4131	"}\n";
Lines 4150-4165 Link Here
4150	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4151	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4151		4152
4152	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	4153	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4153	String expectedParentNodeToString = "<NONE>";	4154	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
4154	String completionIdentifier = "zzz";	4155	String completionIdentifier = "zzz";
4155	String expectedReplacedSource = "zzz";	4156	String expectedReplacedSource = "zzz";
4156	String expectedUnitDisplayString =	4157	String expectedUnitDisplayString =
4157	"package p;\n" +	4158	"package p;\n" +
4158	"public class X {\n" +	4159	"public class X {\n" +
4159	" Object o;\n" +	4160	" Object o = new X[]{<CompleteOnName:zzz>};\n" +
4160	" {\n" +
4161	" <CompleteOnName:zzz>;\n" +
4162	" }\n" +
4163	" public X() {\n" +	4161	" public X() {\n" +
4164	" }\n" +	4162	" }\n" +
4165	"}\n";	4163	"}\n";
Lines 4187-4193 Link Here
4187	String completeBehind = "zzz";	4185	String completeBehind = "zzz";
4188	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4186	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4189		4187
4190	String expectedCompletionNodeToString = "<NONE>";	4188	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4191	String expectedParentNodeToString = "<NONE>";	4189	String expectedParentNodeToString = "<NONE>";
4192	String completionIdentifier = "zzz";	4190	String completionIdentifier = "zzz";
4193	String expectedReplacedSource = "zzz";	4191	String expectedReplacedSource = "zzz";
Lines 4332-4347 Link Here
4332	String completeBehind = "zzz";	4330	String completeBehind = "zzz";
4333	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4331	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4334		4332
4335	String expectedCompletionNodeToString = "<NONE>";	4333	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4336	String expectedParentNodeToString = "<NONE>";	4334	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
4337	String completionIdentifier = "zzz";	4335	String completionIdentifier = "zzz";
4338	String expectedReplacedSource = "zzz";	4336	String expectedReplacedSource = "zzz";
4339	String expectedUnitDisplayString =	4337	String expectedUnitDisplayString =
4340	"package p;\n" +	4338	"package p;\n" +
4341	"public class X {\n" +	4339	"public class X {\n" +
4342	" Object o;\n" +	4340	" Object o = new X[]{<CompleteOnName:zzz>};\n" +
4343	" {\n" +
4344	" }\n" +
4345	" public X() {\n" +	4341	" public X() {\n" +
4346	" }\n" +	4342	" }\n" +
4347	"}\n";	4343	"}\n";
Lines 4368-4383 Link Here
4368	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4364	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4369		4365
4370	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	4366	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4371	String expectedParentNodeToString = "<NONE>";	4367	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
4372	String completionIdentifier = "zzz";	4368	String completionIdentifier = "zzz";
4373	String expectedReplacedSource = "zzz";	4369	String expectedReplacedSource = "zzz";
4374	String expectedUnitDisplayString =	4370	String expectedUnitDisplayString =
4375	"package p;\n" +	4371	"package p;\n" +
4376	"public class X {\n" +	4372	"public class X {\n" +
4377	" Object o;\n" +	4373	" Object o = new X[]{<CompleteOnName:zzz>};\n" +
4378	" {\n" +
4379	" <CompleteOnName:zzz>;\n" +
4380	" }\n" +
4381	" public X() {\n" +	4374	" public X() {\n" +
4382	" }\n" +	4375	" }\n" +
4383	"}\n";	4376	"}\n";
Lines 4406-4412 Link Here
4406	String completeBehind = "zzz";	4399	String completeBehind = "zzz";
4407	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4400	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4408		4401
4409	String expectedCompletionNodeToString = "<NONE>";	4402	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4410	String expectedParentNodeToString = "<NONE>";	4403	String expectedParentNodeToString = "<NONE>";
4411	String completionIdentifier = "zzz";	4404	String completionIdentifier = "zzz";
4412	String expectedReplacedSource = "zzz";	4405	String expectedReplacedSource = "zzz";
Lines 4443-4449 Link Here
4443	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4436	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4444		4437
4445	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	4438	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4446	String expectedParentNodeToString = "<NONE>";	4439	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
4447	String completionIdentifier = "zzz";	4440	String completionIdentifier = "zzz";
4448	String expectedReplacedSource = "zzz";	4441	String expectedReplacedSource = "zzz";
4449	String expectedUnitDisplayString =	4442	String expectedUnitDisplayString =
Lines 4451-4460 Link Here
4451	"public class X {\n" +	4444	"public class X {\n" +
4452	" {\n" +	4445	" {\n" +
4453	" {\n" +	4446	" {\n" +
4454	" Object o;\n" +	4447	" Object o = new X[]{<CompleteOnName:zzz>};\n" +
4455	" {\n" +
4456	" <CompleteOnName:zzz>;\n" +
4457	" }\n" +
4458	" }\n" +	4448	" }\n" +
4459	" }\n" +	4449	" }\n" +
4460	" public X() {\n" +	4450	" public X() {\n" +
Lines 4525-4531 Link Here
4525	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4515	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4526		4516
4527	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	4517	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4528	String expectedParentNodeToString = "<NONE>";	4518	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
4529	String completionIdentifier = "zzz";	4519	String completionIdentifier = "zzz";
4530	String expectedReplacedSource = "zzz";	4520	String expectedReplacedSource = "zzz";
4531	String expectedUnitDisplayString =	4521	String expectedUnitDisplayString =
Lines 4534-4543 Link Here
4534	" public X() {\n" +	4524	" public X() {\n" +
4535	" }\n" +	4525	" }\n" +
4536	" void foo() {\n" +	4526	" void foo() {\n" +
4537	" Object o;\n" +	4527	" Object o = new X[]{<CompleteOnName:zzz>};\n" +
4538	" {\n" +
4539	" <CompleteOnName:zzz>;\n" +
4540	" }\n" +
4541	" }\n" +	4528	" }\n" +
4542	"}\n";	4529	"}\n";
4543		4530
Lines 4927-4942 Link Here
4927	String completeBehind = "zzz";	4914	String completeBehind = "zzz";
4928	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4915	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4929		4916
4930	String expectedCompletionNodeToString = "<NONE>";	4917	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4931	String expectedParentNodeToString = "<NONE>";	4918	String expectedParentNodeToString = "new int[]{<CompleteOnName:zzz>}";
4932	String completionIdentifier = "zzz";	4919	String completionIdentifier = "zzz";
4933	String expectedReplacedSource = "zzz";	4920	String expectedReplacedSource = "zzz";
4934	String expectedUnitDisplayString =	4921	String expectedUnitDisplayString =
4935	"package p;\n" +	4922	"package p;\n" +
4936	"public class X {\n" +	4923	"public class X {\n" +
4937	" int o;\n" +	4924	" int o = new int[]{<CompleteOnName:zzz>};\n" +
4938	" {\n" +
4939	" }\n" +
4940	" public X() {\n" +	4925	" public X() {\n" +
4941	" }\n" +	4926	" }\n" +
4942	"}\n";	4927	"}\n";
Lines 4962-4977 Link Here
4962	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4947	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
4963		4948
4964	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	4949	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
4965	String expectedParentNodeToString = "<NONE>";	4950	String expectedParentNodeToString = "new int[]{<CompleteOnName:zzz>}";
4966	String completionIdentifier = "zzz";	4951	String completionIdentifier = "zzz";
4967	String expectedReplacedSource = "zzz";	4952	String expectedReplacedSource = "zzz";
4968	String expectedUnitDisplayString =	4953	String expectedUnitDisplayString =
4969	"package p;\n" +	4954	"package p;\n" +
4970	"public class X {\n" +	4955	"public class X {\n" +
4971	" int o;\n" +	4956	" int o = new int[]{<CompleteOnName:zzz>};\n" +
4972	" {\n" +
4973	" <CompleteOnName:zzz>;\n" +
4974	" }\n" +
4975	" public X() {\n" +	4957	" public X() {\n" +
4976	" }\n" +	4958	" }\n" +
4977	"}\n";	4959	"}\n";
Lines 5000-5006 Link Here
5000	String completeBehind = "zzz";	4982	String completeBehind = "zzz";
5001	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	4983	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5002		4984
5003	String expectedCompletionNodeToString = "<NONE>";	4985	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5004	String expectedParentNodeToString = "<NONE>";	4986	String expectedParentNodeToString = "<NONE>";
5005	String completionIdentifier = "zzz";	4987	String completionIdentifier = "zzz";
5006	String expectedReplacedSource = "zzz";	4988	String expectedReplacedSource = "zzz";
Lines 5148-5163 Link Here
5148	String completeBehind = "zzz";	5130	String completeBehind = "zzz";
5149	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5131	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5150		5132
5151	String expectedCompletionNodeToString = "<NONE>";	5133	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5152	String expectedParentNodeToString = "<NONE>";	5134	String expectedParentNodeToString = "new int[]{<CompleteOnName:zzz>}";
5153	String completionIdentifier = "zzz";	5135	String completionIdentifier = "zzz";
5154	String expectedReplacedSource = "zzz";	5136	String expectedReplacedSource = "zzz";
5155	String expectedUnitDisplayString =	5137	String expectedUnitDisplayString =
5156	"package p;\n" +	5138	"package p;\n" +
5157	"public class X {\n" +	5139	"public class X {\n" +
5158	" int o;\n" +	5140	" int o = new int[]{<CompleteOnName:zzz>};\n" +
5159	" {\n" +
5160	" }\n" +
5161	" public X() {\n" +	5141	" public X() {\n" +
5162	" }\n" +	5142	" }\n" +
5163	"}\n";	5143	"}\n";
Lines 5184-5199 Link Here
5184	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5164	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5185		5165
5186	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	5166	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5187	String expectedParentNodeToString = "<NONE>";	5167	String expectedParentNodeToString = "new int[]{<CompleteOnName:zzz>}";
5188	String completionIdentifier = "zzz";	5168	String completionIdentifier = "zzz";
5189	String expectedReplacedSource = "zzz";	5169	String expectedReplacedSource = "zzz";
5190	String expectedUnitDisplayString =	5170	String expectedUnitDisplayString =
5191	"package p;\n" +	5171	"package p;\n" +
5192	"public class X {\n" +	5172	"public class X {\n" +
5193	" int o;\n" +	5173	" int o = new int[]{<CompleteOnName:zzz>};\n" +
5194	" {\n" +
5195	" <CompleteOnName:zzz>;\n" +
5196	" }\n" +
5197	" public X() {\n" +	5174	" public X() {\n" +
5198	" }\n" +	5175	" }\n" +
5199	"}\n";	5176	"}\n";
Lines 5223-5229 Link Here
5223	String completeBehind = "zzz";	5200	String completeBehind = "zzz";
5224	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5201	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5225		5202
5226	String expectedCompletionNodeToString = "<NONE>";	5203	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5227	String expectedParentNodeToString = "<NONE>";	5204	String expectedParentNodeToString = "<NONE>";
5228	String completionIdentifier = "zzz";	5205	String completionIdentifier = "zzz";
5229	String expectedReplacedSource = "zzz";	5206	String expectedReplacedSource = "zzz";
Lines 5260-5266 Link Here
5260	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5237	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5261		5238
5262	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	5239	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5263	String expectedParentNodeToString = "<NONE>";	5240	String expectedParentNodeToString = "new int[]{<CompleteOnName:zzz>}";
5264	String completionIdentifier = "zzz";	5241	String completionIdentifier = "zzz";
5265	String expectedReplacedSource = "zzz";	5242	String expectedReplacedSource = "zzz";
5266	String expectedUnitDisplayString =	5243	String expectedUnitDisplayString =
Lines 5268-5277 Link Here
5268	"public class X {\n" +	5245	"public class X {\n" +
5269	" {\n" +	5246	" {\n" +
5270	" {\n" +	5247	" {\n" +
5271	" int o;\n" +	5248	" int o = new int[]{<CompleteOnName:zzz>};\n" +
5272	" {\n" +
5273	" <CompleteOnName:zzz>;\n" +
5274	" }\n" +
5275	" }\n" +	5249	" }\n" +
5276	" }\n" +	5250	" }\n" +
5277	" public X() {\n" +	5251	" public X() {\n" +
Lines 5345-5351 Link Here
5345	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5319	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5346		5320
5347	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	5321	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5348	String expectedParentNodeToString = "<NONE>";	5322	String expectedParentNodeToString = "new int[]{<CompleteOnName:zzz>}";
5349	String completionIdentifier = "zzz";	5323	String completionIdentifier = "zzz";
5350	String expectedReplacedSource = "zzz";	5324	String expectedReplacedSource = "zzz";
5351	String expectedUnitDisplayString =	5325	String expectedUnitDisplayString =
Lines 5354-5363 Link Here
5354	" public X() {\n" +	5328	" public X() {\n" +
5355	" }\n" +	5329	" }\n" +
5356	" void foo() {\n" +	5330	" void foo() {\n" +
5357	" int o;\n" +	5331	" int o = new int[]{<CompleteOnName:zzz>};\n" +
5358	" {\n" +
5359	" <CompleteOnName:zzz>;\n" +
5360	" }\n" +
5361	" }\n" +	5332	" }\n" +
5362	"}\n";	5333	"}\n";
5363		5334
Lines 5381-5396 Link Here
5381	String completeBehind = "zzz";	5352	String completeBehind = "zzz";
5382	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5353	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5383		5354
5384	String expectedCompletionNodeToString = "<NONE>";	5355	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5385	String expectedParentNodeToString = "<NONE>";	5356	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
5386	String completionIdentifier = "zzz";	5357	String completionIdentifier = "zzz";
5387	String expectedReplacedSource = "zzz";	5358	String expectedReplacedSource = "zzz";
5388	String expectedUnitDisplayString =	5359	String expectedUnitDisplayString =
5389	"package p;\n" +	5360	"package p;\n" +
5390	"public class X {\n" +	5361	"public class X {\n" +
5391	" X o;\n" +	5362	" X o = new X[]{<CompleteOnName:zzz>};\n" +
5392	" {\n" +
5393	" }\n" +
5394	" public X() {\n" +	5363	" public X() {\n" +
5395	" }\n" +	5364	" }\n" +
5396	"}\n";	5365	"}\n";
Lines 5416-5431 Link Here
5416	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5385	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5417		5386
5418	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	5387	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5419	String expectedParentNodeToString = "<NONE>";	5388	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
5420	String completionIdentifier = "zzz";	5389	String completionIdentifier = "zzz";
5421	String expectedReplacedSource = "zzz";	5390	String expectedReplacedSource = "zzz";
5422	String expectedUnitDisplayString =	5391	String expectedUnitDisplayString =
5423	"package p;\n" +	5392	"package p;\n" +
5424	"public class X {\n" +	5393	"public class X {\n" +
5425	" X o;\n" +	5394	" X o = new X[]{<CompleteOnName:zzz>};\n" +
5426	" {\n" +
5427	" <CompleteOnName:zzz>;\n" +
5428	" }\n" +
5429	" public X() {\n" +	5395	" public X() {\n" +
5430	" }\n" +	5396	" }\n" +
5431	"}\n";	5397	"}\n";
Lines 5454-5460 Link Here
5454	String completeBehind = "zzz";	5420	String completeBehind = "zzz";
5455	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5421	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5456		5422
5457	String expectedCompletionNodeToString = "<NONE>";	5423	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5458	String expectedParentNodeToString = "<NONE>";	5424	String expectedParentNodeToString = "<NONE>";
5459	String completionIdentifier = "zzz";	5425	String completionIdentifier = "zzz";
5460	String expectedReplacedSource = "zzz";	5426	String expectedReplacedSource = "zzz";
Lines 5601-5616 Link Here
5601	String completeBehind = "zzz";	5567	String completeBehind = "zzz";
5602	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5568	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5603		5569
5604	String expectedCompletionNodeToString = "<NONE>";	5570	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5605	String expectedParentNodeToString = "<NONE>";	5571	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
5606	String completionIdentifier = "zzz";	5572	String completionIdentifier = "zzz";
5607	String expectedReplacedSource = "zzz";	5573	String expectedReplacedSource = "zzz";
5608	String expectedUnitDisplayString =	5574	String expectedUnitDisplayString =
5609	"package p;\n" +	5575	"package p;\n" +
5610	"public class X {\n" +	5576	"public class X {\n" +
5611	" X o;\n" +	5577	" X o = new X[]{<CompleteOnName:zzz>};\n" +
5612	" {\n" +
5613	" }\n" +
5614	" public X() {\n" +	5578	" public X() {\n" +
5615	" }\n" +	5579	" }\n" +
5616	"}\n";	5580	"}\n";
Lines 5637-5652 Link Here
5637	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5601	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5638		5602
5639	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	5603	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5640	String expectedParentNodeToString = "<NONE>";	5604	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
5641	String completionIdentifier = "zzz";	5605	String completionIdentifier = "zzz";
5642	String expectedReplacedSource = "zzz";	5606	String expectedReplacedSource = "zzz";
5643	String expectedUnitDisplayString =	5607	String expectedUnitDisplayString =
5644	"package p;\n" +	5608	"package p;\n" +
5645	"public class X {\n" +	5609	"public class X {\n" +
5646	" X o;\n" +	5610	" X o = new X[]{<CompleteOnName:zzz>};\n" +
5647	" {\n" +
5648	" <CompleteOnName:zzz>;\n" +
5649	" }\n" +
5650	" public X() {\n" +	5611	" public X() {\n" +
5651	" }\n" +	5612	" }\n" +
5652	"}\n";	5613	"}\n";
Lines 5676-5682 Link Here
5676	String completeBehind = "zzz";	5637	String completeBehind = "zzz";
5677	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5638	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5678		5639
5679	String expectedCompletionNodeToString = "<NONE>";	5640	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5680	String expectedParentNodeToString = "<NONE>";	5641	String expectedParentNodeToString = "<NONE>";
5681	String completionIdentifier = "zzz";	5642	String completionIdentifier = "zzz";
5682	String expectedReplacedSource = "zzz";	5643	String expectedReplacedSource = "zzz";
Lines 5713-5719 Link Here
5713	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5674	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5714		5675
5715	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	5676	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5716	String expectedParentNodeToString = "<NONE>";	5677	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
5717	String completionIdentifier = "zzz";	5678	String completionIdentifier = "zzz";
5718	String expectedReplacedSource = "zzz";	5679	String expectedReplacedSource = "zzz";
5719	String expectedUnitDisplayString =	5680	String expectedUnitDisplayString =
Lines 5721-5730 Link Here
5721	"public class X {\n" +	5682	"public class X {\n" +
5722	" {\n" +	5683	" {\n" +
5723	" {\n" +	5684	" {\n" +
5724	" X o;\n" +	5685	" X o = new X[]{<CompleteOnName:zzz>};\n" +
5725	" {\n" +
5726	" <CompleteOnName:zzz>;\n" +
5727	" }\n" +
5728	" }\n" +	5686	" }\n" +
5729	" }\n" +	5687	" }\n" +
5730	" public X() {\n" +	5688	" public X() {\n" +
Lines 5796-5802 Link Here
5796	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;	5754	int cursorLocation = str.indexOf("zzz") + completeBehind.length() - 1;
5797		5755
5798	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";	5756	String expectedCompletionNodeToString = "<CompleteOnName:zzz>";
5799	String expectedParentNodeToString = "<NONE>";	5757	String expectedParentNodeToString = "new X[]{<CompleteOnName:zzz>}";
5800	String completionIdentifier = "zzz";	5758	String completionIdentifier = "zzz";
5801	String expectedReplacedSource = "zzz";	5759	String expectedReplacedSource = "zzz";
5802	String expectedUnitDisplayString =	5760	String expectedUnitDisplayString =
Lines 5805-5814 Link Here
5805	" public X() {\n" +	5763	" public X() {\n" +
5806	" }\n" +	5764	" }\n" +
5807	" void foo() {\n" +	5765	" void foo() {\n" +
5808	" X o;\n" +	5766	" X o = new X[]{<CompleteOnName:zzz>};\n" +
5809	" {\n" +
5810	" <CompleteOnName:zzz>;\n" +
5811	" }\n" +
5812	" }\n" +	5767	" }\n" +
5813	"}\n";	5768	"}\n";
5814		5769




		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(

		"----------\n" +
		"1. ERROR in X.java (at line 2)\n" +
		"	Z <Y1, Y2 var;\n" +
		"	^^^^^^\n" +
		"Syntax error on token(s), misplaced construct(s)\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 2)\n" +

		"----------\n" +
		"1. ERROR in X.java (at line 2)\n" +
		"	Z <Y1, for Y2> var;\n" +
		"	^^^^^^^^^^^^^^\n" +
		"Syntax error on tokens, Type expected instead\n" +
		"----------\n";
	String expected14ProblemLog =
		expected13ProblemLog;




		"}\n";

	String expectedDietPlusBodyPlusStatementsRecoveryUnitToString;
	
	expectedDietPlusBodyPlusStatementsRecoveryUnitToString =
			"public class WB2 {\n" +
			"  public WB2() {\n" +
			"    super();\n" +
			"  }\n" +
			"  public void foo() {\n" +
			"    java.util.Locale $missing$;\n" + 
			"    java.util.Locale java;\n" +
			"  }\n" +
			"}\n";
	} else {
		expectedDietPlusBodyPlusStatementsRecoveryUnitToString =
			expectedDietPlusBodyUnitToString;
	}

	String expectedFullUnitToString = expectedDietUnitToString;


		"        super();\n" +
		"      }\n" +
		"      int hello() {\n" +
		"        fo = $missing$;\n" +
		"      }\n" +
		"      int world() {\n" +
		"      }\n" +
		"      void foo() {\n" +
		"      }\n" +
		"    }\n" +
		"    ba = $missing$;\n" +
		"  }\n" +
		"}\n";


		"  public Hanoi(int numberOfDisks) {\n" +
		"  }\n" +
		"  private void solve(int depth, Post start, Post free, Post end) {\n" +
		"    moveDisk(start, end);\n" +
		"        moveDisk(start, end);\n" +
		"    else\n" +
		"        if ((depth > 1))\n" +
		"            {\n" +
		"              sol = $missing$;\n" +
		"            }\n" +
		"        else\n" +
		"            ;\n" +
		"  }\n" +
		"}\n";


		"    restricts breakpoint;\n" +
		"    given thread;\n" +
		"    any other;\n" +
		"    specified = $missing$;\n" +
		"  }\n" +
		"  public void removeThreadFilter(IJavaThread thread) {\n" +
		"    removes the;\n" +

		"    request as;\n" +
		"    does not;\n" +
		"    the removal;\n" +
		"    thread = $missing$;\n" +
		"  }\n" +
		"  public IJavaThread[] getThreadFilters() {\n" +
		"    return the;\n" +

	String expectedCompletionDietUnitToString =
		"public class X {\n" +
		"  static int B;\n" +
		"  {\n" +
		"  }\n" +
		"  {\n" +
		"  }\n" +
		"  public X() {\n" +
		"  }\n" +
		"  <clinit>() {\n" +

	String expectedCompletionDietUnitToString =
		"public class X {\n" +
		"  int a;\n" +
		"  int b;\n" +
		"  }\n" +
		"  {\n" +
		"  }\n" +
		"  public X() {\n" +
		"  }\n" +
		"}\n";

			"    super();\n" +
			"  }\n" +
			"  void aMethod() {\n" +
			"    m1();\n" +
			"    {\n" +
			"      int a;\n" +
			"      int b;\n" +
			"    }\n" +
			"    m2();\n" +
			"    {\n" +
			"      int c;\n" +
			"      int d;\n" +
			"    }\n" +
			"  }\n" +
			"}\n";
	} else {

			"    super();\n" +
			"  }\n" +
			"  void aMethod() {\n" +
			"    public static @m1() enum $missing$ {\n" +
			"      public $missing$() {\n" +
			"        super();\n" +
			"      }\n" +
			"      <clinit>() {\n" +
			"      }\n" +
			"    }\n" +
			"  }\n" +
			"}\n";
	}

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 \"[\", invalid Name\n" +
		"----------\n" +
		"2. ERROR in <parenthesis mismatch> (at line 4)\n" +
		"	{ arg2, ]						\n" +
		"	^\n" +
		"Syntax error on token \"{\", invalid Name\n" +
		"----------\n" +
		"3. ERROR in <parenthesis mismatch> (at line 4)\n" +
		"	{ arg2, ]						\n" +
		"	        ^\n" +
		"Syntax error on token \"]\", invalid Name\n" +
		"----------\n" +
		"4. ERROR in <parenthesis mismatch> (at line 5)\n" +
		"	arg3, 						\n" +

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

	String testName = "<test>";




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

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

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

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

			"}"
		},
		// compiler results
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	String[] foo = new <Zork>String[] {};\n" + 
		"	                        ^\n" + 
		"Syntax error, insert \"ClassType ( )\" to complete ClassInstanceCreationExpression\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 2)\n" + 
		"	String[] foo = new <Zork>String[] {};\n" + 
		"	                        ^\n" + 
		"Syntax error, insert \";\" to complete ClassBodyDeclarations\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 2)\n" + 
		"	String[] foo = new <Zork>String[] {};\n" + 
		"	                                ^\n" + 
		"Syntax error, insert \"Identifier (\" to complete MethodHeaderName\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 2)\n" + 
		"	String[] foo = new <Zork>String[] {};\n" + 
		"	                                ^\n" + 
		"Syntax error, insert \")\" to complete MethodDeclaration\n" + 
		"----------\n",
		// javac options
		JavacTestOptions.JavacHasABug.JavacBugFixed_7 /* javac test options */);





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




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




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

Return to bug 287648

Lines 7423-7426 Link Here

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

Lines 1456-1476 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java (-18 / +18 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 1796-1802 Link Here
1796	"----------\n" +	1796	"----------\n" +
1797	"1. ERROR in X.java (at line 2)\n" +	1797	"1. ERROR in X.java (at line 2)\n" +
1798	" Z <Y1, Y2 var;\n" +	1798	" Z <Y1, Y2 var;\n" +
1799	" ^^^^^^^\n" +	1799	" ^^^^^^\n" +
1800	"Syntax error on token(s), misplaced construct(s)\n" +	1800	"Syntax error on token(s), misplaced construct(s)\n" +
1801	"----------\n" +	1801	"----------\n" +
1802	"2. ERROR in X.java (at line 2)\n" +	1802	"2. ERROR in X.java (at line 2)\n" +
Lines 1839-1846 Link Here
1839	"----------\n" +	1839	"----------\n" +
1840	"1. ERROR in X.java (at line 2)\n" +	1840	"1. ERROR in X.java (at line 2)\n" +
1841	" Z <Y1, for Y2> var;\n" +	1841	" Z <Y1, for Y2> var;\n" +
1842	" ^^^^^^^^^^^^\n" +	1842	" ^^^^^^^^^^^^^^\n" +
1843	"Syntax error on tokens, delete these tokens\n" +	1843	"Syntax error on tokens, Type expected instead\n" +
1844	"----------\n";	1844	"----------\n";
1845	String expected14ProblemLog =	1845	String expected14ProblemLog =
1846	expected13ProblemLog;	1846	expected13ProblemLog;

Lines 7622-7628 Link Here

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

Lines 31-37 Link Here

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

Lines 889-901 Link Here

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

Lines 729-736 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MatchLocatorParser.java (-2 / +10 lines)
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 copyDims(TypeReference typeRef, int dim, Annotation [][] annotationsOnDimensions) {
733	TypeReference typeRef = super.getTypeReference(dim);	733	TypeReference result = super.copyDims(typeRef, dim, annotationsOnDimensions);
		734	if (this.nodeSet.removePossibleMatch(typeRef) != null)
		735	this.nodeSet.addPossibleMatch(result);
		736	else if (this.nodeSet.removeTrustedMatch(typeRef) != null)
		737	this.nodeSet.addTrustedMatch(result, true);
		738	return result;
		739	}
		740	protected TypeReference getUnannotatedTypeReference(int dim) {
		741	TypeReference typeRef = super.getUnannotatedTypeReference(dim);
734	if (this.patternFineGrain == 0) {	742	if (this.patternFineGrain == 0) {
735	this.patternLocator.match(typeRef, this.nodeSet); // NB: Don't check container since type reference can happen anywhere	743	this.patternLocator.match(typeRef, this.nodeSet); // NB: Don't check container since type reference can happen anywhere
736	}	744	}

Lines 2527-2546 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/DietRecoveryTest.java (-45 / +6 lines)
2527	"}\n";	2527	"}\n";
2528		2528
2529	String expectedDietPlusBodyPlusStatementsRecoveryUnitToString;	2529	String expectedDietPlusBodyPlusStatementsRecoveryUnitToString;
2530	if (this.complianceLevel <= ClassFileConstants.JDK1_4) {	2530
2531	expectedDietPlusBodyPlusStatementsRecoveryUnitToString =	2531	expectedDietPlusBodyPlusStatementsRecoveryUnitToString =
2532	"public class WB2 {\n" +	2532	"public class WB2 {\n" +
2533	" public WB2() {\n" +	2533	" public WB2() {\n" +
2534	" super();\n" +	2534	" super();\n" +
2535	" }\n" +	2535	" }\n" +
2536	" public void foo() {\n" +	2536	" public void foo() {\n" +
2537	" java.util.Locale.java.util.Vector $missing$;\n" +	2537	" java.util.Locale $missing$;\n" +
		2538	" java.util.Locale java;\n" +
2538	" }\n" +	2539	" }\n" +
2539	"}\n";	2540	"}\n";
2540	} else {
2541	expectedDietPlusBodyPlusStatementsRecoveryUnitToString =
2542	expectedDietPlusBodyUnitToString;
2543	}
2544		2541
2545	String expectedFullUnitToString = expectedDietUnitToString;	2542	String expectedFullUnitToString = expectedDietUnitToString;
2546		2543
Lines 4649-4662 Link Here
4649	" super();\n" +	4646	" super();\n" +
4650	" }\n" +	4647	" }\n" +
4651	" int hello() {\n" +	4648	" int hello() {\n" +
4652	" fo = $missing$;\n" +
4653	" }\n" +	4649	" }\n" +
4654	" int world() {\n" +	4650	" int world() {\n" +
4655	" }\n" +	4651	" }\n" +
4656	" void foo() {\n" +	4652	" void foo() {\n" +
4657	" }\n" +	4653	" }\n" +
4658	" }\n" +	4654	" }\n" +
4659	" ba = $missing$;\n" +
4660	" }\n" +	4655	" }\n" +
4661	"}\n";	4656	"}\n";
4662		4657
Lines 4840-4854 Link Here
4840	" public Hanoi(int numberOfDisks) {\n" +	4835	" public Hanoi(int numberOfDisks) {\n" +
4841	" }\n" +	4836	" }\n" +
4842	" private void solve(int depth, Post start, Post free, Post end) {\n" +	4837	" private void solve(int depth, Post start, Post free, Post end) {\n" +
4843	" if ((depth == 1))\n" +	4838	" moveDisk(start, end);\n" +
4844	" moveDisk(start, end);\n" +
4845	" else\n" +
4846	" if ((depth > 1))\n" +
4847	" {\n" +
4848	" sol = $missing$;\n" +
4849	" }\n" +
4850	" else\n" +
4851	" ;\n" +
4852	" }\n" +	4839	" }\n" +
4853	"}\n";	4840	"}\n";
4854		4841
Lines 6000-6006 Link Here
6000	" restricts breakpoint;\n" +	5987	" restricts breakpoint;\n" +
6001	" given thread;\n" +	5988	" given thread;\n" +
6002	" any other;\n" +	5989	" any other;\n" +
6003	" specified = $missing$;\n" +
6004	" }\n" +	5990	" }\n" +
6005	" public void removeThreadFilter(IJavaThread thread) {\n" +	5991	" public void removeThreadFilter(IJavaThread thread) {\n" +
6006	" removes the;\n" +	5992	" removes the;\n" +
Lines 6009-6015 Link Here
6009	" request as;\n" +	5995	" request as;\n" +
6010	" does not;\n" +	5996	" does not;\n" +
6011	" the removal;\n" +	5997	" the removal;\n" +
6012	" thread = $missing$;\n" +
6013	" }\n" +	5998	" }\n" +
6014	" public IJavaThread[] getThreadFilters() {\n" +	5999	" public IJavaThread[] getThreadFilters() {\n" +
6015	" return the;\n" +	6000	" return the;\n" +
Lines 6388-6397 Link Here
6388	String expectedCompletionDietUnitToString =	6373	String expectedCompletionDietUnitToString =
6389	"public class X {\n" +	6374	"public class X {\n" +
6390	" static int B;\n" +	6375	" static int B;\n" +
6391	" {\n" +
6392	" }\n" +
6393	" {\n" +
6394	" }\n" +
6395	" public X() {\n" +	6376	" public X() {\n" +
6396	" }\n" +	6377	" }\n" +
6397	" <clinit>() {\n" +	6378	" <clinit>() {\n" +
Lines 6519-6528 Link Here
6519	String expectedCompletionDietUnitToString =	6500	String expectedCompletionDietUnitToString =
6520	"public class X {\n" +	6501	"public class X {\n" +
6521	" int a;\n" +	6502	" int a;\n" +
6522	" {\n" +	6503	" int b;\n" +
6523	" }\n" +
6524	" {\n" +
6525	" }\n" +
6526	" public X() {\n" +	6504	" public X() {\n" +
6527	" }\n" +	6505	" }\n" +
6528	"}\n";	6506	"}\n";
Lines 7621-7636 Link Here
7621	" super();\n" +	7599	" super();\n" +
7622	" }\n" +	7600	" }\n" +
7623	" void aMethod() {\n" +	7601	" void aMethod() {\n" +
7624	" m1();\n" +
7625	" {\n" +
7626	" int a;\n" +
7627	" int b;\n" +
7628	" }\n" +
7629	" m2();\n" +
7630	" {\n" +
7631	" int c;\n" +
7632	" int d;\n" +
7633	" }\n" +
7634	" }\n" +	7602	" }\n" +
7635	"}\n";	7603	"}\n";
7636	} else {	7604	} else {
Lines 7640-7652 Link Here
7640	" super();\n" +	7608	" super();\n" +
7641	" }\n" +	7609	" }\n" +
7642	" void aMethod() {\n" +	7610	" void aMethod() {\n" +
7643	" public static @m1() enum $missing$ {\n" +
7644	" public $missing$() {\n" +
7645	" super();\n" +
7646	" }\n" +
7647	" <clinit>() {\n" +
7648	" }\n" +
7649	" }\n" +
7650	" }\n" +	7611	" }\n" +
7651	"}\n";	7612	"}\n";
7652	}	7613	}

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 \"[\", invalid Name\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 \"{\", invalid Name\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 \"]\", invalid Name\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 1876-1898 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (-57 / +66 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 37168-37183 Link Here
37168	"}"	37167	"}"
37169	},	37168	},
37170	// compiler results	37169	// compiler results
37171	"----------\n" + /* expected compiler log */	37170	"----------\n" +
37172	"1. ERROR in X.java (at line 2)\n" +	37171	"1. ERROR in X.java (at line 2)\n" +
37173	" String[] foo = new <Zork>String[] {};\n" +	37172	" String[] foo = new <Zork>String[] {};\n" +
37174	" ^^^^^^^^^^^^^^^^^^\n" +	37173	" ^\n" +
37175	"Syntax error on token(s), misplaced construct(s)\n" +	37174	"Syntax error, insert \"ClassType ( )\" to complete ClassInstanceCreationExpression\n" +
37176	"----------\n" +	37175	"----------\n" +
37177	"2. ERROR in X.java (at line 2)\n" +	37176	"2. ERROR in X.java (at line 2)\n" +
37178	" String[] foo = new <Zork>String[] {};\n" +	37177	" String[] foo = new <Zork>String[] {};\n" +
37179	" ^\n" +	37178	" ^\n" +
37180	"Syntax error on token \">\", , expected\n" +	37179	"Syntax error, insert \";\" to complete ClassBodyDeclarations\n" +
		37180	"----------\n" +
		37181	"3. ERROR in X.java (at line 2)\n" +
		37182	" String[] foo = new <Zork>String[] {};\n" +
		37183	" ^\n" +
		37184	"Syntax error, insert \"Identifier (\" to complete MethodHeaderName\n" +
		37185	"----------\n" +
		37186	"4. ERROR in X.java (at line 2)\n" +
		37187	" String[] foo = new <Zork>String[] {};\n" +
		37188	" ^\n" +
		37189	"Syntax error, insert \")\" to complete MethodDeclaration\n" +
37181	"----------\n",	37190	"----------\n",
37182	// javac options	37191	// javac options
37183	JavacTestOptions.JavacHasABug.JavacBugFixed_7 /* javac test options */);	37192	JavacTestOptions.JavacHasABug.JavacBugFixed_7 /* javac test options */);

Lines 14-20 Link Here

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

Lines 568-574 Link Here

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