Examples with UnsolvedSymbolException com.github.javaparser.resolution.UnsolvedSymbolException used on opensource projects

Example 1 with UnsolvedSymbolException

use of com.github.javaparser.resolution.UnsolvedSymbolException in project javaparser by javaparser.

the class MethodCallExprContext method solveMethodAsUsage.

@Override
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> 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<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 {
                    throw new UnsolvedSymbolException(ref.getCorrespondingDeclaration().toString(), "Method '" + name + "' with parameterTypes " + argumentsTypes);
                }
            }
        }
        ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(scope);
        // we can replace the parameter types from the scope into the typeParametersValues
        Map<ResolvedTypeParameterDeclaration, ResolvedType> 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
            ResolvedType originalArgumentType = argumentsTypes.get(i);
            ResolvedType updatedArgumentType = usingParameterTypesFromScope(typeOfScope, originalArgumentType, inferredTypes);
            argumentsTypes.set(i, updatedArgumentType);
        }
        for (int i = 0; i < argumentsTypes.size(); i++) {
            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();
        }
        return parentContext.solveMethodAsUsage(name, argumentsTypes, typeSolver);
    }
}

Example 2 with UnsolvedSymbolException

use of com.github.javaparser.resolution.UnsolvedSymbolException in project javaparser by javaparser.

the class JavaParserFacade method convertToUsage.

protected ResolvedType convertToUsage(com.github.javaparser.ast.type.Type type, Context context) {
    if (context == null) {
        throw new NullPointerException("Context should not be null");
    }
    if (type instanceof ClassOrInterfaceType) {
        ClassOrInterfaceType classOrInterfaceType = (ClassOrInterfaceType) type;
        String name = qName(classOrInterfaceType);
        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType(name, typeSolver);
        if (!ref.isSolved()) {
            throw new UnsolvedSymbolException(name);
        }
        ResolvedTypeDeclaration typeDeclaration = ref.getCorrespondingDeclaration();
        List<ResolvedType> typeParameters = Collections.emptyList();
        if (classOrInterfaceType.getTypeArguments().isPresent()) {
            typeParameters = classOrInterfaceType.getTypeArguments().get().stream().map((pt) -> convertToUsage(pt, context)).collect(Collectors.toList());
        }
        if (typeDeclaration.isTypeParameter()) {
            if (typeDeclaration instanceof ResolvedTypeParameterDeclaration) {
                return new ResolvedTypeVariable((ResolvedTypeParameterDeclaration) typeDeclaration);
            } else {
                JavaParserTypeVariableDeclaration javaParserTypeVariableDeclaration = (JavaParserTypeVariableDeclaration) typeDeclaration;
                return new ResolvedTypeVariable(javaParserTypeVariableDeclaration.asTypeParameter());
            }
        } else {
            return new ReferenceTypeImpl((ResolvedReferenceTypeDeclaration) typeDeclaration, typeParameters, typeSolver);
        }
    } else if (type instanceof com.github.javaparser.ast.type.PrimitiveType) {
        return ResolvedPrimitiveType.byName(((com.github.javaparser.ast.type.PrimitiveType) type).getType().name());
    } else if (type instanceof WildcardType) {
        WildcardType wildcardType = (WildcardType) type;
        if (wildcardType.getExtendedType().isPresent() && !wildcardType.getSuperType().isPresent()) {
            // removed (ReferenceTypeImpl)
            return ResolvedWildcard.extendsBound(convertToUsage(wildcardType.getExtendedType().get(), context));
        } else if (!wildcardType.getExtendedType().isPresent() && wildcardType.getSuperType().isPresent()) {
            // removed (ReferenceTypeImpl)
            return ResolvedWildcard.superBound(convertToUsage(wildcardType.getSuperType().get(), context));
        } else if (!wildcardType.getExtendedType().isPresent() && !wildcardType.getSuperType().isPresent()) {
            return ResolvedWildcard.UNBOUNDED;
        } else {
            throw new UnsupportedOperationException(wildcardType.toString());
        }
    } else if (type instanceof com.github.javaparser.ast.type.VoidType) {
        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 ResolvedArrayType(convertToUsage(jpArrayType.getComponentType(), context));
    } else if (type instanceof UnionType) {
        UnionType unionType = (UnionType) type;
        return new ResolvedUnionType(unionType.getElements().stream().map(el -> convertToUsage(el, context)).collect(Collectors.toList()));
    } else if (type instanceof VarType) {
        Node parent = type.getParentNode().get();
        if (!(parent instanceof VariableDeclarator)) {
            throw new IllegalStateException("Trying to resolve a `var` which is not in a variable declaration.");
        }
        final VariableDeclarator variableDeclarator = (VariableDeclarator) parent;
        return variableDeclarator.getInitializer().map(Expression::calculateResolvedType).orElseThrow(() -> new IllegalStateException("Cannot resolve `var` which has no initializer."));
    } else {
        throw new UnsupportedOperationException(type.getClass().getCanonicalName());
    }
}

