Attachment #238301 for bug #422468

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

Lines 74-82 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionParserTest18.java (-7 / +377 lines)
74	" static void goo(J i) {\n" +	74	" static void goo(J i) {\n" +
75	" }\n" +	75	" }\n" +
76	" public static void main(String[] args) {\n" +	76	" public static void main(String[] args) {\n" +
77	" (<no type> first, <no type> second) -> {\n" +	77	" goo((<no type> first, <no type> second) -> {\n" +
78	" (<no type> xyz, <no type> pqr) -> <CompleteOnName:first.>;\n" +	78	" return (<no type> xyz, <no type> pqr) -> <CompleteOnName:first.>;\n" +
79	" };\n" +	79	"});\n" +
80	" }\n" +	80	" }\n" +
81	"}\n";	81	"}\n";
82		82
Lines 177-183 Link Here
177	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;	177	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
178		178
179	String expectedCompletionNodeToString = "<CompleteOnName:x>";	179	String expectedCompletionNodeToString = "<CompleteOnName:x>";
180	String expectedParentNodeToString = "<NONE>";	180	String expectedParentNodeToString = "static Foo f = (<no type> x5, <no type> x6) -> {\n" +
		181	" <CompleteOnName:x>;\n" +
		182	"};";
181	String completionIdentifier = "x";	183	String completionIdentifier = "x";
182	String expectedReplacedSource = "x";	184	String expectedReplacedSource = "x";
183	String expectedUnitDisplayString =	185	String expectedUnitDisplayString =
Lines 233-242 Link Here
233	" }\n" +	235	" }\n" +
234	" void go() {\n" +	236	" void go() {\n" +
235	" I i = (<no type> argument) -> {\n" +	237	" I i = (<no type> argument) -> {\n" +
236	" {\n" +	238	" if (true)\n" +
237	" if (true)\n" +	239	" {\n" +
238	" return <CompleteOnName:arg>;\n" +	240	" return <CompleteOnName:arg>;\n" +
239	" }\n" +	241	" }\n" +
240	" };\n" +	242	" };\n" +
241	" }\n" +	243	" }\n" +
242	"}\n";	244	"}\n";
Lines 345-348 Link Here
345	expectedReplacedSource,	347	expectedReplacedSource,
346	"diet ast");	348	"diet ast");
347	}	349	}
		350	public void test0010() {
		351	String string =
		352	"interface I {\n" +
		353	" void foo(String x);\n" +
		354	"}\n" +
		355	"public class X {\n" +
		356	" String xField;\n" +
		357	" static void goo(String s) {\n" +
		358	" }\n" +
		359	" static void goo(I i) {\n" +
		360	" }\n" +
		361	" public static void main(String[] args) {\n" +
		362	" goo((xyz) -> {\n" +
		363	" System.out.println(xyz.);\n" +
		364	" });\n" +
		365	" }\n" +
		366	"}\n";
		367
		368	String completeBehind = "xyz.";
		369	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
		370
		371	String expectedCompletionNodeToString = "<CompleteOnName:xyz.>";
		372	String expectedParentNodeToString = "System.out.println(<CompleteOnName:xyz.>)";
		373	String completionIdentifier = "";
		374	String expectedReplacedSource = "xyz.";
		375	String expectedUnitDisplayString =
		376	"interface I {\n" +
		377	" void foo(String x);\n" +
		378	"}\n" +
		379	"public class X {\n" +
		380	" String xField;\n" +
		381	" public X() {\n" +
		382	" }\n" +
		383	" static void goo(String s) {\n" +
		384	" }\n" +
		385	" static void goo(I i) {\n" +
		386	" }\n" +
		387	" public static void main(String[] args) {\n" +
		388	" goo((<no type> xyz) -> {\n" +
		389	" System.out.println(<CompleteOnName:xyz.>);\n" +
		390	"});\n" +
		391	" }\n" +
		392	"}\n";
		393
		394	checkMethodParse(
		395	string.toCharArray(),
		396	cursorLocation,
		397	expectedCompletionNodeToString,
		398	expectedParentNodeToString,
		399	expectedUnitDisplayString,
		400	completionIdentifier,
		401	expectedReplacedSource,
		402	"diet ast");
		403	}
		404	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=417935, [1.8][code select] ICU#codeSelect doesn't work on reference to lambda parameter
		405	public void test417935() {
		406	String string =
		407	"import java.util.ArrayList;\n" +
		408	"import java.util.Arrays;\n" +
		409	"import java.util.Collections;\n" +
		410	"import java.util.Comparator;\n" +
		411	"public class X {\n" +
		412	" int compareTo(X x) { return 0; }\n" +
		413	" void foo() {\n" +
414	" Collections.sort(new ArrayList<X>(Arrays.asList(new X(), new X(), new X())),\n" +
415	" (X o1, X o2) -> o1.compa); //[2]\n" +
416	" }\n" +
417	"}\n";
418
419	String completeBehind = "compa";
420	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
421
422	String expectedCompletionNodeToString = "<CompleteOnName:o1.compa>";
423	String expectedParentNodeToString = "<NONE>";
424	String completionIdentifier = "compa";
425	String expectedReplacedSource = "o1.compa";
426	String expectedUnitDisplayString =
427	"import java.util.ArrayList;\n" +
428	"import java.util.Arrays;\n" +
429	"import java.util.Collections;\n" +
430	"import java.util.Comparator;\n" +
431	"public class X {\n" +
432	" public X() {\n" +
433	" }\n" +
434	" int compareTo(X x) {\n" +
435	" }\n" +
436	" void foo() {\n" +
437	" Collections.sort(new ArrayList<X>(Arrays.asList(new X(), new X(), new X())), (X o1, X o2) -> <CompleteOnName:o1.compa>);\n" +
438	" }\n" +
439	"}\n";
440
441	checkMethodParse(
442	string.toCharArray(),
443	cursorLocation,
444	expectedCompletionNodeToString,
445	expectedParentNodeToString,
446	expectedUnitDisplayString,
447	completionIdentifier,
448	expectedReplacedSource,
449	"diet ast");
450	}
451	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=405126, [1.8][code assist] Lambda parameters incorrectly recovered as fields.
452	public void test405126() {
453	String string =
454	"public interface Foo { \n" +
455	" int run(int s1, int s2); \n" +
456	"}\n" +
457	"interface X {\n" +
458	" static Foo f = (int x5, int x11) -> x\n" +
459	" static int x1 = 2;\n" +
460	"}\n" +
461	"class C {\n" +
462	" void method1(){\n" +
463	" int p = X.\n" +
464	" }\n" +
465	"}\n";
466
467	String completeBehind = "X.";
468	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
469
470	String expectedCompletionNodeToString = "<CompleteOnName:X.>";
471	String expectedParentNodeToString = "int p = <CompleteOnName:X.>;";
472	String completionIdentifier = "";
473	String expectedReplacedSource = "X.";
474	String expectedUnitDisplayString =
475	"public interface Foo {\n" +
476	" int run(int s1, int s2);\n" +
477	"}\n" +
478	"interface X {\n" +
479	" static Foo f;\n" +
480	" static int x1;\n" +
481	" <clinit>() {\n" +
482	" }\n" +
483	"}\n" +
484	"class C {\n" +
485	" C() {\n" +
486	" }\n" +
487	" void method1() {\n" +
488	" int p = <CompleteOnName:X.>;\n" +
489	" }\n" +
490	"}\n";
491
492	checkMethodParse(
493	string.toCharArray(),
494	cursorLocation,
495	expectedCompletionNodeToString,
496	expectedParentNodeToString,
497	expectedUnitDisplayString,
498	completionIdentifier,
499	expectedReplacedSource,
500	"diet ast");
501	}
502	// Verify that locals inside a lambda block don't get promoted to the parent block.
503	public void testLocalsPromotion() {
504	String string =
505	"interface I {\n" +
506	" void foo(int x);\n" +
507	"}\n" +
508	"public class X {\n" +
509	" static void goo(I i) {}\n" +
510	" public static void main(String[] args) {\n" +
511	" int outerLocal;\n" +
512	" goo ((x) -> {\n" +
513	" int lambdaLocal = 10;\n" +
514	" System.out.println(\"Statement inside lambda\");\n" +
515	" lam\n" +
516	" });\n" +
517	" }\n" +
518	"}\n";
519
520	String completeBehind = "lam";
521	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
522
523	String expectedCompletionNodeToString = "<CompleteOnName:lam>";
524	String expectedParentNodeToString = "<NONE>";
525	String completionIdentifier = "lam";
526	String expectedReplacedSource = "lam";
527	String expectedUnitDisplayString =
528	"interface I {\n" +
529	" void foo(int x);\n" +
530	"}\n" +
531	"public class X {\n" +
532	" public X() {\n" +
533	" }\n" +
534	" static void goo(I i) {\n" +
535	" }\n" +
536	" public static void main(String[] args) {\n" +
537	" int outerLocal;\n" +
538	" goo((<no type> x) -> {\n" +
539	" int lambdaLocal;\n" +
540	" System.out.println(\"Statement inside lambda\");\n" +
541	" <CompleteOnName:lam>;\n" +
542	"});\n" +
543	" }\n" +
544	"}\n";
545
546	checkMethodParse(
547	string.toCharArray(),
548	cursorLocation,
549	expectedCompletionNodeToString,
550	expectedParentNodeToString,
551	expectedUnitDisplayString,
552	completionIdentifier,
553	expectedReplacedSource,
554	"diet ast");
555	}
556
557	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422107, [1.8][code assist] Invoking code assist just before and after a variable initialized using lambda gives different result
558	public void testCompletionLocation() {
559	String string =
560	"interface I {\n" +
561	" void doit();\n" +
562	"}\n" +
563	"interface J {\n" +
564	"}\n" +
565	"public class X { \n" +
566	" Object o = (I & J) () -> {};\n" +
567	" /* AFTER */\n" +
568	"}\n";
569
570	String completeBehind = "/* AFTER */";
571	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
572
573	String expectedCompletionNodeToString = "<CompleteOnType:>";
574	String expectedParentNodeToString = "<NONE>";
575	String completionIdentifier = "";
576	String expectedReplacedSource = "";
577	String expectedUnitDisplayString =
578	"interface I {\n" +
579	" void doit();\n" +
580	"}\n" +
581	"interface J {\n" +
582	"}\n" +
583	"public class X {\n" +
584	" Object o;\n" +
585	" <CompleteOnType:>;\n" +
586	" public X() {\n" +
587	" }\n" +
588	"}\n";
589
590	checkMethodParse(
591	string.toCharArray(),
592	cursorLocation,
593	expectedCompletionNodeToString,
594	expectedParentNodeToString,
595	expectedUnitDisplayString,
596	completionIdentifier,
597	expectedReplacedSource,
598	"diet ast");
599	}
600	public void testElidedCompletion() {
601	String string =
602	"class Collections {\n" +
603	" public static void sort(ArrayList list, Comparator c) {\n" +
604	" }\n" +
605	"}\n" +
606	"interface Comparator {\n" +
607	" int compareTo(X t, X s);\n" +
608	"}\n" +
609	"class ArrayList {\n" +
610	"}\n" +
611	"public class X {\n" +
612	" int compareTo(X x) { return 0; }\n" +
613	" void foo() {\n" +
614	" Collections.sort(new ArrayList(), (X o1, X o2) -> o1.compa);\n" +
615	" }\n" +
616	"}\n";
617
618	String completeBehind = "compa";
619	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
620
621	String expectedCompletionNodeToString = "<CompleteOnName:o1.compa>";
622	String expectedParentNodeToString = "<NONE>";
623	String completionIdentifier = "compa";
624	String expectedReplacedSource = "o1.compa";
625	String expectedUnitDisplayString =
626	"class Collections {\n" +
627	" Collections() {\n" +
628	" }\n" +
629	" public static void sort(ArrayList list, Comparator c) {\n" +
630	" }\n" +
631	"}\n" +
632	"interface Comparator {\n" +
633	" int compareTo(X t, X s);\n" +
634	"}\n" +
635	"class ArrayList {\n" +
636	" ArrayList() {\n" +
637	" }\n" +
638	"}\n" +
639	"public class X {\n" +
640	" public X() {\n" +
641	" }\n" +
642	" int compareTo(X x) {\n" +
643	" }\n" +
644	" void foo() {\n" +
645	" Collections.sort(new ArrayList(), (X o1, X o2) -> <CompleteOnName:o1.compa>);\n" +
646	" }\n" +
647	"}\n";
648
649	checkMethodParse(
650	string.toCharArray(),
651	cursorLocation,
652	expectedCompletionNodeToString,
653	expectedParentNodeToString,
654	expectedUnitDisplayString,
655	completionIdentifier,
656	expectedReplacedSource,
657	"diet ast");
658	}
659	public void testElidedCompletion2() {
660	String string =
661	"class Collections {\n" +
662	" public static void sort(ArrayList list, Comparator c) {\n" +
663	" }\n" +
664	"}\n" +
665	"interface Comparator {\n" +
666	" int compareTo(X t, X s);\n" +
667	"}\n" +
668	"class ArrayList {\n" +
669	"}\n" +
670	"public class X {\n" +
671	" int compareTo(X x) { return 0; }\n" +
672	" void foo() {\n" +
673	" Collections.sort(new ArrayList(), (o1, o2) -> o1.compa);\n" +
674	" }\n" +
675	"}\n";
676
677	String completeBehind = "compa";
678	int cursorLocation = string.lastIndexOf(completeBehind) + completeBehind.length() - 1;
679
680	String expectedCompletionNodeToString = "<CompleteOnName:o1.compa>";
681	String expectedParentNodeToString = "<NONE>";
682	String completionIdentifier = "compa";
683	String expectedReplacedSource = "o1.compa";
684	String expectedUnitDisplayString =
685	"class Collections {\n" +
686	" Collections() {\n" +
687	" }\n" +
688	" public static void sort(ArrayList list, Comparator c) {\n" +
689	" }\n" +
690	"}\n" +
691	"interface Comparator {\n" +
692	" int compareTo(X t, X s);\n" +
693	"}\n" +
694	"class ArrayList {\n" +
695	" ArrayList() {\n" +
696	" }\n" +
697	"}\n" +
698	"public class X {\n" +
699	" public X() {\n" +
700	" }\n" +
701	" int compareTo(X x) {\n" +
702	" }\n" +
703	" void foo() {\n" +
704	" Collections.sort(new ArrayList(), (<no type> o1, <no type> o2) -> <CompleteOnName:o1.compa>);\n" +
705	" }\n" +
706	"}\n";
707
708	checkMethodParse(
709	string.toCharArray(),
710	cursorLocation,
711	expectedCompletionNodeToString,
712	expectedParentNodeToString,
713	expectedUnitDisplayString,
714	completionIdentifier,
715	expectedReplacedSource,
716	"diet ast");
717	}
348	}	718	}

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:




