Basic var support

javaparser-core/src/main/java/com/github/javaparser/ParseResult.java

@@ -125,5 +125,4 @@ public String toString() {
     public interface PostProcessor {
         void process(ParseResult<? extends Node> result, ParserConfiguration configuration);
     }
-
 }

javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java

@@ -26,7 +26,7 @@
 import com.github.javaparser.ast.validator.*;
 import com.github.javaparser.printer.lexicalpreservation.LexicalPreservingPrinter;
 import com.github.javaparser.resolution.SymbolResolver;
-import com.github.javaparser.version.Java10Processor;
+import com.github.javaparser.version.Java10PostProcessor;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -52,7 +52,7 @@ public enum LanguageLevel {
         JAVA_7(new Java7Validator(), null),
         JAVA_8(new Java8Validator(), null),
         JAVA_9(new Java9Validator(), null),
-        JAVA_10(null, new Java10Processor());
+        JAVA_10(null, new Java10PostProcessor());
 
         final Validator validator;
         final ParseResult.PostProcessor postProcessor;
@@ -177,7 +177,32 @@ public Optional<Validator> getValidator() {
      */
     @Deprecated
     public ParserConfiguration setValidator(Validator validator) {
-        throw new IllegalStateException("method is deprecated");
+        if (validator instanceof Java10Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_10);
+        } else if (validator instanceof Java9Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_9);
+        } else if (validator instanceof Java8Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_8);
+        } else if (validator instanceof Java7Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_7);
+        } else if (validator instanceof Java6Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_6);
+        } else if (validator instanceof Java5Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_5);
+        } else if (validator instanceof Java1_4Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_1_4);
+        } else if (validator instanceof Java1_3Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_1_3);
+        } else if (validator instanceof Java1_2Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_1_2);
+        } else if (validator instanceof Java1_1Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_1_1);
+        } else if (validator instanceof Java1_0Validator) {
+            setLanguageLevel(LanguageLevel.JAVA_1_0);
+        } else if (validator instanceof NoProblemsValidator) {
+            setLanguageLevel(LanguageLevel.ANY);
+        }
+        return this;
     }
 
     /**

javaparser-core/src/main/java/com/github/javaparser/ast/validator/Java10Validator.java

@@ -0,0 +1,20 @@
+package com.github.javaparser.ast.validator;
+
+import com.github.javaparser.ast.type.VarType;
+
+/**
+ * This validator validates according to Java 10 syntax rules.
+ */
+public class Java10Validator extends Java9Validator {
+
+    protected final Validator varOnlyOnLocalVariableDefinitionAndFor = new SingleNodeTypeValidator<>(VarType.class, (n, reporter) -> {
+
+    });
+
+    public Java10Validator() {
+        super();
+        add(varOnlyOnLocalVariableDefinitionAndFor);
+        /* There is no validator that validates that "var" is not used in Java 9 and lower, since the parser will never create a VarType node,
+           because that is done by the Java10 postprocessor. You can add it by hand, but that is obscure enough to ignore. */
+    }
+}

javaparser-core/src/main/java/com/github/javaparser/ast/validator/NoProblemsValidator.java

@@ -1,10 +1,14 @@
 package com.github.javaparser.ast.validator;
 
+import com.github.javaparser.ParserConfiguration;
 import com.github.javaparser.ast.Node;
 
 /**
  * Stub validator for when no validation is wanted.
+ *
+ * @deprecated when setting a language validator, try {@link com.github.javaparser.ParserConfiguration#setLanguageLevel(ParserConfiguration.LanguageLevel)} with ANY.
  */
