more work on converting to moved classes

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

Hide file tree

Showing 33 changed files with 492 additions and 464 deletions.
diff --git a/...re/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java b/...re/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java
diff --git a/.../main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper.java b/.../main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper.java
@@ -16,17 +16,17 @@
 
 package com.github.javaparser.symbolsolver.javaparsermodel.contexts;
 
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.core.resolution.Context;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserEnumDeclaration;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserInterfaceDeclaration;
 import com.github.javaparser.symbolsolver.javassistmodel.JavassistClassDeclaration;
 import com.github.javaparser.symbolsolver.javassistmodel.JavassistEnumDeclaration;
 import com.github.javaparser.symbolsolver.javassistmodel.JavassistInterfaceDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.TypeDeclaration;
-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.reflectionmodel.ReflectionClassDeclaration;
 import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionEnumDeclaration;
 import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
@@ -43,9 +43,9 @@ private ContextHelper() {
         // prevent instantiation
     }
 
-    public static Optional<MethodUsage> solveMethodAsUsage(TypeDeclaration typeDeclaration, String name,
+    public static Optional<MethodUsage> solveMethodAsUsage(ResolvedTypeDeclaration typeDeclaration, String name,
-                                                           List<Type> argumentsTypes, TypeSolver typeSolver,
+                                                           List<ResolvedType> argumentsTypes, TypeSolver typeSolver,
-                                                           Context invokationContext, List<Type> typeParameters) {
+                                                           Context invokationContext, List<ResolvedType> typeParameters) {
         if (typeDeclaration instanceof JavassistClassDeclaration) {
             return ((JavassistClassDeclaration) typeDeclaration).solveMethodAsUsage(name, argumentsTypes, typeSolver, invokationContext, typeParameters);
         } else if (typeDeclaration instanceof JavassistInterfaceDeclaration) {

diff --git a/.../java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/FieldAccessContext.java b/.../java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/FieldAccessContext.java
@@ -19,16 +19,16 @@
 import com.github.javaparser.ast.expr.Expression;
 import com.github.javaparser.ast.expr.FieldAccessExpr;
 import com.github.javaparser.ast.expr.ThisExpr;
+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.ResolvedPrimitiveType;
+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.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.PrimitiveType;
-import com.github.javaparser.symbolsolver.model.typesystem.Type;
 import com.github.javaparser.symbolsolver.resolution.SymbolSolver;
 
 import java.util.List;
@@ -48,36 +48,36 @@ public FieldAccessContext(FieldAccessExpr wrappedNode, TypeSolver typeSolver) {
     }
 
     @Override
-    public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
+    public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
         if (wrappedNode.getField().toString().equals(name)) {
             if (wrappedNode.getScope() instanceof ThisExpr) {
-                Type typeOfThis = JavaParserFacade.get(typeSolver).getTypeOfThisIn(wrappedNode);
+                ResolvedType typeOfThis = JavaParserFacade.get(typeSolver).getTypeOfThisIn(wrappedNode);
                 return new SymbolSolver(typeSolver).solveSymbolInType(typeOfThis.asReferenceType().getTypeDeclaration(), name);
             }
         }
         return JavaParserFactory.getContext(getParentNode(wrappedNode), typeSolver).solveSymbol(name, typeSolver);
     }
 
     @Override
-    public SymbolReference<TypeDeclaration> solveType(String name, TypeSolver typeSolver) {
+    public SymbolReference<ResolvedTypeDeclaration> solveType(String name, TypeSolver typeSolver) {
         return JavaParserFactory.getContext(getParentNode(wrappedNode), typeSolver).solveType(name, typeSolver);
     }
 
     @Override
-    public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes, boolean staticOnly, TypeSolver typeSolver) {
+    public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly, TypeSolver typeSolver) {
         return JavaParserFactory.getContext(getParentNode(wrappedNode), typeSolver).solveMethod(name, parameterTypes, false, typeSolver);
     }
 
     @Override
     public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
         Expression scope = wrappedNode.getScope();
         if (wrappedNode.getField().toString().equals(name)) {
-            Type typeOfScope = JavaParserFacade.get(typeSolver).getType(scope);
+            ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(scope);
             if (typeOfScope.isArray() && name.equals(ARRAY_LENGTH_FIELD_NAME)) {
-                return Optional.of(new Value(PrimitiveType.INT, ARRAY_LENGTH_FIELD_NAME));
+                return Optional.of(new Value(ResolvedPrimitiveType.INT, ARRAY_LENGTH_FIELD_NAME));
             }
             if (typeOfScope.isReferenceType()) {
-                Optional<Type> typeUsage = typeOfScope.asReferenceType().getFieldType(name);
+                Optional<ResolvedType> typeUsage = typeOfScope.asReferenceType().getFieldType(name);
                 if (typeUsage.isPresent()) {
                     return Optional.of(new Value(typeUsage.get(), name));
                 } else {

diff --git a/...java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForStatementContext.java b/...java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForStatementContext.java
@@ -23,12 +23,12 @@
 import com.github.javaparser.ast.expr.VariableDeclarationExpr;
 import com.github.javaparser.ast.nodeTypes.NodeWithStatements;
 import com.github.javaparser.ast.stmt.ForStmt;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserSymbolDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration;
-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.typesystem.Type;
 
 import java.util.List;
 
@@ -41,7 +41,7 @@ public ForStatementContext(ForStmt wrappedNode, TypeSolver typeSolver) {
     }
 
     @Override
-    public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
+    public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
         for (Expression expression : wrappedNode.getInitialization()) {
             if (expression instanceof VariableDeclarationExpr) {
                 VariableDeclarationExpr variableDeclarationExpr = (VariableDeclarationExpr) expression;
@@ -63,7 +63,8 @@ public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, Type
     }
 
     @Override
-    public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) {
+    public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes,
+                                                                  boolean staticOnly, TypeSolver typeSolver) {
         return getParent().solveMethod(name, argumentsTypes, false, typeSolver);
     }
 }
diff --git a/...a/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForechStatementContext.java b/...a/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForechStatementContext.java
@@ -19,12 +19,12 @@
 import com.github.javaparser.ast.body.VariableDeclarator;
 import com.github.javaparser.ast.stmt.BlockStmt;
 import com.github.javaparser.ast.stmt.ForeachStmt;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserSymbolDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration;
-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.typesystem.Type;
 
 import java.util.List;
 
@@ -37,7 +37,7 @@ public ForechStatementContext(ForeachStmt wrappedNode, TypeSolver typeSolver) {
     }
 
     @Override
-    public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
+    public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
         if (wrappedNode.getVariable().getVariables().size() != 1) {
             throw new IllegalStateException();
         }
@@ -54,7 +54,8 @@ public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, Type
     }
 
     @Override
-    public SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) {
+    public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes,
+                                                                  boolean staticOnly, TypeSolver typeSolver) {
         return getParent().solveMethod(name, argumentsTypes, false, typeSolver);
     }
 }
diff --git a/...n/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/LambdaExprContext.java b/...n/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/LambdaExprContext.java
@@ -21,24 +21,24 @@
 import com.github.javaparser.ast.expr.Expression;
 import com.github.javaparser.ast.expr.LambdaExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedLambdaConstraintType;
+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.logic.FunctionalInterfaceLogic;
 import com.github.javaparser.symbolsolver.logic.InferenceContext;
-import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.TypeDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.TypeParameterDeclaration;
-import com.github.javaparser.symbolsolver.model.declarations.ValueDeclaration;
-import com.github.javaparser.symbolsolver.model.methods.MethodUsage;
 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.LambdaConstraintType;
 import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
-import com.github.javaparser.symbolsolver.model.typesystem.Type;
 import com.github.javaparser.symbolsolver.reflectionmodel.MyObjectProvider;
 import com.github.javaparser.symbolsolver.resolution.SymbolDeclarator;
-import javaslang.Tuple2;
+import javassist.compiler.ast.Pair;
 
 import java.util.*;
 
@@ -58,13 +58,13 @@ public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
         for (Parameter parameter : wrappedNode.getParameters()) {
             SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(parameter, typeSolver);
             int index = 0;
-            for (ValueDeclaration decl : sb.getSymbolDeclarations()) {
+            for (ResolvedValueDeclaration decl : sb.getSymbolDeclarations()) {
                 if (decl.getName().equals(name)) {
                     if (getParentNode(wrappedNode) instanceof MethodCallExpr) {
                         MethodCallExpr methodCallExpr = (MethodCallExpr) getParentNode(wrappedNode);
                         MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(methodCallExpr);
                         int i = pos(methodCallExpr, wrappedNode);
-                        Type lambdaType = methodUsage.getParamTypes().get(i);
+                        ResolvedType lambdaType = methodUsage.getParamTypes().get(i);
 
                         // Get the functional method in order for us to resolve it's type arguments properly
                         Optional<MethodUsage> functionalMethodOpt = FunctionalInterfaceLogic.getFunctionalMethod(lambdaType);
@@ -88,13 +88,13 @@ public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
                             if (!found) { return Optional.empty(); }
 
                             // Now resolve the argument type using the inference context
-                            Type argType = inferenceContext.resolve(inferenceContext.addSingle(functionalMethod.getParamType(lambdaParamIndex)));
+                            ResolvedType argType = inferenceContext.resolve(inferenceContext.addSingle(functionalMethod.getParamType(lambdaParamIndex)));
 
-                            LambdaConstraintType conType;
+                            ResolvedLambdaConstraintType conType;
                             if (argType.isWildcard()){
-                                conType = LambdaConstraintType.bound(argType.asWildcard().getBoundedType());
+                                conType = ResolvedLambdaConstraintType.bound(argType.asWildcard().getBoundedType());
                             } else {
-                                conType = LambdaConstraintType.bound(argType);
+                                conType = ResolvedLambdaConstraintType.bound(argType);
                             }
                             Value value = new Value(conType, name);
                             return Optional.of(value);
@@ -103,18 +103,18 @@ public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
                         }
                     } else if (getParentNode(wrappedNode) instanceof VariableDeclarator) {
                         VariableDeclarator variableDeclarator = (VariableDeclarator) getParentNode(wrappedNode);
-                        Type t = JavaParserFacade.get(typeSolver).convertToUsageVariableType(variableDeclarator);
+                        ResolvedType t = JavaParserFacade.get(typeSolver).convertToUsageVariableType(variableDeclarator);
                         Optional<MethodUsage> functionalMethod = FunctionalInterfaceLogic.getFunctionalMethod(t);
                         if (functionalMethod.isPresent()) {
-                            Type lambdaType = functionalMethod.get().getParamType(index);
+                            ResolvedType lambdaType = functionalMethod.get().getParamType(index);
 
                             // Replace parameter from declarator
-                            Map<TypeParameterDeclaration, Type> inferredTypes = new HashMap<>();
+                            Map<ResolvedTypeParameterDeclaration, ResolvedType> inferredTypes = new HashMap<>();
                             if (lambdaType.isReferenceType()) {
-                                for (Tuple2<TypeParameterDeclaration, Type> entry : lambdaType.asReferenceType().getTypeParametersMap()) {
+                                for (com.github.javaparser.utils.Pair<ResolvedTypeParameterDeclaration, ResolvedType> entry : lambdaType.asReferenceType().getTypeParametersMap()) {
-                                    if (entry._2.isTypeVariable() && entry._2.asTypeParameter().declaredOnType()) {
+                                    if (entry.b.isTypeVariable() && entry.b.asTypeParameter().declaredOnType()) {
-                                        Type ot = t.asReferenceType().typeParametersMap().getValue(entry._1);
+                                        ResolvedType ot = t.asReferenceType().typeParametersMap().getValue(entry.a);
-                                        lambdaType = lambdaType.replaceTypeVariables(entry._1, ot, inferredTypes);
+                                        lambdaType = lambdaType.replaceTypeVariables(entry.a, ot, inferredTypes);
                                     }
                                 }
                             } else if (lambdaType.isTypeVariable() && lambdaType.asTypeParameter().declaredOnType()) {
@@ -139,10 +139,10 @@ public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
     }
 
     @Override
-    public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
+    public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
         for (Parameter parameter : wrappedNode.getParameters()) {
             SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(parameter, typeSolver);
-            SymbolReference<ValueDeclaration> symbolReference = solveWith(sb, name);
+            SymbolReference<ResolvedValueDeclaration> symbolReference = solveWith(sb, name);
             if (symbolReference.isSolved()) {
                 return symbolReference;
             }
@@ -153,13 +153,13 @@ public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, Type
     }
 
     @Override
-    public SymbolReference<TypeDeclaration> solveType(String name, TypeSolver typeSolver) {
+    public SymbolReference<ResolvedTypeDeclaration> solveType(String name, TypeSolver typeSolver) {
         return getParent().solveType(name, typeSolver);
     }
 
     @Override
-    public SymbolReference<MethodDeclaration> solveMethod(
+    public SymbolReference<ResolvedMethodDeclaration> solveMethod(
-            String name, List<Type> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) {
+            String name, List<ResolvedType> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) {
         return getParent().solveMethod(name, argumentsTypes, false, typeSolver);
     }
 
@@ -168,7 +168,7 @@ public SymbolReference<MethodDeclaration> solveMethod(
     ///
 
     protected final Optional<Value> solveWithAsValue(SymbolDeclarator symbolDeclarator, String name, TypeSolver typeSolver) {
-        for (ValueDeclaration decl : symbolDeclarator.getSymbolDeclarations()) {
+        for (ResolvedValueDeclaration decl : symbolDeclarator.getSymbolDeclarations()) {
             if (decl.getName().equals(name)) {
 
                 throw new UnsupportedOperationException();