/*******************************************************************************
 * 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.core.tests;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.jdt.core.tests.compiler.parser.CompletionParserTest18;
import org.eclipse.jdt.core.tests.model.CompletionTests18;
import org.eclipse.jdt.core.tests.model.ResolveTests18;

public class RunOnlyAssistTests18 extends TestCase {
	
	public RunOnlyAssistTests18(String name) {
		super(name);
	}
	public static Class[] getAllTestClasses() {
		return new Class[] {
			ResolveTests18.class,
			CompletionParserTest18.class,
			CompletionTests18.class,
		};
	}
	
	public static Test suite() {
		TestSuite ts = new TestSuite(RunOnlyAssistTests18.class.getName());

		Class[] testClasses = getAllTestClasses();
		addTestsToSuite(ts, testClasses);
		return ts;
	}
	public static void addTestsToSuite(TestSuite suite, Class[] testClasses) {

		for (int i = 0; i < testClasses.length; i++) {
			Class testClass = testClasses[i];
			// call the suite() method and add the resulting suite to the suite
			try {
				Method suiteMethod = testClass.getDeclaredMethod("suite", new Class[0]); //$NON-NLS-1$
				Test test = (Test)suiteMethod.invoke(null, new Object[0]);
				suite.addTest(test);
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.getTargetException().printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			}
		}
	}
	protected void tearDown() throws Exception {
		super.tearDown();
	}
}




	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",
			"interface I {\n" +
			"  String foo(X x, X i); \n" +
			"} \n" +
			"public class X  {\n" +
			"	static void goo(I i) {\n" +

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	assertResults(
			"goo[METHOD_REF]{goo(), LX;, (LI;)V, goo, (i), 24}\n" +
			"goo[METHOD_REF]{goo(), LX;, (Ljava.lang.String;)V, goo, (s), 24}\n" +
			"main[METHOD_REF]{main(), LX;, ([Ljava.lang.String;)V, main, (args), 24}\n" +
			"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" +
			"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" +
			"wait[METHOD_REF]{wait(), Ljava.lang.Object;, ()V, wait, null, 35}\n" +
			"wait[METHOD_REF]{wait(), Ljava.lang.Object;, (J)V, wait, (millis), 35}\n" +
			"wait[METHOD_REF]{wait(), Ljava.lang.Object;, (JI)V, wait, (millis, nanos), 35}",
			"volatile[KEYWORD]{volatile, null, null, volatile, null, 24}\n" +
			"I[TYPE_REF]{I, , LI;, null, null, 27}\n" +
			"J[TYPE_REF]{J, , LJ;, null, null, 27}\n" +
			"X[TYPE_REF]{X, , LX;, null, null, 27}\n" +
			"clone[METHOD_DECLARATION]{protected Object clone() throws CloneNotSupportedException, Ljava.lang.Object;, ()Ljava.lang.Object;, clone, null, 27}\n" +
			"equals[METHOD_DECLARATION]{public boolean equals(Object obj), Ljava.lang.Object;, (Ljava.lang.Object;)Z, equals, (obj), 27}\n" +
			"finalize[METHOD_DECLARATION]{protected void finalize() throws Throwable, Ljava.lang.Object;, ()V, finalize, null, 27}\n" +
			"hashCode[METHOD_DECLARATION]{public int hashCode(), Ljava.lang.Object;, ()I, hashCode, null, 27}\n" +
			"toString[METHOD_DECLARATION]{public String toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 27}",
			requestor.getResults());
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422901, [1.8][code assist] Code assistant sensitive to scope.referenceContext type identity.

			"	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 { // computing visible elements in lambda scope.
	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" +
			"	static X xField;\n" +
			"	static X goo(String s) {\n" +
			"       return null;\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=233\n" +
			"completion range=[233, 232]\n" +
			"completion token=\"\"\n" +
			"completion token kind=TOKEN_KIND_NAME\n" +
			"expectedTypesSignatures=null\n" +
			"expectedTypesKeys=null\n" +
			"completion token location=UNKNOWN\n" +
			"visibleElements={\n" +
			"	xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
			"	goo(String) {key=LX;.goo(Ljava/lang/String;)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 { // computing visible elements in lambda scope.
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src/X.java",
			"interface I {\n" +
			"	void foo(X x);\n" +
			"}\n" +
			"public class X {\n" +
			"	static X xField;\n" +
			"	static X goo(String s) {\n" +
			"       return null;\n" +
			"	}\n" +
			"	static void goo(I i) {\n" +
			"	}\n" +
			"	public static void main(String[] args) {\n" +
			"       X xLocal = null;\n" +
			"       args = null;\n" +
			"       if (args != null) {\n" +
			"           xField = null;\n" +
			"       else \n" +
			"           xField = null;\n" +
			"       while (true);\n" +
			"		goo((xyz) -> {\n" +
			"           X xLambdaLocal = null;\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=419\n" +
			"completion range=[419, 418]\n" +
			"completion token=\"\"\n" +
			"completion token kind=TOKEN_KIND_NAME\n" +
			"expectedTypesSignatures=null\n" +
			"expectedTypesKeys=null\n" +
			"completion token location=UNKNOWN\n" +
			"visibleElements={\n" +
			"	xLocal [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]]],\n" +
	        "	xLambdaLocal [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]]],\n" +
			"	xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
			"	goo(String) {key=LX;.goo(Ljava/lang/String;)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=417935, [1.8][code select] ICU#codeSelect doesn't work on reference to lambda parameter
public void test417935() throws JavaModelException {  // JCL_MIN does not have the relevant classes - these are needed to handle lambda. Use local versions.
	this.wc = getWorkingCopy(
			"/Resolve/src/X.java",
			"class Collections {\n" +
			"	public static void sort(ArrayList list, Comparator c) {\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" +
			"interface Comparator {\n" +
			"	int compareTo(X t, X s);\n" +
			"}\n" +
			"class ArrayList {\n" +
			"}\n" +
			"public class X {\n" +
			"	int compareTo(X x) { return 0; }\n" +
			"	void foo() {\n" +
			"		Collections.sort(new ArrayList(), (X o1, X o2) -> o1.compareTo(o2));\n" +
			"	}\n" +
			"}\n");


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




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


		this.cursorLocation > variable.initialization.sourceEnd) {
		variable.initialization = null;
	} else if (this.assistNode != null && 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() {
	this.hasUnusedModifiers = false;
	if (this.assistNode != null) {
		
		if (requireExtendedRecovery()) {
			if (this.unstackedAct != ERROR_ACTION) {
				return RESUME;
			}
			return super.resumeAfterRecovery();
		}
		
		/* 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;
			}
		}
	}

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




		null/*taskPriorities*/,
		true/*taskCaseSensitive*/);
}
protected boolean isAtAssistIdentifier() {
	if (this.cursorLocation < this.startPosition && this.currentPosition == this.startPosition) { // fake empty identifier got issued
		return true;
	}
	if (this.cursorLocation+1 >= this.startPosition && this.cursorLocation < this.currentPosition) {
		return true;
	}
	return false;
}
/*
 * Truncate the current identifier if it is containing the cursor location. Since completion is performed
 * on an identifier prefix.

					this.currentPosition = this.startPosition; // for being detected as empty free identifier
					return TokenNameIdentifier;
				}
				this.currentPosition = this.startPosition; // fake EOF should not drown the real next token.
				return TokenNameEOF;
			}





 *
 */

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.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.snapShot = 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 boolean triggerRecoveryUponLambdaClosure() {
	// Last block statement reduced is required to be on the AST stack top.
	boolean lambdaClosed = 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;
			lambdaClosed = 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 false;
		}
		this.restartRecovery = true;
		this.isOrphanCompletionNode = false;
		this.lambdaNeedsClosure = false;
	}
	
	if (lambdaClosed && this.currentElement != null) {
		this.restartRecovery = true;
		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.snapShot = null;
	return lambdaClosed;
}
protected boolean isAssistParser() {
	return true;
}
protected void consumeBlockStatement() {
	super.consumeBlockStatement();
	triggerRecoveryUponLambdaClosure();
}

