code-constraints 0.1.0__py3-none-any.whl

code_constraints/lint/rules/cyclic_package_dependencies.py

@@ -0,0 +1,69 @@
+"""Rule: forbid cycles in the package-dependency graph."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, Violation
+
+
+@register("no-cyclic-package-dependencies")
+class NoCyclicPackageDependencies(Rule):
+    """No options. Walks the derived package-edge graph and reports every
+    elementary cycle as a single violation against the alphabetically-first
+    package in the cycle."""
+
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        graph = {src: set(t for t in tgts if t != src) for src, tgts in ctx.outgoing_pkg_refs.items()}
+        reported: set[tuple[str, ...]] = set()
+        for cycle in _find_cycles(graph):
+            cycle = tuple(cycle)
+            # Canonicalise: rotate so the lex-smallest node is first, so
+            # `[A,B,C]` and `[B,C,A]` collapse to one report.
+            min_idx = min(range(len(cycle)), key=lambda i: cycle[i])
+            normalised = cycle[min_idx:] + cycle[:min_idx]
+            if normalised in reported:
+                continue
+            reported.add(normalised)
+            head = normalised[0]
+            if self.is_ignored(head):
+                continue
+            chain = " -> ".join(list(normalised) + [normalised[0]])
+            yield self.emit(
+                qualified_name=head,
+                signature=chain,
+                message=self.message_for(cycle=chain)
+                or f"Cyclic package dependency: {chain}.",
+            )
+
+
+def _find_cycles(graph: dict[str, set[str]]) -> list[list[str]]:
+    """Tarjan-style enumeration of simple cycles. Keeps things small — only
+    used over a package graph whose node count is order-of-magnitudes smaller
+    than the class graph."""
+    cycles: list[list[str]] = []
+    nodes = list(graph.keys())
+    blocked: set[str] = set()
+    stack: list[str] = []
+
+    def dfs(node: str, start: str) -> bool:
+        found = False
+        stack.append(node)
+        blocked.add(node)
+        for nb in graph.get(node, set()):
+            if nb == start and len(stack) >= 1:
+                cycles.append(list(stack))
+                found = True
+            elif nb not in blocked:
+                if dfs(nb, start):
+                    found = True
+        stack.pop()
+        if found:
+            blocked.discard(node)
+        return found
+
+    for start in nodes:
+        blocked.clear()
+        dfs(start, start)
+    return cycles

code_constraints/lint/rules/dangling_classes.py

@@ -0,0 +1,98 @@
+"""Rule: flag classes that have no incoming references."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from code_constraints.core.model import Class, DiffStatus
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, Violation, match_any_glob
+
+# Framework base classes whose subclasses are instantiated by the framework
+# (Unity scenes, the editor, networking) rather than by project code, so they
+# legitimately have no incoming reference. Treated as entry points.
+_DEFAULT_FRAMEWORK_BASES = (
+    "MonoBehaviour",
+    "ScriptableObject",
+    "NetworkBehaviour",
+    "StateMachineBehaviour",
+    "Editor",
+    "EditorWindow",
+    "PropertyDrawer",
+    "ScriptableWizard",
+)
+
+
+@register("dangling-classes")
+class DanglingClasses(Rule):
+    """A class is "dangling" when no other project class references it
+    (no attribute, method signature, method-body usage, or base resolves to it)
+    and it isn't in the configured `entry_points` allow-list.
+
+    Classes that derive (transitively) from a framework base such as
+    `MonoBehaviour` are treated as entry points — the framework instantiates
+    them, so the absence of an in-project reference is expected. Override the
+    base list with the `framework_bases` option.
+
+    Snapshot rule: by default checks every class. If `scope: diff`, only checks
+    classes whose status is ADDED or CHANGED (i.e. don't fail on classes that
+    were already dangling before the change).
+    """
+
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        entry_points: list[str] = list(self.options.get("entry_points") or [])
+        framework_bases: set[str] = set(
+            self.options.get("framework_bases") or _DEFAULT_FRAMEWORK_BASES
+        )
+        for cls in ctx.project.iter_classes():
+            qn = cls.qualified_name
+            if self.is_ignored(qn):
+                continue
+            if self.scope == "diff" and ctx.has_diff:
+                if cls.status not in (DiffStatus.ADDED, DiffStatus.CHANGED):
+                    continue
+            # Skip removed ghost classes — they're already gone.
+            if cls.status == DiffStatus.REMOVED:
+                continue
+            if match_any_glob(qn, entry_points):
+                continue
+            if match_any_glob(cls.name, entry_points):
+                continue
+            if _derives_from_framework(cls, ctx, framework_bases):
+                continue
+            incoming = ctx.incoming_refs.get(qn, set())
+            # Self-references don't count as incoming.
+            incoming = {ref for ref in incoming if ref != qn}
+            if not incoming:
+                yield self.emit(
+                    qualified_name=qn,
+                    message=self.message_for(qualified_name=qn)
+                    or f"Class '{qn}' has no incoming references (dangling).",
+                    location=cls.location,
+                )
+
+
+def _derives_from_framework(
+    cls: Class, ctx: RuleContext, framework_bases: set[str]
+) -> bool:
+    """True if `cls` derives (directly or transitively through project
+    ancestors) from any base name in `framework_bases`."""
+    stack: list[str] = list(cls.bases)
+    seen: set[str] = set()
+    while stack:
+        base = stack.pop()
+        if base in seen:
+            continue
+        seen.add(base)
+        simple = base.split(".")[-1].split("<")[0]
+        if simple in framework_bases:
+            return True
+        parent = ctx.class_by_qn.get(base)
+        if parent is None:
+            for parent_qn, candidate in ctx.class_by_qn.items():
+                if parent_qn.split(".")[-1] == simple:
+                    parent = candidate
+                    break
+        if parent is not None:
+            stack.extend(parent.bases)
+    return False

