Attachment #238252 for bug #422468

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





package org.eclipse.jdt.core.tests.compiler.parser;

import org.eclipse.jdt.core.JavaModelException;
import junit.framework.Test;

public class CompletionParserTest18 extends AbstractCompletionTest {

static {
//	TESTS_NAMES = new String [] { "test405126" };
}

public CompletionParserTest18(String testName) {

			"  static void goo(J i) {\n" + 
			"  }\n" + 
			"  public static void main(String[] args) {\n" + 
			"    goo((<no type> first, <no type> second) -> {\n" + 
			"  return (<no type> xyz, <no type> pqr) -> <CompleteOnName:first.>;\n" + 
			"});\n" + 
			"  }\n" + 
			"}\n";


	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;

	String expectedCompletionNodeToString = "<CompleteOnName:x>";
	String expectedParentNodeToString = "static Foo f = (<no type> x5, <no type> x6) -> {\n" +
										"  <CompleteOnName:x>;\n" +
										"};";
	String completionIdentifier = "x";
	String expectedReplacedSource = "x";
	String expectedUnitDisplayString =

			"  }\n" + 
			"  void go() {\n" + 
			"    I i = (<no type> argument) ->     {\n" + 
			"      if (true)\n" + 
			"          {\n" + 
			"            return <CompleteOnName:arg>;\n" + 
			"          }\n" + 
			"    };\n" + 
			"  }\n" + 
			"}\n";

		expectedReplacedSource,
		"diet ast");
}
public void test0010() {
	String string =
			"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";

	String completeBehind = "xyz.";
	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;

	String expectedCompletionNodeToString = "<CompleteOnName:xyz.>";
	String expectedParentNodeToString = "System.out.println(<CompleteOnName:xyz.>)";
	String completionIdentifier = "";
	String expectedReplacedSource = "xyz.";
	String expectedUnitDisplayString =
			"interface I {\n" +
			"  void foo(String x);\n" +
			"}\n" +
			"public class X {\n" +
			"  String xField;\n" +
			"  public X() {\n" +
			"  }\n" +
			"  static void goo(String s) {\n" +
			"  }\n" +
			"  static void goo(I i) {\n" +
			"  }\n" +
			"  public static void main(String[] args) {\n" +
			"    goo((<no type> xyz) -> {\n" +
			"  System.out.println(<CompleteOnName:xyz.>);\n" +
			"});\n" +
			"  }\n" +
			"}\n";

	checkMethodParse(
		string.toCharArray(),
		cursorLocation,
		expectedCompletionNodeToString,
		expectedParentNodeToString,
		expectedUnitDisplayString,
		completionIdentifier,
		expectedReplacedSource,
		"diet ast");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=417935, [1.8][code select] ICU#codeSelect doesn't work on reference to lambda parameter
public void test417935() throws JavaModelException {
	String string = 
			"import java.util.ArrayList;\n" +
			"import java.util.Arrays;\n" +
			"import java.util.Collections;\n" +
			"import java.util.Comparator;\n" +
			"public class X {\n" +
			"   int compareTo(X x) { return 0; }\n" +
			"	void foo() {\n" +
			"		Collections.sort(new ArrayList<X>(Arrays.asList(new X(), new X(), new X())),\n" +
			"				(X o1, X o2) -> o1.compareTo(o2)); //[2]\n" +
			"	}\n" +
			"}\n";

			String completeBehind = "compa";
			int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;

			String expectedCompletionNodeToString = "<CompleteOnName:o1.compa>";
			String expectedParentNodeToString = "<NONE>";
			String completionIdentifier = "compa";
			String expectedReplacedSource = "o1.compareTo";
			String expectedUnitDisplayString =
					"import java.util.ArrayList;\n" + 
					"import java.util.Arrays;\n" + 
					"import java.util.Collections;\n" + 
					"import java.util.Comparator;\n" + 
					"public class X {\n" + 
					"  public X() {\n" + 
					"  }\n" + 
					"  int compareTo(X x) {\n" + 
					"  }\n" + 
					"  void foo() {\n" + 
					"    (X o1, X o2) -> <CompleteOnName:o1.compa>;\n" + 
					"  }\n" + 
					"}\n";

			checkMethodParse(
				string.toCharArray(),
				cursorLocation,
				expectedCompletionNodeToString,
				expectedParentNodeToString,
				expectedUnitDisplayString,
				completionIdentifier,
				expectedReplacedSource,
				"diet ast");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=405126, [1.8][code assist] Lambda parameters incorrectly recovered as fields. 
public void test405126() throws JavaModelException {
	String string = 
			"public interface Foo { \n" +
			"	int run(int s1, int s2); \n" +
			"}\n" +
			"interface X {\n" +
			"    static Foo f = (int x5, int x11) -> x\n" +
			"    static int x1 = 2;\n" +
			"}\n" +
			"class C {\n" +
			"	void method1(){\n" +
			"		int p = X.\n" +
			"	}\n" +
			"}\n";

			String completeBehind = "X.";
			int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;

			String expectedCompletionNodeToString = "<CompleteOnName:X.>";
			String expectedParentNodeToString = "int p = <CompleteOnName:X.>;";
			String completionIdentifier = "";
			String expectedReplacedSource = "X.";
			String expectedUnitDisplayString =
					"public interface Foo {\n" + 
					"  int run(int s1, int s2);\n" + 
					"}\n" + 
					"interface X {\n" + 
					"  static Foo f;\n" + 
					"  static int x1;\n" + 
					"  <clinit>() {\n" + 
					"  }\n" + 
					"}\n" + 
					"class C {\n" + 
					"  C() {\n" + 
					"  }\n" + 
					"  void method1() {\n" + 
					"    int p = <CompleteOnName:X.>;\n" + 
					"  }\n" + 
					"}\n";

			checkMethodParse(
				string.toCharArray(),
				cursorLocation,
				expectedCompletionNodeToString,
				expectedParentNodeToString,
				expectedUnitDisplayString,
				completionIdentifier,
				expectedReplacedSource,
				"diet ast");
}
// Verify that locals inside a lambda block don't get promoted to the parent block.
public void testLocalsPromotion() throws JavaModelException {
	String string = 
			"interface I {\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"public class X {\n" +
			"	static void goo(I i) {}\n" +
			"	public static void main(String[] args) {\n" +
			"       int outerLocal;\n" +
			"		goo ((x) -> {\n" +
			"			int lambdaLocal = 10;\n" +
			"			System.out.println(\"Statement inside lambda\");\n" +
			"			lam\n" +
			"		});\n" +
			"	}\n" +
			"}\n";

			String completeBehind = "lam";
			int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;

			String expectedCompletionNodeToString = "<CompleteOnName:lam>";
			String expectedParentNodeToString = "<NONE>";
			String completionIdentifier = "lam";
			String expectedReplacedSource = "lam";
			String expectedUnitDisplayString =
					"interface I {\n" + 
					"  void foo(int x);\n" + 
					"}\n" + 
					"public class X {\n" + 
					"  public X() {\n" + 
					"  }\n" + 
					"  static void goo(I i) {\n" + 
					"  }\n" + 
					"  public static void main(String[] args) {\n" + 
					"    int outerLocal;\n" + 
					"    goo((<no type> x) -> {\n" + 
					"  int lambdaLocal;\n" + 
					"  System.out.println(\"Statement inside lambda\");\n" + 
					"  <CompleteOnName:lam>;\n" + 
					"});\n" + 
					"  }\n" + 
					"}\n";

			checkMethodParse(
				string.toCharArray(),
				cursorLocation,
				expectedCompletionNodeToString,
				expectedParentNodeToString,
				expectedUnitDisplayString,
				completionIdentifier,
				expectedReplacedSource,
				"diet ast");
}
}

Lines 1071-1078 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java (-2 lines)
1071	" e.gc.setLineCap(<CompleteOnName:SWT.CAP_>);\n" +	1071	" e.gc.setLineCap(<CompleteOnName:SWT.CAP_>);\n" +
1072	" }\n" +	1072	" }\n" +
1073	" };\n" +	1073	" };\n" +
1074	" new ControlAdapter() {\n" +
1075	" };\n" +
1076	" }\n" +	1074	" }\n" +
1077	"}\n",	1075	"}\n",
1078	// expectedCompletionIdentifier:	1076	// expectedCompletionIdentifier:




public class CompletionTests18 extends AbstractJavaModelCompletionTests {

static {
	//	TESTS_NAMES = new String[] {"test015"};
}

public CompletionTests18(String name) {

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	assertResults(
			// INTERIM RESULTS, WILL FAIL ONCE ELIDED TYPE IS CORRECTLY INFERRED.
			"clone[METHOD_REF]{clone(), Ljava.lang.Object;, ()Ljava.lang.Object;, clone, null, 35}\n" +
			"equals[METHOD_REF]{equals(), Ljava.lang.Object;, (Ljava.lang.Object;)Z, equals, (obj), 35}\n" +
			"finalize[METHOD_REF]{finalize(), Ljava.lang.Object;, ()V, finalize, null, 35}\n" +
			"getClass[METHOD_REF]{getClass(), Ljava.lang.Object;, ()Ljava.lang.Class<+Ljava.lang.Object;>;, getClass, null, 35}\n" +
			"hashCode[METHOD_REF]{hashCode(), Ljava.lang.Object;, ()I, hashCode, null, 35}\n" +
			"length[METHOD_REF]{length(), Ljava.lang.String;, ()I, length, null, 35}\n" +
			"notify[METHOD_REF]{notify(), Ljava.lang.Object;, ()V, notify, null, 35}\n" +
			"notifyAll[METHOD_REF]{notifyAll(), Ljava.lang.Object;, ()V, notifyAll, null, 35}\n" +
			"toString[METHOD_REF]{toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 35}\n" +

			"toString[METHOD_DECLARATION]{public String toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 27}",
			requestor.getResults());
}
public void test010() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src/X.java",

			"	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[] { "testBug408230g" };
	// 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,




import org.eclipse.jdt.internal.compiler.*;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.*;

import org.eclipse.jdt.internal.compiler.ast.*;
import org.eclipse.jdt.internal.compiler.parser.*;
import org.eclipse.jdt.internal.compiler.problem.*;

	int labelPtr = -1;

	boolean isAlreadyAttached;
	boolean shouldStackAssistNode;

	public boolean record = false;
	public boolean skipRecord = false;

public Object becomeSimpleParser() {
	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
	int[] parserState = new int[] {this.cursorLocation, completionScanner.cursorLocation};
	// ??
	this.cursorLocation = Integer.MAX_VALUE;
	completionScanner.cursorLocation = Integer.MAX_VALUE;
	

	// DimWithOrWithOutExpr ::= '[' ']'
	pushOnExpressionStack(null);
}
protected void consumeEmptyStatement() {
	super.consumeEmptyStatement();
	/* Sneak in the assist node. The reason we can't do that when we see the assist node is that 
	   we don't know whether it is the first or subsequent statement in a block to be able to
	   decide whether to call contactNodeLists. See Parser.consumeBlockStatement(s) 
	*/
	if (this.shouldStackAssistNode) {
		this.shouldStackAssistNode = false;
		if (this.assistNode != null)
		//	this.astStack[this.astPtr] = this.assistNodeParent != null ? this.assistNodeParent : this.assistNode;
		this.astStack[this.astPtr] = this.assistNode;
	}
}
protected void consumeEnhancedForStatement() {
	super.consumeEnhancedForStatement();


	if (this.cursorLocation + 1 < variable.initialization.sourceStart ||
		this.cursorLocation > variable.initialization.sourceEnd) {
		variable.initialization = null;
	} else if (this.assistNode != null) {
		if (this.assistNode == variable.initialization)
			this.assistNodeParent = variable;
	}
}
protected void consumeExitVariableWithoutInitialization() {

					case K_MEMBER_VALUE_ARRAY_INITIALIZER:
						popElement(K_MEMBER_VALUE_ARRAY_INITIALIZER);
						break;
					case K_LAMBDA_EXPRESSION_DELIMITER:
						break; // will be popped when the containing block statement is reduced.
					default:
						popElement(K_ARRAY_INITIALIZER);
						break;

								break;
							case TokenNamedo:
								pushOnElementStack(K_BLOCK_DELIMITER, DO);
								break;
							case TokenNameARROW:
								break;
							default :
								pushOnElementStack(K_BLOCK_DELIMITER);

	this.labelPtr = -1;
	initializeForBlockStatements();
}
public void copyState(CommitRollbackParser from) {

	super.copyState(from);
	
	CompletionParser parser = (CompletionParser) from;
	
	this.invocationType = parser.invocationType;
	this.qualifier = parser.qualifier;
	this.inReferenceExpression = parser.inReferenceExpression;
	this.hasUnusedModifiers = parser.hasUnusedModifiers;
	this.canBeExplicitConstructor = parser.canBeExplicitConstructor;
}
/*
 * Initializes the state of the parser that is about to go for BlockStatements.
 */

			break;
	}
}

protected CommitRollbackParser createSnapShotParser() {
	return new CompletionParser(this.problemReporter, this.storeSourceEnds);
}
/*
 * Reset internal state after completion is over
 */

	int[] state = (int[]) parserState;
	
	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
	// ??
	this.cursorLocation = state[0];
	completionScanner.cursorLocation = state[1];
}

 * Move checkpoint location, reset internal stacks and
 * decide which grammar goal is activated.
 */
