Attachment #238163 for bug #422468

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

Lines 15-26 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest18.java (-5 / +108 lines)
15		15
16	package org.eclipse.jdt.core.tests.compiler.parser;	16	package org.eclipse.jdt.core.tests.compiler.parser;
17		17
		18	import org.eclipse.jdt.core.JavaModelException;
		19
18	import junit.framework.Test;	20	import junit.framework.Test;
19		21
20	public class CompletionParserTest18 extends AbstractCompletionTest {	22	public class CompletionParserTest18 extends AbstractCompletionTest {
21		23
22	static {	24	static {
23	// TESTS_NAMES = new String [] { "test0001" };	25	// TESTS_NAMES = new String [] { "test0005" };
24	}	26	}
25		27
26	public CompletionParserTest18(String testName) {	28	public CompletionParserTest18(String testName) {
Lines 233-242 Link Here
233	" }\n" +	235	" }\n" +
234	" void go() {\n" +	236	" void go() {\n" +
235	" I i = (<no type> argument) -> {\n" +	237	" I i = (<no type> argument) -> {\n" +
236	" {\n" +	238	" if (true)\n" +
237	" if (true)\n" +	239	" {\n" +
238	" return <CompleteOnName:arg>;\n" +	240	" return <CompleteOnName:arg>;\n" +
239	" }\n" +	241	" }\n" +
240	" };\n" +	242	" };\n" +
241	" }\n" +	243	" }\n" +
242	"}\n";	244	"}\n";
Lines 251-257 Link Here
251	expectedReplacedSource,	253	expectedReplacedSource,
252	"diet ast");	254	"diet ast");
253	}	255	}
254	public void test0006() {	256	public void _test0006() {
255	String string =	257	String string =
256	"interface I {\n" +	258	"interface I {\n" +
257	" int foo(int x);\n" +	259	" int foo(int x);\n" +
Lines 345-348 Link Here
345	expectedReplacedSource,	347	expectedReplacedSource,
346	"diet ast");	348	"diet ast");
347	}	349	}
		350	public void test0010() {
		351	String string =
		352	"interface I {\n" +
		353	" void foo(String x);\n" +
		354	"}\n" +
		355	"public class X {\n" +
		356	" String xField;\n" +
		357	" static void goo(String s) {\n" +
		358	" }\n" +
		359	" static void goo(I i) {\n" +
		360	" }\n" +
		361	" public static void main(String[] args) {\n" +
		362	" goo((xyz) -> {\n" +
		363	" System.out.println(xyz.);\n" +
		364	" });\n" +
		365	" }\n" +
		366	"}\n";
		367
		368	String completeBehind = "xyz.";
		369	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
		370
		371	String expectedCompletionNodeToString = "<CompleteOnName:xyz.>";
		372	String expectedParentNodeToString = "System.out.println(<CompleteOnName:xyz.>)";
		373	String completionIdentifier = "";
		374	String expectedReplacedSource = "xyz.";
		375	String expectedUnitDisplayString =
		376	"interface I {\n" +
		377	" void foo(String x);\n" +
		378	"}\n" +
		379	"public class X {\n" +
		380	" String xField;\n" +
		381	" public X() {\n" +
		382	" }\n" +
		383	" static void goo(String s) {\n" +
		384	" }\n" +
		385	" static void goo(I i) {\n" +
		386	" }\n" +
		387	" public static void main(String[] args) {\n" +
		388	" goo((<no type> xyz) -> {\n" +
		389	" System.out.println(<CompleteOnName:xyz.>);\n" +
		390	"});\n" +
		391	" }\n" +
		392	"}\n";
		393
		394	checkMethodParse(
		395	string.toCharArray(),
		396	cursorLocation,
		397	expectedCompletionNodeToString,
		398	expectedParentNodeToString,
		399	expectedUnitDisplayString,
		400	completionIdentifier,
		401	expectedReplacedSource,
		402	"diet ast");
		403	}
		404	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=417935, [1.8][code select] ICU#codeSelect doesn't work on reference to lambda parameter
		405	public void test417935() throws JavaModelException {
		406	String string =
		407	"import java.util.ArrayList;\n" +
		408	"import java.util.Arrays;\n" +
		409	"import java.util.Collections;\n" +
		410	"import java.util.Comparator;\n" +
		411	"public class X {\n" +
		412	" int compareTo(X x) { return 0; }\n" +
		413	" void foo() {\n" +
414	" Collections.sort(new ArrayList<X>(Arrays.asList(new X(), new X(), new X())),\n" +
415	" (X o1, X o2) -> o1.compareTo(o2)); //[2]\n" +
416	" }\n" +
417	"}\n";
418
419	String completeBehind = "compa";
420	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
421
422	String expectedCompletionNodeToString = "<CompleteOnName:o1.compa>";
423	String expectedParentNodeToString = "<NONE>";
424	String completionIdentifier = "compa";
425	String expectedReplacedSource = "o1.compareTo";
426	String expectedUnitDisplayString =
427	"import java.util.ArrayList;\n" +
428	"import java.util.Arrays;\n" +
429	"import java.util.Collections;\n" +
430	"import java.util.Comparator;\n" +
431	"public class X {\n" +
432	" public X() {\n" +
433	" }\n" +
434	" int compareTo(X x) {\n" +
435	" }\n" +
436	" void foo() {\n" +
437	" (X o1, X o2) -> <CompleteOnName:o1.compa>;\n" +
438	" }\n" +
439	"}\n";
440
441	checkMethodParse(
442	string.toCharArray(),
443	cursorLocation,
444	expectedCompletionNodeToString,
445	expectedParentNodeToString,
446	expectedUnitDisplayString,
447	completionIdentifier,
448	expectedReplacedSource,
449	"diet ast");
450	}
348	}	451	}




			"	public static void main(String[] args) {\n" +
			"			I i = () -> {\n" +
			"               xyz\n" +
			"	}\n" +
			"	}\n" +
			"}\n");


			"	goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
			"}" , requestor.getContext());
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
public void _test018() throws JavaModelException { // ensure higher relevance for matching return type.
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src/X.java",
			"interface I {\n" +
			"	void foo(String x);\n" +
			"}\n" +
			"public class X {\n" +
			"	String xField;\n" +
			"	static void goo(String s) {\n" +
			"	}\n" +
			"	static void goo(I i) {\n" +
			"	}\n" +
			"	public static void main(String[] args) {\n" +
			"		goo((xyz) -> {\n" +
			"			System.out.println(xyz.);\n" +
			"		});\n" +
			"	}\n" +
			"}\n");

	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, true, true, false);
	requestor.allowAllRequiredProposals();
	requestor.setRequireExtendedContext(true);
	requestor.setComputeEnclosingElement(false);
	requestor.setComputeVisibleElements(true);
	requestor.setAssignableType("LX;");
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "xyz.";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	assertEquals("completion offset=192\n" +
			"completion range=[189, 191]\n" +
			"completion token=\"xyz\"\n" +
			"completion token kind=TOKEN_KIND_NAME\n" +
			"expectedTypesSignatures=null\n" +
			"expectedTypesKeys=null\n" +
			"completion token location={STATEMENT_START}\n" +
			"visibleElements={\n" +
			"	xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
			"	goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
			"}" , requestor.getContext());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
public void _test018a() throws JavaModelException { // ensure higher relevance for matching return type.
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src/X.java",
			"interface I {\n" +
			"	void foo(String x);\n" +
			"}\n" +
			"public class X {\n" +
			"	String xField;\n" +
			"	static void goo(String s) {\n" +
			"	}\n" +
			"	static void goo(I i) {\n" +
			"	}\n" +
			"	public static void main(String[] args) {\n" +
			"       args = null;\n" +
			"       if (args != null) {\n" +
			"           xField = null;\n" +
			"       else \n" +
			"           xField = null;\n" +
			"       while (true);\n" +
			"		goo((xyz) -> {\n" +
			"			System.out.println(xyz.)\n" +
			"		});\n" +
			"	}\n" +
			"}\n");

	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, true, true, false);
	requestor.allowAllRequiredProposals();
	requestor.setRequireExtendedContext(true);
	requestor.setComputeEnclosingElement(false);
	requestor.setComputeVisibleElements(true);
	requestor.setAssignableType("LX;");
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "xyz.";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	assertEquals("completion offset=192\n" +
			"completion range=[189, 191]\n" +
			"completion token=\"xyz\"\n" +
			"completion token kind=TOKEN_KIND_NAME\n" +
			"expectedTypesSignatures=null\n" +
			"expectedTypesKeys=null\n" +
			"completion token location={STATEMENT_START}\n" +
			"visibleElements={\n" +
			"	xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
			"	goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
			"}" , requestor.getContext());
}
}




	ICompilationUnit wc = null;

