Attachment #236207 for bug #408230

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

Lines 1-11 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/TypeResolveTests.java (-1 / +357 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2012 IBM Corporation and others.	2	* Copyright (c) 2000, 2013 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
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	*
		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.
7	*	11	*
8	* Contributors:	12	* Contributors:
9	* IBM Corporation - initial API and implementation	13	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	14	*******************************************************************************/
11	package org.eclipse.jdt.core.tests.model;	15	package org.eclipse.jdt.core.tests.model;
Lines 832-837 Link Here
832	}	836	}
833	finally {	837	finally {
834	deleteProject("Test342393");	838	deleteProject("Test342393");
835	}	839	}
836	}	840	}
		841	// Bug 408230 - [1.8][hovering] NPE on hovering over a type inferred parameter in lambda expression
		842	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=408230
		843	public void testBug408230a() throws CoreException {
		844	try {
		845	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
		846	String source = "package p;\n" +
		847	"public class X {\n" +
		848	" FI i1 = (a, barg) -> a+barg;\n" +
		849	"}\n" +
		850	"interface FI { int f1(int a, int b); }\n";
		851	createFolder("/P/src/p");
		852	createFile(
		853	"/P/src/p/X.java",
		854	source
		855	);
		856	waitForAutoBuild();
		857
		858	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
		859	String selectString = "barg";
		860	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
		861	assertEquals(1, variable.length);
		862	} finally {
		863	deleteProject("P");
		864	}
		865	}
		866	public void testBug408230b() throws CoreException {
		867	try {
		868	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
		869	String source = "package p;\n" +
		870	"public class X {\n" +
		871	" void foo() {\n" +
		872	" FI i2 = (a, barg) -> { return a+barg; };\n" +
		873	" }\n" +
		874	"}\n" +
		875	"interface FI { int f1(int a, int b); }\n";
		876	createFolder("/P/src/p");
		877	createFile(
		878	"/P/src/p/X.java",
		879	source
		880	);
		881	waitForAutoBuild();
		882
		883	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
		884	String selectString = "barg";
		885	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
		886	assertEquals(1, variable.length);
		887	} finally {
		888	deleteProject("P");
		889	}
		890	}
		891	public void testBug408230c() throws CoreException {
		892	try {
		893	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
		894	String source = "package p;\n" +
		895	"public class X {\n" +
		896	" void foo() {\n" +
		897	" FI i2 = (a, barg) -> { int x = 2; while (x < 2) { x++; } return a+barg; };\n" +
		898	" }\n" +
		899	"}\n" +
		900	"interface FI { int f1(int a, int b); }\n";
		901	createFolder("/P/src/p");
		902	createFile(
		903	"/P/src/p/X.java",
		904	source
905	);
906	waitForAutoBuild();
907
908	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
909	String selectString = "barg";
910	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
911	assertEquals(1, variable.length);
912	} finally {
913	deleteProject("P");
914	}
915	}
916	public void testBug408230d() throws CoreException {
917	try {
918	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
919	String source = "package p;\n" +
920	"public class X {\n" +
921	" FI i1 = (barg) -> ++barg;\n" +
922	"}\n" +
923	"interface FI { int f1(int b); }\n";
924	createFolder("/P/src/p");
925	createFile(
926	"/P/src/p/X.java",
927	source
928	);
929	waitForAutoBuild();
930
931	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
932	String selectString = "barg";
933	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
934	assertEquals(1, variable.length);
935	} finally {
936	deleteProject("P");
937	}
938	}
939	public void testBug408230e() throws CoreException {
940	try {
941	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
942	String source = "package p;\n" +
943	"public class X {\n" +
944	" FI i1 = (aarg) -> { return aarg++;};\n" +
945	"}\n" +
946	"interface FI { int f1(int a); }\n";
947	createFolder("/P/src/p");
948	createFile(
949	"/P/src/p/X.java",
950	source
951	);
952	waitForAutoBuild();
953
954	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
955	String selectString = "aarg";
956	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
957	assertEquals(1, variable.length);
958	} finally {
959	deleteProject("P");
960	}
961	}
962	public void testBug408230f() throws CoreException {
963	try {
964	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
965	String source = "package p;\n" +
966	"public class X {\n" +
967	" FI i1 = (aarg) -> { int x = aarg; return aarg++;};\n" +
968	"}\n" +
969	"interface FI { int f1(int a); }\n";
970	createFolder("/P/src/p");
971	createFile(
972	"/P/src/p/X.java",
973	source
974	);
975	waitForAutoBuild();
976
977	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
978	String selectString = "aarg";
979	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
980	assertEquals(1, variable.length);
981	} finally {
982	deleteProject("P");
983	}
984	}
985	public void testBug408230g() throws CoreException {
986	try {
987	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
988	String source = "package p;\n" +
989	"public class X {\n" +
990	" public void boo(FI fi) {}\n" +
991	" void foo() {\n" +
992	" boo((aarg) -> aarg++);\n" +
993	" }\n" +
994	"}\n" +
995	"interface FI { int f1(int a); }\n";
996	createFolder("/P/src/p");
997	createFile(
998	"/P/src/p/X.java",
999	source
1000	);
1001	waitForAutoBuild();
1002
1003	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1004	String selectString = "aarg";
1005	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1006	assertEquals(1, variable.length);
1007	} finally {
1008	deleteProject("P");
1009	}
1010	}
1011	public void testBug408230h() throws CoreException {
1012	try {
1013	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
1014	String source = "package p;\n" +
1015	"public class X {\n" +
1016	" public void boo(FI fi) {}\n" +
1017	" void foo() {\n" +
1018	" boo((aarg) -> {int b = 10; return aarg++;});\n" +
1019	" }\n" +
1020	"}\n" +
1021	"interface FI { int f1(int a); }\n";
1022	createFolder("/P/src/p");
1023	createFile(
1024	"/P/src/p/X.java",
1025	source
1026	);
1027	waitForAutoBuild();
1028
1029	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1030	String selectString = "aarg";
1031	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1032	assertEquals(1, variable.length);
1033	} finally {
1034	deleteProject("P");
1035	}
1036	}
1037	public void testBug408230i() throws CoreException {
1038	try {
1039	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
1040	String source = "package p;\n" +
1041	"public class X {\n" +
1042	" public void boo(FI fi) {}\n" +
1043	" void foo() {\n" +
1044	" boo((aarg, x) -> x + aarg++);\n" +
1045	" }\n" +
1046	"}\n" +
1047	"interface FI { int f1(int a, int b); }\n";
1048	createFolder("/P/src/p");
1049	createFile(
1050	"/P/src/p/X.java",
1051	source
1052	);
1053	waitForAutoBuild();
1054
1055	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1056	String selectString = "aarg";
1057	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1058	assertEquals(1, variable.length);
1059	} finally {
1060	deleteProject("P");
1061	}
1062	}
1063	public void testBug408230j() throws CoreException {
1064	try {
1065	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
1066	String source = "package p;\n" +
1067	"public class X {\n" +
1068	" public void boo(FI fi) {}\n" +
1069	" void foo() {\n" +
1070	" boo((aarg, x) -> {int b = 10; return x + aarg++;});\n" +
1071	" }\n" +
1072	"}\n" +
1073	"interface FI { int f1(int a, int b); }\n";
1074	createFolder("/P/src/p");
1075	createFile(
1076	"/P/src/p/X.java",
1077	source
1078	);
1079	waitForAutoBuild();
1080
1081	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1082	String selectString = "aarg";
1083	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1084	assertEquals(1, variable.length);
1085	} finally {
1086	deleteProject("P");
1087	}
1088	}
1089	public void testBug408230k() throws CoreException {
1090	try {
1091	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
1092	String source = "package p;\n" +
1093	"public class X {\n" +
1094	" public void boo(int x, int y, FI fi) {}\n" +
1095	" void foo() {\n" +
1096	" boo(2, 4, (aarg) -> aarg++);\n" +
1097	" }\n" +
1098	"}\n" +
1099	"interface FI { int f1(int a); }\n";
1100	createFolder("/P/src/p");
1101	createFile(
1102	"/P/src/p/X.java",
1103	source
1104	);
1105	waitForAutoBuild();
1106
1107	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1108	String selectString = "aarg";
1109	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1110	assertEquals(1, variable.length);
1111	} finally {
1112	deleteProject("P");
1113	}
1114	}
1115	public void testBug408230l() throws CoreException {
1116	try {
1117	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
1118	String source = "package p;\n" +
1119	"public class X {\n" +
1120	" public void boo(int x, FI fi) {}\n" +
1121	" void foo() {\n" +
1122	" boo(2, (aarg) -> {int b = 10; return aarg++;});\n" +
1123	" }\n" +
1124	"}\n" +
1125	"interface FI { int f1(int a); }\n";
1126	createFolder("/P/src/p");
1127	createFile(
1128	"/P/src/p/X.java",
1129	source
1130	);
1131	waitForAutoBuild();
1132
1133	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1134	String selectString = "aarg";
1135	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1136	assertEquals(1, variable.length);
1137	} finally {
1138	deleteProject("P");
1139	}
1140	}
1141	public void testBug408230m() throws CoreException {
1142	try {
1143	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
1144	String source = "package p;\n" +
1145	"public class X {\n" +
1146	" public void boo(int x, int y, FI fi) {}\n" +
1147	" void foo() {\n" +
1148	" boo(2, 5+6, (aarg, x) -> x + aarg++);\n" +
1149	" }\n" +
1150	"}\n" +
1151	"interface FI { int f1(int a, int b); }\n";
1152	createFolder("/P/src/p");
1153	createFile(
1154	"/P/src/p/X.java",
1155	source
1156	);
1157	waitForAutoBuild();
1158
1159	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1160	String selectString = "aarg";
1161	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1162	assertEquals(1, variable.length);
1163	} finally {
1164	deleteProject("P");
1165	}
1166	}
1167	public void testBug408230n() throws CoreException {
1168	try {
1169	createJavaProject("P", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8");
1170	String source = "package p;\n" +
1171	"public class X {\n" +
1172	" public void boo(int x, FI fi) {}\n" +
1173	" void foo() {\n" +
1174	" boo(2, (aarg, x) -> {int b = 10; return x + aarg++;});\n" +
1175	" }\n" +
1176	"}\n" +
1177	"interface FI { int f1(int a, int b); }\n";
1178	createFolder("/P/src/p");
1179	createFile(
1180	"/P/src/p/X.java",
1181	source
1182	);
1183	waitForAutoBuild();
1184
1185	ICompilationUnit unit = getCompilationUnit("/P/src/p/X.java");
1186	String selectString = "aarg";
1187	IJavaElement [] variable = ((ICodeAssist) unit).codeSelect(source.lastIndexOf(selectString), selectString.length());
1188	assertEquals(1, variable.length);
1189	} finally {
1190	deleteProject("P");
1191	}
1192	}
837	}	1193	}

