@Override public List<? extends ExpressionTree> visitNewClass(NewClassTree node, Void unused) { return node.getArguments(); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { handleArguments(tree, tree.getArguments(), state); return NO_MATCH; }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { checkArguments(tree, tree.getArguments(), state); return NO_MATCH; }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { Symbol.MethodSymbol sym = ASTHelpers.getSymbol(tree); if (sym == null) { return Description.NO_MATCH; } return matchArguments(state, sym, tree.getArguments().iterator()); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { if (!PATTERN_CTOR_MATCHER.matches(tree, state)) { return Description.NO_MATCH; } return constructDescription(tree, tree.getArguments().get(0), state); }
static InvocationInfo createFromNewClass( NewClassTree tree, MethodSymbol symbol, VisitorState state) { return new AutoValue_InvocationInfo( tree, symbol, ImmutableList.copyOf(tree.getArguments()), getFormalParametersWithoutVarArgs(symbol), state); }
@Override public Type visitNewClass(NewClassTree tree, Void unused) { return visitMethodInvocationOrNewClass( tree.getArguments(), ASTHelpers.getSymbol(tree), ((JCNewClass) tree).constructorType); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { return matchInvocation(tree, ASTHelpers.getSymbol(tree), tree.getArguments(), state); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { if (!BIGDECIMAL_DOUBLE_CONSTRUCTOR.matches(tree, state)) { return Description.NO_MATCH; } ExpressionTree arg = getOnlyElement(tree.getArguments()); if (!FLOATING_POINT_ARGUMENT.matches(arg, state)) { return Description.NO_MATCH; } return createDescription(arg, state); }
@Override public Boolean visitThrow(ThrowTree tree, Void unused) { if (Objects.equals(parameter, ASTHelpers.getSymbol(tree.getExpression()))) { return true; } if (NEW_THROWABLE.matches(tree.getExpression(), state) && ((NewClassTree) tree.getExpression()) .getArguments().stream() .anyMatch( arg -> Objects.equals(parameter, ASTHelpers.getSymbol(arg)))) { return true; } return super.visitThrow(tree, null); }
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);
private Description handleFileReader(NewClassTree tree, VisitorState state) { Tree arg = getOnlyElement(tree.getArguments()); Tree parent = state.getPath().getParentPath().getLeaf(); Tree toReplace = BUFFERED_READER.matches(parent, state) ? parent : tree; Description.Builder description = buildDescription(tree); fileReaderFix(description, state, arg, toReplace); return description.build(); }
private Description handlePrintWriter(NewClassTree tree, VisitorState state) { Description.Builder description = buildDescription(tree); for (CharsetFix charsetFix : CharsetFix.values()) { SuggestedFix.Builder fix = SuggestedFix.builder() .postfixWith( getOnlyElement(tree.getArguments()), String.format(", %s.name()", charsetFix.replacement())); charsetFix.addImport(fix, state); description.addFix(fix.build()); } return description.build(); }
private Description handleScanner(NewClassTree tree, VisitorState state) { Description.Builder description = buildDescription(tree); for (CharsetFix charsetFix : CharsetFix.values()) { SuggestedFix.Builder fix = SuggestedFix.builder() .postfixWith( getOnlyElement(tree.getArguments()), String.format(", %s.name()", charsetFix.replacement())); charsetFix.addImport(fix, state); description.addFix(fix.build()); } return description.build(); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { if (!MATCHER.matches(tree, state)) { return Description.NO_MATCH; } ExpressionTree millisArg = Iterables.getOnlyElement(tree.getArguments()); SuggestedFix fix = SuggestedFix.replace( ((JCTree) tree).getStartPosition(), ((JCTree) millisArg).getStartPosition(), state.getSourceForNode(tree.getIdentifier()) + ".millis("); return describeMatch(tree, fix); } }
@Override public Void visitNewClass(NewClassTree tree, HeldLockSet locks) { scan(tree.getEnclosingExpression(), locks); scan(tree.getIdentifier(), locks); scan(tree.getTypeArguments(), locks); scan(tree.getArguments(), locks); // Don't descend into bodies of anonymous class declarations; // their method declarations will be analyzed separately. return null; }
@Override public Boolean visitNewClass(NewClassTree node, Void unused) { Boolean r = scan(node.getEnclosingExpression(), null); r = scanAndReduce(node.getIdentifier(), r); r = scanAndReduce(node.getTypeArguments(), r); r = scanAndReduce(node.getArguments(), r); // don't descend into class body, if it exists return r; }
@Override public Choice<State<JCNewClass>> visitNewClass(final NewClassTree node, State<?> state) { if (node.getEnclosingExpression() != null || (node.getTypeArguments() != null && !node.getTypeArguments().isEmpty()) || node.getClassBody() != null) { return Choice.none(); } return chooseSubtrees( state, s -> unifyExpression(node.getIdentifier(), s), s -> unifyExpressions(node.getArguments(), s), (ident, args) -> maker().NewClass(null, null, ident, args, null)); }
@Override @Nullable public Choice<Unifier> visitNewClass(NewClassTree newClass, @Nullable Unifier unifier) { return unifyNullable(unifier, getEnclosingExpression(), newClass.getEnclosingExpression()) .thenChoose(unifications(getTypeArguments(), newClass.getTypeArguments())) .thenChoose(unifications(getIdentifier(), newClass.getIdentifier())) .thenChoose(unifications(getClassBody(), newClass.getClassBody())) .thenChoose(unifications(getArguments(), newClass.getArguments())); }
@Override public UNewClass visitNewClass(NewClassTree tree, Void v) { return UNewClass.create( tree.getEnclosingExpression() == null ? null : template(tree.getEnclosingExpression()), templateTypeExpressions(tree.getTypeArguments()), template(tree.getIdentifier()), templateExpressions(tree.getArguments()), (tree.getClassBody() == null) ? null : visitClass(tree.getClassBody(), null)); }