test(resolver/java): add Layer 3 + Layer 6 — concurrency stress + determinism

Phase 7 of the resolver-and-Java-pilot plan, top two highest-leverage
aggressive-testing layers.

Layer 6 — JavaSymbolResolverDeterminismTest (4 tests):
  - sameInputResolvesToSameFqnEveryTime — single resolver, 25 iterations
    over the same source must produce the same resolved FQN
    ("com.example.a.Owner"). Pins the value-stable contract under repeated
    calls (different identity, same value).
  - twoResolverInstancesOverSameProjectAgree — two independent resolver
    instances bootstrapped against the same root must produce the same
    FQN for the same source — establishes that bootstrap is value-stable
    across instances, not just within one.
  - rebootstrapStillProducesSameFqn — resolve, rebootstrap, resolve
    again; FQN is unchanged. The orchestrator calls bootstrap once, but
    if the resolver were ever refreshed mid-run, the value contract must
    still hold.
  - deeperFqnsAreAlsoStable — same shape on a 3-segment package
    (com.example.inner.deep.Marker) so a divergence on a deeper lookup
    can't hide behind a 1-level passing test.

Layer 3 — JavaSymbolResolverConcurrencyTest (3 tests):
  - parallelResolveNeverThrowsAndAlwaysAgrees — 256 virtual threads each
    resolve the same source; the aggregated FQN set must be of size 1.
    Catches "thread X's CU bleeds into thread Y" / shared-mutable-state
    classes of races. Runs cleanly on the per-call-fresh-JavaParser
    contract.
  - parallelResolveAcrossDistinctFilesProducesPerFileResults — 200
    distinct Consumer files each resolved on a virtual thread; aggregate
    FQN set = {com.example.api.Target}. Catches "one thread's resolved
    state survives into another thread's resolution" classes of bugs.
  - parallelResolveOnGarbageInputDoesNotThrow — 256 virtual threads each
    pass garbage strings; no exceptions escape and no thread returns null.
    The resolver's "no throw, no null" contract holds under concurrency.

Plan: docs/plans/2026-04-27-sub-project-1-resolver-spi-and-java-pilot.md
(tasks 30 + 31).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aksOps

src/test/java/io/github/randomcodespace/iq/intelligence/resolver/java/JavaSymbolResolverConcurrencyTest.java

