private static boolean areSingleArgumentsSelfDocumenting(Tree tree) { // Consider single-argument booleans for classes whose names contain "Boolean" to be self- // documenting. This is aimed at classes like AtomicBoolean which simply wrap a value. if (tree instanceof NewClassTree) { return Ascii.toLowerCase(((NewClassTree) tree).getIdentifier().toString()) .contains("boolean"); } return true; } }
@Override public Void visitNewClass(NewClassTree tree, Void unused) { String classFullName = ""; if (tree.getIdentifier().getKind() == Kind.MEMBER_SELECT) { classFullName = ((JCFieldAccess) tree.getIdentifier()).sym.getQualifiedName().toString(); } else if (tree.getIdentifier().getKind() == Kind.IDENTIFIER) { classFullName = ((JCIdent) tree.getIdentifier()).sym.getQualifiedName().toString(); } if (SIDE_EFFECT_FREE_CLASSES.contains(classFullName)) { return null; } hasSideEffect = true; return null; }
private static SuggestedFix appendArgument( NewClassTree constructor, String exception, VisitorState state, List<Type> types) { if (types.isEmpty()) { // Skip past the opening '(' of the constructor. String source = state.getSourceForNode(constructor); int startPosition = ((JCTree) constructor).getStartPosition(); int pos = source.indexOf('(', state.getEndPosition(constructor.getIdentifier()) - startPosition) + startPosition + 1; return SuggestedFix.replace(pos, pos, exception); } return SuggestedFix.postfixWith( getLast(constructor.getArguments()), String.format(", %s", exception)); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { Symbol sym = ASTHelpers.getSymbol(tree.getIdentifier()); if (sym == null) { return NO_MATCH; } Types types = state.getTypes(); Symtab symtab = state.getSymtab(); // TODO(cushon): consider handling String also if (sym.equals(types.boxedClass(symtab.byteType)) || sym.equals(types.boxedClass(symtab.charType)) || sym.equals(types.boxedClass(symtab.shortType)) || sym.equals(types.boxedClass(symtab.intType)) || sym.equals(types.boxedClass(symtab.longType)) || sym.equals(types.boxedClass(symtab.doubleType)) || sym.equals(types.boxedClass(symtab.floatType)) || sym.equals(types.boxedClass(symtab.booleanType))) { return describeMatch(tree, buildFix(tree, state)); } return NO_MATCH; }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { // 1. Check any enclosing expression like a dereference JCExpression receiverTree = (JCExpression) tree.getEnclosingExpression(); if (receiverTree != null) { Description result = checkExpression( receiverTree, state, qual -> String.format( "Outer object %s for %s is %s null", receiverTree, tree.getIdentifier(), qual)); if (result != null) { return result; } } // 2. Check call arguments like a method call return checkCallArguments(tree.getArguments(), getSymbol(tree), state); }
@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); } }
if (immutableType.equals("ImmutableMap") && args.size() > 5) { String typeArguments = tree.getIdentifier() instanceof ParameterizedTypeTree ? ((ParameterizedTypeTree) tree.getIdentifier()) .getTypeArguments().stream() .map(state::getSourceForNode) state.getEndPosition(tree.getIdentifier()), state.getEndPosition(tree), "(" + replacement + ")");
@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 Description matchNewClass(NewClassTree tree, VisitorState state) { if (!CONSTRUCTOR_MATCHER.matches(tree, state)) { return Description.NO_MATCH; } ExpressionTree argument = getOnlyElement(tree.getArguments()); if (!ASTHelpers.isSameType( ASTHelpers.getType(argument), ASTHelpers.getType(tree.getIdentifier()), state)) { return Description.NO_MATCH; } return buildDescription(tree) .setMessage( String.format("Use of %s is a no-op and is not allowed.", ASTHelpers.getSymbol(tree))) .addFix(SuggestedFix.replace(tree, state.getSourceForNode(argument))) .build(); } }
@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)); }
.replace(newClassTree.getIdentifier(), "StringBuilder") .replace(varTree.getType(), "StringBuilder") .build());
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { if (ASTHelpers.isSameType( state.getSymtab().stringBuilderType, ASTHelpers.getType(tree.getIdentifier()), state) && tree.getArguments().size() == 1) { ExpressionTree argument = tree.getArguments().get(0); Type type = ((JCTree) argument).type; if (type.getKind() == TypeKind.CHAR) { if (argument.getKind() == Kind.CHAR_LITERAL) { char ch = (Character) ((LiteralTree) argument).getValue(); return describeMatch( tree, SuggestedFix.replace(argument, "\"" + Convert.quote(Character.toString(ch)) + "\"")); } else { return describeMatch( tree, SuggestedFix.replace( tree, "new StringBuilder().append(" + state.getSourceForNode((JCTree) argument) + ")")); } } } return Description.NO_MATCH; } }
@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)); }
if (!sideEffectFreeConstructor(((JCTree) newClassTree.getIdentifier()).type.tsym, state)) { return Description.NO_MATCH;
describeIfObsolete( tree.getClassBody() == null ? tree.getIdentifier() : null, owner.name.isEmpty() ? state.getTypes().directSupertypes(owner.asType())
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { // check instantiations of `@ImmutableTypeParameter`s in generic constructor invocations checkInvocation( tree, ((JCNewClass) tree).constructorType, state, ((JCNewClass) tree).constructor); // check instantiations of `@ImmutableTypeParameter`s in class constructor invocations ImmutableAnalysis analysis = createImmutableAnalysis(state); Violation info = analysis.checkInstantiation( ASTHelpers.getSymbol(tree.getIdentifier()).getTypeParameters(), ASTHelpers.getType(tree).getTypeArguments()); if (info.isPresent()) { state.reportMatch(buildDescription(tree).setMessage(info.message()).build()); } return NO_MATCH; }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { if (state.isAndroidCompatible()) { return NO_MATCH; } if (CTOR.matches(tree, state)) { Description.Builder description = buildDescription(tree); appendCharsets(description, tree, tree.getIdentifier(), tree.getArguments(), state); return description.build(); } if (FILE_READER.matches(tree, state)) { return handleFileReader(tree, state); } if (FILE_WRITER.matches(tree, state)) { return handleFileWriter(tree, state); } if (PRINT_WRITER.matches(tree, state)) { return handlePrintWriter(tree, state); } if (PRINT_WRITER_OUTPUTSTREAM.matches(tree, state)) { return handlePrintWriterOutputStream(tree, state); } if (SCANNER_MATCHER.matches(tree, state)) { return handleScanner(tree, state); } return NO_MATCH; }
String typeName = state.getSourceForNode(tree.getIdentifier()); DoubleAndFloatStatus doubleAndFloatStatus = doubleAndFloatStatus(state, type, argType); if (HASH_CODE.matches(parent, state)) {