protected void consumeBlockStatements() {
	super.consumeBlockStatements();
	triggerRecoveryUponLambdaClosure();
}
protected void consumeFieldDeclaration() {
	super.consumeFieldDeclaration();
	if (triggerRecoveryUponLambdaClosure()) {
		if (this.currentElement instanceof RecoveredType)
			popUntilElement(K_TYPE_DELIMITER);
	}
}
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);
}
protected void consumeLambdaHeader() {
	super.consumeLambdaHeader();
	LambdaExpression lexp = (LambdaExpression) this.astStack[this.astPtr];
	pushOnElementStack(K_LAMBDA_EXPRESSION_DELIMITER, EXPRESSION_BODY, lexp);
}
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() {
	if (requireExtendedRecovery()) {
		if (this.unstackedAct == ERROR_ACTION) {
			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;

	if (this.diet) this.dietInt = 0;

	/* attempt to move checkpoint location */
	if (this.unstackedAct != ERROR_ACTION && 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 (-41 / +34 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-1464 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() {
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 (this.unstackedAct != ERROR_ACTION) {
		1440	return RESUME;
		1441	}
		1442	return super.resumeAfterRecovery();
		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	}
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 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];
	private static final Block NO_BODY = new Block(0, true);

	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.Statement;

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 Scanner scanner;
	public int currentToken;
	protected int kurrentToken; // copy of currentToken as it is trampled over all over the place :-(
	
	public CommitRollbackParser snapShot;
	private static final int[] RECOVERY_TOKENS = new int [] { TokenNameSEMICOLON, TokenNameRPAREN,};
	
	protected CommitRollbackParser createSnapShotParser() {
		return new Parser();
	}
	
	protected void commit() {
		if (this.snapShot == null) {
			this.snapShot = createSnapShotParser();
		}
		this.snapShot.copyState(this);
	}
	
	public void copyState(CommitRollbackParser commitRollbackParser) {
		// Subclasses should implement.
	}

	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 automatonState = automatonState();
				
		// 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, automatonState)) {
					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. FIXME: need to make sure we don't get stuck keep reducing empty statements !!
		for (int i = 0, length = RECOVERY_TOKENS.length; i < length; i++) {
			if (automatonWillShift(RECOVERY_TOKENS[i], automatonState)) {
				this.currentToken = this.kurrentToken = RECOVERY_TOKENS[i];
				return RESUME;
			}
		}
		// OK, no in place resumption, no local repair, fast forward to next statement.
		if (this.snapShot == null)
			return RESTART;

		this.copyState(this.snapShot);
		if (atCompletionSite) {
			this.currentToken = TokenNameSEMICOLON;
			shouldStackAssistNode();
			return RESUME;
		}
		this.currentToken = this.scanner.fastForward(unused);
		return RESUME;
	}

	public abstract int automatonState();

	public abstract boolean automatonWillShift(int nextToken, int lastAction);
}






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 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 nextTypeStart;
protected TypeDeclaration pendingRecoveredType;
public RecoveryScanner recoveryScanner;

public Scanner scanner;
protected int[] stack = new int[StackIncrement];
protected int stateStackTop;
protected int synchronizedBlockSourceStart;

// used for recovery
protected int lastJavadocEnd;
public org.eclipse.jdt.internal.compiler.ReadManager readManager;
protected int valueLambdaNestDepth = -1;
private int stateStackLengthStack[] = new int[0];
protected boolean parsingJava8Plus;
protected int unstackedAct = ERROR_ACTION;

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;
	}
}
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;
			this.currentElement = this.currentElement.parent;
		}
		this.lastCheckPoint = lexp.sourceEnd + 1;
	}
}


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

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


	         
	    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 (resumeOnSyntaxError()) {
				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);
}


	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;

 * Move checkpoint location, reset internal stacks and
 * decide which grammar goal is activated.
 */