Lines 1095-1105 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (-1 / +1 lines)
1095	int instanceOfIndex = lastIndexOfElement(K_BETWEEN_INSTANCEOF_AND_RPAREN);	1095	int instanceOfIndex = lastIndexOfElement(K_BETWEEN_INSTANCEOF_AND_RPAREN);
1096	index = blockIndex != -1 && instanceOfIndex < blockIndex ? blockIndex : instanceOfIndex;	1096	index = blockIndex != -1 && instanceOfIndex < blockIndex ? blockIndex : instanceOfIndex;
1097	}	1097	}
1098	while (index >= 0) {	1098	while (index >= 0) {
1099	// Try to find an enclosing if statement even if one is not found immediately preceding the completion node.	1099	// Try to find an enclosing if statement even if one is not found immediately preceding the completion node.
1100	if (index != -1 && this.elementInfoStack[index] == IF && this.elementObjectInfoStack[index] != null) {	1100	if (index != -1 && this.elementInfoStack[index] == IF && this.elementObjectInfoStack[index] != null && !(this.elementObjectInfoStack[index] instanceof Integer)) {
1101	Expression condition = (Expression)this.elementObjectInfoStack[index];	1101	Expression condition = (Expression)this.elementObjectInfoStack[index];
1102		1102
1103	// If currentElement is a RecoveredLocalVariable then it can be contained in the if statement	1103	// If currentElement is a RecoveredLocalVariable then it can be contained in the if statement
1104	if (this.currentElement instanceof RecoveredLocalVariable &&	1104	if (this.currentElement instanceof RecoveredLocalVariable &&
1105	this.currentElement.parent instanceof RecoveredBlock) {	1105	this.currentElement.parent instanceof RecoveredBlock) {




/*
 * Parser extension for code assist task
 *
 */

import org.eclipse.jdt.internal.codeassist.select.SelectionOnSingleNameReference;
import org.eclipse.jdt.internal.compiler.ast.*;
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.Parser;

	protected static final int K_TYPE_DELIMITER = ASSIST_PARSER + 2; // whether we are inside a type declaration
	protected static final int K_METHOD_DELIMITER = ASSIST_PARSER + 3; // whether we are inside a method declaration
	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_INSIDE_LAMBDA_EXPRESSION = ASSIST_PARSER + 7; // whether we are inside a field initializer

	// selector constants
	protected static final int THIS_CONSTRUCTOR = -1;
	protected static final int SUPER_CONSTRUCTOR = -2;


				block.sourceStart = lastStart = -this.blockStarts[j];
				element = element.add(block, 1);
			}
			blockIndex = j+1; // shift the index to the new block
		}
		if (node instanceof Argument && ((Argument)node).hasElidedType()){
			Argument local = (Argument) node;
			if (local.declarationSourceEnd == 0){
				element = element.add(local, 0);
				if (local.initialization == null){
					this.lastCheckPoint = local.sourceEnd + 1;
				} else {
					this.lastCheckPoint = local.initialization.sourceEnd + 1;
				}
			} else {
				element = element.add(local, 0);
				this.lastCheckPoint = local.declarationSourceEnd + 1;
			}
			while (i <= this.astPtr && this.astStack[i+1] instanceof Argument && ((Argument)this.astStack[i+1]).hasElidedType()) {
				i++;
			}
			continue;
		} else if (node instanceof LocalDeclaration){
			LocalDeclaration local = (LocalDeclaration) node;
			if (local.declarationSourceEnd == 0){
				element = element.add(local, 0);
				if (local.initialization == null){
					this.lastCheckPoint = local.sourceEnd + 1;

		switch (token) {
			case TokenNameLPAREN :
				this.bracketDepth++;
				switch (this.previousToken) {
					case TokenNameIdentifier:
						this.pushOnElementStack(K_SELECTOR, this.identifierPtr, new Integer(this.expressionPtr));
						break;
					case TokenNamethis: // explicit constructor invocation, e.g. this(1, 2)
						this.pushOnElementStack(K_SELECTOR, THIS_CONSTRUCTOR, new Integer(this.expressionPtr));
						break;
					case TokenNamesuper: // explicit constructor invocation, e.g. super(1, 2)
						this.pushOnElementStack(K_SELECTOR, SUPER_CONSTRUCTOR, new Integer(this.expressionPtr));
						break;
					case TokenNameGREATER: // explicit constructor invocation, e.g. Fred<X>[(]1, 2)
					case TokenNameRIGHT_SHIFT: // or fred<X<X>>[(]1, 2)
					case TokenNameUNSIGNED_RIGHT_SHIFT: //or Fred<X<X<X>>>[(]1, 2)
						if(this.identifierPtr > -1) {

		}
	}
	this.previousToken = token;
	if (token == TokenNameIdentifier) {
		this.previousIdentifierPtr = this.identifierPtr;
	} else if (token == TokenNameBeginLambda) {
		pushOnElementStack(K_INSIDE_LAMBDA_EXPRESSION, this.expressionPtr);
	}
}
protected void consumeTypeImportOnDemandDeclarationName() {
	// TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
	/* push an ImportRef build from the last name

	return null;
}
protected Object topKnownElementObjectInfo(int owner) {
	return topKnownElementObjectInfo(owner, 0);
}
protected void consumeLambdaExpression() {
	super.consumeLambdaExpression();
	popUntilElement(K_INSIDE_LAMBDA_EXPRESSION);
}
/**
 * If the given ast node is inside an explicit constructor call
 * then wrap it with a fake constructor call.
 * Returns the wrapped completion node or the completion node itself.
 */

		return call;
	} else {
		return ast;
	}
}
public MessageSend collectLambdaExpressionInformationFromParserWithoutDisturbingStacks () {
	if(this.expressionPtr >= 0 && this.expressionStack[this.expressionPtr] instanceof SelectionOnSingleNameReference) {
		int argumentsRoof = this.elementInfoStack[lastIndexOfElement(K_INSIDE_LAMBDA_EXPRESSION)];
		if (topKnownElementKind(ASSIST_PARSER) == K_SELECTOR || topKnownElementKind(ASSIST_PARSER, 1) == K_SELECTOR || topKnownElementKind(ASSIST_PARSER, 2) == K_SELECTOR) {
			int argumentsFloor = ((Integer)this.elementObjectInfoStack[lastIndexOfElement(K_SELECTOR)]).intValue();
			MessageSend sentMessage = new MessageSend();
			sentMessage.selector = this.identifierStack[this.identifierPtr];
			if (this.expressionPtr > argumentsFloor && argumentsFloor <= argumentsRoof) {
				int noOfSeenArguments = argumentsRoof - argumentsFloor;
				if (noOfSeenArguments > 0) {
					System.arraycopy(this.expressionStack, argumentsFloor + 1, sentMessage.arguments = new Expression[noOfSeenArguments], 0, noOfSeenArguments);
				}
				this.expressionPtr = argumentsFloor;
			}
			return sentMessage;
		}
	}
	return null;
}
public LambdaExpression collectLambdaExpressionInformation () {
	ASTNode arg;
	if(this.expressionPtr >= 0 && this.expressionStack[this.expressionPtr] instanceof SelectionOnSingleNameReference) {
		Argument [] arguments = ASTNode.NO_ARGUMENTS;
		if (this.astPtr >= 0 && this.astStack[this.astPtr] instanceof Argument) {
			arguments = new Argument[this.astLengthStack[this.astLengthPtr]];
			int k;
			for (int i = k = this.astPtr + 1 - this.astLengthStack[this.astLengthPtr], j = this.astPtr; i <= j && (arg = this.astStack[i]) instanceof Argument; i++) {
				arguments[i - k] = (Argument)arg;
			}

		}
		LambdaExpression lExp;
		int argumentsRoof = this.elementInfoStack[lastIndexOfElement(K_INSIDE_LAMBDA_EXPRESSION)];
		popElement(K_INSIDE_LAMBDA_EXPRESSION);
		lExp = new LambdaExpression(this.compilationUnit.compilationResult, arguments, this.expressionStack[this.expressionPtr--]);
		this.expressionLengthPtr--;
		if (topKnownElementKind(ASSIST_PARSER) == K_SELECTOR) {
			int argumentsFloor = ((Integer)this.elementObjectInfoStack[lastIndexOfElement(K_SELECTOR)]).intValue();
			lExp.sentMessage = new MessageSend();
			lExp.sentMessage.selector = this.identifierStack[this.identifierPtr];
			if (this.expressionPtr > argumentsFloor && argumentsFloor <= argumentsRoof) {
				int noOfSeenArguments = argumentsRoof - argumentsFloor;
				if (noOfSeenArguments > 0) {
					System.arraycopy(this.expressionStack, argumentsFloor + 1, lExp.sentMessage.arguments = new Expression[noOfSeenArguments], 0, noOfSeenArguments);
				}
				this.expressionPtr = argumentsFloor;
				this.expressionLengthPtr--;
			}
		}
		return lExp;
	}
	return null;
}
public Argument [] getLambdaArgumentsOnwards (Argument arg) {
	boolean started = false;
	ASTNode [] nodeStack = this.astStack;
	Argument [] lArgs = null;
	for (int i = 0, j = this.astPtr; i <= j; i++) {
		if (started) {
			if( nodeStack[i] instanceof Argument && ((Argument)nodeStack[i]).hasElidedType()) {
				if (lArgs == null) {
					lArgs = new Argument[1];
				} else {
					int len = lArgs.length;
					System.arraycopy(lArgs, 0, lArgs = new Argument[len + 1], 0, len);
				}
				lArgs[lArgs.length - 1] = (Argument)nodeStack[i];
			} else {
				return lArgs;
			}
		}
		if (nodeStack[i] == arg) {
			started = true;
		}
	}
	return lArgs;
}
}




 */

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.core.compiler.CharOperation;
import org.eclipse.jdt.internal.codeassist.impl.*;
import org.eclipse.jdt.internal.compiler.ast.*;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;

					cast.sourceStart = castType.sourceStart;
					cast.sourceEnd= expression.sourceEnd;
					parentNode = cast;
					this.assistNodeParent = parentNode;
				}
				break nextElement;
			case K_INSIDE_LAMBDA_EXPRESSION :
				this.assistNodeParent = parentNode = collectLambdaExpressionInformation();
				break nextElement;
		}
	}
	if(parentNode != null) {
		this.currentElement = this.currentElement.add((Statement)parentNode, 0);

		this action is also performed when shifting token after recovery
		got activated once.
	*/
	recoveryTokenCheck();
}
protected void consumeTypeElidedLambdaParameter(boolean parenthesized) {
	if (this.astPtr > -1 && this.astStack[this.astPtr] instanceof LocalDeclaration) {
		this.astStack[this.astPtr].bits |= ASTNode.IsInitializedByLamdaExpression;
	}
	super.consumeTypeElidedLambdaParameter(parenthesized);
}

public  String toString() {
	String s = Util.EMPTY_STRING;
	s = s + "elementKindStack : int[] = {"; //$NON-NLS-1$
	for (int i = 0; i <= this.elementPtr; i++) {




	public final static int Bit3 = 0x4;					// return type (operator) | name reference kind (name ref) | implicit this (this ref) | is argument(local)
	public final static int Bit4 = 0x8;					// return type (operator) | first assignment to local (name ref,local decl) | undocumented empty block (block, type and method decl)
	public final static int Bit5 = 0x10;					// value for return (expression) | has all method bodies (unit) | supertype ref (type ref) | resolved (field decl)
	public final static int Bit6 = 0x20;					// depth (name ref, msg) | ignore need cast check (cast expression) | error in signature (method declaration/ initializer) | is recovered (annotation reference)
	public final static int Bit7 = 0x40;					// depth (name ref, msg) | operator (operator) | need runtime checkcast (cast expression) | label used (labelStatement) | needFreeReturn (AbstractMethodDeclaration)
	public final static int Bit8 = 0x80;					// depth (name ref, msg) | operator (operator) | unsafe cast (cast expression) | is default constructor (constructor declaration) | isElseStatementUnreachable (if statement) | IsInitializedByLambdaExpression (local declaration)
	public final static int Bit9 = 0x100;				// depth (name ref, msg) | operator (operator) | is local type (type decl) | isThenStatementUnreachable (if statement) | can be static
	public final static int Bit10= 0x200;				// depth (name ref, msg) | operator (operator) | is anonymous type (type decl)
	public final static int Bit11 = 0x400;				// depth (name ref, msg) | operator (operator) | is member type (type decl)
	public final static int Bit12 = 0x800;				// depth (name ref, msg) | operator (operator) | has abstract methods (type decl)
	public final static int Bit13 = 0x1000;			// depth (name ref, msg) | is secondary type (type decl)

	public static final int IsTypeElided = Bit2;  // type elided lambda argument.
	public static final int IsArgument = Bit3;
	public static final int IsLocalDeclarationReachable = Bit31;
	public static final int IsForeachElementVariable = Bit5;
	public static final int ShadowsOuterLocal = Bit22;
	public static final int IsInitializedByLamdaExpression = Bit8;

	// for name refs or local decls
	public static final int FirstAssignmentToLocal = Bit4;

	// for msg or field references




import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;

	private LambdaExpression original = this;
	private SyntheticArgumentBinding[] outerLocalVariables = NO_SYNTHETIC_ARGUMENTS;
	private int outerLocalVariablesSlotSize = 0;
	public boolean shouldCaptureInstance = false;
	private static final SyntheticArgumentBinding [] NO_SYNTHETIC_ARGUMENTS = new SyntheticArgumentBinding[0];
	public MessageSend sentMessage = null;
	
	public LambdaExpression(CompilationResult compilationResult, Argument [] arguments, Statement body) {
		super(compilationResult);
		this.arguments = arguments != null ? arguments : ASTNode.NO_ARGUMENTS;
		this.body = body;

				currentScope.problemReporter().lambdaExpressionCannotImplementGenericMethod(this, sam);
			return false;
		}
		return super.kosherDescriptor(currentScope, sam, shouldChatter);
	}

	private void handleSelectionNode (BlockScope blockScope) {
		final int smallQSize = 10;
		MessageSend msgSend = this.sentMessage;
		ReferenceBinding [] typeArray = new ReferenceBinding[smallQSize];
		int typeArrayIndx = 0, typeArrayMax = 0;
		typeArray[0] = this.scope.classScope().enclosingReceiverType();
		do {
			if (!typeArray[typeArrayIndx].compoundName.equals(JAVA_LANG_OBJECT)) {
				MethodBinding [] methods = typeArray[typeArrayIndx].methods();
				for (int i = 0, j = methods.length, noOfArgsSeen = msgSend.arguments == null ? 0 : msgSend.arguments.length; i < j; i++) {
					TypeBinding [] params = null;
					if (methods[i].selector.equals(msgSend.selector) && (params = methods[i].parameters) != null && params.length > noOfArgsSeen && (this.descriptor = params[noOfArgsSeen].getSingleAbstractMethod(blockScope)) != null) {
						this.expectedType = this.resolvedType = params[noOfArgsSeen];
						i = j;
					}
				}
				if (this.descriptor == null) {
					ReferenceBinding sc = null;
					ReferenceBinding [] si = null;
					if (typeArray[typeArrayIndx] instanceof SourceTypeBinding) {
						sc = ((SourceTypeBinding)typeArray[typeArrayIndx]).superclass();
						si = ((SourceTypeBinding)typeArray[typeArrayIndx]).superInterfaces();
					} else if (typeArray[typeArrayIndx] instanceof BinaryTypeBinding) {
						sc = ((BinaryTypeBinding)typeArray[typeArrayIndx]).superclass();
						si = ((BinaryTypeBinding)typeArray[typeArrayIndx]).superInterfaces();
					}
					int additionalLength = (si == null ? 0 : si.length) + (sc == null ? 0 : 1);
					if (typeArrayMax + 1 + additionalLength > typeArray.length) {
						System.arraycopy(typeArray, typeArrayIndx + 1, 
								typeArrayMax - typeArrayIndx + 1 + additionalLength <= typeArray.length ? 
										typeArray : (typeArray = new ReferenceBinding[typeArrayMax - typeArrayIndx + (additionalLength > smallQSize ? additionalLength : smallQSize)]), 
								0, typeArrayMax - typeArrayIndx);
						typeArrayMax -= (typeArrayIndx + 1);
						typeArrayIndx = -1;
					}
					if (sc != null){
						typeArray[++typeArrayMax] = sc;
					}
					if (si != null && si.length > 0) {
						System.arraycopy(si, 0, typeArray, ++typeArrayMax, si.length);
						typeArrayMax += si.length - 1;
					}
				}
				typeArrayIndx++;
			}
		} while (this.descriptor == null && typeArrayIndx <= typeArrayMax);
	}

	/* This code is arranged so that we can continue with as much analysis as possible while avoiding 
	 * mine fields that would result in a slew of spurious messages. This method is a merger of:
	 * @see org.eclipse.jdt.internal.compiler.lookup.MethodScope.createMethod(AbstractMethodDeclaration)
	 * @see org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding.resolveTypesFor(MethodBinding)
	 * @see org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolve(ClassScope)

		final boolean haveDescriptor = this.descriptor != null;
		
		if (haveDescriptor && this.descriptor.typeVariables != Binding.NO_TYPE_VARIABLES) // already complained in kosher*
			return null;
		
		if (!haveDescriptor && argumentsTypeElided) {
			if (this.sentMessage == null) {
				return null; // FUBAR, bail out...
			}
			handleSelectionNode(blockScope);
		}

		this.binding = new MethodBinding(ClassFileConstants.AccPrivate | ClassFileConstants.AccSynthetic | ExtraCompilerModifiers.AccUnresolved,
							TypeConstants.ANONYMOUS_METHOD, // will be fixed up later.
							haveDescriptor ? this.descriptor.returnType : null, 
							Binding.NO_PARAMETERS, // for now. 

					buggyArguments = true;
				}
			}
			
			TypeBinding parameterType;
			final TypeBinding expectedParameterType = this.descriptor != null && i < this.descriptor.parameters.length ? this.descriptor.parameters[i] : null;
			parameterType = argumentsTypeElided ? expectedParameterType : argument.type.resolveType(this.scope, true /* check bounds*/);
			if (parameterType == null) {
				buggyArguments = true;
			} else if (parameterType == TypeBinding.VOID) {
				this.scope.problemReporter().argumentTypeCannotBeVoid(this, argument);




/*******************************************************************************
 * Copyright (c) 2000, 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.core.compiler.*;
import org.eclipse.jdt.internal.codeassist.impl.AssistParser;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Block;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;


	public Block blockDeclaration;
	public RecoveredStatement[] statements;
	public int statementCount;
	public boolean preserveContent = false;
	public RecoveredLocalVariable [] pendingArguments = null;

	int pendingModifiers;
	int pendingModifersSourceStart = -1;
	RecoveredAnnotation[] pendingAnnotations;
	int pendingAnnotationCount;

			return this; // ignore this element
		}
	}
	return super.add(methodDeclaration, bracketBalanceValue);
}
public void addPendingArgument(RecoveredLocalVariable pendingArg) {
	if (this.pendingArguments == null) {
		RecoveredLocalVariable recoveredLocalVariable [] = {pendingArg};
		this.pendingArguments = recoveredLocalVariable;
	}
	else {
		int length = this.pendingArguments.length;
		System.arraycopy(this.pendingArguments, 0, this.pendingArguments = new RecoveredLocalVariable[length+1], 0, length);
		this.pendingArguments[length] = pendingArg;
	}
}
/*
 * Record a nested block declaration
 */
public RecoveredElement add(Block nestedBlockDeclaration, int bracketBalanceValue) {
	resetPendingModifiers();

	}

	RecoveredBlock element = new RecoveredBlock(nestedBlockDeclaration, this, bracketBalanceValue);

	// if we have a pending Argument, promote it into the new block
	if (this.pendingArguments != null) {
		for (int indx = 0; indx < this.pendingArguments.length; indx++) {
			element.attach(this.pendingArguments[indx]);			
		}
		this.pendingArguments = null;
	}
	if(parser().statementRecoveryActivated) {
		addBlockStatement(element);
	}
	attach(element);

				this.pendingModifersSourceStart);
	}
	resetPendingModifiers();

	if (localDeclaration instanceof Argument){
		if (((Argument)localDeclaration).hasElidedType()) {
			RecoveredLambdaExpression rLexp = new RecoveredLambdaExpression(new Block(0), this, bracketBalanceValue);
			Parser currParser = parser();
			if (currParser instanceof AssistParser) {
				AssistParser aParser = (AssistParser)currParser;
				rLexp.sentMessage = aParser.collectLambdaExpressionInformationFromParserWithoutDisturbingStacks();
				rLexp.insertLambdaArgument((Argument)localDeclaration);
				rLexp.insertLambdaArgument(aParser.getLambdaArgumentsOnwards((Argument)localDeclaration));
			}
			attach(rLexp);
			return rLexp;
		}
		addPendingArgument(element);
		return this;
	}

	attach(element);
	if (localDeclaration.declarationSourceEnd == 0) return element;

	return result.toString();
}
/*
 * Rebuild a block from the nested structure which is in scope
 */
