remove TypeDeclaration.solveMethod

javaparser · Oct 16, 2016 · 656bb37 · 656bb37
1 parent 2326216
commit 656bb37
Show file tree

Hide file tree

Showing 15 changed files with 84 additions and 56 deletions.
diff --git a/.../tomassetti/symbolsolver/javaparsermodel/contexts/ClassOrInterfaceDeclarationContext.java b/.../tomassetti/symbolsolver/javaparsermodel/contexts/ClassOrInterfaceDeclarationContext.java
@@ -18,8 +18,8 @@
 import me.tomassetti.symbolsolver.model.resolution.TypeSolver;
 import me.tomassetti.symbolsolver.model.resolution.Value;
 import me.tomassetti.symbolsolver.model.usages.typesystem.ReferenceType;
-import me.tomassetti.symbolsolver.model.usages.typesystem.TypeParameter;
 import me.tomassetti.symbolsolver.model.usages.typesystem.Type;
+import me.tomassetti.symbolsolver.model.usages.typesystem.TypeParameter;
 import me.tomassetti.symbolsolver.resolution.MethodResolutionLogic;
 import me.tomassetti.symbolsolver.resolution.SymbolDeclarator;
 
@@ -143,7 +143,7 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
             if (!superclass.isSolved()) {
                 throw new UnsolvedSymbolException(this, superclassName);
             }
-            SymbolReference<MethodDeclaration> res = superclass.getCorrespondingDeclaration().solveMethod(name, parameterTypes);
+            SymbolReference<MethodDeclaration> res = MethodResolutionLogic.solveMethodInType(superclass.getCorrespondingDeclaration(), name, parameterTypes, typeSolver);
             if (res.isSolved()) {
                 candidateMethods.add(res.getCorrespondingDeclaration());
             }
@@ -153,7 +153,7 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
             if (!superclass.isSolved()) {
                 throw new UnsolvedSymbolException(this, superclassName);
             }
-            SymbolReference<MethodDeclaration> res = superclass.getCorrespondingDeclaration().solveMethod(name, parameterTypes);
+            SymbolReference<MethodDeclaration> res = MethodResolutionLogic.solveMethodInType(superclass.getCorrespondingDeclaration(), name, parameterTypes, typeSolver);
             if (res.isSolved()) {
                 candidateMethods.add(res.getCorrespondingDeclaration());
             }
@@ -166,7 +166,7 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
             if (!superclass.isSolved()) {
                 throw new UnsolvedSymbolException(this, interfaceClassName);
             }
-            SymbolReference<MethodDeclaration> res = superclass.getCorrespondingDeclaration().solveMethod(name, parameterTypes);
+            SymbolReference<MethodDeclaration> res = MethodResolutionLogic.solveMethodInType(superclass.getCorrespondingDeclaration(), name, parameterTypes, typeSolver);
             if (res.isSolved() && res.getCorrespondingDeclaration().isDefaultMethod()) {
                 candidateMethods.add(res.getCorrespondingDeclaration());
             }

diff --git a/...main/java/me/tomassetti/symbolsolver/javaparsermodel/contexts/CompilationUnitContext.java b/...main/java/me/tomassetti/symbolsolver/javaparsermodel/contexts/CompilationUnitContext.java
@@ -12,6 +12,7 @@
 import me.tomassetti.symbolsolver.model.usages.typesystem.Type;
 import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
 import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserInterfaceDeclaration;
+import me.tomassetti.symbolsolver.resolution.MethodResolutionLogic;
 
 import java.util.List;
 