static {
//	 TESTS_NAMES = new String[] { "testParser" };
	// TESTS_NUMBERS = new int[] { 124 };
	// TESTS_RANGE = new int[] { 16, -1 };
}

		elements
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
public void test422468d() throws JavaModelException {
	this.wc = getWorkingCopy(
			"/Resolve/src/X.java",
			"interface I {\n" +
			"	J foo(String x, String y);\n" +
			"}\n" +
			"interface J {\n" +
			"	K foo(String x, String y);\n" +
			"}\n" +
			"interface K {\n" +
			"	int foo(String x, int y);\n" +
			"}\n" +
			"public class X {\n" +
			"	static void goo(K i) {}\n" +
			"	public static void main(String[] args) {\n" +
			"		I i = (x, y) -> { return (a, b) -> (p, q) -> a.length(); };\n" +
			"	}\n" +
			"}\n");

	String str = this.wc.getSource();
	String selection = "a.length";
	int start = str.lastIndexOf(selection);
	int length = selection.length();

	IJavaElement[] elements = this.wc.codeSelect(start, length);
	assertElementsEqual(
		"Unexpected elements",
		"length() [in String [in String.class [in java.lang [in "+ getExternalPath() + "jclMin1.8.jar]]]]",
		elements
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
public void test422468e() throws JavaModelException {
	this.wc = getWorkingCopy(
			"/Resolve/src/X.java",
			"interface I {\n" +
			"	J foo(String x, String y);\n" +
			"}\n" +
			"interface J {\n" +
			"	K foo(String x, String y);\n" +
			"}\n" +
			"interface K {\n" +
			"	int foo(String x, int y);\n" +
			"}\n" +
			"public class X {\n" +
			"	static void goo(K i) {}\n" +
			"	public static void main(String[] args) {\n" +
			"		I i = (x, y) -> { return (a, b) -> (p, q) -> a.length(); };\n" +
			"	}\n" +
			"}\n");

	String str = this.wc.getSource();
	String selection = "q";
	int start = str.lastIndexOf(selection);
	int length = selection.length();

	IJavaElement[] elements = this.wc.codeSelect(start, length);
	assertElementsEqual(
		"Unexpected elements",
		"q [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Resolve]]]]]]",
		elements
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
public void testParser() throws JavaModelException {
	this.wc = getWorkingCopy(
			"/Resolve/src/X.java",
			"interface I {\n" +
			"	int foo(String x, Integer y);\n" +
			"}\n" +
			"public class X {\n" +
			"	public static void main(String[] args) {\n" +
			"		I i = (x, y) -> {\n" +
			"			x = \"Hello\"\n" +
			"			y = 10;		\n" +
			"			if (x.length() > y) {\n" +
			"				System.out.println(\"if\");\n" +
			"			} else {\n" +
			"				System.out.println(\"else\");\n" +
			"			}\n" +
			"			return x.length();\n" +
			"		};\n" +
			"		// System.out.println((I) (p, q) -> { return q.\n" +
			"	}\n" +
			"}\n");

	String str = this.wc.getSource();
	String selection = "x";
	int start = str.lastIndexOf(selection);
	int length = selection.length();

	IJavaElement[] elements = this.wc.codeSelect(start, length);
	assertElementsEqual(
		"Unexpected elements",
		"x [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Resolve]]]]]]",
		elements
	);
}
}

Lines 37-43 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionUnitStructureRequestor.java (-2 / +2 lines)
37	import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;	37	import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
38	import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;	38	import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;
39	import org.eclipse.jdt.internal.compiler.ast.TypeReference;	39	import org.eclipse.jdt.internal.compiler.ast.TypeReference;
40	import org.eclipse.jdt.internal.compiler.parser.Parser;	40	import org.eclipse.jdt.internal.compiler.parser.CommitRollbackParser;
41	import org.eclipse.jdt.internal.core.AnnotatableInfo;	41	import org.eclipse.jdt.internal.core.AnnotatableInfo;
42	import org.eclipse.jdt.internal.core.Annotation;	42	import org.eclipse.jdt.internal.core.Annotation;
43	import org.eclipse.jdt.internal.core.CompilationUnit;	43	import org.eclipse.jdt.internal.core.CompilationUnit;
Lines 64-70 Link Here
64	public CompletionUnitStructureRequestor(	64	public CompletionUnitStructureRequestor(
65	ICompilationUnit unit,	65	ICompilationUnit unit,
66	CompilationUnitElementInfo unitInfo,	66	CompilationUnitElementInfo unitInfo,
67	Parser parser,	67	CommitRollbackParser parser,
68	ASTNode assistNode,	68	ASTNode assistNode,
69	Map bindingCache,	69	Map bindingCache,
70	Map elementCache,	70	Map elementCache,

Lines 31-37 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (-7 / +35 lines)
31	import org.eclipse.jdt.internal.compiler.*;	31	import org.eclipse.jdt.internal.compiler.*;
32	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	32	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
33	import org.eclipse.jdt.internal.compiler.env.*;	33	import org.eclipse.jdt.internal.compiler.env.*;
34
35	import org.eclipse.jdt.internal.compiler.ast.*;	34	import org.eclipse.jdt.internal.compiler.ast.*;
36	import org.eclipse.jdt.internal.compiler.parser.*;	35	import org.eclipse.jdt.internal.compiler.parser.*;
37	import org.eclipse.jdt.internal.compiler.problem.*;	36	import org.eclipse.jdt.internal.compiler.problem.*;
Lines 614-620 Link Here
614	public Object becomeSimpleParser() {	613	public Object becomeSimpleParser() {
615	CompletionScanner completionScanner = (CompletionScanner)this.scanner;	614	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
616	int[] parserState = new int[] {this.cursorLocation, completionScanner.cursorLocation};	615	int[] parserState = new int[] {this.cursorLocation, completionScanner.cursorLocation};
617		616	// ??
618	this.cursorLocation = Integer.MAX_VALUE;	617	this.cursorLocation = Integer.MAX_VALUE;
619	completionScanner.cursorLocation = Integer.MAX_VALUE;	618	completionScanner.cursorLocation = Integer.MAX_VALUE;
620		619
Lines 3470-3475 Link Here
3470	case K_MEMBER_VALUE_ARRAY_INITIALIZER:	3469	case K_MEMBER_VALUE_ARRAY_INITIALIZER:
3471	popElement(K_MEMBER_VALUE_ARRAY_INITIALIZER);	3470	popElement(K_MEMBER_VALUE_ARRAY_INITIALIZER);
3472	break;	3471	break;
		3472	case K_LAMBDA_EXPRESSION_DELIMITER:
		3473	break; // will be popped when the containing block statement is reduced.
3473	default:	3474	default:
3474	popElement(K_ARRAY_INITIALIZER);	3475	popElement(K_ARRAY_INITIALIZER);
3475	break;	3476	break;
Lines 3675-3680 Link Here
3675	break;	3676	break;
3676	case TokenNamedo:	3677	case TokenNamedo:
3677	pushOnElementStack(K_BLOCK_DELIMITER, DO);	3678	pushOnElementStack(K_BLOCK_DELIMITER, DO);
		3679	break;
		3680	case TokenNameARROW:
3678	break;	3681	break;
3679	default :	3682	default :
3680	pushOnElementStack(K_BLOCK_DELIMITER);	3683	pushOnElementStack(K_BLOCK_DELIMITER);
Lines 4609-4614 Link Here
4609	this.labelPtr = -1;	4612	this.labelPtr = -1;
4610	initializeForBlockStatements();	4613	initializeForBlockStatements();
4611	}	4614	}
		4615	protected void copyState(CommitRollbackParser from) {
		4616
		4617	super.copyState(from);
		4618
		4619	CompletionParser parser = (CompletionParser) from;
		4620
		4621	this.invocationType = parser.invocationType;
		4622	this.qualifier = parser.qualifier;
		4623	this.inReferenceExpression = parser.inReferenceExpression;
		4624	this.hasUnusedModifiers = parser.hasUnusedModifiers;
		4625	this.canBeExplicitConstructor = parser.canBeExplicitConstructor;
		4626	}
4612	/*	4627	/*
4613	* Initializes the state of the parser that is about to go for BlockStatements.	4628	* Initializes the state of the parser that is about to go for BlockStatements.
4614	*/	4629	*/
Lines 4954-4959 Link Here
4954	break;	4969	break;
4955	}	4970	}
4956	}	4971	}
		4972
		4973	protected CommitRollbackParser createSnapShotParser() {
		4974	return new CompletionParser(this.problemReporter, this.storeSourceEnds);
		4975	}
4957	/*	4976	/*
4958	* Reset internal state after completion is over	4977	* Reset internal state after completion is over
4959	*/	4978	*/
Lines 4977-4983 Link Here
4977	int[] state = (int[]) parserState;	4996	int[] state = (int[]) parserState;
4978		4997
4979	CompletionScanner completionScanner = (CompletionScanner)this.scanner;	4998	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
4980		4999	// ??
4981	this.cursorLocation = state[0];	5000	this.cursorLocation = state[0];
4982	completionScanner.cursorLocation = state[1];	5001	completionScanner.cursorLocation = state[1];
4983	}	5002	}
Lines 4988-5000 Link Here
4988	* Move checkpoint location, reset internal stacks and	5007	* Move checkpoint location, reset internal stacks and
4989	* decide which grammar goal is activated.	5008	* decide which grammar goal is activated.
4990	*/	5009	*/
4991	protected boolean resumeAfterRecovery() {	5010	protected int resumeAfterRecovery(boolean errorRecovery) {
4992	this.hasUnusedModifiers = false;	5011	this.hasUnusedModifiers = false;
4993	if (this.assistNode != null) {	5012	if (this.assistNode != null) {
		5013
		5014	if (requireExtendedRecovery()) {
		5015	if (!errorRecovery) {
		5016	return RESUME;
		5017	}
		5018	return super.resumeAfterRecovery(errorRecovery);
		5019	}
		5020
4994	/* if reached [eof] inside method body, but still inside nested type,	5021	/* if reached [eof] inside method body, but still inside nested type,
4995	or inside a field initializer, should continue in diet mode until	5022	or inside a field initializer, should continue in diet mode until
4996	the end of the method body or compilation unit */	5023	the end of the method body or compilation unit */
4997	if ((this.scanner.eofPosition == this.cursorLocation+1)	5024	if ((this.scanner.eofPosition >= this.cursorLocation+1)
4998	&& (!(this.referenceContext instanceof CompilationUnitDeclaration)	5025	&& (!(this.referenceContext instanceof CompilationUnitDeclaration)
4999	\|\| isIndirectlyInsideFieldInitialization()	5026	\|\| isIndirectlyInsideFieldInitialization()
5000	\|\| this.assistNodeParent instanceof FieldDeclaration && !(this.assistNodeParent instanceof Initializer))) {	5027	\|\| this.assistNodeParent instanceof FieldDeclaration && !(this.assistNodeParent instanceof Initializer))) {
Lines 5022-5027 Link Here
5022	}	5049	}
5023	}	5050	}
5024	*/	5051	*/
		5052
5025	/* restart in diet mode for finding sibling constructs */	5053	/* restart in diet mode for finding sibling constructs */
5026	if (this.currentElement instanceof RecoveredType	5054	if (this.currentElement instanceof RecoveredType
5027	\|\| this.currentElement.enclosingType() != null){	5055	\|\| this.currentElement.enclosingType() != null){
Lines 5035-5045 Link Here
5035	this.scanner.eofPosition = end < Integer.MAX_VALUE ? end + 1 : end;	5063	this.scanner.eofPosition = end < Integer.MAX_VALUE ? end + 1 : end;
5036	} else {	5064	} else {
5037	resetStacks();	5065	resetStacks();
5038	return false;	5066	return HALT;
5039	}	5067	}
5040	}	5068	}
5041	}	5069	}
5042	return super.resumeAfterRecovery();	5070	return super.resumeAfterRecovery(errorRecovery);
5043	}	5071	}
5044	public void setAssistIdentifier(char[] assistIdent){	5072	public void setAssistIdentifier(char[] assistIdent){
5045	((CompletionScanner)this.scanner).completionIdentifier = assistIdent;	5073	((CompletionScanner)this.scanner).completionIdentifier = assistIdent;




import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.Block;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.parser.CommitRollbackParser;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.compiler.parser.RecoveredBlock;
import org.eclipse.jdt.internal.compiler.parser.RecoveredElement;

	protected static final int K_FIELD_INITIALIZER_DELIMITER = ASSIST_PARSER + 4; // whether we are inside a field initializer
	protected static final int K_ATTRIBUTE_VALUE_DELIMITER = ASSIST_PARSER + 5; // whether we are inside a annotation attribute valuer
	protected static final int K_ENUM_CONSTANT_DELIMITER = ASSIST_PARSER + 6; // whether we are inside a field initializer
	protected static final int K_LAMBDA_EXPRESSION_DELIMITER = ASSIST_PARSER + 7; // whether we are inside a lambda expression
	
	// selector constants
	protected static final int THIS_CONSTRUCTOR = -1;
	protected static final int SUPER_CONSTRUCTOR = -2;

	// enum constant constants
	protected static final int NO_BODY = 0;
	protected static final int WITH_BODY = 1;
	
	protected static final int EXPRESSION_BODY = 0;
	protected static final int BLOCK_BODY = 1;
	private static final boolean DEBUG_COMMIT_ROLLBACK = true;

	protected boolean isFirst = false;


public AssistParser(ProblemReporter problemReporter) {
	super(problemReporter, true);

	setMethodsFullRecovery(false);
	setStatementsRecovery(false);
}

public abstract char[] assistIdentifier();

protected void copyState(CommitRollbackParser from) {
	
	super.copyState(from);

	AssistParser parser = (AssistParser) from;
	
	this.previousToken = parser.previousToken;
	this.previousIdentifierPtr = parser.previousIdentifierPtr;
	
	this.lastModifiers = parser.lastModifiers;
	this.lastModifiersStart = parser.lastModifiersStart;
	
	this.bracketDepth = parser.bracketDepth;
	this.elementPtr = parser.elementPtr;
	
	int length;
	System.arraycopy(parser.blockStarts, 0, this.blockStarts = new int [length = parser.blockStarts.length], 0, length);
	System.arraycopy(parser.elementKindStack, 0, this.elementKindStack = new int [length = parser.elementKindStack.length], 0, length);
	System.arraycopy(parser.elementInfoStack, 0, this.elementInfoStack = new int [length = parser.elementInfoStack.length], 0, length);
	System.arraycopy(parser.elementObjectInfoStack, 0, this.elementObjectInfoStack = new Object [length = parser.elementObjectInfoStack.length], 0, length);
	
	this.previousKind = parser.previousKind;
	this.previousInfo = parser.previousInfo;
	this.previousObjectInfo = parser.previousObjectInfo;
}
/**
 * The parser become a simple parser which behave like a Parser
 * @return the state of the assist parser to be able to restore the assist parser state

		}
		if (node instanceof LambdaExpression) {
			LambdaExpression lambda = (LambdaExpression) node;
			if (!lambda.argumentsTypeElided()) {
				Argument [] arguments = lambda.arguments();
				for (int j = 0, length = arguments.length; j < length; j++) {
					element = element.add(fakeLocalFromArgument(arguments[j]), 0);
				}
			}
			continue;
		}
		if (this.assistNode != null && node instanceof Statement) {

protected void consumeExplicitConstructorInvocation(int flag, int recFlag) {
	super.consumeExplicitConstructorInvocation(flag, recFlag);
	popElement(K_SELECTOR);
	triggerRecoveryUponLambdaClosure();
}
protected void triggerRecoveryUponLambdaClosure() {
	if (this.assistNode == null || !this.lambdaNeedsClosure)
		return;
	ASTNode node = this.astStack[this.astPtr];
	if (this.assistNode.sourceStart >= node.sourceStart && this.assistNode.sourceEnd <= node.sourceEnd) {
		for (int i = 0; i <= this.astPtr; i++) {
			if (this.astStack[i] instanceof LambdaExpression)
				return;
		}
		this.restartRecovery = true;
		this.isOrphanCompletionNode = false;
		this.lambdaNeedsClosure = false;
	}
}
protected void consumeExplicitConstructorInvocationWithTypeArguments(int flag, int recFlag) {
	super.consumeExplicitConstructorInvocationWithTypeArguments(flag, recFlag);
	triggerRecoveryUponLambdaClosure();
}

protected void consumeBlock() {
	super.consumeBlock();
	if (DEBUG_COMMIT_ROLLBACK) {
		System.out.println("----- }");//$NON-NLS-1$
	}
}
protected void consumeBlockStatement() {
	super.consumeBlockStatement();
	Statement statement = (Statement) this.astStack[this.astPtr];
	int statementStart, statementEnd;
	statementStart = statement.sourceStart;
	statementEnd = statement instanceof AbstractVariableDeclaration ? ((AbstractVariableDeclaration)statement).declarationSourceEnd : statement.sourceEnd;
	for (int i = this.elementPtr; i >= 0; --i) {
		if (this.elementKindStack[i] != K_LAMBDA_EXPRESSION_DELIMITER)
			continue;
		LambdaExpression expression = (LambdaExpression) this.elementObjectInfoStack[i];
		if (expression.sourceStart >= statementStart && expression.sourceEnd <= statementEnd) {
			this.elementPtr = i - 1;
			this.restartRecovery = true;
		} else {
			this.restartRecovery = false;  // lambda is still awaiting closure.
			return;
		}
	}
}

protected void consumeBlockStatements() {
	super.consumeBlockStatements();
	if (requireExtendedRecovery()) {
		this.commit = true;
		if (DEBUG_COMMIT_ROLLBACK) {
			System.out.println(this.astStack[this.astPtr]);
			System.out.println("---------------------------------------------------------");//$NON-NLS-1$
		}
	} else {
		this.restartRecovery = true;
	}
}
protected void consumeForceNoDiet() {
	super.consumeForceNoDiet();
	// if we are not in a method (i.e. we are not in a local variable initializer)

	super.consumeInterfaceHeader();
	pushOnElementStack(K_TYPE_DELIMITER);
}

LocalDeclaration fakeLocalFromArgument(Argument argument) {
	LocalDeclaration local = new LocalDeclaration(argument.name, argument.sourceStart, argument.sourceEnd);
	local.declarationSourceStart = argument.declarationSourceStart;
	local.declarationSourceEnd = argument.declarationSourceEnd;
	local.modifiers = argument.modifiers;
	local.modifiersSourceStart = argument.modifiersSourceStart;
	local.annotations = argument.annotations;
	local.type = argument.type;
	return local;
}
protected void consumeLambdaHeader() {
	super.consumeLambdaHeader();
	LambdaExpression lexp = (LambdaExpression) this.astStack[this.astPtr];
	pushOnElementStack(K_LAMBDA_EXPRESSION_DELIMITER, EXPRESSION_BODY, lexp);

//	if (this.currentElement != null) {
//		for (int i = 0, length = arguments.length; i < length; i++) {
//			this.currentElement = this.currentElement.add(fakeLocalFromArgument(arguments[i]), 0);
//		}
//	}
}
protected void consumeMethodBody() {
	super.consumeMethodBody();

		popElement(K_METHOD_DELIMITER);
	}
	super.consumeMethodDeclaration(isNotAbstract, isDefaultMethod);
	triggerRecoveryUponLambdaClosure();
}
protected void consumeMethodHeader() {
	super.consumeMethodHeader();

	// OpenBlock ::= $empty

	super.consumeOpenBlock();
	// if (this.astPtr < 0 || !(this.astStack[this.astPtr] instanceof LambdaExpression && this.previousToken == TokenNameARROW)) {
		int stackLength = this.blockStarts.length;
		if (this.realBlockPtr >= stackLength) {
			System.arraycopy(
					this.blockStarts, 0,
					this.blockStarts = new int[stackLength + StackIncrement], 0,
					stackLength);
		}
		this.blockStarts[this.realBlockPtr] = this.scanner.startPosition;
	// }
	if (requireExtendedRecovery()) {
		this.commit = true;
		if (DEBUG_COMMIT_ROLLBACK) {
			System.out.println(" ---  {"); //$NON-NLS-1$
		}
	}
	this.blockStarts[this.realBlockPtr] = this.scanner.startPosition;
}
protected void consumeOpenFakeBlock() {
	// OpenBlock ::= $empty

				}
				break;
			case TokenNameLBRACE:
				if (this.previousToken == TokenNameARROW) {
					popElement(K_LAMBDA_EXPRESSION_DELIMITER);
					pushOnElementStack(K_LAMBDA_EXPRESSION_DELIMITER, BLOCK_BODY, this.previousObjectInfo);
				}
				this.bracketDepth++;
				break;
			case TokenNameLBRACKET:

	}
	return false;
}
protected boolean isIndirectlyInsideLambdaExpression(){
	int i = this.elementPtr;
	while (i > -1) {
		if (this.elementKindStack[i] == K_LAMBDA_EXPRESSION_DELIMITER)
			return true;
		i--;
	}
	return false;
}
protected boolean isIndirectlyInsideType(){
	int i = this.elementPtr;
	while(i > -1) {

		flushElementStack();
	}
}

public boolean requireExtendedRecovery() {
	if (this.assistNode instanceof TypeReference)
		return false;
	return lastIndexOfElement(K_LAMBDA_EXPRESSION_DELIMITER) >= 0;
}

protected void pushOnElementStack(int kind){
	this.pushOnElementStack(kind, 0, null);
}

			break;
		case TokenNameRBRACE :
			super.recoveryTokenCheck();
			if(this.currentElement != oldElement && !isInsideAttributeValue() && !isIndirectlyInsideLambdaExpression()) {
				if(oldElement instanceof RecoveredInitializer
					|| oldElement instanceof RecoveredMethod
					|| (oldElement instanceof RecoveredBlock && oldElement.parent instanceof RecoveredInitializer)

 * Move checkpoint location, reset internal stacks and
 * decide which grammar goal is activated.
 */
protected int resumeAfterRecovery(boolean errorRecovery) {
	
	if (requireExtendedRecovery()) {
		if (errorRecovery) {
			int mode = fallBackToSpringForward((Statement) null);
			if (mode == RESUME || mode == HALT)
				return mode;
			// else fall through and RESTART
		} else {
			return RESUME;
		}
	}

	// reset internal stacks
	this.astPtr = -1;

	this.expressionLengthPtr = -1;
	this.typeAnnotationLengthPtr = -1;
	this.typeAnnotationPtr = -1;
	
	this.identifierPtr = -1;
	this.identifierLengthPtr	= -1;
	this.intPtr = -1;
	
	
	this.dimensions = 0 ;
	this.recoveredStaticInitializerStart = 0;

	this.genericsIdentifiersLengthPtr = -1;
	this.genericsLengthPtr = -1;
	this.genericsPtr = -1;
	
	this.valueLambdaNestDepth = -1;

	this.modifiers = ClassFileConstants.AccDefault;
	this.modifiersSourceStart = -1;

	// Assist state should require some rewinding too ???
	
	// if in diet mode, reset the diet counter because we're going to restart outside an initializer.
	if (this.diet) this.dietInt = 0;

	/* attempt to move checkpoint location */
	if (!moveRecoveryCheckpoint()) return HALT;

	// only look for headers
	if (this.referenceContext instanceof CompilationUnitDeclaration

			goForHeaders();
			this.diet = true; // passed this point, will not consider method bodies
		}
		return RESTART;
	}
	if (this.referenceContext instanceof AbstractMethodDeclaration
		|| this.referenceContext instanceof TypeDeclaration){

			prepareForBlockStatements();
			goForBlockStatementsOrCatchHeader();
		}
		return RESTART;
	}
	// does not know how to restart
	return HALT;
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=292087
// To be implemented in children viz. CompletionParser that are aware of array initializers

		return ast;
	}
}
}

Lines 40-46 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/select/SelectionParser.java (-34 / +22 lines)
40	import org.eclipse.jdt.internal.compiler.ast.Expression;	40	import org.eclipse.jdt.internal.compiler.ast.Expression;
41	import org.eclipse.jdt.internal.compiler.ast.FieldReference;	41	import org.eclipse.jdt.internal.compiler.ast.FieldReference;
42	import org.eclipse.jdt.internal.compiler.ast.ImportReference;	42	import org.eclipse.jdt.internal.compiler.ast.ImportReference;
43	import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
44	import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;	43	import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
45	import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;	44	import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;
46	import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;	45	import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
Lines 62-67 Link Here
62	import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;	61	import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
63	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	62	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
64	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	63	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
		64	import org.eclipse.jdt.internal.compiler.parser.CommitRollbackParser;
65	import org.eclipse.jdt.internal.compiler.parser.JavadocParser;	65	import org.eclipse.jdt.internal.compiler.parser.JavadocParser;
66	import org.eclipse.jdt.internal.compiler.parser.RecoveredType;	66	import org.eclipse.jdt.internal.compiler.parser.RecoveredType;
67	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	67	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
Lines 1184-1189 Link Here
1184	this.restartRecovery = true; // used to avoid branching back into the regular automaton	1184	this.restartRecovery = true; // used to avoid branching back into the regular automaton
1185	}	1185	}
1186	}	1186	}
		1187	protected CommitRollbackParser createSnapShotParser() {
		1188	return new SelectionParser(this.problemReporter);
		1189	}
