working on migrating to JP classes

javaparser · Sep 28, 2017 · 223fc76 · 223fc76
1 parent c3dc366
commit 223fc76
Show file tree

Hide file tree

Showing 32 changed files with 404 additions and 376 deletions.
diff --git a/...solver-core/src/main/java/com/github/javaparser/symbolsolver/core/resolution/Context.java b/...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 {

diff --git a/...-core/src/main/java/com/github/javaparser/symbolsolver/core/resolution/ContextHelper.java b/...-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) {

diff --git a/.../com/github/javaparser/symbolsolver/declarations/common/MethodDeclarationCommonLogic.java b/.../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);
     }
 }
diff --git a/...om/github/javaparser/symbolsolver/javaparsermodel/contexts/AbstractJavaParserContext.java b/...om/github/javaparser/symbolsolver/javaparsermodel/contexts/AbstractJavaParserContext.java
@@ -20,13 +20,13 @@
 import com.github.javaparser.ast.expr.Expression;
 import com.github.javaparser.ast.expr.FieldAccessExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.core.resolution.Context;
 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory;
-import com.github.javaparser.symbolsolver.model.declarations.ValueDeclaration;
 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 com.github.javaparser.symbolsolver.resolution.SymbolDeclarator;
 
 import java.util.Optional;
@@ -45,13 +45,13 @@ public abstract class AbstractJavaParserContext<N extends Node> implements Conte
     /// Static methods
     ///
 
-    public static final SymbolReference<ValueDeclaration> solveWith(SymbolDeclarator symbolDeclarator, String name) {
-        for (ValueDeclaration decl : symbolDeclarator.getSymbolDeclarations()) {
+    public static final SymbolReference<ResolvedValueDeclaration> solveWith(SymbolDeclarator symbolDeclarator, String name) {
+        for (ResolvedValueDeclaration decl : symbolDeclarator.getSymbolDeclarations()) {
             if (decl.getName().equals(name)) {
                 return SymbolReference.solved(decl);
             }
         }
-        return SymbolReference.unsolved(ValueDeclaration.class);
+        return SymbolReference.unsolved(ResolvedValueDeclaration.class);
     }
 
     ///
@@ -88,7 +88,7 @@ public int hashCode() {
     }
 
     @Override
-    public Optional<Type> solveGenericType(String name, TypeSolver typeSolver) {
+    public Optional<ResolvedType> solveGenericType(String name, TypeSolver typeSolver) {
         Context parent = getParent();
         if (parent == null) {
             return Optional.empty();

diff --git a/...avaparser/symbolsolver/javaparsermodel/contexts/AbstractMethodLikeDeclarationContext.java b/...avaparser/symbolsolver/javaparsermodel/contexts/AbstractMethodLikeDeclarationContext.java
@@ -4,17 +4,17 @@
 import com.github.javaparser.ast.body.Parameter;
 import com.github.javaparser.ast.nodeTypes.NodeWithParameters;
 import com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserTypeParameter;
-import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.TypeDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.ValueDeclaration;
 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 com.github.javaparser.symbolsolver.model.typesystem.TypeVariable;
 import com.github.javaparser.symbolsolver.resolution.SymbolDeclarator;
 
 import java.util.List;
@@ -30,10 +30,10 @@ public AbstractMethodLikeDeclarationContext(T wrappedNode, TypeSolver typeSolver
         super(wrappedNode, typeSolver);
     }
 
-    public final SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
+    public final SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
         for (Parameter parameter : wrappedNode.getParameters()) {
             SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(parameter, typeSolver);
-            SymbolReference<? extends ValueDeclaration> symbolReference = AbstractJavaParserContext.solveWith(sb, name);
+            SymbolReference<? extends ResolvedValueDeclaration> symbolReference = AbstractJavaParserContext.solveWith(sb, name);
             if (symbolReference.isSolved()) {
                 return symbolReference;
             }
@@ -44,10 +44,10 @@ public final SymbolReference<? extends ValueDeclaration> solveSymbol(String name
     }
 
     @Override
-    public final Optional<Type> solveGenericType(String name, TypeSolver typeSolver) {
+    public final Optional<ResolvedType> solveGenericType(String name, TypeSolver typeSolver) {
         for (com.github.javaparser.ast.type.TypeParameter tp : wrappedNode.getTypeParameters()) {
             if (tp.getName().getId().equals(name)) {
-                return Optional.of(new TypeVariable(new JavaParserTypeParameter(tp, typeSolver)));
+                return Optional.of(new ResolvedTypeVariable(new JavaParserTypeParameter(tp, typeSolver)));
             }
         }
         return super.solveGenericType(name, typeSolver);
@@ -69,7 +69,7 @@ public final Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolv
     }
 
     @Override
-    public final SymbolReference<TypeDeclaration> solveType(String name, TypeSolver typeSolver) {
+    public final SymbolReference<ResolvedTypeDeclaration> solveType(String name, TypeSolver typeSolver) {
         if (wrappedNode.getTypeParameters() != null) {
             for (com.github.javaparser.ast.type.TypeParameter tp : wrappedNode.getTypeParameters()) {
                 if (tp.getName().getId().equals(name)) {
@@ -94,8 +94,8 @@ public final SymbolReference<TypeDeclaration> solveType(String name, TypeSolver
     }
 
     @Override
-    public final SymbolReference<MethodDeclaration> solveMethod(
-            String name, List<Type> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) {
+    public final SymbolReference<ResolvedMethodDeclaration> solveMethod(
+            String name, List<ResolvedType> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) {
         return getParent().solveMethod(name, argumentsTypes, false, typeSolver);
     }
 }