@@ -173,7 +174,7 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
                         if (importDecl.getName() instanceof QualifiedNameExpr) {
                             String qName = importDecl.getName().toString();
                             me.tomassetti.symbolsolver.model.declarations.TypeDeclaration ref = typeSolver.solveType(qName);
-                            SymbolReference<MethodDeclaration> method = ref.solveMethod(name, parameterTypes);
+                            SymbolReference<MethodDeclaration> method = MethodResolutionLogic.solveMethodInType(ref, name, parameterTypes, typeSolver);
                             if (method.isSolved()) {
                                 return method;
                             }
@@ -186,7 +187,7 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
                             if (qName.equals(name) || qName.endsWith("." + name)) {
                                 String typeName = getType(qName);
                                 me.tomassetti.symbolsolver.model.declarations.TypeDeclaration ref = typeSolver.solveType(typeName);
-                                SymbolReference<MethodDeclaration> method = ref.solveMethod(name, parameterTypes);
+                                SymbolReference<MethodDeclaration> method = MethodResolutionLogic.solveMethodInType(ref, name, parameterTypes, typeSolver);
                                 if (method.isSolved()) {
                                     return method;
                                 }

diff --git a/.../main/java/me/tomassetti/symbolsolver/javaparsermodel/contexts/MethodCallExprContext.java b/.../main/java/me/tomassetti/symbolsolver/javaparsermodel/contexts/MethodCallExprContext.java
@@ -198,7 +198,7 @@ public Optional<MethodUsage> solveMethodAsUsage(String name, List<Type> paramete
                     String className = ((NameExpr) wrappedNode.getScope()).getName();
                     SymbolReference<TypeDeclaration> ref = solveType(className, typeSolver);
                     if (ref.isSolved()) {
-                        SymbolReference<MethodDeclaration> m = ref.getCorrespondingDeclaration().solveMethod(name, parameterTypes);
+                        SymbolReference<MethodDeclaration> m = MethodResolutionLogic.solveMethodInType(ref.getCorrespondingDeclaration(), name, parameterTypes, typeSolver);
                         if (m.isSolved()) {
                             MethodUsage methodUsage = new MethodUsage(m.getCorrespondingDeclaration());
                             methodUsage = resolveMethodTypeParameters(methodUsage, parameterTypes);
@@ -242,7 +242,7 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
                 SymbolReference symbolReference = this.solveType(scopeAsName.getName(), typeSolver);
                 if (symbolReference.isSolved() && symbolReference.getCorrespondingDeclaration().isType()) {
                     TypeDeclaration typeDeclaration = symbolReference.getCorrespondingDeclaration().asType();
-                    return typeDeclaration.solveMethod(name, parameterTypes);
+                    return MethodResolutionLogic.solveMethodInType(typeDeclaration, name, parameterTypes, typeSolver);
                 }
             }
 
@@ -254,26 +254,26 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
             }
             if (typeOfScope.isWildcard()) {
                 if (typeOfScope.asWildcard().isExtends() || typeOfScope.asWildcard().isSuper()) {
-                    return typeOfScope.asWildcard().getBoundedType().asReferenceType().solveMethod(name, parameterTypes);
+                    return MethodResolutionLogic.solveMethodInType(typeOfScope.asWildcard().getBoundedType().asReferenceType().getTypeDeclaration(), name, parameterTypes, typeSolver);
                 } else {
-                    return new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver).solveMethod(name, parameterTypes);
+                    return MethodResolutionLogic.solveMethodInType(new ReflectionClassDeclaration(Object.class, typeSolver), name, parameterTypes, typeSolver);
                 }
             } else if (typeOfScope.isArray() && typeOfScope.asArrayType().getComponentType().isReferenceType()) {
-                return typeOfScope.asArrayType().getComponentType().asReferenceType().solveMethod(name, parameterTypes);
+                return MethodResolutionLogic.solveMethodInType(typeOfScope.asArrayType().getComponentType().asReferenceType().getTypeDeclaration(), name, parameterTypes, typeSolver);
             } else if (typeOfScope.isTypeVariable()) {
                 for (TypeParameterDeclaration.Bound bound : typeOfScope.asTypeParameter().getBounds(typeSolver)) {
-                    SymbolReference<MethodDeclaration> res = bound.getType().asReferenceType().solveMethod(name, parameterTypes);
+                    SymbolReference<MethodDeclaration> res = MethodResolutionLogic.solveMethodInType(bound.getType().asReferenceType().getTypeDeclaration(), name, parameterTypes, typeSolver);
                     if (res.isSolved()) {
                         return res;
                     }
                 }
                 return SymbolReference.unsolved(MethodDeclaration.class);
             } else {
-                return typeOfScope.asReferenceType().solveMethod(name, parameterTypes);
+                return MethodResolutionLogic.solveMethodInType(typeOfScope.asReferenceType().getTypeDeclaration(), name, parameterTypes, typeSolver);
             }
         } else {
             Type typeOfScope = JavaParserFacade.get(typeSolver).getTypeOfThisIn(wrappedNode);
-            return typeOfScope.asReferenceType().solveMethod(name, parameterTypes);
+            return MethodResolutionLogic.solveMethodInType(typeOfScope.asReferenceType().getTypeDeclaration(), name, parameterTypes, typeSolver);
         }
     }
 }
