@Override public void visit(SimpleName n, Void arg) { out.println("SimpleName: " + (extended ? n : n.getIdentifier())); super.visit(n, arg); }
private static Location getFieldLocation( SearchContext context, File targetFile, FieldDeclaration declaration) throws IOException { final List<VariableDeclarator> variables = declaration.getVariables(); for (final VariableDeclarator variable : variables) { final SimpleName simpleName = variable.getName(); final String name = simpleName.getIdentifier(); final Optional<Position> begin = simpleName.getBegin(); if (name.equals(context.name) && begin.isPresent()) { final Position position = begin.get(); return new Location(targetFile.getCanonicalPath(), position.line, position.column); } } return null; }
private void getParameterNames(MethodDeclaration methodDeclaration, boolean isInterface) { final EnumSet<Modifier> modifiers = methodDeclaration.getModifiers(); if (isInterface || modifiers.contains(Modifier.PUBLIC)) { String methodName = methodDeclaration.getName().getIdentifier(); List<Parameter> parameters = methodDeclaration.getParameters(); names.className = this.className; List<List<ParameterName>> parameterNames = names.names.computeIfAbsent(methodName, k -> new ArrayList<>(4)); final List<ParameterName> temp = new ArrayList<>(); for (final Parameter parameter : parameters) { ParameterName parameterName = new ParameterName(); String type = parameter.getType().toString(); String name = parameter.getName().getIdentifier(); if (name.contains("[]")) { type = type + "[]"; name = name.replace("[]", ""); } parameterName.type = type; parameterName.name = name; temp.add(parameterName); } parameterNames.add(temp); } } }
/** * 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 void process(Node node) { String label = ""; if (node instanceof SimpleName) label = ((SimpleName) node).getIdentifier(); else if (node instanceof StringLiteralExpr) label = ((StringLiteralExpr) node).asString(); else if (node instanceof BooleanLiteralExpr) label = Boolean.toString(((BooleanLiteralExpr) node).getValue()); else if (node instanceof LiteralStringValueExpr) label = ((LiteralStringValueExpr) node).getValue(); pushNode(node, label); }
public Member rename(String from, String to) { if (declaration instanceof MethodDeclaration) { ((MethodDeclaration) declaration).setName(to); } else if (declaration instanceof FieldDeclaration) { for (VariableDeclarator var : ((FieldDeclaration) declaration).getVariables()) { if (var.getName().getIdentifier().equals(from)) { var.setName(to); break; } } } return this; }
@Override protected String getTypeName(CompilationUnit compilationUnit, int index) { ClassOrInterfaceDeclaration type = (ClassOrInterfaceDeclaration) compilationUnit.getType(0); NodeList<ClassOrInterfaceType> extendedTypes = type.getExtendedTypes(); ClassOrInterfaceType extendedType = extendedTypes.get(index); String typeSimpleName = extendedType.getName().getIdentifier(); Optional<ClassOrInterfaceType> scope = extendedType.getScope(); String typeName; if (scope.isPresent()) { String typePackageName = scope.get().toString(); typeName = String.format("%s.%s", typePackageName, typeSimpleName); } else { typeName = typeSimpleName; } return typeName; }
@Test public void issue113providedCodeDoesNotCrash() throws FileNotFoundException { String pathToSourceFile = adaptPath("src/test/resources/issue113/com/foo/Widget.java"); CompilationUnit cu = JavaParser.parse(new File(pathToSourceFile)); JavaParserFacade parserFacade = JavaParserFacade.get(typeSolver); MethodDeclaration methodDeclaration = cu.getNodesByType(MethodDeclaration.class).stream() .filter(node -> node.getName().getIdentifier().equals("doSomething")).findAny().orElse(null); methodDeclaration.getNodesByType(MethodCallExpr.class).forEach(parserFacade::solve); }
/** * Return the string representation of the name */ public static String nameAsString(Node name) { if (!isAName(name)) { throw new IllegalArgumentException("A name was expected"); } if (name instanceof Name) { return ((Name) name).asString(); } else if (name instanceof SimpleName) { return ((SimpleName) name).getIdentifier(); } else if (name instanceof ClassOrInterfaceType) { return ((ClassOrInterfaceType) name).asString(); } else if (name instanceof FieldAccessExpr) { FieldAccessExpr fieldAccessExpr = (FieldAccessExpr) name; if (isAName(fieldAccessExpr.getScope())) { return nameAsString(fieldAccessExpr.getScope()) + "." + nameAsString(fieldAccessExpr.getName()); } else { throw new IllegalArgumentException(); } } else if (name instanceof NameExpr) { return ((NameExpr) name).getNameAsString(); } else { throw new UnsupportedOperationException("Unknown type of name found: " + name + " (" + name.getClass().getCanonicalName() + ")"); } }
@Override public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) { for (Expression expr : wrappedNode.getResources()) { if (expr instanceof VariableDeclarationExpr) { for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) { if (v.getName().getIdentifier().equals(name)) { JavaParserSymbolDeclaration decl = JavaParserSymbolDeclaration.localVar(v, typeSolver); return Optional.of(Value.from(decl)); } } } } if (getParentNode(wrappedNode) instanceof BlockStmt) { return StatementContext.solveInBlockAsValue(name, typeSolver, wrappedNode); } else { return getParent().solveSymbolAsValue(name, typeSolver); } }
@Override public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) { for (Expression expr : wrappedNode.getResources()) { if (expr instanceof VariableDeclarationExpr) { for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) { if (v.getName().getIdentifier().equals(name)) { JavaParserSymbolDeclaration decl = JavaParserSymbolDeclaration.localVar(v, typeSolver); return Optional.of(Value.from(decl)); } } } } if (getParentNode(wrappedNode) instanceof BlockStmt) { return StatementContext.solveInBlockAsValue(name, typeSolver, wrappedNode); } else { return getParent().solveSymbolAsValue(name, typeSolver); } }
@Override public Optional<Value> solveSymbolAsValue(String name) { for (Expression expr : wrappedNode.getResources()) { if (expr instanceof VariableDeclarationExpr) { for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) { if (v.getName().getIdentifier().equals(name)) { JavaParserSymbolDeclaration decl = JavaParserSymbolDeclaration.localVar(v, typeSolver); return Optional.of(Value.from(decl)); } } } } if (requireParentNode(wrappedNode) instanceof BlockStmt) { return StatementContext.solveInBlockAsValue(name, typeSolver, wrappedNode); } else { return getParent().solveSymbolAsValue(name); } }
final ClassOrInterfaceDeclaration classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) body; String name = classOrInterfaceDeclaration.getName().getIdentifier(); String key = this.pkg + '.' + name; name = this.originClassName + '.' + name;
@Override public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) { for (Expression expr : wrappedNode.getResources()) { if (expr instanceof VariableDeclarationExpr) { for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) { if (v.getName().getIdentifier().equals(name)) { return SymbolReference.solved(JavaParserSymbolDeclaration.localVar(v, typeSolver)); } } } } if (getParentNode(wrappedNode) instanceof BlockStmt) { return StatementContext.solveInBlock(name, typeSolver, wrappedNode); } else { return getParent().solveSymbol(name, typeSolver); } }
@Override public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) { for (Expression expr : wrappedNode.getResources()) { if (expr instanceof VariableDeclarationExpr) { for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) { if (v.getName().getIdentifier().equals(name)) { return SymbolReference.solved(JavaParserSymbolDeclaration.localVar(v, typeSolver)); } } } } if (requireParentNode(wrappedNode) instanceof BlockStmt) { return StatementContext.solveInBlock(name, typeSolver, wrappedNode); } else { return getParent().solveSymbol(name); } }
@Override public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) { for (Expression expr : wrappedNode.getResources()) { if (expr instanceof VariableDeclarationExpr) { for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) { if (v.getName().getIdentifier().equals(name)) { return SymbolReference.solved(JavaParserSymbolDeclaration.localVar(v, typeSolver)); } } } } if (getParentNode(wrappedNode) instanceof BlockStmt) { return StatementContext.solveInBlock(name, typeSolver, wrappedNode); } else { return getParent().solveSymbol(name, typeSolver); } }
/** * Check the expression for component method calls. This will check that the methods used in the * template exist in the Component. It throws an exception if we use a method that is not declared * in our Component. This will not check for the type or number of parameters, we leave that to * the Java Compiler. * * @param expression The expression to check */ private void checkMethodNames(Expression expression) { if (expression instanceof MethodCallExpr) { MethodCallExpr methodCall = ((MethodCallExpr) expression); if (!methodCall.getScope().isPresent()) { String methodName = methodCall.getName().getIdentifier(); if (!context.hasMethod(methodName) && !context.hasStaticMethod(methodName)) { logger.error("Couldn't find the method \"" + methodName + "\". " + "Make sure it is not private."); } } } for (com.github.javaparser.ast.Node node : expression.getChildNodes()) { if (!(node instanceof Expression)) { continue; } Expression childExpr = (Expression) node; checkMethodNames(childExpr); } }
&& this.wrappedNode.getTypes().stream().anyMatch(it -> it.getName().getIdentifier().equals(toSimpleName(importString)))) {
&& this.wrappedNode.getTypes().stream().anyMatch(it -> it.getName().getIdentifier().equals(toSimpleName(importString)))) {
&& this.wrappedNode.getTypes().stream().anyMatch(it -> it.getName().getIdentifier().equals(toSimpleName(importString)))) {