Merge branch 'master' into issue_1421_escape_eol_for_json

7 files changed, 139 insertions, 44 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 deb8d4cdc..e5be2b80a 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java
@@ -33,6 +33,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.*;
 import static com.github.javaparser.utils.Utils.assertNotNull;
 
 /**
@@ -42,19 +43,38 @@ import static com.github.javaparser.utils.Utils.assertNotNull;
  */
 public class ParserConfiguration {
     public enum LanguageLevel {
+        /** Does no post processing or validation. Only for people wanting the fastest parsing. */
         RAW(null, null),
+        /** The most used Java version. */
+        POPULAR(new Java8Validator(), null),
+        /** The latest Java version that is available. */
+        CURRENT(new Java8Validator(), null),
+        /** The newest Java features supported. */
+        BLEEDING_EDGE(new Java11Validator(), new Java11PostProcessor()),
+        /** Java 1.0 */
         JAVA_1_0(new Java1_0Validator(), null),
+        /** Java 1.1 */
         JAVA_1_1(new Java1_1Validator(), null),
+        /** Java 1.2 */
         JAVA_1_2(new Java1_2Validator(), null),
+        /** Java 1.3 */
         JAVA_1_3(new Java1_3Validator(), null),
+        /** Java 1.4 */
         JAVA_1_4(new Java1_4Validator(), null),
+        /** Java 5 */
         JAVA_5(new Java5Validator(), null),
+        /** Java 6 */
         JAVA_6(new Java6Validator(), null),
+        /** Java 7 */
         JAVA_7(new Java7Validator(), null),
+        /** Java 8 */
         JAVA_8(new Java8Validator(), null),
+        /** Java 9 */
         JAVA_9(new Java9Validator(), null),
-        JAVA_10_PREVIEW(null, new Java10PostProcessor()),
-        JAVA_11_PREVIEW(null, new Java11PostProcessor());
+        /** Java 10 */
+        JAVA_10(new Java10Validator(), new Java10PostProcessor()),
+        /** Java 11 (work in progress) */
+        JAVA_11_PREVIEW(new Java11Validator(), new Java11PostProcessor());
 
         final Validator validator;
         final ParseResult.PostProcessor postProcessor;
@@ -72,7 +92,7 @@ public class ParserConfiguration {
     private boolean lexicalPreservationEnabled = false;
     private SymbolResolver symbolResolver = null;
     private int tabSize = 1;
-    private LanguageLevel languageLevel;
+    private LanguageLevel languageLevel = CURRENT;
 
     private final List<ParseResult.PostProcessor> postProcessors = new ArrayList<>();
 
@@ -107,7 +127,6 @@ public class ParserConfiguration {
                     }
                 })
         ));
-        setLanguageLevel(LanguageLevel.JAVA_8);
     }
 
     public boolean isAttributeComments() {
@@ -181,29 +200,29 @@ public class ParserConfiguration {
     public ParserConfiguration setValidator(Validator validator) {
         // This whole method is a backwards compatability hack.
         if (validator instanceof Java10Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_10_PREVIEW);
+            setLanguageLevel(JAVA_10);
         } else if (validator instanceof Java9Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_9);
+            setLanguageLevel(JAVA_9);
         } else if (validator instanceof Java8Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_8);
+            setLanguageLevel(JAVA_8);
         } else if (validator instanceof Java7Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_7);
+            setLanguageLevel(JAVA_7);
         } else if (validator instanceof Java6Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_6);
+            setLanguageLevel(JAVA_6);
         } else if (validator instanceof Java5Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_5);
+            setLanguageLevel(JAVA_5);
         } else if (validator instanceof Java1_4Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_1_4);
+            setLanguageLevel(JAVA_1_4);
         } else if (validator instanceof Java1_3Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_1_3);
+            setLanguageLevel(JAVA_1_3);
         } else if (validator instanceof Java1_2Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_1_2);
+            setLanguageLevel(JAVA_1_2);
         } else if (validator instanceof Java1_1Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_1_1);