diff --git a/...a/me/tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclaration.java b/...a/me/tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclaration.java
@@ -40,7 +40,6 @@ public JavaParserClassDeclaration(com.github.javaparser.ast.body.ClassOrInterfac
 		this.typeSolver = typeSolver;
 	}
 
-	@Override
 	public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
         Context ctx = getContext();
 		return ctx.solveMethod(name, parameterTypes, typeSolver);

diff --git a/...va/me/tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclaration.java b/...va/me/tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclaration.java
@@ -220,18 +220,10 @@ protected TypeSolver typeSolver() {
         return typeSolver;
     }
 
-    @Override
-    public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
-        if (name.equals("values") && parameterTypes.isEmpty()) {
-            return SymbolReference.solved(new ValuesMethod());
-        }
-        // TODO add methods inherited from Enum
-        return getContext().solveMethod(name, parameterTypes, typeSolver);
-    }
-
+    @Deprecated
     public Optional<MethodUsage> solveMethodAsUsage(String name, List<Type> parameterTypes, TypeSolver typeSolver, Context invokationContext, List<Type> typeParameterValues) {
         if (name.equals("values") && parameterTypes.isEmpty()) {
-            return Optional.of(new ValuesMethod().getUsage(null));
+            return Optional.of(new ValuesMethod(this, typeSolver).getUsage(null));
         }
         // TODO add methods inherited from Enum
         return getContext().solveMethodAsUsage(name, parameterTypes, typeSolver);
@@ -331,16 +323,24 @@ public com.github.javaparser.ast.body.EnumDeclaration getWrappedNode()
 	}
 
     // Needed by ContextHelper
-    public class ValuesMethod implements MethodDeclaration {
+    public static class ValuesMethod implements MethodDeclaration {
+
+        private JavaParserEnumDeclaration enumDeclaration;
+        private TypeSolver typeSolver;
+
+        public ValuesMethod(JavaParserEnumDeclaration enumDeclaration, TypeSolver typeSolver) {
+            this.enumDeclaration = enumDeclaration;
+            this.typeSolver = typeSolver;
+        }
 
         @Override
         public TypeDeclaration declaringType() {
-            return JavaParserEnumDeclaration.this;
+            return enumDeclaration;
         }
 
         @Override
         public Type getReturnType() {
-            return new ArrayType(new ReferenceTypeImpl(JavaParserEnumDeclaration.this, typeSolver));
+            return new ArrayType(new ReferenceTypeImpl(enumDeclaration, typeSolver));
         }
 
         @Override

diff --git a/.../tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclaration.java b/.../tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclaration.java
@@ -37,11 +37,6 @@ public JavaParserInterfaceDeclaration(ClassOrInterfaceDeclaration wrappedNode, T
         this.typeSolver = typeSolver;
     }
 
-    @Override
-    public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
-        return getContext().solveMethod(name, parameterTypes, typeSolver());
-    }
-
     @Override
     public Set<MethodDeclaration> getDeclaredMethods() {
         Set<MethodDeclaration> methods = new HashSet<>();

diff --git a/...java/me/tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter.java b/...java/me/tomassetti/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter.java
@@ -38,7 +38,6 @@ public Set<MethodDeclaration> getDeclaredMethods() {
         return Collections.emptySet();
     }
 
-    @Override
     public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
         return getContext().solveMethod(name, parameterTypes, typeSolver());
     }

diff --git a/...massetti/symbolsolver/javaparsermodel/declarations/JavaParserTypeVariableDeclaration.java b/...massetti/symbolsolver/javaparsermodel/declarations/JavaParserTypeVariableDeclaration.java
@@ -47,7 +47,6 @@ public String toString() {
                 '}';
     }
 
-    @Override
     public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
         throw new UnsupportedOperationException();
     }