+@Deprecated
 public final class NoProblemsValidator implements Validator {
     @Override
     public void accept(Node node, ProblemReporter problemReporter) {

javaparser-core/src/main/java/com/github/javaparser/ast/validator/TypedValidator.java

@@ -1,5 +1,6 @@
 package com.github.javaparser.ast.validator;
 
+import com.github.javaparser.ParseResult;
 import com.github.javaparser.ast.Node;
 
 import java.util.function.BiConsumer;
@@ -13,4 +14,11 @@ public interface TypedValidator<N extends Node> extends BiConsumer<N, ProblemRep
      * @param problemReporter when found, validation errors can be reported here
      */
     void accept(N node, ProblemReporter problemReporter);
+
+    @SuppressWarnings("unchecked")
+    default ParseResult.PostProcessor postProcessor() {
+        return (result, configuration) ->
+                result.getResult().ifPresent(node ->
+                        accept((N) node, new ProblemReporter(problem -> result.getProblems().add(problem))));
+    }
 }

javaparser-core/src/main/java/com/github/javaparser/printer/ConcreteSyntaxModel.java

@@ -793,6 +793,8 @@ private static CsmElement typeArguments() {
 
         concreteSyntaxModelByClass.put(VoidType.class, sequence(comment(), annotations(), token(GeneratedJavaParserConstants.VOID)));
 
+        concreteSyntaxModelByClass.put(VarType.class, sequence(comment(), annotations(), string(GeneratedJavaParserConstants.IDENTIFIER, "var")));
+
         concreteSyntaxModelByClass.put(WildcardType.class, sequence(comment(), annotations(), token(GeneratedJavaParserConstants.HOOK),
                 CsmElement.conditional(ObservableProperty.EXTENDED_TYPE, IS_PRESENT, CsmElement.sequence(space(), token(GeneratedJavaParserConstants.EXTENDS), space(), CsmElement.child(EXTENDED_TYPE))),
                 CsmElement.conditional(ObservableProperty.SUPER_TYPE, IS_PRESENT, CsmElement.sequence(space(), token(GeneratedJavaParserConstants.SUPER), space(), CsmElement.child(SUPER_TYPE)))));

javaparser-core/src/main/java/com/github/javaparser/version/Java10PostProcessor.java

@@ -0,0 +1,30 @@
+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 com.github.javaparser.ast.visitor.ModifierVisitor;
+import com.github.javaparser.ast.visitor.Visitable;
+
+/**
+ * Processes the generic AST into a Java 10 AST and validates it.
+ */
+public class Java10PostProcessor implements ParseResult.PostProcessor {
+    private final Java10Validator validator = new Java10Validator();
+
+    @Override
+    public void process(ParseResult<? extends Node> result, ParserConfiguration configuration) {
+        result.getResult().ifPresent(node -> {
+            node.findAll(ClassOrInterfaceType.class).forEach(n -> {
+                if (n.getNameAsString().equals("var")) {
+                    n.replace(new VarType(n.getTokenRange().orElse(null)));
+                }
+            });
+            validator.accept(node, new ProblemReporter(problem -> result.getProblems().add(problem)));
+        });
+    }
+}

javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/DefaultVisitorAdapter.java

@@ -467,4 +467,9 @@ public ResolvedType visit(UnparsableStmt node, Boolean arg) {
     public ResolvedType visit(ReceiverParameter node, Boolean arg) {
         throw new UnsupportedOperationException(node.getClass().getCanonicalName());
     }
+
+    @Override
+    public ResolvedType visit(VarType node, Boolean arg) {
+        throw new UnsupportedOperationException(node.getClass().getCanonicalName());
+    }
 }

javaparser-testing/src/test/java/com/github/javaparser/ParserConfigurationTest.java

@@ -2,18 +2,33 @@
 
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.stmt.Statement;
+import com.github.javaparser.ast.validator.NoProblemsValidator;
 import org.junit.Test;
 
+import static com.github.javaparser.ParseStart.STATEMENT;
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.*;
 import static com.github.javaparser.Providers.provider;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 public class ParserConfigurationTest {
     @Test
     public void storeNoTokens() {
         ParseResult<CompilationUnit> result = new JavaParser(new ParserConfiguration().setStoreTokens(false)).parse(ParseStart.COMPILATION_UNIT, provider("class X{}"));
-        
+
         assertFalse(result.getTokens().isPresent());
         assertTrue(result.getResult().get().findAll(Node.class).stream().noneMatch(node -> node.getTokenRange().isPresent()));
     }
+
+    @Test
+    public void noProblemsHere() {
+        ParseResult<Statement> result =
+                new JavaParser(new ParserConfiguration().setLanguageLevel(ANY))
+                        .parse(STATEMENT, provider("try{}"));
+        assertEquals(true, result.isSuccessful());
+    }
+
+
 }

javaparser-testing/src/test/java/com/github/javaparser/ast/type/TypeTest.java

@@ -6,11 +6,13 @@
 import com.github.javaparser.ParserConfiguration;
 import com.github.javaparser.ast.expr.VariableDeclarationExpr;
 import com.github.javaparser.ast.validator.Java5Validator;
+import com.github.javaparser.ast.validator.ProblemReporter;
 import org.junit.Test;
 
 import static com.github.javaparser.JavaParser.parseType;
 import static com.github.javaparser.JavaParser.parseVariableDeclarationExpr;
 import static com.github.javaparser.ParseStart.VARIABLE_DECLARATION_EXPR;
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.*;
 import static com.github.javaparser.Providers.provider;
 import static org.junit.Assert.*;
 
@@ -30,10 +32,11 @@ public void primitiveTypeArgumentDefaultValidator() {
 
     @Test
     public void primitiveTypeArgumentLenientValidator() {
-        ParserConfiguration config = new ParserConfiguration();
-        config.setValidator(new Java5Validator() {{
+        ParserConfiguration config = new ParserConfiguration()
+                .setLanguageLevel(ANY);
+        config.getPostProcessors().add(new Java5Validator() {{
             remove(noPrimitiveGenericArguments);
-        }});
+        }}.postProcessor());
 
         ParseResult<VariableDeclarationExpr> result = new JavaParser(config).parse(
                 VARIABLE_DECLARATION_EXPR, provider("List<long> x"));
@@ -56,7 +59,7 @@ public void arrayType() {
         type.ifArrayType(t -> s[0] = t);
         assertNotNull(s[0]);
     }
-    
+
     @Test
     public void issue1251() {
         final Type type = parseType("TypeUtilsTest<String>.Tester");

javaparser-testing/src/test/java/com/github/javaparser/ast/validator/Java7ValidatorTest.java

@@ -16,12 +16,13 @@
 import static com.github.javaparser.ParseStart.COMPILATION_UNIT;
 import static com.github.javaparser.ParseStart.EXPRESSION;
 import static com.github.javaparser.ParseStart.STATEMENT;
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.*;
 import static com.github.javaparser.Providers.provider;
 import static com.github.javaparser.utils.TestUtils.assertNoProblems;
 import static com.github.javaparser.utils.TestUtils.assertProblems;
 
 public class Java7ValidatorTest {
-    public static final JavaParser javaParser = new JavaParser(new ParserConfiguration().setValidator(new Java7Validator()));
+    public static final JavaParser javaParser = new JavaParser(new ParserConfiguration().setLanguageLevel(JAVA_7));
 
     @Test
     public void generics() {
@@ -82,7 +83,7 @@ public void multiCatchWithoutElements() {
         UnionType unionType = new UnionType();
 
         List<Problem> problems = new ArrayList<>();
-        javaParser.getParserConfiguration().getValidator().get().accept(unionType, new ProblemReporter(problems::add));
+        new Java7Validator().accept(unionType, new ProblemReporter(problems::add));
 
         assertProblems(problems, "UnionType.elements can not be empty.");
     }
@@ -93,7 +94,7 @@ public void multiCatchWithOneElement() {
         unionType.getElements().add(new ClassOrInterfaceType());
 
         List<Problem> problems = new ArrayList<>();
-        javaParser.getParserConfiguration().getValidator().get().accept(unionType, new ProblemReporter(problems::add));
+        new Java7Validator().accept(unionType, new ProblemReporter(problems::add));
 
         assertProblems(problems, "Union type (multi catch) must have at least two elements.");
     }

javaparser-testing/src/test/java/com/github/javaparser/utils/TestUtils.java

@@ -20,6 +20,7 @@
 import static com.github.javaparser.utils.CodeGenerationUtils.f;
 import static com.github.javaparser.utils.Utils.EOL;
 import static com.github.javaparser.utils.Utils.normalizeEolInTextBlock;
+import static java.util.Arrays.*;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -130,8 +131,7 @@ public static void assertProblems(ParseResult<?> result, String... expectedArg)
 
     public static void assertProblems(List<Problem> result, String... expectedArg) {
         Set<String> actual = result.stream().map(Problem::toString).collect(Collectors.toSet());
-        Set<String> expected = new HashSet<>();
-        expected.addAll(Arrays.asList(expectedArg));
+        Set<String> expected = new HashSet<>(asList(expectedArg));
         assertCollections(expected, actual);
     }
 

javaparser-testing/src/test/java/com/github/javaparser/version/Java10PostProcessorTest.java

@@ -0,0 +1,51 @@
+package com.github.javaparser.version;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseResult;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.stmt.Statement;
+import com.github.javaparser.ast.type.VarType;
+import org.junit.Test;
+
+import java.util.List;
+
+import static com.github.javaparser.ParseStart.COMPILATION_UNIT;
+import static com.github.javaparser.ParseStart.STATEMENT;
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.*;
+import static com.github.javaparser.Providers.provider;
+import static com.github.javaparser.ast.validator.Java1_1ValidatorTest.allModifiers;
+import static com.github.javaparser.utils.TestUtils.assertNoProblems;
+import static com.github.javaparser.utils.TestUtils.assertProblems;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Java10PostProcessorTest {
+    public static final JavaParser javaParser = new JavaParser(new ParserConfiguration().setLanguageLevel(JAVA_10));
+
+    @Test
+    public void varIsAType() {
+        ParseResult<Statement> result = javaParser.parse(STATEMENT, provider("var x=\"\";"));
+
+        List<VarType> allVarTypes = result.getResult().get().findAll(VarType.class);
+
+        assertEquals(1, allVarTypes.size());
+    }
+
+    @Test
+    public void varAllowedInLocalVariableDeclaration() {
+        ParseResult<Statement> result = javaParser.parse(STATEMENT, provider("var a = 5;"));
+        assertNoProblems(result);
+    }
+
+    @Test
+    public void varAllowedInForEach() {
+        ParseResult<Statement> result = javaParser.parse(STATEMENT, provider("for(var a : as){}"));
+        assertNoProblems(result);
+    }
+
+    @Test
+    public void varAllowedInOldFor() {
+        ParseResult<Statement> result = javaParser.parse(STATEMENT, provider("for(var a = 5;a<9;a++){}"));
+        assertNoProblems(result);
+    }
+}