private int pos(MethodCallExpr callExpr, Expression param) { int i = 0; for (Expression p : callExpr.getArguments()) { if (p == param) { return i; } i++; } throw new IllegalArgumentException(); } }
private int pos(MethodCallExpr callExpr, Expression param) { int i = 0; for (Expression p : callExpr.getArguments()) { if (p == param) { return i; } i++; } throw new IllegalArgumentException(); } }
private int pos(MethodCallExpr callExpr, Expression param) { int i = 0; for (Expression p : callExpr.getArguments()) { if (p == param) { return i; } i++; } throw new IllegalArgumentException(); } }
public static int getParamPos(Node node) { if (getParentNode(node) instanceof MethodCallExpr) { MethodCallExpr call = (MethodCallExpr) getParentNode(node); for (int i = 0; i < call.getArguments().size(); i++) { if (call.getArguments().get(i) == node) return i; } throw new IllegalStateException(); } else { throw new IllegalArgumentException(); } }
public static int getParamPos(Node node) { if (getParentNode(node) instanceof MethodCallExpr) { MethodCallExpr call = (MethodCallExpr) getParentNode(node); for (int i = 0; i < call.getArguments().size(); i++) { if (call.getArguments().get(i) == node) return i; } throw new IllegalStateException(); } else { throw new IllegalArgumentException(); } }
public static int getParamPos(Node node) { if (requireParentNode(node) instanceof MethodCallExpr) { MethodCallExpr call = (MethodCallExpr) requireParentNode(node); for (int i = 0; i < call.getArguments().size(); i++) { if (call.getArguments().get(i) == node) return i; } throw new IllegalStateException(); } throw new IllegalArgumentException(); }
public MethodUsage solveMethodAsUsage(MethodCallExpr call) { List<ResolvedType> params = new ArrayList<>(); if (call.getArguments() != null) { for (Expression param : call.getArguments()) { //getTypeConcrete(Node node, boolean solveLambdas) try { params.add(getType(param, false)); } catch (Exception e) { throw new RuntimeException(String.format("Error calculating the type of parameter %s of method call %s", param, call), e); } //params.add(getTypeConcrete(param, false)); } } Context context = JavaParserFactory.getContext(call, typeSolver); Optional<MethodUsage> methodUsage = context.solveMethodAsUsage(call.getName().getId(), params); if (!methodUsage.isPresent()) { throw new RuntimeException("Method '" + call.getName() + "' cannot be resolved in context " + call + " (line: " + call.getRange().map(r -> "" + r.begin.line).orElse("??") + ") " + context + ". Parameter types: " + params); } return methodUsage.get(); }
public MethodUsage solveMethodAsUsage(MethodCallExpr call) { List<ResolvedType> params = new ArrayList<>(); if (call.getArguments() != null) { for (Expression param : call.getArguments()) { //getTypeConcrete(Node node, boolean solveLambdas) try { params.add(getType(param, false)); } catch (Exception e) { throw new RuntimeException(String.format("Error calculating the type of parameter %s of method call %s", param, call), e); } //params.add(getTypeConcrete(param, false)); } } Context context = JavaParserFactory.getContext(call, typeSolver); Optional<MethodUsage> methodUsage = context.solveMethodAsUsage(call.getName().getId(), params, typeSolver); if (!methodUsage.isPresent()) { throw new RuntimeException("Method '" + call.getName() + "' cannot be resolved in context " + call + " (line: " + call.getRange().get().begin.line + ") " + context + ". Parameter types: " + params); } return methodUsage.get(); }
public MethodUsage solveMethodAsUsage(MethodCallExpr call) { List<ResolvedType> params = new ArrayList<>(); if (call.getArguments() != null) { for (Expression param : call.getArguments()) { //getTypeConcrete(Node node, boolean solveLambdas) try { params.add(getType(param, false)); } catch (Exception e) { throw new RuntimeException(String.format("Error calculating the type of parameter %s of method call %s", param, call), e); } //params.add(getTypeConcrete(param, false)); } } Context context = JavaParserFactory.getContext(call, typeSolver); Optional<MethodUsage> methodUsage = context.solveMethodAsUsage(call.getName().getId(), params, typeSolver); if (!methodUsage.isPresent()) { throw new RuntimeException("Method '" + call.getName() + "' cannot be resolved in context " + call + " (line: " + call.getRange().get().begin.line + ") " + context + ". Parameter types: " + params); } return methodUsage.get(); }
/** * Given a method call find out to which method declaration it corresponds. */ public SymbolReference<ResolvedMethodDeclaration> solve(MethodCallExpr methodCallExpr, boolean solveLambdas) { List<ResolvedType> argumentTypes = new LinkedList<>(); List<LambdaArgumentTypePlaceholder> placeholders = new LinkedList<>(); solveArguments(methodCallExpr, methodCallExpr.getArguments(), solveLambdas, argumentTypes, placeholders); SymbolReference<ResolvedMethodDeclaration> res = JavaParserFactory.getContext(methodCallExpr, typeSolver).solveMethod(methodCallExpr.getName().getId(), argumentTypes, false, typeSolver); for (LambdaArgumentTypePlaceholder placeholder : placeholders) { placeholder.setMethod(res); } return res; }
/** * Given a method call find out to which method declaration it corresponds. */ public SymbolReference<ResolvedMethodDeclaration> solve(MethodCallExpr methodCallExpr, boolean solveLambdas) { List<ResolvedType> argumentTypes = new LinkedList<>(); List<LambdaArgumentTypePlaceholder> placeholders = new LinkedList<>(); solveArguments(methodCallExpr, methodCallExpr.getArguments(), solveLambdas, argumentTypes, placeholders); SymbolReference<ResolvedMethodDeclaration> res = JavaParserFactory.getContext(methodCallExpr, typeSolver).solveMethod(methodCallExpr.getName().getId(), argumentTypes, false, typeSolver); for (LambdaArgumentTypePlaceholder placeholder : placeholders) { placeholder.setMethod(res); } return res; }
/** * Given a method call find out to which method declaration it corresponds. */ public SymbolReference<ResolvedMethodDeclaration> solve(MethodCallExpr methodCallExpr, boolean solveLambdas) { List<ResolvedType> argumentTypes = new LinkedList<>(); List<LambdaArgumentTypePlaceholder> placeholders = new LinkedList<>(); solveArguments(methodCallExpr, methodCallExpr.getArguments(), solveLambdas, argumentTypes, placeholders); SymbolReference<ResolvedMethodDeclaration> res = JavaParserFactory.getContext(methodCallExpr, typeSolver).solveMethod(methodCallExpr.getName().getId(), argumentTypes, false); for (LambdaArgumentTypePlaceholder placeholder : placeholders) { placeholder.setMethod(res); } return res; }
return false; int nActualParams = methodCallExpr.getArguments().size(); int nFormalParams = methodDeclaration.getNumberOfParams(); if (nActualParams != nFormalParams) {
@Override public final Context getParent() { if (getParentNode(wrappedNode) instanceof MethodCallExpr) { MethodCallExpr parentCall = (MethodCallExpr) getParentNode(wrappedNode); boolean found = false; if (parentCall.getArguments() != null) { for (Expression expression : parentCall.getArguments()) { if (expression == wrappedNode) { found = true; } } } if (found) { Node notMethod = getParentNode(wrappedNode); while (notMethod instanceof MethodCallExpr) { notMethod = getParentNode(notMethod); } return JavaParserFactory.getContext(notMethod, typeSolver); } } Node notMethod = getParentNode(wrappedNode); while (notMethod instanceof MethodCallExpr || notMethod instanceof FieldAccessExpr) { notMethod = getParentNode(notMethod); } if (notMethod == null) { return null; } return JavaParserFactory.getContext(notMethod, typeSolver); }
@Override public final Context getParent() { if (getParentNode(wrappedNode) instanceof MethodCallExpr) { MethodCallExpr parentCall = (MethodCallExpr) getParentNode(wrappedNode); boolean found = false; if (parentCall.getArguments() != null) { for (Expression expression : parentCall.getArguments()) { if (expression == wrappedNode) { found = true; } } } if (found) { Node notMethod = getParentNode(wrappedNode); while (notMethod instanceof MethodCallExpr) { notMethod = getParentNode(notMethod); } return JavaParserFactory.getContext(notMethod, typeSolver); } } Node notMethod = getParentNode(wrappedNode); while (notMethod instanceof MethodCallExpr || notMethod instanceof FieldAccessExpr) { notMethod = getParentNode(notMethod); } if (notMethod == null) { return null; } return JavaParserFactory.getContext(notMethod, typeSolver); }
@Test public void solveParameterOfLambdaInMethodCallExpr() throws ParseException { CompilationUnit cu = parseSample("Lambda"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda"); MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap"); ReturnStmt returnStmt = Navigator.findReturnStmt(method); MethodCallExpr methodCallExpr = (MethodCallExpr) returnStmt.getExpression().get(); LambdaExpr lambdaExpr = (LambdaExpr) methodCallExpr.getArguments().get(0); Context context = new LambdaExprContext(lambdaExpr, typeSolver); Optional<Value> ref = context.solveSymbolAsValue("p", typeSolver); assertTrue(ref.isPresent()); assertEquals("? super java.lang.String", ref.get().getType().describe()); }
@Test public void lambdaMapParameter() throws ParseException { CompilationUnit cu = parseSample("Lambda"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda"); MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap"); ReturnStmt returnStmt = Navigator.findReturnStmt(method); MethodCallExpr methodCallExpr = (MethodCallExpr) returnStmt.getExpression().get(); Expression expression = methodCallExpr.getArguments().get(0); JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver()); ResolvedType type = javaParserFacade.getType(expression); assertEquals("java.util.function.Function<? super java.lang.String, ? extends java.lang.String>", type.describe()); }
@Test public void lambdaCollectParam() throws ParseException { CompilationUnit cu = parseSample("LambdaCollect"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda"); MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap"); ReturnStmt returnStmt = Navigator.findReturnStmt(method); MethodCallExpr methodCallExpr = (MethodCallExpr) returnStmt.getExpression().get(); // Collectors.toList() Expression expression = methodCallExpr.getArguments().get(0); JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver()); ResolvedType type = javaParserFacade.getType(expression); assertEquals("java.util.stream.Collector<T, ? extends java.lang.Object, java.util.List<T>>", type.describe()); }
@Test public void genericsInheritance() throws ParseException { CompilationUnit cu = parseSample("MethodTypeParams"); ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "VoidVisitorAdapter"); MethodDeclaration method = Navigator.demandMethod(clazz, "visit"); MethodCallExpr call = Navigator.findMethodCall(method, "accept"); Expression thisRef = call.getArguments().get(0); TypeSolver typeSolver = new ReflectionTypeSolver(); JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver); ResolvedType voidVisitorAdapterOfA = javaParserFacade.getType(thisRef); List<ResolvedReferenceType> allAncestors = voidVisitorAdapterOfA.asReferenceType().getAllAncestors(); assertEquals(2, allAncestors.size()); }
@Test public void resolveLambdaType() 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 callToFilter = Navigator.findMethodCall(method, "filter"); Expression lambdaExpr = callToFilter.getArguments().get(0); String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar"); TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar)); ResolvedType typeOfLambdaExpr = JavaParserFacade.get(typeSolver).getType(lambdaExpr); assertEquals("java.util.function.Predicate<? super com.github.javaparser.ast.body.TypeDeclaration>", typeOfLambdaExpr.describe()); }