diff --git a/...re/src/main/java/me/tomassetti/symbolsolver/javassistmodel/JavassistClassDeclaration.java b/...re/src/main/java/me/tomassetti/symbolsolver/javassistmodel/JavassistClassDeclaration.java
@@ -226,7 +226,7 @@ public Context getContext() {
         throw new UnsupportedOperationException();
     }
 
-    @Override
+    @Deprecated
     public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
         List<MethodDeclaration> candidates = new ArrayList<>();
         for (CtMethod method : ctClass.getDeclaredMethods()) {

diff --git a/...rc/main/java/me/tomassetti/symbolsolver/javassistmodel/JavassistInterfaceDeclaration.java b/...rc/main/java/me/tomassetti/symbolsolver/javassistmodel/JavassistInterfaceDeclaration.java
@@ -88,6 +88,7 @@ private List<Type> parseTypeParameters(String signature, TypeSolver typeSolver,
         }
     }
 
+    @Deprecated
     public Optional<MethodUsage> solveMethodAsUsage(String name, List<Type> parameterTypes, TypeSolver typeSolver,
                                                     Context invokationContext, List<Type> typeParameterValues) {
 
@@ -139,7 +140,7 @@ public Optional<MethodUsage> solveMethodAsUsage(String name, List<Type> paramete
         return Optional.empty();
     }
 
-    @Override
+    @Deprecated
     public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
         List<MethodDeclaration> candidates = new ArrayList<>();
         for (CtMethod method : ctClass.getDeclaredMethods()) {

diff --git a/.../src/main/java/me/tomassetti/symbolsolver/reflectionmodel/ReflectionClassDeclaration.java b/.../src/main/java/me/tomassetti/symbolsolver/reflectionmodel/ReflectionClassDeclaration.java
@@ -107,7 +107,7 @@ public Context getContext() {
         return new ClassOrInterfaceDeclarationContext(clazz);
     }
 
-    @Override
+    @Deprecated
     public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
         List<MethodDeclaration> methods = new ArrayList<>();
         for (Method method : Arrays.stream(clazz.getDeclaredMethods()).filter((m) -> m.getName().equals(name)).sorted(new MethodComparator()).collect(Collectors.toList())) {
@@ -117,13 +117,13 @@ public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> pa
         }
         if (getSuperClass() != null) {
             ClassDeclaration superClass = (ClassDeclaration) getSuperClass().getTypeDeclaration();
-            SymbolReference<MethodDeclaration> ref = superClass.solveMethod(name, parameterTypes);
+            SymbolReference<MethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(superClass, name, parameterTypes, typeSolver);
             if (ref.isSolved()) {
                 methods.add(ref.getCorrespondingDeclaration());
             }
         }
         for (ReferenceType interfaceDeclaration : getInterfaces()) {
-            SymbolReference<MethodDeclaration> ref = interfaceDeclaration.solveMethod(name, parameterTypes);
+            SymbolReference<MethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(interfaceDeclaration.getTypeDeclaration(), name, parameterTypes, typeSolver);
             if (ref.isSolved()) {
                 methods.add(ref.getCorrespondingDeclaration());
             }

diff --git a/.../main/java/me/tomassetti/symbolsolver/reflectionmodel/ReflectionInterfaceDeclaration.java b/.../main/java/me/tomassetti/symbolsolver/reflectionmodel/ReflectionInterfaceDeclaration.java
@@ -55,7 +55,7 @@ public Context getContext() {
         return new ClassOrInterfaceDeclarationContext(clazz);
     }
 
-    @Override
+    @Deprecated
     public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes) {
         List<MethodDeclaration> methods = new ArrayList<>();
         for (Method method : clazz.getMethods()) {

diff --git a/...olver-core/src/main/java/me/tomassetti/symbolsolver/resolution/MethodResolutionLogic.java b/...olver-core/src/main/java/me/tomassetti/symbolsolver/resolution/MethodResolutionLogic.java
@@ -1,13 +1,22 @@
 package me.tomassetti.symbolsolver.resolution;
 
+import me.tomassetti.symbolsolver.core.resolution.Context;
+import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
+import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserEnumDeclaration;
+import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserInterfaceDeclaration;
 import me.tomassetti.symbolsolver.javaparsermodel.declarations.JavaParserMethodDeclaration;
+import me.tomassetti.symbolsolver.javassistmodel.JavassistClassDeclaration;
+import me.tomassetti.symbolsolver.javassistmodel.JavassistInterfaceDeclaration;
 import me.tomassetti.symbolsolver.model.declarations.MethodAmbiguityException;
 import me.tomassetti.symbolsolver.model.declarations.MethodDeclaration;
+import me.tomassetti.symbolsolver.model.declarations.TypeDeclaration;
 import me.tomassetti.symbolsolver.model.usages.MethodUsage;
 import me.tomassetti.symbolsolver.model.resolution.SymbolReference;
 import me.tomassetti.symbolsolver.model.declarations.TypeParameterDeclaration;
 import me.tomassetti.symbolsolver.model.resolution.TypeSolver;
 import me.tomassetti.symbolsolver.model.usages.typesystem.*;
+import me.tomassetti.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import me.tomassetti.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
 
 import java.util.*;
 import java.util.stream.Collectors;
@@ -440,4 +449,43 @@ private static boolean areOverride(MethodUsage winningCandidate, MethodUsage oth
         }
         return true;
     }
+
+    /**
+     * Replace TypeDeclaration.solveMethod
+     * @param typeDeclaration
+     * @param name
+     * @param parameterTypes
+     * @return
+     */
+    public static SymbolReference<MethodDeclaration> solveMethodInType(TypeDeclaration typeDeclaration, String name, List<Type> parameterTypes, TypeSolver typeSolver) {
+        if (typeDeclaration instanceof JavaParserClassDeclaration) {
+            Context ctx = ((JavaParserClassDeclaration)typeDeclaration).getContext();
+            return ctx.solveMethod(name, parameterTypes, typeSolver);
+        }
+        if (typeDeclaration instanceof JavaParserInterfaceDeclaration) {
+            Context ctx = ((JavaParserInterfaceDeclaration)typeDeclaration).getContext();
+            return ctx.solveMethod(name, parameterTypes, typeSolver);
+        }
+        if (typeDeclaration instanceof JavaParserEnumDeclaration) {
+            if (name.equals("values") && parameterTypes.isEmpty()) {
+                return SymbolReference.solved(new JavaParserEnumDeclaration.ValuesMethod((JavaParserEnumDeclaration) typeDeclaration, typeSolver));
+            }
+            Context ctx = ((JavaParserEnumDeclaration)typeDeclaration).getContext();
+            return ctx.solveMethod(name, parameterTypes, typeSolver);
+        }
+        if (typeDeclaration instanceof ReflectionClassDeclaration) {
+            return ((ReflectionClassDeclaration)typeDeclaration).solveMethod(name, parameterTypes);
+        }
+        if (typeDeclaration instanceof ReflectionInterfaceDeclaration) {
+            return ((ReflectionInterfaceDeclaration)typeDeclaration).solveMethod(name, parameterTypes);
+        }
+        if (typeDeclaration instanceof JavassistInterfaceDeclaration) {
+            return ((JavassistInterfaceDeclaration)typeDeclaration).solveMethod(name, parameterTypes);
+        }
+        if (typeDeclaration instanceof JavassistClassDeclaration) {
+            return ((JavassistClassDeclaration)typeDeclaration).solveMethod(name, parameterTypes);
+        }
+        throw new UnsupportedOperationException(typeDeclaration.getClass().getCanonicalName());
+    }
+
 }
diff --git a/...er-model/src/main/java/me/tomassetti/symbolsolver/model/declarations/TypeDeclaration.java b/...er-model/src/main/java/me/tomassetti/symbolsolver/model/declarations/TypeDeclaration.java
@@ -143,14 +143,6 @@ default List<FieldDeclaration> getDeclaredFields() {
     /// Resolution
     ///
 
-    /**
-     * Find the declaration of the method to invoke for a method call with the given name and actual parameter types.
-     *
-     * Deprecated because resolution logic should be outside declarations.
-     */
-    @Deprecated
-    SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes);
-
     /**
      * Solve any possible visible symbols including: fields, internal types, type variables, the type itself or its containers.
      *