Make a simple "var" inferrer.

javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclarator.java

@@ -50,8 +50,9 @@
 import com.github.javaparser.resolution.declarations.ResolvedFieldDeclaration;
 
 /**
- * The declaration of a variable.<br/>In <code>int x = 14, y = 3;</code> "x = 14"  and " y = 3"  are
+ * The declaration of a variable.<br/>In <code>int x = 14, y = 3;</code> "int x = 14"  and "int y = 3"  are
  * VariableDeclarators.
+ * <p/>The type is on all of the variable declarators because, thanks to array brackets, each variable can have a different type.
  *
  * @author Julio Vilmar Gesser
  */

javaparser-core/src/main/java/com/github/javaparser/ast/type/VarType.java

@@ -31,6 +31,7 @@
 import com.github.javaparser.ast.visitor.VoidVisitor;
 import com.github.javaparser.metamodel.JavaParserMetaModel;
 import com.github.javaparser.metamodel.VoidTypeMetaModel;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.resolution.types.ResolvedVoidType;
 import javax.annotation.Generated;
 import java.util.Optional;
@@ -92,8 +93,8 @@ public boolean replace(Node node, Node replacementNode) {
     }
 
     @Override
-    public ResolvedVoidType resolve() {
-        return getSymbolResolver().toResolvedType(this, ResolvedVoidType.class);
+    public ResolvedType resolve() {
+        return getSymbolResolver().toResolvedType(this, ResolvedType.class);
     }
 
     @Override

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

@@ -473,6 +473,9 @@ protected ResolvedType convertToUsage(com.github.javaparser.ast.type.Type type,
         } else if (type instanceof UnionType) {
             UnionType unionType = (UnionType) type;
             return new ResolvedUnionType(unionType.getElements().stream().map(el -> convertToUsage(el, context)).collect(Collectors.toList()));
+        } else if (type instanceof VarType) {
+            final VariableDeclarator variableDeclarator = (VariableDeclarator)type.getParentNode().get();
+            return variableDeclarator.getInitializer().get().calculateResolvedType();
         } else {
             throw new UnsupportedOperationException(type.getClass().getCanonicalName());
         }

javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/model/typesystem/ReferenceTypeImpl.java

@@ -47,7 +47,7 @@ public class ReferenceTypeImpl extends ResolvedReferenceType {
 
     public static ResolvedReferenceType undeterminedParameters(ResolvedReferenceTypeDeclaration typeDeclaration, TypeSolver typeSolver) {
         return new ReferenceTypeImpl(typeDeclaration, typeDeclaration.getTypeParameters().stream().map(
-                tp -> new ResolvedTypeVariable(tp)
+                ResolvedTypeVariable::new
         ).collect(Collectors.toList()), typeSolver);
     }
 

javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/ConvertToUsageTest.java

@@ -15,7 +15,7 @@
 
 public class ConvertToUsageTest extends AbstractResolutionTest {
 
-    TypeSolver typeSolver = new ReflectionTypeSolver();
+    private final TypeSolver typeSolver = new ReflectionTypeSolver();
 
     @Test
     public void testConvertTypeToUsage() {

javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/VarTypeTest.java

@@ -0,0 +1,46 @@
+package com.github.javaparser.symbolsolver.resolution.javaparser;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseStart;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.type.VarType;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.JavaSymbolSolver;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.JAVA_10_PREVIEW;
+import static com.github.javaparser.Providers.provider;
+import static org.junit.Assert.assertEquals;
+
+public class VarTypeTest {
+    private final TypeSolver typeSolver = new ReflectionTypeSolver();
+    private final JavaParser javaParser = new JavaParser(new ParserConfiguration()
+            .setLanguageLevel(JAVA_10_PREVIEW)
+            .setSymbolResolver(new JavaSymbolSolver(typeSolver)));
+
+    @Test
+    public void resolveAPrimitive() {
+        CompilationUnit ast = javaParser.parse(ParseStart.COMPILATION_UNIT, provider("class X{var abc = 1;}")).getResult().get();
+        VarType varType = ast.findFirst(VarType.class).get();
+
+        ResolvedType resolvedType = varType.resolve();
+
+        assertEquals(ResolvedPrimitiveType.byName("int"), resolvedType);
+    }
+
+    @Test
+    public void resolveAReferenceType() {
+        CompilationUnit ast = javaParser.parse(ParseStart.COMPILATION_UNIT, provider("class X{var abc = \"\";}")).getResult().get();
+        VarType varType = ast.findFirst(VarType.class).get();
+
+        ResolvedType resolvedType = varType.resolve();
+
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver), resolvedType);
+    }
+}