Skip to content

Commit 271fd3b

Browse files
authored
Merge pull request #85 from dragonsec-ai/codex/fix-cycle-synthetic-evidence
Fix ordinary dependency evidence in cycle rules
2 parents cbdba6e + d2ee1a1 commit 271fd3b

7 files changed

Lines changed: 316 additions & 3 deletions

File tree

‎CHANGELOG.md‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,9 @@ uses semantic versioning for public releases.
77

88
### Fixed
99

10+
- preserve ordinary member-owned dependencies in type and package cycle checks when synthetic
11+
edges are ignored (the default), and exclude synthetic member evidence correctly; checks may
12+
now report real cycles that `0.1.0` silently missed;
1013
- accept documented dotted CLI rule IDs while still rejecting unknown rule fields;
1114
- retain input and parser failures in CLI/direct `CliAnalyzer` results so corrupt archives or
1215
malformed classes cannot silently produce passing partial checks; and

‎docs/USER_GUIDE.md‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -105,6 +105,13 @@ These entry points are all under the
105105
The generated Javadocs list the overloads and option values. Prefer a narrow selector and an
106106
explicit external-dependency policy over broad patterns that happen to pass today.
107107

108+
Type and package cycle rules ignore evidence from synthetic types, synthetic members, and bridge
109+
methods by default. Ordinary member-owned dependencies remain part of the graph, including an edge
110+
that has both ordinary and synthetic evidence. Evidence without an owning member is retained unless
111+
the edge itself originates from a synthetic type or member. Use
112+
`CycleRuleOptions.withSyntheticEdges(SyntheticEdgePolicy.INCLUDE)` to include generated evidence;
113+
type-use dependencies such as field types are controlled separately and are included by default.
114+
108115
## Layers, slices, modules, and PlantUML
109116

110117
Layers and slices are projections over the imported dependency graph. Define membership first,