protected int resumeAfterRecovery(boolean errorRecovery) {
	this.hasUnusedModifiers = false;
	if (this.assistNode != null) {
		
		if (requireExtendedRecovery()) {
			if (!errorRecovery) {
				return RESUME;
			}
			return super.resumeAfterRecovery(errorRecovery);
		}
		
		/* if reached [eof] inside method body, but still inside nested type,
			or inside a field initializer, should continue in diet mode until
			the end of the method body or compilation unit */
		if ((this.scanner.eofPosition >= this.cursorLocation+1)
			&& (!(this.referenceContext instanceof CompilationUnitDeclaration)
			|| isIndirectlyInsideFieldInitialization()
			|| this.assistNodeParent instanceof FieldDeclaration && !(this.assistNodeParent instanceof Initializer))) {

				}
			}
			*/

			/* restart in diet mode for finding sibling constructs */
			if (this.currentElement instanceof RecoveredType
				|| this.currentElement.enclosingType() != null){

				this.scanner.eofPosition = end < Integer.MAX_VALUE ? end + 1 : end;
			} else {
				resetStacks();
				return HALT;
			}
		}
	}
	return super.resumeAfterRecovery(errorRecovery);
}
public void setAssistIdentifier(char[] assistIdent){
	((CompletionScanner)this.scanner).completionIdentifier = assistIdent;
}

protected void shouldStackAssistNode() {
	this.shouldStackAssistNode = true;
}

public  String toString() {
	StringBuffer buffer = new StringBuffer();
	buffer.append("elementKindStack : int[] = {"); //$NON-NLS-1$


	/* may be able to retrieve completionNode as an orphan, and then attach it */
	completionIdentifierCheck();
	CommitRollbackParser parser = null;
	if (lastIndexOfElement(K_LAMBDA_EXPRESSION_DELIMITER) >= 0) {
		parser = createSnapShotParser();
		parser.copyState(this);
	}
	attachOrphanCompletionNode();
	if (parser != null)
		this.copyState(parser);

	// if an assist node has been found and a recovered element exists,
	// mark enclosing blocks as to be preserved

Lines 56-61 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionScanner.java (-4 / +27 lines)
56	null/taskPriorities/,	56	null/taskPriorities/,
57	true/taskCaseSensitive/);	57	true/taskCaseSensitive/);
58	}	58	}
		59	protected boolean isAtAssistIdentifier() {
		60	if (this.cursorLocation < this.startPosition && this.currentPosition == this.startPosition) { // fake empty identifier got issued
		61	return true;
		62	}
		63	if (this.cursorLocation+1 >= this.startPosition && this.cursorLocation < this.currentPosition) {
		64	return true;
		65	}
		66	return false;
		67	}
59	/*	68	/*
60	* Truncate the current identifier if it is containing the cursor location. Since completion is performed	69	* Truncate the current identifier if it is containing the cursor location. Since completion is performed
61	* on an identifier prefix.	70	* on an identifier prefix.
Lines 146-152 Link Here
146	this.currentPosition = this.startPosition; // for being detected as empty free identifier	155	this.currentPosition = this.startPosition; // for being detected as empty free identifier
147	return TokenNameIdentifier;	156	return TokenNameIdentifier;
148	}	157	}
149	return TokenNameEOF;	158	return TokenNameEOF; // truly at EOF.
150	}	159	}
151	}	160	}
152	if (checkIfUnicode) {	161	if (checkIfUnicode) {
Lines 199-204 Link Here
199	this.currentPosition = this.startPosition; // for being detected as empty free identifier	208	this.currentPosition = this.startPosition; // for being detected as empty free identifier
200	return TokenNameIdentifier;	209	return TokenNameIdentifier;
201	}	210	}
		211	this.currentPosition = this.startPosition; // fake EOF should not drown the real next token.
202	return TokenNameEOF;	212	return TokenNameEOF;
203	}	213	}
204		214
Lines 804-810 Link Here
804	char c = this.currentCharacter;	814	char c = this.currentCharacter;
805	if (c < ScannerHelper.MAX_OBVIOUS) {	815	if (c < ScannerHelper.MAX_OBVIOUS) {
806	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[c] & ScannerHelper.C_IDENT_START) != 0) {	816	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[c] & ScannerHelper.C_IDENT_START) != 0) {
807	return scanIdentifierOrKeyword();	817	int id = scanIdentifierOrKeyword();
		818	// // Read past the cursor location should return the completion identifier if it was truncated.
		819	// if (id == TokenNameIdentifier && this.startPosition <= this.cursorLocation + 1
		820	// && this.cursorLocation < this.currentPosition) {
		821	// return getNextToken0();
		822	// }
		823	return id;
808	} else if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[c] & ScannerHelper.C_DIGIT) != 0) {	824	} else if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[c] & ScannerHelper.C_DIGIT) != 0) {
809	return scanNumber(false);	825	return scanNumber(false);
810	} else {	826	} else {
Lines 833-840 Link Here
833	// optimized case already checked	849	// optimized case already checked
834	isJavaIdStart = Character.isJavaIdentifierStart(c);	850	isJavaIdStart = Character.isJavaIdentifierStart(c);
835	}	851	}
836	if (isJavaIdStart)	852	if (isJavaIdStart) {
837	return scanIdentifierOrKeyword();	853	int id = scanIdentifierOrKeyword();
		854	// // Read past the cursor location should return the completion identifier if it was truncated.
		855	// if (id == TokenNameIdentifier && this.startPosition <= this.cursorLocation + 1
		856	// && this.cursorLocation < this.currentPosition) {
		857	// return getNextToken0();
		858	// }
		859	return id;
		860	}
838	if (ScannerHelper.isDigit(this.currentCharacter)) {	861	if (ScannerHelper.isDigit(this.currentCharacter)) {
839	return scanNumber(false);	862	return scanNumber(false);
840	}	863	}




 *
 */

import org.eclipse.jdt.internal.codeassist.complete.CompletionOnKeyword2;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
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;

public abstract class AssistParser extends Parser {
	public ASTNode assistNode;
	public boolean isOrphanCompletionNode;
	private boolean resumedAfterRepair = false;
	// last modifiers info
	protected int lastModifiers = ClassFileConstants.AccDefault;
	protected int lastModifiersStart = -1;

	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;

	protected boolean isFirst = false;


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

	setMethodsFullRecovery(false);
	setStatementsRecovery(false);
}

public abstract char[] assistIdentifier();

