SymbolReference<ResolvedTypeDeclaration> ref = solveType(className); if (ref.isSolved()) { SymbolReference<ResolvedMethodDeclaration> m = MethodResolutionLogic.solveMethodInType(ref.getCorrespondingDeclaration(), name, argumentsTypes); if (m.isSolved()) { MethodUsage methodUsage = new MethodUsage(m.getCorrespondingDeclaration()); methodUsage = resolveMethodTypeParametersFromExplicitList(typeSolver, methodUsage); methodUsage = resolveMethodTypeParameters(methodUsage, argumentsTypes); return Optional.of(methodUsage); } else { ResolvedType updatedArgumentType = usingParameterTypesFromScope(typeOfScope, originalArgumentType, inferredTypes); argumentsTypes.set(i, updatedArgumentType); ResolvedType updatedArgumentType = applyInferredTypes(argumentsTypes.get(i), inferredTypes); argumentsTypes.set(i, updatedArgumentType); return solveMethodAsUsage(typeOfScope, name, argumentsTypes, this); } else { Context parentContext = getParent(); while (parentContext instanceof MethodCallExprContext || parentContext instanceof ObjectCreationContext) { parentContext = parentContext.getParent();
private void assertCanSolveGenericMethodCallMustUseProvidedTypeArgs(String callMethodName) throws ParseException { MethodCallExpr methodCallExpr = getMethodCallExpr("genericMethodTest", callMethodName); CombinedTypeSolver typeSolver = createTypeSolver(); MethodCallExprContext context = new MethodCallExprContext(methodCallExpr, typeSolver); Optional<MethodUsage> ref = context.solveMethodAsUsage(callMethodName, Collections.emptyList(), typeSolver); assertTrue(ref.isPresent()); assertEquals("MethodCalls", ref.get().declaringType().getQualifiedName()); assertEquals(Collections.singletonList("java.lang.Integer"), ref.get().typeParametersMap().getTypes().stream().map(ty -> ty.asReferenceType().describe()).collect(Collectors.toList())); }
MethodUsage methodUsage = ref.get(); methodUsage = resolveMethodTypeParametersFromExplicitList(typeSolver, methodUsage); parameterType = parameterType.asArrayType().getComponentType(); inferTypes(argumentsTypes.get(i), parameterType, derivedValues);
private Optional<MethodUsage> solveMethodAsUsage(ResolvedTypeVariable tp, String name, List<ResolvedType> argumentsTypes, TypeSolver typeSolver, Context invokationContext) { for (ResolvedTypeParameterDeclaration.Bound bound : tp.asTypeParameter().getBounds()) { Optional<MethodUsage> methodUsage = solveMethodAsUsage(bound.getType(), name, argumentsTypes, typeSolver, invokationContext); if (methodUsage.isPresent()) { return methodUsage; } } return Optional.empty(); }
@Test public void solveNestedMethodCallExprContextWithoutScope() throws ParseException { MethodCallExpr methodCallExpr = getMethodCallExpr("bar1", "foo"); CombinedTypeSolver typeSolver = createTypeSolver(); Context context = new MethodCallExprContext(methodCallExpr, typeSolver); Optional<MethodUsage> ref = context.solveMethodAsUsage("foo", Collections.emptyList(), typeSolver); assertTrue(ref.isPresent()); assertEquals("MethodCalls", ref.get().declaringType().getQualifiedName()); }
@Override public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) { Context parentContext = getParent(); return parentContext.solveSymbolAsValue(name, typeSolver); }
throw new UnsupportedOperationException(actualType.getClass().getCanonicalName()); matchTypeParameters( expectedType.asArrayType().getComponentType(), actualType.asArrayType().getComponentType(), int i = 0; for (ResolvedType tp : expectedType.asReferenceType().typeParametersValues()) { matchTypeParameters(tp, actualType.asReferenceType().typeParametersValues().get(i), matchedTypeParameters); i++;
if (!sourceRefType.isRawType() && !targetRefType.isRawType()) { for (int i = 0; i < sourceRefType.typeParametersValues().size(); i++) { inferTypes(sourceRefType.typeParametersValues().get(i), targetRefType.typeParametersValues().get(i), mappings); inferTypes(source, target.asWildcard().getBoundedType(), mappings); return; inferTypes(source.asWildcard().getBoundedType(), target.asWildcard().getBoundedType(), mappings); inferTypes(source, target.asWildcard().getBoundedType(), mappings); return; inferTypes(source.asWildcard().getBoundedType(), target, mappings); inferTypes(source.asConstraintType().getBound(), target, mappings); return; inferTypes(source.asConstraintType().getBound(), target, mappings); return;
SymbolReference<ResolvedTypeDeclaration> symbolReference = this.solveType(scopeAsName.getName().getId(), typeSolver); if (symbolReference.isSolved() && symbolReference.getCorrespondingDeclaration().isType()) { ResolvedTypeDeclaration typeDeclaration = symbolReference.getCorrespondingDeclaration().asType();
private void assertCanSolveGenericMethodCallCanInferFromArguments(String callMethodName) throws ParseException { MethodCallExpr methodCallExpr = getMethodCallExpr("genericMethodTest", callMethodName); CombinedTypeSolver typeSolver = createTypeSolver(); MethodCallExprContext context = new MethodCallExprContext(methodCallExpr, typeSolver); ResolvedReferenceTypeDeclaration stringType = typeSolver.solveType("java.lang.String"); List<ResolvedType> argumentsTypes = new ArrayList<>(); argumentsTypes.add(new ReferenceTypeImpl(stringType, typeSolver)); Optional<MethodUsage> ref = context.solveMethodAsUsage(callMethodName, argumentsTypes, typeSolver); assertTrue(ref.isPresent()); assertEquals("MethodCalls", ref.get().declaringType().getQualifiedName()); assertEquals(Collections.singletonList("java.lang.String"), ref.get().typeParametersMap().getTypes().stream().map(ty -> ty.asReferenceType().describe()).collect(Collectors.toList())); } }
MethodUsage methodUsage = ref.get(); methodUsage = resolveMethodTypeParametersFromExplicitList(typeSolver, methodUsage); parameterType = parameterType.asArrayType().getComponentType(); inferTypes(argumentsTypes.get(i), parameterType, derivedValues);
private Optional<MethodUsage> solveMethodAsUsage(ResolvedType type, String name, List<ResolvedType> 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()) { throw new UnsupportedOperationException("extends wildcard"); } else { throw new UnsupportedOperationException("unbounded wildcard"); } } else if (type instanceof ResolvedLambdaConstraintType){ ResolvedLambdaConstraintType constraintType = (ResolvedLambdaConstraintType) type; return solveMethodAsUsage(constraintType.getBound(), name, argumentsTypes, typeSolver, invokationContext); } else if (type instanceof ResolvedArrayType) { // An array inherits methods from Object not from it's component type return solveMethodAsUsage(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver), name, argumentsTypes, typeSolver, invokationContext); } else { throw new UnsupportedOperationException("type usage: " + type.getClass().getCanonicalName()); } }
return new ClassOrInterfaceDeclarationContext((ClassOrInterfaceDeclaration) node, typeSolver); } else if (node instanceof MethodCallExpr) { return new MethodCallExprContext((MethodCallExpr) node, typeSolver); } else if (node instanceof EnumDeclaration) { return new EnumDeclarationContext((EnumDeclaration) node, typeSolver);
@Override public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) { Context parentContext = getParent(); return parentContext.solveSymbolAsValue(name, typeSolver); }
throw new UnsupportedOperationException(actualType.getClass().getCanonicalName()); matchTypeParameters( expectedType.asArrayType().getComponentType(), actualType.asArrayType().getComponentType(), int i = 0; for (ResolvedType tp : expectedType.asReferenceType().typeParametersValues()) { matchTypeParameters(tp, actualType.asReferenceType().typeParametersValues().get(i), matchedTypeParameters); i++;
if (!sourceRefType.isRawType() && !targetRefType.isRawType()) { for (int i = 0; i < sourceRefType.typeParametersValues().size(); i++) { inferTypes(sourceRefType.typeParametersValues().get(i), targetRefType.typeParametersValues().get(i), mappings); inferTypes(source, target.asWildcard().getBoundedType(), mappings); return; inferTypes(source.asWildcard().getBoundedType(), target.asWildcard().getBoundedType(), mappings); ResolvedType sourceComponentType = source.asArrayType().getComponentType(); ResolvedType targetComponentType = target.asArrayType().getComponentType(); inferTypes(sourceComponentType, targetComponentType, mappings); return; inferTypes(source, target.asWildcard().getBoundedType(), mappings); return; inferTypes(source.asWildcard().getBoundedType(), target, mappings); inferTypes(source.asConstraintType().getBound(), target, mappings); return; inferTypes(source.asConstraintType().getBound(), target, mappings); return;
SymbolReference<ResolvedTypeDeclaration> ref = solveType(className, typeSolver); if (ref.isSolved()) { SymbolReference<ResolvedMethodDeclaration> m = MethodResolutionLogic.solveMethodInType(ref.getCorrespondingDeclaration(), name, argumentsTypes, typeSolver); if (m.isSolved()) { MethodUsage methodUsage = new MethodUsage(m.getCorrespondingDeclaration()); methodUsage = resolveMethodTypeParametersFromExplicitList(typeSolver, methodUsage); methodUsage = resolveMethodTypeParameters(methodUsage, argumentsTypes); return Optional.of(methodUsage); } else { ResolvedType updatedArgumentType = usingParameterTypesFromScope(typeOfScope, originalArgumentType, inferredTypes); argumentsTypes.set(i, updatedArgumentType); ResolvedType updatedArgumentType = applyInferredTypes(argumentsTypes.get(i), inferredTypes); argumentsTypes.set(i, updatedArgumentType); return solveMethodAsUsage(typeOfScope, name, argumentsTypes, typeSolver, this); } else { Context parentContext = getParent(); while (parentContext instanceof MethodCallExprContext) { parentContext = parentContext.getParent();
MethodUsage methodUsage = ref.get(); methodUsage = resolveMethodTypeParametersFromExplicitList(typeSolver, methodUsage); parameterType = parameterType.asArrayType().getComponentType(); inferTypes(argumentsTypes.get(i), parameterType, derivedValues);
private Optional<MethodUsage> solveMethodAsUsage(ResolvedType type, String name, List<ResolvedType> 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()) { throw new UnsupportedOperationException("extends wildcard"); } else { throw new UnsupportedOperationException("unbounded wildcard"); } } else if (type instanceof ResolvedLambdaConstraintType){ ResolvedLambdaConstraintType constraintType = (ResolvedLambdaConstraintType) type; return solveMethodAsUsage(constraintType.getBound(), name, argumentsTypes, typeSolver, invokationContext); } else if (type instanceof ResolvedArrayType) { // An array inherits methods from Object not from it's component type return solveMethodAsUsage(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver), name, argumentsTypes, typeSolver, invokationContext); } else { throw new UnsupportedOperationException("type usage: " + type.getClass().getCanonicalName()); } }
return new ClassOrInterfaceDeclarationContext((ClassOrInterfaceDeclaration) node, typeSolver); } else if (node instanceof MethodCallExpr) { return new MethodCallExprContext((MethodCallExpr) node, typeSolver); } else if (node instanceof EnumDeclaration) { return new EnumDeclarationContext((EnumDeclaration) node, typeSolver);