1187	public ImportReference createAssistImportReference(char[][] tokens, long[] positions, int mod){	1190	public ImportReference createAssistImportReference(char[][] tokens, long[] positions, int mod){
1188	return new SelectionOnImportReference(tokens, positions, mod);	1191	return new SelectionOnImportReference(tokens, positions, mod);
1189	}	1192	}
Lines 1413-1440 Link Here
1413	return super.parse(sourceUnit, compilationResult, -1, -1/parse without reseting the scanner/);	1416	return super.parse(sourceUnit, compilationResult, -1, -1/parse without reseting the scanner/);
1414	}	1417	}
1415		1418
1416	protected int resumeOnSyntaxError() {
1417
1418	if (this.referenceContext instanceof CompilationUnitDeclaration)
1419	return super.resumeOnSyntaxError();
1420
1421	// Defer initial triggered recovery if we see a type elided lambda expression on the stack.
1422	if (this.assistNode != null && this.restartRecovery) {
1423	this.lambdaNeedsClosure = false;
1424	for (int i = this.astPtr; i >= 0; i--) {
1425	if (this.astStack[i] instanceof LambdaExpression) {
1426	LambdaExpression expression = (LambdaExpression) this.astStack[i];
1427	if (expression.argumentsTypeElided()) {
1428	this.restartRecovery = false; // will be restarted in when the containing expression statement or explicit constructor call is reduced.
1429	this.lambdaNeedsClosure = true;
1430	return RESUME;
1431	}
1432	}
1433	}
1434	}
1435	return super.resumeOnSyntaxError();
1436	}
1437
1438	/*	1419	/*
1439	* Reset context so as to resume to regular parse loop	1420	* Reset context so as to resume to regular parse loop
1440	* If unable to reset for resuming, answers false.	1421	* If unable to reset for resuming, answers false.
Lines 1442-1468 Link Here
1442	* Move checkpoint location, reset internal stacks and	1423	* Move checkpoint location, reset internal stacks and
1443	* decide which grammar goal is activated.	1424	* decide which grammar goal is activated.
1444	*/	1425	*/
1445	protected boolean resumeAfterRecovery() {	1426	protected int resumeAfterRecovery(boolean errorRecovery) {
1446		1427
1447	/* if reached assist node inside method body, but still inside nested type,	1428	/* if reached assist node inside method body, but still inside nested type,
1448	should continue in diet mode until the end of the method body */	1429	should continue in diet mode until the end of the method body */
1449	if (this.assistNode != null	1430	if (this.assistNode != null
1450	&& !(this.referenceContext instanceof CompilationUnitDeclaration)){	1431	&& !(this.referenceContext instanceof CompilationUnitDeclaration)){
1451	this.currentElement.preserveEnclosingBlocks();	1432	this.currentElement.preserveEnclosingBlocks();
		1433	if (requireExtendedRecovery()) {
		1434	if (!errorRecovery) {
		1435	return RESUME;
		1436	}
		1437	return super.resumeAfterRecovery(errorRecovery);
		1438	}
1452	if (this.currentElement.enclosingType() == null) {	1439	if (this.currentElement.enclosingType() == null) {
1453	if(!(this.currentElement instanceof RecoveredType)) {	1440	if (!(this.currentElement instanceof RecoveredType)) {
1454	resetStacks();	1441	resetStacks();
1455	return false;	1442	return HALT;
1456	}	1443	}
1457		1444
1458	RecoveredType recoveredType = (RecoveredType)this.currentElement;	1445	RecoveredType recoveredType = (RecoveredType) this.currentElement;
1459	if(recoveredType.typeDeclaration != null && recoveredType.typeDeclaration.allocation == this.assistNode){	1446	if (recoveredType.typeDeclaration != null && recoveredType.typeDeclaration.allocation == this.assistNode) {
1460	resetStacks();	1447	resetStacks();
1461	return false;	1448	return HALT;
1462	}	1449	}
1463	}	1450	}
1464	}	1451	}
1465	return super.resumeAfterRecovery();	1452	return super.resumeAfterRecovery(errorRecovery);
1466	}	1453	}
1467		1454
1468	public void selectionIdentifierCheck(){	1455	public void selectionIdentifierCheck(){
Lines 1504-1518 Link Here
1504	char[] identifierName = this.identifierStack[this.identifierPtr];	1491	char[] identifierName = this.identifierStack[this.identifierPtr];
1505	long namePositions = this.identifierPositionStack[this.identifierPtr--];	1492	long namePositions = this.identifierPositionStack[this.identifierPtr--];
1506		1493
1507	Argument arg =	1494	Argument argument =
1508	new SelectionOnArgumentName(	1495	new SelectionOnArgumentName(
1509	identifierName,	1496	identifierName,
1510	namePositions,	1497	namePositions,
1511	null, // elided type	1498	null, // elided type
1512	ClassFileConstants.AccDefault,	1499	ClassFileConstants.AccDefault,
1513	true);	1500	true);
1514	arg.declarationSourceStart = (int) (namePositions >>> 32);	1501	argument.declarationSourceStart = (int) (namePositions >>> 32);
1515	return arg;	1502	this.assistNode = argument;
		1503	return argument;
1516	}	1504	}
1517	public String toString() {	1505	public String toString() {
1518	String s = Util.EMPTY_STRING;	1506	String s = Util.EMPTY_STRING;

Lines 307-312 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (+2 lines)
307	public static final int IsSynthetic = ASTNode.Bit7;	307	public static final int IsSynthetic = ASTNode.Bit7;
308		308
309	public static final Argument [] NO_ARGUMENTS = new Argument [0];	309	public static final Argument [] NO_ARGUMENTS = new Argument [0];
		310
		311	public static final Block NO_BODY = new Block(0);
310		312
311	public ASTNode() {	313	public ASTNode() {
312		314




	private Statement body;
	public boolean hasParentheses;
	public MethodScope scope;
	boolean voidCompatible = true;
	boolean valueCompatible = false;
	private boolean shapeAnalysisComplete = false;
	boolean returnsValue;
	boolean returnsVoid;
	private LambdaExpression original = this;
	private SyntheticArgumentBinding[] outerLocalVariables = NO_SYNTHETIC_ARGUMENTS;
	private int outerLocalVariablesSlotSize = 0;
	public boolean shouldCaptureInstance = false;
	private boolean assistNode = false;
	private boolean hasIgnoredMandatoryErrors = false;
	private static final SyntheticArgumentBinding [] NO_SYNTHETIC_ARGUMENTS = new SyntheticArgumentBinding[0];
	
	public LambdaExpression(CompilationResult compilationResult, boolean assistNode) {
		super(compilationResult);
		this.assistNode = assistNode;
		setArguments(NO_ARGUMENTS);
		setBody(NO_BODY);
	}
	
	public void setArguments(Argument [] arguments) {

	}

	public void setBody(Statement body) {
		this.body = body == null ? NO_BODY : body;
	}
	
	public Statement body() {


	public void setArrowPosition(int arrowPosition) {
		this.arrowPosition = arrowPosition;
	}
	
	public int getArrowPosition() {
		return this.arrowPosition;
	}
	
	protected FunctionalExpression original() {

		
		if (!haveDescriptor) {
			if (argumentsTypeElided) {
				if (!this.assistNode)
					return null; // FUBAR, bail out...
				// for code assist ONLY, keep the sluice gate shut on bogus errors otherwise.
				argumentsTypeElided = false;

		return false;
	}
		
	private void analyzeShape() { // simple minded analysis for code assist.
		class ShapeComputer extends ASTVisitor {
			public boolean visit(TypeDeclaration type, BlockScope skope) {
				return false;
			}
			public boolean visit(TypeDeclaration type, ClassScope skope) {
				return false;
			}
			public boolean visit(LambdaExpression type, BlockScope skope) {
				return false;
			}
		    public boolean visit(ReturnStatement returnStatement, BlockScope skope) {
		    	if (returnStatement.expression != null) {
		    		LambdaExpression.this.valueCompatible = true;
		    		LambdaExpression.this.voidCompatible = false;
		    	} else {
		    		LambdaExpression.this.voidCompatible = true;
		    		LambdaExpression.this.valueCompatible = false;
		    	}
		    	return false;
		    }
		}
		if (this.body instanceof Expression) {
			this.voidCompatible = ((Expression) this.body).statementExpression();
			this.valueCompatible = true;
		} else {
			// We need to be a bit tolerant/fuzzy here: the code is being written "just now", if we are too pedantic, selection/completion will break;
			this.voidCompatible = true;
			this.valueCompatible = true;
			this.body.traverse(new ShapeComputer(), null);
		}
		this.shapeAnalysisComplete = true;
	}
	
	public boolean isCompatibleWith(final TypeBinding left, final Scope someScope) {
		
		final MethodBinding sam = left.getSingleAbstractMethod(this.enclosingScope);

			compilerOptions.isAnnotationBasedNullAnalysisEnabled = false;
			try {
				final LambdaExpression copy = copy();
				if (copy == null) {
					if (this.assistNode) {
						analyzeShape(); // not on terra firma here !
						if (sam.returnType.id == TypeIds.T_void) {
							if (!this.voidCompatible)
								return false;
						} else {
							if (!this.valueCompatible)
								return false;
						}
					}
					return !isPertinentToApplicability(left);
				}
				copy.setExpressionContext(this.expressionContext);
				copy.setExpectedType(left);
				this.hasIgnoredMandatoryErrors = false;

			}
		}

		if (!isPertinentToApplicability(left))  // This check should happen after return type check below, but for buggy javac compatibility we have left it in.
			return true;

		if (sam.returnType.id == TypeIds.T_void) {
			if (!this.voidCompatible)
				return false;

			if (!this.valueCompatible)
				return false;
		}
			Expression [] returnExpressions = this.resultExpressions;
		Expression [] returnExpressions = this.resultExpressions;
		for (int i = 0, length = returnExpressions.length; i < length; i++) {
			if (returnExpressions[i] instanceof FunctionalExpression) { // don't want to use the resolvedType - polluted from some other overload resolution candidate
				if (!returnExpressions[i].isCompatibleWith(sam.returnType, this.enclosingScope))




/*******************************************************************************
 * Copyright (c) 2013 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * This is an implementation of an early-draft specification developed under the Java
 * Community Process (JCP) and is made available for testing and evaluation purposes
 * only. The code is not compatible with any specification of the JCP.
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.parser;

import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;

public abstract class CommitRollbackParser implements TerminalTokens, ParserBasicInformation {
	
	// resumeOnSyntaxError codes:
	protected static final int HALT = 0;     // halt and throw up hands.
	protected static final int RESTART = 1;  // stacks adjusted, alternate goal from check point.
	protected static final int RESUME = 2;   // stacks untouched, just continue from where left off.

	public static byte rhs[] = null;
	public static char lhs[] =  null;
	public static char term_action[] = null;
	public static byte term_check[] = null;
	public static char base_action[] = null;
	
	public ReferenceContext referenceContext;


	// Constants.
	protected static final int AstStackIncrement = 100;
	protected static final int ExpressionStackIncrement = 100;
	protected static final int GenericsStackIncrement = 10;
	protected static final int StackIncrement = 255;
	protected static final int TypeAnnotationStackIncrement = 100;
	
	public Scanner scanner;
	public int currentToken;
	protected int kurrentToken; // copy of currentToken as it is trampled over all over the place :-(
	protected boolean commit = false;
	
	// -------------  Stack pointers ---------------

	protected int stateStackTop;
	protected int unstackedAct;

	protected int identifierPtr;
	protected int identifierLengthPtr;
	
	protected int astPtr;
	protected int astLengthPtr;
	
	protected int expressionPtr;
	protected int expressionLengthPtr;
	
	protected int genericsPtr;
	protected int genericsLengthPtr;
	protected int genericsIdentifiersLengthPtr;
	
	protected int typeAnnotationPtr;
	protected int typeAnnotationLengthPtr;
	
	protected int intPtr;
	protected int nestedType;
	protected int realBlockPtr;
	public int valueLambdaNestDepth = -1;
	
	// ---------------- Stacks ----------------
	
	protected int[] stack = new int[StackIncrement];
	
	protected char[][] identifierStack;
	protected int[] identifierLengthStack;
	protected long[] identifierPositionStack;

	protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
	protected int[] astLengthStack;
	
	protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];
	protected int[] expressionLengthStack;

	protected ASTNode[] genericsStack = new ASTNode[GenericsStackIncrement];
	protected int[] genericsLengthStack = new int[GenericsStackIncrement];
	protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];
	
	protected Annotation [] typeAnnotationStack = new Annotation[TypeAnnotationStackIncrement];
	protected int [] typeAnnotationLengthStack;
	
	protected int[] intStack;
	protected int[] nestedMethod;
	protected int[] realBlockStack;
	protected int stateStackLengthStack[] = new int[0];
	protected int[] variablesCounter;
	
	// Loose variables.
	
	protected int listLength;
	protected int listTypeParameterLength;
	protected int modifiers;
	protected int modifiersSourceStart;
	protected int dimensions;
	protected int recoveredStaticInitializerStart;
	
	CommitRollbackParser cryogenicallyFrozenParser;
	private static final int[] RECOVERY_TOKENS = new int [] { TokenNameSEMICOLON, TokenNameRPAREN,};
	
	protected void copyState(CommitRollbackParser parser) {

		// Stack pointers.
		
		this.stateStackTop = parser.stateStackTop;
		this.unstackedAct = parser.unstackedAct;
		this.identifierPtr = parser.identifierPtr;
		this.identifierLengthPtr = parser.identifierLengthPtr;
		this.astPtr = parser.astPtr;
		this.astLengthPtr = parser.astLengthPtr;
		this.expressionPtr = parser.expressionPtr;
		this.expressionLengthPtr = parser.expressionLengthPtr;
		this.genericsPtr = parser.genericsPtr;
		this.genericsLengthPtr = parser.genericsLengthPtr;
		this.genericsIdentifiersLengthPtr = parser.genericsIdentifiersLengthPtr;
		this.typeAnnotationPtr = parser.typeAnnotationPtr;
		this.typeAnnotationLengthPtr = parser.typeAnnotationLengthPtr;
		this.intPtr = parser.intPtr;
		this.nestedType = parser.nestedType;
		this.realBlockPtr = parser.realBlockPtr;
		this.valueLambdaNestDepth = parser.valueLambdaNestDepth;
		
		// Stacks.
		
		int length;
		System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
		System.arraycopy(parser.identifierStack, 0, this.identifierStack = new char [length = parser.identifierStack.length][], 0, length);
		System.arraycopy(parser.identifierLengthStack, 0, this.identifierLengthStack = new int [length = parser.identifierLengthStack.length], 0, length);
		System.arraycopy(parser.identifierPositionStack, 0, this.identifierPositionStack = new long[length = parser.identifierPositionStack.length], 0, length);
		System.arraycopy(parser.astStack, 0, this.astStack = new ASTNode [length = parser.astStack.length], 0, length);
		System.arraycopy(parser.astLengthStack, 0, this.astLengthStack = new int [length = parser.astLengthStack.length], 0, length);
		System.arraycopy(parser.expressionStack, 0, this.expressionStack = new Expression [length = parser.expressionStack.length], 0, length);
		System.arraycopy(parser.expressionLengthStack, 0, this.expressionLengthStack = new int [length = parser.expressionLengthStack.length], 0, length);
		System.arraycopy(parser.genericsStack, 0, this.genericsStack = new ASTNode [length = parser.genericsStack.length], 0, length);
		System.arraycopy(parser.genericsLengthStack, 0, this.genericsLengthStack = new int [length = parser.genericsLengthStack.length], 0, length);
		System.arraycopy(parser.genericsIdentifiersLengthStack, 0, this.genericsIdentifiersLengthStack = new int [length = parser.genericsIdentifiersLengthStack.length], 0, length);
		System.arraycopy(parser.typeAnnotationStack, 0, this.typeAnnotationStack = new Annotation [length = parser.typeAnnotationStack.length], 0, length);
		System.arraycopy(parser.typeAnnotationLengthStack, 0, this.typeAnnotationLengthStack = new int [length = parser.typeAnnotationLengthStack.length], 0, length);
		System.arraycopy(parser.intStack, 0, this.intStack = new int [length = parser.intStack.length], 0, length);
		System.arraycopy(parser.nestedMethod, 0, this.nestedMethod = new int [length = parser.nestedMethod.length], 0, length);
		System.arraycopy(parser.realBlockStack, 0, this.realBlockStack = new int [length = parser.realBlockStack.length], 0, length);
		System.arraycopy(parser.stateStackLengthStack, 0, this.stateStackLengthStack = new int [length = parser.stateStackLengthStack.length], 0, length);
		System.arraycopy(parser.variablesCounter, 0, this.variablesCounter = new int [length = parser.variablesCounter.length], 0, length);
		System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
		System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
		System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);

		// Loose variables.
		
		this.listLength = parser.listLength;
		this.listTypeParameterLength = parser.listTypeParameterLength;
		this.dimensions = parser.dimensions;
		this.recoveredStaticInitializerStart = parser.recoveredStaticInitializerStart;

		// Parser.resetStacks is not clearing the modifiers, but AssistParser.resumeAfterRecovery is - why ? (the former doesn't)
		// this.modifiers = parser.modifiers;
		// this.modifiersSourceStart = parser.modifiersSourceStart;
	}
	
	protected CommitRollbackParser createSnapShotParser() {
		return new Parser();
	}
	
	/* Must be called from Parser.parse ONLY. Rule reduction routine must simply set the flag to request commit. 
	   This ensures the end state of chain rule reductions gets committed rather than some intermediate state.
	   See the reduce do-while loop.
	*/
	protected void commit() {
		if (this.cryogenicallyFrozenParser == null) {
			this.cryogenicallyFrozenParser = createSnapShotParser();
		}
		this.cryogenicallyFrozenParser.copyState(this);
		this.commit = false;
	}
	
	protected int getNextToken() {
		try {
			return this.scanner.getNextToken();
		} catch (InvalidInputException e) {
			return TokenNameEOF;
		}
	}
	
	// We get here on real syntax error or syntax error triggered by fake EOF at completion site, never due to triggered recovery.
	protected int fallBackToSpringForward(Statement unused) {
		int nextToken;
		int lastAction = this.stack[this.stateStackTop];
				
		// If triggered fake EOF at completion site, see if the real next token would have passed muster.
		if (this.kurrentToken == TokenNameEOF) {
			if (this.scanner.eofPosition < this.scanner.source.length) {
				this.scanner.eofPosition = this.scanner.source.length;
				nextToken = getNextToken();
				if (automatonWillShift(nextToken, lastAction)) {
					this.currentToken = this.kurrentToken = nextToken;
					this.unstackedAct = this.stack[this.stateStackTop--];
					return RESUME;
				}
			} else {
				nextToken = TokenNameEOF;
			}
		} else {
			nextToken = this.kurrentToken;
		}
		if (nextToken == TokenNameEOF)
			return HALT; // don't know how to proceed.
		this.scanner.ungetToken(nextToken); // spit out what has been bitten more than we can chew.
		// OK, next token is no good to resume "in place", attempt some local repair.
		for (int i = 0, length = RECOVERY_TOKENS.length; i < length; i++) {
			if (automatonWillShift(RECOVERY_TOKENS[i], lastAction)) {
				this.currentToken = this.kurrentToken = RECOVERY_TOKENS[i];
				this.unstackedAct = this.stack[this.stateStackTop--];
				return RESUME;
			}
		}
		// OK, no in place resumption, no local repair, fast forward to next statement.
		if (this.cryogenicallyFrozenParser == null || this.referenceContext instanceof CompilationUnitDeclaration) {
			return RESTART;
		}
		this.copyState(this.cryogenicallyFrozenParser);
		this.currentToken = this.scanner.fastForward(unused);
		return RESUME;
	}

	protected void resetStacks() {
	
		this.astPtr = -1;
		this.astLengthPtr = -1;
		this.expressionPtr = -1;
		this.expressionLengthPtr = -1;
		this.typeAnnotationLengthPtr = -1;
		this.typeAnnotationPtr = -1;
		this.identifierPtr = -1;
		this.identifierLengthPtr	= -1;
		this.intPtr = -1;
		
		this.nestedMethod[this.nestedType = 0] = 0; // need to reset for further reuse
		this.variablesCounter[this.nestedType] = 0;
		
		this.dimensions = 0 ;
		this.realBlockStack[this.realBlockPtr = 0] = 0;
		this.recoveredStaticInitializerStart = 0;
		this.listLength = 0;
		this.listTypeParameterLength = 0;
	
		this.genericsIdentifiersLengthPtr = -1;
		this.genericsLengthPtr = -1;
		this.genericsPtr = -1;
		this.valueLambdaNestDepth = -1;
	}

	protected boolean automatonWillShift(int token, int lastAction) {
		int stackTop = this.stateStackTop;        // local copy of stack pointer
		int stackTopState = this.stack[stackTop]; // single cell non write through "alternate stack" - the automaton's stack pointer either stays fixed during this manoeuvre or monotonically decreases.
		int highWaterMark = stackTop;
		// A rotated version of the automaton - cf. parse()'s for(;;)
		for (;;) {  
			if (lastAction > ERROR_ACTION) {  
				lastAction -= ERROR_ACTION;    /* shift-reduce on loop entry from above, reduce on loop back */
				do { /* reduce */
					stackTop -= rhs[lastAction] - 1;
					if (stackTop < highWaterMark) {
						stackTopState = this.stack[highWaterMark = stackTop];
					} // else stackTopState is upto date already.
					lastAction = ntAction(stackTopState, lhs[lastAction]);
				} while (lastAction <= NUM_RULES);
			}
			highWaterMark = ++stackTop;
			stackTopState = lastAction; // "push"
			lastAction = tAction(lastAction, token); // can be looked up from a precomputed cache.
			if (lastAction <= NUM_RULES) {
				stackTop --; 
			    lastAction += ERROR_ACTION;
				continue;
			}
			// Error => false, Shift, Shift/Reduce => true, Accept => impossible. 
			return lastAction != ERROR_ACTION;
		}
	}

public static int tAction(int state, int sym) {
	return term_action[term_check[base_action[state]+sym] == sym ? base_action[state] + sym : base_action[state]];
}

public static int ntAction(int state, int sym) {
	return base_action[state + sym];
}


}


Lines 22-25 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/ConflictedParser.java (+4 lines)
22	we treat the type annotation as a declarative annotation.	22	we treat the type annotation as a declarative annotation.
23	*/	23	*/
24	boolean atConflictScenario(int token);	24	boolean atConflictScenario(int token);
		25
		26	void startRecovery();
		27
		28	boolean requireExtendedRecovery();
25	}	29	}




import org.eclipse.jdt.internal.compiler.util.Messages;
import org.eclipse.jdt.internal.compiler.util.Util;

public class Parser extends CommitRollbackParser implements ConflictedParser, OperatorIds, TypeIds {
	
	protected static final int THIS_CALL = ExplicitConstructorCall.This;
	protected static final int SUPER_CALL = ExplicitConstructorCall.Super;

	
	public static char asb[] = null;
	public static char asr[] = null;
	//ast stack
	protected final static int AstStackIncrement = 100;
	public static char base_action[] = null;
	public static final int BracketKinds = 3;

	public static short check_table[] = null;
	public static final int CurlyBracket = 2;
	private static final boolean DEBUG = true;
	private static final boolean DEBUG_AUTOMATON = true;
	private static final String EOF_TOKEN = "$eof" ; //$NON-NLS-1$
	private static final String ERROR_TOKEN = "$error" ; //$NON-NLS-1$
	//expression stack
	protected final static int ExpressionStackIncrement = 100;

	protected final static int GenericsStackIncrement = 10;

	private final static String FILEPREFIX = "parser"; //$NON-NLS-1$
    public static char in_symb[] = null;
	private static final String INVALID_CHARACTER = "Invalid Character" ; //$NON-NLS-1$
	public static char lhs[] =  null;

	public static String name[] = null;
	public static char nasb[] = null;


	public static String readableName[] = null;

	public static byte rhs[] = null;

	public static int[] reverse_index = null;
	public static char[] recovery_templates_index = null;

    public static char scope_suffix[] = null;
	public static final int SquareBracket = 1;

	//internal data for the automat
	protected final static int StackIncrement = 255;

	public static char term_action[] = null;
	public static byte term_check[] = null;

	public static char terminal_index[] = null;


	public static int nasi(int state) {
		return nasb[original_state(state)];
	}
	public static int ntAction(int state, int sym) {
		return base_action[state + sym];
	}
	protected static int original_state(int state) {
		return -base_check(state);
	}

		}
		return chars;
	}
	public static int tAction(int state, int sym) {
		return term_action[term_check[base_action[state]+sym] == sym ? base_action[state] + sym : base_action[state]];
	}
	protected int astLengthPtr;

	protected int[] astLengthStack;
	protected int astPtr;
	protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
	public CompilationUnitDeclaration compilationUnit; /*the result from parse()*/

	protected RecoveredElement currentElement;
	
	protected boolean diet = false; //tells the scanner to jump over some parts of the code/expressions like method bodies
	protected int dietInt = 0; // if > 0 force the none-diet-parsing mode (even if diet if requested) [field parsing with anonymous inner classes...]
	protected int endPosition; //accurate only when used ! (the start position is pushed into intStack while the end the current one)
	protected int endStatementPosition;
	protected int expressionLengthPtr;
	protected int[] expressionLengthStack;
	protected int expressionPtr;
	protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];
	public int firstToken ; // handle for multiple parsing goals
	
	/* jsr308 -- Type annotation management, we now maintain type annotations in a separate stack
	   as otherwise they get interspersed with other expressions and some of the code is not prepared
	   to handle such interleaving and will look ugly if changed. 
	   
	   See consumeArrayCreationExpressionWithoutInitializer for example. 

	   Where SE8 annotations occur in a place SE5 annotations are legal, the SE8 annotations end up in
	   the expression stack as we have no way of distinguishing between the two.
	*/  
	protected int typeAnnotationPtr;
	protected int typeAnnotationLengthPtr;
	protected Annotation [] typeAnnotationStack = new Annotation[TypeAnnotationStackIncrement];
	protected int [] typeAnnotationLengthStack;
	// annotation stack
	protected final static int TypeAnnotationStackIncrement = 100;
	
	// generics management
	protected int genericsIdentifiersLengthPtr;
	protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];
	protected int genericsLengthPtr;
	protected int[] genericsLengthStack = new int[GenericsStackIncrement];
	protected int genericsPtr;
	protected ASTNode[] genericsStack = new ASTNode[GenericsStackIncrement];
	protected boolean hasError;
	protected boolean hasReportedError;
	//identifiers stacks
	protected int identifierLengthPtr;
	protected int[] identifierLengthStack;
	protected long[] identifierPositionStack;
	protected int identifierPtr;
	protected char[][] identifierStack;
	protected boolean ignoreNextOpeningBrace;

	//positions , dimensions , .... (int stacks)
	protected int intPtr;

	protected int[] intStack;
	public int lastAct ; //handle for multiple parsing goals
	//error recovery management
	protected int lastCheckPoint;

	protected int lastErrorEndPositionBeforeRecovery = -1;
	protected int lastIgnoredToken, nextIgnoredToken;

	protected int listLength; // for recovering some incomplete list (interfaces, throws or parameters)

	protected int listTypeParameterLength; // for recovering some incomplete list (type parameters)
	protected int lParenPos,rParenPos; //accurate only when used !
	protected int modifiers;
	protected int modifiersSourceStart;
	protected int[] nestedMethod; //the ptr is nestedType

	protected int nestedType, dimensions;
	ASTNode [] noAstNodes = new ASTNode[AstStackIncrement];

	Expression [] noExpressions = new Expression[ExpressionStackIncrement];
	//modifiers dimensions nestedType etc.......
	protected boolean optimizeStringLiterals =true;
	protected CompilerOptions options;

	protected ProblemReporter problemReporter;

	protected int rBraceStart, rBraceEnd, rBraceSuccessorStart; //accurate only when used !
protected int realBlockPtr;
protected int[] realBlockStack;
protected int recoveredStaticInitializerStart;
public ReferenceContext referenceContext;
public boolean reportOnlyOneSyntaxError = false;
public boolean reportSyntaxErrorIsRequired = true;
protected boolean restartRecovery;

protected TypeDeclaration pendingRecoveredType;
public RecoveryScanner recoveryScanner;
//scanner token
public Scanner scanner;
protected int[] stack = new int[StackIncrement];
protected int stateStackTop;
protected int synchronizedBlockSourceStart;

protected int[] variablesCounter;

protected boolean checkExternalizeStrings;


// used for recovery
protected int lastJavadocEnd;
public org.eclipse.jdt.internal.compiler.ReadManager readManager;
private boolean parsingJava8Plus;
private int stateStackLengthStack[] = new int[0];
protected boolean parsingJava8Plus;
protected int unstackedAct = ERROR_ACTION;
private boolean haltOnSyntaxError = false;
private boolean tolerateDefaultClassMethods = false;
private boolean processingLambdaParameterList = false;
private boolean expectTypeAnnotation = false;

// resumeOnSyntaxError codes:

protected static final int HALT = 0;     // halt and throw up hands.
protected static final int RESTART = 1;  // stacks reset, alternate goal from check point.
protected static final int RESUME = 2;   // stacks untouched, just continue from where left off.


protected Parser () {
	// Caveat Emptor: For inheritance purposes and then only in very special needs. Only minimal state is initialized !

	pushOnAstStack(block);
}
protected void consumeBlockStatement() {
	// for assist parsers.
}
protected void consumeBlockStatements() {
	// BlockStatements ::= BlockStatements BlockStatement

	this.nestedMethod[this.nestedType] ++;
	LambdaExpression lambda = new LambdaExpression(this.compilationUnit.compilationResult, this instanceof AssistParser);
	pushOnAstStack(lambda);
	if (this.currentElement != null) {
		this.currentElement = this.currentElement.add(lambda, 0);
		this.lastCheckPoint = this.scanner.currentPosition;
		this.lastIgnoredToken = -1;
	}
	this.processingLambdaParameterList = true;	
}


	}
	LambdaExpression lexp = (LambdaExpression) this.astStack[this.astPtr];
	lexp.setArguments(arguments);
	lexp.setArrowPosition(arrowPosition);
	lexp.sourceEnd = this.intStack[this.intPtr--];   // ')' position or identifier position.
	lexp.sourceStart = this.intStack[this.intPtr--]; // '(' position or identifier position.
	lexp.hasParentheses = (this.scanner.getSource()[lexp.sourceStart] == '(');
	this.listLength -= arguments == null ? 0 : arguments.length;  // not necessary really.
	if (this.currentElement != null) {
		this.lastCheckPoint = lexp.sourceEnd + 1;
		this.lastIgnoredToken = -1;
	}
	this.processingLambdaParameterList = false;
	if (this.currentElement != null) {
		this.ignoreNextOpeningBrace = true;
		this.currentElement.bracketBalance++;
	}
}
protected void consumeLambdaExpression() {
	

		problemReporter().lambdaExpressionsNotBelow18(lexp);
	}
	pushOnExpressionStack(lexp);
	if (this.currentElement != null && lexp.body() instanceof Expression) {
		this.currentElement.bracketBalance--;
			this.currentElement = this.currentElement.parent;
		}
		this.lastCheckPoint = lexp.sourceEnd + 1;
	}
}


		pushOnIntStack(arg.declarationSourceEnd);
	}
	pushOnAstStack(arg);
	this.listLength++;  // not relevant really.
		indicating that some arguments are available on the stack */
	this.listLength++;
}
protected void consumeElidedLeftBraceAndReturn() {
	/* ElidedLeftBraceAndReturn ::= $empty

	optimizedConcatNodeLists();
}
protected void consumeToken(int type) {
	if (this.commit)
		commit();
//	// clear the commentPtr of the scanner in case we read something different from a modifier
//	switch(type) {
//		case TokenNameabstract :
//		case TokenNamestrictfp :
//		case TokenNamefinal :
//		case TokenNamenative :
//		case TokenNameprivate :
//		case TokenNameprotected :
//		case TokenNamepublic :
//		case TokenNametransient :
//		case TokenNamevolatile :
//		case TokenNamestatic :
//		case TokenNamesynchronized :
//			break;
//		default:
//			this.scanner.commentPtr = -1;
//	}
	//System.out.println(this.scanner.toStringAction(type));
	switch (type) {
		case TokenNameARROW:
			consumeLambdaHeader();

	this.referenceContext = null;
	this.endStatementPosition = 0;
	this.valueLambdaNestDepth = -1;
	
	//remove objects from stack too, while the same parser/compiler couple is
	//re-used between two compilations ....

	int astLength = this.astStack.length;
	for (int i = 0; i < astLength; i++)
		this.astStack[i] = null;
		//System.out.println("Resized AST stacks : "+ astLength);

	}
	System.arraycopy(this.noAstNodes, 0, this.astStack, 0, astLength);

	int expressionLength = this.expressionStack.length;
	for (int i = 0; i < expressionLength; i++)
		this.expressionStack[i] = null;
		//System.out.println("Resized EXPR stacks : "+ expressionLength);
	}
	System.arraycopy(this.noExpressions, 0, this.expressionStack, 0, expressionLength);

	// reset this.scanner state
	this.scanner.commentPtr = -1;

	         
	    Though this code looks complex, we should exit early in most situations.     
	 */
	if (this.unstackedAct == ERROR_ACTION) { // automaton is not running.
	if (lastAction == ERROR_ACTION) { // automaton is not running.
		return false;
	}
	int stackTop = this.stateStackTop;        // local copy of stack pointer
	int stackTopState = this.stack[stackTop]; // single cell non write through "alternate stack" - the automaton's stack pointer either stays fixed during this manoeuvre or monotonically decreases.
	int highWaterMark = stackTop;
	
	if (token != TokenNameAT) {
		token = token == TokenNameLPAREN ? TokenNameBeginLambda : TokenNameBeginTypeArguments;
	}
	
	return automatonWillShift(token, this.unstackedAct);
	for (;;) {  
		if (lastAction > ERROR_ACTION) {  
			lastAction -= ERROR_ACTION;    /* shift-reduce on loop entry from above, reduce on loop back */
			do { /* reduce */
				stackTop -= rhs[lastAction] - 1;
				if (stackTop < highWaterMark) {
					stackTopState = this.stack[highWaterMark = stackTop];
				} // else stackTopState is upto date already.
				lastAction = ntAction(stackTopState, lhs[lastAction]);
			} while (lastAction <= NUM_RULES);
		}
		highWaterMark = ++stackTop;
		stackTopState = lastAction; // "push"
		lastAction = tAction(lastAction, token); // can be looked up from a precomputed cache.
		if (lastAction <= NUM_RULES) {
			stackTop --; 
		    lastAction += ERROR_ACTION;
			continue;
		}
		// Error => false, Shift, Shift/Reduce => true, Accept => impossible. 
		return lastAction != ERROR_ACTION;
	}
}
/*main loop of the automat
When a rule is reduced, the method consumeRule(int) is called with the number


	this.hasReportedError = false;
	int act = START_STATE;
	this.unstackedAct = ERROR_ACTION;
	this.stateStackTop = -1;
	this.currentToken = getFirstToken();
	

				stackLength);
		}
		this.stack[this.stateStackTop] = act;
		this.unstackedAct = act = tAction(act, this.currentToken);
		act = tAction(act, this.currentToken);
		if (act == ERROR_ACTION || this.restartRecovery) {
			if (DEBUG_AUTOMATON) {
				if (this.restartRecovery) {


			int errorPos = this.scanner.currentPosition - 1;
			if (!this.hasReportedError) {
				this.hasError = true;
			}
			this.kurrentToken = this.currentToken;
			switch (resumeOnErrorOrTriggeredRecovery(act == ERROR_ACTION)) {
				case HALT:
					act = ERROR_ACTION;
					break ProcessTerminals;
				case RESTART:
					if (act == ERROR_ACTION && this.kurrentToken != 0) this.lastErrorEndPosition = errorPos;
					act = START_STATE;
					this.stateStackTop = -1;
					this.currentToken = getFirstToken();
					continue ProcessTerminals;
				case RESUME:
					if (act == ERROR_ACTION) {
						act = this.unstackedAct;
						continue ProcessTerminals;
					} else {
						this.currentToken = this.kurrentToken; // Gets trashed all over the place.
					}
					// FALL THROUGH.
			}
		}
		if (act <= NUM_RULES) {

				this.recordStringLiterals = oldValue;
			}
			try {
				this.unstackedAct = act;
				this.currentToken = this.scanner.getNextToken();
			} catch(InvalidInputException e){
				if (!this.hasReportedError){

				this.lastCheckPoint = this.scanner.currentPosition;
				this.currentToken = 0;
				this.restartRecovery = true;
			} 
				this.unstackedAct = ERROR_ACTION;
			}
			if(this.statementRecoveryActivated) {
				jumpOverType();
			}

					this.recordStringLiterals = oldValue;
				}
				try{
					this.unstackedAct = act;
					this.currentToken = this.scanner.getNextToken();
				} catch(InvalidInputException e){
					if (!this.hasReportedError){

					this.lastCheckPoint = this.scanner.currentPosition;
					this.currentToken = 0;
					this.restartRecovery = true;
				} finally {
					this.unstackedAct = ERROR_ACTION;
				}
				if(this.statementRecoveryActivated) {
					jumpOverType();

		}
	}
} finally {
	this.unstackedAct = ERROR_ACTION;
	this.scanner.setActiveParser(null);
}


	}
}

public boolean requireExtendedRecovery() {
	return false; // for assist parsers.
}

public void startRecovery() {
	this.restartRecovery = true;
}

public void recoveryExitFromVariable() {
	if(this.currentElement != null && this.currentElement.parent != null) {
		if(this.currentElement instanceof RecoveredLocalVariable) {

}
/*
 * Reset context so as to resume to regular parse loop
 */
protected void resetStacks() {

	this.astPtr = -1;
	this.astLengthPtr = -1;
	this.expressionPtr = -1;
	this.expressionLengthPtr = -1;
	this.typeAnnotationLengthPtr = -1;
	this.typeAnnotationPtr = -1;
	this.identifierPtr = -1;
	this.identifierLengthPtr	= -1;
	this.intPtr = -1;
	this.nestedMethod[this.nestedType = 0] = 0; // need to reset for further reuse
	this.variablesCounter[this.nestedType] = 0;
	this.dimensions = 0 ;
	this.realBlockStack[this.realBlockPtr = 0] = 0;
	this.recoveredStaticInitializerStart = 0;
	this.listLength = 0;
	this.listTypeParameterLength = 0;

	this.genericsIdentifiersLengthPtr = -1;
	this.genericsLengthPtr = -1;
	this.genericsPtr = -1;
	this.valueLambdaNestDepth = -1;
}
/*
 * Reset context so as to resume to regular parse loop
 * If unable to reset for resuming, answers false.
 *
 * Move checkpoint location, reset internal stacks and
 * decide which grammar goal is activated.
 */
protected int resumeAfterRecovery(boolean errorRecovery) {
	if(!this.methodRecoveryActivated && !this.statementRecoveryActivated) {

		// reset internal stacks


		/* attempt to move checkpoint location */
		if (!moveRecoveryCheckpoint()) {
			return HALT;
		}

		// only look for headers
		if (this.referenceContext instanceof CompilationUnitDeclaration){
			goForHeaders();
			this.diet = true; // passed this point, will not consider method bodies
			return RESTART;
		}

		// does not know how to restart
		return HALT;
	} else if(!this.statementRecoveryActivated) {

		// reset internal stacks


		/* attempt to move checkpoint location */
		if (!moveRecoveryCheckpoint()) {
			return HALT;
		}

		// only look for headers
		goForHeaders();
		return RESTART;
	} else {
		return HALT;
	}
}
protected int resumeOnErrorOrTriggeredRecovery(boolean errorRecovery) {
	if (this.haltOnSyntaxError)
		return HALT;
	/* request recovery initialization */

	}

	/* attempt to reset state in order to resume to parse loop */
	return resumeAfterRecovery(errorRecovery);
}
public void setMethodsFullRecovery(boolean enabled) {
	this.options.performMethodsFullRecovery = enabled;

Lines 194-200 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/RecoveredAnnotation.java (-1 / +1 lines)
194		194
195	public int sourceEnd() {	195	public int sourceEnd() {
196	if (this.annotation == null) {	196	if (this.annotation == null) {
197	Parser parser = parser();	197	CommitRollbackParser parser = parser();
198	if (this.identifierPtr < parser.identifierPositionStack.length) {	198	if (this.identifierPtr < parser.identifierPositionStack.length) {
199	return (int) parser.identifierPositionStack[this.identifierPtr];	199	return (int) parser.identifierPositionStack[this.identifierPtr];
200	} else {	200	} else {




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * This is an implementation of an early-draft specification developed under the Java
 * Community Process (JCP) and is made available for testing and evaluation purposes
 * only. The code is not compatible with any specification of the JCP.
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/


import org.eclipse.jdt.core.compiler.*;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Block;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;

		}
	}
	return super.add(methodDeclaration, bracketBalanceValue);
}
/*
 * Record a Lambda declaration
 */
public RecoveredElement add(LambdaExpression expression, int bracketBalanceValue) {
	RecoveredLambdaExpression element = new RecoveredLambdaExpression(expression, this, bracketBalanceValue);
	attach(element);
	return element;
}
/*
 * Record a nested block declaration

		Statement updatedStatement = this.statements[i].updatedStatement(depth, knownTypes);
		if (updatedStatement != null){
			updatedStatements[updatedCount++] = updatedStatement;
			
			// Statements inside lambda body have been collected into a block. Replace the block if we see a statement that completely subsumes it.
			if (updatedCount > 1) {
				Statement penultimateStatement = updatedStatements[updatedCount - 1];
				int penultimateStatementStart = penultimateStatement.sourceStart;
				int penultimateStatementEnd = penultimateStatement instanceof AbstractVariableDeclaration ? 
						((AbstractVariableDeclaration) penultimateStatement).declarationSourceEnd : penultimateStatement.sourceEnd;
				int ultimateStatementStart = updatedStatement.sourceStart;
				int ultimateStatementEnd =  updatedStatement instanceof AbstractVariableDeclaration ? 
						((AbstractVariableDeclaration) updatedStatement).declarationSourceEnd : updatedStatement.sourceEnd;
				if (penultimateStatementStart <= ultimateStatementStart && penultimateStatementEnd >= ultimateStatementEnd) {
					updatedCount--;
					continue;
				}
				if (ultimateStatementStart <= penultimateStatementStart && ultimateStatementEnd >= penultimateStatementEnd) {
					updatedStatements[updatedCount - 1] = updatedStatement;
					updatedCount--;
				}
			}

			if (updatedStatement instanceof LocalDeclaration) {
				LocalDeclaration localDeclaration = (LocalDeclaration) updatedStatement;




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * This is an implementation of an early-draft specification developed under the Java
 * Community Process (JCP) and is made available for testing and evaluation purposes
 * only. The code is not compatible with any specification of the JCP.
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation

/**
 * Internal structure for parsing recovery
 */
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Block;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;

	if (this.parent == null) return this; // ignore
	this.updateSourceEndIfNecessary(previousAvailableLineEnd(localDeclaration.declarationSourceStart - 1));
	return this.parent.add(localDeclaration, bracketBalanceValue);
}

/*
 * Record a LambdaExpression: Only can occur inside a block. Note: Field initializers are wrapped into a block.
 */
public RecoveredElement add(LambdaExpression expression, int bracketBalanceValue) {
	return this;
}
/*
 * Record a statement

 */
public int previousAvailableLineEnd(int position){

	CommitRollbackParser parser = parser();
	if (parser == null) return position;

	Scanner scanner = parser.scanner;




import org.eclipse.jdt.internal.compiler.ast.ArrayTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;



	public RecoveredAnnotation[] annotations;
	public int annotationCount;

	public RecoveredLambdaExpression initializerLambda;
	
	public int modifiers;
	public int modifiersStart;

		this.fieldDeclaration.declarationSourceEnd = statement.sourceEnd;
		this.fieldDeclaration.declarationEnd = statement.sourceEnd;
		return this;
	}
}
/*
 * Record a lambda expression if field is expecting an initialization expression,
 * used for completion inside field initializers.
 */
public RecoveredElement add(LambdaExpression expression, int bracketBalanceValue) {

	if (this.alreadyCompletedFieldInitialization) {
		return super.add(expression, bracketBalanceValue);
	} else {
		if (expression.sourceEnd > 0)
				this.alreadyCompletedFieldInitialization = true;
		// else we may still be inside the initialization, having parsed only a part of it yet
		this.fieldDeclaration.initialization = expression;
		this.fieldDeclaration.declarationSourceEnd = expression.sourceEnd;
		this.fieldDeclaration.declarationEnd = expression.sourceEnd;
		return this.initializerLambda = new RecoveredLambdaExpression(expression, this, bracketBalanceValue);
	}
}
/*

			}
		}
	}
	if (this.initializerLambda != null)
		this.initializerLambda.updateParseTree();
	
	return this.fieldDeclaration;
}
/*




/*******************************************************************************
 * Copyright (c) 2013 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * This is an implementation of an early-draft specification developed under the Java
 * Community Process (JCP) and is made available for testing and evaluation purposes
 * only. The code is not compatible with any specification of the JCP.
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.compiler.parser;

import java.util.HashSet;
import java.util.Set;

import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Block;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
import org.eclipse.jdt.internal.compiler.ast.Statement;

public class RecoveredLambdaExpression extends RecoveredBlock {

	private LambdaExpression expression;
	private boolean haveBlockBody = false;
	private boolean haveExpressionBody = false;
	private RecoveredStatement bodyExpression;
	
	public RecoveredLambdaExpression(LambdaExpression expression, RecoveredElement parent, int bracketBalance){
		super(new Block(0), parent, bracketBalance); // don't have a block yet. May never have, in that event will course correct.
		this.expression = expression;
		this.expression.setBody(this.blockDeclaration);
	}
	
	/*
	 * Record a nested block declaration
	 */
	public RecoveredElement add(Block block, int bracketBalanceValue) {
		if (!this.haveBlockBody && !this.haveExpressionBody) {
			this.haveBlockBody = true;
			this.haveExpressionBody = false;
			this.blockDeclaration = block;
			return this; 
		}
		return super.add(block, bracketBalanceValue);
	}

	/*
	 * Record a nested block declaration
	 */
	public RecoveredElement add(LambdaExpression lambda, int bracketBalanceValue) {
		if (!this.haveBlockBody && !this.haveExpressionBody) {
			this.haveBlockBody = false;
			this.haveExpressionBody = true;
			this.bodyExpression = new RecoveredLambdaExpression(lambda, this, bracketBalanceValue);
			this.expression.setBody(lambda);
			return this.bodyExpression;
		}
		return super.add(lambda, bracketBalanceValue);
	}
	
	/*
	 * Record a statement declaration
	 */
	public RecoveredElement add(Statement stmt, int bracketBalanceValue) {
		return this.add(stmt, bracketBalanceValue, false);
	}

	/*
	 * Record a statement declaration
	 */
	public RecoveredElement add(Statement stmt, int bracketBalanceValue, boolean delegatedByParent) {
		if (!this.haveBlockBody && !this.haveExpressionBody) {
			this.haveBlockBody = false;
			this.haveExpressionBody = true;
			this.bodyExpression = new RecoveredStatement(stmt, this, bracketBalanceValue);
			this.expression.setBody(stmt);
			return this.bodyExpression;
		}
		return super.add(stmt, bracketBalanceValue, delegatedByParent);
	}
	
	/*
	 * Answer the associated parsed structure
	 */
	public ASTNode parseTree(){
		return updatedLambdaExpression(0, new HashSet());
	}

	public LambdaExpression updatedLambdaExpression(int depth, Set knownTypes) {
		if (this.haveBlockBody)
			this.expression.setBody(super.updatedStatement(depth, knownTypes));
		else if (this.bodyExpression != null)
			this.expression.setBody(this.bodyExpression.updatedStatement(depth, knownTypes));
		return this.expression;
	}
	/*
	 * Rebuild a statement from the nested structure which is in scope
	 */
	public Statement updatedStatement(int depth, Set knownTypes){
		return updatedLambdaExpression(depth, knownTypes);
	}
	/*
	 * Final update the corresponding parse node
	 */
	public void updateParseTree(){
		updatedLambdaExpression(0, new HashSet());
	}
	/*
	 * Rebuild a flattened block from the nested structure which is in scope
	 */
	public Statement updateStatement(int depth, Set knownTypes){
		return updatedLambdaExpression(depth, knownTypes);
	}
	
	public String toString(int tab) {
		StringBuffer result = new StringBuffer(tabString(tab));
		result.append("Recovered Lambda Expression:\n"); //$NON-NLS-1$
		this.expression.print(tab + 1, result);
		return result.toString();
	}
}




import org.eclipse.jdt.internal.compiler.ast.ArrayTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Statement;



	public RecoveredAnnotation[] annotations;
	public int annotationCount;
	private RecoveredLambdaExpression initializer;
	public int modifiers;
	public int modifiersStart;


		this.localDeclaration.declarationSourceEnd = stmt.sourceEnd;
		this.localDeclaration.declarationEnd = stmt.sourceEnd;
		return this;
	}
}
/*
 * Record an expression statement if local variable is expecting an initialization expression.
 */