public 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

		RecoveredElement element = super.buildInitialRecoveryState();
		flushAssistState();
		flushElementStack();
		this.cryogenicallyFrozenParser = null;
		return element;
	}


	element = element.add(block, 1);
	int blockIndex = 1;	// ignore first block start, since manually rebuilt here

	ASTNode node = null, lastNode = null;
	for (int i = 0; i <= this.astPtr; i++, lastNode = node) {
		node = this.astStack[i];
		if(node instanceof ForeachStatement && ((ForeachStatement)node).action == null) {
			node = ((ForeachStatement)node).elementVariable;
		}

					break;
				}
				if (this.blockStarts[j] != lastStart){ // avoid multiple block if at same position
					block = new Block(0, lastNode instanceof LambdaExpression);
					block.sourceStart = lastStart = this.blockStarts[j];
					element = element.add(block, 1);
				}

			}
			continue;
		}
		if (node instanceof LambdaExpression) {
			LambdaExpression lambda = (LambdaExpression) node;
			element = element.add(lambda, 0);
			this.lastCheckPoint = lambda.sourceEnd + 1;
			continue;
		}
		if (this.assistNode != null && node instanceof Statement) {
			Statement stmt = (Statement) node;
			if (!(stmt instanceof Expression) || ((Expression) stmt).statementExpression()) {

	}

	/* might need some extra block (after the last reduced node) */
	/* For block bodied lambdas we should create a block even though the lambda header appears before it, so elements from within don't get misattributed. */
	int pos = this.assistNode == null ? this.lastCheckPoint : this.assistNode.sourceStart;
	boolean createLambdaBlock = lastNode instanceof LambdaExpression && ((LambdaExpression) node).body() instanceof Block;
	for (int j = blockIndex; j <= this.realBlockPtr; j++){
		if (this.blockStarts[j] >= 0) {
			if ((this.blockStarts[j] < pos || createLambdaBlock) && (this.blockStarts[j] != lastStart)){ // avoid multiple block if at same position
				block = new Block(0, createLambdaBlock);
				block.sourceStart = lastStart = this.blockStarts[j];
				element = element.add(block, 1);
				createLambdaBlock = false;
			}
		} else {
			if ((this.blockStarts[j] < pos)){ // avoid multiple block if at same position

protected void consumeExplicitConstructorInvocation(int flag, int recFlag) {
	super.consumeExplicitConstructorInvocation(flag, recFlag);
	popElement(K_SELECTOR);
	triggerRecoveryUponLambdaClosure();
}

protected void triggerRecoveryUponLambdaClosure() {
	// Last block statement reduced is required to be on the AST stack top.
	this.restartRecovery = false;
	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;
			if (this.currentElement != null) {
				this.restartRecovery = true;
			}
		} else {
			int stackLength = this.stack.length;
			if (++this.stateStackTop >= stackLength) {
				System.arraycopy(
					this.stack, 0,
					this.stack = new int[stackLength + StackIncrement], 0,
					stackLength);
			}
			this.stack[this.stateStackTop] = this.unstackedAct;
			commit();
			this.stateStackTop --;
			return;
		}
		this.restartRecovery = true;
		this.isOrphanCompletionNode = false;
		this.lambdaNeedsClosure = false;
	}
	
	if (this.restartRecovery && this.currentElement != null) {
		if (!(statement instanceof AbstractVariableDeclaration)) // added already as part of standard recovery since these contribute a name to the scope prevailing at the cursor.
			this.currentElement.add(statement, 0);
	}
	this.cryogenicallyFrozenParser = null;
}
protected boolean isAssistParser() {
	return true;
}
protected void consumeBlockStatement() {
	super.consumeBlockStatement();
	triggerRecoveryUponLambdaClosure();
}

protected void consumeBlockStatements() {
	super.consumeBlockStatements();
	triggerRecoveryUponLambdaClosure();
}
protected void consumeFieldDeclaration() {
	super.consumeFieldDeclaration();
	triggerRecoveryUponLambdaClosure();
}
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();

}
protected void consumeOpenBlock() {
	// OpenBlock ::= $empty

	super.consumeOpenBlock();

	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 is an epsilon production: We are in the state with kernel item: Block ::= .OpenBlock LBRACE BlockStatementsopt RBRACE
		stackLength = this.stack.length;
		if (++this.stateStackTop >= stackLength - 1) {   // Need two slots.
			System.arraycopy(
				this.stack, 0,
				this.stack = new int[stackLength + StackIncrement], 0,
				stackLength);
		}
		this.stack[this.stateStackTop++] = this.unstackedAct; // transition to Block ::= OpenBlock  .LBRACE BlockStatementsopt RBRACE
		this.stack[this.stateStackTop] = tAction(this.unstackedAct, this.currentToken); // transition to Block ::= OpenBlock LBRACE  .BlockStatementsopt RBRACE 
		commit();
		this.stateStackTop -= 2;
	}
}
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 || this.assistNode instanceof CompletionOnKeyword2)
		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);
			this.resumedAfterRepair = mode == RESUME;
			if (mode == RESUME || mode == HALT)
				return mode;
			// else fall through and RESTART
		} else {
			return RESUME;
		}
	}
		
	// reset internal stacks
	this.astPtr = -1;
	this.astLengthPtr = -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 (!errorRecovery && this.resumedAfterRepair) {
		this.scanner.ungetToken(this.currentToken);  // effectively move recovery checkpoint *backwards*.
	} else {
		if (!moveRecoveryCheckpoint()) return HALT;
	}
	this.resumedAfterRepair = false;

	// 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 (-42 / +35 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 115-122 Link Here
115	if (orphan instanceof Expression) {	115	if (orphan instanceof Expression) {
116	buildMoreCompletionContext((Expression)orphan);	116	buildMoreCompletionContext((Expression)orphan);
117	} else {	117	} else {
118	Statement statement = (Statement) orphan;	118	if (lastIndexOfElement(K_LAMBDA_EXPRESSION_DELIMITER) < 0) { // lambdas are recovered upto the containing expression statement and will carry along the assist node anyways.
119	this.currentElement = this.currentElement.add(statement, 0);	119	Statement statement = (Statement) orphan;
		120	this.currentElement = this.currentElement.add(statement, 0);
		121	}
120	}	122	}
121	this.currentToken = 0; // given we are not on an eof, we do not want side effects caused by looked-ahead token	123	this.currentToken = 0; // given we are not on an eof, we do not want side effects caused by looked-ahead token
122	}	124	}
Lines 176-187 Link Here
176	break nextElement;	178	break nextElement;
177	}	179	}
178	}	180	}
179	if(parentNode != null) {	181	// Do not add assist node/parent into the recovery system if we are inside a lambda. The lambda will be fully reovered including the containing statement and added.
180	this.currentElement = this.currentElement.add((Statement)parentNode, 0);	182	if (lastIndexOfElement(K_LAMBDA_EXPRESSION_DELIMITER) < 0) {
181	} else {	183	if(parentNode != null) {
182	this.currentElement = this.currentElement.add((Statement)wrapWithExplicitConstructorCallIfNeeded(expression), 0);	184	this.currentElement = this.currentElement.add((Statement)parentNode, 0);
183	if(this.lastCheckPoint < expression.sourceEnd) {	185	} else {
184	this.lastCheckPoint = expression.sourceEnd + 1;	186	this.currentElement = this.currentElement.add((Statement)wrapWithExplicitConstructorCallIfNeeded(expression), 0);
		187	if(this.lastCheckPoint < expression.sourceEnd) {
		188	this.lastCheckPoint = expression.sourceEnd + 1;
		189	}
185	}	190	}
186	}	191	}
187	}	192	}
Lines 1184-1189 Link Here
1184	this.restartRecovery = true; // used to avoid branching back into the regular automaton	1189	this.restartRecovery = true; // used to avoid branching back into the regular automaton
1185	}	1190	}
1186	}	1191	}
		1192	protected CommitRollbackParser createSnapShotParser() {
		1193	return new SelectionParser(this.problemReporter);
		1194	}
1187	public ImportReference createAssistImportReference(char[][] tokens, long[] positions, int mod){	1195	public ImportReference createAssistImportReference(char[][] tokens, long[] positions, int mod){
1188	return new SelectionOnImportReference(tokens, positions, mod);	1196	return new SelectionOnImportReference(tokens, positions, mod);
1189	}	1197	}
Lines 1413-1440 Link Here
1413	return super.parse(sourceUnit, compilationResult, -1, -1/parse without reseting the scanner/);	1421	return super.parse(sourceUnit, compilationResult, -1, -1/parse without reseting the scanner/);
1414	}	1422	}
1415		1423
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	/*	1424	/*
1439	* Reset context so as to resume to regular parse loop	1425	* Reset context so as to resume to regular parse loop
1440	* If unable to reset for resuming, answers false.	1426	* If unable to reset for resuming, answers false.
Lines 1442-1468 Link Here
1442	* Move checkpoint location, reset internal stacks and	1428	* Move checkpoint location, reset internal stacks and
1443	* decide which grammar goal is activated.	1429	* decide which grammar goal is activated.
1444	*/	1430	*/
1445	protected boolean resumeAfterRecovery() {	1431	protected int resumeAfterRecovery(boolean errorRecovery) {
1446		1432
1447	/* if reached assist node inside method body, but still inside nested type,	1433	/* 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 */	1434	should continue in diet mode until the end of the method body */
1449	if (this.assistNode != null	1435	if (this.assistNode != null
1450	&& !(this.referenceContext instanceof CompilationUnitDeclaration)){	1436	&& !(this.referenceContext instanceof CompilationUnitDeclaration)){
1451	this.currentElement.preserveEnclosingBlocks();	1437	this.currentElement.preserveEnclosingBlocks();
		1438	if (requireExtendedRecovery()) {
		1439	if (!errorRecovery) {
		1440	return RESUME;
		1441	}
		1442	return super.resumeAfterRecovery(errorRecovery);
		1443	}
1452	if (this.currentElement.enclosingType() == null) {	1444	if (this.currentElement.enclosingType() == null) {
1453	if(!(this.currentElement instanceof RecoveredType)) {	1445	if (!(this.currentElement instanceof RecoveredType)) {
1454	resetStacks();	1446	resetStacks();
1455	return false;	1447	return HALT;
1456	}	1448	}
1457		1449
1458	RecoveredType recoveredType = (RecoveredType)this.currentElement;	1450	RecoveredType recoveredType = (RecoveredType) this.currentElement;
1459	if(recoveredType.typeDeclaration != null && recoveredType.typeDeclaration.allocation == this.assistNode){	1451	if (recoveredType.typeDeclaration != null && recoveredType.typeDeclaration.allocation == this.assistNode) {
1460	resetStacks();	1452	resetStacks();
1461	return false;	1453	return HALT;
1462	}	1454	}
1463	}	1455	}
1464	}	1456	}
1465	return super.resumeAfterRecovery();	1457	return super.resumeAfterRecovery(errorRecovery);
1466	}	1458	}
1467		1459
1468	public void selectionIdentifierCheck(){	1460	public void selectionIdentifierCheck(){
Lines 1504-1518 Link Here
1504	char[] identifierName = this.identifierStack[this.identifierPtr];	1496	char[] identifierName = this.identifierStack[this.identifierPtr];
1505	long namePositions = this.identifierPositionStack[this.identifierPtr--];	1497	long namePositions = this.identifierPositionStack[this.identifierPtr--];
1506		1498
1507	Argument arg =	1499	Argument argument =
1508	new SelectionOnArgumentName(	1500	new SelectionOnArgumentName(
1509	identifierName,	1501	identifierName,
1510	namePositions,	1502	namePositions,
1511	null, // elided type	1503	null, // elided type
1512	ClassFileConstants.AccDefault,	1504	ClassFileConstants.AccDefault,
1513	true);	1505	true);
1514	arg.declarationSourceStart = (int) (namePositions >>> 32);	1506	argument.declarationSourceStart = (int) (namePositions >>> 32);
1515	return arg;	1507	this.assistNode = argument;
		1508	return argument;
1516	}	1509	}
1517	public String toString() {	1510	public String toString() {
1518	String s = Util.EMPTY_STRING;	1511	String s = Util.EMPTY_STRING;

Lines 32-37 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/select/SelectionScanner.java (+4 lines)
32	super(false /comment/, false /whitespace/, false /nls/, sourceLevel, null /taskTags/, null/taskPriorities/, true/taskCaseSensitive/);	32	super(false /comment/, false /whitespace/, false /nls/, sourceLevel, null /taskTags/, null/taskPriorities/, true/taskCaseSensitive/);
33	}	33	}
34		34
		35	protected boolean isAtAssistIdentifier() {
		36	return this.selectionStart == this.startPosition && this.selectionEnd == this.currentPosition - 1;
		37	}
		38
