From 5d8d0cb7947efcf2282f7d056302dd905f348532 Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Thu, 28 Sep 2017 22:36:20 +0200 Subject: [PATCH] more work on converting to moved classes --- .../javaparsermodel/JavaParserFacade.java | 121 +++++++-------- .../contexts/ContextHelper.java | 12 +- .../contexts/FieldAccessContext.java | 24 +-- .../contexts/ForStatementContext.java | 11 +- .../contexts/ForechStatementContext.java | 11 +- .../contexts/LambdaExprContext.java | 54 +++---- .../contexts/MethodCallExprContext.java | 138 +++++++++--------- .../contexts/MethodContext.java | 1 - .../contexts/StatementContext.java | 22 +-- .../contexts/SwitchEntryContext.java | 14 +- .../contexts/TryWithResourceContext.java | 11 +- .../DefaultConstructorDeclaration.java | 23 +-- .../JavaParserAnnotationDeclaration.java | 20 ++- .../JavaParserAnonymousClassDeclaration.java | 2 +- .../JavaParserClassDeclaration.java | 77 +++++----- .../JavaParserConstructorDeclaration.java | 24 +-- .../JavaParserEnumConstantDeclaration.java | 8 +- .../JavaParserEnumDeclaration.java | 34 +++-- .../JavaParserFieldDeclaration.java | 16 +- .../JavaParserInterfaceDeclaration.java | 50 ++++--- .../JavaParserParameterDeclaration.java | 3 +- .../JavaParserSymbolDeclaration.java | 21 ++- .../declarations/JavaParserTypeAdapter.java | 25 ++-- .../declarations/JavaParserTypeParameter.java | 49 +++---- .../JavassistClassDeclaration.java | 13 +- .../JavassistEnumDeclaration.java | 15 +- .../JavassistInterfaceDeclaration.java | 13 +- .../model/typesystem/LazyType.java | 33 +++-- .../reflectionmodel/ReflectionFactory.java | 14 +- .../ReflectionInterfaceDeclaration.java | 3 +- .../ConstructorResolutionLogic.java | 66 +++++---- .../resolution/MethodResolutionLogic.java | 13 +- .../logic/AbstractTypeDeclaration.java | 15 +- 33 files changed, 492 insertions(+), 464 deletions(-) diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java index f116ab3cf1..2f0cbff115 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade.java @@ -24,17 +24,17 @@ import com.github.javaparser.ast.expr.*; import com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt; import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.type.UnknownType; import com.github.javaparser.ast.type.WildcardType; -import com.github.javaparser.resolution.declarations.ResolvedAnnotationDeclaration; -import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +import com.github.javaparser.resolution.MethodUsage; +import com.github.javaparser.resolution.declarations.*; +import com.github.javaparser.resolution.types.ResolvedArrayType; +import com.github.javaparser.resolution.types.ResolvedType; +import com.github.javaparser.resolution.types.ResolvedVoidType; +import com.github.javaparser.resolution.types.ResolvedWildcard; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.javaparsermodel.declarations.*; -import com.github.javaparser.symbolsolver.model.declarations.*; -import com.github.javaparser.symbolsolver.model.declarations.ConstructorDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.TypeDeclaration; -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.typesystem.*; @@ -68,8 +68,8 @@ public class JavaParserFacade { private static Map instances = new WeakHashMap<>(); private TypeSolver typeSolver; private SymbolSolver symbolSolver; - private Map cacheWithLambdasSolved = new IdentityHashMap<>(); - private Map cacheWithoutLambdasSolved = new IdentityHashMap<>(); + private Map cacheWithLambdasSolved = new IdentityHashMap<>(); + private Map cacheWithoutLambdasSolved = new IdentityHashMap<>(); private TypeExtractor typeExtractor; private JavaParserFacade(TypeSolver typeSolver) { @@ -97,9 +97,9 @@ public static void clearInstances() { instances.clear(); } - protected static Type solveGenericTypes(Type type, Context context, TypeSolver typeSolver) { + protected static ResolvedType solveGenericTypes(ResolvedType type, Context context, TypeSolver typeSolver) { if (type.isTypeVariable()) { - Optional solved = context.solveGenericType(type.describe(), typeSolver); + Optional solved = context.solveGenericType(type.describe(), typeSolver); if (solved.isPresent()) { return solved.get(); } else { @@ -107,31 +107,31 @@ protected static Type solveGenericTypes(Type type, Context context, TypeSolver t } } else if (type.isWildcard()) { if (type.asWildcard().isExtends() || type.asWildcard().isSuper()) { - Wildcard wildcardUsage = type.asWildcard(); - Type boundResolved = solveGenericTypes(wildcardUsage.getBoundedType(), context, typeSolver); + ResolvedWildcard wildcardUsage = type.asWildcard(); + ResolvedType boundResolved = solveGenericTypes(wildcardUsage.getBoundedType(), context, typeSolver); if (wildcardUsage.isExtends()) { - return Wildcard.extendsBound(boundResolved); + return ResolvedWildcard.extendsBound(boundResolved); } else { - return Wildcard.superBound(boundResolved); + return ResolvedWildcard.superBound(boundResolved); } } else { return type; } } else { - Type result = type; + ResolvedType result = type; return result; } } - public SymbolReference solve(NameExpr nameExpr) { + public SymbolReference solve(NameExpr nameExpr) { return symbolSolver.solveSymbol(nameExpr.getName().getId(), nameExpr); } - public SymbolReference solve(SimpleName nameExpr) { + public SymbolReference solve(SimpleName nameExpr) { return symbolSolver.solveSymbol(nameExpr.getId(), nameExpr); } - public SymbolReference solve(Expression expr) { + public SymbolReference solve(Expression expr) { if (expr instanceof NameExpr) { return solve((NameExpr) expr); } else { @@ -139,20 +139,20 @@ public SymbolReference solve(Expression expr) { } } - public SymbolReference solve(MethodCallExpr methodCallExpr) { + public SymbolReference solve(MethodCallExpr methodCallExpr) { return solve(methodCallExpr, true); } - public SymbolReference solve(ObjectCreationExpr objectCreationExpr) { + public SymbolReference solve(ObjectCreationExpr objectCreationExpr) { return solve(objectCreationExpr, true); } - public SymbolReference solve(ExplicitConstructorInvocationStmt explicitConstructorInvocationStmt) { + public SymbolReference solve(ExplicitConstructorInvocationStmt explicitConstructorInvocationStmt) { return solve(explicitConstructorInvocationStmt, true); } - public SymbolReference solve(ExplicitConstructorInvocationStmt explicitConstructorInvocationStmt, boolean solveLambdas) { - List argumentTypes = new LinkedList<>(); + public SymbolReference solve(ExplicitConstructorInvocationStmt explicitConstructorInvocationStmt, boolean solveLambdas) { + List argumentTypes = new LinkedList<>(); List placeholders = new LinkedList<>(); solveArguments(explicitConstructorInvocationStmt, explicitConstructorInvocationStmt.getArguments(), solveLambdas, argumentTypes, placeholders); @@ -164,7 +164,7 @@ public SymbolReference solve(ExplicitConstructorInvocati ClassOrInterfaceDeclaration classNode = optAncestor.get(); TypeDeclaration typeDecl = null; if (!explicitConstructorInvocationStmt.isThis()) { - Type classDecl = JavaParserFacade.get(typeSolver).convert(classNode.getExtendedTypes(0), classNode); + ResolvedType classDecl = JavaParserFacade.get(typeSolver).convert(classNode.getExtendedTypes(0), classNode); if (classDecl.isReferenceType()) { typeDecl = classDecl.asReferenceType().getTypeDeclaration(); } @@ -177,20 +177,20 @@ public SymbolReference solve(ExplicitConstructorInvocati if (typeDecl == null) { return SymbolReference.unsolved(ConstructorDeclaration.class); } - SymbolReference res = ConstructorResolutionLogic.findMostApplicable(((ClassDeclaration) typeDecl).getConstructors(), argumentTypes, typeSolver); + SymbolReference res = ConstructorResolutionLogic.findMostApplicable(((ResolvedClassDeclaration) typeDecl).getConstructors(), argumentTypes, typeSolver); for (LambdaArgumentTypePlaceholder placeholder : placeholders) { placeholder.setMethod(res); } return res; } - public SymbolReference solve(ThisExpr node){ + public SymbolReference solve(ThisExpr node){ // If 'this' is prefixed by a class eg. MyClass.this if (node.getClassExpr().isPresent()){ // Get the class name String className = node.getClassExpr().get().toString(); // Attempt to resolve using a typeSolver - SymbolReference clazz = typeSolver.tryToSolveType(className); + SymbolReference clazz = typeSolver.tryToSolveType(className); if (clazz.isSolved()){ return SymbolReference.solved(clazz.getCorrespondingDeclaration()); } @@ -209,24 +209,25 @@ public SymbolReference solve(ThisExpr node){ /** * Given a constructor call find out to which constructor declaration it corresponds. */ - public SymbolReference solve(ObjectCreationExpr objectCreationExpr, boolean solveLambdas) { - List argumentTypes = new LinkedList<>(); + public SymbolReference solve(ObjectCreationExpr objectCreationExpr, boolean solveLambdas) { + List argumentTypes = new LinkedList<>(); List placeholders = new LinkedList<>(); solveArguments(objectCreationExpr, objectCreationExpr.getArguments(), solveLambdas, argumentTypes, placeholders); - Type classDecl = JavaParserFacade.get(typeSolver).convert(objectCreationExpr.getType(), objectCreationExpr); + ResolvedType classDecl = JavaParserFacade.get(typeSolver).convert(objectCreationExpr.getType(), objectCreationExpr); if (!classDecl.isReferenceType()) { return SymbolReference.unsolved(ConstructorDeclaration.class); } - SymbolReference res = ConstructorResolutionLogic.findMostApplicable(((ClassDeclaration) classDecl.asReferenceType().getTypeDeclaration()).getConstructors(), argumentTypes, typeSolver); + SymbolReference res = ConstructorResolutionLogic.findMostApplicable(((ResolvedClassDeclaration) classDecl.asReferenceType().getTypeDeclaration()).getConstructors(), argumentTypes, typeSolver); for (LambdaArgumentTypePlaceholder placeholder : placeholders) { placeholder.setMethod(res); } return res; } - private void solveArguments(Node node, NodeList args, boolean solveLambdas, List argumentTypes, List placeholders) { + private void solveArguments(Node node, NodeList args, boolean solveLambdas, List argumentTypes, + List placeholders) { int i = 0; for (Expression parameterValue : args) { if (parameterValue instanceof LambdaExpr || parameterValue instanceof MethodReferenceExpr) { @@ -250,13 +251,13 @@ private void solveArguments(Node node, NodeList args, boolean solveL /** * Given a method call find out to which method declaration it corresponds. */ - public SymbolReference solve(MethodCallExpr methodCallExpr, boolean solveLambdas) { - List argumentTypes = new LinkedList<>(); + public SymbolReference solve(MethodCallExpr methodCallExpr, boolean solveLambdas) { + List argumentTypes = new LinkedList<>(); List placeholders = new LinkedList<>(); solveArguments(methodCallExpr, methodCallExpr.getArguments(), solveLambdas, argumentTypes, placeholders); - SymbolReference res = JavaParserFactory.getContext(methodCallExpr, typeSolver).solveMethod(methodCallExpr.getName().getId(), argumentTypes, false, typeSolver); + SymbolReference res = JavaParserFactory.getContext(methodCallExpr, typeSolver).solveMethod(methodCallExpr.getName().getId(), argumentTypes, false, typeSolver); for (LambdaArgumentTypePlaceholder placeholder : placeholders) { placeholder.setMethod(res); } @@ -265,7 +266,7 @@ public SymbolReference solve(MethodCallExpr methodCallExpr, b public SymbolReference solve(AnnotationExpr annotationExpr) { Context context = JavaParserFactory.getContext(annotationExpr, typeSolver); - SymbolReference typeDeclarationSymbolReference = context.solveType(annotationExpr.getNameAsString(), typeSolver); + SymbolReference typeDeclarationSymbolReference = context.solveType(annotationExpr.getNameAsString(), typeSolver); ResolvedAnnotationDeclaration annotationDeclaration = (ResolvedAnnotationDeclaration) typeDeclarationSymbolReference.getCorrespondingDeclaration(); if (typeDeclarationSymbolReference.isSolved()) { return SymbolReference.solved(annotationDeclaration); @@ -274,14 +275,14 @@ public SymbolReference solve(AnnotationExpr annot } } - public Type getType(Node node) { + public ResolvedType getType(Node node) { return getType(node, true); } - public Type getType(Node node, boolean solveLambdas) { + public ResolvedType getType(Node node, boolean solveLambdas) { if (solveLambdas) { if (!cacheWithLambdasSolved.containsKey(node)) { - Type res = getTypeConcrete(node, solveLambdas); + ResolvedType res = getTypeConcrete(node, solveLambdas); cacheWithLambdasSolved.put(node, res); @@ -303,13 +304,13 @@ public Type getType(Node node, boolean solveLambdas) { } return cacheWithLambdasSolved.get(node); } else { - Optional res = find(cacheWithLambdasSolved, node); + Optional res = find(cacheWithLambdasSolved, node); if (res.isPresent()) { return res.get(); } res = find(cacheWithoutLambdasSolved, node); if (!res.isPresent()) { - Type resType = getTypeConcrete(node, solveLambdas); + ResolvedType resType = getTypeConcrete(node, solveLambdas); cacheWithoutLambdasSolved.put(node, resType); logger.finer("getType on " + node + " (no solveLambdas) -> " + res); return resType; @@ -318,7 +319,7 @@ public Type getType(Node node, boolean solveLambdas) { } } - private Optional find(Map map, Node node) { + private Optional find(Map map, Node node) { if (map.containsKey(node)) { return Optional.of(map.get(node)); } @@ -335,7 +336,7 @@ private Optional find(Map map, Node node) { * @param map * @return */ - private Optional find(Map map, LambdaExpr lambdaExpr) { + private Optional find(Map map, LambdaExpr lambdaExpr) { for (Node key : map.keySet()) { if (key instanceof LambdaExpr) { LambdaExpr keyLambdaExpr = (LambdaExpr) key; @@ -404,19 +405,19 @@ protected com.github.javaparser.ast.body.TypeDeclaration findContainingTypeDe } } - public Type convertToUsageVariableType(VariableDeclarator var) { - Type type = JavaParserFacade.get(typeSolver).convertToUsage(var.getType(), var); + public ResolvedType convertToUsageVariableType(VariableDeclarator var) { + ResolvedType type = JavaParserFacade.get(typeSolver).convertToUsage(var.getType(), var); return type; } - public Type convertToUsage(com.github.javaparser.ast.type.Type type, Node context) { + public ResolvedType convertToUsage(com.github.javaparser.ast.type.Type type, Node context) { if (type instanceof UnknownType) { throw new IllegalArgumentException("Unknown type"); } return convertToUsage(type, JavaParserFactory.getContext(context, typeSolver)); } - public Type convertToUsage(com.github.javaparser.ast.type.Type type) { + public ResolvedType convertToUsage(com.github.javaparser.ast.type.Type type) { return convertToUsage(type, type); } @@ -430,7 +431,7 @@ private String qName(ClassOrInterfaceType classOrInterfaceType) { } } - protected Type convertToUsage(com.github.javaparser.ast.type.Type type, Context context) { + protected ResolvedType convertToUsage(com.github.javaparser.ast.type.Type type, Context context) { if (type instanceof ClassOrInterfaceType) { ClassOrInterfaceType classOrInterfaceType = (ClassOrInterfaceType) type; String name = qName(classOrInterfaceType); @@ -439,7 +440,7 @@ protected Type convertToUsage(com.github.javaparser.ast.type.Type type, Context throw new UnsolvedSymbolException(name); } TypeDeclaration typeDeclaration = ref.getCorrespondingDeclaration(); - List typeParameters = Collections.emptyList(); + List typeParameters = Collections.emptyList(); if (classOrInterfaceType.getTypeArguments().isPresent()) { typeParameters = classOrInterfaceType.getTypeArguments().get().stream().map((pt) -> convertToUsage(pt, context)).collect(Collectors.toList()); } @@ -458,35 +459,35 @@ protected Type convertToUsage(com.github.javaparser.ast.type.Type type, Context } else if (type instanceof WildcardType) { WildcardType wildcardType = (WildcardType) type; if (wildcardType.getExtendedTypes().isPresent() && !wildcardType.getSuperTypes().isPresent()) { - return Wildcard.extendsBound(convertToUsage(wildcardType.getExtendedTypes().get(), context)); // removed (ReferenceTypeImpl) + return ResolvedWildcard.extendsBound(convertToUsage(wildcardType.getExtendedTypes().get(), context)); // removed (ReferenceTypeImpl) } else if (!wildcardType.getExtendedTypes().isPresent() && wildcardType.getSuperTypes().isPresent()) { - return Wildcard.superBound(convertToUsage(wildcardType.getSuperTypes().get(), context)); // removed (ReferenceTypeImpl) + return ResolvedWildcard.superBound(convertToUsage(wildcardType.getSuperTypes().get(), context)); // removed (ReferenceTypeImpl) } else if (!wildcardType.getExtendedTypes().isPresent() && !wildcardType.getSuperTypes().isPresent()) { - return Wildcard.UNBOUNDED; + return ResolvedWildcard.UNBOUNDED; } else { throw new UnsupportedOperationException(wildcardType.toString()); } } else if (type instanceof com.github.javaparser.ast.type.VoidType) { - return VoidType.INSTANCE; + return ResolvedVoidType.INSTANCE; } else if (type instanceof com.github.javaparser.ast.type.ArrayType) { com.github.javaparser.ast.type.ArrayType jpArrayType = (com.github.javaparser.ast.type.ArrayType) type; - return new ArrayType(convertToUsage(jpArrayType.getComponentType(), context)); + return new ResolvedArrayType(convertToUsage(jpArrayType.getComponentType(), context)); } else { throw new UnsupportedOperationException(type.getClass().getCanonicalName()); } } - public Type convert(com.github.javaparser.ast.type.Type type, Node node) { + public ResolvedType convert(Type type, Node node) { return convert(type, JavaParserFactory.getContext(node, typeSolver)); } - public Type convert(com.github.javaparser.ast.type.Type type, Context context) { + public ResolvedType convert(com.github.javaparser.ast.type.Type type, Context context) { return convertToUsage(type, context); } public MethodUsage solveMethodAsUsage(MethodCallExpr call) { - List params = new ArrayList<>(); + List params = new ArrayList<>(); if (call.getArguments() != null) { for (Expression param : call.getArguments()) { //getTypeConcrete(Node node, boolean solveLambdas) @@ -514,7 +515,7 @@ public ResolvedReferenceTypeDeclaration getTypeDeclaration(ClassOrInterfaceDecla /** * "this" inserted in the given point, which type would have? */ - public Type getTypeOfThisIn(Node node) { + public ResolvedType getTypeOfThisIn(Node node) { // TODO consider static methods if (node instanceof ClassOrInterfaceDeclaration) { return new ReferenceTypeImpl(getTypeDeclaration((ClassOrInterfaceDeclaration) node), typeSolver); @@ -529,7 +530,7 @@ public Type getTypeOfThisIn(Node node) { } } - public ReferenceTypeDeclaration getTypeDeclaration(com.github.javaparser.ast.body.TypeDeclaration typeDeclaration) { + public ResolvedReferenceTypeDeclaration getTypeDeclaration(com.github.javaparser.ast.body.TypeDeclaration typeDeclaration) { return JavaParserFactory.toTypeDeclaration(typeDeclaration, typeSolver); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper.java index e4b791dd59..c24c7c2df1 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper.java @@ -16,6 +16,9 @@ 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; @@ -23,10 +26,7 @@ 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 solveMethodAsUsage(TypeDeclaration typeDeclaration, String name, - List argumentsTypes, TypeSolver typeSolver, - Context invokationContext, List typeParameters) { + public static Optional solveMethodAsUsage(ResolvedTypeDeclaration typeDeclaration, String name, + List argumentsTypes, TypeSolver typeSolver, + Context invokationContext, List typeParameters) { if (typeDeclaration instanceof JavassistClassDeclaration) { return ((JavassistClassDeclaration) typeDeclaration).solveMethodAsUsage(name, argumentsTypes, typeSolver, invokationContext, typeParameters); } else if (typeDeclaration instanceof JavassistInterfaceDeclaration) { diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/FieldAccessContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/FieldAccessContext.java index 85b30481fb..1f09ad6ec9 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/FieldAccessContext.java +++ b/java-symbol-solver-core/src/main/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,10 +48,10 @@ public FieldAccessContext(FieldAccessExpr wrappedNode, TypeSolver typeSolver) { } @Override - public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference 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); } } @@ -59,12 +59,12 @@ public SymbolReference solveSymbol(String name, Type } @Override - public SymbolReference solveType(String name, TypeSolver typeSolver) { + public SymbolReference solveType(String name, TypeSolver typeSolver) { return JavaParserFactory.getContext(getParentNode(wrappedNode), typeSolver).solveType(name, typeSolver); } @Override - public SymbolReference solveMethod(String name, List parameterTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod(String name, List parameterTypes, boolean staticOnly, TypeSolver typeSolver) { return JavaParserFactory.getContext(getParentNode(wrappedNode), typeSolver).solveMethod(name, parameterTypes, false, typeSolver); } @@ -72,12 +72,12 @@ public SymbolReference solveMethod(String name, List pa public Optional 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 typeUsage = typeOfScope.asReferenceType().getFieldType(name); + Optional typeUsage = typeOfScope.asReferenceType().getFieldType(name); if (typeUsage.isPresent()) { return Optional.of(new Value(typeUsage.get(), name)); } else { diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForStatementContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForStatementContext.java index e6a17e4f34..77965bd088 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForStatementContext.java +++ b/java-symbol-solver-core/src/main/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 solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { for (Expression expression : wrappedNode.getInitialization()) { if (expression instanceof VariableDeclarationExpr) { VariableDeclarationExpr variableDeclarationExpr = (VariableDeclarationExpr) expression; @@ -63,7 +63,8 @@ public SymbolReference solveSymbol(String name, Type } @Override - public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod(String name, List argumentsTypes, + boolean staticOnly, TypeSolver typeSolver) { return getParent().solveMethod(name, argumentsTypes, false, typeSolver); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForechStatementContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForechStatementContext.java index 35df8baab9..ed874899f6 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForechStatementContext.java +++ b/java-symbol-solver-core/src/main/java/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 solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { if (wrappedNode.getVariable().getVariables().size() != 1) { throw new IllegalStateException(); } @@ -54,7 +54,8 @@ public SymbolReference solveSymbol(String name, Type } @Override - public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod(String name, List argumentsTypes, + boolean staticOnly, TypeSolver typeSolver) { return getParent().solveMethod(name, argumentsTypes, false, typeSolver); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/LambdaExprContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/LambdaExprContext.java index 02c69ee5de..fe2ec8ba98 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/LambdaExprContext.java +++ b/java-symbol-solver-core/src/main/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 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 functionalMethodOpt = FunctionalInterfaceLogic.getFunctionalMethod(lambdaType); @@ -88,13 +88,13 @@ public Optional 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 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 functionalMethod = FunctionalInterfaceLogic.getFunctionalMethod(t); if (functionalMethod.isPresent()) { - Type lambdaType = functionalMethod.get().getParamType(index); + ResolvedType lambdaType = functionalMethod.get().getParamType(index); // Replace parameter from declarator - Map inferredTypes = new HashMap<>(); + Map inferredTypes = new HashMap<>(); if (lambdaType.isReferenceType()) { - for (Tuple2 entry : lambdaType.asReferenceType().getTypeParametersMap()) { - if (entry._2.isTypeVariable() && entry._2.asTypeParameter().declaredOnType()) { - Type ot = t.asReferenceType().typeParametersMap().getValue(entry._1); - lambdaType = lambdaType.replaceTypeVariables(entry._1, ot, inferredTypes); + for (com.github.javaparser.utils.Pair entry : lambdaType.asReferenceType().getTypeParametersMap()) { + if (entry.b.isTypeVariable() && entry.b.asTypeParameter().declaredOnType()) { + ResolvedType ot = t.asReferenceType().typeParametersMap().getValue(entry.a); + lambdaType = lambdaType.replaceTypeVariables(entry.a, ot, inferredTypes); } } } else if (lambdaType.isTypeVariable() && lambdaType.asTypeParameter().declaredOnType()) { @@ -139,10 +139,10 @@ public Optional solveSymbolAsValue(String name, TypeSolver typeSolver) { } @Override - public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { for (Parameter parameter : wrappedNode.getParameters()) { SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(parameter, typeSolver); - SymbolReference symbolReference = solveWith(sb, name); + SymbolReference symbolReference = solveWith(sb, name); if (symbolReference.isSolved()) { return symbolReference; } @@ -153,13 +153,13 @@ public SymbolReference solveSymbol(String name, Type } @Override - public SymbolReference solveType(String name, TypeSolver typeSolver) { + public SymbolReference solveType(String name, TypeSolver typeSolver) { return getParent().solveType(name, typeSolver); } @Override - public SymbolReference solveMethod( - String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod( + String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { return getParent().solveMethod(name, argumentsTypes, false, typeSolver); } @@ -168,7 +168,7 @@ public SymbolReference solveMethod( /// protected final Optional 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(); diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodCallExprContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodCallExprContext.java index 8f3454f8ef..0e0a4717f3 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodCallExprContext.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodCallExprContext.java @@ -19,25 +19,19 @@ import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.expr.MethodCallExpr; import com.github.javaparser.ast.expr.NameExpr; +import com.github.javaparser.resolution.MethodUsage; +import com.github.javaparser.resolution.UnsolvedSymbolException; +import com.github.javaparser.resolution.declarations.*; +import com.github.javaparser.resolution.types.*; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; -import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.ParameterDeclaration; -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.UnsolvedSymbolException; import com.github.javaparser.symbolsolver.model.resolution.Value; import com.github.javaparser.symbolsolver.model.typesystem.*; -import com.github.javaparser.symbolsolver.model.typesystem.ArrayType; -import com.github.javaparser.symbolsolver.model.typesystem.ReferenceType; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration; import com.github.javaparser.symbolsolver.resolution.MethodResolutionLogic; -import javaslang.Tuple2; +import com.github.javaparser.utils.Pair; import java.util.ArrayList; import java.util.HashMap; @@ -60,10 +54,10 @@ public MethodCallExprContext(MethodCallExpr wrappedNode, TypeSolver typeSolver) /// @Override - public Optional solveGenericType(String name, TypeSolver typeSolver) { + public Optional solveGenericType(String name, TypeSolver typeSolver) { if(wrappedNode.getScope().isPresent()){ - Type typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope().get()); - Optional res = typeOfScope.asReferenceType().getGenericParameterByName(name); + ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope().get()); + Optional res = typeOfScope.asReferenceType().getGenericParameterByName(name); return res; } else{ return Optional.empty(); @@ -76,15 +70,15 @@ public String toString() { } @Override - public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver) { + public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver) { if (wrappedNode.getScope().isPresent()) { Expression scope = wrappedNode.getScope().get(); // Consider static method calls if (scope instanceof NameExpr) { String className = ((NameExpr) scope).getName().getId(); - SymbolReference ref = solveType(className, typeSolver); + SymbolReference ref = solveType(className, typeSolver); if (ref.isSolved()) { - SymbolReference m = MethodResolutionLogic.solveMethodInType(ref.getCorrespondingDeclaration(), name, argumentsTypes, typeSolver); + SymbolReference m = MethodResolutionLogic.solveMethodInType(ref.getCorrespondingDeclaration(), name, argumentsTypes, typeSolver); if (m.isSolved()) { MethodUsage methodUsage = new MethodUsage(m.getCorrespondingDeclaration()); methodUsage = resolveMethodTypeParametersFromExplicitList(typeSolver, methodUsage); @@ -97,19 +91,19 @@ public Optional solveMethodAsUsage(String name, List argument } } - Type typeOfScope = JavaParserFacade.get(typeSolver).getType(scope); + ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(scope); // we can replace the parameter types from the scope into the typeParametersValues - Map inferredTypes = new HashMap<>(); + Map inferredTypes = new HashMap<>(); for (int i = 0; i < argumentsTypes.size(); i++) { // by replacing types I can also find new equivalences // for example if I replace T=U with String because I know that T=String I can derive that also U equal String - Type originalArgumentType = argumentsTypes.get(i); - Type updatedArgumentType = usingParameterTypesFromScope(typeOfScope, originalArgumentType, inferredTypes); + ResolvedType originalArgumentType = argumentsTypes.get(i); + ResolvedType updatedArgumentType = usingParameterTypesFromScope(typeOfScope, originalArgumentType, inferredTypes); argumentsTypes.set(i, updatedArgumentType); } for (int i = 0; i < argumentsTypes.size(); i++) { - Type updatedArgumentType = applyInferredTypes(argumentsTypes.get(i), inferredTypes); + ResolvedType updatedArgumentType = applyInferredTypes(argumentsTypes.get(i), inferredTypes); argumentsTypes.set(i, updatedArgumentType); } @@ -125,12 +119,12 @@ public Optional solveMethodAsUsage(String name, List argument private MethodUsage resolveMethodTypeParametersFromExplicitList(TypeSolver typeSolver, MethodUsage methodUsage) { if (wrappedNode.getTypeArguments().isPresent()) { - final List typeArguments = new ArrayList<>(); + final List typeArguments = new ArrayList<>(); for (com.github.javaparser.ast.type.Type ty : wrappedNode.getTypeArguments().get()) { typeArguments.add(JavaParserFacade.get(typeSolver).convertToUsage(ty)); } - List tyParamDecls = methodUsage.getDeclaration().getTypeParameters(); + List tyParamDecls = methodUsage.getDeclaration().getTypeParameters(); if (tyParamDecls.size() == typeArguments.size()) { for (int i = 0; i < tyParamDecls.size(); i++) { methodUsage = methodUsage.replaceTypeParameter(tyParamDecls.get(i), typeArguments.get(i)); @@ -142,7 +136,7 @@ private MethodUsage resolveMethodTypeParametersFromExplicitList(TypeSolver typeS } @Override - public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { return getParent().solveSymbol(name, typeSolver); } @@ -153,21 +147,21 @@ public Optional solveSymbolAsValue(String name, TypeSolver typeSolver) { } @Override - public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { if (wrappedNode.getScope().isPresent()) { Expression scope = wrappedNode.getScope().get(); // consider static methods if (scope instanceof NameExpr) { NameExpr scopeAsName = (NameExpr) scope; - SymbolReference symbolReference = this.solveType(scopeAsName.getName().getId(), typeSolver); + SymbolReference symbolReference = this.solveType(scopeAsName.getName().getId(), typeSolver); if (symbolReference.isSolved() && symbolReference.getCorrespondingDeclaration().isType()) { - TypeDeclaration typeDeclaration = symbolReference.getCorrespondingDeclaration().asType(); + ResolvedTypeDeclaration typeDeclaration = symbolReference.getCorrespondingDeclaration().asType(); return MethodResolutionLogic.solveMethodInType(typeDeclaration, name, argumentsTypes, false, typeSolver); } } - Type typeOfScope = null; + ResolvedType typeOfScope = null; try { typeOfScope = JavaParserFacade.get(typeSolver).getType(scope); } catch (Exception e) { @@ -183,20 +177,20 @@ public SymbolReference solveMethod(String name, List ar // method call on array are Object methods return MethodResolutionLogic.solveMethodInType(new ReflectionClassDeclaration(Object.class, typeSolver), name, argumentsTypes, false, typeSolver); } else if (typeOfScope.isTypeVariable()) { - for (TypeParameterDeclaration.Bound bound : typeOfScope.asTypeParameter().getBounds(typeSolver)) { - SymbolReference res = MethodResolutionLogic.solveMethodInType(bound.getType().asReferenceType().getTypeDeclaration(), name, argumentsTypes, false, typeSolver); + for (ResolvedTypeParameterDeclaration.Bound bound : typeOfScope.asTypeParameter().getBounds()) { + SymbolReference res = MethodResolutionLogic.solveMethodInType(bound.getType().asReferenceType().getTypeDeclaration(), name, argumentsTypes, false, typeSolver); if (res.isSolved()) { return res; } } - return SymbolReference.unsolved(MethodDeclaration.class); + return SymbolReference.unsolved(ResolvedMethodDeclaration.class); } else if (typeOfScope.isConstraint()){ return MethodResolutionLogic.solveMethodInType(typeOfScope.asConstraintType().getBound().asReferenceType().getTypeDeclaration(), name, argumentsTypes, typeSolver); } else { return MethodResolutionLogic.solveMethodInType(typeOfScope.asReferenceType().getTypeDeclaration(), name, argumentsTypes, false, typeSolver); } } else { - Type typeOfScope = JavaParserFacade.get(typeSolver).getTypeOfThisIn(wrappedNode); + ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getTypeOfThisIn(wrappedNode); return MethodResolutionLogic.solveMethodInType(typeOfScope.asReferenceType().getTypeDeclaration(), name, argumentsTypes, false, typeSolver); } } @@ -205,8 +199,8 @@ public SymbolReference solveMethod(String name, List ar /// Private methods /// - private Optional solveMethodAsUsage(ReferenceType refType, String name, - List argumentsTypes, TypeSolver typeSolver, + private Optional solveMethodAsUsage(ResolvedReferenceType refType, String name, + List argumentsTypes, TypeSolver typeSolver, Context invokationContext) { Optional ref = ContextHelper.solveMethodAsUsage(refType.getTypeDeclaration(), name, argumentsTypes, typeSolver, invokationContext, refType.typeParametersValues()); if (ref.isPresent()) { @@ -232,26 +226,26 @@ private Optional solveMethodAsUsage(ReferenceType refType, String n // In our example Stream.T equal to String, so the R (and the result of the call to collect) is // List - Map derivedValues = new HashMap<>(); + Map derivedValues = new HashMap<>(); for (int i = 0; i < methodUsage.getParamTypes().size(); i++) { - ParameterDeclaration parameter = methodUsage.getDeclaration().getParam(i); - Type parameterType = parameter.getType(); + ResolvedParameterDeclaration parameter = methodUsage.getDeclaration().getParam(i); + ResolvedType parameterType = parameter.getType(); if (parameter.isVariadic()) { parameterType = parameterType.asArrayType().getComponentType(); } inferTypes(argumentsTypes.get(i), parameterType, derivedValues); } - for (Map.Entry entry : derivedValues.entrySet()){ + for (Map.Entry entry : derivedValues.entrySet()){ methodUsage = methodUsage.replaceTypeParameter(entry.getKey(), entry.getValue()); } - Type returnType = refType.useThisTypeParametersOnTheGivenType(methodUsage.returnType()); + ResolvedType returnType = refType.useThisTypeParametersOnTheGivenType(methodUsage.returnType()); if (returnType != methodUsage.returnType()) { methodUsage = methodUsage.replaceReturnType(returnType); } for (int i = 0; i < methodUsage.getParamTypes().size(); i++) { - Type replaced = refType.useThisTypeParametersOnTheGivenType(methodUsage.getParamTypes().get(i)); + ResolvedType replaced = refType.useThisTypeParametersOnTheGivenType(methodUsage.getParamTypes().get(i)); methodUsage = methodUsage.replaceParamType(i, replaced); } return Optional.of(methodUsage); @@ -260,13 +254,13 @@ private Optional solveMethodAsUsage(ReferenceType refType, String n } } - private void inferTypes(Type source, Type target, Map mappings) { + private void inferTypes(ResolvedType source, ResolvedType target, Map mappings) { if (source.equals(target)) { return; } if (source.isReferenceType() && target.isReferenceType()) { - ReferenceType sourceRefType = source.asReferenceType(); - ReferenceType targetRefType = target.asReferenceType(); + ResolvedReferenceType sourceRefType = source.asReferenceType(); + ResolvedReferenceType targetRefType = target.asReferenceType(); if (sourceRefType.getQualifiedName().equals(targetRefType.getQualifiedName())) { if (!sourceRefType.isRawType() && !targetRefType.isRawType()) { for (int i = 0; i < sourceRefType.typeParametersValues().size(); i++) { @@ -337,21 +331,21 @@ private void inferTypes(Type source, Type target, Map actualParamTypes) { - Map matchedTypeParameters = new HashMap<>(); + private MethodUsage resolveMethodTypeParameters(MethodUsage methodUsage, List actualParamTypes) { + Map matchedTypeParameters = new HashMap<>(); if (methodUsage.getDeclaration().hasVariadicParameter()) { if (actualParamTypes.size() == methodUsage.getDeclaration().getNumberOfParams()) { // the varargs parameter is an Array, so extract the inner type - Type expectedType = + ResolvedType expectedType = methodUsage.getDeclaration().getLastParam().getType().asArrayType().getComponentType(); // the varargs corresponding type can be either T or Array - Type actualType = + ResolvedType actualType = actualParamTypes.get(actualParamTypes.size() - 1).isArray() ? actualParamTypes.get(actualParamTypes.size() - 1).asArrayType().getComponentType() : actualParamTypes.get(actualParamTypes.size() - 1); if (!expectedType.isAssignableBy(actualType)) { - for (TypeParameterDeclaration tp : methodUsage.getDeclaration().getTypeParameters()) { + for (ResolvedTypeParameterDeclaration tp : methodUsage.getDeclaration().getTypeParameters()) { expectedType = MethodResolutionLogic.replaceTypeParam(expectedType, tp, typeSolver); } } @@ -376,17 +370,17 @@ private MethodUsage resolveMethodTypeParameters(MethodUsage methodUsage, List matchedTypeParameters) { + private void matchTypeParameters(ResolvedType expectedType, ResolvedType actualType, Map matchedTypeParameters) { if (expectedType.isTypeVariable()) { if (!actualType.isTypeVariable() && !actualType.isReferenceType()) { throw new UnsupportedOperationException(actualType.getClass().getCanonicalName()); @@ -404,7 +398,7 @@ private void matchTypeParameters(Type expectedType, Type actualType, Map" if (actualType.isReferenceType() && actualType.asReferenceType().typeParametersValues().size() > 0) { int i = 0; - for (Type tp : expectedType.asReferenceType().typeParametersValues()) { + for (ResolvedType tp : expectedType.asReferenceType().typeParametersValues()) { matchTypeParameters(tp, actualType.asReferenceType().typeParametersValues().get(i), matchedTypeParameters); i++; } @@ -418,8 +412,8 @@ private void matchTypeParameters(Type expectedType, Type actualType, Map solveMethodAsUsage(TypeVariable tp, String name, List argumentsTypes, TypeSolver typeSolver, Context invokationContext) { - for (TypeParameterDeclaration.Bound bound : tp.asTypeParameter().getBounds(typeSolver)) { + private Optional solveMethodAsUsage(ResolvedTypeVariable tp, String name, List argumentsTypes, TypeSolver typeSolver, Context invokationContext) { + for (ResolvedTypeParameterDeclaration.Bound bound : tp.asTypeParameter().getBounds()) { Optional methodUsage = solveMethodAsUsage(bound.getType(), name, argumentsTypes, typeSolver, invokationContext); if (methodUsage.isPresent()) { return methodUsage; @@ -428,13 +422,13 @@ private Optional solveMethodAsUsage(TypeVariable tp, String name, L return Optional.empty(); } - private Optional solveMethodAsUsage(Type type, String name, List argumentsTypes, TypeSolver typeSolver, Context invokationContext) { - if (type instanceof ReferenceType) { - return solveMethodAsUsage((ReferenceType) type, name, argumentsTypes, typeSolver, invokationContext); - } else if (type instanceof TypeVariable) { - return solveMethodAsUsage((TypeVariable) type, name, argumentsTypes, typeSolver, invokationContext); - } else if (type instanceof Wildcard) { - Wildcard wildcardUsage = (Wildcard) type; + private Optional solveMethodAsUsage(ResolvedType type, String name, List argumentsTypes, TypeSolver typeSolver, Context invokationContext) { + if (type instanceof ResolvedReferenceType) { + return solveMethodAsUsage((ResolvedReferenceType) type, name, argumentsTypes, typeSolver, invokationContext); + } else if (type instanceof ResolvedTypeVariable) { + return solveMethodAsUsage((ResolvedTypeVariable) type, name, argumentsTypes, typeSolver, invokationContext); + } else if (type instanceof ResolvedWildcard) { + ResolvedWildcard wildcardUsage = (ResolvedWildcard) type; if (wildcardUsage.isSuper()) { return solveMethodAsUsage(wildcardUsage.getBoundedType(), name, argumentsTypes, typeSolver, invokationContext); } else if (wildcardUsage.isExtends()) { @@ -442,10 +436,10 @@ private Optional solveMethodAsUsage(Type type, String name, List solveMethodAsUsage(Type type, String name, List inferredTypes) { + private ResolvedType usingParameterTypesFromScope(ResolvedType scope, ResolvedType type, Map inferredTypes) { if (type.isReferenceType()) { - for (Tuple2 entry : type.asReferenceType().getTypeParametersMap()) { - if (entry._1.declaredOnType() && scope.asReferenceType().getGenericParameterByName(entry._1.getName()).isPresent()) { - type = type.replaceTypeVariables(entry._1, scope.asReferenceType().getGenericParameterByName(entry._1.getName()).get(), inferredTypes); + for (Pair entry : type.asReferenceType().getTypeParametersMap()) { + if (entry.a.declaredOnType() && scope.asReferenceType().getGenericParameterByName(entry.a.getName()).isPresent()) { + type = type.replaceTypeVariables(entry.a, scope.asReferenceType().getGenericParameterByName(entry.a.getName()).get(), inferredTypes); } } return type; @@ -466,8 +460,8 @@ private Type usingParameterTypesFromScope(Type scope, Type type, Map inferredTypes) { - for (TypeParameterDeclaration tp : inferredTypes.keySet()) { + private ResolvedType applyInferredTypes(ResolvedType type, Map inferredTypes) { + for (ResolvedTypeParameterDeclaration tp : inferredTypes.keySet()) { type = type.replaceTypeVariables(tp, inferredTypes.get(tp), inferredTypes); } return type; diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodContext.java index f7a2e44957..9a7530b18f 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodContext.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodContext.java @@ -16,7 +16,6 @@ package com.github.javaparser.symbolsolver.javaparsermodel.contexts; - import com.github.javaparser.ast.body.MethodDeclaration; import com.github.javaparser.symbolsolver.model.resolution.TypeSolver; diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/StatementContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/StatementContext.java index 5074b5e079..51dd2d6d07 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/StatementContext.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/StatementContext.java @@ -20,15 +20,15 @@ import com.github.javaparser.ast.nodeTypes.NodeWithStatements; import com.github.javaparser.ast.stmt.IfStmt; 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.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.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.resolution.SymbolDeclarator; import java.util.List; @@ -45,7 +45,7 @@ public StatementContext(N wrappedNode, TypeSolver typeSolver) { super(wrappedNode, typeSolver); } - public static SymbolReference solveInBlock(String name, TypeSolver typeSolver, Statement stmt) { + public static SymbolReference solveInBlock(String name, TypeSolver typeSolver, Statement stmt) { if (!(getParentNode(stmt) instanceof NodeWithStatements)) { throw new IllegalArgumentException(); } @@ -61,7 +61,7 @@ public static SymbolReference solveInBlock(String na } for (int i = position - 1; i >= 0; i--) { SymbolDeclarator symbolDeclarator = JavaParserFactory.getSymbolDeclarator(blockStmt.getStatements().get(i), typeSolver); - SymbolReference symbolReference = solveWith(symbolDeclarator, name); + SymbolReference symbolReference = solveWith(symbolDeclarator, name); if (symbolReference.isSolved()) { return symbolReference; } @@ -87,7 +87,7 @@ public static Optional solveInBlockAsValue(String name, TypeSolver typeSo } for (int i = position - 1; i >= 0; i--) { SymbolDeclarator symbolDeclarator = JavaParserFactory.getSymbolDeclarator(blockStmt.getStatements().get(i), typeSolver); - SymbolReference symbolReference = solveWith(symbolDeclarator, name); + SymbolReference symbolReference = solveWith(symbolDeclarator, name); if (symbolReference.isSolved()) { return Optional.of(Value.from(symbolReference.getCorrespondingDeclaration())); } @@ -144,11 +144,11 @@ public Optional solveSymbolAsValue(String name, TypeSolver typeSolver) { } @Override - public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { // if we're in a multiple Variable declaration line (for ex: double a=0, b=a;) SymbolDeclarator symbolDeclarator = JavaParserFactory.getSymbolDeclarator(wrappedNode, typeSolver); - SymbolReference symbolReference = solveWith(symbolDeclarator, name); + SymbolReference symbolReference = solveWith(symbolDeclarator, name); if (symbolReference.isSolved()) { return symbolReference; } @@ -189,12 +189,12 @@ public SymbolReference solveSymbol(String name, Type } @Override - public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { return getParent().solveMethod(name, argumentsTypes, false, typeSolver); } @Override - public SymbolReference solveType(String name, TypeSolver typeSolver) { + public SymbolReference solveType(String name, TypeSolver typeSolver) { return getParent().solveType(name, typeSolver); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/SwitchEntryContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/SwitchEntryContext.java index 7deca86919..053cc2de1a 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/SwitchEntryContext.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/SwitchEntryContext.java @@ -19,14 +19,14 @@ import com.github.javaparser.ast.stmt.Statement; import com.github.javaparser.ast.stmt.SwitchEntryStmt; import com.github.javaparser.ast.stmt.SwitchStmt; +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.JavaParserFacade; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory; -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.ReferenceTypeImpl; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import com.github.javaparser.symbolsolver.resolution.SymbolDeclarator; import java.util.List; @@ -43,9 +43,9 @@ public SwitchEntryContext(SwitchEntryStmt wrappedNode, TypeSolver typeSolver) { } @Override - public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { SwitchStmt switchStmt = (SwitchStmt) getParentNode(wrappedNode); - Type type = JavaParserFacade.get(typeSolver).getType(switchStmt.getSelector()); + ResolvedType type = JavaParserFacade.get(typeSolver).getType(switchStmt.getSelector()); if (type.isReferenceType() && type.asReferenceType().getTypeDeclaration().isEnum()) { if (type instanceof ReferenceTypeImpl) { ReferenceTypeImpl typeUsageOfTypeDeclaration = (ReferenceTypeImpl) type; @@ -62,7 +62,7 @@ public SymbolReference solveSymbol(String name, Type if (!seStmt.equals(wrappedNode)) { for (Statement stmt : seStmt.getStatements()) { SymbolDeclarator symbolDeclarator = JavaParserFactory.getSymbolDeclarator(stmt, typeSolver); - SymbolReference symbolReference = solveWith(symbolDeclarator, name); + SymbolReference symbolReference = solveWith(symbolDeclarator, name); if (symbolReference.isSolved()) { return symbolReference; } @@ -74,7 +74,7 @@ public SymbolReference solveSymbol(String name, Type } @Override - public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { return getParent().solveMethod(name, argumentsTypes, false, typeSolver); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/TryWithResourceContext.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/TryWithResourceContext.java index c72a856533..de6516436d 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/TryWithResourceContext.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/TryWithResourceContext.java @@ -21,13 +21,13 @@ import com.github.javaparser.ast.expr.VariableDeclarationExpr; import com.github.javaparser.ast.stmt.BlockStmt; import com.github.javaparser.ast.stmt.TryStmt; +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.resolution.Value; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import java.util.List; import java.util.Optional; @@ -61,7 +61,7 @@ public Optional solveSymbolAsValue(String name, TypeSolver typeSolver) { } @Override - public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { for (Expression expr : wrappedNode.getResources()) { if (expr instanceof VariableDeclarationExpr) { for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) { @@ -80,7 +80,8 @@ public SymbolReference solveSymbol(String name, Type } @Override - public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { + public SymbolReference solveMethod(String name, List argumentsTypes, + boolean staticOnly, TypeSolver typeSolver) { return getParent().solveMethod(name, argumentsTypes, false, typeSolver); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/DefaultConstructorDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/DefaultConstructorDeclaration.java index 409d172170..aff7c7c850 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/DefaultConstructorDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/DefaultConstructorDeclaration.java @@ -17,8 +17,11 @@ package com.github.javaparser.symbolsolver.javaparsermodel.declarations; import com.github.javaparser.ast.AccessSpecifier; -import com.github.javaparser.symbolsolver.model.declarations.*; -import com.github.javaparser.symbolsolver.model.typesystem.Type; +import com.github.javaparser.resolution.declarations.ResolvedClassDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedConstructorDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedParameterDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration; +import com.github.javaparser.resolution.types.ResolvedType; import java.util.Collections; import java.util.List; @@ -29,16 +32,16 @@ * * @author Federico Tomassetti */ -class DefaultConstructorDeclaration implements ConstructorDeclaration { +class DefaultConstructorDeclaration implements ResolvedConstructorDeclaration { - private ClassDeclaration classDeclaration; + private ResolvedClassDeclaration classDeclaration; - DefaultConstructorDeclaration(ClassDeclaration classDeclaration) { + DefaultConstructorDeclaration(ResolvedClassDeclaration classDeclaration) { this.classDeclaration = classDeclaration; } @Override - public ClassDeclaration declaringType() { + public ResolvedClassDeclaration declaringType() { return classDeclaration; } @@ -48,7 +51,7 @@ public int getNumberOfParams() { } @Override - public ParameterDeclaration getParam(int i) { + public ResolvedParameterDeclaration getParam(int i) { throw new UnsupportedOperationException("The default constructor has not parameters"); } @@ -58,12 +61,12 @@ public String getName() { } @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { return AccessSpecifier.PUBLIC; } @Override - public List getTypeParameters() { + public List getTypeParameters() { return Collections.emptyList(); } @@ -73,7 +76,7 @@ public int getNumberOfSpecifiedExceptions() { } @Override - public Type getSpecifiedException(int index) { + public ResolvedType getSpecifiedException(int index) { throw new UnsupportedOperationException("The default constructor does not throw exceptions"); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnnotationDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnnotationDeclaration.java index 15cba1a85c..6591ed4a30 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnnotationDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnnotationDeclaration.java @@ -1,12 +1,10 @@ package com.github.javaparser.symbolsolver.javaparsermodel.declarations; -import com.github.javaparser.resolution.declarations.ResolvedAnnotationDeclaration; -import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +import com.github.javaparser.resolution.declarations.*; +import com.github.javaparser.resolution.types.ResolvedReferenceType; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.logic.AbstractTypeDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.*; 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.util.List; import java.util.Optional; @@ -28,22 +26,22 @@ public JavaParserAnnotationDeclaration(com.github.javaparser.ast.body.Annotation } @Override - public List getAncestors() { + public List getAncestors() { throw new UnsupportedOperationException(); } @Override - public List getAllFields() { + public List getAllFields() { throw new UnsupportedOperationException(); } @Override - public Set getDeclaredMethods() { + public Set getDeclaredMethods() { throw new UnsupportedOperationException(); } @Override - public boolean isAssignableBy(Type type) { + public boolean isAssignableBy(ResolvedType type) { throw new UnsupportedOperationException(); } @@ -83,12 +81,12 @@ public String getName() { } @Override - public List getTypeParameters() { + public List getTypeParameters() { throw new UnsupportedOperationException(); } @Override - public Optional containerType() { + public Optional containerType() { throw new UnsupportedOperationException("containerType is not supported for " + this.getClass().getCanonicalName()); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclaration.java index 2cb2933ad9..94800f11b0 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclaration.java @@ -91,7 +91,7 @@ public List getConstructors() { } @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { return AccessSpecifier.PRIVATE; } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclaration.java index f82d065a3c..7a6e198daf 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclaration.java @@ -21,23 +21,18 @@ import com.github.javaparser.ast.body.*; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.type.ClassOrInterfaceType; -import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +import com.github.javaparser.resolution.declarations.*; +import com.github.javaparser.resolution.types.ResolvedReferenceType; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory; import com.github.javaparser.symbolsolver.javaparsermodel.UnsolvedSymbolException; import com.github.javaparser.symbolsolver.logic.AbstractClassDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.*; -import com.github.javaparser.symbolsolver.model.declarations.ConstructorDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.FieldDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration; -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.LazyType; -import com.github.javaparser.symbolsolver.model.typesystem.ReferenceType; import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import com.github.javaparser.symbolsolver.resolution.SymbolSolver; import com.google.common.collect.ImmutableList; @@ -104,15 +99,15 @@ public String toString() { /// @Override - public List getAllFields() { - List fields = javaParserTypeAdapter.getFieldsForDeclaredVariables(); + public List getAllFields() { + List fields = javaParserTypeAdapter.getFieldsForDeclaredVariables(); getAncestors().forEach(ancestor -> ancestor.getTypeDeclaration().getAllFields().forEach(f -> { - fields.add(new FieldDeclaration() { + fields.add(new ResolvedFieldDeclaration() { @Override - public AccessSpecifier accessLevel() { - return f.accessLevel(); + public AccessSpecifier accessSpecifier() { + return f.accessSpecifier(); } @Override @@ -121,7 +116,7 @@ public String getName() { } @Override - public Type getType() { + public ResolvedType getType() { return ancestor.useThisTypeParametersOnTheGivenType(f.getType()); } @@ -131,7 +126,7 @@ public boolean isStatic() { } @Override - public TypeDeclaration declaringType() { + public ResolvedTypeDeclaration declaringType() { return f.declaringType(); } }); @@ -144,7 +139,7 @@ public TypeDeclaration declaringType() { /// Public methods /// - public SymbolReference solveMethod(String name, List parameterTypes) { + public SymbolReference solveMethod(String name, List parameterTypes) { Context ctx = getContext(); return ctx.solveMethod(name, parameterTypes, false, typeSolver); } @@ -154,7 +149,7 @@ public Context getContext() { return JavaParserFactory.getContext(wrappedNode, typeSolver); } - public Type getUsage(Node node) { + public ResolvedType getUsage(Node node) { throw new UnsupportedOperationException(); } @@ -164,7 +159,7 @@ public String getName() { } @Override - public ReferenceType getSuperClass() { + public ResolvedReferenceType getSuperClass() { if (wrappedNode.getExtendedTypes().isEmpty()) { return object(); } else { @@ -173,8 +168,8 @@ public ReferenceType getSuperClass() { } @Override - public List getInterfaces() { - List interfaces = new ArrayList<>(); + public List getInterfaces() { + List interfaces = new ArrayList<>(); if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType t : wrappedNode.getImplementedTypes()) { interfaces.add(toReferenceType(t)); @@ -184,8 +179,8 @@ public List getInterfaces() { } @Override - public List getConstructors() { - List declared = new LinkedList<>(); + public List getConstructors() { + List declared = new LinkedList<>(); for (BodyDeclaration member : wrappedNode.getMembers()) { if (member instanceof com.github.javaparser.ast.body.ConstructorDeclaration) { com.github.javaparser.ast.body.ConstructorDeclaration constructorDeclaration = (com.github.javaparser.ast.body.ConstructorDeclaration) member; @@ -236,7 +231,7 @@ public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) { } @Override - public boolean isAssignableBy(Type type) { + public boolean isAssignableBy(ResolvedType type) { return javaParserTypeAdapter.isAssignableBy(type); } @@ -246,7 +241,7 @@ public boolean canBeAssignedTo(ResolvedReferenceTypeDeclaration other) { if (this.getQualifiedName().equals(other.getQualifiedName())) { return true; } - ClassDeclaration superclass = (ClassDeclaration) getSuperClass().getTypeDeclaration(); + ResolvedClassDeclaration superclass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); if (superclass != null) { // We want to avoid infinite recursion in case of Object having Object as ancestor if (Object.class.getCanonicalName().equals(superclass.getQualifiedName())) { @@ -275,11 +270,11 @@ public boolean isTypeParameter() { } @Deprecated - public SymbolReference solveType(String name, TypeSolver typeSolver) { + public SymbolReference solveType(String name, TypeSolver typeSolver) { if (this.wrappedNode.getName().getId().equals(name)) { return SymbolReference.solved(this); } - SymbolReference ref = javaParserTypeAdapter.solveType(name, typeSolver); + SymbolReference ref = javaParserTypeAdapter.solveType(name, typeSolver); if (ref.isSolved()) { return ref; } @@ -293,15 +288,15 @@ public SymbolReference solveType(String name, TypeSolver typeSo } @Override - public List getAncestors() { - List ancestors = new ArrayList<>(); - ReferenceType superclass = getSuperClass(); + public List getAncestors() { + List ancestors = new ArrayList<>(); + ResolvedReferenceType superclass = getSuperClass(); if (superclass != null) { ancestors.add(superclass); } if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType implemented : wrappedNode.getImplementedTypes()) { - ReferenceType ancestor = toReferenceType(implemented); + ResolvedReferenceType ancestor = toReferenceType(implemented); ancestors.add(ancestor); } } @@ -309,8 +304,8 @@ public List getAncestors() { } @Override - public Set getDeclaredMethods() { - Set methods = new HashSet<>(); + public Set getDeclaredMethods() { + Set methods = new HashSet<>(); for (BodyDeclaration member : wrappedNode.getMembers()) { if (member instanceof com.github.javaparser.ast.body.MethodDeclaration) { methods.add(new JavaParserMethodDeclaration((com.github.javaparser.ast.body.MethodDeclaration) member, typeSolver)); @@ -320,7 +315,7 @@ public Set getDeclaredMethods() { } @Override - public List getTypeParameters() { + public List getTypeParameters() { return this.wrappedNode.getTypeParameters().stream().map( (tp) -> new JavaParserTypeParameter(tp, typeSolver) ).collect(Collectors.toList()); @@ -336,7 +331,7 @@ public com.github.javaparser.ast.body.ClassOrInterfaceDeclaration getWrappedNode } @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { return Helper.toAccessLevel(wrappedNode.getModifiers()); } @@ -345,13 +340,13 @@ public AccessSpecifier accessLevel() { /// @Override - protected ReferenceType object() { + protected ResolvedReferenceType object() { return new ReferenceTypeImpl(typeSolver.solveType(Object.class.getCanonicalName()), typeSolver); } @Override - public Set internalTypes() { - Set res = new HashSet<>(); + public Set internalTypes() { + Set res = new HashSet<>(); for (BodyDeclaration member : this.wrappedNode.getMembers()) { if (member instanceof com.github.javaparser.ast.body.TypeDeclaration) { res.add(JavaParserFacade.get(typeSolver).getTypeDeclaration((com.github.javaparser.ast.body.TypeDeclaration)member)); @@ -361,7 +356,7 @@ public Set internalTypes() { } @Override - public Optional containerType() { + public Optional containerType() { return javaParserTypeAdapter.containerType(); } @@ -369,13 +364,13 @@ public Optional containerType() { /// Private methods /// - private ReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { + private ResolvedReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { String className = classOrInterfaceType.getName().getId(); if (classOrInterfaceType.getScope().isPresent()) { // look for the qualified name (for example class of type Rectangle2D.Double) className = classOrInterfaceType.getScope().get().toString() + "." + className; } - SymbolReference ref = solveType(className, typeSolver); + SymbolReference ref = solveType(className, typeSolver); if (!ref.isSolved()) { Optional localScope = classOrInterfaceType.getScope(); if (localScope.isPresent()) { @@ -389,7 +384,7 @@ private ReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) if (!classOrInterfaceType.getTypeArguments().isPresent()) { return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), typeSolver); } - List superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() + List superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() .stream().map(ta -> new LazyType(v -> JavaParserFacade.get(typeSolver).convert(ta, ta))) .collect(Collectors.toList()); return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), superClassTypeParameters, typeSolver); diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserConstructorDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserConstructorDeclaration.java index e96f0398bf..e9500fed2f 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserConstructorDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserConstructorDeclaration.java @@ -17,11 +17,13 @@ package com.github.javaparser.symbolsolver.javaparsermodel.declarations; import com.github.javaparser.ast.AccessSpecifier; +import com.github.javaparser.resolution.declarations.ResolvedClassDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedConstructorDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedParameterDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; -import com.github.javaparser.symbolsolver.model.declarations.*; 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.util.List; import java.util.stream.Collectors; @@ -29,13 +31,13 @@ /** * @author Federico Tomassetti */ -public class JavaParserConstructorDeclaration implements ConstructorDeclaration { +public class JavaParserConstructorDeclaration implements ResolvedConstructorDeclaration { - private ClassDeclaration classDeclaration; + private ResolvedClassDeclaration classDeclaration; private com.github.javaparser.ast.body.ConstructorDeclaration wrappedNode; private TypeSolver typeSolver; - JavaParserConstructorDeclaration(ClassDeclaration classDeclaration, com.github.javaparser.ast.body.ConstructorDeclaration wrappedNode, + JavaParserConstructorDeclaration(ResolvedClassDeclaration classDeclaration, com.github.javaparser.ast.body.ConstructorDeclaration wrappedNode, TypeSolver typeSolver) { this.classDeclaration = classDeclaration; this.wrappedNode = wrappedNode; @@ -43,7 +45,7 @@ public class JavaParserConstructorDeclaration implements ConstructorDeclaration } @Override - public ClassDeclaration declaringType() { + public ResolvedClassDeclaration declaringType() { return classDeclaration; } @@ -53,7 +55,7 @@ public int getNumberOfParams() { } @Override - public ParameterDeclaration getParam(int i) { + public ResolvedParameterDeclaration getParam(int i) { if (i < 0 || i >= getNumberOfParams()) { throw new IllegalArgumentException(String.format("No param with index %d. Number of params: %d", i, getNumberOfParams())); } @@ -75,12 +77,12 @@ public com.github.javaparser.ast.body.ConstructorDeclaration getWrappedNode() { } @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { return Helper.toAccessLevel(wrappedNode.getModifiers()); } @Override - public List getTypeParameters() { + public List getTypeParameters() { return this.wrappedNode.getTypeParameters().stream().map((astTp) -> new JavaParserTypeParameter(astTp, typeSolver)).collect(Collectors.toList()); } @@ -90,7 +92,7 @@ public int getNumberOfSpecifiedExceptions() { } @Override - public Type getSpecifiedException(int index) { + public ResolvedType getSpecifiedException(int index) { if (index < 0 || index >= getNumberOfSpecifiedExceptions()) { throw new IllegalArgumentException(String.format("No exception with index %d. Number of exceptions: %d", index, getNumberOfSpecifiedExceptions())); diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumConstantDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumConstantDeclaration.java index de76be18d8..75c20c851f 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumConstantDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumConstantDeclaration.java @@ -17,17 +17,17 @@ package com.github.javaparser.symbolsolver.javaparsermodel.declarations; import com.github.javaparser.ast.body.EnumDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.ValueDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.model.resolution.TypeSolver; import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import static com.github.javaparser.symbolsolver.javaparser.Navigator.getParentNode; /** * @author Federico Tomassetti */ -public class JavaParserEnumConstantDeclaration implements ValueDeclaration { +public class JavaParserEnumConstantDeclaration implements ResolvedValueDeclaration { private TypeSolver typeSolver; private com.github.javaparser.ast.body.EnumConstantDeclaration wrappedNode; @@ -38,7 +38,7 @@ public JavaParserEnumConstantDeclaration(com.github.javaparser.ast.body.EnumCons } @Override - public Type getType() { + public ResolvedType getType() { return new ReferenceTypeImpl(new JavaParserEnumDeclaration((EnumDeclaration) getParentNode(wrappedNode), typeSolver), typeSolver); } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclaration.java index 8f27c76dd3..ae82577fe8 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclaration.java @@ -24,12 +24,15 @@ import com.github.javaparser.resolution.MethodUsage; import com.github.javaparser.resolution.declarations.*; import com.github.javaparser.resolution.types.ResolvedArrayType; +import com.github.javaparser.resolution.types.ResolvedReferenceType; import com.github.javaparser.resolution.types.ResolvedType; +import com.github.javaparser.resolution.types.parametrization.ResolvedTypeParametersMap; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory; import com.github.javaparser.symbolsolver.javaparsermodel.UnsolvedSymbolException; import com.github.javaparser.symbolsolver.logic.AbstractTypeDeclaration; +import com.github.javaparser.symbolsolver.model.resolution.SymbolReference; import com.github.javaparser.symbolsolver.model.resolution.TypeSolver; import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl; import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionFactory; @@ -153,7 +156,7 @@ public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) { } @Override - public boolean isAssignableBy(Type type) { + public boolean isAssignableBy(ResolvedType type) { return javaParserTypeAdapter.isAssignableBy(type); } @@ -180,7 +183,8 @@ public int hashCode() { } @Deprecated - public Optional solveMethodAsUsage(String name, List parameterTypes, TypeSolver typeSolver, Context invokationContext, List typeParameterValues) { + public Optional solveMethodAsUsage(String name, List parameterTypes, + TypeSolver typeSolver, Context invokationContext, List typeParameterValues) { if (name.equals("values") && parameterTypes.isEmpty()) { return Optional.of(new ValuesMethod(this, typeSolver).getUsage(null)); } @@ -189,8 +193,8 @@ public Optional solveMethodAsUsage(String name, List paramete } @Override - public List getAllFields() { - List fields = javaParserTypeAdapter.getFieldsForDeclaredVariables(); + public List getAllFields() { + List fields = javaParserTypeAdapter.getFieldsForDeclaredVariables(); if (this.wrappedNode.getEntries() != null) { for (EnumConstantDeclaration member : this.wrappedNode.getEntries()) { @@ -202,26 +206,26 @@ public List getAllFields() { } @Override - public List getAncestors() { - List ancestors = new ArrayList<>(); - ReferenceType enumClass = ReflectionFactory.typeUsageFor(Enum.class, typeSolver).asReferenceType(); - TypeParameterDeclaration eTypeParameter = enumClass.getTypeDeclaration().getTypeParameters().get(0); - enumClass = enumClass.deriveTypeParameters(new TypeParametersMap.Builder().setValue(eTypeParameter, new ReferenceTypeImpl(this, typeSolver)).build()); + public List getAncestors() { + List ancestors = new ArrayList<>(); + ResolvedReferenceType enumClass = ReflectionFactory.typeUsageFor(Enum.class, typeSolver).asReferenceType(); + ResolvedTypeParameterDeclaration eTypeParameter = enumClass.getTypeDeclaration().getTypeParameters().get(0); + enumClass = enumClass.deriveTypeParameters(new ResolvedTypeParametersMap.Builder().setValue(eTypeParameter, new ReferenceTypeImpl(this, typeSolver)).build()); ancestors.add(enumClass); if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType implementedType : wrappedNode.getImplementedTypes()) { - SymbolReference implementedDeclRef = new SymbolSolver(typeSolver).solveTypeInType(this, implementedType.getName().getId()); + SymbolReference implementedDeclRef = new SymbolSolver(typeSolver).solveTypeInType(this, implementedType.getName().getId()); if (!implementedDeclRef.isSolved()) { throw new UnsolvedSymbolException(implementedType.getName().getId()); } - ancestors.add(new ReferenceTypeImpl((ReferenceTypeDeclaration) implementedDeclRef.getCorrespondingDeclaration(), typeSolver)); + ancestors.add(new ReferenceTypeImpl((ResolvedReferenceTypeDeclaration) implementedDeclRef.getCorrespondingDeclaration(), typeSolver)); } } return ancestors; } @Override - public List getTypeParameters() { + public List getTypeParameters() { return Collections.emptyList(); } @@ -235,7 +239,7 @@ public com.github.javaparser.ast.body.EnumDeclaration getWrappedNode() { } // Needed by ContextHelper - public static class ValuesMethod implements MethodDeclaration { + public static class ValuesMethod implements ResolvedMethodDeclaration { private JavaParserEnumDeclaration enumDeclaration; private TypeSolver typeSolver; @@ -299,7 +303,7 @@ public List getTypeParameters() { } @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { return Helper.toAccessLevel(enumDeclaration.getWrappedNode().getModifiers()); } @@ -315,7 +319,7 @@ public ResolvedType getSpecifiedException(int index) { } @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { throw new UnsupportedOperationException(); } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserFieldDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserFieldDeclaration.java index e4d3fc648b..fe55deeb48 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserFieldDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserFieldDeclaration.java @@ -20,13 +20,13 @@ import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.body.EnumConstantDeclaration; import com.github.javaparser.ast.body.VariableDeclarator; +import com.github.javaparser.resolution.declarations.ResolvedFieldDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.javaparser.Navigator; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; -import com.github.javaparser.symbolsolver.model.declarations.FieldDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.TypeDeclaration; import com.github.javaparser.symbolsolver.model.resolution.TypeSolver; import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import java.util.Optional; @@ -35,7 +35,7 @@ /** * @author Federico Tomassetti */ -public class JavaParserFieldDeclaration implements FieldDeclaration { +public class JavaParserFieldDeclaration implements ResolvedFieldDeclaration { private VariableDeclarator variableDeclarator; private com.github.javaparser.ast.body.FieldDeclaration wrappedNode; @@ -63,12 +63,12 @@ public JavaParserFieldDeclaration(EnumConstantDeclaration enumConstantDeclaratio } @Override - public Type getType() { + public ResolvedType getType() { if (enumConstantDeclaration != null) { com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = (com.github.javaparser.ast.body.EnumDeclaration) getParentNode(enumConstantDeclaration); return new ReferenceTypeImpl(new JavaParserEnumDeclaration(enumDeclaration, typeSolver), typeSolver); } else { - Type retType = JavaParserFacade.get(typeSolver).convert(variableDeclarator.getType(), wrappedNode); + ResolvedType retType = JavaParserFacade.get(typeSolver).convert(variableDeclarator.getType(), wrappedNode); return retType; } } @@ -107,12 +107,12 @@ public String toString() { } @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { return Helper.toAccessLevel(wrappedNode.getModifiers()); } @Override - public TypeDeclaration declaringType() { + public ResolvedTypeDeclaration declaringType() { Optional typeDeclaration = Navigator.findAncestor(wrappedNode, com.github.javaparser.ast.body.TypeDeclaration.class); if (typeDeclaration.isPresent()) { return JavaParserFacade.get(typeSolver).getTypeDeclaration(typeDeclaration.get()); diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclaration.java index 5cde17f6b7..78d57d2b83 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclaration.java @@ -22,7 +22,9 @@ import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.type.ClassOrInterfaceType; -import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +import com.github.javaparser.resolution.declarations.*; +import com.github.javaparser.resolution.types.ResolvedReferenceType; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory; @@ -43,7 +45,7 @@ /** * @author Federico Tomassetti */ -public class JavaParserInterfaceDeclaration extends AbstractTypeDeclaration implements InterfaceDeclaration { +public class JavaParserInterfaceDeclaration extends AbstractTypeDeclaration implements ResolvedInterfaceDeclaration { private TypeSolver typeSolver; private ClassOrInterfaceDeclaration wrappedNode; @@ -59,8 +61,8 @@ public JavaParserInterfaceDeclaration(ClassOrInterfaceDeclaration wrappedNode, T } @Override - public Set getDeclaredMethods() { - Set methods = new HashSet<>(); + public Set getDeclaredMethods() { + Set methods = new HashSet<>(); for (BodyDeclaration member : wrappedNode.getMembers()) { if (member instanceof com.github.javaparser.ast.body.MethodDeclaration) { methods.add(new JavaParserMethodDeclaration((com.github.javaparser.ast.body.MethodDeclaration) member, typeSolver)); @@ -73,7 +75,7 @@ public Context getContext() { return JavaParserFactory.getContext(wrappedNode, typeSolver); } - public Type getUsage(Node node) { + public ResolvedType getUsage(Node node) { throw new UnsupportedOperationException(); } @@ -100,7 +102,7 @@ public String getName() { } @Override - public InterfaceDeclaration asInterface() { + public ResolvedInterfaceDeclaration asInterface() { return this; } @@ -120,8 +122,8 @@ public boolean isInterface() { } @Override - public List getInterfacesExtended() { - List interfaces = new ArrayList<>(); + public List getInterfacesExtended() { + List interfaces = new ArrayList<>(); if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType t : wrappedNode.getImplementedTypes()) { interfaces.add(new ReferenceTypeImpl(solveType(t.getName().getId(), typeSolver).getCorrespondingDeclaration().asInterface(), typeSolver)); @@ -188,14 +190,14 @@ public boolean isTypeParameter() { } @Override - public List getAllFields() { - List fields = javaParserTypeAdapter.getFieldsForDeclaredVariables(); + public List getAllFields() { + List fields = javaParserTypeAdapter.getFieldsForDeclaredVariables(); getAncestors().forEach(ancestor -> ancestor.getTypeDeclaration().getAllFields().forEach(f -> { - fields.add(new FieldDeclaration() { + fields.add(new ResolvedFieldDeclaration() { @Override - public AccessSpecifier accessLevel() { + public AccessSpecifier accessSpecifier() { return f.accessLevel(); } @@ -205,7 +207,7 @@ public String getName() { } @Override - public Type getType() { + public ResolvedType getType() { return ancestor.useThisTypeParametersOnTheGivenType(f.getType()); } @@ -215,7 +217,7 @@ public boolean isStatic() { } @Override - public TypeDeclaration declaringType() { + public ResolvedTypeDeclaration declaringType() { return f.declaringType(); } }); @@ -233,11 +235,11 @@ public String toString() { } @Deprecated - public SymbolReference solveType(String name, TypeSolver typeSolver) { + public SymbolReference solveType(String name, TypeSolver typeSolver) { if (this.wrappedNode.getName().getId().equals(name)) { return SymbolReference.solved(this); } - SymbolReference ref = javaParserTypeAdapter.solveType(name, typeSolver); + SymbolReference ref = javaParserTypeAdapter.solveType(name, typeSolver); if (ref.isSolved()) { return ref; } @@ -251,8 +253,8 @@ public SymbolReference solveType(String name, TypeSolver typeSo } @Override - public List getAncestors() { - List ancestors = new ArrayList<>(); + public List getAncestors() { + List ancestors = new ArrayList<>(); if (wrappedNode.getExtendedTypes() != null) { for (ClassOrInterfaceType extended : wrappedNode.getExtendedTypes()) { ancestors.add(toReferenceType(extended)); @@ -292,8 +294,8 @@ public AccessSpecifier accessLevel() { } @Override - public Set internalTypes() { - Set res = new HashSet<>(); + public Set internalTypes() { + Set res = new HashSet<>(); for (BodyDeclaration member : this.wrappedNode.getMembers()) { if (member instanceof com.github.javaparser.ast.body.TypeDeclaration) { res.add(JavaParserFacade.get(typeSolver).getTypeDeclaration((com.github.javaparser.ast.body.TypeDeclaration)member)); @@ -303,7 +305,7 @@ public Set internalTypes() { } @Override - public Optional containerType() { + public Optional containerType() { return javaParserTypeAdapter.containerType(); } @@ -311,8 +313,8 @@ public Optional containerType() { /// Private methods /// - private ReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { - SymbolReference ref = null; + private ResolvedReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { + SymbolReference ref = null; if (classOrInterfaceType.toString().indexOf('.') > -1) { ref = typeSolver.tryToSolveType(classOrInterfaceType.toString()); } @@ -328,7 +330,7 @@ private ReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) if (!classOrInterfaceType.getTypeArguments().isPresent()) { return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), typeSolver); } - List superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() + List superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() .stream().map(ta -> new LazyType(v -> JavaParserFacade.get(typeSolver).convert(ta, ta))) .collect(Collectors.toList()); return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), superClassTypeParameters, typeSolver); diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserParameterDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserParameterDeclaration.java index 2a6e24729b..aefe5f1661 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserParameterDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserParameterDeclaration.java @@ -18,6 +18,7 @@ import com.github.javaparser.ast.body.Parameter; import com.github.javaparser.ast.type.UnknownType; +import com.github.javaparser.resolution.declarations.ResolvedParameterDeclaration; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory; import com.github.javaparser.symbolsolver.javaparsermodel.contexts.LambdaExprContext; @@ -32,7 +33,7 @@ /** * @author Federico Tomassetti */ -public class JavaParserParameterDeclaration implements ParameterDeclaration { +public class JavaParserParameterDeclaration implements ResolvedParameterDeclaration { private Parameter wrappedNode; private TypeSolver typeSolver; diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserSymbolDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserSymbolDeclaration.java index 5a05506ec0..7c391ad345 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserSymbolDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserSymbolDeclaration.java @@ -23,6 +23,11 @@ import com.github.javaparser.ast.expr.LambdaExpr; import com.github.javaparser.ast.expr.MethodCallExpr; import com.github.javaparser.ast.expr.VariableDeclarationExpr; +import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration; +import com.github.javaparser.resolution.types.ResolvedArrayType; +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.TypeDeclaration; @@ -37,7 +42,7 @@ /** * @author Federico Tomassetti */ -public class JavaParserSymbolDeclaration implements ValueDeclaration { +public class JavaParserSymbolDeclaration implements ResolvedValueDeclaration { private String name; private Node wrappedNode; @@ -120,26 +125,26 @@ public boolean isType() { } @Override - public Type getType() { + public ResolvedType getType() { if (wrappedNode instanceof Parameter) { Parameter parameter = (Parameter) wrappedNode; if (getParentNode(wrappedNode) instanceof LambdaExpr) { int pos = getParamPos(parameter); - Type lambdaType = JavaParserFacade.get(typeSolver).getType(getParentNode(wrappedNode)); + ResolvedType lambdaType = JavaParserFacade.get(typeSolver).getType(getParentNode(wrappedNode)); // TODO understand from the context to which method this corresponds //MethodDeclaration methodDeclaration = JavaParserFacade.get(typeSolver).getMethodCalled //MethodDeclaration methodCalled = JavaParserFacade.get(typeSolver).solve() throw new UnsupportedOperationException(wrappedNode.getClass().getCanonicalName()); } else { - Type rawType = null; + ResolvedType rawType = null; if (parameter.getType() instanceof com.github.javaparser.ast.type.PrimitiveType) { - rawType = PrimitiveType.byName(((com.github.javaparser.ast.type.PrimitiveType) parameter.getType()).getType().name()); + rawType = ResolvedPrimitiveType.byName(((com.github.javaparser.ast.type.PrimitiveType) parameter.getType()).getType().name()); } else { rawType = JavaParserFacade.get(typeSolver).convertToUsage(parameter.getType(), wrappedNode); } if (parameter.isVarArgs()) { - return new ArrayType(rawType); + return new ResolvedArrayType(rawType); } else { return rawType; } @@ -147,7 +152,7 @@ public Type getType() { } else if (wrappedNode instanceof VariableDeclarator) { VariableDeclarator variableDeclarator = (VariableDeclarator) wrappedNode; if (getParentNode(wrappedNode) instanceof VariableDeclarationExpr) { - Type type = JavaParserFacade.get(typeSolver).convert(variableDeclarator.getType(), JavaParserFactory.getContext(wrappedNode, typeSolver)); + ResolvedType type = JavaParserFacade.get(typeSolver).convert(variableDeclarator.getType(), JavaParserFactory.getContext(wrappedNode, typeSolver)); return type; } else if (getParentNode(wrappedNode) instanceof FieldDeclaration) { return JavaParserFacade.get(typeSolver).convert(variableDeclarator.getType(), JavaParserFactory.getContext(wrappedNode, typeSolver)); @@ -160,7 +165,7 @@ public Type getType() { } @Override - public TypeDeclaration asType() { + public ResolvedTypeDeclaration asType() { throw new UnsupportedOperationException(this.getClass().getCanonicalName() + ": wrapping " + this.getWrappedNode().getClass().getCanonicalName()); } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeAdapter.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeAdapter.java index 982fad2214..c65b2d8176 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeAdapter.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeAdapter.java @@ -8,16 +8,15 @@ import com.github.javaparser.ast.nodeTypes.NodeWithMembers; import com.github.javaparser.ast.nodeTypes.NodeWithSimpleName; import com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters; +import com.github.javaparser.resolution.declarations.ResolvedFieldDeclaration; import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +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.JavaParserFactory; -import com.github.javaparser.symbolsolver.model.declarations.FieldDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.ReferenceTypeDeclaration; -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.ReferenceTypeImpl; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import com.github.javaparser.symbolsolver.resolution.SymbolSolver; import java.util.ArrayList; @@ -57,9 +56,9 @@ public String getQualifiedName() { } public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) { - List ancestorsOfOther = other.getAllAncestors(); + List ancestorsOfOther = other.getAllAncestors(); ancestorsOfOther.add(new ReferenceTypeImpl(other, typeSolver)); - for (ReferenceType ancestorOfOther : ancestorsOfOther) { + for (ResolvedReferenceType ancestorOfOther : ancestorsOfOther) { if (ancestorOfOther.getQualifiedName().equals(this.getQualifiedName())) { return true; } @@ -67,7 +66,7 @@ public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) { return false; } - public boolean isAssignableBy(Type type) { + public boolean isAssignableBy(ResolvedType type) { if (type.isNull()) { return true; } @@ -79,7 +78,7 @@ public boolean isAssignableBy(Type type) { } } - public SymbolReference solveType(String name, TypeSolver typeSolver) { + public SymbolReference solveType(String name, TypeSolver typeSolver) { if (this.wrappedNode.getTypeParameters() != null) { for (com.github.javaparser.ast.type.TypeParameter typeParameter : this.wrappedNode.getTypeParameters()) { if (typeParameter.getName().getId().equals(name)) { @@ -112,18 +111,18 @@ public SymbolReference solveType(String name, TypeSolver typeSo } } } - return SymbolReference.unsolved(TypeDeclaration.class); + return SymbolReference.unsolved(ResolvedTypeDeclaration.class); } - public Optional containerType() { + public Optional containerType() { Optional parent = wrappedNode.getParentNode(); return parent.isPresent() ? Optional.of(JavaParserFactory.toTypeDeclaration(parent.get(), typeSolver)) : Optional.empty(); } - public List getFieldsForDeclaredVariables() { - ArrayList fields = new ArrayList<>(); + public List getFieldsForDeclaredVariables() { + ArrayList fields = new ArrayList<>(); if (wrappedNode.getMembers() != null) { for (BodyDeclaration member : this.wrappedNode.getMembers()) { if (member instanceof com.github.javaparser.ast.body.FieldDeclaration) { diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter.java index e9d67c6808..79eaf350f0 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter.java @@ -19,18 +19,15 @@ import com.github.javaparser.ast.Node; import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; import com.github.javaparser.ast.type.ClassOrInterfaceType; -import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration; -import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; -import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration; +import com.github.javaparser.resolution.declarations.*; +import com.github.javaparser.resolution.types.ResolvedReferenceType; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade; import com.github.javaparser.symbolsolver.logic.AbstractTypeDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.*; 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.ReferenceTypeImpl; -import com.github.javaparser.symbolsolver.model.typesystem.Type; import java.util.ArrayList; import java.util.Collections; @@ -59,7 +56,7 @@ public Set getDeclaredMethods() { return Collections.emptySet(); } - public SymbolReference solveMethod(String name, List parameterTypes) { + public SymbolReference solveMethod(String name, List parameterTypes) { return getContext().solveMethod(name, parameterTypes, false, typeSolver); } @@ -94,9 +91,9 @@ public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) { @Override public String getContainerQualifiedName() { - TypeParametrizable container = getContainer(); - if (container instanceof ReferenceTypeDeclaration) { - return ((ReferenceTypeDeclaration) container).getQualifiedName(); + ResolvedTypeParametrizable container = getContainer(); + if (container instanceof ResolvedReferenceTypeDeclaration) { + return ((ResolvedReferenceTypeDeclaration) container).getQualifiedName(); } else if (container instanceof JavaParserConstructorDeclaration) { return ((JavaParserConstructorDeclaration) container).getQualifiedSignature(); } else { @@ -106,9 +103,9 @@ public String getContainerQualifiedName() { @Override public String getContainerId() { - TypeParametrizable container = getContainer(); - if (container instanceof ReferenceTypeDeclaration) { - return ((ReferenceTypeDeclaration) container).getId(); + ResolvedTypeParametrizable container = getContainer(); + if (container instanceof ResolvedReferenceTypeDeclaration) { + return ((ResolvedReferenceTypeDeclaration) container).getId(); } else if (container instanceof JavaParserConstructorDeclaration) { return ((JavaParserConstructorDeclaration) container).getQualifiedSignature(); } else { @@ -117,7 +114,7 @@ public String getContainerId() { } @Override - public TypeParametrizable getContainer() { + public ResolvedTypeParametrizable getContainer() { Node parentNode = getParentNode(wrappedNode); if (parentNode instanceof com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) { com.github.javaparser.ast.body.ClassOrInterfaceDeclaration jpTypeDeclaration = (com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) parentNode; @@ -144,12 +141,12 @@ public String getQualifiedName() { } @Override - public List getBounds(TypeSolver typeSolver) { + public List getBounds() { return wrappedNode.getTypeBound().stream().map((astB) -> toBound(astB, typeSolver)).collect(Collectors.toList()); } private Bound toBound(ClassOrInterfaceType classOrInterfaceType, TypeSolver typeSolver) { - Type type = JavaParserFacade.get(typeSolver).convertToUsage(classOrInterfaceType, classOrInterfaceType); + ResolvedType type = JavaParserFacade.get(typeSolver).convertToUsage(classOrInterfaceType, classOrInterfaceType); Bound bound = Bound.extendsBound(type); return bound; } @@ -158,17 +155,17 @@ public Context getContext() { throw new UnsupportedOperationException(); } - public Type getUsage(Node node) { + public ResolvedType getUsage(Node node) { throw new UnsupportedOperationException(); } @Override - public boolean isAssignableBy(Type type) { + public boolean isAssignableBy(ResolvedType type) { throw new UnsupportedOperationException(); } @Override - public FieldDeclaration getField(String name) { + public ResolvedFieldDeclaration getField(String name) { throw new UnsupportedOperationException(); } @@ -178,12 +175,12 @@ public boolean hasField(String name) { } @Override - public List getAllFields() { + public List getAllFields() { return new ArrayList<>(); } @Override - public List getAncestors() { + public List getAncestors() { throw new UnsupportedOperationException(); } @@ -198,7 +195,7 @@ public boolean hasDirectlyAnnotation(String canonicalName) { } @Override - public List getTypeParameters() { + public List getTypeParameters() { return Collections.emptyList(); } @@ -217,10 +214,10 @@ public String toString() { } @Override - public Optional containerType() { - TypeParametrizable container = getContainer(); - if (container instanceof ReferenceTypeDeclaration) { - return Optional.of((ReferenceTypeDeclaration) container); + public Optional containerType() { + ResolvedTypeParametrizable container = getContainer(); + if (container instanceof ResolvedReferenceTypeDeclaration) { + return Optional.of((ResolvedReferenceTypeDeclaration) container); } return Optional.empty(); } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclaration.java index 6e7210a522..3191f4ab98 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclaration.java @@ -18,7 +18,10 @@ import com.github.javaparser.ast.AccessSpecifier; import com.github.javaparser.ast.Node; +import com.github.javaparser.resolution.MethodUsage; import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +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.LambdaArgumentTypePlaceholder; import com.github.javaparser.symbolsolver.logic.AbstractClassDeclaration; @@ -122,13 +125,13 @@ public String getQualifiedName() { return ctClass.getName().replace('$', '.'); } - public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver, - Context invokationContext, List typeParameterValues) { + public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver, + Context invokationContext, List typeParameterValues) { return JavassistUtils.getMethodUsage(ctClass, name, argumentsTypes, typeSolver, invokationContext); } @Deprecated - public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { + public SymbolReference solveSymbol(String name, TypeSolver typeSolver) { for (CtField field : ctClass.getDeclaredFields()) { if (field.getName().equals(name)) { return SymbolReference.solved(new JavassistFieldDeclaration(field, typeSolver)); @@ -138,7 +141,7 @@ public SymbolReference solveSymbol(String name, Type try { CtClass superClass = ctClass.getSuperclass(); if (superClass != null) { - SymbolReference ref = new JavassistClassDeclaration(superClass, typeSolver).solveSymbol(name, typeSolver); + SymbolReference ref = new JavassistClassDeclaration(superClass, typeSolver).solveSymbol(name, typeSolver); if (ref.isSolved()) { return ref; } @@ -149,7 +152,7 @@ public SymbolReference solveSymbol(String name, Type try { for (CtClass interfaze : ctClass.getInterfaces()) { - SymbolReference ref = new JavassistInterfaceDeclaration(interfaze, typeSolver).solveSymbol(name, typeSolver); + SymbolReference ref = new JavassistInterfaceDeclaration(interfaze, typeSolver).solveSymbol(name, typeSolver); if (ref.isSolved()) { return ref; } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclaration.java index 82337a8d94..6cae1776ce 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclaration.java @@ -18,7 +18,11 @@ import com.github.javaparser.ast.AccessSpecifier; import com.github.javaparser.ast.expr.MethodCallExpr; +import com.github.javaparser.resolution.MethodUsage; +import com.github.javaparser.resolution.UnsolvedSymbolException; +import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration; import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.logic.AbstractTypeDeclaration; import com.github.javaparser.symbolsolver.model.declarations.*; @@ -182,7 +186,7 @@ public SymbolReference solveMethod(String name, List ar try { CtClass superClass = ctClass.getSuperclass(); if (superClass != null) { - SymbolReference ref = new JavassistClassDeclaration(superClass, typeSolver).solveMethod(name, argumentsTypes, staticOnly); + SymbolReference ref = new JavassistClassDeclaration(superClass, typeSolver).solveMethod(name, argumentsTypes, staticOnly); if (ref.isSolved()) { candidates.add(ref.getCorrespondingDeclaration()); } @@ -194,12 +198,13 @@ public SymbolReference solveMethod(String name, List ar return MethodResolutionLogic.findMostApplicable(candidates, name, argumentsTypes, typeSolver); } - public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver, Context invokationContext, List typeParameterValues) { + public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver, + Context invokationContext, List typeParameterValues) { return JavassistUtils.getMethodUsage(ctClass, name, argumentsTypes, typeSolver, invokationContext); } @Override - public Set internalTypes() { + public Set internalTypes() { try { /* Get all internal types of the current class and get their corresponding ReferenceTypeDeclaration. @@ -212,12 +217,12 @@ public Set internalTypes() { } @Override - public ReferenceTypeDeclaration getInternalType(String name) { + public ResolvedReferenceTypeDeclaration getInternalType(String name) { /* The name of the ReferenceTypeDeclaration could be composed on the internal class and the outer class, e.g. A$B. That's why we search the internal type in the ending part. In case the name is composed of the internal type only, i.e. f.getName() returns B, it will also works. */ - Optional type = + Optional type = this.internalTypes().stream().filter(f -> f.getName().endsWith(name)).findFirst(); return type.orElseThrow(() -> new UnsolvedSymbolException("Internal type not found: " + name)); diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclaration.java index 228682bdac..8e1dcda401 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclaration.java @@ -17,7 +17,10 @@ package com.github.javaparser.symbolsolver.javassistmodel; import com.github.javaparser.ast.AccessSpecifier; +import com.github.javaparser.resolution.MethodUsage; +import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration; import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.core.resolution.Context; import com.github.javaparser.symbolsolver.logic.AbstractTypeDeclaration; import com.github.javaparser.symbolsolver.model.declarations.*; @@ -97,15 +100,15 @@ public String getQualifiedName() { } @Deprecated - public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver, - Context invokationContext, List typeParameterValues) { + public Optional solveMethodAsUsage(String name, List argumentsTypes, TypeSolver typeSolver, + Context invokationContext, List typeParameterValues) { return JavassistUtils.getMethodUsage(ctClass, name, argumentsTypes, typeSolver, invokationContext); } @Deprecated - public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly) { - List candidates = new ArrayList<>(); + public SymbolReference solveMethod(String name, List argumentsTypes, boolean staticOnly) { + List candidates = new ArrayList<>(); Predicate staticOnlyCheck = m -> !staticOnly || (staticOnly && Modifier.isStatic(m.getModifiers())); for (CtMethod method : ctClass.getDeclaredMethods()) { boolean isSynthetic = method.getMethodInfo().getAttribute(SyntheticAttribute.tag) != null; @@ -118,7 +121,7 @@ public SymbolReference solveMethod(String name, List ar try { CtClass superClass = ctClass.getSuperclass(); if (superClass != null) { - SymbolReference ref = new JavassistClassDeclaration(superClass, typeSolver).solveMethod(name, argumentsTypes, staticOnly); + SymbolReference ref = new JavassistClassDeclaration(superClass, typeSolver).solveMethod(name, argumentsTypes, staticOnly); if (ref.isSolved()) { candidates.add(ref.getCorrespondingDeclaration()); } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/model/typesystem/LazyType.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/model/typesystem/LazyType.java index 179c0fb9ed..a7d05d1432 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/model/typesystem/LazyType.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/model/typesystem/LazyType.java @@ -1,19 +1,21 @@ package com.github.javaparser.symbolsolver.model.typesystem; -import com.github.javaparser.symbolsolver.model.declarations.TypeParameterDeclaration; +import com.github.javaparser.resolution.declarations.*; +import com.github.javaparser.resolution.types.*; +import com.github.javaparser.resolution.types.ResolvedType; import java.util.Map; import java.util.function.Function; -public class LazyType implements Type { - private Type concrete; - private Function provider; +public class LazyType implements ResolvedType { + private ResolvedType concrete; + private Function provider; - public LazyType(Function provider) { + public LazyType(Function provider) { this.provider = provider; } - private Type getType() { + private ResolvedType getType() { if (concrete == null) { concrete = provider.apply(null); } @@ -66,32 +68,32 @@ public boolean isWildcard() { } @Override - public ArrayType asArrayType() { + public ResolvedArrayType asArrayType() { return getType().asArrayType(); } @Override - public ReferenceType asReferenceType() { + public ResolvedReferenceType asReferenceType() { return getType().asReferenceType(); } @Override - public TypeParameterDeclaration asTypeParameter() { + public ResolvedTypeParameterDeclaration asTypeParameter() { return getType().asTypeParameter(); } @Override - public TypeVariable asTypeVariable() { + public ResolvedTypeVariable asTypeVariable() { return getType().asTypeVariable(); } @Override - public PrimitiveType asPrimitive() { + public ResolvedPrimitiveType asPrimitive() { return getType().asPrimitive(); } @Override - public Wildcard asWildcard() { + public ResolvedWildcard asWildcard() { return getType().asWildcard(); } @@ -101,17 +103,18 @@ public String describe() { } @Override - public Type replaceTypeVariables(TypeParameterDeclaration tp, Type replaced, Map inferredTypes) { + public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tp, ResolvedType replaced, + Map inferredTypes) { return getType().replaceTypeVariables(tp, replaced, inferredTypes); } @Override - public Type replaceTypeVariables(TypeParameterDeclaration tp, Type replaced) { + public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tp, ResolvedType replaced) { return getType().replaceTypeVariables(tp, replaced); } @Override - public boolean isAssignableBy(Type other) { + public boolean isAssignableBy(ResolvedType other) { return getType().isAssignableBy(other); } } diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionFactory.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionFactory.java index 24e82bd3ef..e6d409022a 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionFactory.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionFactory.java @@ -17,6 +17,10 @@ package com.github.javaparser.symbolsolver.reflectionmodel; import com.github.javaparser.ast.AccessSpecifier; +import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +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.model.declarations.ReferenceTypeDeclaration; import com.github.javaparser.symbolsolver.model.declarations.TypeParameterDeclaration; import com.github.javaparser.symbolsolver.model.resolution.TypeSolver; @@ -35,7 +39,7 @@ */ public class ReflectionFactory { - public static ReferenceTypeDeclaration typeDeclarationFor(Class clazz, TypeSolver typeSolver) { + public static ResolvedReferenceTypeDeclaration typeDeclarationFor(Class clazz, TypeSolver typeSolver) { if (clazz.isArray()) { throw new IllegalArgumentException("No type declaration available for an Array"); } else if (clazz.isPrimitive()) { @@ -49,15 +53,15 @@ public static ReferenceTypeDeclaration typeDeclarationFor(Class clazz, TypeSo } } - public static Type typeUsageFor(java.lang.reflect.Type type, TypeSolver typeSolver) { + public static ResolvedType typeUsageFor(java.lang.reflect.Type type, TypeSolver typeSolver) { if (type instanceof java.lang.reflect.TypeVariable) { java.lang.reflect.TypeVariable tv = (java.lang.reflect.TypeVariable) type; boolean declaredOnClass = tv.getGenericDeclaration() instanceof java.lang.reflect.Type; - TypeParameterDeclaration typeParameter = new ReflectionTypeParameter(tv, declaredOnClass, typeSolver); - return new com.github.javaparser.symbolsolver.model.typesystem.TypeVariable(typeParameter); + ResolvedTypeParameterDeclaration typeParameter = new ReflectionTypeParameter(tv, declaredOnClass, typeSolver); + return new ResolvedTypeVariable(typeParameter); } else if (type instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) type; - ReferenceType rawType = typeUsageFor(pt.getRawType(), typeSolver).asReferenceType(); + ResolvedReferenceType rawType = typeUsageFor(pt.getRawType(), typeSolver).asReferenceType(); List actualTypes = new ArrayList<>(); actualTypes.addAll(Arrays.asList(pt.getActualTypeArguments())); // we consume the actual types diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclaration.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclaration.java index ce5573b1f0..2f4e11e8f0 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclaration.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclaration.java @@ -132,7 +132,8 @@ public int hashCode() { return clazz.hashCode(); } - public Optional solveMethodAsUsage(String name, List parameterTypes, TypeSolver typeSolver, Context invokationContext, List typeParameterValues) { + public Optional solveMethodAsUsage(String name, List parameterTypes, TypeSolver typeSolver, + Context invokationContext, List typeParameterValues) { Optional res = ReflectionMethodResolutionLogic.solveMethodAsUsage(name, parameterTypes, typeSolver, invokationContext, typeParameterValues, this, clazz); if (res.isPresent()) { diff --git a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/ConstructorResolutionLogic.java b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/ConstructorResolutionLogic.java index 192eae041b..6501f067db 100644 --- a/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/ConstructorResolutionLogic.java +++ b/java-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/resolution/ConstructorResolutionLogic.java @@ -14,6 +14,11 @@ package com.github.javaparser.symbolsolver.resolution; +import com.github.javaparser.resolution.MethodAmbiguityException; +import com.github.javaparser.resolution.declarations.ResolvedConstructorDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration; +import com.github.javaparser.resolution.types.ResolvedArrayType; +import com.github.javaparser.resolution.types.ResolvedType; import com.github.javaparser.symbolsolver.model.declarations.ConstructorDeclaration; import com.github.javaparser.symbolsolver.model.declarations.MethodAmbiguityException; import com.github.javaparser.symbolsolver.model.declarations.TypeParameterDeclaration; @@ -33,21 +38,21 @@ */ public class ConstructorResolutionLogic { - private static List groupVariadicParamValues(List argumentsTypes, int startVariadic, - Type variadicType) { - List res = new ArrayList<>(argumentsTypes.subList(0, startVariadic)); - List variadicValues = argumentsTypes.subList(startVariadic, argumentsTypes.size()); + private static List groupVariadicParamValues(List argumentsTypes, int startVariadic, + ResolvedType variadicType) { + List res = new ArrayList<>(argumentsTypes.subList(0, startVariadic)); + List variadicValues = argumentsTypes.subList(startVariadic, argumentsTypes.size()); if (variadicValues.isEmpty()) { // TODO if there are no variadic values we should default to the bound of the formal type res.add(variadicType); } else { - Type componentType = findCommonType(variadicValues); - res.add(new ArrayType(componentType)); + ResolvedType componentType = findCommonType(variadicValues); + res.add(new ResolvedArrayType(componentType)); } return res; } - private static Type findCommonType(List variadicValues) { + private static ResolvedType findCommonType(List variadicValues) { if (variadicValues.isEmpty()) { throw new IllegalArgumentException(); } @@ -55,21 +60,21 @@ private static Type findCommonType(List variadicValues) { return variadicValues.get(0); } - public static boolean isApplicable(ConstructorDeclaration constructor, List argumentsTypes, + public static boolean isApplicable(ResolvedConstructorDeclaration constructor, List argumentsTypes, TypeSolver typeSolver) { return isApplicable(constructor, argumentsTypes, typeSolver, false); } - private static boolean isApplicable(ConstructorDeclaration constructor, List argumentsTypes, + private static boolean isApplicable(ResolvedConstructorDeclaration constructor, List argumentsTypes, TypeSolver typeSolver, boolean withWildcardTolerance) { if (constructor.hasVariadicParameter()) { int pos = constructor.getNumberOfParams() - 1; if (constructor.getNumberOfParams() == argumentsTypes.size()) { // check if the last value is directly assignable as an array - Type expectedType = constructor.getLastParam().getType(); - Type actualType = argumentsTypes.get(pos); + ResolvedType expectedType = constructor.getLastParam().getType(); + ResolvedType actualType = argumentsTypes.get(pos); if (!expectedType.isAssignableBy(actualType)) { - for (TypeParameterDeclaration tp : constructor.getTypeParameters()) { + for (ResolvedTypeParameterDeclaration tp : constructor.getTypeParameters()) { expectedType = MethodResolutionLogic.replaceTypeParam(expectedType, tp, typeSolver); } if (!expectedType.isAssignableBy(actualType)) { @@ -94,11 +99,11 @@ private static boolean isApplicable(ConstructorDeclaration constructor, List matchedParameters = new HashMap<>(); + Map matchedParameters = new HashMap<>(); boolean needForWildCardTolerance = false; for (int i = 0; i < constructor.getNumberOfParams(); i++) { - Type expectedType = constructor.getParam(i).getType(); - Type actualType = argumentsTypes.get(i); + ResolvedType expectedType = constructor.getParam(i).getType(); + ResolvedType actualType = argumentsTypes.get(i); if ((expectedType.isTypeVariable() && !(expectedType.isWildcard())) && expectedType.asTypeParameter().declaredOnMethod()) { matchedParameters.put(expectedType.asTypeParameter().getName(), actualType); @@ -106,16 +111,16 @@ private static boolean isApplicable(ConstructorDeclaration constructor, List typeParameters = constructor.getTypeParameters(); + List typeParameters = constructor.getTypeParameters(); typeParameters.addAll(constructor.declaringType().getTypeParameters()); - for (TypeParameterDeclaration tp : typeParameters) { + for (ResolvedTypeParameterDeclaration tp : typeParameters) { expectedType = MethodResolutionLogic.replaceTypeParam(expectedType, tp, typeSolver); } @@ -125,7 +130,7 @@ private static boolean isApplicable(ConstructorDeclaration constructor, List findMostApplicable( - List constructors, List argumentsTypes, TypeSolver typeSolver) { - SymbolReference res = + public static SymbolReference findMostApplicable( + List constructors, List argumentsTypes, TypeSolver typeSolver) { + SymbolReference res = findMostApplicable(constructors, argumentsTypes, typeSolver, false); if (res.isSolved()) { return res; @@ -153,16 +158,17 @@ public static SymbolReference findMostApplicable( return findMostApplicable(constructors, argumentsTypes, typeSolver, true); } - public static SymbolReference findMostApplicable(List constructors, List argumentsTypes, TypeSolver typeSolver, boolean wildcardTolerance) { - List applicableConstructors = constructors.stream().filter((m) -> isApplicable(m, argumentsTypes, typeSolver, wildcardTolerance)).collect(Collectors.toList()); + public static SymbolReference findMostApplicable( + List constructors, List argumentsTypes, TypeSolver typeSolver, boolean wildcardTolerance) { + List applicableConstructors = constructors.stream().filter((m) -> isApplicable(m, argumentsTypes, typeSolver, wildcardTolerance)).collect(Collectors.toList()); if (applicableConstructors.isEmpty()) { return SymbolReference.unsolved(ConstructorDeclaration.class); } if (applicableConstructors.size() == 1) { return SymbolReference.solved(applicableConstructors.get(0)); } else { - ConstructorDeclaration winningCandidate = applicableConstructors.get(0); - ConstructorDeclaration other = null; + ResolvedConstructorDeclaration winningCandidate = applicableConstructors.get(0); + ResolvedConstructorDeclaration other = null; boolean possibleAmbiguity = false; for (int i = 1; i < applicableConstructors.size(); i++) { other = applicableConstructors.get(i); @@ -194,8 +200,8 @@ public static SymbolReference findMostApplicable(List bounds = tp.getBounds(typeSolver); + List bounds = tp.getBounds(typeSolver); if (bounds.size() > 1) { throw new UnsupportedOperationException(); } else if (bounds.size() == 1) { @@ -256,14 +257,14 @@ public static Type replaceTypeParam(Type type, TypeParameterDeclaration tp, Type } else if (type.isPrimitive()) { return type; } else if (type.isArray()) { - return new ArrayType(replaceTypeParam(type.asArrayType().getComponentType(), tp, typeSolver)); + return new ResolvedArrayType(replaceTypeParam(type.asArrayType().getComponentType(), tp, typeSolver)); } else if (type.isReferenceType()) { - ReferenceType result = type.asReferenceType(); + ResolvedReferenceType result = type.asReferenceType(); result = result.transformTypeParameters(typeParam -> replaceTypeParam(typeParam, tp, typeSolver)).asReferenceType(); return result; } else if (type.isWildcard()) { if (type.describe().equals(tp.getName())) { - List bounds = tp.getBounds(typeSolver); + List bounds = tp.getBounds(typeSolver); if (bounds.size() > 1) { throw new UnsupportedOperationException(); } else if (bounds.size() == 1) { @@ -278,7 +279,7 @@ public static Type replaceTypeParam(Type type, TypeParameterDeclaration tp, Type } } - public static boolean isApplicable(MethodUsage method, String name, List argumentsTypes, TypeSolver typeSolver) { + public static boolean isApplicable(MethodUsage method, String name, List argumentsTypes, TypeSolver typeSolver) { if (!method.getName().equals(name)) { return false; } diff --git a/java-symbol-solver-logic/src/main/java/com/github/javaparser/symbolsolver/logic/AbstractTypeDeclaration.java b/java-symbol-solver-logic/src/main/java/com/github/javaparser/symbolsolver/logic/AbstractTypeDeclaration.java index db86ef1caf..b08ff1e67b 100644 --- a/java-symbol-solver-logic/src/main/java/com/github/javaparser/symbolsolver/logic/AbstractTypeDeclaration.java +++ b/java-symbol-solver-logic/src/main/java/com/github/javaparser/symbolsolver/logic/AbstractTypeDeclaration.java @@ -16,11 +16,10 @@ package com.github.javaparser.symbolsolver.logic; -import com.github.javaparser.symbolsolver.model.declarations.MethodDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.ReferenceTypeDeclaration; -import com.github.javaparser.symbolsolver.model.declarations.TypeDeclaration; -import com.github.javaparser.symbolsolver.model.methods.MethodUsage; -import com.github.javaparser.symbolsolver.model.typesystem.ReferenceType; +import com.github.javaparser.resolution.MethodUsage; +import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration; +import com.github.javaparser.resolution.types.ResolvedReferenceType; import java.util.HashSet; import java.util.List; @@ -31,7 +30,7 @@ * * @author Federico Tomassetti */ -public abstract class AbstractTypeDeclaration implements ReferenceTypeDeclaration { +public abstract class AbstractTypeDeclaration implements ResolvedReferenceTypeDeclaration { @Override public final Set getAllMethods() { @@ -39,12 +38,12 @@ public final Set getAllMethods() { Set methodsSignatures = new HashSet<>(); - for (MethodDeclaration methodDeclaration : getDeclaredMethods()) { + for (ResolvedMethodDeclaration methodDeclaration : getDeclaredMethods()) { methods.add(new MethodUsage(methodDeclaration)); methodsSignatures.add(methodDeclaration.getSignature()); } - for (ReferenceType ancestor : getAllAncestors()) { + for (ResolvedReferenceType ancestor : getAllAncestors()) { for (MethodUsage mu : ancestor.getDeclaredMethods()) { String signature = mu.getDeclaration().getSignature(); if (!methodsSignatures.contains(signature)) {