public RecoveredElement add(LambdaExpression expression, int bracketBalanceValue) {

	if (this.alreadyCompletedLocalInitialization) {
		return this;
	} else {
		this.alreadyCompletedLocalInitialization = true;
		this.localDeclaration.initialization = expression;
		this.localDeclaration.declarationSourceEnd = expression.sourceEnd;
		this.localDeclaration.declarationEnd = expression.sourceEnd;
		return this.initializer = new RecoveredLambdaExpression(expression, this, bracketBalanceValue);
	}
}
public void attach(RecoveredAnnotation[] annots, int annotCount, int mods, int modsSourceStart) {

			this.localDeclaration.declarationSourceStart = start;
		}
	}
	if (this.initializer != null)
		this.initializer.updateParseTree();
	return this.localDeclaration;
}
/*

Lines 626-632 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/RecoveredMethod.java (-1 / +1 lines)
626		626
627	int lastParameterEnd = parameters[parameters.length - 1].sourceEnd;	627	int lastParameterEnd = parameters[parameters.length - 1].sourceEnd;
628		628
629	Parser parser = parser();	629	CommitRollbackParser parser = parser();
630	Scanner scanner = parser.scanner;	630	Scanner scanner = parser.scanner;
631	if(Util.getLineNumber(this.methodDeclaration.declarationSourceStart, scanner.lineEnds, 0, scanner.linePtr)	631	if(Util.getLineNumber(this.methodDeclaration.declarationSourceStart, scanner.lineEnds, 0, scanner.linePtr)
632	!= Util.getLineNumber(lastParameterEnd, scanner.lineEnds, 0, scanner.linePtr)) return;	632	!= Util.getLineNumber(lastParameterEnd, scanner.lineEnds, 0, scanner.linePtr)) return;




import java.util.Set;

import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
import org.eclipse.jdt.internal.compiler.ast.Statement;

public class RecoveredStatement extends RecoveredElement {

	public Statement statement;
	public RecoveredLambdaExpression subExpression;
	
public RecoveredStatement(Statement statement, RecoveredElement parent, int bracketBalance){
	super(parent, bracketBalance);
	this.statement = statement;
}

public RecoveredElement add(LambdaExpression expression, int bracketBalanceValue) {
	return this.subExpression = new RecoveredLambdaExpression(expression, this, bracketBalanceValue);
}
/*
 * Answer the associated parsed structure
 */