@@ -0,0 +1,196 @@
+package io.github.randomcodespace.iq.intelligence.resolver.java;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.ast.type.Type;
+import com.github.javaparser.resolution.types.ResolvedType;
+import io.github.randomcodespace.iq.analyzer.DiscoveredFile;
+import io.github.randomcodespace.iq.intelligence.resolver.ResolutionException;
+import io.github.randomcodespace.iq.intelligence.resolver.Resolved;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Phase 7 Layer 3 — virtual-thread concurrency stress for the resolver.
+ *
+ * <p>Production analysis fans every {@code Analyzer.run()} file across virtual
+ * threads — every {@link JavaSymbolResolver#resolve} call therefore happens
+ * on a different carrier with no synchronization. This test fires a lot of
+ * concurrent {@code resolve()} calls against a bootstrapped resolver and
+ * asserts:
+ * <ul>
+ *   <li>no exceptions escape (the virtual-thread fan-out is exception-clean),</li>
+ *   <li>every concurrent call produces the same resolved FQN for the same
+ *       source — concurrency does not corrupt resolution,</li>
+ *   <li>per-call {@code JavaParser} allocation (not a shared instance) is
+ *       safe — JavaParser instances aren't thread-safe and the resolver's
+ *       contract is "fresh JavaParser per call".</li>
+ * </ul>
+ *
+ * <p>Total time bound: kept loose ({@code timeout 60s}) — the goal is to
+ * catch races / deadlocks, not benchmark throughput.
+ */
+class JavaSymbolResolverConcurrencyTest {
+
+    private static final int N_FILES = 200;          // distinct files
+    private static final int CONCURRENT_CALLS = 256; // virtual threads
+
+    @TempDir Path repoRoot;
+
+    private JavaSymbolResolver resolver;
+
+    @BeforeEach
+    void setUp() throws IOException, ResolutionException {
+        // Single-source-root layout with a target type the per-file content
+        // imports + uses, plus N_FILES different "consumer" files that each
+        // resolve the same target.
+        Files.createDirectories(repoRoot.resolve("src/main/java/com/example/api"));
+        Files.writeString(repoRoot.resolve("pom.xml"), "<project/>");
+        Files.writeString(repoRoot.resolve("src/main/java/com/example/api/Target.java"),
+                """
+                package com.example.api;
+                public class Target {}
+                """);
+
+        Path pkg = repoRoot.resolve("src/main/java/com/example/consumers");
+        Files.createDirectories(pkg);
+        for (int i = 0; i < N_FILES; i++) {
+            Files.writeString(pkg.resolve("Consumer" + i + ".java"),
+                    "package com.example.consumers;\n"
+                            + "import com.example.api.Target;\n"
+                            + "public class Consumer" + i + " {\n"
+                            + "    private Target t;\n"
+                            + "}\n");
+        }
+
+        resolver = new JavaSymbolResolver(new JavaSourceRootDiscovery());
+        resolver.bootstrap(repoRoot);
+    }
+
+    @Test
+    void parallelResolveNeverThrowsAndAlwaysAgrees() throws Exception {
+        // Same content resolved CONCURRENT_CALLS times across virtual threads.
+        // Race signal: any divergence in resolved FQN means the resolver isn't
+        // safe under concurrent fan-out.
+        String relPath = "src/main/java/com/example/consumers/Consumer0.java";
+        String content = Files.readString(repoRoot.resolve(relPath));
+        DiscoveredFile file = new DiscoveredFile(Path.of(relPath), "java", content.length());
+
+        Set<String> fqns = ConcurrentHashMap.newKeySet();
+        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
+            List<Future<String>> futures = IntStream.range(0, CONCURRENT_CALLS)
+                    .mapToObj(i -> exec.submit(() -> {
+                        Resolved r = resolver.resolve(file, content);
+                        String fqn = targetFieldFqn((JavaResolved) r);
+                        fqns.add(fqn);
+                        return fqn;
+                    }))
+                    .toList();
+
+            // Drain — assertAll will surface any task exception explicitly.
+            for (Future<String> f : futures) {
+                f.get(60, TimeUnit.SECONDS);
+            }
+        }
+
+        assertEquals(1, fqns.size(),
+                "all concurrent resolutions must agree on the FQN — got " + fqns);
+        assertEquals("com.example.api.Target", fqns.iterator().next());
+    }
+
+    @Test
+    void parallelResolveAcrossDistinctFilesProducesPerFileResults() throws Exception {
+        // Each virtual thread resolves a distinct file. Aggregated set of FQNs
+        // must still be {Target}: every consumer's field resolves to the same
+        // target type. Catches "thread X's resolver state leaked into thread Y"
+        // class of bugs where one thread's CU bleeds into another's resolution.
+        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
+            List<Future<String>> futures = IntStream.range(0, N_FILES)
+                    .mapToObj(i -> {
+                        String relPath = "src/main/java/com/example/consumers/Consumer" + i + ".java";
+                        String content;
+                        try {
+                            content = Files.readString(repoRoot.resolve(relPath));
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                        DiscoveredFile file = new DiscoveredFile(Path.of(relPath), "java", content.length());
+                        return exec.submit(() ->
+                                targetFieldFqn((JavaResolved) resolver.resolve(file, content)));
+                    })
+                    .toList();
+
+            Set<String> distinct = futures.stream()
+                    .map(f -> {
+                        try {
+                            return f.get(60, TimeUnit.SECONDS);
+                        } catch (Exception e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .collect(Collectors.toSet());
+
+            assertEquals(Set.of("com.example.api.Target"), distinct,
+                    "every Consumer's field resolves to the single Target FQN — concurrent runs agree");
+        }
+    }
+
+    @Test
+    void parallelResolveOnGarbageInputDoesNotThrow() throws Exception {
+        // The contract is "no exceptions, no nulls" even for unparseable
+        // input. JavaParser is permissive and may produce a CU; our resolver
+        // returns either JavaResolved (with errors attached) or
+        // EmptyResolved.INSTANCE. Both are valid; the test asserts no
+        // RuntimeException leaks from the executor.
+        DiscoveredFile file = new DiscoveredFile(Path.of("Bad.java"), "java", 50);
+
+        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
+            List<Future<Resolved>> futures = IntStream.range(0, CONCURRENT_CALLS)
+                    .mapToObj(i -> exec.submit(() -> resolver.resolve(file, "@@@@@ garbage input " + i)))
+                    .toList();
+
+            for (Future<Resolved> f : futures) {
+                Resolved r = f.get(60, TimeUnit.SECONDS);
+                assertNotNull(r, "resolver must never return null even under garbage input");
+            }
+        }
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    /** Resolve the Consumer's "t" field's declared-type FQN via the carried solver. */
+    private static String targetFieldFqn(JavaResolved r) {
+        CompilationUnit cu = r.cu();
+        ClassOrInterfaceDeclaration cls = cu.findFirst(ClassOrInterfaceDeclaration.class)
+                .orElseThrow();
+        FieldDeclaration field = cls.getFields().stream().findFirst().orElseThrow();
+        Type fieldType = field.getVariable(0).getType();
+        ResolvedType rt = fieldType.asClassOrInterfaceType().resolve();
+        return rt.isReferenceType()
+                ? rt.asReferenceType().getQualifiedName()
+                : rt.describe();
+    }
+
+    @SuppressWarnings("unused") // Reserved for future test additions that need raw type access.
+    private static ClassOrInterfaceType firstClassOrInterfaceType(CompilationUnit cu) {
+        return cu.findFirst(ClassOrInterfaceType.class).orElseThrow();
+    }
+}

src/test/java/io/github/randomcodespace/iq/intelligence/resolver/java/JavaSymbolResolverDeterminismTest.java

@@ -0,0 +1,187 @@
+package io.github.randomcodespace.iq.intelligence.resolver.java;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import io.github.randomcodespace.iq.analyzer.DiscoveredFile;
+import io.github.randomcodespace.iq.intelligence.resolver.ResolutionException;
+import io.github.randomcodespace.iq.intelligence.resolver.Resolved;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Phase 7 Layer 6 — determinism gate for the symbol resolver.
+ *
+ * <p>The graph-build determinism contract (same input → byte-identical graph,
+ * every run) extends to the resolver: same project root + same source content
+ * must produce the same {@link Resolved} shape, and the same field/type
+ * reference must resolve to the same FQN every time.
+ *
+ * <p>Tested invariants:
+ * <ol>
+ *   <li>Same source string resolved N times → identical resolved FQN.</li>
+ *   <li>Two independent resolver instances over the same project root →
+ *       identical resolved FQN for the same source.</li>
+ *   <li>Re-bootstrap on the same root → identical resolution behaviour
+ *       (the registry-side determinism guarantee, but checked at the resolver
+ *       boundary too).</li>
+ * </ol>
+ */
+class JavaSymbolResolverDeterminismTest {
+
+    @TempDir Path repoRoot;
+
+    private static final String PET_PATH = "src/main/java/com/example/Pet.java";
+    private static final String PET_SOURCE = """
+            package com.example;
+            import com.example.a.Owner;
+            public class Pet {
+                private Owner owner;
+            }
+            """;
+
+    @BeforeEach
+    void setUp() throws IOException {
+        Files.createDirectories(repoRoot.resolve("src/main/java/com/example/a"));
+        Files.writeString(repoRoot.resolve("pom.xml"), "<project/>");
+        Files.writeString(repoRoot.resolve("src/main/java/com/example/a/Owner.java"),
+                """
+                package com.example.a;
+                public class Owner {}
+                """);
+        Path absPet = repoRoot.resolve(PET_PATH);
+        Files.createDirectories(absPet.getParent());
+        Files.writeString(absPet, PET_SOURCE);
+    }
+
+    @Test
+    void sameInputResolvesToSameFqnEveryTime() throws ResolutionException {
+        JavaSymbolResolver resolver = new JavaSymbolResolver(new JavaSourceRootDiscovery());
+        resolver.bootstrap(repoRoot);
+        DiscoveredFile file = new DiscoveredFile(Path.of(PET_PATH), "java", PET_SOURCE.length());
+
+        // Resolve 25 times — every call must produce the same FQN. JavaParser's
+        // identity-not-value semantics means the JavaResolved instances differ,
+        // but the resolved type's FQN must be stable.
+        List<String> fqns = IntStream.range(0, 25)
+                .mapToObj(i -> {
+                    Resolved r = resolver.resolve(file, PET_SOURCE);
+                    return ownerFieldFqn((JavaResolved) r);
+                })
+                .toList();
+
+        // All elements are the same FQN.
+        String first = fqns.get(0);
+        assertEquals("com.example.a.Owner", first,
+                "first resolution must pin the imported Owner FQN");
+        for (int i = 1; i < fqns.size(); i++) {
+            assertEquals(first, fqns.get(i),
+                    "resolution #" + i + " diverged — determinism gate broken");
+        }
+    }
+
+    @Test
+    void twoResolverInstancesOverSameProjectAgree() throws ResolutionException {
+        JavaSymbolResolver a = new JavaSymbolResolver(new JavaSourceRootDiscovery());
+        JavaSymbolResolver b = new JavaSymbolResolver(new JavaSourceRootDiscovery());
+        a.bootstrap(repoRoot);
+        b.bootstrap(repoRoot);
+
+        DiscoveredFile file = new DiscoveredFile(Path.of(PET_PATH), "java", PET_SOURCE.length());
+
+        String fqnA = ownerFieldFqn((JavaResolved) a.resolve(file, PET_SOURCE));
+        String fqnB = ownerFieldFqn((JavaResolved) b.resolve(file, PET_SOURCE));
+
+        assertEquals("com.example.a.Owner", fqnA);
+        assertEquals(fqnA, fqnB, "two independent resolver instances must agree on the FQN");
+    }
+
+    @Test
+    void rebootstrapStillProducesSameFqn() throws ResolutionException {
+        // The contract: rebootstrap is allowed (idempotent in observable
+        // behaviour). After a second bootstrap on the same root, the resolver
+        // resolves the same input the same way.
+        JavaSymbolResolver resolver = new JavaSymbolResolver(new JavaSourceRootDiscovery());
+
+        resolver.bootstrap(repoRoot);
+        DiscoveredFile file = new DiscoveredFile(Path.of(PET_PATH), "java", PET_SOURCE.length());
+        String first = ownerFieldFqn((JavaResolved) resolver.resolve(file, PET_SOURCE));
+
+        resolver.bootstrap(repoRoot); // second bootstrap on same root
+        String second = ownerFieldFqn((JavaResolved) resolver.resolve(file, PET_SOURCE));
+
+        assertEquals("com.example.a.Owner", first);
+        assertEquals(first, second, "rebootstrap must not change resolution behaviour");
+    }
+
+    @Test
+    void deeperFqnsAreAlsoStable() throws Exception {
+        // Add a slightly deeper hierarchy to widen the determinism check —
+        // the test is small enough that a divergence on a 1-level lookup
+        // could hide one on a 2-level one.
+        Files.createDirectories(repoRoot.resolve("src/main/java/com/example/inner/deep"));
+        Files.writeString(repoRoot.resolve("src/main/java/com/example/inner/deep/Marker.java"),
+                """
+                package com.example.inner.deep;
+                public class Marker {}
+                """);
+        String depPath = "src/main/java/com/example/Dep.java";
+        String depSource = """
+                package com.example;
+                import com.example.inner.deep.Marker;
+                public class Dep {
+                    private Marker marker;
+                }
+                """;
+        Files.writeString(repoRoot.resolve(depPath), depSource);
+
+        JavaSymbolResolver resolver = new JavaSymbolResolver(new JavaSourceRootDiscovery());
+        resolver.bootstrap(repoRoot);
+        DiscoveredFile file = new DiscoveredFile(Path.of(depPath), "java", depSource.length());
+
+        for (int i = 0; i < 10; i++) {
+            JavaResolved r = (JavaResolved) resolver.resolve(file, depSource);
+            assertEquals("com.example.inner.deep.Marker",
+                    fieldFqn(r, "marker"),
+                    "deep FQN diverged on iteration " + i);
+        }
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    /** Resolve the Pet.owner field's declared-type FQN via the carried solver. */
+    private static String ownerFieldFqn(JavaResolved r) {
+        return fieldFqn(r, "owner");
+    }
+
+    private static String fieldFqn(JavaResolved r, String fieldName) {
+        CompilationUnit cu = r.cu();
+        ClassOrInterfaceDeclaration cls = cu.findFirst(ClassOrInterfaceDeclaration.class)
+                .orElseThrow();
+        return cls.getFields().stream()
+                .filter(f -> f.getVariables().stream()
+                        .anyMatch(v -> v.getNameAsString().equals(fieldName)))
+                .findFirst()
+                .map(f -> f.getVariable(0).getType())
+                .filter(t -> t.isClassOrInterfaceType())
+                .map(t -> resolveFqn(t.asClassOrInterfaceType()))
+                .orElseThrow(() -> new AssertionError("field '" + fieldName + "' not found"));
+    }
+
+    private static String resolveFqn(ClassOrInterfaceType type) {
+        ResolvedType rt = type.resolve();
+        return rt.isReferenceType()
+                ? rt.asReferenceType().getQualifiedName()
+                : rt.describe();
+    }
+}