Example 3 with UnsolvedSymbolException

use of com.github.javaparser.resolution.UnsolvedSymbolException in project javaparser by javaparser.

the class JavaParserEnumDeclaration method getAncestors.

@Override
public List<ResolvedReferenceType> getAncestors() {
    List<ResolvedReferenceType> 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<ResolvedTypeDeclaration> implementedDeclRef = new SymbolSolver(typeSolver).solveTypeInType(this, implementedType.getName().getId());
            if (!implementedDeclRef.isSolved()) {
                throw new UnsolvedSymbolException(implementedType.getName().getId());
            }
            ancestors.add(new ReferenceTypeImpl((ResolvedReferenceTypeDeclaration) implementedDeclRef.getCorrespondingDeclaration(), typeSolver));
        }
    }
    return ancestors;
}

Example 4 with UnsolvedSymbolException

use of com.github.javaparser.resolution.UnsolvedSymbolException in project javaparser by javaparser.

the class JavassistUtils method signatureTypeToType.

static ResolvedType signatureTypeToType(SignatureAttribute.Type signatureType, TypeSolver typeSolver, ResolvedTypeParametrizable typeParametrizable) {
    if (signatureType instanceof SignatureAttribute.ClassType) {
        SignatureAttribute.ClassType classType = (SignatureAttribute.ClassType) signatureType;
        List<ResolvedType> typeArguments = classType.getTypeArguments() == null ? Collections.emptyList() : Arrays.stream(classType.getTypeArguments()).map(ta -> typeArgumentToType(ta, typeSolver, typeParametrizable)).collect(Collectors.toList());
        final String typeName = classType.getDeclaringClass() != null ? classType.getDeclaringClass().getName() + "." + classType.getName() : classType.getName();
        ResolvedReferenceTypeDeclaration typeDeclaration = typeSolver.solveType(removeTypeArguments(internalNameToCanonicalName(typeName)));
        return new ReferenceTypeImpl(typeDeclaration, typeArguments, typeSolver);
    } else if (signatureType instanceof SignatureAttribute.TypeVariable) {
        SignatureAttribute.TypeVariable typeVariableSignature = (SignatureAttribute.TypeVariable) signatureType;
        Optional<ResolvedTypeParameterDeclaration> typeParameterDeclarationOpt = typeParametrizable.findTypeParameter(typeVariableSignature.getName());
        if (!typeParameterDeclarationOpt.isPresent()) {
            throw new UnsolvedSymbolException("Unable to solve TypeVariable " + typeVariableSignature);
        }
        ResolvedTypeParameterDeclaration typeParameterDeclaration = typeParameterDeclarationOpt.get();
        return new ResolvedTypeVariable(typeParameterDeclaration);
    } else if (signatureType instanceof SignatureAttribute.ArrayType) {
        SignatureAttribute.ArrayType arrayType = (SignatureAttribute.ArrayType) signatureType;
        return new ResolvedArrayType(signatureTypeToType(arrayType.getComponentType(), typeSolver, typeParametrizable));
    } else if (signatureType instanceof SignatureAttribute.BaseType) {
        SignatureAttribute.BaseType baseType = (SignatureAttribute.BaseType) signatureType;
        if (baseType.toString().equals("void")) {
            return ResolvedVoidType.INSTANCE;
        } else {
            return ResolvedPrimitiveType.byName(baseType.toString());
        }
    } else {
        throw new RuntimeException(signatureType.getClass().getCanonicalName());
    }
}