public ASTNode parseTree() {
	if (this.subExpression != null)
		this.subExpression.updateParseTree();
	return this.statement;
}
/*

Lines 753-759 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/RecoveredType.java (-1 / +1 lines)
753	// might be an initializer	753	// might be an initializer
754	if (this.bracketBalance == 1){	754	if (this.bracketBalance == 1){
755	Block block = new Block(0);	755	Block block = new Block(0);
756	Parser parser = parser();	756	CommitRollbackParser parser = parser();
757	block.sourceStart = parser.scanner.startPosition;	757	block.sourceStart = parser.scanner.startPosition;
758	Initializer init;	758	Initializer init;
759	if (parser.recoveredStaticInitializerStart == 0){	759	if (parser.recoveredStaticInitializerStart == 0){




import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.util.Util;


	private int nextToken = TokenNameNotAToken; // allows for one token push back, only the most recent token can be reliably ungotten.
	private VanguardScanner vanguardScanner;
	private VanguardParser vanguardParser;
	protected ConflictedParser activeParser = null;
	private boolean consumingEllipsisAnnotations = false;
	
	public static final int RoundBracket = 0;

	static int IntersectionCastRule = 0;
	static int ReferenceExpressionRule = 0;
	static int VarargTypeAnnotationsRule  = 0;
	static int BlockStatementoptRule = 0;
	
	static Goal LambdaParameterListGoal;
	static Goal IntersectionCastGoal;
	static Goal VarargTypeAnnotationGoal;
	static Goal ReferenceExpressionGoal;
	static Goal BlockStatementoptGoal;
	static {
		
		for (int i = 1; i <= ParserBasicInformation.NUM_RULES; i++) {  // 0 == $acc

			else 
			if ("TypeAnnotations".equals(Parser.name[Parser.non_terminal_index[Parser.lhs[i]]])) //$NON-NLS-1$
				VarargTypeAnnotationsRule = i;
			else
			if ("BlockStatementopt".equals(Parser.name[Parser.non_terminal_index[Parser.lhs[i]]])) //$NON-NLS-1$
				BlockStatementoptRule = i;
					
		}
		
		LambdaParameterListGoal =  new Goal(TokenNameARROW, new int[] { TokenNameARROW }, LambdaParameterListRule);
		IntersectionCastGoal =     new Goal(TokenNameLPAREN, followSetOfCast(), IntersectionCastRule);
		VarargTypeAnnotationGoal = new Goal(TokenNameAT, new int[] { TokenNameELLIPSIS }, VarargTypeAnnotationsRule);
		ReferenceExpressionGoal =  new Goal(TokenNameLESS, new int[] { TokenNameCOLON_COLON }, ReferenceExpressionRule);
		BlockStatementoptGoal =    new Goal(TokenNameLBRACE, new int [0], BlockStatementoptRule);
	}



	boolean hasBeenReached(int act, int token) {
		/*
		System.out.println("[Goal = " + Parser.name[Parser.non_terminal_index[Parser.lhs[this.rule]]] + "]  " + "Saw: " + Parser.name[Parser.non_terminal_index[Parser.lhs[act]]] + "::" +  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
					Parser.name[Parser.terminal_index[token]]);
		*/
		if (act == this.rule) {
			final int length = this.follow.length;
			if (length == 0)
				return true;
			for (int i = 0; i < length; i++)
				if (this.follow[i] == token)
					return true;
		}

				if (act <= NUM_RULES) {
					this.stateStackTop--;
				} else if (act > ERROR_ACTION) { /* shift-reduce */
					this.currentToken = this.scanner.getNextToken();
					try {
						this.currentToken = this.scanner.getNextToken();
					} finally {
						this.unstackedAct = ERROR_ACTION;
					}
					act -= ERROR_ACTION;
				} else {
				    if (act < ACCEPT_ACTION) { /* shift */
				    	this.currentToken = this.scanner.getNextToken();
						try {
							this.currentToken = this.scanner.getNextToken();
						} finally {
							this.unstackedAct = ERROR_ACTION;
						}
						continue ProcessTerminals;
					}
				    return FAILURE; // accept - we should never reach this state, we accept at reduce with a right member of follow set below.

	}
	return token;
}

