codd-dev 3.26.0__tar.gz → 3.28.0__tar.gz

{codd_dev-3.26.0 → codd_dev-3.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 3.26.0
+Version: 3.28.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-3.26.0 → codd_dev-3.28.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.26.0"
+__version__ = "3.28.0"

{codd_dev-3.26.0 → codd_dev-3.28.0}/codd/languages/adapters/oracle_cpp.py

@@ -81,6 +81,7 @@ dependency edge runs gate → executor → adapters → leaf types, never back.
 
 from __future__ import annotations
 
+import dataclasses
 import re
 from pathlib import Path, PurePosixPath
 
@@ -214,6 +215,37 @@ _CPP_HEADER_NOT_FOUND_CLANG = re.compile(
     r"^'(?P<header>[^']+)'\s+file not found\b"
 )
 
+#: GNU ld's undefined-reference diagnostic — the LINK-time analogue of the
+#: undeclared-symbol family (an implementation artifact fails to DEFINE a symbol
+#: another artifact demands). Two shapes, both anchored on the message tail:
+#:   * ``/usr/bin/ld: file.cpp:(.text+0x40): undefined reference to `sym'``
+#:   * ``file.cpp:(.text+0x40): undefined reference to `sym'``   (no ld prefix)
+#: The referencing TU (``file.cpp``) and the SYMBOL are captured: the symbol is the
+#: repair-feedback identity (WHAT is missing), the TU the best-available file
+#: attribution (WHO demands it). lld/mold keep the same message tail. Without this
+#: regex a pure link failure had NO parseable diagnostic and collapsed to an opaque
+#: environment_build_error, aborting the repair loop (cpp2 exprcalc dogfood,
+#: 2026-07-11).
+_CPP_LD_UNDEFINED_RE = re.compile(
+    r"^(?:\S*ld(?:\.\w+)?:\s*)?"
+    r"(?:(?P<path>[^\s:][^:\n]*\.(?:h|hpp|hh|hxx|c|cc|cpp|cxx|cppm|ixx)):\(\S*\):\s*)?"
+    r"undefined reference to [`'](?P<symbol>[^']+)'"
+)
+
+#: ld's two-line context header (``…/main.cpp.o: in function `main':``) — context
+#: for the positioned undefined-reference that follows, never a diagnostic itself.
+_CPP_LD_CONTEXT_RE = re.compile(
+    r"^(?:\S*ld(?:\.\w+)?:\s*)?\S+\.o(?:bj)?:\s*in function\s"
+)
+
+#: collect2's sign-off (``collect2: error: ld returned 1 exit status``) — a SUMMARY
+#: epilog after the explicit ld error lines above it. Skipped in PARSING only (the
+#: undefined-reference findings are the authority); deliberately NOT recognized in
+#: the benign-accounting path, so a collect2 line with NO accompanying parsed
+#: diagnostic stays an honest opaque RED (anti-false-green — same reasoning as the
+#: ``ninja:`` note above).
+_CPP_LD_EPILOG_RE = re.compile(r"^collect2:\s*(?:fatal error|error):\s*ld returned")
+
 #: cmake progress / informational chatter that is NOT a failure — the C++ analogue
 #: of Go's ``# pkg`` headers + ``ok``/``?`` run-summary noise. ``--`` status lines
 #: (``-- Configuring done``, ``-- Detecting C compiler ...``, ``-- Build files have
@@ -412,6 +444,7 @@ def _parse_cpp_tool_output(
     """
     findings: list[ImplementOracleFinding] = []
     failed_paths: list[str] = []
+    seen_ld_refs: set[tuple[str | None, str]] = set()
 
     def _add(category: str, code: str, message: str, rel: str | None) -> None:
         findings.append(
@@ -437,11 +470,58 @@ def _parse_cpp_tool_output(
         ):
             continue
 
+        # ld undefined-reference → missing_symbol, deduped per (TU, symbol): ld
+        # repeats the same reference once per call site; per-site duplicates add
+        # no repair signal. The symbol identity rides the message (feedback).
+        ld = _CPP_LD_UNDEFINED_RE.match(line)
+        if ld is not None:
+            symbol = ld.group("symbol").strip()
+            raw_path = ld.group("path")
+            rel = _cpp_rel_path(raw_path, project_root) if raw_path else None
+            key = (rel, symbol)
+            if key not in seen_ld_refs:
+                seen_ld_refs.add(key)
+                _add(
+                    EVIDENCE_MISSING_SYMBOL,
+                    "CPP_LD_UNDEFINED_REFERENCE",
+                    f"undefined reference to `{symbol}' (link-time; referenced "
+                    f"from {rel or 'unknown TU'})",
+                    rel,
+                )
+            continue
+        if _CPP_LD_CONTEXT_RE.match(line) or _CPP_LD_EPILOG_RE.match(line):
+            continue  # ld context / collect2 epilog — the reference lines above are the authority
+
         m = _CPP_DIAG_LINE.match(line)
         if m is not None:
             severity = (m.group("severity") or "").strip().lower()
-            if severity in ("warning", "note"):
-                continue  # a warning/note is not a failure
+            if severity == "warning":
+                continue  # a warning is not a failure
+            if severity == "note":
+                # A positioned ``note:`` is CONTEXT for the PRECEDING error — the
+                # other side of a two-sided diagnostic (``previously defined
+                # here`` names the header a redefinition collides with; candidate
+                # sites for an overload miss). Attach it to the last finding's
+                # message and attribution so the repair feedback carries BOTH
+                # sides of the disagreement (cpp3 exprcalc dogfood, 2026-07-11:
+                # feedback saw only the .cpp side and oscillated). An orphan note
+                # (no preceding finding) stays noise — a note is never a failure
+                # of its own. Capped at 2 notes per finding (overload-candidate
+                # spam adds no repair signal past the first sites).
+                if findings and findings[-1].code.startswith("CPP_"):
+                    last = findings[-1]
+                    if last.message.count(": note: ") < 2:
+                        note_txt = (
+                            f"{m.group('path')}:{m.group('line')}: note: "
+                            f"{m.group('message').strip()}"
+                        )
+                        findings[-1] = dataclasses.replace(
+                            last, message=f"{last.message} [{note_txt}]"
+                        )
+                        rel_note = _cpp_rel_path(m.group("path"), project_root)
+                        if rel_note and rel_note not in failed_paths:
+                            failed_paths.append(rel_note)
+                continue
             classified = _classify_cpp_compiler_diagnostic(
                 severity, m.group("message").strip()
             )

{codd_dev-3.26.0 → codd_dev-3.28.0}/codd/languages/adapters/oracle_java.py

@@ -139,6 +139,22 @@ _JAVA_ERROR_SUMMARY_RE = re.compile(
     r"after the errors? )",
 )
 
+#: A POSITIONLESS fatal compiler-plugin failure. javac/maven emit it WITHOUT any
+#: ``File.java:`` anchor — canonical shapes:
+#:   * ``[ERROR] Failed to execute goal …maven-compiler-plugin…: Fatal error
+#:     compiling: error: release version 21 not supported -> [Help 1]``
+#:   * ``[ERROR] Fatal error compiling: error: invalid target release: 21``
+#: The tail after ``Fatal error compiling:`` is the authoritative message (the
+#: trailing ``-> [Help N]`` pointer is stripped). Without this catch the whole run
+#: had NO parseable diagnostic — the ``Failed to execute goal`` wrapper is
+#: summary-echo noise — and collapsed to an opaque environment_build_error that
+#: aborts the repair loop (java2 exprcalc dogfood, 2026-07-11). The C# adapter's
+#: positionless ``error CS####`` catch (``_CS_DIAG_NO_POS``) is the parity
+#: precedent for a positionless first-class diagnostic.
+_JAVA_FATAL_COMPILING_RE = re.compile(
+    r"\bFatal error compiling:\s*(?P<message>.+?)\s*(?:->\s*\[Help[^\]]*\]?\s*)?$"
+)
+
 
 # ── pure helpers ─────────────────────────────────────────────────────────────
 
@@ -209,12 +225,31 @@ def _parse_java_tool_output(
     """
     findings: list[ImplementOracleFinding] = []
     failed_paths: list[str] = []
+    seen_fatal: set[str] = set()
     for raw_line in (output or "").splitlines():
         line = raw_line.rstrip()
         if not line.strip():
             continue
         matched = _match_java_diagnostic(line)
         if matched is None:
+            # A positionless ``Fatal error compiling: …`` (toolchain-level compile
+            # failure, e.g. a --release the installed JDK cannot satisfy) is a
+            # first-class diagnostic even without a File.java anchor. Deduped by
+            # message: maven prints the same fatal in both the Failed-to-execute-
+            # goal wrapper and the bare echo form.
+            fatal = _JAVA_FATAL_COMPILING_RE.search(line)
+            if fatal is not None:
+                message = fatal.group("message").strip()
+                if message not in seen_fatal:
+                    seen_fatal.add(message)
+                    findings.append(
+                        ImplementOracleFinding(
+                            category=EVIDENCE_OTHER,
+                            code="JAVA_FATAL_COMPILING",
+                            message=f"[{tool}] Fatal error compiling: {message}",
+                            path=None,
+                        )
+                    )
             continue
         path_raw, message = matched
         category, code = _classify_java_diagnostic(message)

{codd_dev-3.26.0 → codd_dev-3.28.0}/codd/languages/profiles/java.yaml

@@ -282,6 +282,20 @@ scaffold:
     compiler_plugin_version: "3.13.0"
     build_helper_plugin_version: "3.6.0"
 
+  # Host-toolchain version clamp — the environment-continuation projection of
+  # toolchain materialization (v3.15.0 lineage) applied to scaffold DEFAULTS: a
+  # declared toolchain level must never EXCEED what the host provides, or the
+  # scaffolded pom demands a --release the installed JDK cannot satisfy and the
+  # implement oracle reds on "Fatal error compiling: error: release version N
+  # not supported" (java2 exprcalc dogfood, 2026-07-11). The probe runs once at
+  # scaffold time; min semantics (declared 21 + host 17 → 17; declared 11 +
+  # host 17 → 11); probe failure keeps the declared value (fail-open).
+  # CONTENT-only: clamped variables must never appear in a template `path`.
+  host_version_clamps:
+    java_version:
+      probe_argv: ["javac", "-version"]
+      version_pattern: '(\d+)'
+
   templates:
     # Single pom.xml: Java's package_root.kind=none means there is no C#-style
     # nested lib/test project split to enforce deliverable purity. Maven's own

{codd_dev-3.26.0 → codd_dev-3.28.0}/codd/project_types.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 import dataclasses
 import json
 import os
+import re
 import subprocess
 import sys
 from collections.abc import Callable, Mapping
@@ -2807,6 +2808,96 @@ def _generic_template_substitutions(
     return subst
 
 
+def _probe_host_toolchain_version(argv: tuple[str, ...], pattern: str) -> int | None:
+    """Best-effort host-toolchain MAJOR-version probe (``javac -version`` → ``17``).
+
+    Runs the profile-declared probe argv (10s timeout), searches ``pattern``
+    (first group = the major) across stdout+stderr (``javac -version`` printed to
+    stderr before JDK 9, stdout after), and returns the integer major — or
+    ``None`` on ANY failure (missing binary, timeout, no match, non-integer
+    group). The caller treats ``None`` as "keep the declared default"
+    (fail-open): the probe can only ever LOWER a doomed default, never introduce
+    a new failure mode.
+    """
+    try:
+        proc = subprocess.run(
+            list(argv), capture_output=True, text=True, timeout=10, check=False
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    match = re.search(pattern, f"{proc.stdout}\n{proc.stderr}")
+    if match is None:
+        return None
+    try:
+        return int(match.group(1))
+    except (IndexError, ValueError):
+        return None
+
+
+def _generic_template_host_clamps(
+    language: str | None,
+) -> dict[str, Mapping[str, Any]]:
+    """The profile's ``scaffold.host_version_clamps`` mapping (raw view), or ``{}``.
+
+    Read from ``raw`` like ``scaffold.defaults`` (the ScaffoldSpec dataclass
+    models only adapter/owned_files/templates; ``raw`` is the documented
+    later-phase escape hatch).
+    """
+    lang_profile = _resolve_kernel_language_profile(language)
+    raw = getattr(lang_profile, "raw", None) if lang_profile is not None else None
+    if isinstance(raw, Mapping):
+        raw_scaffold = raw.get("scaffold")
+        if isinstance(raw_scaffold, Mapping):
+            clamps = raw_scaffold.get("host_version_clamps")
+            if isinstance(clamps, Mapping):
+                return {
+                    str(k): v for k, v in clamps.items() if isinstance(v, Mapping)
+                }
+    return {}
+
+
+def _resolve_host_clamped_defaults(
+    defaults: Mapping[str, str], clamps: Mapping[str, Mapping[str, Any]]
+) -> tuple[dict[str, str], list[str]]:
+    """Clamp scaffold DEFAULTS to the host toolchain — the environment-continuation
+    projection of toolchain materialization (v3.15.0 lineage) applied to the
+    generic-template scaffold's substitution variables.
+
+    For each profile-declared clamp key: probe the host (profile-declared
+    argv+pattern); when the probed major is LOWER than the declared default's
+    leading integer, replace the default with the probed major (min semantics —
+    a declared ``21`` on a JDK-17 host scaffolds ``17``; a declared ``11`` on a
+    JDK-17 host stays ``11``). A probe failure or a non-numeric declared value
+    keeps the declared default (fail-open). Returns ``(resolved defaults,
+    human-readable clamp notes)`` — the notes ride the scaffold detail so a
+    clamp is never silent. CONTENT-only: the harness-owned PATH declaration
+    (:meth:`LayoutProfile.harness_owned_scaffold_paths`) substitutes UNCLAMPED
+    defaults, so a clamped variable must never appear in a template ``path``.
+    """
+    out = dict(defaults)
+    notes: list[str] = []
+    for key, spec in (clamps or {}).items():
+        declared = out.get(key)
+        if declared is None:
+            continue
+        declared_match = re.match(r"\s*(\d+)", str(declared))
+        if declared_match is None:
+            continue  # non-numeric default → this clamp cannot reason about it
+        declared_major = int(declared_match.group(1))
+        argv = tuple(str(a) for a in (spec.get("probe_argv") or ()) if str(a).strip())
+        if not argv:
+            continue
+        pattern = str(spec.get("version_pattern") or r"(\d+)")
+        probed = _probe_host_toolchain_version(argv, pattern)
+        if probed is None or probed >= declared_major:
+            continue
+        out[key] = str(probed)
+        notes.append(
+            f"host-clamped {key} {declared}→{probed} (probe: {' '.join(argv)})"
+        )
+    return out, notes
+
+
 def _apply_template_substitutions(text: str, subst: Mapping[str, str]) -> str:
     """Replace each ``{key}`` token with its value (replace-based, NOT ``str.format`` — so
     a template's literal braces never raise; mirrors the oracle gate's ``{package_name}``
@@ -2862,6 +2953,9 @@ def _scaffold_generic_template(
     code branch — a new generic-template stack is one YAML profile + the opt-in key.
     """
     templates, defaults, _owned = spec
+    defaults, clamp_notes = _resolve_host_clamped_defaults(
+        defaults, _generic_template_host_clamps(profile.language)
+    )
     subst = _generic_template_substitutions(profile, defaults)
     created: list[str] = []
     skipped: list[str] = []
@@ -2891,6 +2985,8 @@ def _scaffold_generic_template(
         f"generic-template: {len(created)} created, {len(skipped)} skipped "
         f"(package={profile.package_name})"
     )
+    if clamp_notes:
+        detail += "; " + "; ".join(clamp_notes)
     return ScaffoldResult(
         language=profile.language,
         created=tuple(created),

{codd_dev-3.26.0 → codd_dev-3.28.0}/codd/vb_marker_authenticity.py

@@ -3488,8 +3488,19 @@ _CSHARP_SKIP_ARG_RE = re.compile(r"\bSkip\s*=")
 #: ``(?<![A-Za-z0-9_.])`` so a member access ``foo.Assert.X`` (an unrelated SUT
 #: type that happens to expose an ``Assert`` member) does not masquerade as the
 #: framework's static ``Assert``.
+#: Optional generic type-argument list between the method name and ``(`` —
+#: ``Assert.IsType<ParseError>(x)``, ``Assert.Throws<T>(() => …)``, nested up to
+#: depth 3 (``Assert.IsType<Dictionary<string, List<int>>>(x)``). ``;{}`` are
+#: excluded so a malformed ``<`` can never swallow past a statement boundary.
+#: Without this, generic-only asserts were reported as "test with NO assertion"
+#: (false-RED observed on the csharp exprcalc greenfield dogfood, 2026-07-11).
+_CSHARP_GENERIC_ARGS = (
+    r"<[^<>;{}]*(?:<[^<>;{}]*(?:<[^<>;{}]*>[^<>;{}]*)*>[^<>;{}]*)*>"
+)
 _CSHARP_ASSERT_CALL_RE = re.compile(
-    r"(?<![A-Za-z0-9_.])Assert\.[A-Z][A-Za-z0-9_]*\s*\("
+    r"(?<![A-Za-z0-9_.])Assert\.[A-Z][A-Za-z0-9_]*\s*(?:"
+    + _CSHARP_GENERIC_ARGS
+    + r")?\s*\("
 )
 
 
@@ -5850,10 +5861,15 @@ def _java_resolve_module(importer_rel: str, spec: str, project_root: Path) -> Pa
 #: helper like ``HarnessAssertions.assertSuccess`` is exactly this shape. A bare
 #: CALL (``assertSuccess(result, "14.0");``) never matches: it has no
 #: return-type-shaped token before it, and it ends in ``;`` rather than ``{``.
+#: The return type accepts a QUALIFIED / nested name (``Expr.Literal``,
+#: ``Map.Entry<K, V>``) — dot-separated identifier segments — not just a single
+#: identifier: a same-file helper returning a nested type was otherwise
+#: invisible, resolving as ``unresolved_helper`` and false-redding real
+#: delegated assertions (java3 exprcalc dogfood, 2026-07-11).
 _JAVA_METHOD_DEF_RE = re.compile(
     r"(?<![A-Za-z0-9_.])(?:(?:public|protected|private|static|final|synchronized|"
     r"abstract|default|native|strictfp)\s+)*"
-    r"[A-Za-z_][A-Za-z0-9_$]*(?:<[^;{}]*?>)?(?:\[\])*\s+"
+    r"[A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)*(?:<[^;{}]*?>)?(?:\[\])*\s+"
     r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*\((?P<params>[^;{}]*)\)"
     r"(?:\s*throws\s+[A-Za-z0-9_.,\s<>]+?)?\s*\{",
     re.DOTALL,

{codd_dev-3.26.0 → codd_dev-3.28.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "3.26.0"
+version = "3.28.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"