private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
@Override public int getNumberOfParams() { return wrappedNode.getParameters().size(); }
@Override public int getNumberOfParams() { return wrappedNode.getParameters().size(); }
@Override public int getNumberOfParams() { return wrappedNode.getParameters().size(); }
@Override public List<Parameter> parametersExposedToChild(Node child) { if (wrappedNode.getBody().isPresent() && child == wrappedNode.getBody().get()) { return wrappedNode.getParameters(); } return Collections.emptyList(); } }
private Method findMethod(MethodDeclaration n) { Class<?> currentVisitedClass = getCurrentVisitedClass(); for (Method method : currentVisitedClass.getDeclaredMethods()) { if (method.getName().equals(n.getNameAsString()) && argsMatch(method.getParameterTypes(), n.getParameters())) { return method; } } return null; }
private Method findMethod(MethodDeclaration n) { Class<?> currentVisitedClass = getCurrentVisitedClass(); for (Method method : currentVisitedClass.getDeclaredMethods()) { if (method.getName().equals(n.getNameAsString()) && argsMatch(method.getParameterTypes(), n.getParameters())) { return method; } } return null; }
@Override public Void visit(MethodDeclaration n, Map<AccessibleObject, String[]> arg) { Method m = findMethod(n); String[] paramNames = extractParameterNames(n.getParameters()); arg.put(m, paramNames); return super.visit(n, arg); }
@Override public Void visit(MethodDeclaration n, Map<AccessibleObject, String[]> arg) { Method m = findMethod(n); String[] paramNames = extractParameterNames(n.getParameters()); arg.put(m, paramNames); return super.visit(n, arg); }
@Override public ResolvedParameterDeclaration getParam(int i) { if (i < 0 || i >= getNumberOfParams()) { throw new IllegalArgumentException(String.format("No param with index %d. Number of params: %d", i, getNumberOfParams())); } return new JavaParserParameterDeclaration(wrappedNode.getParameters().get(i), typeSolver); }
@Override public ResolvedParameterDeclaration getParam(int i) { if (i < 0 || i >= getNumberOfParams()) { throw new IllegalArgumentException(String.format("No param with index %d. Number of params: %d", i, getNumberOfParams())); } return new JavaParserParameterDeclaration(wrappedNode.getParameters().get(i), typeSolver); }
@Override public ResolvedParameterDeclaration getParam(int i) { if (i < 0 || i >= getNumberOfParams()) { throw new IllegalArgumentException(String.format("No param with index %d. Number of params: %d", i, getNumberOfParams())); } return new JavaParserParameterDeclaration(wrappedNode.getParameters().get(i), typeSolver); }
@Override public boolean doIsEquals(MethodDeclaration first, MethodDeclaration second) { if (!StringUtils.equals(first.getName(), second.getName())) return false; if (!isParametersEquals(first.getParameters(), second.getParameters())) return false; if (!isTypeParameterEquals(first.getTypeParameters(), second.getTypeParameters())) return false; return true; } }
/** * <b>Note:</b> This will not return the actual identifier but only the simple names of the types (return type & parameter types). * Doing a full type resolving with all imports adds too much complexity at this point. * This is a best-effort approach. */ private MethodIdentifier calculateMethodIdentifier(MethodDeclaration method) { String[] parameters = method.getParameters().stream() .map(p -> p.getType().asString()) .map(p -> p.replace('.', '/')) .toArray(String[]::new); String returnType = method.getType().asString().replace('.', '/'); if (method.isStatic()) { return ofStatic(className, method.getNameAsString(), returnType, parameters); } return ofNonStatic(className, method.getNameAsString(), returnType, parameters); }
private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
public void index(MethodDeclaration methodDeclaration, int typeId) { List<Parameter> parameters = methodDeclaration.getParameters(); String name = methodDeclaration.getNameAsString(); int methodId = methodDao.save(new Method(name, methodDeclaration.isPublic(), methodDeclaration.isStatic(), methodDeclaration.isFinal(), methodDeclaration.isAbstract(), false, typeId)); for (Parameter parameter : parameters) { parameterIndexer.index(parameter, methodId); } }
private void addStepToRegistry(Expression expression, MethodDeclaration methodDeclaration, SingleMemberAnnotationExpr annotation) { String parameterizedStep = expression.toString().replaceAll("\"", ""); String stepText = getStepText(parameterizedStep); stepValue = new StepValue(stepText, parameterizedStep); entry = new StepRegistryEntry(); entry.setName(methodDeclaration.getDeclarationAsString()); entry.setStepText(parameterizedStep); entry.setStepValue(stepValue); entry.setParameters(methodDeclaration.getParameters()); entry.setSpan(methodDeclaration.getRange()); entry.setHasAlias(hasAlias(annotation)); entry.setAliases(getAliases(annotation)); entry.setFileName(file); stepRegistry.addStep(stepValue, entry); }
@Test public void resolveReferenceToJreType() throws ParseException, IOException { CompilationUnit cu = parseSample("NavigatorSimplified"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator"); MethodDeclaration method = Navigator.demandMethod(clazz, "foo"); com.github.javaparser.ast.type.Type streamJavaParserType = method.getParameters().get(0).getType(); TypeSolver typeSolver = new ReflectionTypeSolver(); ResolvedType streamType = JavaParserFacade.get(typeSolver).convert(streamJavaParserType, method); assertEquals("java.util.stream.Stream<java.lang.String>", streamType.describe()); }
@Test public void arrayTypeIsNotPartOfTheTree() throws ParseException { CompilationUnit cu = parseSample("Issue116"); ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "JavaTest"); MethodDeclaration methodDeclaration = Navigator.demandMethod(clazz, "foo"); TypeSolver typeSolver = new ReflectionTypeSolver(); JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver); com.github.javaparser.ast.type.Type typeNode = methodDeclaration.getParameters().get(0).getType(); ResolvedType type = javaParserFacade.convert(typeNode, typeNode); assertEquals("java.lang.String[]", type.describe()); ExpressionStmt expressionStmt = (ExpressionStmt) methodDeclaration.getBody().get().getStatements().get(0); Expression argRef = expressionStmt.getExpression(); assertEquals("java.lang.String[]", javaParserFacade.getType(argRef).describe()); } }