// Position the scanner at the next block statement and return the start token. We recognize empty statements.
public int fastForward(Statement unused) {
	
	int token;

	while (true) {
		try {
			token = getNextToken();
		} catch (InvalidInputException e) {
			return TokenNameEOF;
		}
		/* FOLLOW map of BlockStatement, since the non-terminal is recursive is a super set of its own FIRST set. 
	   	   We use FOLLOW rather than FIRST since we want to recognize empty statements. i.e if (x > 10) {  x = 0 }
		*/
		switch(token) {
			case TokenNameIdentifier:
			case TokenNameabstract:
			case TokenNameassert:
			case TokenNameboolean:
			case TokenNamebreak:
			case TokenNamebyte:
			case TokenNamecase:
			case TokenNamechar:
			case TokenNameclass:
			case TokenNamecontinue:
			case TokenNamedefault:
			case TokenNamedo:
			case TokenNamedouble:
			case TokenNameenum:
			case TokenNamefalse:
			case TokenNamefinal:
			case TokenNamefloat:
			case TokenNamefor:
			case TokenNameif:
			case TokenNameint:
			case TokenNameinterface:
			case TokenNamelong:
			case TokenNamenative:
			case TokenNamenew:
			case TokenNamenull:
			case TokenNameprivate:
			case TokenNameprotected:
			case TokenNamepublic:
			case TokenNamereturn:
			case TokenNameshort:
			case TokenNamestatic:
			case TokenNamestrictfp:
			case TokenNamesuper:
			case TokenNameswitch:
			case TokenNamesynchronized:
			case TokenNamethis:
			case TokenNamethrow:
			case TokenNametransient:
			case TokenNametrue:
			case TokenNametry:
			case TokenNamevoid:
			case TokenNamevolatile:
			case TokenNamewhile:
			case TokenNameIntegerLiteral: // ??!
			case TokenNameLongLiteral:
			case TokenNameFloatingPointLiteral:
			case TokenNameDoubleLiteral:
			case TokenNameCharacterLiteral:
			case TokenNameStringLiteral:
			case TokenNamePLUS_PLUS:
			case TokenNameMINUS_MINUS:
			case TokenNameLESS:
			case TokenNameLPAREN:
			case TokenNameLBRACE:
			case TokenNameAT:
			case TokenNameBeginLambda:
			case TokenNameAT308:
				if(getVanguardParser().parse(Goal.BlockStatementoptGoal) == VanguardParser.SUCCESS)
					return token;
				break;
			case TokenNameSEMICOLON:
			case TokenNameEOF:
				return token;
			case TokenNameRBRACE: // simulate empty statement.
				ungetToken(token);
				return TokenNameSEMICOLON;
			default:
				break;
		}
	}
}
}

Lines 2588-2591 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/diagnose/DiagnoseParser.java (+8 lines)
2588	*/	2588	*/
2589	return (token == TokenNameLPAREN \|\| token == TokenNameAT \|\| (token == TokenNameLESS && !this.lexStream.awaitingColonColon()));	2589	return (token == TokenNameLPAREN \|\| token == TokenNameAT \|\| (token == TokenNameLESS && !this.lexStream.awaitingColonColon()));
2590	}	2590	}
		2591
		2592	public void startRecovery() {
		2593	return; // not in that business.
		2594	}
		2595
		2596	public boolean requireExtendedRecovery() {
		2597	return false; // not in that business.
		2598	}
2591	}	2599	}

Lines 790-796 Link Here

(-)a/org.eclipse.jdt.core/eval/org/eclipse/jdt/internal/eval/CodeSnippetParser.java (-1 / +1 lines)
790	* A syntax error was detected. If a method is being parsed, records the number of errors and	790	* A syntax error was detected. If a method is being parsed, records the number of errors and
791	* attempts to restart from the last statement by going for an expression.	791	* attempts to restart from the last statement by going for an expression.
792	*/	792	*/
793	protected int resumeOnSyntaxError() {	793	protected int resumeOnErrorOrTriggeredRecovery(boolean errorRecovery) {
794	if (this.diet \|\| this.hasRecoveredOnExpression) { // no reentering inside expression recovery	794	if (this.diet \|\| this.hasRecoveredOnExpression) { // no reentering inside expression recovery
795	return HALT;	795	return HALT;
796	}	796	}

Lines 1511-1517 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/DocumentElementParser.java (-1 / +1 lines)
1511	* Syntax error was detected. Will attempt to perform some recovery action in order	1511	* Syntax error was detected. Will attempt to perform some recovery action in order
1512	* to resume to the regular parse loop.	1512	* to resume to the regular parse loop.
1513	*/	1513	*/
1514	protected int resumeOnSyntaxError() {	1514	protected int resumeOnErrorOrTriggeredRecovery(boolean errorRecovery) {
1515	return HALT;	1515	return HALT;
1516	}	1516	}
1517	/*	1517	/*

Lines 41-47 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/CompilationUnitStructureRequestor.java (-2 / +2 lines)
41	import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;	41	import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
42	import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;	42	import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
43	import org.eclipse.jdt.internal.compiler.ast.UnaryExpression;	43	import org.eclipse.jdt.internal.compiler.ast.UnaryExpression;
44	import org.eclipse.jdt.internal.compiler.parser.Parser;	44	import org.eclipse.jdt.internal.compiler.parser.CommitRollbackParser;
45	import org.eclipse.jdt.internal.compiler.parser.RecoveryScanner;	45	import org.eclipse.jdt.internal.compiler.parser.RecoveryScanner;
46	import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;	46	import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;
47	import org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt;	47	import org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt;
Lines 122-128 Link Here
122	/*	122	/*
123	* The parser this requestor is using.	123	* The parser this requestor is using.
124	*/	124	*/
125	protected Parser parser;	125	protected CommitRollbackParser parser;
126		126
127	protected HashtableOfObject fieldRefCache;	127	protected HashtableOfObject fieldRefCache;
128	protected HashtableOfObject messageRefCache;	128	protected HashtableOfObject messageRefCache;

Return to bug 422468

Lines 19-24 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Scanner.java (-16 / +103 lines)
19	import org.eclipse.jdt.core.compiler.CharOperation;	19	import org.eclipse.jdt.core.compiler.CharOperation;
20	import org.eclipse.jdt.core.compiler.InvalidInputException;	20	import org.eclipse.jdt.core.compiler.InvalidInputException;
21	import org.eclipse.jdt.internal.compiler.CompilationResult;	21	import org.eclipse.jdt.internal.compiler.CompilationResult;
		22	import org.eclipse.jdt.internal.compiler.ast.Statement;
22	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	23	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
23	import org.eclipse.jdt.internal.compiler.util.Util;	24	import org.eclipse.jdt.internal.compiler.util.Util;
24		25
Lines 200-206 Link Here
200	private int nextToken = TokenNameNotAToken; // allows for one token push back, only the most recent token can be reliably ungotten.	201	private int nextToken = TokenNameNotAToken; // allows for one token push back, only the most recent token can be reliably ungotten.
201	private VanguardScanner vanguardScanner;	202	private VanguardScanner vanguardScanner;
202	private VanguardParser vanguardParser;	203	private VanguardParser vanguardParser;
203	private ConflictedParser activeParser = null;	204	protected ConflictedParser activeParser = null;
204	private boolean consumingEllipsisAnnotations = false;	205	private boolean consumingEllipsisAnnotations = false;
205		206
206	public static final int RoundBracket = 0;	207	public static final int RoundBracket = 0;
Lines 4241-4252 Link Here
4241	static int IntersectionCastRule = 0;	4242	static int IntersectionCastRule = 0;
4242	static int ReferenceExpressionRule = 0;	4243	static int ReferenceExpressionRule = 0;
4243	static int VarargTypeAnnotationsRule = 0;	4244	static int VarargTypeAnnotationsRule = 0;
		4245	static int BlockStatementoptRule = 0;
4244		4246
4245	static Goal LambdaParameterListGoal;	4247	static Goal LambdaParameterListGoal;
4246	static Goal IntersectionCastGoal;	4248	static Goal IntersectionCastGoal;
4247	static Goal VarargTypeAnnotationGoal;	4249	static Goal VarargTypeAnnotationGoal;
4248	static Goal ReferenceExpressionGoal;	4250	static Goal ReferenceExpressionGoal;
4249		4251	static Goal BlockStatementoptGoal;
4250	static {	4252	static {
4251		4253
4252	for (int i = 1; i <= ParserBasicInformation.NUM_RULES; i++) { // 0 == $acc	4254	for (int i = 1; i <= ParserBasicInformation.NUM_RULES; i++) { // 0 == $acc
Lines 4261-4272 Link Here
4261	else	4263	else
4262	if ("TypeAnnotations".equals(Parser.name[Parser.non_terminal_index[Parser.lhs[i]]])) //$NON-NLS-1$	4264	if ("TypeAnnotations".equals(Parser.name[Parser.non_terminal_index[Parser.lhs[i]]])) //$NON-NLS-1$
4263	VarargTypeAnnotationsRule = i;	4265	VarargTypeAnnotationsRule = i;
		4266	else
		4267	if ("BlockStatementopt".equals(Parser.name[Parser.non_terminal_index[Parser.lhs[i]]])) //$NON-NLS-1$
		4268	BlockStatementoptRule = i;
		4269
4264	}	4270	}
4265		4271
4266	LambdaParameterListGoal = new Goal(TokenNameARROW, new int[] { TokenNameARROW }, LambdaParameterListRule);	4272	LambdaParameterListGoal = new Goal(TokenNameARROW, new int[] { TokenNameARROW }, LambdaParameterListRule);
4267	IntersectionCastGoal = new Goal(TokenNameLPAREN, followSetOfCast(), IntersectionCastRule);	4273	IntersectionCastGoal = new Goal(TokenNameLPAREN, followSetOfCast(), IntersectionCastRule);
4268	VarargTypeAnnotationGoal = new Goal(TokenNameAT, new int[] { TokenNameELLIPSIS }, VarargTypeAnnotationsRule);	4274	VarargTypeAnnotationGoal = new Goal(TokenNameAT, new int[] { TokenNameELLIPSIS }, VarargTypeAnnotationsRule);
4269	ReferenceExpressionGoal = new Goal(TokenNameLESS, new int[] { TokenNameCOLON_COLON }, ReferenceExpressionRule);	4275	ReferenceExpressionGoal = new Goal(TokenNameLESS, new int[] { TokenNameCOLON_COLON }, ReferenceExpressionRule);
		4276	BlockStatementoptGoal = new Goal(TokenNameLBRACE, new int [0], BlockStatementoptRule);
4270	}	4277	}
4271		4278
4272		4279
Lines 4279-4288 Link Here
4279	boolean hasBeenReached(int act, int token) {	4286	boolean hasBeenReached(int act, int token) {
4280	/*	4287	/*
4281	System.out.println("[Goal = " + Parser.name[Parser.non_terminal_index[Parser.lhs[this.rule]]] + "] " + "Saw: " + Parser.name[Parser.non_terminal_index[Parser.lhs[act]]] + "::" + //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$	4288	System.out.println("[Goal = " + Parser.name[Parser.non_terminal_index[Parser.lhs[this.rule]]] + "] " + "Saw: " + Parser.name[Parser.non_terminal_index[Parser.lhs[act]]] + "::" + //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
4282	Parser.name[Parser.terminal_index[token]]);	4289	Parser.name[Parser.terminal_index[token]]);
4283	*/	4290	*/
4284	if (act == this.rule) {	4291	if (act == this.rule) {
4285	for (int i = 0, length = this.follow.length; i < length; i++)	4292	final int length = this.follow.length;
		4293	if (length == 0)
		4294	return true;
		4295	for (int i = 0; i < length; i++)
4286	if (this.follow[i] == token)	4296	if (this.follow[i] == token)
4287	return true;	4297	return true;
4288	}	4298	}
Lines 4330-4350 Link Here
4330	if (act <= NUM_RULES) {	4340	if (act <= NUM_RULES) {
4331	this.stateStackTop--;	4341	this.stateStackTop--;
4332	} else if (act > ERROR_ACTION) { /* shift-reduce */	4342	} else if (act > ERROR_ACTION) { /* shift-reduce */
4333	this.unstackedAct = act;	4343	this.currentToken = this.scanner.getNextToken();
4334	try {
4335	this.currentToken = this.scanner.getNextToken();
4336	} finally {
4337	this.unstackedAct = ERROR_ACTION;
4338	}
4339	act -= ERROR_ACTION;	4344	act -= ERROR_ACTION;
4340	} else {	4345	} else {
4341	if (act < ACCEPT_ACTION) { /* shift */	4346	if (act < ACCEPT_ACTION) { /* shift */
4342	this.unstackedAct = act;	4347	this.currentToken = this.scanner.getNextToken();
4343	try {
4344	this.currentToken = this.scanner.getNextToken();
4345	} finally {
4346	this.unstackedAct = ERROR_ACTION;
4347	}
4348	continue ProcessTerminals;	4348	continue ProcessTerminals;
4349	}	4349	}
4350	return FAILURE; // accept - we should never reach this state, we accept at reduce with a right member of follow set below.	4350	return FAILURE; // accept - we should never reach this state, we accept at reduce with a right member of follow set below.
Lines 4493-4496 Link Here
4493	}	4493	}
4494	return token;	4494	return token;
4495	}	4495	}
		4496
		4497	// Position the scanner at the next block statement and return the start token. We recognize empty statements.
		4498	public int fastForward(Statement unused) {
		4499
		4500	int token;
		4501
		4502	while (true) {
		4503	try {
		4504	token = getNextToken();
		4505	} catch (InvalidInputException e) {
		4506	return TokenNameEOF;
		4507	}
		4508	/* FOLLOW map of BlockStatement, since the non-terminal is recursive is a super set of its own FIRST set.
		4509	We use FOLLOW rather than FIRST since we want to recognize empty statements. i.e if (x > 10) { x = 0 }
		4510	*/
		4511	switch(token) {
		4512	case TokenNameIdentifier:
		4513	case TokenNameabstract:
		4514	case TokenNameassert:
		4515	case TokenNameboolean:
		4516	case TokenNamebreak:
		4517	case TokenNamebyte:
		4518	case TokenNamecase:
		4519	case TokenNamechar:
		4520	case TokenNameclass:
		4521	case TokenNamecontinue:
		4522	case TokenNamedefault:
		4523	case TokenNamedo:
		4524	case TokenNamedouble:
		4525	case TokenNameenum:
		4526	case TokenNamefalse:
		4527	case TokenNamefinal:
		4528	case TokenNamefloat:
		4529	case TokenNamefor:
		4530	case TokenNameif:
		4531	case TokenNameint:
		4532	case TokenNameinterface:
		4533	case TokenNamelong:
		4534	case TokenNamenative:
		4535	case TokenNamenew:
		4536	case TokenNamenull:
		4537	case TokenNameprivate:
		4538	case TokenNameprotected:
		4539	case TokenNamepublic:
		4540	case TokenNamereturn:
		4541	case TokenNameshort:
		4542	case TokenNamestatic:
		4543	case TokenNamestrictfp:
		4544	case TokenNamesuper:
		4545	case TokenNameswitch:
		4546	case TokenNamesynchronized:
		4547	case TokenNamethis:
		4548	case TokenNamethrow:
		4549	case TokenNametransient:
		4550	case TokenNametrue:
		4551	case TokenNametry:
		4552	case TokenNamevoid:
		4553	case TokenNamevolatile:
		4554	case TokenNamewhile:
		4555	case TokenNameIntegerLiteral: // ??!
		4556	case TokenNameLongLiteral:
		4557	case TokenNameFloatingPointLiteral:
		4558	case TokenNameDoubleLiteral:
		4559	case TokenNameCharacterLiteral:
4560	case TokenNameStringLiteral:
4561	case TokenNamePLUS_PLUS:
4562	case TokenNameMINUS_MINUS:
4563	case TokenNameLESS:
4564	case TokenNameLPAREN:
4565	case TokenNameLBRACE:
4566	case TokenNameAT:
4567	case TokenNameBeginLambda:
4568	case TokenNameAT308:
4569	if(getVanguardParser().parse(Goal.BlockStatementoptGoal) == VanguardParser.SUCCESS)
4570	return token;
4571	break;
4572	case TokenNameSEMICOLON:
4573	case TokenNameEOF:
4574	return token;
4575	case TokenNameRBRACE: // simulate empty statement.
4576	ungetToken(token);
4577	return TokenNameSEMICOLON;
4578	default:
4579	break;
4580	}
4581	}
4582	}
4496	}	4583	}

