Optimise ArchUnit transitive analysis

Author: Markus Paulsen

.github/workflows/maven.yml

@@ -140,22 +140,18 @@ jobs:
             method-suffixes: '*MavenArchunitAspectJ+*_archunit_aspectj'
             architecture-method-suffixes: '*MavenArchunitAspectJ_test'
             reuse-forks: 'true'
-            run-core-tests: true
           - name: ArchUnit + instrumentation
             method-suffixes: '*MavenArchunitInstrumentation+*_archunit_instrumentation'
             architecture-method-suffixes: '*MavenArchunitInstrumentation_test'
             reuse-forks: 'true'
-            run-core-tests: false
           - name: WALA + AspectJ
             method-suffixes: '*MavenWalaAspectJ+*_wala_aspectj'
             architecture-method-suffixes: '*MavenWalaAspectJ_test'
             reuse-forks: 'true'
-            run-core-tests: false
           - name: WALA + instrumentation
             method-suffixes: '*MavenWalaInstrumentation+*_wala_instrumentation'
             architecture-method-suffixes: '*MavenWalaInstrumentation_test'
             reuse-forks: 'true'
-            run-core-tests: false
     permissions:
       contents: read
     steps:
@@ -171,19 +167,36 @@ jobs:
           distribution: 'temurin'
           cache: 'maven'
 
-      # Non-matrix integration tests run once and remain separate from unit tests.
-      - name: Core integration tests
-        if: ${{ matrix.run-core-tests }}
-        run: mvn test -Pintegration-core-tests -f pom.xml
-
-      - name: jqwik integration tests
-        if: ${{ matrix.run-core-tests }}
-        run: mvn test -f pom.xml -Dtest=de.tum.cit.ase.ares.integration.JqwickTest
-
       # Method-level selection starts only the classes belonging to this mode. All
       # mode combinations reuse one fork; WALA state remains policy-scoped.
       - name: Test mode combination
         run: >-
           mvn test -f pom.xml
           -Dtest='de.tum.cit.ase.ares.integration.aop.allowed.*Test#${{ matrix.method-suffixes }},de.tum.cit.ase.ares.integration.aop.allowed.FileSystemAccessTest$*#${{ matrix.method-suffixes }},de.tum.cit.ase.ares.integration.aop.forbidden.*Test#${{ matrix.method-suffixes }},de.tum.cit.ase.ares.integration.architecture.forbidden.*Test#${{ matrix.architecture-method-suffixes }}'
           -Dsurefire-reuse-forks=${{ matrix.reuse-forks }}
+
+  core-integration-tests:
+    name: Core Integration Tests
+    needs: build
+    runs-on: ubuntu-24.04
+    timeout-minutes: 45
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+          cache: 'maven'
+
+      - name: Core integration tests
+        run: mvn test -Pintegration-core-tests -f pom.xml
+
+      - name: jqwik integration tests
+        run: mvn test -f pom.xml -Dtest=de.tum.cit.ase.ares.integration.JqwickTest

src/main/java/de/tum/cit/ase/ares/api/architecture/java/archunit/JavaArchunitTestCaseCollection.java

@@ -3,6 +3,7 @@
 //<editor-fold desc="Imports">
 import java.nio.file.Path;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import com.tngtech.archunit.base.DescribedPredicate;
 import com.tngtech.archunit.core.domain.JavaAccess;
@@ -76,16 +77,23 @@ private static ArchRule createNoClassShouldHaveMethodRule(String ruleName, Path
 			Set<ClassPermission> allowedClasses) {
 		return ArchRuleDefinition.noClasses().that(isNotAllowedClass(allowedClasses))
 				.should(new TransitivelyAccessesMethodsCondition(new DescribedPredicate<>(ruleName) {
-					private Set<String> forbiddenMethods;
+					private Set<String> exactForbiddenMethods;
+
+					private Set<String> forbiddenMethodPrefixes;
 
 					@Override
 					public boolean test(JavaAccess<?> javaAccess) {
-						if (forbiddenMethods == null) {
-							forbiddenMethods = ForbiddenMethodMatcher.effectiveMethods(methodsFilePath);
+						if (exactForbiddenMethods == null) {
+							Set<String> forbiddenMethods = ForbiddenMethodMatcher.effectiveMethods(methodsFilePath);
+							exactForbiddenMethods = forbiddenMethods.stream().filter(method -> method.indexOf('(') >= 0)
+									.collect(Collectors.toUnmodifiableSet());
+							forbiddenMethodPrefixes = forbiddenMethods.stream()
+									.filter(method -> method.indexOf('(') < 0).collect(Collectors.toUnmodifiableSet());
 						}
-						return forbiddenMethods.stream().filter(method -> !method.isEmpty())
-								.anyMatch(method -> ForbiddenMethodMatcher
-										.matches(convertArrayNotation(javaAccess.getTarget().getFullName()), method));
+						String accessedMethod = ForbiddenMethodMatcher
+								.canonicalise(convertArrayNotation(javaAccess.getTarget().getFullName()));
+						return exactForbiddenMethods.contains(accessedMethod) || forbiddenMethodPrefixes.stream()
+								.anyMatch(method -> ForbiddenMethodMatcher.matches(accessedMethod, method));
 					}
 				})).as(ruleName);
 	}