@Override public void visit(MethodCallExpr n, Void arg) { out.println("MethodCallExpr: " + (extended ? n : n.getNameAsString() + " " + n.getScope())); super.visit(n, arg); }
@Override public Optional<ResolvedType> solveGenericType(String name) { if(wrappedNode.getScope().isPresent()){ ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope().get()); Optional<ResolvedType> res = typeOfScope.asReferenceType().getGenericParameterByName(name); return res; } else{ return Optional.empty(); } }
@Override public Optional<ResolvedType> solveGenericType(String name, TypeSolver typeSolver) { if(wrappedNode.getScope().isPresent()){ ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope().get()); Optional<ResolvedType> res = typeOfScope.asReferenceType().getGenericParameterByName(name); return res; } else{ return Optional.empty(); } }
private static boolean isScopeOfAMethodCall(@Nonnull Expression expression) { return MethodCallExpr.class.isInstance(expression.getParentNode()) && expression == MethodCallExpr.class.cast(expression.getParentNode()).getScope(); }
@Override public Optional<ResolvedType> solveGenericType(String name, TypeSolver typeSolver) { if(wrappedNode.getScope().isPresent()){ ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope().get()); Optional<ResolvedType> res = typeOfScope.asReferenceType().getGenericParameterByName(name); return res; } else{ return Optional.empty(); } }
private Map<String, Object> doc(final MethodCallExpr expr, final Context ctx) { if (expr.getScope() == null) { return doc(expr.getParentNode(), ctx); } else { List<Expression> args = expr.getArgs(); if (args.size() > 0) { return doc(args.get(0), ctx); } } return null; }
private static boolean isSyntacticallyAAmbiguousName(Node name) { // A name is syntactically classified as an AmbiguousName in these contexts: // // 1. To the left of the "." in a qualified ExpressionName if (whenParentIs(FieldAccessExpr.class, name, (p, c) -> p.getScope() == c)) { return true; } // 2. To the left of the rightmost . that occurs before the "(" in a method invocation expression if (whenParentIs(MethodCallExpr.class, name, (p, c) -> p.getScope().isPresent() && p.getScope().get() == c)) { return true; } // 3. To the left of the "." in a qualified AmbiguousName // // 4. In the default value clause of an annotation type element declaration (§9.6.2) // // 5. To the right of an "=" in an an element-value pair (§9.7.1) if (whenParentIs(MemberValuePair.class, name, (p, c) -> p.getValue() == c)) { return true; } // 6. To the left of :: in a method reference expression (§15.13) return false; }
/** * Resolve static method calls using static imports * * @param expression The expression to resolve */ private void resolveStaticMethodsUsingImports(Expression expression) { if (expression instanceof MethodCallExpr) { MethodCallExpr methodCall = ((MethodCallExpr) expression); String methodName = methodCall.getName().getIdentifier(); if (!methodCall.getScope().isPresent() && context.hasStaticMethod(methodName)) { methodCall.setName(context.getFullyQualifiedNameForMethodName(methodName)); } } // Recurse downward in the expression expression .getChildNodes() .stream() .filter(Expression.class::isInstance) .map(Expression.class::cast) .forEach(this::resolveStaticMethodsUsingImports); }
@Override public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly, TypeSolver typeSolver) { Collection<ResolvedReferenceTypeDeclaration> rrtds = findTypeDeclarations(wrappedNode.getScope(), typeSolver); for (ResolvedReferenceTypeDeclaration rrtd : rrtds) { SymbolReference<ResolvedMethodDeclaration> res = MethodResolutionLogic.solveMethodInType(rrtd, name, argumentsTypes, false, typeSolver); if (res.isSolved()) { return res; } } return SymbolReference.unsolved(ResolvedMethodDeclaration.class); }
@Override public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) { Collection<ResolvedReferenceTypeDeclaration> rrtds = findTypeDeclarations(wrappedNode.getScope()); for (ResolvedReferenceTypeDeclaration rrtd : rrtds) { SymbolReference<ResolvedMethodDeclaration> res = MethodResolutionLogic.solveMethodInType(rrtd, name, argumentsTypes, false); if (res.isSolved()) { return res; } } return SymbolReference.unsolved(ResolvedMethodDeclaration.class); }
public void visit(final MethodCallExpr n, final RoutingDefineContext arg) { if (n.getName().equals("define") && n.getScope().equals(ASTHelper.createNameExpr("Routes"))) { arg.setInRoutingDefine(true); super.visit(n, arg); arg.setInRoutingDefine(false); } else { super.visit(n, arg); } }
@Override public boolean doIsEquals(MethodCallExpr first, MethodCallExpr second) { if(!isEqualsUseMerger(first.getNameExpr(),second.getNameExpr())) return false; if(!isEqualsUseMerger(first.getTypeArgs(),second.getTypeArgs())) return false; if(!isEqualsUseMerger(first.getScope(),second.getScope())) return false; if(!isEqualsUseMerger(first.getArgs(),second.getArgs())) return false; return true; } }
@Override public MethodCallExpr doMerge(MethodCallExpr first, MethodCallExpr second) { MethodCallExpr mce = new MethodCallExpr(); mce.setNameExpr(mergeSingle(first.getNameExpr(),second.getNameExpr())); mce.setArgs(mergeCollectionsInOrder(first.getArgs(),second.getArgs())); mce.setScope(mergeSingle(first.getScope(),second.getScope())); mce.setTypeArgs(mergeCollectionsInOrder(first.getTypeArgs(),second.getTypeArgs())); return mce; }
@Test public void solveTryWithResourceVariable() { String code = "import java.util.Scanner; class A { void foo() { try (Scanner sc = new Scanner(System.in)) {\n" + " sc.nextLine();\n" + "} } }"; CompilationUnit cu = JavaParser.parse(code); MethodCallExpr methodCallExpr = Navigator.findMethodCall(cu, "nextLine"); Expression scope = methodCallExpr.getScope().get(); ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(scope); assertEquals(true, type.isReferenceType()); assertEquals("java.util.Scanner", type.asReferenceType().getQualifiedName()); }
@Test public void classCastScope() throws ParseException { CompilationUnit cu = parseSample("ClassCast"); ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ClassCast"); MethodDeclaration method = Navigator.demandMethod(clazz, "getNodesByType"); MethodCallExpr call = Navigator.findMethodCall(method, "cast"); TypeSolver typeSolver = new ReflectionTypeSolver(); Expression scope = call.getScope().get(); ResolvedType type = JavaParserFacade.get(typeSolver).getType(scope); //System.out.println(typeUsage); assertEquals(false, type.isTypeVariable()); assertEquals("java.lang.Class<N>", type.describe()); }
@Test public void resolveReferenceToLambdaParam() throws ParseException, IOException { CompilationUnit cu = parseSample("Navigator"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator"); MethodDeclaration method = Navigator.demandMethod(clazz, "findType"); MethodCallExpr callToGetName = Navigator.findMethodCall(method, "getName"); Expression referenceToT = callToGetName.getScope().get(); String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar"); TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar)); ResolvedType typeOfT = JavaParserFacade.get(typeSolver).getType(referenceToT); assertEquals("? super com.github.javaparser.ast.body.TypeDeclaration", typeOfT.describe()); }
@Test public void resolveLocalAndSeveralAnnidatedLevels() throws ParseException { CompilationUnit cu = parseSample("LocalVariableInParent"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "LocalVariableInParent"); MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo4"); MethodCallExpr call = Navigator.findMethodCall(method, "add"); TypeSolver typeSolver = new ReflectionTypeSolver(); SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(typeSolver).solve(call.getScope().get()); assertTrue(ref.isSolved()); assertEquals("java.util.List<Comment>", ref.getCorrespondingDeclaration().getType().describe()); MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call); assertEquals("add", methodUsage.getName()); }
@Test public void resolveMethodOnGenericClass() throws ParseException { CompilationUnit cu = parseSample("LocalVariableInParent"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "LocalVariableInParent"); MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo5"); MethodCallExpr call = Navigator.findMethodCall(method, "add"); TypeSolver typeSolver = new ReflectionTypeSolver(); SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(typeSolver).solve(call.getScope().get()); assertTrue(ref.isSolved()); assertEquals("java.util.List<Comment>", ref.getCorrespondingDeclaration().getType().describe()); MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call); assertEquals("add", methodUsage.getName()); }