code_constraints/lint/rules/forbidden_package_references.py

@@ -0,0 +1,47 @@
+"""Rule: forbid packages in `from` from referencing packages in `to`.
+
+Edges between packages are derived from class-level outgoing references
+(aggregated by containing package), matching the logic in
+`code_constraints.core.graph_model.build_package_graph`.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, Violation, match_any_glob
+
+
+@register("forbidden-package-references")
+class ForbiddenPackageReferences(Rule):
+    """Options:
+      from:  list[str] of package qualified-name globs
+      to:    list[str] of package qualified-name globs
+    """
+
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        from_patterns: list[str] = list(self.options.get("from") or [])
+        to_patterns: list[str] = list(self.options.get("to") or [])
+        if not from_patterns or not to_patterns:
+            return
+        for src_pkg, tgt_pkgs in ctx.outgoing_pkg_refs.items():
+            if self.is_ignored(src_pkg):
+                continue
+            if not match_any_glob(src_pkg, from_patterns):
+                continue
+            for tgt_pkg in tgt_pkgs:
+                if tgt_pkg == src_pkg:
+                    continue
+                if self.is_ignored(tgt_pkg):
+                    continue
+                if not match_any_glob(tgt_pkg, to_patterns):
+                    continue
+                yield self.emit(
+                    qualified_name=src_pkg,
+                    signature=f"->{tgt_pkg}",
+                    message=self.message_for(
+                        qualified_name=src_pkg, source=src_pkg, target=tgt_pkg
+                    )
+                    or f"Package '{src_pkg}' is not allowed to reference package '{tgt_pkg}'.",
+                )

code_constraints/lint/rules/forbidden_references.py

@@ -0,0 +1,48 @@
+"""Rule: forbid classes in `from` from referencing classes in `to`."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from code_constraints.core.model import DiffStatus
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, Violation, match_any_glob
+
+
+@register("forbidden-references")
+class ForbiddenReferences(Rule):
+    """Options:
+      from:  list[str] of qualified-name globs (source side)
+      to:    list[str] of qualified-name globs (target side)
+    """
+
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        from_patterns: list[str] = list(self.options.get("from") or [])
+        to_patterns: list[str] = list(self.options.get("to") or [])
+        if not from_patterns or not to_patterns:
+            return
+        for cls in ctx.project.iter_classes():
+            if cls.status == DiffStatus.REMOVED:
+                continue
+            src_qn = cls.qualified_name
+            if self.is_ignored(src_qn):
+                continue
+            if not match_any_glob(src_qn, from_patterns):
+                continue
+            if self.scope == "diff" and ctx.has_diff:
+                if cls.status not in (DiffStatus.ADDED, DiffStatus.CHANGED):
+                    continue
+            for tgt_qn in ctx.outgoing_refs.get(src_qn, set()):
+                if self.is_ignored(tgt_qn):
+                    continue
+                if not match_any_glob(tgt_qn, to_patterns):
+                    continue
+                yield self.emit(
+                    qualified_name=src_qn,
+                    signature=f"->{tgt_qn}",
+                    message=self.message_for(
+                        qualified_name=src_qn, source=src_qn, target=tgt_qn
+                    )
+                    or f"'{src_qn}' is not allowed to reference '{tgt_qn}'.",
+                    location=cls.location,
+                )