35	public char[] getCurrentIdentifierSource() {	39	public char[] getCurrentIdentifierSource() {
36		40
37	if (this.selectionIdentifier == null){	41	if (this.selectionIdentifier == null){

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

Lines 5-10 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (+9 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	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	*
8	* Contributors:	12	* Contributors:
9	* IBM Corporation - initial API and implementation	13	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contributions for	14	* Stephan Herrmann - Contributions for
Lines 27-33 Link Here
27	public int explicitDeclarations;	31	public int explicitDeclarations;
28	// the number of explicit declaration , used to create scope	32	// the number of explicit declaration , used to create scope
29	public BlockScope scope;	33	public BlockScope scope;
		34	public boolean lambdaBody;
30		35
		36	public Block(int explicitDeclarations, boolean lambdaBody) {
		37	this.explicitDeclarations = explicitDeclarations;
		38	this.lambdaBody = lambdaBody;
		39	}
31	public Block(int explicitDeclarations) {	40	public Block(int explicitDeclarations) {
32	this.explicitDeclarations = explicitDeclarations;	41	this.explicitDeclarations = explicitDeclarations;
33	}	42	}




	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.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 :-(
	
	// -------------  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;
	
	public CommitRollbackParser cryogenicallyFrozenParser;
	private static final int[] RECOVERY_TOKENS = new int [] { TokenNameSEMICOLON, TokenNameRPAREN,};
	
	public 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);
	}
	
	protected int getNextToken() {
		try {
			return this.scanner.getNextToken();
		} catch (InvalidInputException e) {
			return TokenNameEOF;
		}
	}
	
	protected void shouldStackAssistNode() {
		// Not relevant here.
	}
	// 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;
		boolean atCompletionSite = false;
		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) {
				atCompletionSite = true;
				this.scanner.eofPosition = this.scanner.source.length;
				nextToken = getNextToken();
				if (automatonWillShift(nextToken, lastAction)) {
					this.currentToken = this.kurrentToken = nextToken;
					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];
				return RESUME;
			}
		}
		// OK, no in place resumption, no local repair, fast forward to next statement.
		if (this.cryogenicallyFrozenParser == null)
			return RESTART;

		this.copyState(this.cryogenicallyFrozenParser);
		if (atCompletionSite) {
			this.currentToken = TokenNameSEMICOLON;
			shouldStackAssistNode();
			return RESUME;
		}
		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.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.codeassist.impl.AssistParser;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression;

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;

	private static final boolean DEBUG_AUTOMATON = false;
	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;

public Parser () {

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 !
}
public Parser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {

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

	pushOnIntStack(0);  // signal explicit this
}

protected boolean isAssistParser() {
	return false;
}
protected void consumeNestedLambda() {
	// NestedLambda ::= $empty - we get here just after the type+parenthesis elided singleton parameter or just before the '(' of the parameter list. 
	consumeNestedType();
	this.nestedMethod[this.nestedType] ++;
	LambdaExpression lambda = new LambdaExpression(this.compilationUnit.compilationResult, isAssistParser());
	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.lastCheckPoint = arrowPosition + 1;
//		this.ignoreNextOpeningBrace = true;
//		this.currentElement.bracketBalance++;
	}
}
protected void consumeLambdaExpression() {
	

		if (this.options.ignoreMethodBodies) {
			body = new Block(0);
		}
		((Block) body).lambdaBody = true; // for consistency's sakes.
	}

	LambdaExpression lexp = (LambdaExpression) this.astStack[this.astPtr--];

	}
	pushOnExpressionStack(lexp);
	if (this.currentElement != null) {
		this.lastCheckPoint = body.sourceEnd + 1;
//		if (body instanceof Expression)
//		    this.currentElement.bracketBalance --;
		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) {
	/* remember the last consumed value */
	/* try to minimize the number of build values */
//	// 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.stack[this.stateStackTop--];
						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.unstackedAct = act -= ERROR_ACTION;

			if (DEBUG_AUTOMATON) {
				System.out.print("Shift/Reduce - (" + name[terminal_index[this.currentToken]]+") ");  //$NON-NLS-1$  //$NON-NLS-2$

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

			}

			this.stateStackTop -= (rhs[act] - 1);
			this.unstackedAct = ntAction(this.stack[this.stateStackTop], lhs[act]);
			consumeRule(act);
			act = this.unstackedAct;

			if (DEBUG_AUTOMATON) {
				if (act <= NUM_RULES) {

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


	// if block was not marked to be preserved or empty, then ignore it
	if (!this.preserveContent || this.statementCount == 0) return null;
	
	/* If this block stands for the lambda body, trash the contents. Lambda expressions are recovered as part of the enclosing statement.
	   We still have left in a block here to make sure that contained elements can be trapped and tossed out.
	*/
	if (this.blockDeclaration.lambdaBody) return null; 

	Statement[] updatedStatements = new Statement[this.statementCount];
	int updatedCount = 0;

		Statement updatedStatement = this.statements[i].updatedStatement(depth, knownTypes);
		if (updatedStatement != null){
			updatedStatements[updatedCount++] = updatedStatement;
			
			/* Statements inside lambda body have been collected into a block attached to this block. 
			   Replace the lambda block if we see a sibling statement that completely subsumes it.
			   See (Assist)consumeBlockStatement(s)
			*/
//			if (updatedCount > 1) {
//				Statement penultimateStatement = updatedStatements[updatedCount - 2];
//				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 - 2] = updatedStatement;
//					updatedCount--;
//				}
//			}

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


	// if block was closed or empty, then ignore it
	if (this.blockDeclaration.sourceEnd != 0 || this.statementCount == 0) return null;
	
	/* If this block stands for the lambda body, trash the contents. Lambda expressions are recovered as part of the enclosing statement.
	   We still have left in a block here to make sure that contained elements can be trapped and tossed out.
	*/
	if (this.blockDeclaration.lambdaBody) return null; 

	Statement[] updatedStatements = new Statement[this.statementCount];
	int updatedCount = 0;




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

				} else if (act > ERROR_ACTION) { /* shift-reduce */
					this.unstackedAct = act;
					try {
					this.currentToken = this.scanner.getNextToken();
					} finally {
						this.unstackedAct = ERROR_ACTION;
					}

				    if (act < ACCEPT_ACTION) { /* shift */
				    	this.unstackedAct = act;
						try {
				    	this.currentToken = this.scanner.getNextToken();
						} finally {
							this.unstackedAct = ERROR_ACTION;
						}

	}
	return token;
}

protected boolean isAtAssistIdentifier() {
	return false;
}

// 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:
				if (isAtAssistIdentifier()) // do not fast forward past the assist identifier ! We don't handle collections as of now.
					return token;
				//$FALL-THROUGH$
			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 31-37 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (-9 / +64 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 156-161 Link Here
156	int labelPtr = -1;	155	int labelPtr = -1;
157		156
158	boolean isAlreadyAttached;	157	boolean isAlreadyAttached;
		158	boolean shouldStackAssistNode;
159		159
160	public boolean record = false;	160	public boolean record = false;
161	public boolean skipRecord = false;	161	public boolean skipRecord = false;
Lines 614-620 Link Here
614	public Object becomeSimpleParser() {	614	public Object becomeSimpleParser() {
615	CompletionScanner completionScanner = (CompletionScanner)this.scanner;	615	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
616	int[] parserState = new int[] {this.cursorLocation, completionScanner.cursorLocation};	616	int[] parserState = new int[] {this.cursorLocation, completionScanner.cursorLocation};
617		617	// ??
618	this.cursorLocation = Integer.MAX_VALUE;	618	this.cursorLocation = Integer.MAX_VALUE;
619	completionScanner.cursorLocation = Integer.MAX_VALUE;	619	completionScanner.cursorLocation = Integer.MAX_VALUE;
620		620
Lines 2407-2412 Link Here
2407	// DimWithOrWithOutExpr ::= '[' ']'	2407	// DimWithOrWithOutExpr ::= '[' ']'
2408	pushOnExpressionStack(null);	2408	pushOnExpressionStack(null);
2409	}	2409	}
		2410	protected void consumeEmptyStatement() {
		2411	super.consumeEmptyStatement();
		2412	/* Sneak in the assist node. The reason we can't do that when we see the assist node is that
		2413	we don't know whether it is the first or subsequent statement in a block to be able to
		2414	decide whether to call contactNodeLists. See Parser.consumeBlockStatement(s)
		2415	*/
		2416	if (this.shouldStackAssistNode) {
		2417	this.shouldStackAssistNode = false;
		2418	if (this.assistNode != null)
		2419	// this.astStack[this.astPtr] = this.assistNodeParent != null ? this.assistNodeParent : this.assistNode;
		2420	this.astStack[this.astPtr] = this.assistNode;
		2421	}
		2422	}
2410	protected void consumeEnhancedForStatement() {	2423	protected void consumeEnhancedForStatement() {
2411	super.consumeEnhancedForStatement();	2424	super.consumeEnhancedForStatement();
2412		2425
Lines 2579-2586 Link Here
2579	if (this.cursorLocation + 1 < variable.initialization.sourceStart \|\|	2592	if (this.cursorLocation + 1 < variable.initialization.sourceStart \|\|
2580	this.cursorLocation > variable.initialization.sourceEnd) {	2593	this.cursorLocation > variable.initialization.sourceEnd) {
2581	variable.initialization = null;	2594	variable.initialization = null;
2582	} else if (this.assistNode != null && this.assistNode == variable.initialization) {	2595	} else if (this.assistNode != null) {
2583	this.assistNodeParent = variable;	2596	if (this.assistNode == variable.initialization)
		2597	this.assistNodeParent = variable;
2584	}	2598	}
2585	}	2599	}
2586	protected void consumeExitVariableWithoutInitialization() {	2600	protected void consumeExitVariableWithoutInitialization() {
Lines 3470-3475 Link Here
3470	case K_MEMBER_VALUE_ARRAY_INITIALIZER:	3484	case K_MEMBER_VALUE_ARRAY_INITIALIZER:
3471	popElement(K_MEMBER_VALUE_ARRAY_INITIALIZER);	3485	popElement(K_MEMBER_VALUE_ARRAY_INITIALIZER);
3472	break;	3486	break;
		3487	case K_LAMBDA_EXPRESSION_DELIMITER:
		3488	break; // will be popped when the containing block statement is reduced.
3473	default:	3489	default:
3474	popElement(K_ARRAY_INITIALIZER);	3490	popElement(K_ARRAY_INITIALIZER);
3475	break;	3491	break;
Lines 3675-3680 Link Here
3675	break;	3691	break;
3676	case TokenNamedo:	3692	case TokenNamedo:
3677	pushOnElementStack(K_BLOCK_DELIMITER, DO);	3693	pushOnElementStack(K_BLOCK_DELIMITER, DO);
		3694	break;
		3695	case TokenNameARROW:
3678	break;	3696	break;
3679	default :	3697	default :
3680	pushOnElementStack(K_BLOCK_DELIMITER);	3698	pushOnElementStack(K_BLOCK_DELIMITER);
Lines 4609-4614 Link Here
4609	this.labelPtr = -1;	4627	this.labelPtr = -1;
4610	initializeForBlockStatements();	4628	initializeForBlockStatements();
4611	}	4629	}
		4630	public void copyState(CommitRollbackParser from) {
		4631
		4632	super.copyState(from);
		4633
		4634	CompletionParser parser = (CompletionParser) from;
		4635
		4636	this.invocationType = parser.invocationType;
		4637	this.qualifier = parser.qualifier;
		4638	this.inReferenceExpression = parser.inReferenceExpression;
		4639	this.hasUnusedModifiers = parser.hasUnusedModifiers;
		4640	this.canBeExplicitConstructor = parser.canBeExplicitConstructor;
		4641	}
4612	/*	4642	/*
4613	* Initializes the state of the parser that is about to go for BlockStatements.	4643	* Initializes the state of the parser that is about to go for BlockStatements.
4614	*/	4644	*/
Lines 4954-4959 Link Here
4954	break;	4984	break;
4955	}	4985	}
4956	}	4986	}
		4987
		4988	protected CommitRollbackParser createSnapShotParser() {
		4989	return new CompletionParser(this.problemReporter, this.storeSourceEnds);
		4990	}