‎src/main/java/dev/archunitjava/rules/CycleRules.java‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -294,7 +294,9 @@ private static DependencyGraph withoutSyntheticEvidence(
294294
&& syntheticMembers.contains(member));
295295
edge.evidence().stream()
296296
.filter(evidence -> !syntheticOrigin
297-
&& evidence.ownerMember().map(syntheticMembers::contains).orElse(true))
297+
&& evidence.ownerMember()
298+
.map(member -> !syntheticMembers.contains(member))
299+
.orElse(true))
298300
.forEach(evidence -> result.addDependency(
299301
edge.origin(), edge.target(), edge.kind(), evidence));
300302
}
Lines changed: 173 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,173 @@
1+
package dev.archunitjava.rules;
2+
3+
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertFalse;
5+
import static org.junit.jupiter.api.Assertions.assertNotNull;
6+
import static org.junit.jupiter.api.Assertions.assertTrue;
7+
8+
import dev.archunitjava.cli.CliAnalysisResult;
9+
import dev.archunitjava.cli.CliAnalyzer;
10+
import dev.archunitjava.cli.CliConfigurationLoader;
11+
import dev.archunitjava.graph.DependencyEvidence;
12+
import dev.archunitjava.graph.DependencyKind;
13+
import dev.archunitjava.graph.MemberId;
14+
import dev.archunitjava.graph.TypeId;
15+
import dev.archunitjava.model.JavaMemberModifier;
16+
import dev.archunitjava.pattern.JavaPattern;
17+
import dev.archunitjava.pattern.PatternDomain;
18+
import dev.archunitjava.result.RuleStatus;
19+
import dev.archunitjava.selector.PackageSelector;
20+
import dev.archunitjava.selector.TypeSelector;
21+
import java.io.IOException;
22+
import java.nio.file.Files;
23+
import java.nio.file.Path;
24+
import java.util.List;
25+
import java.util.Set;
26+
import java.util.stream.Collectors;
27+
import org.junit.jupiter.api.BeforeEach;
28+
import org.junit.jupiter.api.Test;
29+
import org.junit.jupiter.api.io.TempDir;
30+
31+
class CycleRulesBytecodeTest {
32+
private static final String PREFIX = "dev.archunitjava.rules.fixtures.cycles.";
33+
private static final TypeId LEFT = TypeId.ofBinaryName(PREFIX + "left.CycleLeft");
34+
private static final TypeId RIGHT = TypeId.ofBinaryName(PREFIX + "right.CycleRight");
35+
36+
@TempDir Path temporaryDirectory;
37+
private CliAnalysisResult analysis;
38+
39+
@BeforeEach
40+
void importJavacFixturesWithoutLoadingTargetClasses() throws IOException {
41+
for (String name : List.of(LEFT.binaryName(), RIGHT.binaryName(),
42+
LEFT.binaryName() + "$OneWay", RIGHT.binaryName() + "$Leaf")) {
43+
String resource = name.replace('.', '/') + ".class";
44+
Path target = temporaryDirectory.resolve("classes").resolve(resource);
45+
Files.createDirectories(target.getParent());
46+
try (var input = CycleRulesBytecodeTest.class.getResourceAsStream("/" + resource)) {
47+
assertNotNull(input, resource);
48+
Files.copy(input, target);
49+
}
50+
}
51+
Path configuration = temporaryDirectory.resolve("archunitjava.properties");
52+
Files.writeString(configuration, """
53+
schema=archunitjava.cli.v1
54+
inputs=classes
55+
rules=fixture
56+
rule.fixture.domain=types
57+
rule.fixture.mode=only
58+
rule.fixture.origins=glob:dev.archunitjava.rules.fixtures.cycles.**
59+
rule.fixture.targets=glob:dev.archunitjava.rules.fixtures.cycles.**
60+
rule.fixture.external=ignore
61+
""");
62+
analysis = new CliAnalyzer().analyze(
63+
CliConfigurationLoader.load(configuration, temporaryDirectory));
64+
assertTrue(analysis.imports().model().classFileDiagnostics().isEmpty());
65+
assertEquals(4, analysis.imports().model().types().size());
66+
}
67+
68+
@Test
69+
void defaultRulesDetectJavacTypeAndPackageCycles() {
70+
TypeSelector selected = types(LEFT.binaryName(), RIGHT.binaryName());
71+
assertEquals(RuleStatus.FAILED, CycleRules.typesAreAcyclic(
72+
analysis.imports().model(), analysis.graph(), selected).check().status());
73+
assertEquals(RuleStatus.FAILED, CycleRules.packagesAreAcyclic(
74+
analysis.imports().model(), analysis.graph(), PackageSelector.all()).check().status());
75+
}
76+
77+
@Test
78+
void javacMethodCyclesAreDetectedUnderEverySyntheticPolicy() {
79+
assertCyclesUnderEverySyntheticPolicy(DependencyKind.METHOD_CALL);
80+
}
81+
82+
@Test
83+
void javacFieldCyclesRespectTheIndependentTypeUsePolicy() {
84+
assertCyclesUnderEverySyntheticPolicy(DependencyKind.FIELD_TYPE);
85+
var noTypeUses = CycleRuleOptions.defaults().includingOnly(Set.of(DependencyKind.FIELD_TYPE))
86+
.withTypeUseDependencies(TypeUseDependencyPolicy.IGNORE);
87+
assertEquals(RuleStatus.PASSED, CycleRules.typesAreAcyclic(
88+
analysis.imports().model(), analysis.graph(), types(LEFT.binaryName(), RIGHT.binaryName()),
89+
noTypeUses).check().status());
90+
}
91+
92+
@Test
93+
void javacLambdaEvidenceIsFilteredWithoutRemovingOrdinaryCallsOnTheSameEdge() {
94+
Set<MemberId> syntheticMembers = analysis.imports().model().types().stream()
95+
.flatMap(type -> type.declaredMembers().stream()
96+
.filter(member -> member.modifiers().contains(JavaMemberModifier.SYNTHETIC))
97+
.map(member -> MemberId.of(TypeId.ofBinaryName(type.binaryName()),
98+
member.name(), member.descriptor())))
99+
.collect(Collectors.toSet());
100+
assertFalse(syntheticMembers.isEmpty(), "javac must generate a lambda implementation member");
101+
var calls = analysis.graph().edges().stream()
102+
.filter(edge -> edge.origin().equals(LEFT) && edge.target().equals(RIGHT)
103+
&& edge.kind() == DependencyKind.METHOD_CALL)
104+
.flatMap(edge -> edge.evidence().stream()).toList();
105+
assertTrue(calls.stream().anyMatch(evidence -> syntheticMembers.contains(
106+
evidence.ownerMember().orElseThrow())));
107+
assertTrue(calls.stream().anyMatch(evidence -> !syntheticMembers.contains(
108+
evidence.ownerMember().orElseThrow())));
109+
110+
for (SyntheticEdgePolicy policy : SyntheticEdgePolicy.values()) {
111+
var result = CycleRules.typesAreAcyclic(analysis.imports().model(), analysis.graph(),
112+
types(LEFT.binaryName(), RIGHT.binaryName()), CycleRuleOptions.defaults()
113+
.includingOnly(Set.of(DependencyKind.METHOD_CALL))
114+
.withSyntheticEdges(policy)).check();
115+
assertEquals(RuleStatus.FAILED, result.status());
116+
Set<MemberId> owners = result.violations().getFirst().evidence().stream()
117+
.map(DependencyEvidence::ownerMember).map(owner -> owner.orElseThrow())
118+
.collect(Collectors.toSet());
119+
assertTrue(owners.contains(MemberId.of(LEFT, "work", "()V")));
120+
assertTrue(owners.contains(MemberId.of(RIGHT, "work", "()V")));
121+
assertEquals(policy == SyntheticEdgePolicy.INCLUDE,
122+
owners.stream().anyMatch(syntheticMembers::contains));
123+
}
124+
}
125+
126+
@Test
127+
void javacOneWayDependenciesRemainAcyclicUnderEverySyntheticPolicy() {
128+
TypeSelector selected = types(LEFT.binaryName() + "$OneWay", RIGHT.binaryName() + "$Leaf");
129+
assertEquals(2, selected.selectFrom(analysis.imports().model()).selected().size());
130+
Set<DependencyKind> importedKinds = analysis.graph().edges().stream()
131+
.filter(edge -> edge.origin().equals(TypeId.ofBinaryName(LEFT.binaryName() + "$OneWay"))
132+
&& edge.target().equals(TypeId.ofBinaryName(RIGHT.binaryName() + "$Leaf")))
133+
.map(edge -> edge.kind()).collect(Collectors.toSet());
134+
assertTrue(importedKinds.containsAll(Set.of(DependencyKind.METHOD_CALL, DependencyKind.FIELD_TYPE)));
135+
assertEquals(RuleStatus.PASSED, CycleRules.typesAreAcyclic(
136+
analysis.imports().model(), analysis.graph(), selected).check().status());
137+
for (SyntheticEdgePolicy policy : SyntheticEdgePolicy.values()) {
138+
var result = CycleRules.typesAreAcyclic(analysis.imports().model(), analysis.graph(),
139+
selected, CycleRuleOptions.defaults().withSyntheticEdges(policy)).check();
140+
assertEquals(RuleStatus.PASSED, result.status(), policy.name());
141+
assertTrue(result.violations().isEmpty());
142+
}
143+
}
144+
145+
private void assertCyclesUnderEverySyntheticPolicy(DependencyKind kind) {
146+
var edges = analysis.graph().edges().stream()
147+
.filter(edge -> edge.kind() == kind)
148+
.filter(edge -> Set.of(LEFT, RIGHT).contains(edge.origin())
149+
&& Set.of(LEFT, RIGHT).contains(edge.target()))
150+
.toList();
151+
assertEquals(2, edges.size(), kind.name());
152+
assertTrue(edges.stream().flatMap(edge -> edge.evidence().stream())
153+
.allMatch(evidence -> evidence.ownerMember().isPresent()));
154+
for (SyntheticEdgePolicy policy : SyntheticEdgePolicy.values()) {
155+
var options = CycleRuleOptions.defaults().includingOnly(Set.of(kind)).withSyntheticEdges(policy);
156+
var result = CycleRules.typesAreAcyclic(analysis.imports().model(), analysis.graph(),
157+
types(LEFT.binaryName(), RIGHT.binaryName()), options).check();
158+
assertEquals(RuleStatus.FAILED, result.status(), kind + "/" + policy);
159+
assertEquals(1, result.violations().size());
160+
assertFalse(result.violations().getFirst().evidence().isEmpty());
161+
var packages = CycleRules.packagesAreAcyclic(analysis.imports().model(),
162+
analysis.graph(), PackageSelector.all(), options).check();
163+
assertEquals(RuleStatus.FAILED, packages.status(), kind + "/" + policy);
164+
assertEquals(1, packages.violations().size());
165+
}
166+
}
167+
168+
private static TypeSelector types(String first, String second) {
169+
return TypeSelector.anyOf(
170+
TypeSelector.binaryName(JavaPattern.exact(PatternDomain.QUALIFIED_NAME, first)),
171+
TypeSelector.binaryName(JavaPattern.exact(PatternDomain.QUALIFIED_NAME, second)));
172+
}
173+
}