code_constraints/lint/rules/frozen_members.py

@@ -0,0 +1,67 @@
+"""Rule: forbid changes (add/remove/change) to attributes or operations on
+a selected set of classes."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from code_constraints.core.model import DiffStatus
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, Violation, match_any_glob
+
+
+@register("frozen-members")
+class FrozenMembers(Rule):
+    """Options:
+      classes:  list[str] of qualified-name globs identifying the locked classes
+      members:  optional list[str] of member-name or signature globs (default: all)
+      kinds:    optional list, subset of ["attribute", "operation"] (default: both)
+    """
+
+    default_scope = "diff"
+
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        if not ctx.has_diff:
+            return
+        class_patterns: list[str] = list(self.options.get("classes") or ["*"])
+        member_patterns: list[str] = list(self.options.get("members") or ["*"])
+        kinds: list[str] = list(self.options.get("kinds") or ["attribute", "operation"])
+
+        for cls in ctx.project.iter_classes():
+            if self.is_ignored(cls.qualified_name):
+                continue
+            if not match_any_glob(cls.qualified_name, class_patterns):
+                continue
+            members: list[tuple[str, object]] = []
+            if "attribute" in kinds:
+                members.extend(("attribute", a) for a in cls.attributes)
+            if "operation" in kinds:
+                members.extend(("operation", o) for o in cls.operations)
+            for kind, member in members:
+                status = getattr(member, "status", DiffStatus.UNCHANGED)
+                if status == DiffStatus.UNCHANGED:
+                    continue
+                name = getattr(member, "name", "")
+                sig = member.signature() if hasattr(member, "signature") else name
+                if not (
+                    match_any_glob(name, member_patterns)
+                    or match_any_glob(sig, member_patterns)
+                ):
+                    continue
+                action = {
+                    DiffStatus.ADDED: "added",
+                    DiffStatus.REMOVED: "removed",
+                    DiffStatus.CHANGED: "changed",
+                }.get(status, str(status))
+                yield self.emit(
+                    qualified_name=cls.qualified_name,
+                    signature=f"{kind}:{sig}",
+                    message=self.message_for(
+                        qualified_name=cls.qualified_name,
+                        member=sig,
+                        kind=kind,
+                        action=action,
+                    )
+                    or f"{kind.capitalize()} '{sig}' on '{cls.qualified_name}' was {action}.",
+                    location=cls.location,
+                )

code_constraints/lint/rules/frozen_rules.py

@@ -0,0 +1,105 @@
+"""Rule: architectural-rule tags present in the baseline must not be removed
+or modified in the current model.
+
+This is the *drift* half of architectural-rule enforcement (Engine A). It never
+inspects method bodies — it only compares the tag sets recorded on the baseline
+(OLD) elements against the current (NEW) ones. The semantic question "does the
+code actually obey the tag" is the job of the decoupled `cdec enforce` command.
+
+A frozen tag is satisfied only when an identical tag (same name, same args, same
+kwargs) still exists on the same element. Removing a tag or weakening its
+parameters therefore fires — exactly the drift the user wants CI to block.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from code_constraints.core.model import Class, Operation
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, Violation, match_any_glob
+
+
+@register("frozen-rules")
+class FrozenRules(Rule):
+    """Options:
+      classes:  list[str] of qualified-name globs identifying locked classes
+                (default: all classes)
+
+    Scope must be `diff` — it needs a baseline to compare against.
+    """
+
+    default_scope = "diff"
+
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        if not ctx.has_diff:
+            return
+        class_patterns: list[str] = list(self.options.get("classes") or ["*"])
+
+        for qn, base_cls in ctx.baseline_class_by_qn.items():
+            if self.is_ignored(qn):
+                continue
+            if not match_any_glob(qn, class_patterns):
+                continue
+            cur_cls = ctx.class_by_qn.get(qn)
+            if cur_cls is None:
+                # Whole class removed — that's `no-removed-classes`' job.
+                continue
+
+            yield from self._check_element(
+                qn, signature=None, base=base_cls, cur=cur_cls, location=cur_cls.location
+            )
+
+            cur_ops = {o.signature(): o for o in cur_cls.operations}
+            for base_op in base_cls.operations:
+                if not base_op.rules:
+                    continue
+                cur_op = cur_ops.get(base_op.signature())
+                if cur_op is None:
+                    # Operation removed — `frozen-members` handles that.
+                    continue
+                yield from self._check_element(
+                    qn,
+                    signature=f"operation:{base_op.signature()}",
+                    base=base_op,
+                    cur=cur_op,
+                    location=cur_cls.location,
+                )
+
+    def _check_element(
+        self,
+        qn: str,
+        *,
+        signature: str | None,
+        base: Class | Operation,
+        cur: Class | Operation,
+        location,
+    ) -> Iterable[Violation]:
+        cur_rules = list(cur.rules)
+        cur_by_name = {r.name: r for r in cur_rules}
+        where = signature.split(":", 1)[1] if signature else qn
+        for base_rule in base.rules:
+            if base_rule in cur_rules:
+                continue  # identical tag still present
+            if base_rule.name in cur_by_name:
+                action = "weakened"
+                detail = (
+                    f"architectural tag @{base_rule.name} on '{where}' was weakened "
+                    f"(params changed from the baseline)."
+                )
+            else:
+                action = "removed"
+                detail = f"architectural tag @{base_rule.name} on '{where}' was removed."
+            sig = f"{signature or 'class'}|@{base_rule.name}"
+            yield self.emit(
+                qualified_name=qn,
+                signature=sig,
+                message=self.message_for(
+                    qualified_name=qn,
+                    rule=base_rule.name,
+                    member=where,
+                    action=action,
+                )
+                or detail,
+                location=location,
+            )