4957	/*	4991	/*
4958	* Reset internal state after completion is over	4992	* Reset internal state after completion is over
4959	*/	4993	*/
Lines 4977-4983 Link Here
4977	int[] state = (int[]) parserState;	5011	int[] state = (int[]) parserState;
4978		5012
4979	CompletionScanner completionScanner = (CompletionScanner)this.scanner;	5013	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
4980		5014	// ??
4981	this.cursorLocation = state[0];	5015	this.cursorLocation = state[0];
4982	completionScanner.cursorLocation = state[1];	5016	completionScanner.cursorLocation = state[1];
4983	}	5017	}
Lines 4988-5000 Link Here
4988	* Move checkpoint location, reset internal stacks and	5022	* Move checkpoint location, reset internal stacks and
4989	* decide which grammar goal is activated.	5023	* decide which grammar goal is activated.
4990	*/	5024	*/
4991	protected boolean resumeAfterRecovery() {	5025	protected int resumeAfterRecovery(boolean errorRecovery) {
4992	this.hasUnusedModifiers = false;	5026	this.hasUnusedModifiers = false;
4993	if (this.assistNode != null) {	5027	if (this.assistNode != null) {
		5028
		5029	if (requireExtendedRecovery()) {
		5030	if (!errorRecovery) {
		5031	return RESUME;
		5032	}
		5033	return super.resumeAfterRecovery(errorRecovery);
		5034	}
		5035
4994	/* if reached [eof] inside method body, but still inside nested type,	5036	/* if reached [eof] inside method body, but still inside nested type,
4995	or inside a field initializer, should continue in diet mode until	5037	or inside a field initializer, should continue in diet mode until
4996	the end of the method body or compilation unit */	5038	the end of the method body or compilation unit */
4997	if ((this.scanner.eofPosition == this.cursorLocation+1)	5039	if ((this.scanner.eofPosition >= this.cursorLocation+1)
4998	&& (!(this.referenceContext instanceof CompilationUnitDeclaration)	5040	&& (!(this.referenceContext instanceof CompilationUnitDeclaration)
4999	\|\| isIndirectlyInsideFieldInitialization()	5041	\|\| isIndirectlyInsideFieldInitialization()
5000	\|\| this.assistNodeParent instanceof FieldDeclaration && !(this.assistNodeParent instanceof Initializer))) {	5042	\|\| this.assistNodeParent instanceof FieldDeclaration && !(this.assistNodeParent instanceof Initializer))) {
Lines 5022-5027 Link Here
5022	}	5064	}
5023	}	5065	}
5024	*/	5066	*/
		5067
5025	/* restart in diet mode for finding sibling constructs */	5068	/* restart in diet mode for finding sibling constructs */
5026	if (this.currentElement instanceof RecoveredType	5069	if (this.currentElement instanceof RecoveredType
5027	\|\| this.currentElement.enclosingType() != null){	5070	\|\| this.currentElement.enclosingType() != null){
Lines 5035-5049 Link Here
5035	this.scanner.eofPosition = end < Integer.MAX_VALUE ? end + 1 : end;	5078	this.scanner.eofPosition = end < Integer.MAX_VALUE ? end + 1 : end;
5036	} else {	5079	} else {
5037	resetStacks();	5080	resetStacks();
5038	return false;	5081	return HALT;
5039	}	5082	}
5040	}	5083	}
5041	}	5084	}
5042	return super.resumeAfterRecovery();	5085	return super.resumeAfterRecovery(errorRecovery);
5043	}	5086	}
5044	public void setAssistIdentifier(char[] assistIdent){	5087	public void setAssistIdentifier(char[] assistIdent){
5045	((CompletionScanner)this.scanner).completionIdentifier = assistIdent;	5088	((CompletionScanner)this.scanner).completionIdentifier = assistIdent;
5046	}	5089	}
		5090
		5091	protected void shouldStackAssistNode() {
		5092	this.shouldStackAssistNode = true;
		5093	}
		5094