Lines 570-576 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests18.java (-1 / +95 lines)
570	" public static void main(String[] args) {\n" +	570	" public static void main(String[] args) {\n" +
571	" I i = () -> {\n" +	571	" I i = () -> {\n" +
572	" xyz\n" +	572	" xyz\n" +
573	" }\n" +	573	" }\n" +
574	" }\n" +	574	" }\n" +
575	"}\n");	575	"}\n");
576		576
Lines 597-600 Link Here
597	" goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +	597	" goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
598	"}" , requestor.getContext());	598	"}" , requestor.getContext());
599	}	599	}
		600	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		601	public void _test018() throws JavaModelException { // ensure higher relevance for matching return type.
		602	this.workingCopies = new ICompilationUnit[1];
		603	this.workingCopies[0] = getWorkingCopy(
		604	"/Completion/src/X.java",
		605	"interface I {\n" +
		606	" void foo(String x);\n" +
		607	"}\n" +
		608	"public class X {\n" +
		609	" String xField;\n" +
		610	" static void goo(String s) {\n" +
		611	" }\n" +
		612	" static void goo(I i) {\n" +
		613	" }\n" +
		614	" public static void main(String[] args) {\n" +
		615	" goo((xyz) -> {\n" +
		616	" System.out.println(xyz.);\n" +
		617	" });\n" +
		618	" }\n" +
		619	"}\n");
		620
		621	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, true, true, false);
		622	requestor.allowAllRequiredProposals();
		623	requestor.setRequireExtendedContext(true);
		624	requestor.setComputeEnclosingElement(false);
		625	requestor.setComputeVisibleElements(true);
		626	requestor.setAssignableType("LX;");
		627
		628	String str = this.workingCopies[0].getSource();
		629	String completeBehind = "xyz.";
		630	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		631	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		632	assertEquals("completion offset=192\n" +
		633	"completion range=[189, 191]\n" +
		634	"completion token=\"xyz\"\n" +
		635	"completion token kind=TOKEN_KIND_NAME\n" +
		636	"expectedTypesSignatures=null\n" +
		637	"expectedTypesKeys=null\n" +
		638	"completion token location={STATEMENT_START}\n" +
		639	"visibleElements={\n" +
		640	" xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
		641	" goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
		642	"}" , requestor.getContext());
		643	}
		644	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		645	public void _test018a() throws JavaModelException { // ensure higher relevance for matching return type.
		646	this.workingCopies = new ICompilationUnit[1];
		647	this.workingCopies[0] = getWorkingCopy(
		648	"/Completion/src/X.java",
		649	"interface I {\n" +
		650	" void foo(String x);\n" +
		651	"}\n" +
		652	"public class X {\n" +
		653	" String xField;\n" +
		654	" static void goo(String s) {\n" +
		655	" }\n" +
		656	" static void goo(I i) {\n" +
		657	" }\n" +
		658	" public static void main(String[] args) {\n" +
		659	" args = null;\n" +
		660	" if (args != null) {\n" +
		661	" xField = null;\n" +
		662	" else \n" +
		663	" xField = null;\n" +
664	" while (true);\n" +
665	" goo((xyz) -> {\n" +
666	" System.out.println(xyz.)\n" +
667	" });\n" +
668	" }\n" +
669	"}\n");
670
671	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, true, true, false);
672	requestor.allowAllRequiredProposals();
673	requestor.setRequireExtendedContext(true);
674	requestor.setComputeEnclosingElement(false);
675	requestor.setComputeVisibleElements(true);
676	requestor.setAssignableType("LX;");
677
678	String str = this.workingCopies[0].getSource();
679	String completeBehind = "xyz.";
680	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
681	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
682	assertEquals("completion offset=192\n" +
683	"completion range=[189, 191]\n" +
684	"completion token=\"xyz\"\n" +
685	"completion token kind=TOKEN_KIND_NAME\n" +
686	"expectedTypesSignatures=null\n" +
687	"expectedTypesKeys=null\n" +
688	"completion token location={STATEMENT_START}\n" +
689	"visibleElements={\n" +
690	" xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
691	" goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
692	"}" , requestor.getContext());
693	}
600	}	694	}

Lines 28-34 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/ResolveTests18.java (-1 / +100 lines)
28	ICompilationUnit wc = null;	28	ICompilationUnit wc = null;
29		29
30	static {	30	static {
31	// TESTS_NAMES = new String[] { "test0023" };	31	// TESTS_NAMES = new String[] { "testParser" };
32	// TESTS_NUMBERS = new int[] { 124 };	32	// TESTS_NUMBERS = new int[] { 124 };
33	// TESTS_RANGE = new int[] { 16, -1 };	33	// TESTS_RANGE = new int[] { 16, -1 };
34	}	34	}
Lines 1531-1534 Link Here
1531	elements	1531	elements
1532	);	1532	);
1533	}	1533	}
		1534	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		1535	public void test422468d() throws JavaModelException {
		1536	this.wc = getWorkingCopy(
		1537	"/Resolve/src/X.java",
		1538	"interface I {\n" +
		1539	" J foo(String x, String y);\n" +
		1540	"}\n" +
		1541	"interface J {\n" +
		1542	" K foo(String x, String y);\n" +
		1543	"}\n" +
		1544	"interface K {\n" +
		1545	" int foo(String x, int y);\n" +
		1546	"}\n" +
		1547	"public class X {\n" +
		1548	" static void goo(K i) {}\n" +
		1549	" public static void main(String[] args) {\n" +
		1550	" I i = (x, y) -> { return (a, b) -> (p, q) -> a.length(); };\n" +
		1551	" }\n" +
		1552	"}\n");
		1553
		1554	String str = this.wc.getSource();
		1555	String selection = "a.length";
		1556	int start = str.lastIndexOf(selection);
		1557	int length = selection.length();
		1558
		1559	IJavaElement[] elements = this.wc.codeSelect(start, length);
		1560	assertElementsEqual(
		1561	"Unexpected elements",
		1562	"length() [in String [in String.class [in java.lang [in "+ getExternalPath() + "jclMin1.8.jar]]]]",
		1563	elements
		1564	);
		1565	}
		1566	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		1567	public void test422468e() throws JavaModelException {
		1568	this.wc = getWorkingCopy(
		1569	"/Resolve/src/X.java",
		1570	"interface I {\n" +
		1571	" J foo(String x, String y);\n" +
		1572	"}\n" +
		1573	"interface J {\n" +
		1574	" K foo(String x, String y);\n" +
		1575	"}\n" +
		1576	"interface K {\n" +
		1577	" int foo(String x, int y);\n" +
		1578	"}\n" +
		1579	"public class X {\n" +
		1580	" static void goo(K i) {}\n" +
		1581	" public static void main(String[] args) {\n" +
		1582	" I i = (x, y) -> { return (a, b) -> (p, q) -> a.length(); };\n" +
		1583	" }\n" +
		1584	"}\n");
		1585
		1586	String str = this.wc.getSource();
		1587	String selection = "q";
		1588	int start = str.lastIndexOf(selection);
		1589	int length = selection.length();
		1590
		1591	IJavaElement[] elements = this.wc.codeSelect(start, length);
		1592	assertElementsEqual(
		1593	"Unexpected elements",
		1594	"q [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Resolve]]]]]]",
		1595	elements
		1596	);
		1597	}
1598	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
1599	public void testParser() throws JavaModelException {
1600	this.wc = getWorkingCopy(
1601	"/Resolve/src/X.java",
1602	"interface I {\n" +
1603	" int foo(String x, Integer y);\n" +
1604	"}\n" +
1605	"public class X {\n" +
1606	" public static void main(String[] args) {\n" +
1607	" I i = (x, y) -> {\n" +
1608	" x = \"Hello\"\n" +
1609	" y = 10; \n" +
1610	" if (x.length() > y) {\n" +
1611	" System.out.println(\"if\");\n" +
1612	" } else {\n" +
1613	" System.out.println(\"else\");\n" +
1614	" }\n" +
1615	" return x.length();\n" +
1616	" };\n" +
1617	" // System.out.println((I) (p, q) -> { return q.\n" +
1618	" }\n" +
1619	"}\n");
1620
1621	String str = this.wc.getSource();
1622	String selection = "x";
1623	int start = str.lastIndexOf(selection);
1624	int length = selection.length();
1625
1626	IJavaElement[] elements = this.wc.codeSelect(start, length);
1627	assertElementsEqual(
1628	"Unexpected elements",
1629	"x [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Resolve]]]]]]",
1630	elements
1631	);
1632	}
1534	}	1633	}