code_constraints/lint/rules/implementation_locks.py

@@ -0,0 +1,156 @@
+"""Rule: a frozen implementation may not change at all.
+
+The adapter for the implementation-freeze engine (`code_constraints.lock`,
+"Engine C"). It answers a narrower question than every other rule here — not
+"did the design drift" or "does the code obey its tag", but "did this body
+change at all" — by comparing an AST-derived digest against the approved digest
+recorded in the `locks:` section of `.cdec/rules.yaml`.
+
+Two things about this rule are deliberately unlike the others.
+
+**Its violations cannot be excepted.** `waivable=False`, so
+`cdec exceptions allow` refuses a lock key and prints the privileged command
+instead. Accepting a change to frozen code is
+`cdec check --automatic-exceptions locks --force`, which rewrites the ledger and
+therefore shows up as a reviewable diff. Route it through the ordinary exception
+list and that reviewability is gone.
+
+**It carries its own baseline.** `accept_current_state` records digests for
+newly tagged elements — safe for anyone to run, because without `force` it can
+only ever *add* a lock, never overwrite evidence that a locked body changed.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterable
+
+from code_constraints.core.model import SourceLocation
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, RuleSkipped, Violation
+
+if TYPE_CHECKING:
+    from code_constraints.lock import LockOptions
+
+#: Languages with an AST fingerprinter. Freezing a body needs one.
+LOCKABLE_LANGUAGES = ("python", "csharp", "odin", "lua", "julia")
+
+
+@register("implementation-locks")
+class ImplementationLocks(Rule):
+    """Options:
+      targets:            list[str] of qualified-name globs to freeze WITHOUT a
+                          tag in the source, e.g. ["orders.pricing.**"].
+      include_docstrings: bool — do docstring edits count as implementation
+                          changes? (default false)
+    """
+
+    supports_auto_accept = True
+
+    # ---- configuration ----
+    def lock_options(self) -> "LockOptions":
+        from code_constraints.lock import LockOptions
+
+        targets = self.options.get("targets") or []
+        if not isinstance(targets, list):
+            raise RuleSkipped(f"{self.rule_id}: 'targets' must be a list of globs")
+        return LockOptions(
+            include_docstrings=bool(self.options.get("include_docstrings", False)),
+            patterns=[str(t) for t in targets],
+        )
+
+    def _resolve(self, ctx: RuleContext) -> tuple[Path, str, Path]:
+        """(source, language, config_dir), or `RuleSkipped` explaining why not.
+
+        Returns the values rather than just validating them so the caller — and
+        the type checker — both see them narrowed.
+        """
+        if ctx.source is None or not ctx.language:
+            raise RuleSkipped("no source tree resolved")
+        if ctx.language not in LOCKABLE_LANGUAGES:
+            raise RuleSkipped(
+                f"{ctx.language} has no AST fingerprinter; implementation locks "
+                f"support {', '.join(LOCKABLE_LANGUAGES)}"
+            )
+        if ctx.config_dir is None:
+            raise RuleSkipped("no .cdec/ folder resolved to read the lock ledger from")
+        return ctx.source, ctx.language, ctx.config_dir
+
+    # ---- checking ----
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        source, language, config_dir = self._resolve(ctx)
+        from code_constraints.lock import UnsupportedLockLanguage, check_locks, load_locks
+
+        options = self.lock_options()
+        entries = load_locks(config_dir)
+        try:
+            report = check_locks(source, language, entries, options)
+        except UnsupportedLockLanguage as exc:
+            raise RuleSkipped(str(exc)) from exc
+
+        for violation in report.violations:
+            if self.is_ignored(violation.target):
+                continue
+            yield Violation(
+                rule_id=self.rule_id,
+                severity=self.severity,
+                qualified_name=violation.target,
+                message=self.message_for(
+                    qualified_name=violation.target,
+                    kind=violation.kind,
+                    message=violation.message,
+                )
+                or violation.message,
+                location=(
+                    SourceLocation(file=violation.file, start_line=violation.line, end_line=violation.line)
+                    if violation.file
+                    else None
+                ),
+                key_engine="lock",
+                key_rule=violation.kind,
+                waivable=False,
+            )
+
+    # ---- baselining ----
+    def accept_current_state(self, ctx: RuleContext, *, force: bool = False) -> list[str]:
+        """Record digests for locked elements — `--automatic-exceptions locks`.
+
+        Without `force` this only *adds* entries for newly tagged code, so it is
+        safe for anyone to run and can never erase the evidence that a frozen
+        implementation changed. `force` is the lead-gated path that accepts a
+        drifted body and prunes released entries.
+        """
+        source, language, config_dir = self._resolve(ctx)
+        from code_constraints.lock import UnsupportedLockLanguage, load_locks, update_locks, write_locks
+
+        options = self.lock_options()
+        entries = load_locks(config_dir)
+        try:
+            updated, result = update_locks(
+                source, language, entries, options, force=force
+            )
+        except UnsupportedLockLanguage as exc:
+            raise RuleSkipped(str(exc)) from exc
+
+        lines: list[str] = []
+        for entry in result.added:
+            lines.append(f"  + locked   {entry.target}  ({entry.kind}, {entry.digest[:12]})")
+        for entry in result.updated:
+            lines.append(f"  ~ rebased  {entry.target}  ({entry.kind}, {entry.digest[:12]})")
+        for entry in result.removed:
+            lines.append(f"  - released {entry.target}")
+        for blocked in result.blocked:
+            lines.append(
+                f"  ! CHANGED  {blocked.target} — left untouched; re-run with --force "
+                f"to accept it as the new baseline (a lead's call)."
+            )
+        for stale in result.stale:
+            lines.append(
+                f"  ! STALE    {stale.target} — still locked but its element is gone or "
+                f"has lost its tag; restore it, or drop it with --force."
+            )
+        if result.changed:
+            lines.append(f"  wrote {len(updated)} lock(s) to {write_locks(config_dir, updated.values())}")
+        elif not lines:
+            lines.append("  every lock is already recorded; nothing to write.")
+        return lines

code_constraints/lint/rules/layer_dependencies.py

@@ -0,0 +1,92 @@
+"""Rule: enforce allowed dependency directions between architectural layers.
+
+Classes declare their layer with the `@layer("name")` tag. This rule takes an
+allowed-direction matrix and flags any reference from a class in layer A to a
+class in layer B when B is not in A's allow-list. Same-layer references are
+always permitted.
+
+Pure architectural check (Engine A): it reads tags + the structural reference
+graph (`ctx.outgoing_refs`); it never inspects method bodies.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from code_constraints.core.model import DiffStatus
+from code_constraints.lint.rules import register
+from code_constraints.lint.rules.base import Rule, RuleContext, Violation
+
+_LAYER_RULE_ID = "layer"
+
+
+def _layer_of(cls) -> str | None:
+    """The layer name declared by `@layer("name")`, or None.
+
+    The first positional arg is the layer name as raw source text, so it may be
+    wrapped in quotes (`'domain'` from Python, `"domain"` from C#) — strip them.
+    """
+    for rule in cls.rules:
+        if rule.name == _LAYER_RULE_ID and rule.args:
+            return rule.args[0].strip().strip("'\"")
+    return None
+
+
+@register("layer-dependencies")
+class LayerDependencies(Rule):
+    """Options:
+      allow:  mapping of layer -> list of layers it MAY depend on. A class whose
+              layer is not a key in `allow` is left unconstrained. An empty list
+              means the layer may not depend on any *other* layer.
+    """
+
+    def check(self, ctx: RuleContext) -> Iterable[Violation]:
+        allow_raw = self.options.get("allow") or {}
+        allow: dict[str, set[str]] = {
+            str(k): {str(v) for v in (vals or [])} for k, vals in allow_raw.items()
+        }
+        if not allow:
+            return
+
+        layer_by_qn: dict[str, str] = {}
+        for cls in ctx.project.iter_classes():
+            if cls.status == DiffStatus.REMOVED:
+                continue
+            lyr = _layer_of(cls)
+            if lyr is not None:
+                layer_by_qn[cls.qualified_name] = lyr
+
+        for cls in ctx.project.iter_classes():
+            if cls.status == DiffStatus.REMOVED:
+                continue
+            src_qn = cls.qualified_name
+            if self.is_ignored(src_qn):
+                continue
+            src_layer = layer_by_qn.get(src_qn)
+            if src_layer is None or src_layer not in allow:
+                continue
+            allowed = allow[src_layer]
+            for tgt_qn in ctx.outgoing_refs.get(src_qn, set()):
+                if self.is_ignored(tgt_qn):
+                    continue
+                tgt_layer = layer_by_qn.get(tgt_qn)
+                if tgt_layer is None or tgt_layer == src_layer:
+                    continue
+                if tgt_layer in allowed:
+                    continue
+                yield self.emit(
+                    qualified_name=src_qn,
+                    signature=f"{src_layer}->{tgt_layer}:{tgt_qn}",
+                    message=self.message_for(
+                        qualified_name=src_qn,
+                        source=src_qn,
+                        target=tgt_qn,
+                        source_layer=src_layer,
+                        target_layer=tgt_layer,
+                    )
+                    or (
+                        f"layer '{src_layer}' may not depend on layer "
+                        f"'{tgt_layer}' ('{src_qn}' -> '{tgt_qn}')."
+                    ),
+                    location=cls.location,
+                )