Merge remote-tracking branch 'upstream/master' into issue9inference

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

@@ -0,0 +1,39 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.resolution.SymbolResolver;
+import com.github.javaparser.resolution.types.ResolvedArrayType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserMethodDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+
+import com.github.javaparser.ast.type.ArrayType;
+
+
+public class JavaSymbolSolver implements SymbolResolver {
+
+    private TypeSolver typeSolver;
+
+    public JavaSymbolSolver(TypeSolver typeSolver) {
+        this.typeSolver = typeSolver;
+    }
+
+    @Override
+    public <T> T resolve(Node node, Class<T> resultClass) {
+        if (node instanceof MethodDeclaration) {
+            return resultClass.cast(new JavaParserMethodDeclaration((MethodDeclaration)node, typeSolver));
+        }
+        if (node instanceof ArrayType) {
+            return resultClass.cast(JavaParserFacade.get(typeSolver).convert((ArrayType)node, node));
+        }
+        throw new UnsupportedOperationException("Unable to resolve to " + resultClass.getSimpleName() + " from " + node.getClass().getSimpleName());
+    }
+
+    public void inject(CompilationUnit destination) {
+        destination.setData(Node.SYMBOL_RESOLVER_KEY, this);
+    }
+}

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

@@ -28,12 +28,13 @@
 import com.github.javaparser.ast.expr.MethodCallExpr;
 import com.github.javaparser.ast.ImportDeclaration;
 import com.github.javaparser.ast.stmt.Statement;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
-import com.github.javaparser.symbolsolver.model.declarations.TypeDeclaration;
 import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
 import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
-import com.github.javaparser.symbolsolver.model.typesystem.ReferenceType;
-import com.github.javaparser.symbolsolver.model.typesystem.Type;
 
 import java.io.File;
 import java.io.IOException;
