@Override protected Iterable<? extends VariableTree> getChildNodes( MethodTree methodTree, VisitorState state) { return methodTree.getParameters(); } }
@Override public boolean matches(MethodTree methodTree, VisitorState state) { return methodTree.getParameters().size() == arity; } };
/** Returns arity (number of parameters) of given {@code methodTree}. */ static int getMethodTreeArity(MethodTree methodTree) { return methodTree.getParameters().size(); } }
@Override public boolean matches(MethodTree methodTree, VisitorState state) { if (methodTree.getParameters().size() != variableMatcher.size()) { return false; } int paramIndex = 0; for (Matcher<VariableTree> eachVariableMatcher : variableMatcher) { if (!eachVariableMatcher.matches(methodTree.getParameters().get(paramIndex++), state)) { return false; } } return true; } };
/** Returns a {@link ParameterTree} at {@code position} in the associated method. */ private ParameterTree getParameterTree(int position) { return ParameterTree.create(methodTree.getParameters().get(position)); } }
public static ImmutableMap<String, VarSymbol> freeExpressionVariables( MethodTree templateMethodDecl) { ImmutableMap.Builder<String, VarSymbol> builder = ImmutableMap.builder(); for (VariableTree param : templateMethodDecl.getParameters()) { builder.put(param.getName().toString(), ASTHelpers.getSymbol(param)); } return builder.build(); }
public static Parameter create(MethodTree methodTree, int position) { ParameterTree parameterTree = ParameterTree.create(methodTree.getParameters().get(position)); return new AutoValue_ParameterTrie_Parameter(parameterTree, position); } }
@Override public Description matchMethod(MethodTree tree, VisitorState state) { MethodSymbol symbol = getSymbol(tree); if (!symbol.isConstructor()) { return NO_MATCH; } paramTypesForMethod.put(symbol, unmodifiableList(tree.getParameters())); return evaluateCallers(symbol); }
@Override public Description matchMethod(MethodTree methodTree, VisitorState state) { DocTreePath path = Utils.getDocTreePath(state); if (path != null) { ImmutableSet<String> parameters = methodTree.getParameters().stream() .map(v -> v.getName().toString()) .collect(toImmutableSet()); new InvalidTagChecker(state, JavadocTag.VALID_METHOD_TAGS, parameters).scan(path, null); } return Description.NO_MATCH; }
@Override public Description matchMethod(MethodTree methodTree, VisitorState state) { DocTreePath path = Utils.getDocTreePath(state); if (path != null) { ImmutableSet<String> parameters = methodTree.getParameters().stream() .map(v -> v.getName().toString()) .collect(toImmutableSet()); new InvalidTagChecker(state, JavadocTag.VALID_METHOD_TAGS, parameters).scan(path, null); } return Description.NO_MATCH; }
@Override public Void visitMethod(MethodTree tree, Void unused) { if (getSymbol(tree).equals(methodSymbol)) { removeByIndex(tree.getParameters()); } return super.visitMethod(tree, null); }
@Override public Description matchMethod(MethodTree methodTree, VisitorState state) { DocTreePath path = getDocTreePath(state); if (path != null) { ImmutableSet<String> parameters = methodTree.getParameters().stream() .map(v -> v.getName().toString()) .collect(toImmutableSet()); ImmutableSet<String> typeParameters = methodTree.getTypeParameters().stream() .map(t -> t.getName().toString()) .collect(toImmutableSet()); new ParamsChecker(state, methodTree, parameters, typeParameters).scan(path, null); } return Description.NO_MATCH; }
private ImmutableList<Parameter> createParameterList(Tree tree) { if (tree instanceof MethodInvocationTree) { return Parameter.createListFromExpressionTrees( ((MethodInvocationTree) tree).getArguments()); } if (tree instanceof NewClassTree) { return Parameter.createListFromExpressionTrees(((NewClassTree) tree).getArguments()); } if (tree instanceof MethodTree) { return Parameter.createListFromVariableTrees(((MethodTree) tree).getParameters()); } return ImmutableList.of(); } }.scan(enclosingNode, null);
@Override public boolean matches(MethodTree method, VisitorState state) { List<? extends VariableTree> parameters = method.getParameters(); if (!parameters.isEmpty()) { return false; } BlockTree body = method.getBody(); if (body == null) { return false; } List<? extends StatementTree> statements = body.getStatements(); if (statements.size() != 1) { return false; } StatementTree onlyStatement = Iterables.getOnlyElement(statements); if (!onlyStatement.getKind().equals(RETURN)) { return false; } return EMPTY_SET.matches(((ReturnTree) onlyStatement).getExpression(), state); } };
@Override public boolean matches(MethodTree t, VisitorState state) { List<? extends VariableTree> parameters = t.getParameters(); if (parameters.size() != 1) { return false; } final VariableTree onlyParameter = Iterables.getOnlyElement(parameters); BlockTree body = t.getBody(); if (body == null) { return false; } List<? extends StatementTree> statements = body.getStatements(); if (statements.size() != 1) { return false; } StatementTree onlyStatement = Iterables.getOnlyElement(statements); if (!onlyStatement.getKind().equals(RETURN)) { return false; } Symbol returnedSymbol = getSymbol(((ReturnTree) onlyStatement).getExpression()); if (returnedSymbol == null) { return false; } return getSymbol(onlyParameter).equals(returnedSymbol); } };
@Override public Description matchMethod(MethodTree methodTree, VisitorState visitorState) { if (Matchers.equalsMethodDeclaration().matches(methodTree, visitorState)) { VariableTree variableTree = methodTree.getParameters().get(0); VarSymbol varSymbol = ASTHelpers.getSymbol(variableTree); TreeScannerEquals treeScannerEquals = new TreeScannerEquals(methodTree); treeScannerEquals.scan(methodTree.getBody(), varSymbol); if (treeScannerEquals.hasIllegalEquals) { return describeMatch(methodTree); } } return Description.NO_MATCH; }
@Override public Description matchMethod(MethodTree tree, VisitorState state) { if (tree.getBody() == null) { return NO_MATCH; } for (VariableTree parameter : tree.getParameters()) { VarSymbol sym = ASTHelpers.getSymbol(parameter); if (sym == null) { continue; } if (!CompileTimeConstantExpressionMatcher.hasCompileTimeConstantAnnotation(state, sym)) { continue; } if ((sym.flags() & FINAL) == FINAL || (sym.flags() & EFFECTIVELY_FINAL) == EFFECTIVELY_FINAL) { continue; } return describeMatch(parameter); } return NO_MATCH; } }
@Override @Nullable public Choice<Unifier> visitMethod(MethodTree decl, @Nullable Unifier unifier) { return getName() .unify(decl.getName(), unifier) .thenChoose(unifications(getReturnType(), decl.getReturnType())) .thenChoose(unifications(getParameters(), decl.getParameters())) .thenChoose(unifications(getThrows(), decl.getThrows())) .thenChoose(unifications(getBody(), decl.getBody())); }
@Override public UMethodDecl visitMethod(MethodTree decl, Void v) { return UMethodDecl.create( visitModifiers(decl.getModifiers(), null), decl.getName(), templateType(decl.getReturnType()), cast(templateStatements(decl.getParameters()), UVariableDecl.class), templateExpressions(decl.getThrows()), (UBlock) template(decl.getBody())); }
public Description describe(MethodTree tree, VisitorState state) { SuggestedFix.Builder builder = null; MethodSymbol method = ASTHelpers.getSymbol(tree); if (supermethod == null) { throw new IllegalStateException("Matching supermethod was not found"); } for (int x = 0; x < method.params().size(); x++) { Type methodParamType = method.params().get(x).type; Type supermethodParamType = supermethod.params().get(x).type; if (methodParamType.tsym.name.contentEquals(supermethodParamType.tsym.name) && !state.getTypes().isSameType(methodParamType, supermethodParamType)) { VariableTree param = tree.getParameters().get(x); // TODO(user): Name is most likely more qualified than necessary. Name replacement = supermethodParamType.tsym.getQualifiedName(); if (builder == null) { builder = SuggestedFix.builder(); } builder.replace(param, replacement + " " + param.getName()); } } return (builder != null) ? describeMatch(tree, builder.build()) : describeMatch(tree); } }