‎src/test/java/dev/archunitjava/rules/CycleRulesTest.java‎

Lines changed: 90 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -36,8 +36,11 @@ class CycleRulesTest {
3636
private static final TypeId C = TypeId.ofBinaryName("app.C");
3737
private static final TypeId D = TypeId.ofBinaryName("other.D");
3838
private static final TypeId GENERATED = TypeId.ofBinaryName("app.Generated");
39+
private static final MemberId A_WORK = MemberId.of(A, "work", "()V");
3940
private static final MemberId A_BRIDGE = MemberId.of(A, "bridge", "()V");
41+
private static final MemberId A_SYNTHETIC = MemberId.of(A, "generated", "()V");
4042
private static final MemberId B_WORK = MemberId.of(B, "work", "()V");
43+
private static final MemberId D_WORK = MemberId.of(D, "work", "()V");
4144
private static final MemberId GENERATED_WORK = MemberId.of(GENERATED, "work", "()V");
4245

4346
@TempDir Path temporaryDirectory;
@@ -132,10 +135,91 @@ void typeUseAndSyntheticEdgesAreIndependentExplicitPolicies() {
132135
.check().status());
133136
}
134137

138+
@Test
139+
void ordinaryMemberEvidenceIsRetainedUnderEverySyntheticPolicy() {
140+
DependencyEvidence outward = evidence(A_WORK, 10);
141+
DependencyEvidence inward = evidence(B_WORK, 20);
142+
DependencyGraph graph = DependencyGraph.builder()
143+
.addNode(A).addNode(B)
144+
.addDependency(A, B, DependencyKind.METHOD_CALL, outward)
145+
.addDependency(B, A, DependencyKind.METHOD_CALL, inward)
146+
.build();
147+
148+
assertEquals(RuleStatus.FAILED,
149+
CycleRules.typesAreAcyclic(model, graph, packages("app")).check().status());
150+
for (SyntheticEdgePolicy policy : SyntheticEdgePolicy.values()) {
151+
var result = CycleRules.typesAreAcyclic(model, graph, packages("app"),
152+
CycleRuleOptions.defaults().withSyntheticEdges(policy)).check();
153+
assertEquals(RuleStatus.FAILED, result.status(), policy.name());
154+
assertEquals(1, result.violations().size());
155+
assertEquals(List.of(outward, inward), result.violations().getFirst().evidence());
156+
}
157+
}
158+
159+
@Test
160+
void syntheticMemberEvidenceCannotCreateAnOrdinaryTypeCycle() {
161+
for (MemberId owner : List.of(A_BRIDGE, A_SYNTHETIC)) {
162+
DependencyGraph graph = DependencyGraph.builder()
163+
.addNode(A).addNode(B)
164+
.addDependency(A, B, DependencyKind.METHOD_CALL, evidence(owner, 10))
165+
.addDependency(B, A, DependencyKind.METHOD_CALL, evidence(null, 20))
166+
.build();
167+
168+
assertEquals(RuleStatus.PASSED,
169+
CycleRules.typesAreAcyclic(model, graph, packages("app")).check().status(),
170+
owner.stableKey());
171+
var included = CycleRules.typesAreAcyclic(model, graph, packages("app"),
172+
CycleRuleOptions.defaults().withSyntheticEdges(SyntheticEdgePolicy.INCLUDE))
173+
.check();
174+
assertEquals(RuleStatus.FAILED, included.status());
175+
assertEquals(1, included.violations().size());
176+
}
177+
}
178+
179+
@Test
180+
void mixedEvidenceKeepsTheOrdinaryCycleAndDropsOnlySyntheticOwners() {
181+
DependencyEvidence ordinary = evidence(A_WORK, 10);
182+
DependencyEvidence synthetic = evidence(A_BRIDGE, 20);
183+
DependencyEvidence reverse = evidence(B_WORK, 30);
184+
DependencyGraph graph = DependencyGraph.builder()
185+
.addNode(A).addNode(B)
186+
.addDependency(A, B, DependencyKind.METHOD_CALL, ordinary)
187+
.addDependency(A, B, DependencyKind.METHOD_CALL, synthetic)
188+
.addDependency(B, A, DependencyKind.METHOD_CALL, reverse)
189+
.build();
190+
191+
var ignored = CycleRules.typesAreAcyclic(model, graph, packages("app")).check();
192+
assertEquals(RuleStatus.FAILED, ignored.status());
193+
assertEquals(List.of(ordinary, reverse), ignored.violations().getFirst().evidence());
194+
var included = CycleRules.typesAreAcyclic(model, graph, packages("app"),
195+
CycleRuleOptions.defaults().withSyntheticEdges(SyntheticEdgePolicy.INCLUDE)).check();
196+
assertEquals(RuleStatus.FAILED, included.status());
197+
assertEquals(List.of(ordinary, synthetic, reverse).stream().sorted().toList(),
198+
included.violations().getFirst().evidence());
199+
}
200+
201+
@Test
202+
void syntheticOriginsAreIgnoredEvenWithoutEvidenceOwners() {
203+
for (var origin : List.of(GENERATED, A_BRIDGE)) {
204+
DependencyGraph graph = DependencyGraph.builder()
205+
.addNode(origin).addNode(B)
206+
.addDependency(origin, B, DependencyKind.METHOD_CALL, evidence(null, 10))
207+
.addDependency(B, origin, DependencyKind.METHOD_CALL, evidence(null, 20))
208+
.build();
209+
210+
assertEquals(RuleStatus.PASSED,
211+
CycleRules.typesAreAcyclic(model, graph, packages("app")).check().status());
212+
assertEquals(RuleStatus.FAILED,
213+
CycleRules.typesAreAcyclic(model, graph, packages("app"),
214+
CycleRuleOptions.defaults().withSyntheticEdges(SyntheticEdgePolicy.INCLUDE))
215+
.check().status());
216+
}
217+
}
218+
135219
@Test
136220
void packageProjectionIgnoresIntraPackageEdgesAndRetainsUnderlyingEvidence() {
137-
DependencyEvidence outward = evidence(null, 50);
138-
DependencyEvidence inward = evidence(null, 60);
221+
DependencyEvidence outward = evidence(A_WORK, 50);
222+
DependencyEvidence inward = evidence(D_WORK, 60);
139223
DependencyGraph graph = DependencyGraph.builder()
140224
.addNode(A).addNode(B).addNode(D)
141225
.addDependency(A, B, DependencyKind.METHOD_CALL, evidence(null, 40))
@@ -182,6 +266,10 @@ private static byte[] type(String binaryName, boolean syntheticBridge) {
182266
"bridge", MethodTypeDesc.of(ClassDesc.ofDescriptor("V")),
183267
ClassFile.ACC_PUBLIC | ClassFile.ACC_SYNTHETIC | ClassFile.ACC_BRIDGE,
184268
code -> code.return_());
269+
builder.withMethodBody(
270+
"generated", MethodTypeDesc.of(ClassDesc.ofDescriptor("V")),
271+
ClassFile.ACC_PRIVATE | ClassFile.ACC_SYNTHETIC,
272+
code -> code.return_());
185273
}
186274
});
187275
}
Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
package dev.archunitjava.rules.fixtures.cycles.left;
2+
3+
import dev.archunitjava.rules.fixtures.cycles.right.CycleRight;
4+
5+
/** Compiled by the test build; imported as bytes, never loaded or executed by the analyzer. */
6+
public final class CycleLeft {
7+
private CycleRight right;
8+
9+
public void work() {
10+
right.work();
11+
}
12+
13+
public Runnable deferred() {
14+
return () -> right.work();
15+
}
16+
17+
public static final class OneWay {
18+
private CycleRight.Leaf leaf;
19+
20+
public void work() {
21+
leaf.work();
22+
}
23+
}
24+
}
Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
package dev.archunitjava.rules.fixtures.cycles.right;
2+
3+
import dev.archunitjava.rules.fixtures.cycles.left.CycleLeft;
4+
5+
/** Compiled by the test build; imported as bytes, never loaded or executed by the analyzer. */
6+
public final class CycleRight {
7+
private CycleLeft left;
8+
9+
public void work() {
10+
left.work();
11+
}
12+
13+
public static final class Leaf {
14+
public void work() {}
15+
}
16+
}

0 commit comments

Comments
 (0)