Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JEP323VarLambdaParamsTest.java27
-rw-r--r--org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java44
-rw-r--r--org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java30
3 files changed, 66 insertions, 35 deletions
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JEP323VarLambdaParamsTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JEP323VarLambdaParamsTest.java
index 5bc4f6e811..351fb85796 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JEP323VarLambdaParamsTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JEP323VarLambdaParamsTest.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2018 IBM Corporation and others.
+ * Copyright (c) 2018, 2019 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
@@ -316,4 +316,29 @@ public void testBug536159_04() throws IOException {
"\'var\' is not allowed as an element type of an array\n" +
"----------\n");
}
+public void testBug541532_01() throws IOException {
+ runConformTest(new String[] {
+ "X.java",
+ "import java.util.Arrays;\n" +
+ "import java.util.List;\n" +
+ "\n" +
+ "public class X {\n" +
+ "\n" +
+ " public static void foo(List<String> list) {\n" +
+ " list.stream()\n" +
+ " .map((var s) -> s.toLowerCase())\n" +
+ " .forEach(System.out::println);\n" +
+ "\n" +
+ " list.stream()\n" +
+ " .filter((var s) -> s.length() == 1)\n" +
+ " .forEach(System.out::println);\n" +
+ " }\n" +
+ " public static void main(String[] args) {\n" +
+ " String[] greetings = {\"hello\", \"world\"};\n" +
+ " X.foo(Arrays.asList(greetings));\n" +
+ " }\n" +
+ "}\n",
+ "hello\nworld"
+ });
+}
} \ No newline at end of file
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
index 349406911d..08067d8306 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2012, 2018 IBM Corporation and others.
+ * Copyright (c) 2012, 2019 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
@@ -136,6 +136,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
protected Expression [] resultExpressions = NO_EXPRESSIONS;
public InferenceContext18 inferenceContext; // when performing tentative resolve keep a back reference to the driving context
private Map<Integer/*sourceStart*/, LocalTypeBinding> localTypes; // support look-up of a local type from this lambda copy
+ public boolean argumentsTypeVar = false;
public LambdaExpression(CompilationResult compilationResult, boolean assistNode, boolean requiresGenericSignature) {
@@ -247,7 +248,6 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
public TypeBinding resolveType(BlockScope blockScope, boolean skipKosherCheck) {
boolean argumentsTypeElided = argumentsTypeElided();
- boolean argumentsTypeVar = argumentsTypeVar(blockScope);
int argumentsLength = this.arguments == null ? 0 : this.arguments.length;
if (this.constant != Constant.NotAConstant) {
@@ -256,7 +256,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
if (this.original == this)
this.ordinal = recordFunctionalType(blockScope);
- if (!argumentsTypeElided && !argumentsTypeVar) {
+ if (!argumentsTypeElided) {
for (int i = 0; i < argumentsLength; i++)
this.argumentTypes[i] = this.arguments[i].type.resolveType(blockScope, true /* check bounds*/);
}
@@ -289,7 +289,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
int parametersLength = this.descriptor.parameters.length;
if (parametersLength != argumentsLength) {
this.scope.problemReporter().lambdaSignatureMismatched(this);
- if (argumentsTypeElided || argumentsTypeVar || this.original != this) // no interest in continuing to error check copy.
+ if (argumentsTypeElided || this.original != this) // no interest in continuing to error check copy.
return this.resolvedType = null; // FUBAR, bail out ...
else {
this.resolvedType = null; // continue to type check.
@@ -314,7 +314,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
TypeBinding argumentType;
final TypeBinding expectedParameterType = haveDescriptor && i < this.descriptor.parameters.length ? this.descriptor.parameters[i] : null;
- argumentType = (argumentsTypeElided || argumentsTypeVar) ? expectedParameterType : this.argumentTypes[i];
+ argumentType = argumentsTypeElided ? expectedParameterType : this.argumentTypes[i];
if (argumentType == null) {
argumentsHaveErrors = true;
} else if (argumentType == TypeBinding.VOID) {
@@ -329,7 +329,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
}
}
}
- if (!argumentsTypeElided && !argumentsTypeVar && !argumentsHaveErrors) {
+ if (!argumentsTypeElided && !argumentsHaveErrors) {
ReferenceBinding groundType = null;
ReferenceBinding expectedSAMType = null;
if (this.expectedType instanceof IntersectionTypeBinding18)
@@ -365,7 +365,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
Argument argument = this.arguments[i];
TypeBinding argumentType;
final TypeBinding expectedParameterType = haveDescriptor && i < this.descriptor.parameters.length ? this.descriptor.parameters[i] : null;
- argumentType = (argumentsTypeElided || argumentsTypeVar) ? expectedParameterType : this.argumentTypes[i];
+ argumentType = argumentsTypeElided ? expectedParameterType : this.argumentTypes[i];
expectedParameterTypes[i] = expectedParameterType;
if (argumentType != null && argumentType != TypeBinding.VOID) {
if (haveDescriptor && expectedParameterType != null && argumentType.isValidBinding() && TypeBinding.notEquals(argumentType, expectedParameterType)) {
@@ -396,7 +396,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
}
}
}
- if (argumentsTypeVar) {
+ if (this.argumentsTypeVar) {
for (int i = 0; i < argumentsLength; ++i) {
this.arguments[i].type.resolvedType = expectedParameterTypes[i];
}
@@ -408,7 +408,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
this.binding.setParameterAnnotations(parameterAnnotations);
}
- if (!argumentsTypeElided && !argumentsTypeVar && !argumentsHaveErrors && this.binding.isVarargs()) {
+ if (!argumentsTypeElided && !argumentsHaveErrors && this.binding.isVarargs()) {
if (!this.binding.parameters[this.binding.parameters.length - 1].isReifiable()) {
this.scope.problemReporter().possibleHeapPollutionFromVararg(this.arguments[this.arguments.length - 1]);
}
@@ -438,7 +438,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
} // TODO (stephan): else? (can that happen?)
if (haveDescriptor && !argumentsHaveErrors && blockScope.compilerOptions().isAnnotationBasedNullAnalysisEnabled) {
- if (!argumentsTypeElided && !argumentsTypeVar) {
+ if (!argumentsTypeElided) {
AbstractMethodDeclaration.createArgumentBindings(this.arguments, this.binding, this.scope); // includes validation
// no application of null-ness default, hence also no warning regarding redundant null annotation
mergeParameterNullAnnotations(blockScope);
@@ -533,28 +533,7 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
@Override
public boolean argumentsTypeElided() {
- return this.arguments.length > 0 && this.arguments[0].hasElidedType();
- }
-
- private boolean argumentsTypeVar(BlockScope blockScope) {
- if (blockScope.compilerOptions().complianceLevel < ClassFileConstants.getComplianceLevelForJavaVersion(ClassFileConstants.MAJOR_VERSION_11)) return false;
- boolean retval = false, isVar = false, mixReported = false;
- Argument[] args = this.arguments;
- for (int i = 0, l = args.length; i < l; ++i) {
- Argument arg = args[i];
- TypeReference type = arg.type;
- if (type == null) continue;
- boolean prev = isVar;
- retval |= isVar = type.isTypeNameVar(blockScope);
- if (i > 0 && prev != isVar && !mixReported) { // report only once per list
- blockScope.problemReporter().varCannotBeMixedWithNonVarParams(isVar ? arg : args[i - 1]);
- mixReported = true;
- }
- if (isVar && (type.dimensions() > 0 || type.extraDimensions() > 0)) {
- blockScope.problemReporter().varLocalCannotBeArray(arg);
- }
- }
- return retval;
+ return (this.arguments.length > 0 && this.arguments[0].hasElidedType()) || this.argumentsTypeVar;
}
private void analyzeExceptions() {
@@ -710,7 +689,6 @@ public class LambdaExpression extends FunctionalExpression implements IPolyExpre
if (targetType == null) // assumed to signal another primary error
return true;
-
if (argumentsTypeElided())
return false;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
index 885fc4cc3a..a9e213965a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2018 IBM Corporation and others.
+ * Copyright (c) 2000, 2019 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
@@ -941,6 +941,7 @@ protected int valueLambdaNestDepth = -1;
private int stateStackLengthStack[] = new int[0];
protected boolean parsingJava8Plus;
protected boolean parsingJava9Plus;
+protected boolean parsingJava11Plus;
protected int unstackedAct = ERROR_ACTION;
private boolean haltOnSyntaxError = false;
private boolean tolerateDefaultClassMethods = false;
@@ -959,6 +960,7 @@ public Parser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
initializeScanner();
this.parsingJava8Plus = this.options.sourceLevel >= ClassFileConstants.JDK1_8;
this.parsingJava9Plus = this.options.sourceLevel >= ClassFileConstants.JDK9;
+ this.parsingJava11Plus = this.options.sourceLevel >= ClassFileConstants.JDK11;
this.astLengthStack = new int[50];
this.expressionLengthStack = new int[30];
this.typeAnnotationLengthStack = new int[30];
@@ -8552,6 +8554,31 @@ protected void consumeLambdaHeader() {
this.currentElement.lambdaNestLevel++;
}
}
+private void setArgumentsTypeVar(LambdaExpression lexp) {
+ Argument[] args = lexp.arguments;
+ if (!this.parsingJava11Plus || args == null || args.length == 0) {
+ lexp.argumentsTypeVar = false;
+ return;
+ }
+
+ boolean isVar = false, mixReported = false;
+ for (int i = 0, l = args.length; i < l; ++i) {
+ Argument arg = args[i];
+ TypeReference type = arg.type;
+ char[][] typeName = type != null ? type.getTypeName() : null;
+ boolean prev = isVar;
+ isVar = typeName != null && typeName.length == 1 &&
+ CharOperation.equals(typeName[0], TypeConstants.VAR);
+ lexp.argumentsTypeVar |= isVar;
+ if (i > 0 && prev != isVar && !mixReported) { // report only once per list
+ this.problemReporter().varCannotBeMixedWithNonVarParams(isVar ? arg : args[i - 1]);
+ mixReported = true;
+ }
+ if (isVar && (type.dimensions() > 0 || type.extraDimensions() > 0)) {
+ this.problemReporter().varLocalCannotBeArray(arg);
+ }
+ }
+}
protected void consumeLambdaExpression() {
// LambdaExpression ::= LambdaHeader LambdaBody
@@ -8581,6 +8608,7 @@ protected void consumeLambdaExpression() {
if (!this.parsingJava8Plus) {
problemReporter().lambdaExpressionsNotBelow18(lexp);
}
+ setArgumentsTypeVar(lexp);
pushOnExpressionStack(lexp);
if (this.currentElement != null) {
this.lastCheckPoint = body.sourceEnd + 1;

Back to the top