Lines 71-94 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java (-16 / +64 lines)
71	private Statement body;	71	private Statement body;
72	public boolean hasParentheses;	72	public boolean hasParentheses;
73	public MethodScope scope;	73	public MethodScope scope;
74	private boolean voidCompatible = true;	74	boolean voidCompatible = true;
75	private boolean valueCompatible = false;	75	boolean valueCompatible = false;
76	private boolean shapeAnalysisComplete = false;	76	private boolean shapeAnalysisComplete = false;
77	private boolean returnsValue;	77	boolean returnsValue;
78	private boolean returnsVoid;	78	boolean returnsVoid;
79	private LambdaExpression original = this;	79	private LambdaExpression original = this;
80	private SyntheticArgumentBinding[] outerLocalVariables = NO_SYNTHETIC_ARGUMENTS;	80	private SyntheticArgumentBinding[] outerLocalVariables = NO_SYNTHETIC_ARGUMENTS;
81	private int outerLocalVariablesSlotSize = 0;	81	private int outerLocalVariablesSlotSize = 0;
82	public boolean shouldCaptureInstance = false;	82	public boolean shouldCaptureInstance = false;
83	private boolean shouldUnelideTypes = false;	83	private boolean assistNode = false;
84	private boolean hasIgnoredMandatoryErrors = false;	84	private boolean hasIgnoredMandatoryErrors = false;
85	private static final SyntheticArgumentBinding [] NO_SYNTHETIC_ARGUMENTS = new SyntheticArgumentBinding[0];	85	private static final SyntheticArgumentBinding [] NO_SYNTHETIC_ARGUMENTS = new SyntheticArgumentBinding[0];
86		86
87	public LambdaExpression(CompilationResult compilationResult, boolean shouldUnelideTypes) {	87	public LambdaExpression(CompilationResult compilationResult, boolean assistNode) {
88	super(compilationResult);	88	super(compilationResult);
89	this.shouldUnelideTypes = shouldUnelideTypes;	89	this.assistNode = assistNode;
90	setArguments(NO_ARGUMENTS);	90	setArguments(NO_ARGUMENTS);
91	setBody(new Block(0));	91	setBody(NO_BODY);
92	}	92	}
93		93
94	public void setArguments(Argument [] arguments) {	94	public void setArguments(Argument [] arguments) {
Lines 101-107 Link Here
101	}	101	}
102		102
103	public void setBody(Statement body) {	103	public void setBody(Statement body) {
104	this.body = body == null ? new Block(0) : body;	104	this.body = body == null ? NO_BODY : body;
105	}	105	}
106		106
107	public Statement body() {	107	public Statement body() {
Lines 110-115 Link Here
110		110
111	public void setArrowPosition(int arrowPosition) {	111	public void setArrowPosition(int arrowPosition) {
112	this.arrowPosition = arrowPosition;	112	this.arrowPosition = arrowPosition;
		113	}
		114
		115	public int getArrowPosition() {
		116	return this.arrowPosition;
113	}	117	}
114		118
115	protected FunctionalExpression original() {	119	protected FunctionalExpression original() {
Lines 188-194 Link Here
188		192
189	if (!haveDescriptor) {	193	if (!haveDescriptor) {
190	if (argumentsTypeElided) {	194	if (argumentsTypeElided) {
191	if (!this.shouldUnelideTypes)	195	if (!this.assistNode)
192	return null; // FUBAR, bail out...	196	return null; // FUBAR, bail out...
193	// for code assist ONLY, keep the sluice gate shut on bogus errors otherwise.	197	// for code assist ONLY, keep the sluice gate shut on bogus errors otherwise.
194	argumentsTypeElided = false;	198	argumentsTypeElided = false;
Lines 524-529 Link Here
524	return false;	528	return false;
525	}	529	}
526		530
		531	private void analyzeShape() { // simple minded analysis for code assist.
		532	class ShapeComputer extends ASTVisitor {
		533	public boolean visit(TypeDeclaration type, BlockScope skope) {
		534	return false;
		535	}
		536	public boolean visit(TypeDeclaration type, ClassScope skope) {
		537	return false;
		538	}
		539	public boolean visit(LambdaExpression type, BlockScope skope) {
		540	return false;
		541	}
		542	public boolean visit(ReturnStatement returnStatement, BlockScope skope) {
		543	if (returnStatement.expression != null) {
		544	LambdaExpression.this.valueCompatible = true;
		545	LambdaExpression.this.voidCompatible = false;
		546	} else {
		547	LambdaExpression.this.voidCompatible = true;
		548	LambdaExpression.this.valueCompatible = false;
		549	}
		550	return false;
		551	}
		552	}
		553	if (this.body instanceof Expression) {
		554	this.voidCompatible = ((Expression) this.body).statementExpression();
		555	this.valueCompatible = true;
		556	} else {
		557	// We need to be a bit tolerant/fuzzy here: the code is being written "just now", if we are too pedantic, selection/completion will break;
		558	this.voidCompatible = true;
		559	this.valueCompatible = true;
		560	this.body.traverse(new ShapeComputer(), null);
		561	}
		562	this.shapeAnalysisComplete = true;
		563	}
		564
527	public boolean isCompatibleWith(final TypeBinding left, final Scope someScope) {	565	public boolean isCompatibleWith(final TypeBinding left, final Scope someScope) {
528		566
529	final MethodBinding sam = left.getSingleAbstractMethod(this.enclosingScope);	567	final MethodBinding sam = left.getSingleAbstractMethod(this.enclosingScope);
Lines 540-547 Link Here
540	compilerOptions.isAnnotationBasedNullAnalysisEnabled = false;	578	compilerOptions.isAnnotationBasedNullAnalysisEnabled = false;
541	try {	579	try {
542	final LambdaExpression copy = copy();	580	final LambdaExpression copy = copy();
543	if (copy == null)	581	if (copy == null) {
544	return false;	582	if (this.assistNode) {
		583	analyzeShape(); // not on terra firma here !
		584	if (sam.returnType.id == TypeIds.T_void) {
		585	if (!this.voidCompatible)
		586	return false;
		587	} else {
		588	if (!this.valueCompatible)
		589	return false;
		590	}
		591	}
		592	return !isPertinentToApplicability(left);
		593	}
545	copy.setExpressionContext(this.expressionContext);	594	copy.setExpressionContext(this.expressionContext);
546	copy.setExpectedType(left);	595	copy.setExpectedType(left);
547	this.hasIgnoredMandatoryErrors = false;	596	this.hasIgnoredMandatoryErrors = false;
Lines 576-584 Link Here
576	}	625	}
577	}	626	}
578		627
579	if (!isPertinentToApplicability(left))	628	if (!isPertinentToApplicability(left)) // This check should happen after return type check below, but for buggy javac compatibility we have left it in.
580	return true;	629	return true;
581		630
582	if (sam.returnType.id == TypeIds.T_void) {	631	if (sam.returnType.id == TypeIds.T_void) {
583	if (!this.voidCompatible)	632	if (!this.voidCompatible)
584	return false;	633	return false;
Lines 586-593 Link Here
586	if (!this.valueCompatible)	635	if (!this.valueCompatible)
587	return false;	636	return false;
588	}	637	}
589		638	Expression [] returnExpressions = this.resultExpressions;
590	Expression [] returnExpressions = this.resultExpressions;
591	for (int i = 0, length = returnExpressions.length; i < length; i++) {	639	for (int i = 0, length = returnExpressions.length; i < length; i++) {
592	if (returnExpressions[i] instanceof FunctionalExpression) { // don't want to use the resolvedType - polluted from some other overload resolution candidate	640	if (returnExpressions[i] instanceof FunctionalExpression) { // don't want to use the resolvedType - polluted from some other overload resolution candidate
593	if (!returnExpressions[i].isCompatibleWith(sam.returnType, this.enclosingScope))	641	if (!returnExpressions[i].isCompatibleWith(sam.returnType, this.enclosingScope))

Added Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/CommitRollbackParser.java (+308 lines)
1	/*******************************************************************************
2	* Copyright (c) 2013 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* This is an implementation of an early-draft specification developed under the Java
9	* Community Process (JCP) and is made available for testing and evaluation purposes
10	* only. The code is not compatible with any specification of the JCP.
11	*
12	* Contributors:
13	* IBM Corporation - initial API and implementation
14	*******************************************************************************/
15	package org.eclipse.jdt.internal.compiler.parser;
16
17	import org.eclipse.jdt.core.compiler.InvalidInputException;
18	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
19	import org.eclipse.jdt.internal.compiler.ast.Annotation;
20	import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
21	import org.eclipse.jdt.internal.compiler.ast.Expression;
22	import org.eclipse.jdt.internal.compiler.ast.Statement;
23	import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
24
25	public abstract class CommitRollbackParser implements TerminalTokens, ParserBasicInformation {
26
27	// resumeOnSyntaxError codes:
28	protected static final int HALT = 0; // halt and throw up hands.
29	protected static final int RESTART = 1; // stacks adjusted, alternate goal from check point.
30	protected static final int RESUME = 2; // stacks untouched, just continue from where left off.
31
32	public static byte rhs[] = null;
33	public static char lhs[] = null;
34	public static char term_action[] = null;
35	public static byte term_check[] = null;
36	public static char base_action[] = null;
37
38	public ReferenceContext referenceContext;
39
40
41	// Constants.
42	protected static final int AstStackIncrement = 100;
43	protected static final int ExpressionStackIncrement = 100;
44	protected static final int GenericsStackIncrement = 10;
45	protected static final int StackIncrement = 255;
46	protected static final int TypeAnnotationStackIncrement = 100;
47
48	public Scanner scanner;
49	public int currentToken;
50	protected int kurrentToken; // copy of currentToken as it is trampled over all over the place :-(
51	protected boolean commit = false;
52
53	// ------------- Stack pointers ---------------
54
55	protected int stateStackTop;
56	protected int unstackedAct;
57
58	protected int identifierPtr;
59	protected int identifierLengthPtr;
60
61	protected int astPtr;
62	protected int astLengthPtr;
63
64	protected int expressionPtr;
65	protected int expressionLengthPtr;
66
67	protected int genericsPtr;
68	protected int genericsLengthPtr;
69	protected int genericsIdentifiersLengthPtr;
70
71	protected int typeAnnotationPtr;
72	protected int typeAnnotationLengthPtr;
73
74	protected int intPtr;
75	protected int nestedType;
76	protected int realBlockPtr;
77	public int valueLambdaNestDepth = -1;
78
79	// ---------------- Stacks ----------------
80
81	protected int[] stack = new int[StackIncrement];
82
83	protected char[][] identifierStack;
84	protected int[] identifierLengthStack;
85	protected long[] identifierPositionStack;
86
87	protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
88	protected int[] astLengthStack;
89
90	protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];
91	protected int[] expressionLengthStack;
92
93	protected ASTNode[] genericsStack = new ASTNode[GenericsStackIncrement];
94	protected int[] genericsLengthStack = new int[GenericsStackIncrement];
95	protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];
96
97	protected Annotation [] typeAnnotationStack = new Annotation[TypeAnnotationStackIncrement];
98	protected int [] typeAnnotationLengthStack;
99
100	protected int[] intStack;
101	protected int[] nestedMethod;
102	protected int[] realBlockStack;
103	protected int stateStackLengthStack[] = new int[0];
104	protected int[] variablesCounter;
105
106	// Loose variables.
107
108	protected int listLength;
109	protected int listTypeParameterLength;
110	protected int modifiers;
111	protected int modifiersSourceStart;
112	protected int dimensions;
113	protected int recoveredStaticInitializerStart;
114
115	CommitRollbackParser cryogenicallyFrozenParser;
116	private static final int[] RECOVERY_TOKENS = new int [] { TokenNameSEMICOLON, TokenNameRPAREN,};
117
118	protected void copyState(CommitRollbackParser parser) {
119
120	// Stack pointers.
121
122	this.stateStackTop = parser.stateStackTop;
123	this.unstackedAct = parser.unstackedAct;
124	this.identifierPtr = parser.identifierPtr;
125	this.identifierLengthPtr = parser.identifierLengthPtr;
126	this.astPtr = parser.astPtr;
127	this.astLengthPtr = parser.astLengthPtr;
128	this.expressionPtr = parser.expressionPtr;
129	this.expressionLengthPtr = parser.expressionLengthPtr;
130	this.genericsPtr = parser.genericsPtr;
131	this.genericsLengthPtr = parser.genericsLengthPtr;
132	this.genericsIdentifiersLengthPtr = parser.genericsIdentifiersLengthPtr;
133	this.typeAnnotationPtr = parser.typeAnnotationPtr;
134	this.typeAnnotationLengthPtr = parser.typeAnnotationLengthPtr;
135	this.intPtr = parser.intPtr;
136	this.nestedType = parser.nestedType;
137	this.realBlockPtr = parser.realBlockPtr;
138	this.valueLambdaNestDepth = parser.valueLambdaNestDepth;
139
140	// Stacks.
141
142	int length;
143	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
144	System.arraycopy(parser.identifierStack, 0, this.identifierStack = new char [length = parser.identifierStack.length][], 0, length);
145	System.arraycopy(parser.identifierLengthStack, 0, this.identifierLengthStack = new int [length = parser.identifierLengthStack.length], 0, length);
146	System.arraycopy(parser.identifierPositionStack, 0, this.identifierPositionStack = new long[length = parser.identifierPositionStack.length], 0, length);
147	System.arraycopy(parser.astStack, 0, this.astStack = new ASTNode [length = parser.astStack.length], 0, length);
148	System.arraycopy(parser.astLengthStack, 0, this.astLengthStack = new int [length = parser.astLengthStack.length], 0, length);
149	System.arraycopy(parser.expressionStack, 0, this.expressionStack = new Expression [length = parser.expressionStack.length], 0, length);
150	System.arraycopy(parser.expressionLengthStack, 0, this.expressionLengthStack = new int [length = parser.expressionLengthStack.length], 0, length);
151	System.arraycopy(parser.genericsStack, 0, this.genericsStack = new ASTNode [length = parser.genericsStack.length], 0, length);
152	System.arraycopy(parser.genericsLengthStack, 0, this.genericsLengthStack = new int [length = parser.genericsLengthStack.length], 0, length);
153	System.arraycopy(parser.genericsIdentifiersLengthStack, 0, this.genericsIdentifiersLengthStack = new int [length = parser.genericsIdentifiersLengthStack.length], 0, length);
154	System.arraycopy(parser.typeAnnotationStack, 0, this.typeAnnotationStack = new Annotation [length = parser.typeAnnotationStack.length], 0, length);
155	System.arraycopy(parser.typeAnnotationLengthStack, 0, this.typeAnnotationLengthStack = new int [length = parser.typeAnnotationLengthStack.length], 0, length);
156	System.arraycopy(parser.intStack, 0, this.intStack = new int [length = parser.intStack.length], 0, length);
157	System.arraycopy(parser.nestedMethod, 0, this.nestedMethod = new int [length = parser.nestedMethod.length], 0, length);
158	System.arraycopy(parser.realBlockStack, 0, this.realBlockStack = new int [length = parser.realBlockStack.length], 0, length);
159	System.arraycopy(parser.stateStackLengthStack, 0, this.stateStackLengthStack = new int [length = parser.stateStackLengthStack.length], 0, length);
160	System.arraycopy(parser.variablesCounter, 0, this.variablesCounter = new int [length = parser.variablesCounter.length], 0, length);
161	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
162	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
163	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
164
165	// Loose variables.
166
167	this.listLength = parser.listLength;
168	this.listTypeParameterLength = parser.listTypeParameterLength;
169	this.dimensions = parser.dimensions;
170	this.recoveredStaticInitializerStart = parser.recoveredStaticInitializerStart;
171
172	// Parser.resetStacks is not clearing the modifiers, but AssistParser.resumeAfterRecovery is - why ? (the former doesn't)
173	// this.modifiers = parser.modifiers;
174	// this.modifiersSourceStart = parser.modifiersSourceStart;
175	}
176
177	protected CommitRollbackParser createSnapShotParser() {
178	return new Parser();
179	}
180
181	/* Must be called from Parser.parse ONLY. Rule reduction routine must simply set the flag to request commit.
182	This ensures the end state of chain rule reductions gets committed rather than some intermediate state.
183	See the reduce do-while loop.
184	*/
185	protected void commit() {
186	if (this.cryogenicallyFrozenParser == null) {
187	this.cryogenicallyFrozenParser = createSnapShotParser();
188	}
189	this.cryogenicallyFrozenParser.copyState(this);
190	this.commit = false;
191	}
192
193	protected int getNextToken() {
194	try {
195	return this.scanner.getNextToken();
196	} catch (InvalidInputException e) {
197	return TokenNameEOF;
198	}
199	}
200
201	// We get here on real syntax error or syntax error triggered by fake EOF at completion site, never due to triggered recovery.
202	protected int fallBackToSpringForward(Statement unused) {
203	int nextToken;
204	int lastAction = this.stack[this.stateStackTop];
205
206	// If triggered fake EOF at completion site, see if the real next token would have passed muster.
207	if (this.kurrentToken == TokenNameEOF) {
208	if (this.scanner.eofPosition < this.scanner.source.length) {
209	this.scanner.eofPosition = this.scanner.source.length;
210	nextToken = getNextToken();
211	if (automatonWillShift(nextToken, lastAction)) {
212	this.currentToken = this.kurrentToken = nextToken;
213	this.unstackedAct = this.stack[this.stateStackTop--];
214	return RESUME;
215	}
216	} else {
217	nextToken = TokenNameEOF;
218	}
219	} else {
220	nextToken = this.kurrentToken;
221	}
222	if (nextToken == TokenNameEOF)
223	return HALT; // don't know how to proceed.
224	this.scanner.ungetToken(nextToken); // spit out what has been bitten more than we can chew.
225	// OK, next token is no good to resume "in place", attempt some local repair.
226	for (int i = 0, length = RECOVERY_TOKENS.length; i < length; i++) {
227	if (automatonWillShift(RECOVERY_TOKENS[i], lastAction)) {
228	this.currentToken = this.kurrentToken = RECOVERY_TOKENS[i];
229	this.unstackedAct = this.stack[this.stateStackTop--];
230	return RESUME;
231	}
232	}
233	// OK, no in place resumption, no local repair, fast forward to next statement.
234	if (this.cryogenicallyFrozenParser == null \|\| this.referenceContext instanceof CompilationUnitDeclaration) {
235	return RESTART;
236	}
237	this.copyState(this.cryogenicallyFrozenParser);
238	this.currentToken = this.scanner.fastForward(unused);
239	return RESUME;
240	}
241
242	protected void resetStacks() {
243
244	this.astPtr = -1;
245	this.astLengthPtr = -1;
246	this.expressionPtr = -1;
247	this.expressionLengthPtr = -1;
248	this.typeAnnotationLengthPtr = -1;
249	this.typeAnnotationPtr = -1;
250	this.identifierPtr = -1;
251	this.identifierLengthPtr = -1;
252	this.intPtr = -1;
253
254	this.nestedMethod[this.nestedType = 0] = 0; // need to reset for further reuse
255	this.variablesCounter[this.nestedType] = 0;
256
257	this.dimensions = 0 ;
258	this.realBlockStack[this.realBlockPtr = 0] = 0;
259	this.recoveredStaticInitializerStart = 0;
260	this.listLength = 0;
261	this.listTypeParameterLength = 0;
262
263	this.genericsIdentifiersLengthPtr = -1;
264	this.genericsLengthPtr = -1;
265	this.genericsPtr = -1;
266	this.valueLambdaNestDepth = -1;
267	}
268
269	protected boolean automatonWillShift(int token, int lastAction) {
270	int stackTop = this.stateStackTop; // local copy of stack pointer
271	int stackTopState = this.stack[stackTop]; // single cell non write through "alternate stack" - the automaton's stack pointer either stays fixed during this manoeuvre or monotonically decreases.
272	int highWaterMark = stackTop;
273	// A rotated version of the automaton - cf. parse()'s for(;;)
274	for (;;) {
275	if (lastAction > ERROR_ACTION) {
276	lastAction -= ERROR_ACTION; /* shift-reduce on loop entry from above, reduce on loop back */
277	do { /* reduce */
278	stackTop -= rhs[lastAction] - 1;
279	if (stackTop < highWaterMark) {
280	stackTopState = this.stack[highWaterMark = stackTop];
281	} // else stackTopState is upto date already.
282	lastAction = ntAction(stackTopState, lhs[lastAction]);
283	} while (lastAction <= NUM_RULES);
284	}
285	highWaterMark = ++stackTop;
286	stackTopState = lastAction; // "push"
287	lastAction = tAction(lastAction, token); // can be looked up from a precomputed cache.
288	if (lastAction <= NUM_RULES) {
289	stackTop --;
290	lastAction += ERROR_ACTION;
291	continue;
292	}
293	// Error => false, Shift, Shift/Reduce => true, Accept => impossible.
294	return lastAction != ERROR_ACTION;
295	}
296	}
297
298	public static int tAction(int state, int sym) {
299	return term_action[term_check[base_action[state]+sym] == sym ? base_action[state] + sym : base_action[state]];
300	}
301
302	public static int ntAction(int state, int sym) {
303	return base_action[state + sym];
304	}
305
306
307	}
308

Lines 17-44 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/RecoveredStatement.java (-7 lines)
17	import java.util.Set;	17	import java.util.Set;
18		18
19	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	19	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
20	import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
21	import org.eclipse.jdt.internal.compiler.ast.Statement;	20	import org.eclipse.jdt.internal.compiler.ast.Statement;
22		21
23	public class RecoveredStatement extends RecoveredElement {	22	public class RecoveredStatement extends RecoveredElement {
24		23
25	public Statement statement;	24	public Statement statement;
26	public RecoveredLambdaExpression subExpression;
27		25
28	public RecoveredStatement(Statement statement, RecoveredElement parent, int bracketBalance){	26	public RecoveredStatement(Statement statement, RecoveredElement parent, int bracketBalance){
29	super(parent, bracketBalance);	27	super(parent, bracketBalance);
30	this.statement = statement;	28	this.statement = statement;
31	}	29	}
32		30
33	public RecoveredElement add(LambdaExpression expression, int bracketBalanceValue) {
34	return this.subExpression = new RecoveredLambdaExpression(expression, this, bracketBalanceValue);
35	}
36	/*	31	/*
37	* Answer the associated parsed structure	32	* Answer the associated parsed structure
38	*/	33	*/
39	public ASTNode parseTree() {	34	public ASTNode parseTree() {
40	if (this.subExpression != null)
41	this.subExpression.updateParseTree();
42	return this.statement;	35	return this.statement;
43	}	36	}
44	/*	37	/*