Merge pull request #1431 from matozoid/issue_1407_var_validations

Validate positions of var

4 files changed, 104 insertions, 6 deletions

diff --git a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java
index 41d981016..e5be2b80a 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java
@@ -71,8 +71,8 @@ public class ParserConfiguration {
         JAVA_8(new Java8Validator(), null),
         /** Java 9 */
         JAVA_9(new Java9Validator(), null),
-        /** Java 10 (work in progress) */
-        JAVA_10_PREVIEW(new Java10Validator(), new Java10PostProcessor()),
+        /** Java 10 */
+        JAVA_10(new Java10Validator(), new Java10PostProcessor()),
         /** Java 11 (work in progress) */
         JAVA_11_PREVIEW(new Java11Validator(), new Java11PostProcessor());
 
@@ -200,7 +200,7 @@ public class ParserConfiguration {
     public ParserConfiguration setValidator(Validator validator) {
         // This whole method is a backwards compatability hack.
         if (validator instanceof Java10Validator) {
-            setLanguageLevel(JAVA_10_PREVIEW);
+            setLanguageLevel(JAVA_10);
         } else if (validator instanceof Java9Validator) {
             setLanguageLevel(JAVA_9);
         } else if (validator instanceof Java8Validator) {
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java
index b182e8db5..c7fda2f46 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java
@@ -1,15 +1,14 @@
 package com.github.javaparser.ast.validator;
 
 import com.github.javaparser.ast.type.VarType;
+import com.github.javaparser.ast.validator.chunks.VarValidator;
 
 /**
  * This validator validates according to Java 10 syntax rules.
  */
 public class Java10Validator extends Java9Validator {
 
-    protected final Validator varOnlyOnLocalVariableDefinitionAndFor = new SingleNodeTypeValidator<>(VarType.class, (n, reporter) -> {
-        // TODO issue 1407
-    });
+    protected final Validator varOnlyOnLocalVariableDefinitionAndFor = new SingleNodeTypeValidator<>(VarType.class, new VarValidator(false));
 
     public Java10Validator() {
         super();
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java
index d80577268..0eb879aa0 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java11Validator.java
@@ -1,10 +1,16 @@
 package com.github.javaparser.ast.validator;
 
+import com.github.javaparser.ast.type.VarType;
+import com.github.javaparser.ast.validator.chunks.VarValidator;
+
 /**
  * This validator validates according to Java 11 syntax rules.
  */
 public class Java11Validator extends Java10Validator {
+    protected final Validator varAlsoInLambdaParameters = new SingleNodeTypeValidator<>(VarType.class, new VarValidator(true));
+
     public Java11Validator() {
         super();
+        replace(varOnlyOnLocalVariableDefinitionAndFor, varAlsoInLambdaParameters);
     }
 }
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/validator/chunks/VarValidator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/chunks/VarValidator.java
new file mode 100644
index 000000000..19357e83c
--- /dev/null
+++ b/javaparser-core/src/main/java/com/github/javaparser/ast/validator/chunks/VarValidator.java
@@ -0,0 +1,93 @@
+package com.github.javaparser.ast.validator.chunks;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.ArrayCreationExpr;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.expr.NullLiteralExpr;
+import com.github.javaparser.ast.expr.VariableDeclarationExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.ast.stmt.ForStmt;
+import com.github.javaparser.ast.stmt.ForeachStmt;
+import com.github.javaparser.ast.type.VarType;
+import com.github.javaparser.ast.validator.ProblemReporter;
+import com.github.javaparser.ast.validator.TypedValidator;
+
+import java.util.Optional;
+
+public class VarValidator implements TypedValidator<VarType> {
+    private boolean varAllowedInLambdaParameters;
+
+    public VarValidator(boolean varAllowedInLambdaParameters) {
+        this.varAllowedInLambdaParameters = varAllowedInLambdaParameters;
+    }
+
+    @Override
+    public void accept(VarType node, ProblemReporter reporter) {
+        // All allowed locations are within a VariableDeclaration inside a VariableDeclarationExpr inside something else.
+        Optional<VariableDeclarator> variableDeclarator = node.findParent(VariableDeclarator.class);
+        if (!variableDeclarator.isPresent()) {
+            // Java 11's var in lambda's
+            if (varAllowedInLambdaParameters) {
+                boolean valid = node
+                        .findParent(Parameter.class)
+                        .flatMap(Node::getParentNode)
+                        .map((Node p) -> p instanceof LambdaExpr).orElse(false);
+                if (valid) {
+                    return;
+                }
+            }
+            reportIllegalPosition(node, reporter);
+            return;
+        }
+        variableDeclarator.ifPresent(vd -> {
+            Optional<Node> variableDeclarationExpr = vd.getParentNode();
+            if (!variableDeclarationExpr.isPresent()) {
+                reportIllegalPosition(node, reporter);
+                return;
+            }
+            variableDeclarationExpr.ifPresent(vdeNode -> {
+                if (!(vdeNode instanceof VariableDeclarationExpr)) {
+                    reportIllegalPosition(node, reporter);
+                    return;
+                }
+                VariableDeclarationExpr vde = (VariableDeclarationExpr) vdeNode;
+                if (vde.getVariables().size() > 1) {
+                    reporter.report(vde, "\"var\" only takes a single variable.");
+                }
+                Optional<Node> container = vdeNode.getParentNode();
+                if (!container.isPresent()) {
+                    reportIllegalPosition(node, reporter);
+                    return;
+                }
+                container.ifPresent(c -> {
+                    boolean positionIsFine = c instanceof ForStmt || c instanceof ForeachStmt || c instanceof ExpressionStmt;
+                    if (!positionIsFine) {
+                        reportIllegalPosition(node, reporter);
+                    }
+                    // A local variable declaration ends up inside an ExpressionStmt.
+                    if (c instanceof ExpressionStmt) {
+                        if (!vd.getInitializer().isPresent()) {
+                            reporter.report(node, "\"var\" needs an initializer.");
+                        }
+                        vd.getInitializer().ifPresent(initializer -> {
+                            if (initializer instanceof NullLiteralExpr) {
+                                reporter.report(node, "\"var\" cannot infer type from just null.");
+                            }
+                            if (initializer instanceof ArrayCreationExpr) {
+                                reporter.report(node, "\"var\" cannot infer array types.");
+                            }
+                        });
+
+                    }
+                });
+            });
+        });
+
+    }
+
+    private void reportIllegalPosition(VarType n, ProblemReporter reporter) {
+        reporter.report(n, "\"var\" is not allowed here.");
+    }
+}