From 962c20d0d16ba51829ec0b07f870e5fb2a338c76 Mon Sep 17 00:00:00 2001 From: Rahul Krishna Date: Mon, 7 Sep 2026 19:33:07 -0400 Subject: [PATCH 1/2] =?UTF-8?q?feat(java):=20take=20up=20codeanalyzer-java?= =?UTF-8?q?=203.1.0=20=E2=80=94=20config-read=20tiers=20and=20the=20entryp?= =?UTF-8?q?oint=20report?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 3.1.0 adds three application-scope overlays: the entrypoint pass's coverage record (codeanalyzer-java#235) and the code-to-config layer in two tiers, a literal tier (#233) and a dataflow tier closed over the L3 DDG and the L4 call graph (#237). The graph contract stays at 2.0.0, but the Java models are extra="forbid", so a 3.1.0 payload did not parse at all until they grew the five new fields. Models mirror the wire: JEntrypointReport, JConfigUse and JConfigRead (the last two are PyConfigUseEdge/PyConfigRead's fields verbatim), entrypoint_frameworks on JCallable and JType, and the three overlays on JApplication as Optional — the one place in that file where None and [] are different answers. get_config_uses, get_unresolved_config_reads, get_config_readers and get_entrypoint_coverage are implemented once on JavaAnalysisBackend over the canonical JApplication, which JNeo4jBackend now rebuilds with the overlays in it (two more statements, and only on a graph that carries them). The two tiers are surfaced through prov rather than flattened: a key reached over dataflow is weaker evidence than a literal at the call site. The refusal is kept and measured from the data. It is deliberately NOT the config layer's own absence, which is ambiguous both ways: the analyzer writes config_uses/config_reads_unresolved only when non-empty (the a4 fixture is a level-4 3.1.0 run that reads no configuration and carries neither key), and the graph declares J_USES_CONFIG/J_READS_CONFIG_UNRESOLVED only once an edge exists. The witness is the sibling overlay from the same release — 3.1.0 writes an entrypoint report on every run, 3.0.x writes none of the three — so all three are probed as the one analyzer generation they are, and no version literal enters the decision path. Verified rather than assumed, against a graph emitted by 3.1.0: - The relationship names are J_USES_CONFIG and J_READS_CONFIG_UNRESOLVED, not the JAVA_ prefix a comment on #231 proposed. That agrees with PY_/TS_ on the concept and differs only in each language's own node prefix, so there is no parity-clause problem to settle upstream. - The projection still carries no comment nodes: :JComment is a declared label with zero nodes. remove_all_comments and the file-keyed Neo4j comment accessors stay blocked and stay documented as such. Fixtures regenerated with 3.1.0 and every published figure in their README re-measured: both files are identical to their 3.0.3 copies apart from the version stamp and the additive fields, and no figure moved. Closes #369 --- CHANGELOG.md | 36 ++- CLAUDE.md | 10 +- cldk/analysis/java/backend.py | 210 +++++++++++++++--- .../java/codeanalyzer/codeanalyzer.py | 12 +- cldk/analysis/java/neo4j/neo4j_backend.py | 75 +++++-- cldk/analysis/java/neo4j/reconstruct.py | 2 + cldk/models/java/models.py | 62 +++++- docs/agent-api-reference.md | 58 +++-- pyproject.toml | 4 +- tests/analysis/java/conftest.py | 5 + .../java/test_java_backend_contract.py | 21 +- tests/analysis/java/test_java_entrypoints.py | 132 +++++++++-- .../java/test_java_entrypoints_live.py | 36 ++- .../analysis/java/test_java_neo4j_backend.py | 7 +- ...test_java_neo4j_multi_application_scope.py | 17 +- .../java/test_java_v1_accessors_live.py | 2 +- tests/analysis/java/test_jcodeanalyzer.py | 4 +- tests/conftest.py | 2 +- tests/models/java/test_java_models.py | 4 +- .../resources/java/analysis_json/v2/README.md | 48 +++- .../java/analysis_json/v2/a1/analysis.json.gz | Bin 919836 -> 924438 bytes .../java/analysis_json/v2/a4/analysis.json.gz | Bin 352538 -> 353246 bytes uv.lock | 6 +- 23 files changed, 611 insertions(+), 142 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4359ac32..d567b9ad 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -95,7 +95,20 @@ surface** (3b). Design records: `docs/design/specs/2026-09-06-leg-2.5-typescript `ddg` edges whose endpoint was never emitted as a body node (codeanalyzer-java#228), so `get_ddg()` over `analysis.json` and over Neo4j now report the same edges — 10,430 on daytrader8, set for set, against a 5,434/5,347 split before. -- **Pins:** `codeanalyzer-java` 2.4.1 → 3.0.3, `codeanalyzer-typescript` 0.4.3 → 1.3.0. +- **Java's code-to-config layer and entrypoint report now answer.** codeanalyzer-java 3.1.0 adds both, so + `get_config_uses()`, `get_config_readers(key)` and `get_unresolved_config_reads()` return real edges instead + of `[]`, and `get_entrypoint_coverage()` returns the pass's own record instead of + `entrypoint_report_unavailable`. **The two config tiers are surfaced, not flattened:** `prov == ["literal"]` + is a string literal at the call site (codeanalyzer-java#233), `"dataflow"` is a key reached over the L3 DDG + or the L4 call graph (#237) — a derived answer, weaker evidence, and it widens with the analysis level. On a + `PyConfigRead` the list is every tier *attempted*, so `["literal", "dataflow"]` means the dataflow tier ran + and still could not name the key. Measured on daytrader8: 13 resolved uses (all `["literal"]`) and 16 + unresolved reads — `["literal"]` at level 1, `["literal", "dataflow"]` at level 4; the graph collapses those + 16 into 8 edges, since `J_READS_CONFIG_UNRESOLVED` is discriminated by `(key, reason)` and carries no site. + **To get this, re-analyse (or re-emit your Neo4j graph) with codeanalyzer-java 3.1.0**; an older analysis + keeps refusing, and the probe is measured from the data rather than from a version string — see the known + limitation below for what it measures and why it cannot be the config layer's own absence. +- **Pins:** `codeanalyzer-java` 2.4.1 → 3.1.0, `codeanalyzer-typescript` 0.4.3 → 1.3.0. - **The Java analyzer ships as a wheel, not a jar in this repo.** The 35 MB checked-in jar, the Temurin download in `_jdk.py`, and the release workflow's jar injection are gone; no `JAVA_HOME` is read or set, and no JDK is downloaded. The published wheel drops from about 35 MB to 320 KB. @@ -167,16 +180,25 @@ surface** (3b). Design records: `docs/design/specs/2026-09-06-leg-2.5-typescript site from the one statement containing it, not from the reaching definition of that argument, so on a reached call site every argument answers `True` together. Paths are complete; per-argument precision is not what the analyzer promises. -- **Java has no entrypoint report**, so `get_entrypoint_coverage()` returns `entrypoint_report_unavailable` - rather than fabricated coverage. `get_entrypoints()` and `get_entrypoint_classes()` carry the real marks. +- **Java's entrypoint report and code-to-config layer need codeanalyzer-java 3.1.0.** On an older analysis — + a cached `analysis.json` is reused whatever wrote it, and a 3.0.x Neo4j graph is still attachable, the floor + being 3.0.1 — `get_entrypoint_coverage()` returns `entrypoint_report_unavailable` rather than fabricated + coverage, and `get_config_uses()` / `get_config_readers()` / `get_unresolved_config_reads()` raise rather + than answer `[]`. The probe is one fact measured from the data: 3.1.0 writes an entrypoint report on every + run and 3.0.x writes none of the three overlays. It deliberately is **not** the config layer's own absence, + which is ambiguous — the analyzer writes `config_uses` / `config_reads_unresolved` only when non-empty, and + the graph declares `J_USES_CONFIG` / `J_READS_CONFIG_UNRESOLVED` only once an edge exists, so a clean 3.1.0 + analysis of a project that reads no configuration carries neither and must still answer. `get_entrypoints()` + and `get_entrypoint_classes()` carry the real marks at every generation, as does `get_config_keys()`. - **Java's `get_external_symbols()` answers over Neo4j and raises locally**: the analyzer homes out-of-project call targets only under `--external-calls`, which `--emit neo4j` forces and a local run does not. - The Java graph carries a `switch` body-node kind, which is outside `SliceNode.KINDS` (that vocabulary is codeanalyzer-python's, and Python has no switch statement). It is reported as the analyzer spells it. -- **Java's `get_config_readers(key)`, `get_config_uses()` and `get_unresolved_config_reads()` are `[]` for - every input**: the Java wire carries no code-to-config edges and no config-read detector, so there is - nothing to resolve to a reading callable. The empty list means the analyzer emits no such edge, not that - no code reads the key. `get_config_keys()` is the configuration accessor Java really answers. +- **The Java Neo4j projection still carries no comment nodes.** codeanalyzer-java 3.1.0 closes + codeanalyzer-java#231's config-read and entrypoint-report halves and not its comment half: `:JComment` is a + declared label with **zero** nodes on a graph emitted by it, and only a declaration's `docstring` reaches + the graph. So `remove_all_comments` keeps raising, and the file-keyed comment accessors keep refusing over + Neo4j while the javadoc-only ones narrow, exactly as before. ## [v2.0.0-rc.2] - 2026-09-06 Python legs 1, 1.5 and 1.6 of the CLDK 2.0 agent-facing query facade (see diff --git a/CLAUDE.md b/CLAUDE.md index 495a7004..587d7c00 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -10,7 +10,7 @@ an optional read-only Neo4j backend — selected by the *type* of the `backend=` | Language | Entry point | Local backend | Neo4j backend | Models | |----------|-------------|---------------|---------------|--------| -| Java | `CLDK.java(...)` (needs the `cldk[java]` extra) | `JCodeanalyzer` (the `codeanalyzer-java` 3.0.3 wheel's jar on its bundled JVM, subprocess, `-a 1..4` — no jar in this repo, no JDK download) | `JNeo4jBackend` (3.0.1 graph, probed at attach) | `cldk/models/java/` (schema v2 mirror) + `projections.py` | +| Java | `CLDK.java(...)` (needs the `cldk[java]` extra) | `JCodeanalyzer` (the `codeanalyzer-java` 3.1.0 wheel's jar on its bundled JVM, subprocess, `-a 1..4` — no jar in this repo, no JDK download) | `JNeo4jBackend` (3.0.1 graph, probed at attach) | `cldk/models/java/` (schema v2 mirror) + `projections.py` | | Python | `CLDK.python(...)` | `PyCodeanalyzer` (in-process `codeanalyzer-python`) | `PyNeo4jBackend` | re-exported from `codeanalyzer-python` | | TypeScript (+ JavaScript modules) | `CLDK.typescript(...)` | `TSCodeanalyzer` (`codeanalyzer-typescript` 1.3.0 binary from the wheel, subprocess; `-a 1..4`, but `--emit neo4j` takes no `-a` and is always full depth) | `TSNeo4jBackend` (graphs emitted by ≥ 1.3.0; older refused at attach) | `cldk/models/typescript/` (schema v2 mirror) | @@ -27,9 +27,11 @@ paths; the policy lives once on `JavaAnalysisBackend` because `JNeo4jBackend` re `JApplication` and answers from it. Four things Java says rather than answering, each measured: `slice_forward` / `paths_between` / `flows_to_call` / `flows_to_argument` raise (the analyzer's L4 port lattice carries no dependence edge, codeanalyzer-java#227); `get_entrypoint_coverage` reports -`entrypoint_report_unavailable` (Java projects no report, J-4); `get_external_symbols` raises off a -local run (`--external-calls` is opt-in and `--emit neo4j` forces it); the CRUD accessors still -raise. `docs/agent-api-reference.md` has the full lossiness list. +`entrypoint_report_unavailable` and the three config-read accessors raise on an analysis older than +codeanalyzer-java 3.1.0, which is the release that added both overlays (the probe is the entrypoint +report's presence, measured from the data, never a version string); `get_external_symbols` raises +off a local run (`--external-calls` is opt-in and `--emit neo4j` forces it); the CRUD accessors +still raise. `docs/agent-api-reference.md` has the full lossiness list. The legacy `CLDK(language="").analysis(...)` entry still works as a compat shim. Adding a language means a new factory method + facade + backend ABC/impl(s) + models + tests — **update this diff --git a/cldk/analysis/java/backend.py b/cldk/analysis/java/backend.py index 18413fe3..52506f82 100644 --- a/cldk/analysis/java/backend.py +++ b/cldk/analysis/java/backend.py @@ -85,6 +85,7 @@ ) from cldk.analysis.commons.treesitter import TreesitterJava from cldk.analysis.commons.treesitter.models import Captures +from cldk.models.python import PyConfigRead, PyConfigUseEdge from cldk.models.java.models import ( JApplication, JBodyNode, @@ -95,6 +96,8 @@ JCfgEdge, JComment, JCompilationUnit, + JConfigRead, + JConfigUse, JCRUDOperation, JDdgEdge, JEnumConstant, @@ -113,15 +116,39 @@ #: J-4: the CRUD accessors keep their names and raise this on schema v2, on both backends. CRUD_UNAVAILABLE = "CRUD operations are not emitted by codeanalyzer-java 3.0.1 or newer (schema v2); tracked upstream as codeanalyzer-java#187" -#: J-4: what ``get_entrypoint_coverage`` says instead of counting booleans and calling it coverage. -#: Java is the one of the three languages whose analyzer projects **no** entrypoint report -- -#: measured on the reference graph, where the ``:JApplication`` anchor carries four properties and -#: none of them is a report -- so the accessor reports that, through the shared model's own -#: ``entrypoint_report_unavailable`` vocabulary. +#: J-4: what ``get_entrypoint_coverage`` says when this analysis carries no report, instead of +#: counting booleans and calling it coverage. codeanalyzer-java 3.1.0 (codeanalyzer-java#235) emits +#: one -- ``JApplication.entrypoint_report`` on the wire, ``:JApplication.entrypoint_report_json`` +#: on the graph -- and the accessor reads it. Before 3.1.0 there was none at all, and a 3.0.x +#: payload or graph is still servable (the Neo4j floor is 3.0.1, and a cached ``analysis.json`` +#: computed at a sufficient ``max_level`` is reused whatever wrote it), so the refusal stays and is +#: decided by :data:`the overlay probe `, never by a version string. ENTRYPOINT_REPORT_UNAVAILABLE = ( - "codeanalyzer-java 3.0.1 emits no entrypoint report: analysis.json carries no such key and the :JApplication anchor carries only " - "name/schema_version/analyzer_name/analyzer_version, so the entrypoint pass's coverage (frameworks_detected/rulesets/unresolved/errors) " - "cannot be reported. get_entrypoints() and get_entrypoint_classes() still carry the analyzer's own per-declaration marks." + "this analysis carries no entrypoint report: codeanalyzer-java emits one only from 3.1.0 onwards, so the entrypoint pass's coverage " + "(frameworks_detected/rulesets/unresolved/errors) cannot be reported for an older payload or an older graph. Re-analyse, or re-emit " + "your Neo4j graph, with codeanalyzer-java 3.1.0 or newer. get_entrypoints() and get_entrypoint_classes() still carry the analyzer's " + "own per-declaration marks." +) + +#: Why the three config-read accessors refuse, **when they do**. codeanalyzer-java 3.1.0 added the +#: code-to-config layer (codeanalyzer-java#233 literal tier, #237 dataflow tier); 3.0.x has no +#: detector at all, and answering ``[]`` off a 3.0.x analysis would say "this application reads no +#: configuration" when the truth is "nothing looked" -- the ambiguous empty D7 forbids. +#: +#: **The probe cannot be the config layer's own absence**, and that is measured, not assumed: the +#: analyzer writes ``config_uses``/``config_reads_unresolved`` only when non-empty (the committed +#: ``v2/a4`` fixture is a level-4 3.1.0 run whose pruned tree reads no configuration, and it +#: carries neither key), and the graph declares ``J_USES_CONFIG``/``J_READS_CONFIG_UNRESOLVED`` as +#: relationship types only once an edge of that type exists. Both would refuse a clean 3.1.0 +#: analysis that genuinely reads nothing. The witness that *is* unconditional is the sibling +#: overlay from the same release: 3.1.0 writes an entrypoint report on every run and 3.0.x writes +#: none of the three, so all three overlays are probed as the one thing they are -- one analyzer +#: generation's output -- and never as a version literal. +CONFIG_OVERLAY_UNAVAILABLE = ( + "the code-to-config layer cannot be answered for application {app!r}: this analysis carries none of codeanalyzer-java 3.1.0's " + "application-scope overlays (config_uses, config_reads_unresolved, entrypoint_report), so an empty answer here would say " + "'this application reads no configuration' where the truth is that nothing looked. Re-analyse, or re-emit your Neo4j graph, with " + "codeanalyzer-java 3.1.0 or newer. get_config_keys() is unaffected: the keys a config artifact declares are read at every generation." ) #: What ``get_external_symbols`` raises on a payload whose run never homed out-of-project call @@ -930,11 +957,13 @@ def has_resolution_edges(self) -> bool: # ``:JExternal`` set, which :meth:`JNeo4jBackend._external_rows` now projects into # ``JApplication.external_symbols``. # - # THE ONE HONEST REFUSAL IS ``get_entrypoint_coverage``. Java projects no entrypoint report at - # all -- the ``:JApplication`` anchor carries only ``name``/``schema_version``/ - # ``analyzer_name``/``analyzer_version``, and ``analysis.json`` has no such key, unlike - # codeanalyzer-python 1.4.1 and codeanalyzer-typescript 1.3.0 which both project one. A count of - # syntactically-marked callables is not a coverage report, so it is not dressed up as one (J-4). + # ``get_entrypoint_coverage`` READS THE REPORT FROM 3.1.0 ON, AND REFUSES BELOW IT. Java was + # the one of the three languages whose analyzer projected no entrypoint report; 3.1.0 + # (codeanalyzer-java#235) projects one, on the wire as ``JApplication.entrypoint_report`` and on + # the graph as ``:JApplication.entrypoint_report_json``, so the accessor reads the same four + # fields codeanalyzer-python and codeanalyzer-typescript already carry. A 3.0.x analysis carries + # none, and a count of syntactically-marked callables is not a coverage report, so it is not + # dressed up as one (J-4): that case reports :data:`ENTRYPOINT_REPORT_UNAVAILABLE`. # ===================================================================================== def get_callables_overview(self) -> List[JCallableOverview]: """A lightweight projection of every callable in the application, without the full @@ -1015,22 +1044,33 @@ def get_entrypoint_classes(self) -> List[JClassOverview]: return [JClassOverview.of(t, path=self._file_of[name], qualified_name=name) for name, t in self._types.items() if t.is_entrypoint_class] def get_entrypoint_coverage(self) -> EntrypointCoverage: - """**Reports that there is no report** (J-4), identically on both backends. - - codeanalyzer-java 3.0.1 emits the entrypoint *marks* and nothing about the pass that made - them: ``analysis.json`` carries no report key, and the ``:JApplication`` anchor carries only - ``name``/``schema_version``/``analyzer_name``/``analyzer_version`` — measured on the - reference graph, and unlike codeanalyzer-python 1.4.1 and codeanalyzer-typescript 1.3.0, - which both project one. So this answers with a ``diagnostics``-only - :class:`~cldk.analysis.commons.results.EntrypointCoverage`, the same "say so honestly" - shape a Python graph without the report uses. - - It deliberately does **not** synthesise a report out of the ``is_entrypoint`` booleans: a - count of syntactically-marked callables is not a coverage record, and presenting one as if - it were is the ambiguous empty D7 forbids wearing a hat. The day the analyzer emits a - report, this reads it and the ``diagnostics`` go away. + """The entrypoint pass's own coverage and failure record, identically on both backends. + + codeanalyzer-java 3.1.0 (codeanalyzer-java#235) emits it — ``JApplication.entrypoint_report`` + off ``analysis.json``, ``:JApplication.entrypoint_report_json`` off the graph, which + :class:`~cldk.analysis.java.neo4j.neo4j_backend.JNeo4jBackend` parses back into the same + model, so the two backends read one object and there is no lossiness between them. The four + fields are the ones codeanalyzer-python and codeanalyzer-typescript already carry + (``frameworks_detected``, ``rulesets``, ``unresolved``, ``errors``); on daytrader8 that is + three frameworks detected of five rulesets run, nothing unresolved and no errors. + + A 3.0.x analysis carries no report at all, and both a cached ``analysis.json`` and an + attached 3.0.x graph are still servable, so that case answers with a ``diagnostics``-only + :class:`~cldk.analysis.commons.results.EntrypointCoverage` + (:data:`ENTRYPOINT_REPORT_UNAVAILABLE`) rather than fabricating empty-but-clean-looking + fields — the same "say so honestly" shape a Python graph without the report uses. It still + never synthesises a report out of the ``is_entrypoint`` booleans: a count of + syntactically-marked callables is not a coverage record (J-4). """ - return EntrypointCoverage(diagnostics=[Diagnostic(code="entrypoint_report_unavailable", message=ENTRYPOINT_REPORT_UNAVAILABLE)]) + report = self.get_application_view().entrypoint_report + if report is None: + return EntrypointCoverage(diagnostics=[Diagnostic(code="entrypoint_report_unavailable", message=ENTRYPOINT_REPORT_UNAVAILABLE)]) + return EntrypointCoverage( + frameworks_detected=list(report.frameworks_detected), + rulesets=list(report.rulesets), + unresolved=dict(report.unresolved), + errors=list(report.errors), + ) def get_callsites_for(self, signatures: List[str]) -> Dict[str, List[JCallSite]]: """Call sites of the given callables, keyed by the key that named them. @@ -1081,13 +1121,115 @@ def get_external_symbols(self) -> Dict[str, JExternalSymbol]: raise CodeanalyzerExecutionException(EXTERNAL_SYMBOLS_UNAVAILABLE) return external + # -----[ the code-to-config layer (codeanalyzer-java 3.1.0) ]----- + # + # IMPLEMENTED HERE, NOT PER BACKEND, for this section's reason: :class:`JNeo4jBackend` rebuilds + # the canonical :class:`JApplication` from the graph -- these three overlays included -- so both + # backends read one object through one implementation, and the refusal below cannot come to + # differ between them. + # + # THE TWO TIERS ARE SURFACED, NOT FLATTENED. ``prov`` on every edge names how the key was + # reached: ``"literal"`` is a string literal at the call site (codeanalyzer-java#233), + # ``"dataflow"`` is a key closed over the L3 DDG / the L4 call graph (#237) -- weaker evidence, + # and it widens with the analysis level rather than replacing the literal tier. On a + # :class:`PyConfigRead` the list is every tier *attempted* before giving up, so + # ``["literal", "dataflow"]`` there means the dataflow tier ran too and still could not name the + # key. Measured on daytrader8 at level 4: 13 uses, all ``["literal"]``; 16 unresolved reads, + # all ``["literal", "dataflow"]`` (8 edges on the graph -- see :meth:`get_unresolved_config_reads`). + def _config_overlay(self) -> Tuple[List[JConfigUse], List[JConfigRead]]: + """This analysis's config-use and unresolved-read lists, or raise if it has neither pass. + + Raises: + CodeanalyzerExecutionException: This analysis predates codeanalyzer-java 3.1.0 + (:data:`CONFIG_OVERLAY_UNAVAILABLE`, which is also where the probe's choice of + witness is argued from measurement). Both backends raise the same type with the + same message, which names the application and no ``can://`` id (E6). + """ + app = self.get_application_view() + if app.entrypoint_report is None: + raise CodeanalyzerExecutionException(CONFIG_OVERLAY_UNAVAILABLE.format(app=self._application_name)) + return list(app.config_uses or []), list(app.config_reads_unresolved or []) + + def _config_key_ids(self, key: str) -> Set[str]: + """The ids of every declared config key spelling ``key`` — a dotted key can be declared by + more than one artifact (a ``daytrader.properties`` and a ``web.xml`` naming the same one), + so this is a set and not a lookup. Compared on the id rather than on the dotted tail of the + edge's ``dst``, because the id is what the analyzer wrote on both sides of the edge.""" + return {ck.id for a in self.get_application_view().artifacts.values() for ck in a.config_keys if ck.key == key} + + def get_config_uses(self, key: str | None = None) -> List[PyConfigUseEdge]: + """Every code-to-config edge the analyzer resolved: a config read whose key closed on a + declared :class:`~cldk.models.java.models.JConfigKey`. + + Args: + key: Restrict to one dotted key, matched exactly against the declared key's own + ``key`` (never fuzzily, E8). ``None`` returns every edge. + + Returns: + The shared :class:`~cldk.models.python.PyConfigUseEdge`, as the generic ABC promises. + ``src`` is the reading call's body-node id, ``dst`` the matched key's id, and ``prov`` + the tier that resolved it — see this section's note. Empty means the pass ran and + resolved nothing. + + Raises: + CodeanalyzerExecutionException: See :meth:`_config_overlay`. + """ + uses, _ = self._config_overlay() + wanted = None if key is None else self._config_key_ids(key) + return [PyConfigUseEdge(src=u.src, dst=u.dst, prov=list(u.prov)) for u in uses if wanted is None or u.dst in wanted] + + def get_unresolved_config_reads(self) -> List[PyConfigRead]: + """Every config read whose key closed on no declared key — first class, so a read nobody can + trace stays as visible as one that resolves. + + Returns: + The shared :class:`~cldk.models.python.PyConfigRead`. ``key`` is the literal text when it + *was* a literal matching no declared key (``reason="undefined-key"``) and ``None`` when + it never closed on one (``reason="non-literal"``); ``prov`` is every tier attempted. + + **The graph is lossier than the payload here, in two named ways, and neither is a + presence/absence gap.** ``J_READS_CONFIG_UNRESOLVED`` runs application-to-ghost + (``:JApplication`` → ``:JExternal``) and never touches the body node that made the call, + so ``site`` comes back ``""`` off Neo4j; and the edge's discriminant is ``(key, reason)`` + rather than the site, so several call sites reading one key collapse into one edge — + daytrader8's 16 wire entries are 8 edges. Any unresolved read still guarantees at least + one edge, so "no rows" never means a false negative. Same shape, and the same reason, as + codeanalyzer-python's ``PY_READS_CONFIG_UNRESOLVED``. + + Raises: + CodeanalyzerExecutionException: See :meth:`_config_overlay`. + """ + _, reads = self._config_overlay() + return [PyConfigRead(site=r.site, callee=r.callee, key=r.key, reason=r.reason, prov=list(r.prov)) for r in reads] + def get_config_readers(self, key: str) -> List[JCallableOverview]: - """Always ``[]``, for the reason 3a's :meth:`get_config_uses` gives: codeanalyzer-java 3.0.1 - emits no code-to-config edges (there is no ``config_uses`` on the Java wire), so there is no - edge to resolve to a reading callable and no callable to name. Not a fact of its own: it is - empty *because* :meth:`get_config_uses` is, and the day the analyzer emits those edges this - is where they get resolved to callables.""" - return [] + """Overviews of every callable that reads one config key — :meth:`get_config_uses` resolved + from body nodes back to the callables that own them. + + Args: + key: The dotted key, matched exactly as in :meth:`get_config_uses`. + + Returns: + One overview per distinct callable, in the addressing index's order; a callable reading + the key at several call sites appears once. Empty means nothing reads it. + + A ``J_USES_CONFIG`` edge may also be rooted on a field, a type or a callable rather than + on a body node (the schema allows all four sources; every one of daytrader8's 13 is a + body node). A field- or type-rooted read has no reading *callable*, so it has no entry + here — it is still in :meth:`get_config_uses`, which is where the whole edge set lives. + + Raises: + CodeanalyzerExecutionException: See :meth:`_config_overlay`. + """ + wanted, found = self._config_key_ids(key), {} + for use in self.get_config_uses(key) if wanted else []: + # ``src`` is a body-node id (``@:``) or, for the other three + # sources the schema allows, the declaration's own id. One lookup covers both: a + # callable id carries no ``@`` of its own. + row = self._addressing.by_id.get(use.src) or self._addressing.by_id.get(use.src.rpartition("@")[0]) + if row is not None: + found[row.key] = row + return [JCallableOverview.of(r.key, r.type, r.callable, path=r.path) for r in found.values()] # -----[ the type-kind leaf accessors (J-7) ]----- def get_interfaces(self) -> Dict[str, JType]: diff --git a/cldk/analysis/java/codeanalyzer/codeanalyzer.py b/cldk/analysis/java/codeanalyzer/codeanalyzer.py index 2d0203dd..5a1e53cc 100644 --- a/cldk/analysis/java/codeanalyzer/codeanalyzer.py +++ b/cldk/analysis/java/codeanalyzer/codeanalyzer.py @@ -73,7 +73,7 @@ JMethodDetail, JType, ) -from cldk.models.python import PyArtifact, PyConfigKey, PyConfigRead, PyConfigUseEdge, PyDependency +from cldk.models.python import PyArtifact, PyConfigKey, PyDependency from cldk.utils.exceptions.exceptions import CodeanalyzerExecutionException, CodeanalyzerUsageException logger = logging.getLogger(__name__) @@ -835,16 +835,6 @@ def get_config_keys(self) -> Dict[str, PyConfigKey]: """ return {f"{path}@key/{ck.key}": PyConfigKey(**ck.model_dump()) for path, a in self.application.artifacts.items() for ck in a.config_keys} - def get_config_uses(self, key: str | None = None) -> List[PyConfigUseEdge]: - """Always empty: codeanalyzer-java 3.0.1 emits no code-to-config edges (there is no - ``config_uses`` on the Java wire), so there is nothing to filter by ``key``.""" - return [] - - def get_unresolved_config_reads(self) -> List[PyConfigRead]: - """Always empty: codeanalyzer-java 3.0.1 has no config-read detector (no ``config_reads`` - on the Java wire).""" - return [] - # -----[ comments ]----- def get_comments_in_a_method(self, qualified_class_name: str, method_signature: str) -> List[JComment]: method = self.get_method(qualified_class_name, method_signature) diff --git a/cldk/analysis/java/neo4j/neo4j_backend.py b/cldk/analysis/java/neo4j/neo4j_backend.py index f093d52a..ab305534 100644 --- a/cldk/analysis/java/neo4j/neo4j_backend.py +++ b/cldk/analysis/java/neo4j/neo4j_backend.py @@ -71,10 +71,13 @@ **Strategy.** Unlike the Python and TypeScript Neo4j backends, which answer each accessor with its own statement, this one rebuilds the canonical :class:`JApplication` from the graph and then answers every query with the *same* logic the in-memory backend runs over the same models. The application -is built on first use, not at attach, and cached — **nine round trips in all**: three at attach (the -relationship-type fingerprint, the version probe, the module fetch) and six on first use (one +is built on first use, not at attach, and cached — **fourteen round trips in all**: four at attach +(the relationship-type fingerprint, the version probe, the resolution probe -- which reuses the +fingerprint -- and the module fetch) and ten on first use (the anchor's properties, then one containment-subtree traversal instead of one query per parent, then call sites, imports, call edges, -artifacts and dependencies). +externals, artifacts, dependencies, and the two codeanalyzer-java 3.1.0 config-overlay statements). +On a 3.0.x graph it is twelve: the anchor carries no entrypoint report, so the two config statements +are not issued at all (:meth:`_overlay_rows`). **Lossiness** relative to the in-memory backend (the projection's, not this client's; see :mod:`reconstruct` for the per-node detail): a module carries no ``source`` and no span, so @@ -132,14 +135,17 @@ JCfgEdge, JComment, JCompilationUnit, + JConfigRead, + JConfigUse, JDdgEdge, JDecorator, + JEntrypointReport, JExternalSymbol, JField, JMethodDetail, JType, ) -from cldk.models.python import PyArtifact, PyConfigKey, PyConfigRead, PyConfigUseEdge, PyDependency +from cldk.models.python import PyArtifact, PyConfigKey, PyDependency from cldk.utils.exceptions.exceptions import CodeanalyzerExecutionException, GraphSchemaMismatch logger = logging.getLogger(__name__) @@ -332,7 +338,7 @@ def _load_modules(self) -> Dict[str, Dict[str, Any]]: return {r["k"]: r["p"] for r in rows} # ===================================================================================== - # Reconstruction: eight statements, then the canonical JApplication. + # Reconstruction: ten statements (eight on a 3.0.x graph), then the canonical JApplication. # ===================================================================================== #: The whole containment subtree beneath the application's modules, in one statement: the #: ``*0..`` walk reaches every module, type (nested and local), callable and field, and the last @@ -406,6 +412,49 @@ def _artifact_rows(self) -> List[Dict[str, Any]]: app=self.application_name, ) + def _overlay_rows(self) -> Tuple[JEntrypointReport | None, List[JConfigUse], List[JConfigRead]]: + """The three application-scope overlays codeanalyzer-java 3.1.0 added, in two statements. + + The report is the whole ``JEntrypointReport`` as sorted-key JSON on the anchor, exactly as + codeanalyzer-python projects ``PyApplication.entrypoint_report``, so it parses back into the + model with no lossiness. ``properties(a)`` rather than naming the key: a 3.0.x graph has no + such property at all, and naming one statically makes the server log a warning per call. + + **The report is also the overlay probe** (see :data:`~cldk.analysis.java.backend.CONFIG_OVERLAY_UNAVAILABLE`): + a 3.1.0 graph carries it whatever the application reads, whereas ``J_USES_CONFIG`` and + ``J_READS_CONFIG_UNRESOLVED`` are declared as relationship types only once an edge of that + type exists. So the config lists are ``None`` — "nothing looked" — exactly when the report + is absent, and a real (possibly empty) list otherwise. + + Both endpoints of ``J_USES_CONFIG`` carry the scope, and each carries a different one, + because the edge is the one place the two id spaces meet: the **key** is anchored through + the artifact layer (``can://artifact//…``, which no ``$prefix`` predicate matches) and + the **source** by the code prefix, since the schema roots that edge on a body node, a + callable, a field or a type — none of which the application anchor reaches in one hop. + ``J_READS_CONFIG_UNRESOLVED`` runs from the anchor itself and carries no ``site``, which is + the lossiness :meth:`~cldk.analysis.java.backend.JavaAnalysisBackend.get_unresolved_config_reads` + states. + """ + rows = self._run("MATCH (a:JApplication {name: $app}) RETURN properties(a) AS p", app=self.application_name) + raw = rows[0]["p"].get("entrypoint_report_json") if rows else None + if raw is None: + return None, [], [] + uses = self._run( + "MATCH (:JApplication {name: $app})-[:HAS_ARTIFACT]->(:Artifact)-[:DEFINES_CONFIG]->(ck:ConfigKey)<-[u:J_USES_CONFIG]-(src) " + f"WHERE {_scoped('src')} RETURN src.id AS src, ck.id AS dst, u.prov AS prov ORDER BY src.id, ck.id", + app=self.application_name, + prefix=self._scope_prefix, + ) + reads = self._run( + "MATCH (:JApplication {name: $app})-[u:J_READS_CONFIG_UNRESOLVED]->(ghost) RETURN properties(u) AS p, ghost.id AS callee ORDER BY u.key, ghost.id", + app=self.application_name, + ) + return ( + JEntrypointReport.model_validate_json(raw), + [JConfigUse(src=r["src"], dst=r["dst"], prov=list(r["prov"] or [])) for r in uses], + [JConfigRead(site="", callee=r["callee"], key=r["p"].get("key"), reason=r["p"].get("reason", "non-literal"), prov=list(r["p"].get("prov") or [])) for r in reads], + ) + def _dependency_rows(self) -> List[Dict[str, Any]]: return self._run( "MATCH (:JApplication {name: $app})-[:HAS_ARTIFACT]->(a:Artifact)-[r:DECLARES_DEPENDENCY]->(p:Package) " @@ -469,6 +518,7 @@ def _type(self, props: Dict[str, Any], children: Dict[str, List[_Child]], sites: def _reconstruct(self) -> JApplication: """The canonical :class:`JApplication` for this application, rebuilt from the graph.""" + report, uses, reads = self._overlay_rows() children = self._subtree_rows() sites = self._call_site_rows() imports = self._import_rows() @@ -504,6 +554,10 @@ def _reconstruct(self) -> JApplication: ) }, dependencies=[R.dependency(r["rel"], r["pkg"], r["declared_in"]) for r in self._dependency_rows()], + entrypoint_report=report, + # ``None`` and ``[]`` are different answers here: see :meth:`_overlay_rows`. + config_uses=None if report is None else uses, + config_reads_unresolved=None if report is None else reads, ) @staticmethod @@ -1202,17 +1256,6 @@ def get_config_keys(self) -> Dict[str, PyConfigKey]: """ return {f"{path}@key/{ck.key}": PyConfigKey(**ck.model_dump()) for path, a in self.application.artifacts.items() for ck in a.config_keys} - def get_config_uses(self, key: str | None = None) -> List[PyConfigUseEdge]: - """Always empty, and not a projection gap: codeanalyzer-java 3.0.1 emits no code-to-config - edges at all (there is no such relationship type in the Java graph, and no ``config_uses`` - on the Java wire), so the in-memory backend answers the same way.""" - return [] - - def get_unresolved_config_reads(self) -> List[PyConfigRead]: - """Always empty, as on the in-memory backend: codeanalyzer-java 3.0.1 has no config-read - detector.""" - return [] - # -----[ comments ]----- def get_comments_in_a_method(self, qualified_class_name: str, method_signature: str) -> List[JComment]: """The method's javadoc — **narrower than the ABC's "the comments in a method"**: the graph diff --git a/cldk/analysis/java/neo4j/reconstruct.py b/cldk/analysis/java/neo4j/reconstruct.py index 2db32cb8..ed71297f 100644 --- a/cldk/analysis/java/neo4j/reconstruct.py +++ b/cldk/analysis/java/neo4j/reconstruct.py @@ -301,6 +301,7 @@ def callable_( types=types, is_implicit=implicit, is_entrypoint=bool(props.get("is_entrypoint", False)), + entrypoint_frameworks=list(props.get("entrypoint_frameworks") or []), span=span(props), ) @@ -329,6 +330,7 @@ def type_( callables=callables, types=types, is_entrypoint_class=bool(props.get("is_entrypoint", False)), + entrypoint_frameworks=list(props.get("entrypoint_frameworks") or []), # ``span`` is required on a type and the projection always carries its lines. span=span(props) or _unknown_span(), ) diff --git a/cldk/models/java/models.py b/cldk/models/java/models.py index 9fe4b8e0..a3668acf 100644 --- a/cldk/models/java/models.py +++ b/cldk/models/java/models.py @@ -19,7 +19,8 @@ The wire is one containment tree: ``JAnalysis{analyzer, application}`` → ``JApplication{symbol_table{path → JCompilationUnit}, call_graph, param_in, param_out, artifacts, -dependencies}`` → ``JCompilationUnit{types{name → JType}}`` → ``JType{fields{}, callables{signature → +dependencies, config_uses, config_reads_unresolved, entrypoint_report}`` → +``JCompilationUnit{types{name → JType}}`` → ``JType{fields{}, callables{signature → JCallable}, types{}}`` → ``JCallable{body{}, cfg, cdg, ddg, summary, types{}}``. Every node carries a ``can://`` ``id`` and a ``kind``; a unit carries its full ``source`` once and every node's text is a slice of it. Gson omits ``null`` fields, so an absent key is a ``None``/empty default here. @@ -404,6 +405,11 @@ class JCallable(_Node): is_implicit: bool = False comments: List[JComment] = [] is_entrypoint: bool = False + #: The entrypoint rulesets that marked this callable (``["jakarta"]``, ``["spring"]``, …), from + #: codeanalyzer-java 3.1.0 (codeanalyzer-java#235). ``[]`` on an unmarked callable *and* on a + #: payload from an older analyzer; :meth:`~cldk.analysis.java.backend.JavaAnalysisBackend.get_entrypoint_coverage` + #: is where that distinction is drawn, off :attr:`JApplication.entrypoint_report`. + entrypoint_frameworks: List[str] = [] metrics: Optional[JMetrics] = None refs: Optional[JRefs] = None local_variables: List[JLocalVariable] = [] @@ -508,6 +514,8 @@ class JType(_Node): decorators: List[JDecorator] = [] type_parameters: List[JTypeParameter] = [] is_entrypoint_class: bool = False + #: As :attr:`JCallable.entrypoint_frameworks`, for a type marked in its own right. + entrypoint_frameworks: List[str] = [] enum_constants: List[JEnumConstant] = [] record_components: List[JRecordComponent] = [] fields: Dict[str, JField] = {} @@ -774,6 +782,50 @@ class JDependency(_Base): prov: List[str] = [] +class JEntrypointReport(_Base): + """Coverage and failure record for the entrypoint pass (codeanalyzer-java#235, 3.1.0). + + The same four fields Python and TypeScript already carry (``PyEntrypointReport`` / + ``TSEntrypointReport``), so :class:`~cldk.analysis.commons.results.EntrypointCoverage` reads + one shape across the three languages.""" + + frameworks_detected: List[str] = [] + rulesets: List[str] = [] + unresolved: Dict[str, int] = {} + errors: List[str] = [] + + +class JConfigUse(_Base): + """One code-to-config edge: a config read whose key closed on a declared :class:`JConfigKey`. + + ``src`` is the reading call's body-node id (``@:``), ``dst`` the matched + key's id. ``prov`` names the **tier** that resolved it and is the reason this is not flattened: + ``["literal"]`` is a string literal at the call site (codeanalyzer-java#233); ``"dataflow"`` + means the key was reached over the L3 DDG / L4 call graph (codeanalyzer-java#237) — weaker + evidence, and monotone with the analysis level. Python's ``PyConfigUseEdge`` verbatim.""" + + src: str + dst: str + prov: List[str] = [] + + +class JConfigRead(_Base): + """One config read whose key closed on no declared key — first class, so a read nobody can + trace stays as visible as one that resolves. + + ``key`` is the literal text when it *was* a literal that matches no declared key + (``reason="undefined-key"``) and ``None`` when it never closed on one (``reason="non-literal"``); + ``prov`` lists every tier that was **attempted** before giving up, so ``["literal", "dataflow"]`` + means the dataflow tier ran too and still could not name the key. Python's ``PyConfigRead`` + verbatim.""" + + site: str + callee: str + key: Optional[str] = None + reason: str = "non-literal" + prov: List[str] = [] + + class JApplication(_Base): """The application root. ``call_graph``/``param_in``/``param_out`` are absent below the level that computes them — empty here, never ``None``. @@ -793,6 +845,14 @@ class JApplication(_Base): param_out: List[JParamEdge] = [] artifacts: Dict[str, JArtifact] = {} dependencies: List[JDependency] = [] + #: The three 3.1.0 overlays, and the one place in this file where ``None`` and ``[]`` are + #: *different answers*: ``None`` is "this payload predates the pass" (codeanalyzer-java 3.0.x + #: emits none of these keys at all) and an empty list/report is "the pass ran and found + #: nothing". The accessors refuse on the first and answer on the second, measured here rather + #: than from an analyzer version string — the same ruling as the port probe. + config_uses: Optional[List[JConfigUse]] = None + config_reads_unresolved: Optional[List[JConfigRead]] = None + entrypoint_report: Optional[JEntrypointReport] = None def model_post_init(self, __context: Any) -> None: for path, unit in self.symbol_table.items(): diff --git a/docs/agent-api-reference.md b/docs/agent-api-reference.md index 7b9be452..be72ffdd 100644 --- a/docs/agent-api-reference.md +++ b/docs/agent-api-reference.md @@ -213,16 +213,18 @@ accessors** — `get_callables_overview`, `get_method_bodies`, `get_decorated_ca `get_config_uses` / `get_unresolved_config_reads` / `get_config_readers`, and `get_interfaces` / `get_enums` / `get_enum_members` / `get_records`. Five rules: -- **`get_entrypoint_coverage` reports that there is no report.** codeanalyzer-java emits the - entrypoint *marks* and nothing about the pass that made them: `analysis.json` carries no report - key and the `:JApplication` anchor carries only `name` / `schema_version` / `analyzer_name` / - `analyzer_version` — unlike codeanalyzer-python 1.4.1 and codeanalyzer-typescript 1.3.0, which - both project one. So it answers with `diagnostics=[entrypoint_report_unavailable]` and empty - fields that are explicitly *not* coverage. It is not synthesised from the `is_entrypoint` - booleans: a count of syntactically-marked callables is not a coverage record. The marks - themselves are real and unambiguous — 133 callables and 66 types of daytrader8's 1,216 and 149, - 1,501 callables and 904 types of ThingsBoard's — and `get_entrypoints` / - `get_entrypoint_classes` return those. +- **`get_entrypoint_coverage` reads the report from codeanalyzer-java 3.1.0 on.** 3.1.0 + (codeanalyzer-java#235) emits the entrypoint pass's own coverage record — `entrypoint_report` on + `analysis.json`, `entrypoint_report_json` on the `:JApplication` anchor, parsed back into the same + model — so the four fields agree with codeanalyzer-python and codeanalyzer-typescript and the two + Java backends are lossless against each other. On daytrader8: `frameworks_detected` + `["jakarta", "jaxrs", "spring"]` of five `rulesets` run, nothing unresolved, no errors. **A 3.0.x + analysis carries no report**, and both a cached `analysis.json` and an attached 3.0.x graph are + still servable, so that answers `diagnostics=[entrypoint_report_unavailable]` with empty fields + that are explicitly *not* coverage. It is never synthesised from the `is_entrypoint` booleans: a + count of syntactically-marked callables is not a coverage record. The marks themselves are real + and unambiguous — 133 callables and 66 types of daytrader8's 1,216 and 149, 1,501 callables and + 904 types of ThingsBoard's — and `get_entrypoints` / `get_entrypoint_classes` return those. - **A marker matches an annotation by simple name.** `get_decorated_callables(["Test"])`, `["@Test"]` and `["org.junit.Test"]` are the same query: the Java wire carries an annotation's simple name, so both sides are compared on the segment after the last `.` with a leading `@` @@ -240,12 +242,25 @@ accessors** — `get_callables_overview`, `get_method_bodies`, `get_decorated_ca - **`get_config_keys` is keyed `"@key/"`,** artifact-relative rather than by the raw `can://artifact//…` id. Python and TypeScript still key by the id; aligning the three is python-sdk#346 and is deliberately not done piecemeal. -- **`get_config_readers(key)` is `[]` for every key on Java, and so are `get_config_uses` and - `get_unresolved_config_reads`.** The Java wire carries no `config_uses` and no config-read - detector, so there is no code-to-config edge to resolve to a reading callable — the empty list is - "the analyzer emits no such edge", not "no callable reads this key". Do not read a Java `[]` here - as evidence about the code; `get_config_keys` (which is real) is what Java answers about - configuration. Python is where the "which code reads this key" question has an answer today. +- **`get_config_uses` / `get_config_readers` / `get_unresolved_config_reads` answer from + codeanalyzer-java 3.1.0 on, and `prov` says how strong the evidence is.** 3.1.0 added the + code-to-config layer in two tiers, and the SDK surfaces the tier rather than flattening it: + `prov == ["literal"]` is a string literal at the call site (codeanalyzer-java#233); + `"dataflow"` means the key was reached over the L3 DDG / the L4 call graph (#237) — a derived + answer, weaker than a literal, and one that widens with the analysis level rather than replacing + the literal tier. On a `PyConfigRead` the list is every tier *attempted* before giving up, so + `["literal", "dataflow"]` there means the dataflow tier ran too and still could not name the key. + Measured on daytrader8: 13 resolved uses, all `["literal"]`; 16 unresolved reads (the + `System.getenv` calls), `["literal"]` at level 1 and `["literal", "dataflow"]` at level 4. + **A 3.0.x analysis has no detector at all, and the three accessors raise rather than answer `[]`** + — "this application reads no configuration" and "nothing looked" are different facts. The probe is + measured from the data, never from a version string, but it is *not* the config layer's own + absence: the analyzer writes `config_uses` / `config_reads_unresolved` only when non-empty, and + the graph declares `J_USES_CONFIG` / `J_READS_CONFIG_UNRESOLVED` as relationship types only once + an edge exists, so both would refuse a clean 3.1.0 analysis that genuinely reads nothing. The + witness is the sibling overlay from the same release — 3.1.0 writes an entrypoint report on every + run and 3.0.x writes none of the three. `get_config_keys` is unaffected and answers at every + generation. **Still absent for Java**: the scoping keywords (`get_symbol_table(paths=)`, `get_classes(module=)`, `get_call_graph(roots=, depth=)`). Calling those keywords raises @@ -287,8 +302,8 @@ What Java answers today is the 1.x accessor surface, on the v2 models: `get_symb `get_call_graph_json` / `get_callers` / `get_callees` / `get_class_call_graph`, `get_entry_point_classes` / `get_entry_point_methods`, `get_test_methods`, the comment and docstring accessors, and — new in 3a, from the generic backend ABC — `get_artifacts` / -`get_dependencies` / `get_config_keys` (`get_config_uses` and `get_unresolved_config_reads` are -`[]`: the Java analyzer emits neither). Six more joined them in #366 — `get_imports`, +`get_dependencies` / `get_config_keys` / `get_config_uses` / `get_unresolved_config_reads` (the +last two from codeanalyzer-java 3.1.0; they raise on an older analysis rather than answer `[]`). Six more joined them in #366 — `get_imports`, `get_variables`, `get_class_hierarchy`, `get_methods_with_annotations`, `get_call_targets` and `get_calling_lines`, all at their published 1.x signatures, answering identically on both backends and issuing no new Cypher. Note what each one is: `get_imports()` is the project's **distinct @@ -671,7 +686,12 @@ directly, where `PyConfigUseEdge` gives you `{src, dst, prov}` ids you would hav `PyConfigRead` carries `reason`, so an unresolved read tells you *why* it could not be resolved rather than just vanishing. -This layer is identical across Python, Java and TypeScript — the queries port unchanged. +This layer is identical across Python, Java and TypeScript — the queries port unchanged. Two +language notes: Java keys `get_config_keys()` artifact-relatively rather than by the `can://` id +(python-sdk#346), and Java's three code-to-config accessors need **codeanalyzer-java 3.1.0** — on an +older analysis they raise rather than answer `[]`, since "reads no configuration" and "nothing +looked" are different facts. `prov` is where the evidence lives on all three: `["literal"]` is a +literal at the call site, `"dataflow"` a key reached over the DDG or the call graph. --- diff --git a/pyproject.toml b/pyproject.toml index 4dde1647..146a56cb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,7 +43,7 @@ dependencies = [ # The Neo4j-backed analysis backends (read-only; no analyzer is invoked). neo4j = ["neo4j>=5.14,<7"] # The local Java backend: the analyzer wheel carries the jar and a bundled JVM (jdk4py). -java = ["codeanalyzer-java==3.0.3"] +java = ["codeanalyzer-java==3.1.0"] # Everything. `codeanalyzer-python` and `codeanalyzer-typescript` are still hard # dependencies; #340 moves them here, and this list grows when it does. all = ["cldk[java]", "cldk[neo4j]"] @@ -86,7 +86,7 @@ include = [ ] [tool.backend-versions] -codeanalyzer-java = "3.0.3" +codeanalyzer-java = "3.1.0" codeanalyzer-python = "1.4.1" codeanalyzer-typescript = "1.3.0" diff --git a/tests/analysis/java/conftest.py b/tests/analysis/java/conftest.py index 6a621697..157de5b9 100644 --- a/tests/analysis/java/conftest.py +++ b/tests/analysis/java/conftest.py @@ -36,6 +36,11 @@ "DEFINES_CONFIG", "DECLARES_DEPENDENCY", "LOCKS", + # codeanalyzer-java 3.1.0's code-to-config layer (codeanalyzer-java#233/#237). In the + # default set because the fake driver stands in for a graph emitted by the pinned analyzer; + # a test that wants a 3.0.x-shaped graph subtracts them. + "J_USES_CONFIG", + "J_READS_CONFIG_UNRESOLVED", } ) diff --git a/tests/analysis/java/test_java_backend_contract.py b/tests/analysis/java/test_java_backend_contract.py index 8e0011d5..f48240dc 100644 --- a/tests/analysis/java/test_java_backend_contract.py +++ b/tests/analysis/java/test_java_backend_contract.py @@ -38,9 +38,28 @@ def test_java_contract_parameterises_the_generic_abc(): assert JavaAnalysisBackend.N == "J" +#: The two generic methods :class:`JavaAnalysisBackend` answers **itself** rather than leaving +#: abstract, and why that is not the stub the test below forbids: the code-to-config layer is read +#: off the canonical :class:`JApplication`, which :class:`JNeo4jBackend` rebuilds from the graph +#: (overlays included) and :class:`JCodeanalyzer` holds off the wire — so one implementation serves +#: both sources, and the refusal on a pre-3.1.0 analysis cannot come to differ between them. +#: :func:`test_the_config_layer_is_answered_once_for_both_backends` pins that it stays one. +ANSWERED_ON_THE_CONTRACT = {"get_config_uses", "get_unresolved_config_reads"} + + def test_generic_methods_are_all_abstract_on_the_java_contract(): """Inheriting the generic ABC must not quietly satisfy any of its methods with a stub.""" - assert set(GENERIC_METHODS) <= JavaAnalysisBackend.__abstractmethods__ + assert set(GENERIC_METHODS) - ANSWERED_ON_THE_CONTRACT <= JavaAnalysisBackend.__abstractmethods__ + + +def test_the_config_layer_is_answered_once_for_both_backends(): + """The exemption is only sound while it really is one implementation: concrete on the contract, + and overridden by neither backend.""" + for name in ANSWERED_ON_THE_CONTRACT: + shared = getattr(JavaAnalysisBackend, name) + assert not getattr(shared, "__isabstractmethod__", False), f"{name} is abstract on the contract, so the exemption is stale" + for backend in BACKENDS: + assert getattr(backend, name) is shared, f"{backend.__name__} overrides {name}: the two backends can now disagree about it" @pytest.mark.parametrize("backend", BACKENDS) diff --git a/tests/analysis/java/test_java_entrypoints.py b/tests/analysis/java/test_java_entrypoints.py index 7cc6dd3b..222fcd3d 100644 --- a/tests/analysis/java/test_java_entrypoints.py +++ b/tests/analysis/java/test_java_entrypoints.py @@ -47,6 +47,8 @@ from cldk.utils.exceptions import SelectorNotInGraph from cldk.utils.exceptions.exceptions import CodeanalyzerExecutionException +from cldk.analysis.java.codeanalyzer.codeanalyzer import JCodeanalyzer + from .test_java_addressing import _graph, _local DIRECT_PKG = "com.ibm.websphere.samples.daytrader.impl.direct" @@ -115,18 +117,18 @@ def test_get_entrypoint_classes_is_the_class_level_sibling(both): assert all(c.path in both.get_symbol_table() for c in classes) -def test_get_entrypoint_coverage_reports_the_report_unavailable(both): - """Java projects **no** entrypoint report -- the ``:JApplication`` anchor carries only - ``name``/``schema_version``/``analyzer_name``/``analyzer_version``, and ``analysis.json`` has no - such key -- so the coverage accessor says so through the shared model's own vocabulary rather - than counting the ``is_entrypoint`` booleans and calling that coverage (J-4, D7).""" +def test_get_entrypoint_coverage_reads_the_report(both): + """codeanalyzer-java 3.1.0 (codeanalyzer-java#235) emits the entrypoint pass's own coverage + record, so the accessor reads it rather than saying there is none. Measured on a1: three of the + five shipped rulesets matched, nothing unresolved, no errors. It still never synthesises one + out of the ``is_entrypoint`` booleans (J-4, D7) -- the counts below are 66/133 and appear + nowhere in the report.""" coverage = both.get_entrypoint_coverage() assert isinstance(coverage, EntrypointCoverage) - assert [d.code for d in coverage.diagnostics] == ["entrypoint_report_unavailable"] - assert coverage.frameworks_detected == [] and coverage.rulesets == [] and coverage.unresolved == {} and coverage.errors == [] - message = coverage.diagnostics[0].message - assert "codeanalyzer-java" in message and "can://" not in message - assert coverage.diagnostics[0].suggestions == [] + assert coverage.diagnostics == [] + assert coverage.frameworks_detected == ["jakarta", "jaxrs", "spring"] + assert coverage.rulesets == ["jakarta", "struts", "spring", "camel", "jaxrs"] + assert coverage.unresolved == {} and coverage.errors == [] def test_the_coverage_diagnostic_is_the_same_on_both_backends(analysis_json): @@ -260,13 +262,107 @@ def test_get_enum_members_returns_the_constants_of_a_real_enum(both): del both._types["x.Color"] -# ---- config readers ---------------------------------------------------------------------------- -def test_get_config_readers_has_no_edges_to_resolve(both): - """codeanalyzer-java 3.0.1 emits no code-to-config edges, so ``get_config_uses`` is empty and - there is no reading callable to name -- stated on the accessor, as 3a stated it on - ``get_config_uses`` itself.""" - assert both.get_config_uses() == [] - assert both.get_config_readers("project.artifactId") == [] +# ---- the code-to-config layer (codeanalyzer-java 3.1.0) ---------------------------------------- +def test_get_config_uses_carries_the_resolved_edges_and_their_tier(both): + """13 edges on a1, every one of them ``["literal"]`` -- a string literal at the call site + (codeanalyzer-java#233). ``prov`` is surfaced, not flattened: the dataflow tier (#237) is a + weaker answer and has to stay distinguishable from this one.""" + uses = both.get_config_uses() + assert len(uses) == 13 + assert {tuple(u.prov) for u in uses} == {("literal",)} + assert {u.dst.rpartition("@key/")[2] for u in uses} == { + "displayOrderAlerts", + "listQuotePriceChangeFrequency", + "longRun", + "marketSummaryInterval", + "maxQuotes", + "maxUsers", + "orderProcessingMode", + "primIterations", + "publishQuotePriceChange", + "runtimeMode", + "webInterface", + } + assert all(u.src.startswith(u.src.rpartition("@")[0] + "@") for u in uses), "src is a body-node id" + + +def test_get_config_uses_filters_by_key_exactly(both): + """``key`` is matched against the declared key's own ``key``, never fuzzily (E8), and a key + nothing reads is an empty list rather than an unfiltered one.""" + one = both.get_config_uses("maxUsers") + assert len(one) == 2 and all(u.dst.endswith("@key/maxUsers") for u in one), "two call sites read maxUsers" + assert both.get_config_uses("maxuser") == [] and both.get_config_uses("project.artifactId") == [] + + +def test_get_config_readers_resolves_the_edges_to_their_callables(both): + """All 13 of a1's reads are in one callable, so the 13 edges resolve to **one** overview: a + callable reading a key at several call sites appears once.""" + readers = both.get_config_readers("maxUsers") + assert [r.key for r in readers] == ["com.ibm.websphere.samples.daytrader.web.servlet.TradeWebContextListener.contextInitialized(javax.servlet.ServletContextEvent)"] + assert all(isinstance(r, JCallableOverview) for r in readers) + assert both.get_config_readers("project.artifactId") == [], "a declared key nothing reads has no readers" + assert both.get_config_readers("no.such.key") == [] + + +def test_get_unresolved_config_reads_keeps_the_untraceable_ones_visible(both): + """16 reads on a1 whose key matched no declared key -- every one of them a decoded literal + (``reason="undefined-key"``, the environment variables ``System.getenv`` reads), so ``key`` + carries the text. ``prov`` is every tier *attempted*: a1 is a level-1 analysis, where there is + no DDG for the dataflow tier to run over, so it is ``["literal"]`` alone -- on the level-4 + reference graph the same reads carry ``["literal", "dataflow"]``.""" + reads = both.get_unresolved_config_reads() + assert len(reads) == 16 + assert {r.reason for r in reads} == {"undefined-key"} + assert {tuple(r.prov) for r in reads} == {("literal",)} + assert {r.key for r in reads} == { + "DISPLAY_ORDER_ALERTS", + "LIST_QUOTE_PRICE_CHANGE_FREQUENCY", + "MAX_QUOTES", + "MAX_USERS", + "ORDER_PROCESSING_MODE", + "PUBLISH_QUOTES", + "RUNTIME_MODE", + "WEB_INTERFACE", + } + assert all(r.site and r.callee.startswith("can://java/daytrader8/@external/") for r in reads) + + +def test_a_clean_run_that_reads_nothing_is_an_empty_answer_and_not_a_refusal(both_l4): + """a4 is a level-4 3.1.0 analysis of a pruned tree that reads no configuration at all. It + carries the entrypoint report and **neither config key** -- the analyzer writes those two only + when non-empty -- which is exactly why the overlay probe cannot be the config layer's own + absence. The three accessors answer empty here; the next test is what refusing looks like.""" + assert both_l4.get_config_uses() == [] + assert both_l4.get_unresolved_config_reads() == [] + assert both_l4.get_config_readers("maxUsers") == [] + assert both_l4.get_entrypoint_coverage().frameworks_detected == ["jakarta"] + + +def test_an_analysis_without_the_overlays_refuses_rather_than_answering_empty(analysis_json): + """The refusal, measured from the data and never from a version string (the same ruling as the + port probe). A 3.0.x payload and a 3.0.x graph carry none of the three overlays, and both are + still servable -- a cached ``analysis.json`` at a sufficient ``max_level`` is reused whatever + wrote it, and the Neo4j floor is 3.0.1 -- so answering ``[]`` would say "this application reads + no configuration" where the truth is that nothing looked.""" + for backend in (_local(analysis_json), _graph(analysis_json)): + stripped = backend.get_application_view().model_copy(update={"entrypoint_report": None, "config_uses": None, "config_reads_unresolved": None}) + # Each backend's own seam: the in-memory one holds the application on an attribute, the + # graph one behind the ``_application`` cache its ``application`` property reads. + backend.__dict__["application" if isinstance(backend, JCodeanalyzer) else "_application"] = stripped + for call in (backend.get_config_uses, backend.get_unresolved_config_reads, lambda: backend.get_config_readers("maxUsers")): + with pytest.raises(CodeanalyzerExecutionException) as excinfo: + call() + message = str(excinfo.value) + assert "daytrader8" in message and "3.1.0" in message and "can://" not in message + # The entrypoint report is the same absence, reported rather than raised -- the shared + # model's own vocabulary, as a Python graph without the report uses. + coverage = backend.get_entrypoint_coverage() + assert [d.code for d in coverage.diagnostics] == ["entrypoint_report_unavailable"] + assert coverage.frameworks_detected == [] and coverage.rulesets == [] and coverage.unresolved == {} and coverage.errors == [] + assert coverage.diagnostics[0].suggestions == [] and "can://" not in coverage.diagnostics[0].message + # get_config_keys() is unaffected: what a config artifact declares is read at every + # generation, and only the code-to-config edges are the 3.1.0 addition. + assert len(backend.get_config_keys()) == 336 # ---- the artifact layer reaches the facade ------------------------------------------------------ @@ -277,7 +373,7 @@ def test_the_artifact_five_are_the_backends_own_answers(both): assert both.get_dependencies(ecosystem="pypi") == [], "a filter that matches nothing is empty, not unfiltered" keys = both.get_config_keys() assert keys and all(k.startswith(tuple(artifacts)) and "@key/" in k for k in keys), "the key is artifact-relative (python-sdk#346 keeps it that way)" - assert both.get_unresolved_config_reads() == [] + assert len(both.get_unresolved_config_reads()) == 16 def test_the_l4_fixture_answers_the_same_shapes(both_l4): diff --git a/tests/analysis/java/test_java_entrypoints_live.py b/tests/analysis/java/test_java_entrypoints_live.py index ed4e514f..0912bb21 100644 --- a/tests/analysis/java/test_java_entrypoints_live.py +++ b/tests/analysis/java/test_java_entrypoints_live.py @@ -140,17 +140,21 @@ def test_the_entrypoint_types_agree_type_for_type(backends): assert sorted(ref.get_entrypoint_classes(), key=lambda c: c.qualified_name) == sorted(neo.get_entrypoint_classes(), key=lambda c: c.qualified_name) -def test_get_entrypoint_coverage_reports_the_report_unavailable_on_a_real_graph(backends): - """The ``:JApplication`` anchor really does carry no entrypoint key -- asserted against the - server, not against a fixture, because that is the fact J-4's ruling rests on.""" +def test_get_entrypoint_coverage_reads_the_report_off_a_real_graph(backends): + """The ``:JApplication`` anchor really does carry the report -- asserted against the server, not + against a fixture, because that is the fact the accessor rests on. codeanalyzer-java 3.1.0 + projects it as ``entrypoint_report_json``, the whole model as JSON, so the graph and the payload + are equal object for object rather than merely both non-empty.""" ref, neo = backends props = neo._run("MATCH (a:JApplication {name: $app}) RETURN keys(a) AS k", app=JAVA_APP)[0]["k"] - assert sorted(props) == ["analyzer_name", "analyzer_version", "name", "schema_version"] - assert not any("entrypoint" in key for key in props) + assert sorted(props) == ["analyzer_name", "analyzer_version", "entrypoint_frameworks", "entrypoint_report_json", "name", "schema_version"] for backend in (ref, neo): coverage = backend.get_entrypoint_coverage() assert isinstance(coverage, EntrypointCoverage) - assert [d.code for d in coverage.diagnostics] == ["entrypoint_report_unavailable"] + assert coverage.diagnostics == [] + assert coverage.frameworks_detected == ["jakarta", "jaxrs", "spring"] + assert coverage.rulesets == ["jakarta", "struts", "spring", "camel", "jaxrs"] + assert coverage.unresolved == {} and coverage.errors == [] assert ref.get_entrypoint_coverage() == neo.get_entrypoint_coverage() @@ -242,6 +246,22 @@ def test_the_artifact_layer_and_config_readers_agree(backends): assert [(d.name, d.ecosystem, d.direct) for d in ref.get_dependencies()] == [(d.name, d.ecosystem, d.direct) for d in neo.get_dependencies()] assert set(ref.get_config_keys()) == set(neo.get_config_keys()) assert all("@key/" in k and not k.startswith("can://") for k in ref.get_config_keys()) + # The code-to-config layer (codeanalyzer-java 3.1.0). The two sources agree on the resolved + # edges exactly and diverge on the unresolved reads for one stated reason: + # ``J_READS_CONFIG_UNRESOLVED`` is discriminated by ``(key, reason)`` and carries no site, so + # the payload's 16 per-site entries are 8 edges. Presence, not count, is the contract. + assert len(ref.get_config_uses()) == len(neo.get_config_uses()) == 13 + assert {(u.src, u.dst, tuple(u.prov)) for u in ref.get_config_uses()} == {(u.src, u.dst, tuple(u.prov)) for u in neo.get_config_uses()} + assert {tuple(u.prov) for u in ref.get_config_uses()} == {("literal",)}, "every resolved use is a literal at the call site" + assert len(ref.get_unresolved_config_reads()) == 16 and len(neo.get_unresolved_config_reads()) == 8 + assert {(r.callee, r.key, r.reason, tuple(r.prov)) for r in ref.get_unresolved_config_reads()} == { + (r.callee, r.key, r.reason, tuple(r.prov)) for r in neo.get_unresolved_config_reads() + }, "the graph collapses per-site duplicates and loses nothing else" + # ``--emit neo4j`` forces level 4, and the reference is read at level 4 too, so both ran the + # dataflow tier over the DDG -- and it still could not name these keys. + assert {tuple(r.prov) for r in ref.get_unresolved_config_reads()} == {("literal", "dataflow")} + assert all(r.site for r in ref.get_unresolved_config_reads()) and all(r.site == "" for r in neo.get_unresolved_config_reads()) for backend in (ref, neo): - assert backend.get_config_uses() == [] and backend.get_unresolved_config_reads() == [] - assert backend.get_config_readers(next(iter(backend.get_config_keys())).split("@key/")[1]) == [] + readers = backend.get_config_readers("maxUsers") + assert [r.key for r in readers] == ["com.ibm.websphere.samples.daytrader.web.servlet.TradeWebContextListener.contextInitialized(javax.servlet.ServletContextEvent)"] + assert backend.get_config_readers("project.artifactId") == [], "a declared key nothing reads has no readers" diff --git a/tests/analysis/java/test_java_neo4j_backend.py b/tests/analysis/java/test_java_neo4j_backend.py index 67747600..c5106a0a 100644 --- a/tests/analysis/java/test_java_neo4j_backend.py +++ b/tests/analysis/java/test_java_neo4j_backend.py @@ -394,8 +394,11 @@ def test_artifact_layer_parity(backends): for path, artifact in ref.application.artifacts.items(): for ck in artifact.config_keys: assert f"{path}@key/{ck.key}" in ck_r - assert neo.get_config_uses() == [] == ref.get_config_uses() - assert neo.get_unresolved_config_reads() == [] == ref.get_unresolved_config_reads() + # The 3.1.0 code-to-config layer: identical resolved edges, and unresolved reads that agree on + # every (callee, key, reason, prov) while the graph collapses their per-site duplicates -- + # ``test_java_entrypoints_live.py`` states that lossiness and pins the counts. + assert sorted((u.src, u.dst, tuple(u.prov)) for u in neo.get_config_uses()) == sorted((u.src, u.dst, tuple(u.prov)) for u in ref.get_config_uses()) + assert {(r.callee, r.key, r.reason) for r in neo.get_unresolved_config_reads()} == {(r.callee, r.key, r.reason) for r in ref.get_unresolved_config_reads()} # The Java wire's own artifact models carry two fields the shared Py* ones have no home for. assert sorted(neo.application.artifacts) == sorted(ref.application.artifacts) assert {p: (a.text_truncated, a.sha256) for p, a in neo.application.artifacts.items()} == {p: (a.text_truncated, a.sha256) for p, a in ref.application.artifacts.items()} diff --git a/tests/analysis/java/test_java_neo4j_multi_application_scope.py b/tests/analysis/java/test_java_neo4j_multi_application_scope.py index 20bffe31..5d42bb78 100644 --- a/tests/analysis/java/test_java_neo4j_multi_application_scope.py +++ b/tests/analysis/java/test_java_neo4j_multi_application_scope.py @@ -49,6 +49,7 @@ from cldk.analysis.java.neo4j import neo4j_backend from cldk.analysis.java.neo4j.neo4j_backend import JNeo4jBackend +from cldk.utils.exceptions.exceptions import CodeanalyzerExecutionException from .conftest import FakeDriver @@ -531,7 +532,13 @@ def test_the_artifact_layer_is_reached_only_through_the_application_anchor(): assert backend.get_artifacts()["pom.xml"].source == "", "application B's pom.xml leaked" assert [d.name for d in backend.get_dependencies()] == ["alpha-core"] assert [ck.key for ck in backend.get_config_keys().values()] == ["alpha.key"] - assert backend.get_config_uses() == [] and backend.get_unresolved_config_reads() == [] + # The code-to-config layer is codeanalyzer-java 3.1.0's, and this graph is a 3.0.1 one (see the + # module docstring), so it refuses here rather than answering the empty that would read as + # "application A reads no configuration". The other half of that ruling -- a 3.1.0-shaped + # analysis answering, empty or not -- is pinned in ``test_java_entrypoints.py``. + for call in (backend.get_config_uses, backend.get_unresolved_config_reads): + with pytest.raises(CodeanalyzerExecutionException, match="3.1.0"): + call() def test_the_addressing_surface_answers_from_this_application_only(): @@ -579,7 +586,8 @@ def test_the_task_three_surface_answers_from_this_application_only(): assert backend.get_entrypoints() == [] and backend.get_entrypoint_classes() == [] assert [d.code for d in backend.get_entrypoint_coverage().diagnostics] == ["entrypoint_report_unavailable"] assert backend.get_interfaces() == {} and backend.get_enums() == {} and backend.get_records() == {} - assert backend.get_config_readers("alpha.key") == [] + with pytest.raises(CodeanalyzerExecutionException, match=APP_A): + backend.get_config_readers("alpha.key") def test_external_symbols_are_this_applications_ghosts_only(): @@ -664,6 +672,11 @@ def test_a_module_row_that_is_not_a_type_is_refused_by_the_model(): "J_HAS_BODY_NODE", "HAS_ARTIFACT", "DEFINES_CONFIG", + # codeanalyzer-java 3.1.0: runs from the application node to the ghost callee of a config + # read it could not resolve, minted under the same prefix. ``J_USES_CONFIG`` is deliberately + # **not** here -- its two endpoints live in the two different id spaces (code and artifact), + # so each carries its own scope and neither may be inferred from the other. + "J_READS_CONFIG_UNRESOLVED", } ) diff --git a/tests/analysis/java/test_java_v1_accessors_live.py b/tests/analysis/java/test_java_v1_accessors_live.py index 581c70f4..edf8dcae 100644 --- a/tests/analysis/java/test_java_v1_accessors_live.py +++ b/tests/analysis/java/test_java_v1_accessors_live.py @@ -73,7 +73,7 @@ TRADE_DIRECT = f"{DIRECT}.TradeDirect" PING_SERVLET = "com.ibm.websphere.samples.daytrader.web.prims.PingServlet" -#: Measured on the reference graph (daytrader8, codeanalyzer-java 3.0.3), 2026-09-07. +#: Measured on the reference graph (daytrader8, codeanalyzer-java 3.1.0), 2026-09-07. DT_IMPORTS = 268 DT_CALLABLES = 1216 DT_DECLARING_LOCALS, DT_LOCALS = 235, 854 diff --git a/tests/analysis/java/test_jcodeanalyzer.py b/tests/analysis/java/test_jcodeanalyzer.py index d590bf3f..f65a7465 100644 --- a/tests/analysis/java/test_jcodeanalyzer.py +++ b/tests/analysis/java/test_jcodeanalyzer.py @@ -15,7 +15,7 @@ ################################################################################ """ -Test Cases for JCodeanalyzer (codeanalyzer-java 3.0.3, schema v2). The analyzer subprocess is +Test Cases for JCodeanalyzer (codeanalyzer-java 3.1.0, schema v2). The analyzer subprocess is mocked; ``analysis_json`` is daytrader8 at ``-a 1`` (no call graph), ``analysis_json_a4`` the four-file ``-a 4`` slice (247 call edges). """ @@ -103,7 +103,7 @@ def test_unknown_level_raises_instead_of_defaulting(test_fixture, analysis_json) def test_envelope_and_application_are_kept(test_fixture, analysis_json): analyzer, _ = _analyzer(analysis_json, project_dir=test_fixture) assert analyzer.analysis.schema_version == "2.0.0" - assert analyzer.analysis.analyzer.version == "3.0.3" + assert analyzer.analysis.analyzer.version == "3.1.0" assert analyzer.analysis.max_level == 1 assert analyzer.application is analyzer.analysis.application assert analyzer.application.id == "can://java/daytrader8" diff --git a/tests/conftest.py b/tests/conftest.py index 0e11918a..31445001 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -68,7 +68,7 @@ def analysis_json(analysis_json_fixture) -> str: @pytest.fixture(scope="session") def analysis_json_a4(analysis_json_fixture) -> str: - """The codeanalyzer-java 3.0.3 ``-a 4`` fixture (``v2/a4``) as a JSON string.""" + """The codeanalyzer-java 3.1.0 ``-a 4`` fixture (``v2/a4``) as a JSON string.""" with gzip.open(analysis_json_fixture.parent / "a4" / "analysis.json.gz", "rt", encoding="utf-8") as json_data: return json.dumps(json.load(json_data)) diff --git a/tests/models/java/test_java_models.py b/tests/models/java/test_java_models.py index 07d51123..a116ece3 100644 --- a/tests/models/java/test_java_models.py +++ b/tests/models/java/test_java_models.py @@ -14,7 +14,7 @@ # limitations under the License. ################################################################################ -"""Schema-level tests for the Java v2 models: the codeanalyzer-java 3.0.3 envelope parses at +"""Schema-level tests for the Java v2 models: the codeanalyzer-java 3.1.0 envelope parses at L1 and L4, round-trips losslessly, and rejects anything the wire does not carry.""" import json @@ -46,7 +46,7 @@ def test_envelope_at_both_levels(a1: JAnalysis, a4: JAnalysis): assert a.max_level == level assert a.k_limit is None # never emitted by 3.0.x assert a.analyzer.name == "codeanalyzer-java" - assert a.analyzer.version == "3.0.3" + assert a.analyzer.version == "3.1.0" assert a.application.id == "can://java/daytrader8" assert a.application.kind == "application" diff --git a/tests/resources/java/analysis_json/v2/README.md b/tests/resources/java/analysis_json/v2/README.md index 2614b337..b90171aa 100644 --- a/tests/resources/java/analysis_json/v2/README.md +++ b/tests/resources/java/analysis_json/v2/README.md @@ -1,5 +1,5 @@ Generated from `tests/resources/java/application/daytrader8-1.2.zip` (unzipped to `` = -`sample.daytrader8-1.2/`) by **codeanalyzer-java 3.0.3** — the pinned `codeanalyzer-java` wheel (the +`sample.daytrader8-1.2/`) by **codeanalyzer-java 3.1.0** — the pinned `codeanalyzer-java` wheel (the `cldk[java]` extra), run as `codeanalyzer_java.command()`: the wheel's own jar on the JVM it bundles (`jdk4py`, Temurin 21.0.8), with `JAVA_HOME` unset. **Never hand-edit these files** — regenerate them when the pin moves. @@ -24,14 +24,46 @@ earlier by a whole-project `-a 4` run of the analyzer on the unpruned tree (the java -jar codeanalyzer.jar -i -a 4 --no-build --app-name daytrader8 -o a4 -c /fx-cache-a4 -Measured on the committed files: `a1` has `schema_version 2.0.0`, `analyzer.version 3.0.3`, +Measured on the committed files: `a1` has `schema_version 2.0.0`, `analyzer.version 3.1.0`, `max_level 1`, 138 symbol-table keys, no `call_graph`/`param_in`/`param_out` keys at all, 235 -artifacts. `a4` has `max_level 4`, 4 symbol-table keys, `call_graph` 247 edges, `param_in` 258, -`param_out` 97, 2,358 `ddg` edges (2,038 `ssa`, 320 with `prov == ["points-to"]`), 76 `summary` -edges, 235 artifacts, and both `cancelOrder` overloads on `TradeDirect` -(`cancelOrder(java.lang.Integer, boolean)`, `cancelOrder(java.sql.Connection, java.lang.Integer)`). -Artifact text (default `--artifact-text`, 256 KiB cap) is included in both; the four -`jmeter_files/*.jmx` are the largest entries. +artifacts, 149 types and 1,216 callables (133 of them `is_entrypoint`, in 66 `is_entrypoint_class` +types). `a4` has `max_level 4`, 4 symbol-table keys, 128 callables, `call_graph` 247 edges, +`param_in` 258, `param_out` 97, 2,358 `ddg` edges (2,038 `ssa`, 320 with `prov == ["points-to"]`, +20 self-loops), 1,570 `cfg`, 1,258 `cdg`, 76 `summary` edges, 235 artifacts, and both `cancelOrder` +overloads on `TradeDirect` (`cancelOrder(java.lang.Integer, boolean)`, +`cancelOrder(java.sql.Connection, java.lang.Integer)`). Artifact text (default `--artifact-text`, +256 KiB cap) is included in both; the four `jmeter_files/*.jmx` are the largest entries. + +**The 3.1.0 overlays, and what each fixture carries of them.** Both carry `entrypoint_report` +(`a1`: `frameworks_detected ["jakarta", "jaxrs", "spring"]`; `a4`: `["jakarta"]`; both with the +same five `rulesets`, nothing unresolved, no errors) and `entrypoint_frameworks` on every callable +and type — non-empty on exactly the marked ones, 133 callables and 66 types in `a1`, 13 callables +and no type in `a4`. `a1` carries **13** `config_uses` (every one `prov == ["literal"]`, all in +`TradeWebContextListener.contextInitialized`, over 11 distinct `daytrader.properties` keys) and +**16** `config_reads_unresolved` (all `reason "undefined-key"`, the `System.getenv` reads, `prov +["literal"]` — level 1 has no DDG for the dataflow tier to run over; the same reads carry +`["literal", "dataflow"]` at level 4). `a4` carries **neither key at all**: its pruned tree reads no +configuration, and the analyzer writes those two only when non-empty. That is the measurement the +SDK's overlay probe rests on — an absent `config_uses` cannot mean "this analyzer had no detector", +so the probe is the entrypoint report's presence instead (`cldk/analysis/java/backend.py`, +`CONFIG_OVERLAY_UNAVAILABLE`). + +## What the 3.1.0 regeneration moved + +Both files were regenerated with the commands above when the pin moved from 3.0.3 to 3.1.0 +(python-sdk#369, analyzer-side codeanalyzer-java#233 / #235 / #237). Measured by loading the old and +new copies and comparing them structurally: **both are identical to their 3.0.3 copies apart from +the `analyzer.version` stamp and the additive fields** — `entrypoint_report`, `config_uses` and +`config_reads_unresolved` on the application, `entrypoint_frameworks` on every type and callable. +Every figure published above and below this section was re-measured on the new files and none of +them moved: 138 units / 149 types / 1,216 callables / 235 artifacts in `a1`, and `a4`'s whole +dataflow structure (2,358 `ddg`, 2,038 `ssa`, 320 `points-to`, 20 self-loops, 1,570 `cfg`, 1,258 +`cdg`, 76 `summary`, 247 `call_graph`, 258 `param_in`, 97 `param_out`), as well as the signature +table further down (154 / 0 / 45 of 45 for `a1`, 8 / 4 / 4 of 5 for `a4`). + +Note that the new fields make a 3.1.0 payload **unparsable by the pre-#369 models**, which are +`extra="forbid"`: the graph contract stays at 2.0.0 and the wire is additive, but the SDK's mirror +had to grow the five fields before it could read one. ## What the 3.0.3 regeneration moved diff --git a/tests/resources/java/analysis_json/v2/a1/analysis.json.gz b/tests/resources/java/analysis_json/v2/a1/analysis.json.gz index 52432569ee11a40122ba27b2f2f307823455b7e8..65265661c1dcc945cee67bfbdf448d38d036bd11 100644 GIT binary patch literal 924438 zcmV)cK&ZbTiwFp7L!W8_17U7qYWi)$d;z#=(5_(SI1;eDY`WAek|cIAFoEv7ULltKe2DlJ()iar-fNYzb%Hd1^e;8b3Yo% z-sb+y{q<<-}X2h{gRR^ThIYp z(7|#+2kC+imJ2$F7qqZ8;nQpszkc%Nm)BF{OXKj(k?|&ce4YjO9~Z{?>+jiLv&V22 zlb3-_WDTNraocyn$e+&rvGFuzy&H>0P`$x;%s7l1Tpy&*t`CmB zihFqupNxm$voQ@9#?#zq-2`*vE|~a+|J%raTo}RBU?0b5d^jEX#^+%1F&--IC!UV+ z&$N^9cEL!@7_v7W*i-kraB`~LFn zpV_pRulzV=i#a!D{;yBLjD7U&vypNhV=`kh{A`3XV|YLF*|S9$&HD2!SOnAiV`CoP zEj|xte%#MEm@j6*?bD*LaM>K$x91zMr5jG!qMcnD=a<(9#_O}o^ULG7pZ`3+`tIV# zE8{=UK72TPe|7%$(zy6wyt#P)?fKRD#e4SGUyZZ(|1|#n{QbAbhR>Fb4dws#IE%i5 zO*M#?)E_77cj^0uY21a$wC0cgD7XtoMuv>WeaMh(%0A0@^k)yjJlftlo8&m|XA(RF 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