Examples with ResolvedMethodDeclaration com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration used on opensource projects

Example 21 with ResolvedMethodDeclaration

use of com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration in project javaparser by javaparser.

the class TypeExtractor method visit.

@Override
public ResolvedType visit(LambdaExpr node, Boolean solveLambdas) {
    if (requireParentNode(node) instanceof MethodCallExpr) {
        MethodCallExpr callExpr = (MethodCallExpr) requireParentNode(node);
        int pos = JavaParserSymbolDeclaration.getParamPos(node);
        SymbolReference<ResolvedMethodDeclaration> refMethod = facade.solve(callExpr);
        if (!refMethod.isSolved()) {
            throw new com.github.javaparser.resolution.UnsolvedSymbolException(requireParentNode(node).toString(), callExpr.getName().getId());
        }
        logger.finest("getType on lambda expr " + refMethod.getCorrespondingDeclaration().getName());
        if (solveLambdas) {
            // The type parameter referred here should be the java.util.stream.Stream.T
            ResolvedType result = refMethod.getCorrespondingDeclaration().getParam(pos).getType();
            if (callExpr.getScope().isPresent()) {
                Expression scope = callExpr.getScope().get();
                // If it is a static call we should not try to get the type of the scope
                boolean staticCall = false;
                if (scope instanceof NameExpr) {
                    NameExpr nameExpr = (NameExpr) scope;
                    try {
                        SymbolReference<ResolvedTypeDeclaration> type = JavaParserFactory.getContext(nameExpr, typeSolver).solveType(nameExpr.getName().getId(), typeSolver);
                        if (type.isSolved()) {
                            staticCall = true;
                        }
                    } catch (Exception e) {
                    }
                }
                if (!staticCall) {
                    ResolvedType scopeType = facade.getType(scope);
                    if (scopeType.isReferenceType()) {
                        result = scopeType.asReferenceType().useThisTypeParametersOnTheGivenType(result);
                    }
                }
            }
            // We need to replace the type variables
            Context ctx = JavaParserFactory.getContext(node, typeSolver);
            result = solveGenericTypes(result, ctx, typeSolver);
            // We should find out which is the functional method (e.g., apply) and replace the params of the
            // solveLambdas with it, to derive so the values. We should also consider the value returned by the
            // lambdas
            Optional<MethodUsage> functionalMethod = FunctionalInterfaceLogic.getFunctionalMethod(result);
            if (functionalMethod.isPresent()) {
                LambdaExpr lambdaExpr = node;
                InferenceContext lambdaCtx = new InferenceContext(MyObjectProvider.INSTANCE);
                InferenceContext funcInterfaceCtx = new InferenceContext(MyObjectProvider.INSTANCE);
                // At this point parameterType
                // if Function<T=? super Stream.T, ? extends map.R>
                // we should replace Stream.T
                ResolvedType functionalInterfaceType = ReferenceTypeImpl.undeterminedParameters(functionalMethod.get().getDeclaration().declaringType(), typeSolver);
                lambdaCtx.addPair(result, functionalInterfaceType);
                ResolvedType actualType;
                if (lambdaExpr.getBody() instanceof ExpressionStmt) {
                    actualType = facade.getType(((ExpressionStmt) lambdaExpr.getBody()).getExpression());
                } else if (lambdaExpr.getBody() instanceof BlockStmt) {
                    BlockStmt blockStmt = (BlockStmt) lambdaExpr.getBody();
                    // Get all the return statements in the lambda block
                    List<ReturnStmt> returnStmts = blockStmt.findAll(ReturnStmt.class);
                    if (returnStmts.size() > 0) {
                        actualType = returnStmts.stream().map(returnStmt -> returnStmt.getExpression().map(e -> facade.getType(e)).orElse(ResolvedVoidType.INSTANCE)).filter(x -> x != null && !x.isVoid() && !x.isNull()).findFirst().orElse(ResolvedVoidType.INSTANCE);
                    } else {
                        return ResolvedVoidType.INSTANCE;
                    }
                } else {
                    throw new UnsupportedOperationException();
                }
                ResolvedType formalType = functionalMethod.get().returnType();
                // Infer the functional interfaces' return vs actual type
                funcInterfaceCtx.addPair(formalType, actualType);
                // Substitute to obtain a new type
                ResolvedType functionalTypeWithReturn = funcInterfaceCtx.resolve(funcInterfaceCtx.addSingle(functionalInterfaceType));
                // we don't need to bother inferring types
                if (!(formalType instanceof ResolvedVoidType)) {
                    lambdaCtx.addPair(result, functionalTypeWithReturn);
                    result = lambdaCtx.resolve(lambdaCtx.addSingle(result));
                }
            }
            return result;
        } else {
            return refMethod.getCorrespondingDeclaration().getParam(pos).getType();
        }
    } else {
        throw new UnsupportedOperationException("The type of a lambda expr depends on the position and its return value");
    }
}