+            setLanguageLevel(JAVA_1_1);
         } else if (validator instanceof Java1_0Validator) {
-            setLanguageLevel(LanguageLevel.JAVA_1_0);
+            setLanguageLevel(JAVA_1_0);
         } else if (validator instanceof NoProblemsValidator) {
-            setLanguageLevel(LanguageLevel.RAW);
+            setLanguageLevel(RAW);
         }
         return this;
     }
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java
index 3658d14f9..ab1dad9cb 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java
@@ -55,7 +55,7 @@ import java.util.Optional;
  *
  * @author Julio Vilmar Gesser
  */
-public final class ConstructorDeclaration extends CallableDeclaration<ConstructorDeclaration> implements NodeWithBlockStmt<ConstructorDeclaration>, NodeWithAccessModifiers<ConstructorDeclaration>, NodeWithJavadoc<ConstructorDeclaration>, NodeWithDeclaration, NodeWithSimpleName<ConstructorDeclaration>, NodeWithParameters<ConstructorDeclaration>, NodeWithThrownExceptions<ConstructorDeclaration>, NodeWithTypeParameters<ConstructorDeclaration>, Resolvable<ResolvedConstructorDeclaration> {
+public final class ConstructorDeclaration extends CallableDeclaration<ConstructorDeclaration> implements NodeWithBlockStmt<ConstructorDeclaration>, NodeWithAccessModifiers<ConstructorDeclaration>, NodeWithJavadoc<ConstructorDeclaration>, NodeWithSimpleName<ConstructorDeclaration>, NodeWithParameters<ConstructorDeclaration>, NodeWithThrownExceptions<ConstructorDeclaration>, NodeWithTypeParameters<ConstructorDeclaration>, Resolvable<ResolvedConstructorDeclaration> {
 
     private BlockStmt body;
 
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.");
+    }
+}
diff --git a/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java b/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java
index 01251712e..7130870e7 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java
@@ -1,23 +1,15 @@
 package com.github.javaparser.version;
 
-import com.github.javaparser.ParseResult;
-import com.github.javaparser.ParserConfiguration;
-import com.github.javaparser.ast.Node;
 import com.github.javaparser.ast.type.ClassOrInterfaceType;
 import com.github.javaparser.ast.type.VarType;
-import com.github.javaparser.ast.validator.Java10Validator;
-import com.github.javaparser.ast.validator.ProblemReporter;
 
-import static com.github.javaparser.ParseResult.*;
+import static com.github.javaparser.ParseResult.PostProcessor;
 
 /**
  * Processes the generic AST into a Java 10 AST and validates it.
  */
 public class Java10PostProcessor extends PostProcessors {
-    protected final PostProcessor java10Validator = new Java10Validator().postProcessor();
-    protected final PostProcessor varNodeCreator = new PostProcessor() {
-        @Override
-        public void process(ParseResult<? extends Node> result, ParserConfiguration configuration) {
+    protected final PostProcessor varNodeCreator = (result, configuration) ->
             result.getResult().ifPresent(node -> {
                 node.findAll(ClassOrInterfaceType.class).forEach(n -> {
                     if (n.getNameAsString().equals("var")) {
@@ -25,11 +17,8 @@ public class Java10PostProcessor extends PostProcessors {
                     }
                 });
             });
-        }
-    };
 
     public Java10PostProcessor() {
         add(varNodeCreator);
-        add(java10Validator);
     }
 }
diff --git a/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java b/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java
index 5d36efc05..004967edd 100644
--- a/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java
+++ b/javaparser-core/src/main/java/com/github/javaparser/version/Java11PostProcessor.java
@@ -1,18 +1,7 @@
 package com.github.javaparser.version;
 
-import com.github.javaparser.ParseResult;
-import com.github.javaparser.ParserConfiguration;
-import com.github.javaparser.ast.Node;
-import com.github.javaparser.ast.validator.Java11Validator;
-import com.github.javaparser.ast.validator.ProblemReporter;
-
 /**
  * Processes the generic AST into a Java 10 AST and validates it.
  */
 public class Java11PostProcessor extends Java10PostProcessor {
-    protected final ParseResult.PostProcessor java11Validator = new Java11Validator().postProcessor();
-
-    public Java11PostProcessor() {
-        replace(java10Validator, java11Validator);
-    }
 }