@Override public void visitClass(ClassTree tree) { scan(tree.modifiers()); scan(tree.simpleName()); scan(tree.typeParameters()); scan(tree.superClass()); scan(tree.superInterfaces()); scan(tree.members()); }
@Override public void visitClass(ClassTree tree) { //skip superclass and interfaces : visited in second pass. scan(tree.modifiers()); completeMetadata((JavaSymbol) tree.symbol(), tree.modifiers().annotations()); scan(tree.typeParameters()); scan(tree.members()); }
@Override public void visitClass(ClassTree tree) { if (tree.is(Tree.Kind.CLASS) && tree.simpleName() != null && !pattern.matcher(tree.simpleName().name()).matches()) { context.reportIssue(this, tree.simpleName(), "Rename this class name to match the regular expression '" + format + "'."); } super.visitClass(tree); }
private int computeClassFlags(ClassTree tree) { int flags = computeFlags(tree.modifiers(), tree); if (tree.is(Tree.Kind.INTERFACE)) { flags |= Flags.INTERFACE; }else if (tree.is(Tree.Kind.ENUM)) { flags |= Flags.ENUM; }else if (tree.is(Tree.Kind.ANNOTATION_TYPE)) { flags |= Flags.INTERFACE | Flags.ANNOTATION; } return flags; }
/** * Return the correct tree to report on for class trees. * @param classTree class tree raising an issue. * @return simple name of class tree or identifier in parent expression for anonymous class. */ public static Tree reportOnClassTree(ClassTree classTree) { Tree reportTree = classTree.simpleName(); if(reportTree == null) { reportTree = ((NewClassTree) classTree.parent()).identifier(); } return reportTree; }
@Override public void visitClass(ClassTree tree) { IdentifierTree simpleName = tree.simpleName(); if (simpleName != null) { createSymbol(simpleName, tree.symbol().usages()); } for (TypeParameterTree typeParameterTree : tree.typeParameters()) { createSymbol(typeParameterTree.identifier(), typeParameterTree); } super.visitClass(tree); }
private void handleClassTree(ClassTree tree) { tree.superInterfaces().stream() .filter(superInterface -> INTERFACES.stream().anyMatch(superInterface.symbolType()::is)) .forEach(this::reportIssue); TypeTree superClass = tree.superClass(); if (superClass != null && superClass.symbolType().is(GLOBAL_METHOD_SECURITY_CONFIGURATION)) { reportIssue(superClass); } checkAnnotations(tree.modifiers(), JSR_250_ANNOTATIONS); }
private void checkSuperType(ClassTree tree, @Nullable Type superType) { if (superType != null && superType.symbol().name().equals(tree.symbol().name())) { String classOrInterface = tree.is(Tree.Kind.CLASS) ? "class" : "interface"; reportIssue(tree.simpleName(), "Rename this " + classOrInterface + "."); } }
@Override public void visitNode(Tree tree) { ClassTree classTree = (ClassTree) tree; Symbol.TypeSymbol classSymbol = classTree.symbol(); if (isCloneable(classTree) && !classSymbol.isAbstract() && !declaresCloneMethod(classSymbol)) { reportIssue(classTree.simpleName(), "Add a \"clone()\" method to this class."); } }
@Override public void visitClass(ClassTree tree) { if (tree.is(Tree.Kind.CLASS) || tree.is(Tree.Kind.ENUM)) { for (Tree member : tree.members()) { if (member.is(Tree.Kind.VARIABLE) && isPublicStaticNotFinal((VariableTree) member)) { context.addIssue(member, this, "Make this \"public static " + ((VariableTree) member).simpleName() + "\" field final"); } } } super.visitClass(tree); }
@Override public void visitNode(Tree tree) { ClassTree classTree = (ClassTree) tree; findRequestMappingAnnotation(classTree.modifiers()) .flatMap(SpringRequestMappingMethodCheck::findRequestMethod) .filter(SpringRequestMappingMethodCheck::hasMoreThanOneValue) .ifPresent(assignment -> reportIssue(assignment.expression(), "Consider narrowing this list of methods to one.")); classTree.members().stream() .filter(member -> member.is(Tree.Kind.METHOD)) .forEach(member -> checkMethod((MethodTree) member, classTree.symbol())); }
private void checkExtensions(ClassTree tree) { if (tree.symbol().type().isSubtypeOf(JAVAX_NET_SOCKET_FACTORY) || (tree.symbol().type().isSubtypeOf("io.netty.channel.ChannelInitializer"))) { TypeTree superClass = tree.superClass(); if (superClass != null) { // Anonymous class creation will raise issue in `onConstructorFound` method reportIssue(superClass, MESSAGE); } } }
@Override public void visitClass(ClassTree tree) { TypeTree superClass = tree.superClass(); if (superClass != null) { reportIssueOnDeprecatedType(ExpressionsHelper.reportOnClassTree(tree), superClass.symbolType()); } scan(tree.members()); }
@Override public void visitClass(ClassTree tree) { TypeTree superClass = tree.superClass(); if (superClass != null && superClass.symbolType().erasure() == type) { isExtended = true; } super.visitClass(tree); }
@Override public void visitNode(Tree tree) { ClassTree classTree = (ClassTree) tree; if (!hasDeprecatedAnnotation(tree)) { checkSuperTypeDeprecation(classTree.superClass(), false); for (TypeTree superInterface : classTree.superInterfaces()) { checkSuperTypeDeprecation(superInterface, true); } } }
@Override public void visitClass(ClassTree tree) { List<TypeTree> interfaces = tree.superInterfaces(); for (TypeTree typeTree : interfaces) { LOGGER.info("implements Interface : " + typeTree); if ("MySecurityInterface".equals(typeTree.toString())) { implementsSpecificInterface = Boolean.TRUE; } } super.visitClass(tree); }
@Override public void visitNode(Tree tree) { if (tree.is(Tree.Kind.BLOCK, Tree.Kind.STATIC_INITIALIZER, Tree.Kind.INITIALIZER)) { BlockTree blockTree = (BlockTree) tree; checkBlockBody(blockTree.openBraceToken(), blockTree.closeBraceToken(), blockTree.body()); } else { ClassTree classTree = (ClassTree) tree; checkBlockBody(classTree.openBraceToken(), classTree.closeBraceToken(), classTree.members()); } }