protected int resumeAfterRecovery() {
	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 resumeOnSyntaxError() {

	}

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

	exp.sourceEnd = this.intStack[this.intPtr--];
	exp.sourceStart = this.intStack[this.intPtr--];
}
public void copyState(CommitRollbackParser from) {
	
	Parser parser = (Parser) from;

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

public int automatonState() {
	return this.stack[this.stateStackTop];
}
public 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;
	}
}
}

Lines 61-74 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/RecoveredBlock.java (-9 / +15 lines)
61	return super.add(methodDeclaration, bracketBalanceValue);	61	return super.add(methodDeclaration, bracketBalanceValue);
62	}	62	}
63	/*	63	/*
64	* Record a Lambda declaration
65	*/
66	public RecoveredElement add(LambdaExpression expression, int bracketBalanceValue) {
67	RecoveredLambdaExpression element = new RecoveredLambdaExpression(expression, this, bracketBalanceValue);
68	attach(element);
69	return element;
70	}
71	/*
72	* Record a nested block declaration	64	* Record a nested block declaration
73	*/	65	*/
74	public RecoveredElement add(Block nestedBlockDeclaration, int bracketBalanceValue) {	66	public RecoveredElement add(Block nestedBlockDeclaration, int bracketBalanceValue) {
Lines 162-167 Link Here
162	* Record a statement declaration	154	* Record a statement declaration
163	*/	155	*/
164	public RecoveredElement add(Statement stmt, int bracketBalanceValue, boolean delegatedByParent) {	156	public RecoveredElement add(Statement stmt, int bracketBalanceValue, boolean delegatedByParent) {
		157
		158	if (stmt instanceof LambdaExpression) // lambdas are recovered up to the containing statement anyways.
		159	return this;
		160
165	resetPendingModifiers();	161	resetPendingModifiers();
166		162
167	/* do not consider a nested block starting passed the block end (if set)	163	/* do not consider a nested block starting passed the block end (if set)
Lines 295-300 Link Here
295		291
296	// if block was not marked to be preserved or empty, then ignore it	292	// if block was not marked to be preserved or empty, then ignore it
297	if (!this.preserveContent \|\| this.statementCount == 0) return null;	293	if (!this.preserveContent \|\| this.statementCount == 0) return null;
		294
		295	/* If this block stands for the lambda body, trash the contents. Lambda expressions are recovered as part of the enclosing statement.
		296	We still have left in a block here to make sure that contained elements can be trapped and tossed out.
		297	*/
		298	if (this.blockDeclaration.lambdaBody) return null;
298		299
299	Statement[] updatedStatements = new Statement[this.statementCount];	300	Statement[] updatedStatements = new Statement[this.statementCount];
300	int updatedCount = 0;	301	int updatedCount = 0;
Lines 340-346 Link Here
340	Statement updatedStatement = this.statements[i].updatedStatement(depth, knownTypes);	341	Statement updatedStatement = this.statements[i].updatedStatement(depth, knownTypes);
341	if (updatedStatement != null){	342	if (updatedStatement != null){
342	updatedStatements[updatedCount++] = updatedStatement;	343	updatedStatements[updatedCount++] = updatedStatement;
343		344
344	if (updatedStatement instanceof LocalDeclaration) {	345	if (updatedStatement instanceof LocalDeclaration) {
345	LocalDeclaration localDeclaration = (LocalDeclaration) updatedStatement;	346	LocalDeclaration localDeclaration = (LocalDeclaration) updatedStatement;
346	if(localDeclaration.declarationSourceEnd > lastEnd) {	347	if(localDeclaration.declarationSourceEnd > lastEnd) {
Lines 431-436 Link Here
431		432
432	// if block was closed or empty, then ignore it	433	// if block was closed or empty, then ignore it
433	if (this.blockDeclaration.sourceEnd != 0 \|\| this.statementCount == 0) return null;	434	if (this.blockDeclaration.sourceEnd != 0 \|\| this.statementCount == 0) return null;
		435
		436	/* If this block stands for the lambda body, trash the contents. Lambda expressions are recovered as part of the enclosing statement.
		437	We still have left in a block here to make sure that contained elements can be trapped and tossed out.
		438	*/
		439	if (this.blockDeclaration.lambdaBody) return null;
434		440
435	Statement[] updatedStatements = new Statement[this.statementCount];	441	Statement[] updatedStatements = new Statement[this.statementCount];
436	int updatedCount = 0;	442	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

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




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




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




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;


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

Return to bug 422468

Lines 1349-1368 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/ResolveTests18.java (-11 / +112 lines)
1349	}	1349	}
1350	}	1350	}
1351	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=417935, [1.8][code select] ICU#codeSelect doesn't work on reference to lambda parameter	1351	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=417935, [1.8][code select] ICU#codeSelect doesn't work on reference to lambda parameter
1352	public void test417935() throws JavaModelException {	1352	public void test417935() throws JavaModelException { // JCL_MIN does not have the relevant classes - these are needed to handle lambda. Use local versions.
1353	this.wc = getWorkingCopy(	1353	this.wc = getWorkingCopy(
1354	"/Resolve/src/X.java",	1354	"/Resolve/src/X.java",
1355	"import java.util.ArrayList;\n" +	1355	"class Collections {\n" +
1356	"import java.util.Arrays;\n" +	1356	" public static void sort(ArrayList list, Comparator c) {\n" +
1357	"import java.util.Collections;\n" +
1358	"import java.util.Comparator;\n" +
1359	"public class X {\n" +
1360	" int compareTo(X x) { return 0; }\n" +
1361	" void foo() {\n" +
1362	" Collections.sort(new ArrayList<X>(Arrays.asList(new X(), new X(), new X())),\n" +
1363	" (X o1, X o2) -> o1.compareTo(o2)); //[2]\n" +
1364	" }\n" +	1357	" }\n" +
1365	"\n" +	1358	"}\n" +
		1359	"interface Comparator {\n" +
		1360	" int compareTo(X t, X s);\n" +
		1361	"}\n" +
		1362	"class ArrayList {\n" +
		1363	"}\n" +
		1364	"public class X {\n" +
		1365	" int compareTo(X x) { return 0; }\n" +
		1366	" void foo() {\n" +
		1367	" Collections.sort(new ArrayList(), (X o1, X o2) -> o1.compareTo(o2));\n" +
1366	" }\n" +	1368	" }\n" +
1367	"}\n");	1369	"}\n");
1368		1370
Lines 1531-1534 Link Here
1531	elements	1533	elements
1532	);	1534	);
1533	}	1535	}
		1536	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		1537	public void test422468d() throws JavaModelException {
		1538	this.wc = getWorkingCopy(
		1539	"/Resolve/src/X.java",
		1540	"interface I {\n" +
		1541	" J foo(String x, String y);\n" +
		1542	"}\n" +
		1543	"interface J {\n" +
		1544	" K foo(String x, String y);\n" +
		1545	"}\n" +
		1546	"interface K {\n" +
		1547	" int foo(String x, int y);\n" +
		1548	"}\n" +
		1549	"public class X {\n" +
		1550	" static void goo(K i) {}\n" +
		1551	" public static void main(String[] args) {\n" +
		1552	" I i = (x, y) -> { return (a, b) -> (p, q) -> a.length(); };\n" +
		1553	" }\n" +
		1554	"}\n");
		1555
		1556	String str = this.wc.getSource();
		1557	String selection = "a.length";
		1558	int start = str.lastIndexOf(selection);
		1559	int length = selection.length();
		1560
		1561	IJavaElement[] elements = this.wc.codeSelect(start, length);
		1562	assertElementsEqual(
		1563	"Unexpected elements",
		1564	"length() [in String [in String.class [in java.lang [in "+ getExternalPath() + "jclMin1.8.jar]]]]",
		1565	elements
		1566	);
		1567	}
		1568	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		1569	public void test422468e() throws JavaModelException {
		1570	this.wc = getWorkingCopy(
		1571	"/Resolve/src/X.java",
		1572	"interface I {\n" +
		1573	" J foo(String x, String y);\n" +
		1574	"}\n" +
		1575	"interface J {\n" +
		1576	" K foo(String x, String y);\n" +
		1577	"}\n" +
		1578	"interface K {\n" +
		1579	" int foo(String x, int y);\n" +
		1580	"}\n" +
		1581	"public class X {\n" +
		1582	" static void goo(K i) {}\n" +
		1583	" public static void main(String[] args) {\n" +
		1584	" I i = (x, y) -> { return (a, b) -> (p, q) -> a.length(); };\n" +
		1585	" }\n" +
		1586	"}\n");
		1587
		1588	String str = this.wc.getSource();
		1589	String selection = "q";
		1590	int start = str.lastIndexOf(selection);
		1591	int length = selection.length();
		1592
		1593	IJavaElement[] elements = this.wc.codeSelect(start, length);
		1594	assertElementsEqual(
		1595	"Unexpected elements",
		1596	"q [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Resolve]]]]]]",
		1597	elements
		1598	);
		1599	}
1600	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
1601	public void testParser() throws JavaModelException {
1602	this.wc = getWorkingCopy(
1603	"/Resolve/src/X.java",
1604	"interface I {\n" +
1605	" int foo(String x, Integer y);\n" +
1606	"}\n" +
1607	"public class X {\n" +
1608	" public static void main(String[] args) {\n" +
1609	" I i = (x, y) -> {\n" +
1610	" x = \"Hello\"\n" +
1611	" y = 10; \n" +
1612	" if (x.length() > y) {\n" +
1613	" System.out.println(\"if\");\n" +
1614	" } else {\n" +
1615	" System.out.println(\"else\");\n" +
1616	" }\n" +
1617	" return x.length();\n" +
1618	" };\n" +
1619	" // System.out.println((I) (p, q) -> { return q.\n" +
1620	" }\n" +
1621	"}\n");
1622
1623	String str = this.wc.getSource();
1624	String selection = "x";
1625	int start = str.lastIndexOf(selection);
1626	int length = selection.length();
1627
1628	IJavaElement[] elements = this.wc.codeSelect(start, length);
1629	assertElementsEqual(
1630	"Unexpected elements",
1631	"x [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Resolve]]]]]]",
1632	elements
1633	);
1634	}
1534	}	1635	}

Lines 19-24 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Scanner.java (-5 / +109 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 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	}

Added Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/RunOnlyAssistTests18.java (+69 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.core.tests;
16
17	import java.lang.reflect.InvocationTargetException;
18	import java.lang.reflect.Method;
19
20	import junit.framework.Test;
21	import junit.framework.TestCase;
22	import junit.framework.TestSuite;
23
24	import org.eclipse.jdt.core.tests.compiler.parser.CompletionParserTest18;
25	import org.eclipse.jdt.core.tests.model.CompletionTests18;
26	import org.eclipse.jdt.core.tests.model.ResolveTests18;
27
28	public class RunOnlyAssistTests18 extends TestCase {
29
30	public RunOnlyAssistTests18(String name) {
31	super(name);
32	}
33	public static Class[] getAllTestClasses() {
34	return new Class[] {
35	ResolveTests18.class,
36	CompletionParserTest18.class,
37	CompletionTests18.class,
38	};
39	}
40
41	public static Test suite() {
42	TestSuite ts = new TestSuite(RunOnlyAssistTests18.class.getName());
43
44	Class[] testClasses = getAllTestClasses();
45	addTestsToSuite(ts, testClasses);
46	return ts;
47	}
48	public static void addTestsToSuite(TestSuite suite, Class[] testClasses) {
49
50	for (int i = 0; i < testClasses.length; i++) {
51	Class testClass = testClasses[i];
52	// call the suite() method and add the resulting suite to the suite
53	try {
54	Method suiteMethod = testClass.getDeclaredMethod("suite", new Class[0]); //$NON-NLS-1$
55	Test test = (Test)suiteMethod.invoke(null, new Object[0]);
56	suite.addTest(test);
57	} catch (IllegalAccessException e) {
58	e.printStackTrace();
59	} catch (InvocationTargetException e) {
60	e.getTargetException().printStackTrace();
61	} catch (NoSuchMethodException e) {
62	e.printStackTrace();
63	}
64	}
65	}
66	protected void tearDown() throws Exception {
67	super.tearDown();
68	}
69	}

Lines 115-126 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests18.java (-27 / +119 lines)
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-342 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",
338	"interface I {\n" +	338	"interface I {\n" +
339	" String foo(String x, Integer i); \n" +	339	" String foo(X x, X i); \n" +
340	"} \n" +	340	"} \n" +
341	"public class X {\n" +	341	"public class X {\n" +
342	" static void goo(I i) {\n" +	342	" static void goo(I i) {\n" +
Lines 358-386 Link Here
358	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	358	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
359	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	359	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
360	assertResults(	360	assertResults(
361	"[POTENTIAL_METHOD_DECLARATION]{, LX;, ()V, , null, 14}\n" +	361	"goo[METHOD_REF]{goo(), LX;, (LI;)V, goo, (i), 24}\n" +
362	"abstract[KEYWORD]{abstract, null, null, abstract, null, 24}\n" +	362	"goo[METHOD_REF]{goo(), LX;, (Ljava.lang.String;)V, goo, (s), 24}\n" +
363	"class[KEYWORD]{class, null, null, class, null, 24}\n" +	363	"main[METHOD_REF]{main(), LX;, ([Ljava.lang.String;)V, main, (args), 24}\n" +
364	"enum[KEYWORD]{enum, null, null, enum, null, 24}\n" +	364	"clone[METHOD_REF]{clone(), Ljava.lang.Object;, ()Ljava.lang.Object;, clone, null, 35}\n" +
365	"final[KEYWORD]{final, null, null, final, null, 24}\n" +	365	"equals[METHOD_REF]{equals(), Ljava.lang.Object;, (Ljava.lang.Object;)Z, equals, (obj), 35}\n" +
366	"interface[KEYWORD]{interface, null, null, interface, null, 24}\n" +	366	"finalize[METHOD_REF]{finalize(), Ljava.lang.Object;, ()V, finalize, null, 35}\n" +
367	"native[KEYWORD]{native, null, null, native, null, 24}\n" +	367	"getClass[METHOD_REF]{getClass(), Ljava.lang.Object;, ()Ljava.lang.Class<+Ljava.lang.Object;>;, getClass, null, 35}\n" +
368	"private[KEYWORD]{private, null, null, private, null, 24}\n" +	368	"hashCode[METHOD_REF]{hashCode(), Ljava.lang.Object;, ()I, hashCode, null, 35}\n" +
369	"protected[KEYWORD]{protected, null, null, protected, null, 24}\n" +	369	"notify[METHOD_REF]{notify(), Ljava.lang.Object;, ()V, notify, null, 35}\n" +
370	"public[KEYWORD]{public, null, null, public, null, 24}\n" +	370	"notifyAll[METHOD_REF]{notifyAll(), Ljava.lang.Object;, ()V, notifyAll, null, 35}\n" +
371	"static[KEYWORD]{static, null, null, static, null, 24}\n" +	371	"toString[METHOD_REF]{toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 35}\n" +
372	"strictfp[KEYWORD]{strictfp, null, null, strictfp, null, 24}\n" +	372	"wait[METHOD_REF]{wait(), Ljava.lang.Object;, ()V, wait, null, 35}\n" +
373	"synchronized[KEYWORD]{synchronized, null, null, synchronized, null, 24}\n" +	373	"wait[METHOD_REF]{wait(), Ljava.lang.Object;, (J)V, wait, (millis), 35}\n" +
374	"transient[KEYWORD]{transient, null, null, transient, null, 24}\n" +	374	"wait[METHOD_REF]{wait(), Ljava.lang.Object;, (JI)V, wait, (millis, nanos), 35}",
375	"volatile[KEYWORD]{volatile, null, null, volatile, null, 24}\n" +
376	"I[TYPE_REF]{I, , LI;, null, null, 27}\n" +
377	"J[TYPE_REF]{J, , LJ;, null, null, 27}\n" +
378	"X[TYPE_REF]{X, , LX;, null, null, 27}\n" +
379	"clone[METHOD_DECLARATION]{protected Object clone() throws CloneNotSupportedException, Ljava.lang.Object;, ()Ljava.lang.Object;, clone, null, 27}\n" +
380	"equals[METHOD_DECLARATION]{public boolean equals(Object obj), Ljava.lang.Object;, (Ljava.lang.Object;)Z, equals, (obj), 27}\n" +
381	"finalize[METHOD_DECLARATION]{protected void finalize() throws Throwable, Ljava.lang.Object;, ()V, finalize, null, 27}\n" +
382	"hashCode[METHOD_DECLARATION]{public int hashCode(), Ljava.lang.Object;, ()I, hashCode, null, 27}\n" +
383	"toString[METHOD_DECLARATION]{public String toString(), Ljava.lang.Object;, ()Ljava.lang.String;, toString, null, 27}",
384	requestor.getResults());	375	requestor.getResults());
385	}	376	}
386	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422901, [1.8][code assist] Code assistant sensitive to scope.referenceContext type identity.	377	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422901, [1.8][code assist] Code assistant sensitive to scope.referenceContext type identity.
Lines 570-576 Link Here
570	" public static void main(String[] args) {\n" +	561	" public static void main(String[] args) {\n" +
571	" I i = () -> {\n" +	562	" I i = () -> {\n" +
572	" xyz\n" +	563	" xyz\n" +
573	" }\n" +	564	" }\n" +
574	" }\n" +	565	" }\n" +
575	"}\n");	566	"}\n");
576		567
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" +	588	" goo() {key=LX;.goo()LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
598	"}" , requestor.getContext());	589	"}" , requestor.getContext());
599	}	590	}
		591	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		592	public void test018() throws JavaModelException { // computing visible elements in lambda scope.
		593	this.workingCopies = new ICompilationUnit[1];
		594	this.workingCopies[0] = getWorkingCopy(
		595	"/Completion/src/X.java",
		596	"interface I {\n" +
		597	" void foo(String x);\n" +
		598	"}\n" +
		599	"public class X {\n" +
		600	" static X xField;\n" +
		601	" static X goo(String s) {\n" +
		602	" return null;\n" +
		603	" }\n" +
		604	" static void goo(I i) {\n" +
		605	" }\n" +
		606	" public static void main(String[] args) {\n" +
		607	" goo((xyz) -> {\n" +
		608	" System.out.println(xyz.);\n" +
		609	" });\n" +
		610	" }\n" +
		611	"}\n");
		612
		613	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, true, true, false);
		614	requestor.allowAllRequiredProposals();
		615	requestor.setRequireExtendedContext(true);
		616	requestor.setComputeEnclosingElement(false);
		617	requestor.setComputeVisibleElements(true);
		618	requestor.setAssignableType("LX;");
		619
		620	String str = this.workingCopies[0].getSource();
		621	String completeBehind = "xyz.";
		622	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		623	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		624	assertEquals("completion offset=233\n" +
		625	"completion range=[233, 232]\n" +
		626	"completion token=\"\"\n" +
		627	"completion token kind=TOKEN_KIND_NAME\n" +
		628	"expectedTypesSignatures=null\n" +
		629	"expectedTypesKeys=null\n" +
		630	"completion token location=UNKNOWN\n" +
		631	"visibleElements={\n" +
		632	" xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
		633	" goo(String) {key=LX;.goo(Ljava/lang/String;)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
		634	"}" , requestor.getContext());
		635	}
		636	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=422468, [1.8][assist] Code assist issues with type elided lambda parameters
		637	public void test018a() throws JavaModelException { // computing visible elements in lambda scope.
		638	this.workingCopies = new ICompilationUnit[1];
		639	this.workingCopies[0] = getWorkingCopy(
		640	"/Completion/src/X.java",
		641	"interface I {\n" +
		642	" void foo(X x);\n" +
		643	"}\n" +
		644	"public class X {\n" +
		645	" static X xField;\n" +
		646	" static X goo(String s) {\n" +
		647	" return null;\n" +
		648	" }\n" +
		649	" static void goo(I i) {\n" +
		650	" }\n" +
		651	" public static void main(String[] args) {\n" +
		652	" X xLocal = null;\n" +
		653	" args = null;\n" +
		654	" if (args != null) {\n" +
655	" xField = null;\n" +
656	" else \n" +
657	" xField = null;\n" +
658	" while (true);\n" +
659	" goo((xyz) -> {\n" +
660	" X xLambdaLocal = null;\n" +
661	" System.out.println(xyz.)\n" +
662	" });\n" +
663	" }\n" +
664	"}\n");
665
666	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, true, true, false);
667	requestor.allowAllRequiredProposals();
668	requestor.setRequireExtendedContext(true);
669	requestor.setComputeEnclosingElement(false);
670	requestor.setComputeVisibleElements(true);
671	requestor.setAssignableType("LX;");
672
673	String str = this.workingCopies[0].getSource();
674	String completeBehind = "xyz.";
675	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
676	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
677	assertEquals(
678	"completion offset=419\n" +
679	"completion range=[419, 418]\n" +
680	"completion token=\"\"\n" +
681	"completion token kind=TOKEN_KIND_NAME\n" +
682	"expectedTypesSignatures=null\n" +
683	"expectedTypesKeys=null\n" +
684	"completion token location=UNKNOWN\n" +
685	"visibleElements={\n" +
686	" xLocal [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]]],\n" +
687	" xLambdaLocal [in main(String[]) [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]]],\n" +
688	" xField {key=LX;.xField)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
689	" goo(String) {key=LX;.goo(Ljava/lang/String;)LX;} [in X [in [Working copy] X.java [in <default> [in src [in Completion]]]]],\n" +
690	"}" , requestor.getContext());
691	}
600	}	692	}