Example 22 with ResolvedMethodDeclaration

use of com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration in project javaparser by javaparser.

the class ReflectionMethodResolutionLogic method solveMethodAsUsage.

static Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> argumentsTypes, TypeSolver typeSolver, Context invokationContext, List<ResolvedType> typeParameterValues, ResolvedReferenceTypeDeclaration scopeType, Class clazz) {
    if (typeParameterValues.size() != scopeType.getTypeParameters().size()) {
        // if it is zero we are going to ignore them
        if (!scopeType.getTypeParameters().isEmpty()) {
            // Parameters not specified, so default to Object
            typeParameterValues = new ArrayList<>();
            for (int i = 0; i < scopeType.getTypeParameters().size(); i++) {
                typeParameterValues.add(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver));
            }
        }
    }
    List<MethodUsage> methods = new ArrayList<>();
    for (Method method : clazz.getMethods()) {
        if (method.getName().equals(name) && !method.isBridge() && !method.isSynthetic()) {
            ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver);
            MethodUsage methodUsage = replaceParams(typeParameterValues, scopeType, methodDeclaration);
            methods.add(methodUsage);
        }
    }
    for (ResolvedReferenceType ancestor : scopeType.getAncestors()) {
        SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(ancestor.getTypeDeclaration(), name, argumentsTypes, typeSolver);
        if (ref.isSolved()) {
            ResolvedMethodDeclaration correspondingDeclaration = ref.getCorrespondingDeclaration();
            MethodUsage methodUsage = replaceParams(typeParameterValues, ancestor.getTypeDeclaration(), correspondingDeclaration);
            methods.add(methodUsage);
        }
    }
    if (scopeType.getAncestors().isEmpty()) {
        ReferenceTypeImpl objectClass = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
        SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(objectClass.getTypeDeclaration(), name, argumentsTypes, typeSolver);
        if (ref.isSolved()) {
            MethodUsage usage = replaceParams(typeParameterValues, objectClass.getTypeDeclaration(), ref.getCorrespondingDeclaration());
            methods.add(usage);
        }
    }
    final List<ResolvedType> finalTypeParameterValues = typeParameterValues;
    argumentsTypes = argumentsTypes.stream().map((pt) -> {
        int i = 0;
        for (ResolvedTypeParameterDeclaration tp : scopeType.getTypeParameters()) {
            pt = pt.replaceTypeVariables(tp, finalTypeParameterValues.get(i));
            i++;
        }
        return pt;
    }).collect(Collectors.toList());
    return MethodResolutionLogic.findMostApplicableUsage(methods, name, argumentsTypes, typeSolver);
}

Example 23 with ResolvedMethodDeclaration

use of com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration in project javaparser by javaparser.

the class ReferenceTypeImpl method getDeclaredMethods.

@Override
public Set<MethodUsage> getDeclaredMethods() {
    // TODO replace variables
    Set<MethodUsage> methods = new HashSet<>();
    for (ResolvedMethodDeclaration methodDeclaration : getTypeDeclaration().getDeclaredMethods()) {
        MethodUsage methodUsage = new MethodUsage(methodDeclaration);
        methods.add(methodUsage);
    }
    return methods;
}

Example 24 with ResolvedMethodDeclaration

use of com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration in project javaparser by javaparser.

the class AbstractTypeDeclaration method getAllMethods.

@Override
public final Set<MethodUsage> getAllMethods() {
    Set<MethodUsage> methods = new HashSet<>();
    Set<String> methodsSignatures = new HashSet<>();
    for (ResolvedMethodDeclaration methodDeclaration : getDeclaredMethods()) {
        methods.add(new MethodUsage(methodDeclaration));
        methodsSignatures.add(methodDeclaration.getSignature());
    }
    for (ResolvedReferenceType ancestor : getAllAncestors()) {
        for (MethodUsage mu : ancestor.getDeclaredMethods()) {
            String signature = mu.getDeclaration().getSignature();
            if (!methodsSignatures.contains(signature)) {
                methodsSignatures.add(signature);
                methods.add(mu);
            }
        }
    }
    return methods;
}

Example 25 with ResolvedMethodDeclaration

use of com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration in project javaparser by javaparser.

the class ClassOrInterfaceDeclarationContextResolutionTest method solveMethodWithMoreSpecializedParameter.

@Test
public void solveMethodWithMoreSpecializedParameter() {
    CompilationUnit cu = parseSample("ClassWithMethods");
    ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
    Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
    ResolvedType stringType = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
    SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo4", ImmutableList.of(stringType), false, new ReflectionTypeSolver());
    assertEquals(true, ref.isSolved());
    assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName());
    assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams());
}