public Block updatedBlock(int depth, Set knownTypes) {
	return updatedBlock(depth, knownTypes, false);
}
public Block updatedBlock(int depth, Set knownTypes, boolean lambdaExpressionExpected) {

	// if block was not marked to be preserved or empty, then ignore it
	if (!this.preserveContent || this.statementCount == 0) return null;

	Statement[] updatedStatements = new Statement[this.statementCount];


	int lastEnd = this.blockDeclaration.sourceStart;

	// only collect the non-null updated statements
	for (int i = 0; i < this.statementCount; i++){
		boolean lambdaExprInit = i > 0 && lambdaExpressionInitializable(this.statements[i-1]);
		Statement updatedStatement = this.statements[i].updatedStatement(depth, knownTypes, lambdaExprInit);
		if (updatedStatement != null){
			LambdaExpression lambdaExpr = getLambdaExpression(updatedStatement);
			if (lambdaExprInit && lambdaExpr != null) {
				((LocalDeclaration)updatedStatements[updatedCount-1]).initialization = lambdaExpr;
			}
			else {
				updatedStatements[updatedCount++] = updatedStatement;
			}

			if (updatedStatement instanceof LocalDeclaration) {
				LocalDeclaration localDeclaration = (LocalDeclaration) updatedStatement;
				if(localDeclaration.declarationSourceEnd > lastEnd) {
					lastEnd = localDeclaration.declarationSourceEnd;

	// resize statement collection if necessary
	if (updatedCount != this.statementCount){
		this.blockDeclaration.statements = new Statement[updatedCount];
		System.arraycopy(updatedStatements, 0, this.blockDeclaration.statements, 0, updatedCount);
	} else {
		LambdaExpression lambda = null;
		if (lambdaExpressionExpected && !(updatedStatements[0] instanceof LambdaExpression) && (lambda = canGetLambdaExpression(updatedStatements, updatedCount)) != null) {
			Statement [] stmt = {lambda};
			this.blockDeclaration.statements = stmt;
		}
		else {
			this.blockDeclaration.statements = updatedStatements;
		}
	}

	if (this.blockDeclaration.sourceEnd == 0) {
		if(lastEnd < bodyEndValue) {
			this.blockDeclaration.sourceEnd = bodyEndValue;

		}
	}

	return this.blockDeclaration;
}
public LambdaExpression getLambdaExpression (Statement stmnt) {
	if (stmnt instanceof LambdaExpression) {
		return (LambdaExpression)stmnt;
	}
	else if (stmnt instanceof Block && ((Block)stmnt).statements[0] instanceof LambdaExpression) {
		return (LambdaExpression)((Block)stmnt).statements[0];
	}
	return null;
}
public LambdaExpression canGetLambdaExpression (Statement [] statementsArray, int count) {
	for (int indx = 0; indx < count - 1; indx++) {
		if (!(statementsArray[indx] instanceof Argument)) {
			return null;
		}
	}
	Argument [] arguments = new Argument [count-1];
	System.arraycopy(statementsArray, 0, arguments, 0, count-1);
	return new LambdaExpression(parser().compilationUnit.compilationResult, arguments, statementsArray[count-1]);
}
/*
 * Rebuild a statement from the nested structure which is in scope
 */
public Statement updatedStatement(int depth, Set knownTypes){

	return updatedBlock(depth, knownTypes);
}
public Statement updatedStatement(int depth, Set knownTypes, boolean lambdaExpressionExpected) {

	return lambdaExpressionExpected ? updatedBlock(depth, knownTypes, true) : updatedStatement(depth, knownTypes);
}
boolean lambdaExpressionInitializable(RecoveredStatement stmnt) {
	if (stmnt instanceof RecoveredLocalVariable) {
		RecoveredLocalVariable recLocVar = (RecoveredLocalVariable) stmnt;
		return recLocVar.localDeclaration != null && (recLocVar.localDeclaration.bits & ASTNode.IsInitializedByLamdaExpression) != 0;
	}
	return false;
}
/*
 * A closing brace got consumed, might have closed the current element,
 * in which case both the currentElement is exited
 */
public RecoveredElement updateOnClosingBrace(int braceStart, int braceEnd){




/*******************************************************************************
 * Copyright (c) 2000, 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.Set;

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

public class RecoveredLambdaExpression extends RecoveredBlock {
	
	public Argument [] lambdaArguments = null;
	public MessageSend sentMessage = null;

	public RecoveredLambdaExpression(Block block, RecoveredElement parent, int bracketBalance) {
		super(block, parent, bracketBalance);
	}

	public void insertLambdaArgument (Argument arg) {
		if (this.lambdaArguments == null) {
			(this.lambdaArguments = new Argument[1])[0] = arg;
		} else {
			int len;
			System.arraycopy(this.lambdaArguments, 0, this.lambdaArguments = new Argument[(len = this.lambdaArguments.length) + 1], 0, len);
			this.lambdaArguments[len] = arg;
		}
	}
	
	public void insertLambdaArgument (Argument [] args) {
		if (args != null) {
			if (this.lambdaArguments == null) {
				this.lambdaArguments = args;
			} else {
				int len = this.lambdaArguments.length;
				System.arraycopy(this.lambdaArguments, 0, this.lambdaArguments = new Argument[len + args.length], 0, len);
				System.arraycopy(args, 0, this.lambdaArguments, len, args.length);
			}
		}
	}
	
	public Statement updatedStatement(int depth, Set knownTypes, boolean lambdaExpressionExpected) {
		return updatedBlock(depth, knownTypes, true);
	}
	
	public LambdaExpression canGetLambdaExpression (Statement [] statementsArray, int count) {
		if (statementsArray.length == 1 && this.lambdaArguments != null) {
			LambdaExpression lExp = new LambdaExpression(parser().compilationUnit.compilationResult, this.lambdaArguments, statementsArray[0]);
			lExp.sentMessage = this.sentMessage;
			return lExp;
		}
		return super.canGetLambdaExpression(statementsArray, count);
	}
	
	public String toString(int tab) {
		StringBuffer result = new StringBuffer(tabString(tab));
		result.append("Recovered Lambda Expression:\n"); //$NON-NLS-1$
		this.blockDeclaration.print(tab + 1, result);
		if (this.statements != null) {
			for (int i = 0; i < this.statementCount; i++) {
				result.append("\n"); //$NON-NLS-1$
				result.append(this.statements[i].toString(tab + 1));
			}
		}
		return result.toString();
	}

}

Lines 1-12 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/RecoveredStatement.java (-1 / +8 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2013 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
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	*******************************************************************************/	14	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.parser;	15	package org.eclipse.jdt.internal.compiler.parser;
12		16
Lines 42-51 Link Here
42	return tabString(tab) + "Recovered statement:\n" + this.statement.print(tab + 1, new StringBuffer(10)); //$NON-NLS-1$	46	return tabString(tab) + "Recovered statement:\n" + this.statement.print(tab + 1, new StringBuffer(10)); //$NON-NLS-1$
43	}	47	}
44	public Statement updatedStatement(int depth, Set knownTypes){	48	public Statement updatedStatement(int depth, Set knownTypes){
45	return this.statement;	49	return this.statement;
46	}	50	}
		51	public Statement updatedStatement(int depth, Set knownTypes, boolean lambdaExpressionExpected) {
		52	return updatedStatement(depth, knownTypes);
		53	}
47	public void updateParseTree(){	54	public void updateParseTree(){
48	updatedStatement(0, new HashSet());	55	updatedStatement(0, new HashSet());
49	}	56	}
50	/*	57	/*
51	* Update the declarationSourceEnd of the corresponding parse node	58	* Update the declarationSourceEnd of the corresponding parse node




/*******************************************************************************
 * Copyright (c) 2000, 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.core;


				new String(local.name),
				local.declarationSourceStart,
				local.declarationSourceEnd,
				local.sourceStart,
				local.sourceEnd,
				local.type == null ? Signature.createTypeSignature(local.binding.type.readableName(), false) : Util.typeSignature(local.type),
				local.annotations,
				local.modifiers,
				local.getKind() == AbstractVariableDeclaration.PARAMETER);
	}
	if (localVar != null) {

Return to bug 408230

Lines 17-26 Link Here

(-)a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistParser.java (-4 / +106 lines)
17	/*	17	/*
18	* Parser extension for code assist task	18	* Parser extension for code assist task
19	*	19	*
20	*/	20	*/
21		21
		22	import org.eclipse.jdt.internal.codeassist.select.SelectionOnSingleNameReference;
22	import org.eclipse.jdt.internal.compiler.ast.*;	23	import org.eclipse.jdt.internal.compiler.ast.*;
23	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	24	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
24	import org.eclipse.jdt.internal.compiler.lookup.Binding;	25	import org.eclipse.jdt.internal.compiler.lookup.Binding;
25	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;	26	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
26	import org.eclipse.jdt.internal.compiler.parser.Parser;	27	import org.eclipse.jdt.internal.compiler.parser.Parser;
Lines 70-79 Link Here
70	protected static final int K_TYPE_DELIMITER = ASSIST_PARSER + 2; // whether we are inside a type declaration	71	protected static final int K_TYPE_DELIMITER = ASSIST_PARSER + 2; // whether we are inside a type declaration
71	protected static final int K_METHOD_DELIMITER = ASSIST_PARSER + 3; // whether we are inside a method declaration	72	protected static final int K_METHOD_DELIMITER = ASSIST_PARSER + 3; // whether we are inside a method declaration
72	protected static final int K_FIELD_INITIALIZER_DELIMITER = ASSIST_PARSER + 4; // whether we are inside a field initializer	73	protected static final int K_FIELD_INITIALIZER_DELIMITER = ASSIST_PARSER + 4; // whether we are inside a field initializer
73	protected static final int K_ATTRIBUTE_VALUE_DELIMITER = ASSIST_PARSER + 5; // whether we are inside a annotation attribute valuer	74	protected static final int K_ATTRIBUTE_VALUE_DELIMITER = ASSIST_PARSER + 5; // whether we are inside a annotation attribute valuer
74	protected static final int K_ENUM_CONSTANT_DELIMITER = ASSIST_PARSER + 6; // whether we are inside a field initializer	75	protected static final int K_ENUM_CONSTANT_DELIMITER = ASSIST_PARSER + 6; // whether we are inside a field initializer
		76	protected static final int K_INSIDE_LAMBDA_EXPRESSION = ASSIST_PARSER + 7; // whether we are inside a field initializer
75		77
76	// selector constants	78	// selector constants
77	protected static final int THIS_CONSTRUCTOR = -1;	79	protected static final int THIS_CONSTRUCTOR = -1;
78	protected static final int SUPER_CONSTRUCTOR = -2;	80	protected static final int SUPER_CONSTRUCTOR = -2;
79		81
Lines 191-201 Link Here
191	block.sourceStart = lastStart = -this.blockStarts[j];	193	block.sourceStart = lastStart = -this.blockStarts[j];
192	element = element.add(block, 1);	194	element = element.add(block, 1);
193	}	195	}
194	blockIndex = j+1; // shift the index to the new block	196	blockIndex = j+1; // shift the index to the new block
195	}	197	}
196	if (node instanceof LocalDeclaration){	198	if (node instanceof Argument && ((Argument)node).hasElidedType()){
		199	Argument local = (Argument) node;
		200	if (local.declarationSourceEnd == 0){
		201	element = element.add(local, 0);
		202	if (local.initialization == null){
		203	this.lastCheckPoint = local.sourceEnd + 1;
		204	} else {
		205	this.lastCheckPoint = local.initialization.sourceEnd + 1;
		206	}
		207	} else {
		208	element = element.add(local, 0);
		209	this.lastCheckPoint = local.declarationSourceEnd + 1;
		210	}
		211	while (i <= this.astPtr && this.astStack[i+1] instanceof Argument && ((Argument)this.astStack[i+1]).hasElidedType()) {
		212	i++;
		213	}
		214	continue;
		215	} else if (node instanceof LocalDeclaration){
197	LocalDeclaration local = (LocalDeclaration) node;	216	LocalDeclaration local = (LocalDeclaration) node;
198	if (local.declarationSourceEnd == 0){	217	if (local.declarationSourceEnd == 0){
199	element = element.add(local, 0);	218	element = element.add(local, 0);
200	if (local.initialization == null){	219	if (local.initialization == null){
201	this.lastCheckPoint = local.sourceEnd + 1;	220	this.lastCheckPoint = local.sourceEnd + 1;
Lines 769-785 Link Here
769	switch (token) {	788	switch (token) {
770	case TokenNameLPAREN :	789	case TokenNameLPAREN :
771	this.bracketDepth++;	790	this.bracketDepth++;
772	switch (this.previousToken) {	791	switch (this.previousToken) {
773	case TokenNameIdentifier:	792	case TokenNameIdentifier:
774	this.pushOnElementStack(K_SELECTOR, this.identifierPtr);	793	this.pushOnElementStack(K_SELECTOR, this.identifierPtr, new Integer(this.expressionPtr));
775	break;	794	break;
776	case TokenNamethis: // explicit constructor invocation, e.g. this(1, 2)	795	case TokenNamethis: // explicit constructor invocation, e.g. this(1, 2)
777	this.pushOnElementStack(K_SELECTOR, THIS_CONSTRUCTOR);	796	this.pushOnElementStack(K_SELECTOR, THIS_CONSTRUCTOR, new Integer(this.expressionPtr));
778	break;	797	break;
779	case TokenNamesuper: // explicit constructor invocation, e.g. super(1, 2)	798	case TokenNamesuper: // explicit constructor invocation, e.g. super(1, 2)
780	this.pushOnElementStack(K_SELECTOR, SUPER_CONSTRUCTOR);	799	this.pushOnElementStack(K_SELECTOR, SUPER_CONSTRUCTOR, new Integer(this.expressionPtr));
781	break;	800	break;
782	case TokenNameGREATER: // explicit constructor invocation, e.g. Fred<X>[(]1, 2)	801	case TokenNameGREATER: // explicit constructor invocation, e.g. Fred<X>[(]1, 2)
783	case TokenNameRIGHT_SHIFT: // or fred<X<X>>[(]1, 2)	802	case TokenNameRIGHT_SHIFT: // or fred<X<X>>[(]1, 2)
784	case TokenNameUNSIGNED_RIGHT_SHIFT: //or Fred<X<X<X>>>[(]1, 2)	803	case TokenNameUNSIGNED_RIGHT_SHIFT: //or Fred<X<X<X>>>[(]1, 2)
785	if(this.identifierPtr > -1) {	804	if(this.identifierPtr > -1) {
Lines 814-823 Link Here
814	}	833	}
815	}	834	}
816	this.previousToken = token;	835	this.previousToken = token;
817	if (token == TokenNameIdentifier) {	836	if (token == TokenNameIdentifier) {
818	this.previousIdentifierPtr = this.identifierPtr;	837	this.previousIdentifierPtr = this.identifierPtr;
		838	} else if (token == TokenNameBeginLambda) {
		839	pushOnElementStack(K_INSIDE_LAMBDA_EXPRESSION, this.expressionPtr);
819	}	840	}
820	}	841	}
821	protected void consumeTypeImportOnDemandDeclarationName() {	842	protected void consumeTypeImportOnDemandDeclarationName() {
822	// TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'	843	// TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
823	/* push an ImportRef build from the last name	844	/* push an ImportRef build from the last name
Lines 1736-1745 Link Here
1736	return null;	1757	return null;
1737	}	1758	}
1738	protected Object topKnownElementObjectInfo(int owner) {	1759	protected Object topKnownElementObjectInfo(int owner) {
1739	return topKnownElementObjectInfo(owner, 0);	1760	return topKnownElementObjectInfo(owner, 0);
1740	}	1761	}
		1762	protected void consumeLambdaExpression() {
		1763	super.consumeLambdaExpression();
		1764	popUntilElement(K_INSIDE_LAMBDA_EXPRESSION);
		1765	}
1741	/**	1766	/**
1742	* If the given ast node is inside an explicit constructor call	1767	* If the given ast node is inside an explicit constructor call
1743	* then wrap it with a fake constructor call.	1768	* then wrap it with a fake constructor call.
1744	* Returns the wrapped completion node or the completion node itself.	1769	* Returns the wrapped completion node or the completion node itself.
1745	*/	1770	*/
Lines 1759-1764 Link Here
1759	return call;	1784	return call;
1760	} else {	1785	} else {
1761	return ast;	1786	return ast;
1762	}	1787	}
1763	}	1788	}
		1789	public MessageSend collectLambdaExpressionInformationFromParserWithoutDisturbingStacks () {
		1790	if(this.expressionPtr >= 0 && this.expressionStack[this.expressionPtr] instanceof SelectionOnSingleNameReference) {
		1791	int argumentsRoof = this.elementInfoStack[lastIndexOfElement(K_INSIDE_LAMBDA_EXPRESSION)];
		1792	if (topKnownElementKind(ASSIST_PARSER) == K_SELECTOR \|\| topKnownElementKind(ASSIST_PARSER, 1) == K_SELECTOR \|\| topKnownElementKind(ASSIST_PARSER, 2) == K_SELECTOR) {
		1793	int argumentsFloor = ((Integer)this.elementObjectInfoStack[lastIndexOfElement(K_SELECTOR)]).intValue();
		1794	MessageSend sentMessage = new MessageSend();
		1795	sentMessage.selector = this.identifierStack[this.identifierPtr];
		1796	if (this.expressionPtr > argumentsFloor && argumentsFloor <= argumentsRoof) {
		1797	int noOfSeenArguments = argumentsRoof - argumentsFloor;
		1798	if (noOfSeenArguments > 0) {
		1799	System.arraycopy(this.expressionStack, argumentsFloor + 1, sentMessage.arguments = new Expression[noOfSeenArguments], 0, noOfSeenArguments);
		1800	}
		1801	this.expressionPtr = argumentsFloor;
		1802	}
		1803	return sentMessage;
		1804	}
		1805	}
		1806	return null;
		1807	}
		1808	public LambdaExpression collectLambdaExpressionInformation () {
		1809	ASTNode arg;
		1810	if(this.expressionPtr >= 0 && this.expressionStack[this.expressionPtr] instanceof SelectionOnSingleNameReference) {
		1811	Argument [] arguments = ASTNode.NO_ARGUMENTS;
		1812	if (this.astPtr >= 0 && this.astStack[this.astPtr] instanceof Argument) {
		1813	arguments = new Argument[this.astLengthStack[this.astLengthPtr]];
		1814	int k;
		1815	for (int i = k = this.astPtr + 1 - this.astLengthStack[this.astLengthPtr], j = this.astPtr; i <= j && (arg = this.astStack[i]) instanceof Argument; i++) {
		1816	arguments[i - k] = (Argument)arg;
		1817	}
		1818
		1819	}
		1820	LambdaExpression lExp;
		1821	int argumentsRoof = this.elementInfoStack[lastIndexOfElement(K_INSIDE_LAMBDA_EXPRESSION)];
		1822	popElement(K_INSIDE_LAMBDA_EXPRESSION);
		1823	lExp = new LambdaExpression(this.compilationUnit.compilationResult, arguments, this.expressionStack[this.expressionPtr--]);
		1824	this.expressionLengthPtr--;
		1825	if (topKnownElementKind(ASSIST_PARSER) == K_SELECTOR) {
		1826	int argumentsFloor = ((Integer)this.elementObjectInfoStack[lastIndexOfElement(K_SELECTOR)]).intValue();
		1827	lExp.sentMessage = new MessageSend();
		1828	lExp.sentMessage.selector = this.identifierStack[this.identifierPtr];
		1829	if (this.expressionPtr > argumentsFloor && argumentsFloor <= argumentsRoof) {
		1830	int noOfSeenArguments = argumentsRoof - argumentsFloor;
		1831	if (noOfSeenArguments > 0) {
		1832	System.arraycopy(this.expressionStack, argumentsFloor + 1, lExp.sentMessage.arguments = new Expression[noOfSeenArguments], 0, noOfSeenArguments);
		1833	}
		1834	this.expressionPtr = argumentsFloor;
		1835	this.expressionLengthPtr--;
		1836	}
		1837	}
		1838	return lExp;
		1839	}
		1840	return null;
		1841	}
		1842	public Argument [] getLambdaArgumentsOnwards (Argument arg) {
		1843	boolean started = false;
		1844	ASTNode [] nodeStack = this.astStack;
		1845	Argument [] lArgs = null;
		1846	for (int i = 0, j = this.astPtr; i <= j; i++) {
		1847	if (started) {
		1848	if( nodeStack[i] instanceof Argument && ((Argument)nodeStack[i]).hasElidedType()) {
		1849	if (lArgs == null) {
		1850	lArgs = new Argument[1];
		1851	} else {
		1852	int len = lArgs.length;
1853	System.arraycopy(lArgs, 0, lArgs = new Argument[len + 1], 0, len);
1854	}
1855	lArgs[lArgs.length - 1] = (Argument)nodeStack[i];
1856	} else {
1857	return lArgs;
1858	}
1859	}
1860	if (nodeStack[i] == arg) {
1861	started = true;
1862	}
1863	}
1864	return lArgs;
1865	}
1764	}	1866	}

Lines 69-79 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (-1 / +2 lines)
69	public final static int Bit3 = 0x4; // return type (operator) \| name reference kind (name ref) \| implicit this (this ref) \| is argument(local)	69	public final static int Bit3 = 0x4; // return type (operator) \| name reference kind (name ref) \| implicit this (this ref) \| is argument(local)
70	public final static int Bit4 = 0x8; // return type (operator) \| first assignment to local (name ref,local decl) \| undocumented empty block (block, type and method decl)	70	public final static int Bit4 = 0x8; // return type (operator) \| first assignment to local (name ref,local decl) \| undocumented empty block (block, type and method decl)
71	public final static int Bit5 = 0x10; // value for return (expression) \| has all method bodies (unit) \| supertype ref (type ref) \| resolved (field decl)	71	public final static int Bit5 = 0x10; // value for return (expression) \| has all method bodies (unit) \| supertype ref (type ref) \| resolved (field decl)
72	public final static int Bit6 = 0x20; // depth (name ref, msg) \| ignore need cast check (cast expression) \| error in signature (method declaration/ initializer) \| is recovered (annotation reference)	72	public final static int Bit6 = 0x20; // depth (name ref, msg) \| ignore need cast check (cast expression) \| error in signature (method declaration/ initializer) \| is recovered (annotation reference)
73	public final static int Bit7 = 0x40; // depth (name ref, msg) \| operator (operator) \| need runtime checkcast (cast expression) \| label used (labelStatement) \| needFreeReturn (AbstractMethodDeclaration)	73	public final static int Bit7 = 0x40; // depth (name ref, msg) \| operator (operator) \| need runtime checkcast (cast expression) \| label used (labelStatement) \| needFreeReturn (AbstractMethodDeclaration)
74	public final static int Bit8 = 0x80; // depth (name ref, msg) \| operator (operator) \| unsafe cast (cast expression) \| is default constructor (constructor declaration) \| isElseStatementUnreachable (if statement)	74	public final static int Bit8 = 0x80; // depth (name ref, msg) \| operator (operator) \| unsafe cast (cast expression) \| is default constructor (constructor declaration) \| isElseStatementUnreachable (if statement) \| IsInitializedByLambdaExpression (local declaration)
75	public final static int Bit9 = 0x100; // depth (name ref, msg) \| operator (operator) \| is local type (type decl) \| isThenStatementUnreachable (if statement) \| can be static	75	public final static int Bit9 = 0x100; // depth (name ref, msg) \| operator (operator) \| is local type (type decl) \| isThenStatementUnreachable (if statement) \| can be static
76	public final static int Bit10= 0x200; // depth (name ref, msg) \| operator (operator) \| is anonymous type (type decl)	76	public final static int Bit10= 0x200; // depth (name ref, msg) \| operator (operator) \| is anonymous type (type decl)
77	public final static int Bit11 = 0x400; // depth (name ref, msg) \| operator (operator) \| is member type (type decl)	77	public final static int Bit11 = 0x400; // depth (name ref, msg) \| operator (operator) \| is member type (type decl)
78	public final static int Bit12 = 0x800; // depth (name ref, msg) \| operator (operator) \| has abstract methods (type decl)	78	public final static int Bit12 = 0x800; // depth (name ref, msg) \| operator (operator) \| has abstract methods (type decl)
79	public final static int Bit13 = 0x1000; // depth (name ref, msg) \| is secondary type (type decl)	79	public final static int Bit13 = 0x1000; // depth (name ref, msg) \| is secondary type (type decl)
Lines 154-163 Link Here
154	public static final int IsTypeElided = Bit2; // type elided lambda argument.	154	public static final int IsTypeElided = Bit2; // type elided lambda argument.
155	public static final int IsArgument = Bit3;	155	public static final int IsArgument = Bit3;
156	public static final int IsLocalDeclarationReachable = Bit31;	156	public static final int IsLocalDeclarationReachable = Bit31;
157	public static final int IsForeachElementVariable = Bit5;	157	public static final int IsForeachElementVariable = Bit5;
158	public static final int ShadowsOuterLocal = Bit22;	158	public static final int ShadowsOuterLocal = Bit22;
		159	public static final int IsInitializedByLamdaExpression = Bit8;
159		160
160	// for name refs or local decls	161	// for name refs or local decls
161	public static final int FirstAssignmentToLocal = Bit4;	162	public static final int FirstAssignmentToLocal = Bit4;
162		163
163	// for msg or field references	164	// for msg or field references

Lines 1-12 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SelectionRequestor.java (-2 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2013 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
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	*******************************************************************************/	14	*******************************************************************************/
11	package org.eclipse.jdt.internal.core;	15	package org.eclipse.jdt.internal.core;
12		16
Lines 449-459 Link Here
449	new String(local.name),	453	new String(local.name),
450	local.declarationSourceStart,	454	local.declarationSourceStart,
451	local.declarationSourceEnd,	455	local.declarationSourceEnd,
452	local.sourceStart,	456	local.sourceStart,
453	local.sourceEnd,	457	local.sourceEnd,
454	Util.typeSignature(local.type),	458	local.type == null ? Signature.createTypeSignature(local.binding.type.readableName(), false) : Util.typeSignature(local.type),
455	local.annotations,	459	local.annotations,
456	local.modifiers,	460	local.modifiers,
457	local.getKind() == AbstractVariableDeclaration.PARAMETER);	461	local.getKind() == AbstractVariableDeclaration.PARAMETER);
458	}	462	}
459	if (localVar != null) {	463	if (localVar != null) {