Lines 56-61 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionScanner.java (+10 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 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 71-94 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java (-17 / +66 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	private static final Block NO_BODY = new Block(0, true);
87	public LambdaExpression(CompilationResult compilationResult, boolean shouldUnelideTypes) {	87
		88	public LambdaExpression(CompilationResult compilationResult, boolean assistNode) {
88	super(compilationResult);	89	super(compilationResult);
89	this.shouldUnelideTypes = shouldUnelideTypes;	90	this.assistNode = assistNode;
90	setArguments(NO_ARGUMENTS);	91	setArguments(NO_ARGUMENTS);
91	setBody(new Block(0));	92	setBody(NO_BODY);
92	}	93	}
93		94
94	public void setArguments(Argument [] arguments) {	95	public void setArguments(Argument [] arguments) {
Lines 101-107 Link Here
101	}	102	}
102		103
103	public void setBody(Statement body) {	104	public void setBody(Statement body) {
104	this.body = body == null ? new Block(0) : body;	105	this.body = body == null ? NO_BODY : body;
105	}	106	}
106		107
107	public Statement body() {	108	public Statement body() {
Lines 110-115 Link Here
110		111
111	public void setArrowPosition(int arrowPosition) {	112	public void setArrowPosition(int arrowPosition) {
112	this.arrowPosition = arrowPosition;	113	this.arrowPosition = arrowPosition;
		114	}
		115
		116	public int getArrowPosition() {
		117	return this.arrowPosition;
113	}	118	}
114		119
115	protected FunctionalExpression original() {	120	protected FunctionalExpression original() {
Lines 188-194 Link Here
188		193
189	if (!haveDescriptor) {	194	if (!haveDescriptor) {
190	if (argumentsTypeElided) {	195	if (argumentsTypeElided) {
191	if (!this.shouldUnelideTypes)	196	if (!this.assistNode)
192	return null; // FUBAR, bail out...	197	return null; // FUBAR, bail out...
193	// for code assist ONLY, keep the sluice gate shut on bogus errors otherwise.	198	// for code assist ONLY, keep the sluice gate shut on bogus errors otherwise.
194	argumentsTypeElided = false;	199	argumentsTypeElided = false;
Lines 524-529 Link Here
524	return false;	529	return false;
525	}	530	}
526		531
		532	private void analyzeShape() { // simple minded analysis for code assist.
		533	class ShapeComputer extends ASTVisitor {
		534	public boolean visit(TypeDeclaration type, BlockScope skope) {
		535	return false;
		536	}
		537	public boolean visit(TypeDeclaration type, ClassScope skope) {
		538	return false;
		539	}
		540	public boolean visit(LambdaExpression type, BlockScope skope) {
		541	return false;
		542	}
		543	public boolean visit(ReturnStatement returnStatement, BlockScope skope) {
		544	if (returnStatement.expression != null) {
		545	LambdaExpression.this.valueCompatible = true;
		546	LambdaExpression.this.voidCompatible = false;
		547	} else {
		548	LambdaExpression.this.voidCompatible = true;
		549	LambdaExpression.this.valueCompatible = false;
		550	}
		551	return false;
		552	}
		553	}
		554	if (this.body instanceof Expression) {
		555	this.voidCompatible = ((Expression) this.body).statementExpression();
		556	this.valueCompatible = true;
		557	} else {
		558	// 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;
		559	this.voidCompatible = true;
		560	this.valueCompatible = true;
		561	this.body.traverse(new ShapeComputer(), null);
		562	}
		563	this.shapeAnalysisComplete = true;
		564	}
		565
527	public boolean isCompatibleWith(final TypeBinding left, final Scope someScope) {	566	public boolean isCompatibleWith(final TypeBinding left, final Scope someScope) {
528		567
529	final MethodBinding sam = left.getSingleAbstractMethod(this.enclosingScope);	568	final MethodBinding sam = left.getSingleAbstractMethod(this.enclosingScope);
Lines 540-547 Link Here
540	compilerOptions.isAnnotationBasedNullAnalysisEnabled = false;	579	compilerOptions.isAnnotationBasedNullAnalysisEnabled = false;
541	try {	580	try {
542	final LambdaExpression copy = copy();	581	final LambdaExpression copy = copy();
543	if (copy == null)	582	if (copy == null) {
544	return false;	583	if (this.assistNode) {
		584	analyzeShape(); // not on terra firma here !
		585	if (sam.returnType.id == TypeIds.T_void) {
		586	if (!this.voidCompatible)
		587	return false;
		588	} else {
		589	if (!this.valueCompatible)
		590	return false;
		591	}
		592	}
		593	return !isPertinentToApplicability(left);
		594	}
545	copy.setExpressionContext(this.expressionContext);	595	copy.setExpressionContext(this.expressionContext);
546	copy.setExpectedType(left);	596	copy.setExpectedType(left);
547	this.hasIgnoredMandatoryErrors = false;	597	this.hasIgnoredMandatoryErrors = false;
Lines 576-584 Link Here
576	}	626	}
577	}	627	}
578		628
579	if (!isPertinentToApplicability(left))	629	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;	630	return true;
581		631
582	if (sam.returnType.id == TypeIds.T_void) {	632	if (sam.returnType.id == TypeIds.T_void) {
583	if (!this.voidCompatible)	633	if (!this.voidCompatible)
584	return false;	634	return false;
Lines 586-593 Link Here
586	if (!this.valueCompatible)	636	if (!this.valueCompatible)
587	return false;	637	return false;
588	}	638	}
589		639	Expression [] returnExpressions = this.resultExpressions;
590	Expression [] returnExpressions = this.resultExpressions;
591	for (int i = 0, length = returnExpressions.length; i < length; i++) {	640	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	641	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))	642	if (!returnExpressions[i].isCompatibleWith(sam.returnType, this.enclosingScope))

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