@@ -97,13 +98,13 @@ public int getKo() {
     }
 
     private void solveTypeDecl(ClassOrInterfaceDeclaration node) {
-        TypeDeclaration typeDeclaration = JavaParserFacade.get(typeSolver).getTypeDeclaration(node);
+        ResolvedTypeDeclaration typeDeclaration = JavaParserFacade.get(typeSolver).getTypeDeclaration(node);
         if (typeDeclaration.isClass()) {
             out.println("\n[ Class " + typeDeclaration.getQualifiedName() + " ]");
-            for (ReferenceType sc : typeDeclaration.asClass().getAllSuperClasses()) {
+            for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllSuperClasses()) {
                 out.println("  superclass: " + sc.getQualifiedName());
             }
-            for (ReferenceType sc : typeDeclaration.asClass().getAllInterfaces()) {
+            for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllInterfaces()) {
                 out.println("  interface: " + sc.getQualifiedName());
             }
         }
@@ -119,7 +120,7 @@ private void solve(Node node) {
                 // skip
             } else if ((getParentNode(node) instanceof Statement) || (getParentNode(node) instanceof VariableDeclarator)) {
                 try {
-                    Type ref = JavaParserFacade.get(typeSolver).getType(node);
+                    ResolvedType ref = JavaParserFacade.get(typeSolver).getType(node);
                     out.println("  Line " + node.getRange().get().begin.line + ") " + node + " ==> " + ref.describe());
                     ok++;
                 } catch (UnsupportedOperationException upe) {
@@ -156,7 +157,7 @@ private String toString(MethodCallExpr node) {
         }
     }
 
-    private String toString(SymbolReference<com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration> methodDeclarationSymbolReference) {
+    private String toString(SymbolReference<ResolvedMethodDeclaration> methodDeclarationSymbolReference) {
         if (methodDeclarationSymbolReference.isSolved()) {
             return methodDeclarationSymbolReference.getCorrespondingDeclaration().getQualifiedSignature();
         } else {

java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/core/resolution/Context.java

@@ -16,12 +16,12 @@
 
 package com.github.javaparser.symbolsolver.core.resolution;
 
-import com.github.javaparser.symbolsolver.model.declarations.*;
-import com.github.javaparser.symbolsolver.model.methods.MethodUsage;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.*;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
 import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
 import com.github.javaparser.symbolsolver.model.resolution.Value;
-import com.github.javaparser.symbolsolver.model.typesystem.Type;
 
 import java.util.List;
 import java.util.Optional;
@@ -38,25 +38,25 @@ public interface Context {
 
     /* Type resolution */
 
-    default Optional<Type> solveGenericType(String name, TypeSolver typeSolver) {
+    default Optional<ResolvedType> solveGenericType(String name, TypeSolver typeSolver) {
         return Optional.empty();
     }
 
-    default SymbolReference<TypeDeclaration> solveType(String name, TypeSolver typeSolver) {
+    default SymbolReference<ResolvedTypeDeclaration> solveType(String name, TypeSolver typeSolver) {
         Context parent = getParent();
         if (parent == null) {
-            return SymbolReference.unsolved(ReferenceTypeDeclaration.class);
+            return SymbolReference.unsolved(ResolvedReferenceTypeDeclaration.class);
         } else {
             return parent.solveType(name, typeSolver);
         }
     }
 
     /* Symbol resolution */
 
-    SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver);
+    SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver);
 
     default Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
-        SymbolReference<? extends ValueDeclaration> ref = solveSymbol(name, typeSolver);
+        SymbolReference<? extends ResolvedValueDeclaration> ref = solveSymbol(name, typeSolver);
         if (ref.isSolved()) {
             Value value = Value.from(ref.getCorrespondingDeclaration());
             return Optional.of(value);
@@ -70,7 +70,7 @@ default Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
     /**
      * We find the method declaration which is the best match for the given name and list of typeParametersValues.
      */
-    default SymbolReference<ConstructorDeclaration> solveConstructor(List<Type> argumentsTypes, TypeSolver typeSolver) {
+    default SymbolReference<ResolvedConstructorDeclaration> solveConstructor(List<ResolvedType> argumentsTypes, TypeSolver typeSolver) {
         throw new IllegalArgumentException("Constructor resolution is available only on Class Context");
     }
 
@@ -79,16 +79,16 @@ default SymbolReference<ConstructorDeclaration> solveConstructor(List<Type> argu
     /**
      * We find the method declaration which is the best match for the given name and list of typeParametersValues.
      */
-    SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> argumentsTypes, boolean staticOnly, TypeSolver typeSolver);
+    SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly, TypeSolver typeSolver);
 
     /**
      * Similar to solveMethod but we return a MethodUsage. A MethodUsage corresponds to a MethodDeclaration plus the
      * resolved type variables.
      */
-    default Optional<MethodUsage> solveMethodAsUsage(String name, List<Type> argumentsTypes, TypeSolver typeSolver) {
-        SymbolReference<MethodDeclaration> methodSolved = solveMethod(name, argumentsTypes, false, typeSolver);
+    default Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> argumentsTypes, TypeSolver typeSolver) {
+        SymbolReference<ResolvedMethodDeclaration> methodSolved = solveMethod(name, argumentsTypes, false, typeSolver);
         if (methodSolved.isSolved()) {
-            MethodDeclaration methodDeclaration = methodSolved.getCorrespondingDeclaration();
+            ResolvedMethodDeclaration methodDeclaration = methodSolved.getCorrespondingDeclaration();
             MethodUsage methodUsage = ContextHelper.resolveTypeVariables(this, methodDeclaration, argumentsTypes);//methodDeclaration.resolveTypeVariables(this, argumentsTypes);
             return Optional.of(methodUsage);
         } else {

java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/core/resolution/ContextHelper.java

@@ -16,12 +16,12 @@
 
 package com.github.javaparser.symbolsolver.core.resolution;
 
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserEnumDeclaration;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserMethodDeclaration;
 import com.github.javaparser.symbolsolver.javassistmodel.JavassistMethodDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration;
-import com.github.javaparser.symbolsolver.model.methods.MethodUsage;
-import com.github.javaparser.symbolsolver.model.typesystem.Type;
 import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionMethodDeclaration;
 
 import java.util.List;
@@ -35,7 +35,7 @@ private ContextHelper() {
         // prevent instantiation
     }
 
-    static MethodUsage resolveTypeVariables(Context context, MethodDeclaration methodDeclaration, List<Type> parameterTypes) {
+    static MethodUsage resolveTypeVariables(Context context, ResolvedMethodDeclaration methodDeclaration, List<ResolvedType> parameterTypes) {
         if (methodDeclaration instanceof JavaParserMethodDeclaration) {
             return ((JavaParserMethodDeclaration) methodDeclaration).resolveTypeVariables(context, parameterTypes);
         } else if (methodDeclaration instanceof JavassistMethodDeclaration) {

java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/declarations/common/MethodDeclarationCommonLogic.java

@@ -16,14 +16,14 @@
 
 package com.github.javaparser.symbolsolver.declarations.common;
 
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
 import com.github.javaparser.symbolsolver.core.resolution.Context;
 import com.github.javaparser.symbolsolver.logic.InferenceContext;
-import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.TypeParameterDeclaration;
-import com.github.javaparser.symbolsolver.model.methods.MethodUsage;
 import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
-import com.github.javaparser.symbolsolver.model.typesystem.Type;
-import com.github.javaparser.symbolsolver.model.typesystem.TypeVariable;
 import com.github.javaparser.symbolsolver.reflectionmodel.MyObjectProvider;
 
 import java.util.ArrayList;
@@ -35,19 +35,19 @@
  */
 public class MethodDeclarationCommonLogic {
 
-    private MethodDeclaration methodDeclaration;
+    private ResolvedMethodDeclaration methodDeclaration;
     private TypeSolver typeSolver;
 
-    public MethodDeclarationCommonLogic(MethodDeclaration methodDeclaration, TypeSolver typeSolver) {
+    public MethodDeclarationCommonLogic(ResolvedMethodDeclaration methodDeclaration, TypeSolver typeSolver) {
         this.methodDeclaration = methodDeclaration;
         this.typeSolver = typeSolver;
     }
 
-    public MethodUsage resolveTypeVariables(Context context, List<Type> parameterTypes) {
-        Type returnType = replaceTypeParams(methodDeclaration.getReturnType(), typeSolver, context);
-        List<Type> params = new ArrayList<>();
+    public MethodUsage resolveTypeVariables(Context context, List<ResolvedType> parameterTypes) {
+        ResolvedType returnType = replaceTypeParams(methodDeclaration.getReturnType(), typeSolver, context);
+        List<ResolvedType> params = new ArrayList<>();
         for (int i = 0; i < methodDeclaration.getNumberOfParams(); i++) {
-            Type replaced = replaceTypeParams(methodDeclaration.getParam(i).getType(), typeSolver, context);
+            ResolvedType replaced = replaceTypeParams(methodDeclaration.getParam(i).getType(), typeSolver, context);
             params.add(replaced);
         }
 
@@ -56,8 +56,8 @@ public MethodUsage resolveTypeVariables(Context context, List<Type> parameterTyp
         // Map<TypeParameterDeclaration, Type> determinedTypeParameters = new HashMap<>();
         InferenceContext inferenceContext = new InferenceContext(MyObjectProvider.INSTANCE);
         for (int i = 0; i < methodDeclaration.getNumberOfParams() - (methodDeclaration.hasVariadicParameter() ? 1 : 0); i++) {
-            Type formalParamType = methodDeclaration.getParam(i).getType();
-            Type actualParamType = parameterTypes.get(i);
+            ResolvedType formalParamType = methodDeclaration.getParam(i).getType();
+            ResolvedType actualParamType = parameterTypes.get(i);
             inferenceContext.addPair(formalParamType, actualParamType);
         }
 
@@ -66,11 +66,11 @@ public MethodUsage resolveTypeVariables(Context context, List<Type> parameterTyp
         return new MethodUsage(methodDeclaration, params, returnType);
     }
 
-    private Type replaceTypeParams(Type type, TypeSolver typeSolver, Context context) {
+    private ResolvedType replaceTypeParams(ResolvedType type, TypeSolver typeSolver, Context context) {
         if (type.isTypeVariable()) {
-            TypeParameterDeclaration typeParameter = type.asTypeParameter();
+            ResolvedTypeParameterDeclaration typeParameter = type.asTypeParameter();
             if (typeParameter.declaredOnType()) {
-                Optional<Type> typeParam = typeParamByName(typeParameter.getName(), typeSolver, context);
+                Optional<ResolvedType> typeParam = typeParamByName(typeParameter.getName(), typeSolver, context);
                 if (typeParam.isPresent()) {
                     type = typeParam.get();
                 }
@@ -84,11 +84,11 @@ private Type replaceTypeParams(Type type, TypeSolver typeSolver, Context context
         return type;
     }
 
-    protected Optional<Type> typeParamByName(String name, TypeSolver typeSolver, Context context) {
+    protected Optional<ResolvedType> typeParamByName(String name, TypeSolver typeSolver, Context context) {
         return methodDeclaration.getTypeParameters().stream().filter(tp -> tp.getName().equals(name)).map(tp -> toType(tp)).findFirst();
     }
 
-    protected Type toType(TypeParameterDeclaration typeParameterDeclaration) {
-        return new TypeVariable(typeParameterDeclaration);
+    protected ResolvedType toType(ResolvedTypeParameterDeclaration typeParameterDeclaration) {
+        return new ResolvedTypeVariable(typeParameterDeclaration);
     }
 }