597 lines
30 KiB
Java
597 lines
30 KiB
Java
import com.puppycrawl.tools.checkstyle.*;
|
|
import com.puppycrawl.tools.checkstyle.api.*;
|
|
import java.io.*;
|
|
import java.nio.file.*;
|
|
import java.util.*;
|
|
import net.sourceforge.pmd.*;
|
|
import net.sourceforge.pmd.cpd.*;
|
|
import net.sourceforge.pmd.lang.*;
|
|
import net.sourceforge.pmd.lang.ast.*;
|
|
import net.sourceforge.pmd.lang.java.ast.*;
|
|
import net.sourceforge.pmd.lang.java.rule.AbstractJavaRule;
|
|
import net.sourceforge.pmd.lang.java.symbols.*;
|
|
import net.sourceforge.pmd.lang.java.types.*;
|
|
import net.sourceforge.pmd.lang.metrics.MetricOptions;
|
|
import net.sourceforge.pmd.lang.rule.RuleSet;
|
|
|
|
/** Deliberately independent of the application build and its annotation processors. */
|
|
public class Standards {
|
|
static final List<String> findings = new ArrayList<>();
|
|
static final Map<Path, Set<Integer>> codeLines = new HashMap<>();
|
|
static final Set<String> ownedTypes = new HashSet<>();
|
|
static final Map<String, ASTTypeDeclaration> types = new HashMap<>();
|
|
static final List<ASTCompilationUnit> units = new ArrayList<>();
|
|
static Path root;
|
|
static String module;
|
|
|
|
record Waiver(String metric, String executable, double value, String reason) {}
|
|
|
|
static final List<Waiver> waivers = new ArrayList<>();
|
|
|
|
/**
|
|
* Checks configured backend sources and writes standards reports without changing maintained code.
|
|
*
|
|
* @param args the consumer repository root as the sole argument
|
|
* @throws Exception if configuration, resolution or parsing fails, or a blocking violation is found
|
|
*/
|
|
public static void main(final String... args) throws Exception {
|
|
findings.clear();
|
|
codeLines.clear();
|
|
types.clear();
|
|
units.clear();
|
|
ownedTypes.clear();
|
|
root = Path.of(args[0]).toAbsolutePath().normalize();
|
|
final var settings = new Properties();
|
|
try (var input = Files.newInputStream(root.resolve("engineering.properties"))) {
|
|
settings.load(input);
|
|
}
|
|
module = settings.getProperty("BACKEND_MODULE");
|
|
if (module == null || module.isBlank()) throw new IllegalArgumentException("BACKEND_MODULE is required");
|
|
waivers.clear();
|
|
final Path waiverFile = root.resolve("tooling/standards/waivers.tsv");
|
|
if (Files.exists(waiverFile))
|
|
for (String line : Files.readAllLines(waiverFile)) {
|
|
if (line.isBlank() || line.startsWith("#")) continue;
|
|
final String[] fields = line.split("\t", -1);
|
|
if (fields.length != 4 || fields[0].contains("*") || fields[1].contains("*") || fields[3].isBlank())
|
|
throw new IllegalArgumentException("Invalid exact waiver in " + waiverFile + ": " + line);
|
|
waivers.add(new Waiver(fields[0], fields[1], Double.parseDouble(fields[2]), fields[3]));
|
|
}
|
|
final Path output = root.resolve(module + "/target/standards");
|
|
Files.createDirectories(output);
|
|
final List<Path> files = new ArrayList<>();
|
|
for (String scope : List.of("main", "test")) {
|
|
try (var paths = Files.walk(root.resolve(module + "/src/" + scope + "/java"))) {
|
|
paths.filter(p -> p.toString().endsWith(".java")).sorted().forEach(files::add);
|
|
}
|
|
}
|
|
for (Path file : files) {
|
|
final var matcher =
|
|
java.util.regex.Pattern.compile("package\\s+([\\w.]+)\\s*;").matcher(Files.readString(file));
|
|
if (matcher.find())
|
|
ownedTypes.add(
|
|
matcher.group(1) + "." + file.getFileName().toString().replace(".java", ""));
|
|
}
|
|
checkstyle(files);
|
|
final PMDConfiguration config = new PMDConfiguration();
|
|
config.setDefaultLanguageVersion(
|
|
LanguageRegistry.PMD.getLanguageById("java").getVersion("25"));
|
|
config.setThreads(1);
|
|
config.prependAuxClasspath(
|
|
Path.of(System.getProperty("java.home"), "lib/jrt-fs.jar").toString());
|
|
config.setIgnoreIncrementalAnalysis(true);
|
|
// Compiled application/test dependencies permit PMD to resolve external types.
|
|
final Path cp = root.resolve(module + "/target/standards-classpath.txt");
|
|
if (Files.exists(cp))
|
|
config.prependAuxClasspath(
|
|
Files.readString(cp) + File.pathSeparator + root.resolve(module + "/target/classes"));
|
|
try (var analysis = PmdAnalysis.create(config)) {
|
|
analysis.addRuleSet(RuleSet.forSingleRule(new Measurements()));
|
|
for (String rule : List.of(
|
|
"category/java/codestyle.xml/LocalVariableCouldBeFinal",
|
|
"category/java/codestyle.xml/MethodArgumentCouldBeFinal",
|
|
"category/java/design.xml/ImmutableField"))
|
|
analysis.addRuleSet(analysis.newRuleSetLoader().loadFromResource(rule));
|
|
for (Path file : files) analysis.files().addFile(file);
|
|
final var report = analysis.performAnalysisAndCollectReport();
|
|
for (var error : report.getProcessingErrors())
|
|
findings.add("BLOCK parser " + error.getFileId() + " " + error.getMsg());
|
|
for (var violation : report.getViolations())
|
|
findings.add("BLOCK " + violation.getFileId() + ":" + violation.getBeginLine() + " "
|
|
+ violation.getRule().getName() + " " + violation.getDescription());
|
|
for (var violation : report.getSuppressedViolations())
|
|
findings.add("BLOCK Unapproved suppression: " + violation);
|
|
for (var error : report.getConfigurationErrors()) findings.add("BLOCK configuration " + error);
|
|
}
|
|
duplication(files);
|
|
Collections.sort(findings);
|
|
Files.write(output.resolve("report.txt"), findings);
|
|
findings.stream().filter(f -> !f.startsWith("METRIC ")).forEach(System.out::println);
|
|
System.out.println(
|
|
"Backend standards: " + files.size() + " source files; full metrics: " + output.resolve("report.txt"));
|
|
if (findings.stream().anyMatch(s -> s.startsWith("BLOCK")))
|
|
throw new IllegalStateException("Backend standards failed; see " + output.resolve("report.txt"));
|
|
}
|
|
|
|
static void checkstyle(List<Path> files) throws Exception {
|
|
final Checker checker = new Checker();
|
|
checker.setModuleClassLoader(Standards.class.getClassLoader());
|
|
checker.configure(ConfigurationLoader.loadConfiguration(
|
|
root.resolve("generated/tooling/standards/checkstyle.xml").toString(),
|
|
new PropertiesExpander(new Properties())));
|
|
checker.addListener(new AuditListener() {
|
|
public void auditStarted(AuditEvent e) {}
|
|
|
|
public void auditFinished(AuditEvent e) {}
|
|
|
|
public void fileStarted(AuditEvent e) {}
|
|
|
|
public void fileFinished(AuditEvent e) {}
|
|
|
|
public void addError(AuditEvent e) {
|
|
findings.add("BLOCK " + e.getFileName() + ":" + e.getLine() + " " + e.getMessage());
|
|
}
|
|
|
|
public void addException(AuditEvent e, Throwable t) {
|
|
findings.add("BLOCK " + e.getFileName() + " parser: " + t);
|
|
}
|
|
});
|
|
try {
|
|
checker.process(files.stream().map(Path::toFile).toList());
|
|
} finally {
|
|
checker.destroy();
|
|
}
|
|
}
|
|
|
|
public static class Measurements extends AbstractJavaRule {
|
|
public Measurements() {
|
|
setName("BackendMeasurements");
|
|
setMessage("Backend standards");
|
|
setLanguage(LanguageRegistry.PMD.getLanguageById("java"));
|
|
}
|
|
|
|
@Override
|
|
public Object visit(ASTCompilationUnit unit, Object data) {
|
|
units.add(unit);
|
|
for (var type : all(unit, ASTTypeDeclaration.class))
|
|
types.put(type.getSymbol().getBinaryName(), type);
|
|
final Set<Integer> lines = lines(unit);
|
|
codeLines.put(path(unit), lines);
|
|
for (var node : all(unit, JavaNode.class)) {
|
|
if (node instanceof ASTExecutableDeclaration executable) executable(executable);
|
|
if (node instanceof ASTCompactConstructorDeclaration compact) {
|
|
final var cyclo = new org.apache.commons.lang3.mutable.MutableInt(1);
|
|
compact.acceptVisitor(new ScopedCyclo(compact), cyclo);
|
|
final var cognitive =
|
|
new net.sourceforge.pmd.lang.java.metrics.internal.CognitiveComplexityVisitor.State(
|
|
compact);
|
|
compact.acceptVisitor(new ScopedCognitive(), cognitive);
|
|
metric(compact, "cyclomatic", cyclo.intValue(), 7, 10);
|
|
metric(compact, "cognitive", cognitive.getComplexity(), 10, 15);
|
|
metric(compact, "executableLines", lines(compact).size(), 30, 50);
|
|
metric(compact, "nesting", nesting(compact.getBody(), 0), 3, 4);
|
|
metric(
|
|
compact,
|
|
"parameters",
|
|
compact.getEnclosingType().getRecordComponents().size(),
|
|
5,
|
|
7);
|
|
visibility(compact);
|
|
}
|
|
if (node instanceof ASTVariableId variable) variable(variable);
|
|
if (node instanceof ASTTypeDeclaration nested
|
|
&& nested.isNested()
|
|
&& !nested.isLocal()
|
|
&& !nested.isAnonymous()) visibility(nested);
|
|
if (node instanceof ASTImportDeclaration imp && imp.isStatic() && production(unit))
|
|
block(imp, "Static imports are test-only");
|
|
if (node instanceof ASTExecutableDeclaration || node instanceof ASTFieldDeclaration)
|
|
visibility((ModifierOwner) node);
|
|
if (node instanceof ASTMethodDeclaration method
|
|
&& method.isOverride()
|
|
&& !method.isAnnotationPresent("java.lang.Override"))
|
|
block(method, "Overriding methods require @Override");
|
|
}
|
|
for (var type : all(unit, ASTTypeDeclaration.class)) typeMetrics(type);
|
|
return data;
|
|
}
|
|
}
|
|
|
|
static Path path(Node node) {
|
|
return Path.of(node.getTextDocument().getFileId().getAbsolutePath())
|
|
.toAbsolutePath()
|
|
.normalize();
|
|
}
|
|
|
|
static boolean production(Node node) {
|
|
return path(node).startsWith(root.resolve(module + "/src/main/java"));
|
|
}
|
|
|
|
static <T> List<T> all(Node node, Class<T> clazz) {
|
|
final List<T> result = new ArrayList<>();
|
|
if (clazz.isInstance(node)) result.add(clazz.cast(node));
|
|
for (int i = 0; i < node.getNumChildren(); i++) result.addAll(all(node.getChild(i), clazz));
|
|
return result;
|
|
}
|
|
|
|
static void block(Node node, String message) {
|
|
findings.add("BLOCK " + location(node) + " " + message);
|
|
}
|
|
|
|
static String location(Node node) {
|
|
return root.relativize(path(node)) + ":" + node.getBeginLine();
|
|
}
|
|
|
|
static void metric(Node node, String name, double value, double review, double limit) {
|
|
if (value > limit)
|
|
for (Waiver waiver : waivers) {
|
|
if (waiver.metric().equals(name)
|
|
&& waiver.executable().equals(identity(node))
|
|
&& waiver.value() == value) {
|
|
findings.add("WAIVER " + location(node) + " " + name + "=" + value + " " + waiver.reason());
|
|
return;
|
|
}
|
|
}
|
|
findings.add((value > limit ? "BLOCK " : value > review ? "REVIEW " : "METRIC ") + location(node) + " " + name
|
|
+ "=" + value);
|
|
}
|
|
|
|
static String identity(Node node) {
|
|
if (node instanceof ASTCompactConstructorDeclaration compact) {
|
|
final List<String> parameters = new ArrayList<>();
|
|
for (var component : compact.getEnclosingType().getRecordComponents())
|
|
parameters.add(component.getTypeMirror().toString());
|
|
return compact.getEnclosingType().getBinaryName() + "#<init>(" + String.join(",", parameters) + ")";
|
|
}
|
|
if (node instanceof ASTExecutableDeclaration executable) {
|
|
final List<String> parameters = new ArrayList<>();
|
|
for (var parameter : executable.getFormalParameters())
|
|
parameters.add(parameter.getTypeMirror().toString());
|
|
return executable.getEnclosingType().getBinaryName() + "#"
|
|
+ (executable instanceof ASTConstructorDeclaration ? "<init>" : executable.getName())
|
|
+ "(" + String.join(",", parameters) + ")";
|
|
}
|
|
return node instanceof ASTTypeDeclaration type ? type.getBinaryName() : location(node);
|
|
}
|
|
|
|
static Set<Integer> lines(JavaNode node) {
|
|
final Set<Integer> result = new HashSet<>();
|
|
var token = node.getFirstToken();
|
|
while (token != null && !token.isEof()) {
|
|
final var loc = token.getReportLocation();
|
|
for (int line = loc.getStartLine(); line <= loc.getEndLine(); line++) result.add(line);
|
|
if (token == node.getLastToken()) break;
|
|
token = token.getNext();
|
|
}
|
|
final String[] sourceLines = node.getTextDocument().getText().toString().split("\\R", -1);
|
|
result.removeIf(line -> line > sourceLines.length || sourceLines[line - 1].isBlank());
|
|
return result;
|
|
}
|
|
|
|
static void executable(ASTExecutableDeclaration method) {
|
|
{
|
|
metric(
|
|
method,
|
|
"parameters",
|
|
method.getArity(),
|
|
method instanceof ASTMethodDeclaration ? 4 : 5,
|
|
method instanceof ASTMethodDeclaration ? 5 : 7);
|
|
}
|
|
if (method.getBody() == null) return;
|
|
metric(method, "cyclomatic", cyclomatic(method), 7, 10);
|
|
metric(method, "cognitive", cognitive(method), 10, 15);
|
|
metric(method, "executableLines", lines(method).size(), 30, 50);
|
|
metric(method, "nesting", nesting(method.getBody(), 0), 3, 4);
|
|
}
|
|
|
|
static final class ScopedCyclo extends net.sourceforge.pmd.lang.java.metrics.internal.CycloVisitor {
|
|
ScopedCyclo(JavaNode node) {
|
|
super(MetricOptions.emptyOptions(), node);
|
|
}
|
|
|
|
@Override
|
|
public Void visit(ASTLambdaExpression lambda, org.apache.commons.lang3.mutable.MutableInt value) {
|
|
for (int i = 0; i < lambda.getNumChildren(); i++) lambda.getChild(i).acceptVisitor(this, value);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static final class ScopedCognitive
|
|
extends net.sourceforge.pmd.lang.java.metrics.internal.CognitiveComplexityVisitor {
|
|
@Override
|
|
public Void visit(ASTClassBody body, State state) {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public Void visitJavaNode(JavaNode node, State state) {
|
|
return node instanceof ASTTypeDeclaration || node instanceof ASTTypeBody
|
|
? null
|
|
: super.visitJavaNode(node, state);
|
|
}
|
|
}
|
|
|
|
static int cyclomatic(ASTExecutableDeclaration method) {
|
|
final var value = new org.apache.commons.lang3.mutable.MutableInt();
|
|
method.acceptVisitor(new ScopedCyclo(method), value);
|
|
return value.intValue();
|
|
}
|
|
|
|
static int cognitive(ASTExecutableDeclaration method) {
|
|
final var state = new net.sourceforge.pmd.lang.java.metrics.internal.CognitiveComplexityVisitor.State(method);
|
|
method.acceptVisitor(new ScopedCognitive(), state);
|
|
return state.getComplexity();
|
|
}
|
|
|
|
static int nesting(Node node, int depth) {
|
|
if (node instanceof ASTTypeDeclaration) return depth;
|
|
final String kind = node.getXPathNodeName();
|
|
final boolean control = Set.of(
|
|
"IfStatement",
|
|
"ForStatement",
|
|
"ForeachStatement",
|
|
"WhileStatement",
|
|
"DoStatement",
|
|
"SwitchStatement",
|
|
"SwitchExpression",
|
|
"CatchClause")
|
|
.contains(kind);
|
|
final boolean elseIf = node instanceof ASTIfStatement
|
|
&& node.getParent() instanceof ASTIfStatement p
|
|
&& p.getElseBranch() == node;
|
|
final int current = depth + (control && !elseIf ? 1 : 0);
|
|
int maximum = current;
|
|
for (int i = 0; i < node.getNumChildren(); i++) maximum = Math.max(maximum, nesting(node.getChild(i), current));
|
|
return maximum;
|
|
}
|
|
|
|
static void visibility(ModifierOwner member) {
|
|
final ASTTypeDeclaration owner = ((JavaNode) member).getEnclosingType();
|
|
if (owner == null || owner.isAnnotation()) return;
|
|
if (!member.getModifiers().hasAnyExplicitly(JModifier.PUBLIC, JModifier.PROTECTED, JModifier.PRIVATE))
|
|
block(member, "Declare explicit member visibility");
|
|
}
|
|
|
|
static void variable(ASTVariableId id) {
|
|
if (id.isEnumConstant() && !id.getName().matches("[A-Z][A-Z0-9]*(_[A-Z0-9]+)*"))
|
|
block(id, "Enum constants require UPPER_SNAKE_CASE");
|
|
if (id.isRecordComponent() || id.isEnumConstant() || id.isUnnamed()) return;
|
|
if (id.isTypeInferred() && !id.isLambdaParameter() && !id.isPatternBinding()) {
|
|
final ASTExpression initializer = id.getInitializer();
|
|
if (!(initializer instanceof ASTConstructorCall)
|
|
&& !(initializer instanceof ASTCastExpression)
|
|
&& !(initializer instanceof ASTArrayAllocation)) {
|
|
block(id, "var requires a visible constructor or cast type");
|
|
}
|
|
}
|
|
if (id.isLambdaParameter()
|
|
&& id.getParent() instanceof ASTLambdaParameter parameter
|
|
&& parameter.hasVarKeyword()) block(id, "Use an explicit lambda parameter type with final");
|
|
if (id.isFinal()) return;
|
|
final boolean written =
|
|
id.getLocalUsages().stream().anyMatch(u -> u.getAccessType() != ASTAssignableExpr.AccessType.READ);
|
|
if (written) return;
|
|
if (id.isLambdaParameter()) {
|
|
block(id, "Assigned-once lambda parameter requires final: " + id.getName());
|
|
return;
|
|
}
|
|
if (id.isField()) {
|
|
final ASTFieldDeclaration field =
|
|
id.ancestors(ASTFieldDeclaration.class).first();
|
|
if (field == null
|
|
|| id.getInitializer() == null
|
|
|| field.isAnnotationPresent("jakarta.inject.Inject")
|
|
|| field.isAnnotationPresent("lombok.Setter")
|
|
|| id.getEnclosingType().isAnnotationPresent("lombok.Setter")
|
|
|| id.getEnclosingType().isAnnotationPresent("lombok.Data")) return;
|
|
}
|
|
block(id, "Assigned-once variable requires final: " + id.getName());
|
|
}
|
|
|
|
static boolean owned(String name) {
|
|
return types.containsKey(name) || ownedTypes.stream().anyMatch(n -> name.equals(n) || name.startsWith(n + "$"));
|
|
}
|
|
|
|
static void typeMetrics(ASTTypeDeclaration type) {
|
|
final Set<Integer> ownLines = new HashSet<>();
|
|
final Set<Integer> scopeLines = codeLines.getOrDefault(path(type), lines(type));
|
|
final var nestedTypes = all(type, ASTTypeDeclaration.class).stream()
|
|
.filter(t -> t != type)
|
|
.toList();
|
|
var token = type.getFirstToken();
|
|
while (token != null && !token.isEof()) {
|
|
final var region = token.getRegion();
|
|
if (nestedTypes.stream().noneMatch(t -> t.getTextRegion().contains(region))) {
|
|
final var loc = token.getReportLocation();
|
|
for (int line = loc.getStartLine(); line <= loc.getEndLine(); line++)
|
|
if (scopeLines.contains(line)) ownLines.add(line);
|
|
}
|
|
if (token == type.getLastToken()) break;
|
|
token = token.getNext();
|
|
}
|
|
metric(type, "classLines", ownLines.size(), 300, 500);
|
|
if (type.isRecord())
|
|
findings.add("DESIGN " + location(type) + " recordComponents="
|
|
+ type.getRecordComponents().size() + " (manual design review)");
|
|
int depth = 0;
|
|
var superclass = type.getSymbol().getSuperclass();
|
|
while (superclass != null && owned(superclass.getBinaryName())) {
|
|
depth++;
|
|
superclass = superclass.getSuperclass();
|
|
}
|
|
metric(type, "ownSuperclassDepth", depth, 2, 3);
|
|
final Set<String> fanout = new HashSet<>();
|
|
for (var ref : all(type, ASTClassType.class)) {
|
|
if (ref.getEnclosingType() != type) continue;
|
|
final var symbol = ref.getTypeMirror().getSymbol();
|
|
if (symbol != null && symbol.isUnresolved())
|
|
block(
|
|
ref,
|
|
"Cannot resolve type " + ref.getSimpleName()
|
|
+ "; compile the backend and regenerate target/standards-classpath.txt before"
|
|
+ " checking");
|
|
if (symbol instanceof JClassSymbol resolved && !resolved.equals(type.getSymbol()))
|
|
fanout.add(resolved.getBinaryName());
|
|
}
|
|
metric(type, "fanOut", fanout.size(), 15, Double.POSITIVE_INFINITY);
|
|
int publicMethods = 0;
|
|
for (var method : type.getOperations())
|
|
if (method instanceof ASTMethodDeclaration
|
|
&& method.hasExplicitModifiers(JModifier.PUBLIC)
|
|
&& !trivial(method)) publicMethods++;
|
|
metric(type, "publicMethods", publicMethods, 15, Double.POSITIVE_INFINITY);
|
|
final Set<Dependency> dependencies = new HashSet<>();
|
|
injected(type, dependencies, new HashSet<>());
|
|
metric(type, "injectedDependencies", dependencies.size(), 5, 7);
|
|
}
|
|
|
|
static boolean trivial(ASTExecutableDeclaration method) {
|
|
if (method.getBody() == null || method.getBody().getNumChildren() != 1) return false;
|
|
final JavaNode statement = method.getBody().getChild(0);
|
|
final String name = method.getName();
|
|
String property = name;
|
|
if (name.startsWith("get") || name.startsWith("set")) property = name.substring(3);
|
|
else if (name.startsWith("is")) property = name.substring(2);
|
|
if (property.isEmpty()) return false;
|
|
property = Character.toLowerCase(property.charAt(0)) + property.substring(1);
|
|
final String fieldName = property;
|
|
if (method.getEnclosingType().getSymbol().getDeclaredFields().stream()
|
|
.noneMatch(f -> f.getSimpleName().equals(fieldName))) return false;
|
|
if (method.getArity() == 0)
|
|
return statement instanceof ASTReturnStatement returned
|
|
&& accessorField(returned.getExpr(), method, property);
|
|
if (method.getArity() != 1 || !name.startsWith("set")) return false;
|
|
return statement instanceof ASTExpressionStatement expression
|
|
&& expression.getExpr() instanceof ASTAssignmentExpression assignment
|
|
&& !assignment.isCompound()
|
|
&& accessorField(assignment.getLeftOperand(), method, property)
|
|
&& assignment.getRightOperand() instanceof ASTVariableAccess value
|
|
&& method.getFormalParameters().get(0).getVarId().getSymbol().equals(value.getReferencedSym());
|
|
}
|
|
|
|
static boolean accessorField(ASTExpression expression, ASTExecutableDeclaration method, String property) {
|
|
if (!(expression instanceof ASTAssignableExpr.ASTNamedReferenceExpr reference)) return false;
|
|
if (expression instanceof ASTFieldAccess field && !(field.getQualifier() instanceof ASTThisExpression))
|
|
return false;
|
|
return method.getEnclosingType().getSymbol().getDeclaredFields().stream()
|
|
.anyMatch(
|
|
field -> field.getSimpleName().equals(property) && field.equals(reference.getReferencedSym()));
|
|
}
|
|
|
|
record Dependency(JTypeMirror type, Set<String> qualifiers) {}
|
|
|
|
static boolean annotated(AnnotableSymbol symbol, String annotation) {
|
|
return symbol.getDeclaredAnnotations().stream()
|
|
.anyMatch(a -> a.getBinaryName().equals(annotation));
|
|
}
|
|
|
|
static Dependency dependency(JVariableSymbol variable) {
|
|
return dependency(variable, Substitution.EMPTY);
|
|
}
|
|
|
|
static Dependency dependency(JVariableSymbol variable, Substitution substitution) {
|
|
final Set<String> qualifiers = new HashSet<>();
|
|
for (var annotation : variable.getDeclaredAnnotations()) {
|
|
if (annotation.getBinaryName().equals("jakarta.inject.Named")
|
|
|| annotated(annotation.getAnnotationSymbol(), "jakarta.inject.Qualifier")) {
|
|
final Map<String, String> attributes = new TreeMap<>();
|
|
for (String name : annotation.getAttributeNames())
|
|
attributes.put(name, String.valueOf(annotation.getAttribute(name)));
|
|
qualifiers.add(annotation.getBinaryName() + attributes);
|
|
}
|
|
}
|
|
return new Dependency(variable.getTypeMirror(substitution), qualifiers);
|
|
}
|
|
|
|
static void injected(ASTTypeDeclaration type, Set<Dependency> dependencies, Set<String> visited) {
|
|
if (!visited.add(type.getBinaryName())) return;
|
|
final var constructors = type.getSymbol().getConstructors();
|
|
final boolean bean = type.getDeclaredAnnotations().any(a -> {
|
|
final var symbol = a.getTypeMirror().getSymbol();
|
|
return Set.of(
|
|
"jakarta.inject.Singleton",
|
|
"jakarta.enterprise.context.ApplicationScoped",
|
|
"jakarta.enterprise.context.RequestScoped",
|
|
"jakarta.enterprise.context.Dependent",
|
|
"jakarta.enterprise.context.SessionScoped")
|
|
.contains(symbol.getCanonicalName())
|
|
|| annotated(symbol, "jakarta.inject.Scope")
|
|
|| annotated(symbol, "jakarta.enterprise.context.NormalScope")
|
|
|| annotated(symbol, "jakarta.enterprise.inject.Stereotype");
|
|
});
|
|
for (var constructor : constructors) {
|
|
if (annotated(constructor, "jakarta.inject.Inject") || bean && constructors.size() == 1) {
|
|
for (var parameter : constructor.getFormalParameters()) dependencies.add(dependency(parameter));
|
|
}
|
|
}
|
|
// PMD deliberately sees handwritten source, so account for Lombok's generated constructor.
|
|
if (bean
|
|
&& type.getOperations()
|
|
.filterIs(ASTConstructorDeclaration.class)
|
|
.isEmpty()) {
|
|
final boolean allArgs = type.isAnnotationPresent("lombok.AllArgsConstructor");
|
|
final boolean requiredArgs = type.isAnnotationPresent("lombok.RequiredArgsConstructor");
|
|
if (allArgs || requiredArgs)
|
|
for (var field : type.getDeclarations(ASTFieldDeclaration.class)) {
|
|
if (!field.isStatic())
|
|
for (var id : field.getVarIds())
|
|
if (allArgs
|
|
|| id.getInitializer() == null
|
|
&& (id.isFinal() || field.isAnnotationPresent("lombok.NonNull")))
|
|
dependencies.add(dependency(id.getSymbol()));
|
|
}
|
|
}
|
|
inheritedInjection(type.getTypeMirror(), dependencies, new HashSet<>());
|
|
}
|
|
|
|
static void inheritedInjection(JClassType resolvedType, Set<Dependency> dependencies, Set<String> visited) {
|
|
if (resolvedType == null) return;
|
|
final JClassSymbol symbol = resolvedType.getSymbol();
|
|
final Substitution substitution = resolvedType.getTypeParamSubst();
|
|
if (!visited.add(symbol.getBinaryName())) return;
|
|
for (var field : symbol.getDeclaredFields())
|
|
if (annotated(field, "jakarta.inject.Inject")) dependencies.add(dependency(field, substitution));
|
|
for (var method : symbol.getDeclaredMethods())
|
|
if (annotated(method, "jakarta.inject.Inject"))
|
|
for (var parameter : method.getFormalParameters())
|
|
dependencies.add(dependency(parameter, substitution));
|
|
inheritedInjection(resolvedType.getSuperClass(), dependencies, visited);
|
|
}
|
|
|
|
static void duplication(List<Path> files) throws Exception {
|
|
final var config = new CPDConfiguration();
|
|
config.setMinimumTileSize(100);
|
|
config.setIgnoreIdentifiers(false);
|
|
config.setIgnoreLiterals(false);
|
|
config.setSkipLexicalErrors(false);
|
|
config.setNoSkipBlocks(true);
|
|
final Set<String> duplicated = new HashSet<>();
|
|
try (var cpd = CpdAnalysis.create(config)) {
|
|
for (var file : files)
|
|
if (file.startsWith(root.resolve(module + "/src/main/java")))
|
|
cpd.files().addFile(file);
|
|
cpd.performAnalysis(report -> {
|
|
for (var error : report.getProcessingErrors()) findings.add("BLOCK CPD parser " + error);
|
|
for (var match : report.getMatches())
|
|
for (var mark : match) {
|
|
final var loc = mark.getLocation();
|
|
final Path path = Path.of(loc.getFileId().getAbsolutePath())
|
|
.toAbsolutePath()
|
|
.normalize();
|
|
for (int line = loc.getStartLine(); line <= loc.getEndLine(); line++)
|
|
if (codeLines.getOrDefault(path, Set.of()).contains(line))
|
|
duplicated.add(path + ":" + line);
|
|
findings.add("CLONE " + path + ":" + loc.getStartLine() + "-" + loc.getEndLine());
|
|
}
|
|
});
|
|
}
|
|
final long total = codeLines.entrySet().stream()
|
|
.filter(e -> e.getKey().startsWith(root.resolve(module + "/src/main/java")))
|
|
.mapToLong(e -> e.getValue().size())
|
|
.sum();
|
|
final double density = total == 0 ? 0 : 100.0 * duplicated.size() / total;
|
|
findings.add((density > 3 ? "BLOCK " : density > 1 ? "REVIEW " : "METRIC ") + "productionDuplication=" + density
|
|
+ "% (" + duplicated.size() + "/" + total + ")");
|
|
}
|
|
}
|