@Override public void visitNewClass(NewClassTree tree) { scan(tree.enclosingExpression()); scan(tree.identifier()); scan(tree.typeArguments()); scan(tree.arguments()); scan(tree.classBody()); }
@Override public void visitNode(Tree tree) { NewClassTree newClassTree = (NewClassTree) tree; if (newClassTree.symbolType().is("javax.crypto.NullCipher")) { reportIssue(newClassTree.identifier(), "Remove this use of the \"NullCipher\" class."); } }
@Override protected void onConstructorFound(NewClassTree newClassTree) { checkCall(newClassTree, newClassTree.constructorSymbol(), newClassTree.arguments()); }
@Override public void visitNewClass(NewClassTree tree) { if (tree.classBody() != null && !isEnumConstantBody) { int lines = getNumberOfLines(tree.classBody()); if (lines > max) { context.reportIssue(this, tree.newKeyword(), tree.identifier(), "Reduce this anonymous class number of lines from " + lines + " to at most " + max + ", or make it a named class."); } } isEnumConstantBody = false; super.visitNewClass(tree); }
@Override public void visitNewClass(NewClassTree tree) { super.visitNewClass(tree); if (tree.classBody() != null) { List<Tree> members = tree.classBody().members(); if (!useThisIdentifier(tree.classBody()) && !enumConstants.contains(tree.identifier()) && members.size() == 1 && members.get(0).is(Tree.Kind.METHOD)) { context.addIssue(tree.identifier(), this, "Make this anonymous inner class a lambda"); } } }
private void checkIfUnknown(NewClassTree nct) { if (nct.constructorSymbol().isUnknown()) { unresolvedMethodNames.add(constructorName(nct.identifier())); } }
private static Symbol.TypeSymbol wrapperClassSymbol(NewClassTree newClassTree) { Symbol.TypeSymbol classSymbol = newClassTree.symbolType().symbol(); if (PRIMITIVE_TYPES_BY_WRAPPER.containsKey(newClassTree.symbolType().fullyQualifiedName()) && !newClassTree.arguments().isEmpty()) { return classSymbol; } return null; }
private void buildNewClass(NewClassTree tree) { handleExceptionalPaths(tree.constructorSymbol()); currentBlock.elements.add(tree); build(tree.arguments()); ExpressionTree enclosingExpression = tree.enclosingExpression(); if (enclosingExpression != null) { build(enclosingExpression); } }
private static void handleNewClass(Set<Symbol> out, Symbol.MethodSymbol methodSymbol, NewClassTree element) { ClassTree body = element.classBody(); if (body != null) { out.addAll(getUsedLocalVarInSubTree(body, methodSymbol)); } }
private void categorizeBasedOnConstructor(NewClassTree newClassTree, VariableSymbol variableSymbol) { if (isIgnoredCookieName(newClassTree.arguments())) { ignoredVariables.add(variableSymbol); } else if (isCompliantConstructorCall(newClassTree)) { compliantConstructorInitializations.add(variableSymbol); } else { variablesToReport.add(variableSymbol); } }
@Override public void visitNewClass(NewClassTree tree) { if (tree.classBody() != null && tree.symbolType().isSubtypeOf(type)) { isExtended = true; } super.visitNewClass(tree); } }
private Symbol.TypeSymbol wrapperClassSymbol(NewClassTree newClassTree) { Symbol.TypeSymbol classSymbol = newClassTree.symbolType().symbol(); if (PRIMITIVE_TYPES_BY_WRAPPER.containsKey(newClassTree.symbolType().fullyQualifiedName())) { return classSymbol; } return null; }
public static String getclassName(NewClassTree newClasstree) { if (newClasstree.identifier().is(Tree.Kind.MEMBER_SELECT)) { return ((MemberSelectExpressionTree) newClasstree.identifier()).identifier().name(); } else if (newClasstree.identifier().is(Tree.Kind.IDENTIFIER)) { return ((IdentifierTree) newClasstree.identifier()).name(); } return null; }
private void buildNewClass(NewClassTree tree) { currentBlock.elements.add(tree); ExpressionTree enclosingExpression = tree.enclosingExpression(); if (enclosingExpression != null) { build(enclosingExpression); } build(Lists.reverse(tree.arguments())); }
private void computeExecutableLines(List<? extends Tree> trees) { if(trees.isEmpty()) { return; } // rely on cfg to get every instructions and get most of the token. CFG cfg = CFG.buildCFG(trees); cfg.blocks() .stream() .flatMap(b->b.elements().stream()) .forEach( t -> { if (t.is(NEW_CLASS)) { NewClassTree newClassTree = (NewClassTree) t; new ExecutableLinesTokenVisitor().scanTree(newClassTree.identifier()); executableLines.add(newClassTree.newKeyword().line()); } else if (t.is(TRY_STATEMENT)) { // add last token of try statements executableLines.add(t.lastToken().line()); } else { executableLines.add(t.firstToken().line()); } } ); }
@Override public void visitNewClass(NewClassTree newClassTree) { String newClassTypeName = newClassTree.identifier().symbolType().fullyQualifiedName(); Tree parent = newClassTree.parent(); if (parent != null && !parent.is(Tree.Kind.VARIABLE)) { checkIfDisallowed(newClassTypeName, newClassTree); } super.visitNewClass(newClassTree ); }
@Override public void visitNewClass(NewClassTree tree) { checkIfThrowThrowable(tree.constructorSymbol()); super.visitNewClass(tree); }
@Override public void visitNode(Tree tree) { if (!hasSemantic()) { return; } NewClassTree newClassTree = (NewClassTree) tree; if (newClassTree.symbolType().isSubtypeOf("java.lang.Throwable") && newClassTree.parent().is(Tree.Kind.EXPRESSION_STATEMENT)) { reportIssue(newClassTree, "Throw this exception or remove this useless statement"); } } }
@Override public void visitClass(ClassTree tree) { if (!isBodyOfEnumConstantTree(tree)) { Type superClass = tree.symbol().superClass(); int dit = 0; while (superClass != null) { String fullyQualifiedName = superClass.fullyQualifiedName(); if (getPatterns().stream().anyMatch(wp -> wp.match(fullyQualifiedName))) { break; } dit++; superClass = superClass.symbol().superClass(); } if (dit > max) { Tree reportTree = tree.simpleName(); if (tree.parent().is(Tree.Kind.NEW_CLASS)) { reportTree = ((NewClassTree) tree.parent()).newKeyword(); } context.reportIssue(this, reportTree, "This class has " + dit + " parents which is greater than " + max + " authorized.", new ArrayList<>(), dit - max); } } super.visitClass(tree); }