5047	public String toString() {	5095	public String toString() {
5048	StringBuffer buffer = new StringBuffer();	5096	StringBuffer buffer = new StringBuffer();
5049	buffer.append("elementKindStack : int[] = {"); //$NON-NLS-1$	5097	buffer.append("elementKindStack : int[] = {"); //$NON-NLS-1$
Lines 5070-5076 Link Here
5070		5118
5071	/* may be able to retrieve completionNode as an orphan, and then attach it */	5119	/* may be able to retrieve completionNode as an orphan, and then attach it */
5072	completionIdentifierCheck();	5120	completionIdentifierCheck();
		5121	CommitRollbackParser parser = null;
		5122	if (lastIndexOfElement(K_LAMBDA_EXPRESSION_DELIMITER) >= 0) {
		5123	parser = createSnapShotParser();
		5124	parser.copyState(this);
		5125	}
5073	attachOrphanCompletionNode();	5126	attachOrphanCompletionNode();
		5127	if (parser != null)
		5128	this.copyState(parser);
5074		5129
5075	// if an assist node has been found and a recovered element exists,	5130	// if an assist node has been found and a recovered element exists,
5076	// mark enclosing blocks as to be preserved	5131	// mark enclosing blocks as to be preserved

Lines 19-24 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Scanner.java (-6 / +110 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 4332-4338 Link Here
4332	} else if (act > ERROR_ACTION) { /* shift-reduce */	4342	} else if (act > ERROR_ACTION) { /* shift-reduce */
4333	this.unstackedAct = act;	4343	this.unstackedAct = act;
4334	try {	4344	try {
4335	this.currentToken = this.scanner.getNextToken();	4345	this.currentToken = this.scanner.getNextToken();
4336	} finally {	4346	} finally {
4337	this.unstackedAct = ERROR_ACTION;	4347	this.unstackedAct = ERROR_ACTION;
4338	}	4348	}
Lines 4341-4347 Link Here
4341	if (act < ACCEPT_ACTION) { /* shift */	4351	if (act < ACCEPT_ACTION) { /* shift */
4342	this.unstackedAct = act;	4352	this.unstackedAct = act;
4343	try {	4353	try {
4344	this.currentToken = this.scanner.getNextToken();	4354	this.currentToken = this.scanner.getNextToken();
4345	} finally {	4355	} finally {
4346	this.unstackedAct = ERROR_ACTION;	4356	this.unstackedAct = ERROR_ACTION;
4347	}	4357	}
Lines 4493-4496 Link Here
4493	}	4503	}
4494	return token;	4504	return token;
4495	}	4505	}
		4506
		4507	protected boolean isAtAssistIdentifier() {
		4508	return false;
		4509	}
		4510
		4511	// Position the scanner at the next block statement and return the start token. We recognize empty statements.
		4512	public int fastForward(Statement unused) {
		4513
		4514	int token;
		4515
		4516	while (true) {
		4517	try {
		4518	token = getNextToken();
		4519	} catch (InvalidInputException e) {
		4520	return TokenNameEOF;
		4521	}
		4522	/* FOLLOW map of BlockStatement, since the non-terminal is recursive is a super set of its own FIRST set.
		4523	We use FOLLOW rather than FIRST since we want to recognize empty statements. i.e if (x > 10) { x = 0 }
		4524	*/
		4525	switch(token) {
		4526	case TokenNameIdentifier:
		4527	if (isAtAssistIdentifier()) // do not fast forward past the assist identifier ! We don't handle collections as of now.
		4528	return token;
		4529	//$FALL-THROUGH$
		4530	case TokenNameabstract:
		4531	case TokenNameassert:
		4532	case TokenNameboolean:
		4533	case TokenNamebreak:
		4534	case TokenNamebyte:
		4535	case TokenNamecase:
		4536	case TokenNamechar:
		4537	case TokenNameclass:
		4538	case TokenNamecontinue:
		4539	case TokenNamedefault:
		4540	case TokenNamedo:
		4541	case TokenNamedouble:
		4542	case TokenNameenum:
		4543	case TokenNamefalse:
		4544	case TokenNamefinal:
		4545	case TokenNamefloat:
		4546	case TokenNamefor:
		4547	case TokenNameif:
		4548	case TokenNameint:
		4549	case TokenNameinterface:
		4550	case TokenNamelong:
		4551	case TokenNamenative:
		4552	case TokenNamenew:
		4553	case TokenNamenull:
		4554	case TokenNameprivate:
		4555	case TokenNameprotected:
		4556	case TokenNamepublic:
		4557	case TokenNamereturn:
		4558	case TokenNameshort:
		4559	case TokenNamestatic:
		4560	case TokenNamestrictfp:
		4561	case TokenNamesuper:
		4562	case TokenNameswitch:
		4563	case TokenNamesynchronized:
		4564	case TokenNamethis:
		4565	case TokenNamethrow:
		4566	case TokenNametransient:
		4567	case TokenNametrue:
		4568	case TokenNametry:
		4569	case TokenNamevoid:
4570	case TokenNamevolatile:
4571	case TokenNamewhile:
4572	case TokenNameIntegerLiteral: // ??!
4573	case TokenNameLongLiteral:
4574	case TokenNameFloatingPointLiteral:
4575	case TokenNameDoubleLiteral:
4576	case TokenNameCharacterLiteral:
4577	case TokenNameStringLiteral:
4578	case TokenNamePLUS_PLUS:
4579	case TokenNameMINUS_MINUS:
4580	case TokenNameLESS:
4581	case TokenNameLPAREN:
4582	case TokenNameLBRACE:
4583	case TokenNameAT:
4584	case TokenNameBeginLambda:
4585	case TokenNameAT308:
4586	if(getVanguardParser().parse(Goal.BlockStatementoptGoal) == VanguardParser.SUCCESS)
4587	return token;
4588	break;
4589	case TokenNameSEMICOLON:
4590	case TokenNameEOF:
4591	return token;
4592	case TokenNameRBRACE: // simulate empty statement.
4593	ungetToken(token);
4594	return TokenNameSEMICOLON;
4595	default:
4596	break;
4597	}
4598	}
4599	}
4496	}	4600	}

Lines 15-26 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest18.java (-8 / +217 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;
18	import junit.framework.Test;	19	import junit.framework.Test;
19		20
20	public class CompletionParserTest18 extends AbstractCompletionTest {	21	public class CompletionParserTest18 extends AbstractCompletionTest {
21		22
22	static {	23	static {
23	// TESTS_NAMES = new String [] { "test0001" };	24	// TESTS_NAMES = new String [] { "test405126" };
24	}	25	}
25		26
26	public CompletionParserTest18(String testName) {	27	public CompletionParserTest18(String testName) {
Lines 74-82 Link Here
74	" static void goo(J i) {\n" +	75	" static void goo(J i) {\n" +
75	" }\n" +	76	" }\n" +
76	" public static void main(String[] args) {\n" +	77	" public static void main(String[] args) {\n" +
77	" (<no type> first, <no type> second) -> {\n" +	78	" goo((<no type> first, <no type> second) -> {\n" +
78	" (<no type> xyz, <no type> pqr) -> <CompleteOnName:first.>;\n" +	79	" return (<no type> xyz, <no type> pqr) -> <CompleteOnName:first.>;\n" +
79	" };\n" +	80	"});\n" +
80	" }\n" +	81	" }\n" +
81	"}\n";	82	"}\n";
82		83
Lines 177-183 Link Here
177	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;	178	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
178		179
179	String expectedCompletionNodeToString = "<CompleteOnName:x>";	180	String expectedCompletionNodeToString = "<CompleteOnName:x>";
180	String expectedParentNodeToString = "<NONE>";	181	String expectedParentNodeToString = "static Foo f = (<no type> x5, <no type> x6) -> {\n" +
		182	" <CompleteOnName:x>;\n" +
		183	"};";
181	String completionIdentifier = "x";	184	String completionIdentifier = "x";
182	String expectedReplacedSource = "x";	185	String expectedReplacedSource = "x";
183	String expectedUnitDisplayString =	186	String expectedUnitDisplayString =
Lines 233-242 Link Here
233	" }\n" +	236	" }\n" +
234	" void go() {\n" +	237	" void go() {\n" +
235	" I i = (<no type> argument) -> {\n" +	238	" I i = (<no type> argument) -> {\n" +
236	" {\n" +	239	" if (true)\n" +
237	" if (true)\n" +	240	" {\n" +
238	" return <CompleteOnName:arg>;\n" +	241	" return <CompleteOnName:arg>;\n" +
239	" }\n" +	242	" }\n" +
240	" };\n" +	243	" };\n" +
241	" }\n" +	244	" }\n" +
242	"}\n";	245	"}\n";
Lines 345-348 Link Here
345	expectedReplacedSource,	348	expectedReplacedSource,
346	"diet ast");	349	"diet ast");
347	}	350	}
		351	public void test0010() {
		352	String string =
		353	"interface I {\n" +
		354	" void foo(String x);\n" +
		355	"}\n" +
		356	"public class X {\n" +
		357	" String xField;\n" +
		358	" static void goo(String s) {\n" +
		359	" }\n" +
		360	" static void goo(I i) {\n" +
		361	" }\n" +
		362	" public static void main(String[] args) {\n" +
		363	" goo((xyz) -> {\n" +
		364	" System.out.println(xyz.);\n" +
		365	" });\n" +
		366	" }\n" +
		367	"}\n";
		368
		369	String completeBehind = "xyz.";
		370	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
		371
		372	String expectedCompletionNodeToString = "<CompleteOnName:xyz.>";
		373	String expectedParentNodeToString = "System.out.println(<CompleteOnName:xyz.>)";
		374	String completionIdentifier = "";
		375	String expectedReplacedSource = "xyz.";
		376	String expectedUnitDisplayString =
		377	"interface I {\n" +
		378	" void foo(String x);\n" +
		379	"}\n" +
		380	"public class X {\n" +
		381	" String xField;\n" +
		382	" public X() {\n" +
		383	" }\n" +
		384	" static void goo(String s) {\n" +
		385	" }\n" +
		386	" static void goo(I i) {\n" +
		387	" }\n" +
		388	" public static void main(String[] args) {\n" +
		389	" goo((<no type> xyz) -> {\n" +
		390	" System.out.println(<CompleteOnName:xyz.>);\n" +
		391	"});\n" +
		392	" }\n" +
		393	"}\n";
		394
		395	checkMethodParse(
		396	string.toCharArray(),
		397	cursorLocation,
		398	expectedCompletionNodeToString,
		399	expectedParentNodeToString,
		400	expectedUnitDisplayString,
		401	completionIdentifier,
		402	expectedReplacedSource,
		403	"diet ast");
		404	}
		405	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=417935, [1.8][code select] ICU#codeSelect doesn't work on reference to lambda parameter
		406	public void test417935() throws JavaModelException {
		407	String string =
		408	"import java.util.ArrayList;\n" +
		409	"import java.util.Arrays;\n" +
		410	"import java.util.Collections;\n" +
		411	"import java.util.Comparator;\n" +
		412	"public class X {\n" +
		413	" int compareTo(X x) { return 0; }\n" +
		414	" void foo() {\n" +
415	" Collections.sort(new ArrayList<X>(Arrays.asList(new X(), new X(), new X())),\n" +
416	" (X o1, X o2) -> o1.compareTo(o2)); //[2]\n" +
417	" }\n" +
418	"}\n";
419
420	String completeBehind = "compa";
421	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
422
423	String expectedCompletionNodeToString = "<CompleteOnName:o1.compa>";
424	String expectedParentNodeToString = "<NONE>";
425	String completionIdentifier = "compa";
426	String expectedReplacedSource = "o1.compareTo";
427	String expectedUnitDisplayString =
428	"import java.util.ArrayList;\n" +
429	"import java.util.Arrays;\n" +
430	"import java.util.Collections;\n" +
431	"import java.util.Comparator;\n" +
432	"public class X {\n" +
433	" public X() {\n" +
434	" }\n" +
435	" int compareTo(X x) {\n" +
436	" }\n" +
437	" void foo() {\n" +
438	" (X o1, X o2) -> <CompleteOnName:o1.compa>;\n" +
439	" }\n" +
440	"}\n";
441
442	checkMethodParse(
443	string.toCharArray(),
444	cursorLocation,
445	expectedCompletionNodeToString,
446	expectedParentNodeToString,
447	expectedUnitDisplayString,
448	completionIdentifier,
449	expectedReplacedSource,
450	"diet ast");
451	}
452	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=405126, [1.8][code assist] Lambda parameters incorrectly recovered as fields.
453	public void test405126() throws JavaModelException {
454	String string =
455	"public interface Foo { \n" +
456	" int run(int s1, int s2); \n" +
457	"}\n" +
458	"interface X {\n" +
459	" static Foo f = (int x5, int x11) -> x\n" +
460	" static int x1 = 2;\n" +
461	"}\n" +
462	"class C {\n" +
463	" void method1(){\n" +
464	" int p = X.\n" +
465	" }\n" +
466	"}\n";
467
468	String completeBehind = "X.";
469	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
470
471	String expectedCompletionNodeToString = "<CompleteOnName:X.>";
472	String expectedParentNodeToString = "int p = <CompleteOnName:X.>;";
473	String completionIdentifier = "";
474	String expectedReplacedSource = "X.";
475	String expectedUnitDisplayString =
476	"public interface Foo {\n" +
477	" int run(int s1, int s2);\n" +
478	"}\n" +
479	"interface X {\n" +
480	" static Foo f;\n" +
481	" static int x1;\n" +
482	" <clinit>() {\n" +
483	" }\n" +
484	"}\n" +
485	"class C {\n" +
486	" C() {\n" +
487	" }\n" +
488	" void method1() {\n" +
489	" int p = <CompleteOnName:X.>;\n" +
490	" }\n" +
491	"}\n";
492
493	checkMethodParse(
494	string.toCharArray(),
495	cursorLocation,
496	expectedCompletionNodeToString,
497	expectedParentNodeToString,
498	expectedUnitDisplayString,
499	completionIdentifier,
500	expectedReplacedSource,
501	"diet ast");
502	}
503	// Verify that locals inside a lambda block don't get promoted to the parent block.
504	public void testLocalsPromotion() throws JavaModelException {
505	String string =
506	"interface I {\n" +
507	" void foo(int x);\n" +
508	"}\n" +
509	"public class X {\n" +
510	" static void goo(I i) {}\n" +
511	" public static void main(String[] args) {\n" +
512	" int outerLocal;\n" +
513	" goo ((x) -> {\n" +
514	" int lambdaLocal = 10;\n" +
515	" System.out.println(\"Statement inside lambda\");\n" +
516	" lam\n" +
517	" });\n" +
518	" }\n" +
519	"}\n";
520
521	String completeBehind = "lam";
522	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
523
524	String expectedCompletionNodeToString = "<CompleteOnName:lam>";
525	String expectedParentNodeToString = "<NONE>";
526	String completionIdentifier = "lam";
527	String expectedReplacedSource = "lam";
528	String expectedUnitDisplayString =
529	"interface I {\n" +
530	" void foo(int x);\n" +
531	"}\n" +
532	"public class X {\n" +
533	" public X() {\n" +
534	" }\n" +
535	" static void goo(I i) {\n" +
536	" }\n" +
537	" public static void main(String[] args) {\n" +
538	" int outerLocal;\n" +
539	" goo((<no type> x) -> {\n" +
540	" int lambdaLocal;\n" +
541	" System.out.println(\"Statement inside lambda\");\n" +
542	" <CompleteOnName:lam>;\n" +
543	"});\n" +
544	" }\n" +
545	"}\n";
546
547	checkMethodParse(
548	string.toCharArray(),
549	cursorLocation,
550	expectedCompletionNodeToString,
551	expectedParentNodeToString,
552	expectedUnitDisplayString,
553	completionIdentifier,
554	expectedReplacedSource,
555	"diet ast");
556	}
348	}	557	}

Lines 23-29 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests18.java (-4 / +98 lines)
23	public class CompletionTests18 extends AbstractJavaModelCompletionTests {	23	public class CompletionTests18 extends AbstractJavaModelCompletionTests {
24		24
25	static {	25	static {
26	// TESTS_NAMES = new String[] {"test001"};	26	// TESTS_NAMES = new String[] {"test015"};
27	}	27	}
28		28
29	public CompletionTests18(String name) {	29	public CompletionTests18(String name) {
Lines 115-126 Link Here
115	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	115	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
116	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	116	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
117	assertResults(	117	assertResults(
118	// INTERIM RESULTS, WILL FAIL ONCE ELIDED TYPE IS CORRECTLY INFERRED.
119	"clone[METHOD_REF]{clone(), Ljava.lang.Object;, ()Ljava.lang.Object;, clone, null, 35}\n" +	118	"clone[METHOD_REF]{clone(), Ljava.lang.Object;, ()Ljava.lang.Object;, clone, null, 35}\n" +
120	"equals[METHOD_REF]{equals(), Ljava.lang.Object;, (Ljava.lang.Object;)Z, equals, (obj), 35}\n" +	119	"equals[METHOD_REF]{equals(), Ljava.lang.Object;, (Ljava.lang.Object;)Z, equals, (obj), 35}\n" +
121	"finalize[METHOD_REF]{finalize(), Ljava.lang.Object;, ()V, finalize, null, 35}\n" +	120	"finalize[METHOD_REF]{finalize(), Ljava.lang.Object;, ()V, finalize, null, 35}\n" +
122	"getClass[METHOD_REF]{getClass(), Ljava.lang.Object;, ()Ljava.lang.Class<+Ljava.lang.Object;>;, getClass, null, 35}\n" +	121	"getClass[METHOD_REF]{getClass(), Ljava.lang.Object;, ()Ljava.lang.Class<+Ljava.lang.Object;>;, getClass, null, 35}\n" +
123	"hashCode[METHOD_REF]{hashCode(), Ljava.lang.Object;, ()I, hashCode, null, 35}\n" +	122	"hashCode[METHOD_REF]{hashCode(), Ljava.lang.Object;, ()I, hashCode, null, 35}\n" +
		123	"length[METHOD_REF]{length(), Ljava.lang.String;, ()I, length, null, 35}\n" +
124	"notify[METHOD_REF]{notify(), Ljava.lang.Object;, ()V, notify, null, 35}\n" +	124	"notify[METHOD_REF]{notify(), Ljava.lang.Object;, ()V, notify, null, 35}\n" +
125	"notifyAll[METHOD_REF]{notifyAll(), Ljava.lang.Object;, ()V, notifyAll, null, 35}\n" +	125	"notifyAll[METHOD_REF]{notifyAll(), Ljava.lang.Object;, ()V, notifyAll, null, 35}\n" +
126	"toString[METHOD_REF]{toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 35}\n" +	126	"toString[METHOD_REF]{toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 35}\n" +
Lines 331-337 Link Here
331	"toString[METHOD_DECLARATION]{public String toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 27}",	331	"toString[METHOD_DECLARATION]{public String toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 27}",
332	requestor.getResults());	332	requestor.getResults());
333	}	333	}
334	public void _test010() throws JavaModelException {	334	public void test010() throws JavaModelException {
335	this.workingCopies = new ICompilationUnit[1];	335	this.workingCopies = new ICompilationUnit[1];
336	this.workingCopies[0] = getWorkingCopy(	336	this.workingCopies[0] = getWorkingCopy(
337	"/Completion/src/X.java",	337	"/Completion/src/X.java",
Lines 570-576 Link Here
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[] { "testBug408230g" };
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 (+313 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.Expression;
21	import org.eclipse.jdt.internal.compiler.ast.Statement;
22	import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
23
24	public abstract class CommitRollbackParser implements TerminalTokens, ParserBasicInformation {
25
26	// resumeOnSyntaxError codes:
27	protected static final int HALT = 0; // halt and throw up hands.
28	protected static final int RESTART = 1; // stacks adjusted, alternate goal from check point.
29	protected static final int RESUME = 2; // stacks untouched, just continue from where left off.
30
31	public static byte rhs[] = null;
32	public static char lhs[] = null;
33	public static char term_action[] = null;
34	public static byte term_check[] = null;
35	public static char base_action[] = null;
36
37	public ReferenceContext referenceContext;
38
39
40	// Constants.
41	protected static final int AstStackIncrement = 100;
42	protected static final int ExpressionStackIncrement = 100;
43	protected static final int GenericsStackIncrement = 10;
44	protected static final int StackIncrement = 255;
45	protected static final int TypeAnnotationStackIncrement = 100;
46
47	public Scanner scanner;
48	public int currentToken;
49	protected int kurrentToken; // copy of currentToken as it is trampled over all over the place :-(
50
51	// ------------- Stack pointers ---------------
52
53	protected int stateStackTop;
54	protected int unstackedAct;
55
56	protected int identifierPtr;
57	protected int identifierLengthPtr;
58
59	protected int astPtr;
60	protected int astLengthPtr;
61
62	protected int expressionPtr;
63	protected int expressionLengthPtr;
64
65	protected int genericsPtr;
66	protected int genericsLengthPtr;
67	protected int genericsIdentifiersLengthPtr;
68
69	protected int typeAnnotationPtr;
70	protected int typeAnnotationLengthPtr;
71
72	protected int intPtr;
73	protected int nestedType;
74	protected int realBlockPtr;
75	public int valueLambdaNestDepth = -1;
76
77	// ---------------- Stacks ----------------
78
79	protected int[] stack = new int[StackIncrement];
80
81	protected char[][] identifierStack;
82	protected int[] identifierLengthStack;
83	protected long[] identifierPositionStack;
84
85	protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
86	protected int[] astLengthStack;
87
88	protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];
89	protected int[] expressionLengthStack;
90
91	protected ASTNode[] genericsStack = new ASTNode[GenericsStackIncrement];
92	protected int[] genericsLengthStack = new int[GenericsStackIncrement];
93	protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];
94
95	protected Annotation [] typeAnnotationStack = new Annotation[TypeAnnotationStackIncrement];
96	protected int [] typeAnnotationLengthStack;
97
98	protected int[] intStack;
99	protected int[] nestedMethod;
100	protected int[] realBlockStack;
101	protected int stateStackLengthStack[] = new int[0];
102	protected int[] variablesCounter;
103
104	// Loose variables.
105
106	protected int listLength;
107	protected int listTypeParameterLength;
108	protected int modifiers;
109	protected int modifiersSourceStart;
110	protected int dimensions;
111	protected int recoveredStaticInitializerStart;
112
113	public CommitRollbackParser cryogenicallyFrozenParser;
114	private static final int[] RECOVERY_TOKENS = new int [] { TokenNameSEMICOLON, TokenNameRPAREN,};
115
116	public void copyState(CommitRollbackParser parser) {
117
118	// Stack pointers.
119
120	this.stateStackTop = parser.stateStackTop;
121	this.unstackedAct = parser.unstackedAct;
122	this.identifierPtr = parser.identifierPtr;
123	this.identifierLengthPtr = parser.identifierLengthPtr;
124	this.astPtr = parser.astPtr;
125	this.astLengthPtr = parser.astLengthPtr;
126	this.expressionPtr = parser.expressionPtr;
127	this.expressionLengthPtr = parser.expressionLengthPtr;
128	this.genericsPtr = parser.genericsPtr;
129	this.genericsLengthPtr = parser.genericsLengthPtr;
130	this.genericsIdentifiersLengthPtr = parser.genericsIdentifiersLengthPtr;
131	this.typeAnnotationPtr = parser.typeAnnotationPtr;
132	this.typeAnnotationLengthPtr = parser.typeAnnotationLengthPtr;
133	this.intPtr = parser.intPtr;
134	this.nestedType = parser.nestedType;
135	this.realBlockPtr = parser.realBlockPtr;
136	this.valueLambdaNestDepth = parser.valueLambdaNestDepth;
137
138	// Stacks.
139
140	int length;
141	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
142	System.arraycopy(parser.identifierStack, 0, this.identifierStack = new char [length = parser.identifierStack.length][], 0, length);
143	System.arraycopy(parser.identifierLengthStack, 0, this.identifierLengthStack = new int [length = parser.identifierLengthStack.length], 0, length);
144	System.arraycopy(parser.identifierPositionStack, 0, this.identifierPositionStack = new long[length = parser.identifierPositionStack.length], 0, length);
145	System.arraycopy(parser.astStack, 0, this.astStack = new ASTNode [length = parser.astStack.length], 0, length);
146	System.arraycopy(parser.astLengthStack, 0, this.astLengthStack = new int [length = parser.astLengthStack.length], 0, length);
147	System.arraycopy(parser.expressionStack, 0, this.expressionStack = new Expression [length = parser.expressionStack.length], 0, length);
148	System.arraycopy(parser.expressionLengthStack, 0, this.expressionLengthStack = new int [length = parser.expressionLengthStack.length], 0, length);
149	System.arraycopy(parser.genericsStack, 0, this.genericsStack = new ASTNode [length = parser.genericsStack.length], 0, length);
150	System.arraycopy(parser.genericsLengthStack, 0, this.genericsLengthStack = new int [length = parser.genericsLengthStack.length], 0, length);
151	System.arraycopy(parser.genericsIdentifiersLengthStack, 0, this.genericsIdentifiersLengthStack = new int [length = parser.genericsIdentifiersLengthStack.length], 0, length);
152	System.arraycopy(parser.typeAnnotationStack, 0, this.typeAnnotationStack = new Annotation [length = parser.typeAnnotationStack.length], 0, length);
153	System.arraycopy(parser.typeAnnotationLengthStack, 0, this.typeAnnotationLengthStack = new int [length = parser.typeAnnotationLengthStack.length], 0, length);
154	System.arraycopy(parser.intStack, 0, this.intStack = new int [length = parser.intStack.length], 0, length);
155	System.arraycopy(parser.nestedMethod, 0, this.nestedMethod = new int [length = parser.nestedMethod.length], 0, length);
156	System.arraycopy(parser.realBlockStack, 0, this.realBlockStack = new int [length = parser.realBlockStack.length], 0, length);
157	System.arraycopy(parser.stateStackLengthStack, 0, this.stateStackLengthStack = new int [length = parser.stateStackLengthStack.length], 0, length);
158	System.arraycopy(parser.variablesCounter, 0, this.variablesCounter = new int [length = parser.variablesCounter.length], 0, length);
159	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
160	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
161	System.arraycopy(parser.stack, 0, this.stack = new int [length = parser.stack.length], 0, length);
162
163	// Loose variables.
164
165	this.listLength = parser.listLength;
166	this.listTypeParameterLength = parser.listTypeParameterLength;
167	this.dimensions = parser.dimensions;
168	this.recoveredStaticInitializerStart = parser.recoveredStaticInitializerStart;
169
170	// Parser.resetStacks is not clearing the modifiers, but AssistParser.resumeAfterRecovery is - why ? (the former doesn't)
171	// this.modifiers = parser.modifiers;
172	// this.modifiersSourceStart = parser.modifiersSourceStart;
173	}
174
175	protected CommitRollbackParser createSnapShotParser() {
176	return new Parser();
177	}
178
179	/* Must be called from Parser.parse ONLY. Rule reduction routine must simply set the flag to request commit.
180	This ensures the end state of chain rule reductions gets committed rather than some intermediate state.
181	See the reduce do-while loop.
182	*/
183	protected void commit() {
184	if (this.cryogenicallyFrozenParser == null) {
185	this.cryogenicallyFrozenParser = createSnapShotParser();
186	}
187	this.cryogenicallyFrozenParser.copyState(this);
188	}
189
190	protected int getNextToken() {
191	try {
192	return this.scanner.getNextToken();
193	} catch (InvalidInputException e) {
194	return TokenNameEOF;
195	}
196	}
197
198	protected void shouldStackAssistNode() {
199	// Not relevant here.
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	boolean atCompletionSite = false;
205	int lastAction = this.stack[this.stateStackTop];
206
207	// If triggered fake EOF at completion site, see if the real next token would have passed muster.
208	if (this.kurrentToken == TokenNameEOF) {
209	if (this.scanner.eofPosition < this.scanner.source.length) {
210	atCompletionSite = true;
211	this.scanner.eofPosition = this.scanner.source.length;
212	nextToken = getNextToken();
213	if (automatonWillShift(nextToken, lastAction)) {
214	this.currentToken = this.kurrentToken = nextToken;
215	return RESUME;
216	}
217	} else {
218	nextToken = TokenNameEOF;
219	}
220	} else {
221	nextToken = this.kurrentToken;
222	}
223	if (nextToken == TokenNameEOF)
224	return HALT; // don't know how to proceed.
225	this.scanner.ungetToken(nextToken); // spit out what has been bitten more than we can chew.
226	// OK, next token is no good to resume "in place", attempt some local repair.
227	for (int i = 0, length = RECOVERY_TOKENS.length; i < length; i++) {
228	if (automatonWillShift(RECOVERY_TOKENS[i], lastAction)) {
229	this.currentToken = this.kurrentToken = RECOVERY_TOKENS[i];
230	return RESUME;
231	}
232	}
233	// OK, no in place resumption, no local repair, fast forward to next statement.
234	if (this.cryogenicallyFrozenParser == null)
235	return RESTART;
236
237	this.copyState(this.cryogenicallyFrozenParser);
238	if (atCompletionSite) {
239	this.currentToken = TokenNameSEMICOLON;
240	shouldStackAssistNode();
241	return RESUME;
242	}
243	this.currentToken = this.scanner.fastForward(unused);
244	return RESUME;
245	}
246
247	protected void resetStacks() {
248
249	this.astPtr = -1;
250	this.astLengthPtr = -1;
251	this.expressionPtr = -1;
252	this.expressionLengthPtr = -1;
253	this.typeAnnotationLengthPtr = -1;
254	this.typeAnnotationPtr = -1;
255	this.identifierPtr = -1;
256	this.identifierLengthPtr = -1;
257	this.intPtr = -1;
258
259	this.nestedMethod[this.nestedType = 0] = 0; // need to reset for further reuse
260	this.variablesCounter[this.nestedType] = 0;
261
262	this.dimensions = 0 ;
263	this.realBlockStack[this.realBlockPtr = 0] = 0;
264	this.recoveredStaticInitializerStart = 0;
265	this.listLength = 0;
266	this.listTypeParameterLength = 0;
267
268	this.genericsIdentifiersLengthPtr = -1;
269	this.genericsLengthPtr = -1;
270	this.genericsPtr = -1;
271	this.valueLambdaNestDepth = -1;
272	}
273
274	protected boolean automatonWillShift(int token, int lastAction) {
275	int stackTop = this.stateStackTop; // local copy of stack pointer
276	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.
277	int highWaterMark = stackTop;
278	// A rotated version of the automaton - cf. parse()'s for(;;)
279	for (;;) {
280	if (lastAction > ERROR_ACTION) {
281	lastAction -= ERROR_ACTION; /* shift-reduce on loop entry from above, reduce on loop back */
282	do { /* reduce */
283	stackTop -= rhs[lastAction] - 1;
284	if (stackTop < highWaterMark) {
285	stackTopState = this.stack[highWaterMark = stackTop];
286	} // else stackTopState is upto date already.
287	lastAction = ntAction(stackTopState, lhs[lastAction]);
288	} while (lastAction <= NUM_RULES);
289	}
290	highWaterMark = ++stackTop;
291	stackTopState = lastAction; // "push"
292	lastAction = tAction(lastAction, token); // can be looked up from a precomputed cache.
293	if (lastAction <= NUM_RULES) {
294	stackTop --;
295	lastAction += ERROR_ACTION;
296	continue;
297	}
298	// Error => false, Shift, Shift/Reduce => true, Accept => impossible.
299	return lastAction != ERROR_ACTION;
300	}
301	}
302
303	public static int tAction(int state, int sym) {
304	return term_action[term_check[base_action[state]+sym] == sym ? base_action[state] + sym : base_action[state]];
305	}
306
307	public static int ntAction(int state, int sym) {
308	return base_action[state + sym];
309	}
310
311
312	}
313

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