chipgraph 0.1.0__py3-none-any.whl

chipgraph/checks/_common.py

@@ -0,0 +1,268 @@
+"""Shared helpers for built-in checks: template/glob matching, file walking, hashing, timing.
+
+Nothing here knows about a specific check; `layout.py`, `filelist.py` and `generated.py`
+build on top of this module.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import time
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from chipgraph.core.contracts import CheckResult, CheckSpec, Issue
+
+# ---------------------------------------------------------------------------
+# Argument validation
+# ---------------------------------------------------------------------------
+
+
+class ArgError(Exception):
+    """Raised for invalid `CheckSpec.args`; the caller turns this into an `error` result."""
+
+
+def require_str(args: Mapping[str, Any], key: str) -> str:
+    """Return `args[key]` as a string, or raise `ArgError`."""
+    if key not in args:
+        raise ArgError(f"args[{key!r}] is required")
+    val = args[key]
+    if not isinstance(val, str):
+        raise ArgError(f"args[{key!r}] must be a string")
+    return val
+
+
+def require_dict(args: Mapping[str, Any], key: str) -> dict[str, Any]:
+    """Return `args[key]` as a dict, or raise `ArgError`."""
+    if key not in args:
+        raise ArgError(f"args[{key!r}] is required")
+    val = args[key]
+    if not isinstance(val, dict):
+        raise ArgError(f"args[{key!r}] must be a mapping")
+    return val
+
+
+def optional_bool(args: Mapping[str, Any], key: str, default: bool) -> bool:
+    """Return `args[key]` as a bool, defaulting to `default`, or raise `ArgError`."""
+    val = args.get(key, default)
+    if not isinstance(val, bool):
+        raise ArgError(f"args[{key!r}] must be a boolean")
+    return val
+
+
+def optional_str(args: Mapping[str, Any], key: str, default: str) -> str:
+    """Return `args[key]` as a string, defaulting to `default`, or raise `ArgError`."""
+    val = args.get(key, default)
+    if not isinstance(val, str):
+        raise ArgError(f"args[{key!r}] must be a string")
+    return val
+
+
+def require_list_of_str(args: Mapping[str, Any], key: str) -> list[str]:
+    """Return `args[key]` as a list of strings, or raise `ArgError`."""
+    if key not in args:
+        raise ArgError(f"args[{key!r}] is required")
+    return _as_list_of_str(args[key], key)
+
+
+def optional_list_of_str(args: Mapping[str, Any], key: str) -> list[str]:
+    """Return `args[key]` as a list of strings, defaulting to `[]`, or raise `ArgError`."""
+    if key not in args:
+        return []
+    return _as_list_of_str(args[key], key)
+
+
+def _as_list_of_str(val: Any, key: str) -> list[str]:
+    if not isinstance(val, list) or not all(isinstance(v, str) for v in val):
+        raise ArgError(f"args[{key!r}] must be a list of strings")
+    return list(val)
+
+
+def str_or_list_of_str(val: Any, where: str) -> list[str]:
+    """Normalize a `str | list[str]` value into a list of strings, or raise `ArgError`."""
+    if isinstance(val, str):
+        return [val]
+    if isinstance(val, list) and all(isinstance(v, str) for v in val):
+        return list(val)
+    raise ArgError(f"{where} must be a string or a list of strings")
+
+
+# ---------------------------------------------------------------------------
+# Template and glob matching
+#
+# A template is a repo-relative path pattern with two kinds of wildcards:
+#   - `{name}` matches exactly one path segment (or part of one); repeating the same
+#     name later in the template requires the same value (a backreference).
+#   - `**` (as a whole path segment, e.g. `a/**/b.sv` or `vendor/**`) matches any depth,
+#     including zero.
+#   - `*` and `?` behave as usual within a single path segment.
+# ---------------------------------------------------------------------------
+
+_PLACEHOLDER_TOKEN = re.compile(r"\{([a-zA-Z_][a-zA-Z0-9_.]*)\}")
+_GLOB_SPECIAL = re.compile(r"(\*\*/|/\*\*|\*\*|\*|\?)")
+
+
+def _sanitize(name: str) -> str:
+    """A valid, collision-resistant Python regex group name for placeholder `name`."""
+    return "p_" + name.replace(".", "_")
+
+
+def _glob_literal_to_regex(text: str) -> str:
+    """Translate glob wildcards (`**`, `*`, `?`) in a literal chunk of text to a regex body."""
+    parts = _GLOB_SPECIAL.split(text)
+    out: list[str] = []
+    for part in parts:
+        if part == "**/":
+            out.append("(?:.*/)?")
+        elif part == "/**":
+            out.append("(?:/.*)?")
+        elif part == "**":
+            out.append(".*")
+        elif part == "*":
+            out.append("[^/]*")
+        elif part == "?":
+            out.append("[^/]")
+        else:
+            out.append(re.escape(part))
+    return "".join(out)
+
+
+def glob_to_regex(pattern: str) -> re.Pattern[str]:
+    """Compile a glob pattern (`**`, `*`, `?`) into a regex matching a whole repo-relative path."""
+    return re.compile("^" + _glob_literal_to_regex(pattern) + "$")
+
+
+@dataclass(frozen=True)
+class CompiledTemplate:
+    """A path template compiled to a regex, with its placeholder names in first-seen order."""
+
+    regex: re.Pattern[str]
+    names: tuple[str, ...]
+
+    def match(self, path: str) -> dict[str, str] | None:
+        """Match `path` (a repo-relative POSIX path) against this template.
+
+        Returns a mapping of placeholder name to captured value, or `None` if `path`
+        does not match.
+        """
+        m = self.regex.fullmatch(path)
+        if m is None:
+            return None
+        groups = m.groupdict()
+        return {name: groups[_sanitize(name)] for name in self.names}
+
+
+def compile_template(template: str) -> CompiledTemplate:
+    """Compile a path template (placeholders, `**`, `*`, `?`) into a `CompiledTemplate`."""
+    tokens = _PLACEHOLDER_TOKEN.split(template)
+    seen: set[str] = set()
+    order: list[str] = []
+    parts: list[str] = []
+    is_placeholder = False
+    for tok in tokens:
+        if is_placeholder:
+            sanitized = _sanitize(tok)
+            if tok in seen:
+                parts.append(f"(?P={sanitized})")
+            else:
+                seen.add(tok)
+                order.append(tok)
+                parts.append(f"(?P<{sanitized}>[^/]+)")
+        else:
+            parts.append(_glob_literal_to_regex(tok))
+        is_placeholder = not is_placeholder
+    regex = re.compile("^" + "".join(parts) + "$")
+    return CompiledTemplate(regex=regex, names=tuple(order))
+
+
+# ---------------------------------------------------------------------------
+# Repo file walking
+# ---------------------------------------------------------------------------
+
+_ALWAYS_SKIP_DIR = ".git"
+_STATE_DIR = (".chipgraph", "state")
+
+
+def iter_repo_files(root: Path) -> list[str]:
+    """List every file under `root` as a repo-relative POSIX path, sorted.
+
+    Always skips `.git` and `.chipgraph/state`, regardless of check configuration.
+    """
+    out: list[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        rel_dir = Path(dirpath).relative_to(root)
+        rel_parts = () if rel_dir == Path() else rel_dir.parts
+        dirnames[:] = [
+            d for d in dirnames if d != _ALWAYS_SKIP_DIR and (*rel_parts, d) != _STATE_DIR
+        ]
+        for filename in filenames:
+            rel = "/".join((*rel_parts, filename)) if rel_parts else filename
+            out.append(rel)
+    return sorted(out)
+
+
+def norm_path(path: Path) -> Path:
+    """Normalize `path` (collapse `..`/`.`) without resolving symlinks."""
+    return Path(os.path.normpath(str(path)))
+
+
+def to_repo_rel(path: Path, root: Path) -> str | None:
+    """Return `path` as a repo-relative POSIX string, or `None` if it is outside `root`."""
+    try:
+        return norm_path(path).relative_to(norm_path(root)).as_posix()
+    except ValueError:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Hashing and idempotency
+# ---------------------------------------------------------------------------
+
+
+def sha256_bytes(data: bytes) -> str:
+    """Return the hex sha256 digest of `data`."""
+    return hashlib.sha256(data).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    """Return the hex sha256 digest of the content of the file at `path`."""
+    return sha256_bytes(path.read_bytes())
+
+
+def canonical_json(obj: Any) -> str:
+    """Render `obj` as canonical JSON (sorted keys, no extra whitespace)."""
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"), default=str)
+
+
+def compute_idempotency_key(
+    check_id: str,
+    args: Mapping[str, Any],
+    file_hashes: Iterable[tuple[str, str]],
+) -> str:
+    """A stable idempotency key over the check id, its args, and the files it read.
+
+    `file_hashes` is an iterable of `(repo_relative_path, content_sha256)` pairs; it is
+    sorted here so caller order does not matter.
+    """
+    payload = {
+        "check_id": check_id,
+        "args": args,
+        "files": sorted(file_hashes),
+    }
+    return sha256_bytes(canonical_json(payload).encode("utf-8"))
+
+
+def error_result(spec: CheckSpec, msg: str, start: float, *, rule: str = "args") -> CheckResult:
+    """Build an `error` `CheckResult` for a bad-args failure, timed from `start`."""
+    return CheckResult(
+        check_id=spec.id,
+        status="error",
+        issues=(Issue(msg=msg, severity="error", rule=rule),),
+        duration_s=time.monotonic() - start,
+        idempotency_key=compute_idempotency_key(spec.id, spec.args, ()),
+    )

chipgraph/checks/_cross.py

@@ -0,0 +1,96 @@
+"""Shared helpers for the model-based cross checks (M1-07 part A, DESIGN.md 4.4/4.8).
+
+Everything a `spec_schema`/`cross_chip`/`ports_diff` check needs beyond `_model.py`:
+building the `error` result when the model is missing, turning a loaded model plus a
+list of `Issue`s into a `pass`/`fail` `CheckResult`, and small model helpers (the block
+key a scope maps to, the entities owned by a block).
+"""
+
+from __future__ import annotations
+
+import time
+
+from chipgraph.checks._common import compute_idempotency_key, error_result
+from chipgraph.checks._model import LoadedModel, ModelUnavailable, block_param, load_model
+from chipgraph.core.contracts import CheckResult, CheckSpec, Issue
+from chipgraph.core.contracts.types import CheckStatus
+from chipgraph.core.model.model import DesignModel
+from chipgraph.core.plugin_api.types import ToolContext
+
+
+def load_model_or_skip(
+    spec: CheckSpec, ctx: ToolContext, start: float
+) -> LoadedModel | CheckResult:
+    """Load the Design Model, or return an `error` `CheckResult` when it is missing.
+
+    The cross checks never build the model themselves (`_model.py` docstring); a missing
+    store means `chipgraph ingest` has not run yet, and the message says so. The same
+    rule holds for every model-based check (`trace`, `connect`, `hardcode` too).
+    """
+    try:
+        return load_model(ctx.repo_root)
+    except ModelUnavailable as exc:
+        return error_result(spec, str(exc), start, rule="model")
+
+
+def result_from_issues(
+    spec: CheckSpec,
+    issues: list[Issue],
+    loaded: LoadedModel,
+    start: float,
+) -> CheckResult:
+    """Build a deterministic `pass`/`fail` `CheckResult` from model-derived issues.
+
+    Issues are sorted by (file, line, rule, msg) so the same model always yields the same
+    order. The idempotency key is over the check id, args and the model's build-inputs
+    hash: the same ingested model gives the same key, and re-ingesting after an edit
+    changes it. A result is `fail` when any issue is an `error`, else `pass` (an `info`
+    issue does not fail a check).
+    """
+    ordered = sort_issues(issues)
+    key = compute_idempotency_key(spec.id, spec.args, [("<model>", loaded.build_inputs_hash or "")])
+    status: CheckStatus = "fail" if any(i.severity == "error" for i in ordered) else "pass"
+    return CheckResult(
+        check_id=spec.id,
+        status=status,
+        issues=tuple(ordered),
+        duration_s=time.monotonic() - start,
+        idempotency_key=key,
+    )
+
+
+def sort_issues(issues: list[Issue]) -> list[Issue]:
+    """Return `issues` in a stable, deterministic order."""
+    return sorted(issues, key=lambda i: (i.file or "", i.line or 0, i.rule, i.msg))
+
+
+def block_key(name: str) -> str:
+    """The model key of the block named `name` (`block:<name>`)."""
+    return f"block:{name}"
+
+
+def scope_block_keys(model: DesignModel, block: str) -> set[str]:
+    """The block key `block` scopes to, plus its instances (`instance_of` -> it).
+
+    A `--block timer` run covers `block:timer` and every `block:<instance>` that is an
+    `instance_of` it (D38: `timer_0`, `timer_1`), so an issue about an instance of the
+    scoped IP is still reported.
+    """
+    ip_key = block_key(block)
+    keys = {ip_key}
+    for rel in model.get_relations(dst=ip_key, kind="instance_of"):
+        keys.add(rel.src)
+    return keys
+
+
+__all__ = [
+    "LoadedModel",
+    "ModelUnavailable",
+    "block_key",
+    "block_param",
+    "load_model",
+    "load_model_or_skip",
+    "result_from_issues",
+    "scope_block_keys",
+    "sort_issues",
+]

chipgraph/checks/_model.py

@@ -0,0 +1,64 @@
+"""Shared helpers for the model-based cross checks (M1-07, DESIGN.md 4.4).
+
+Cross checks read the Design Model that `chipgraph ingest` wrote to the project's
+`ModelStore`; they never run extractors themselves. A missing store is a check `error`
+telling the user to run `chipgraph ingest` first.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+
+from chipgraph.core.model.model import DesignModel
+from chipgraph.core.model.store import ModelStore, default_model_db_path
+from chipgraph.core.plugin_api.types import ToolContext
+
+
+class ModelUnavailable(Exception):
+    """Raised when there is no Design Model to check (ingest has not run)."""
+
+
+@dataclass(frozen=True, slots=True)
+class LoadedModel:
+    """The stored model, plus the hash of the inputs it was built from."""
+
+    model: DesignModel
+    build_inputs_hash: str | None
+    db_path: Path
+
+
+def load_model(repo_root: Path) -> LoadedModel:
+    """Read the model `chipgraph ingest` wrote for `repo_root`.
+
+    Raises `ModelUnavailable` with a message naming the command to run when the store
+    does not exist yet.
+    """
+    db_path = default_model_db_path(repo_root)
+    if not db_path.is_file():
+        raise ModelUnavailable(
+            f"no Design Model at {db_path}; run `chipgraph ingest` before the cross checks"
+        )
+    model = ModelStore(db_path).read()
+    return LoadedModel(model=model, build_inputs_hash=_build_inputs_hash(db_path), db_path=db_path)
+
+
+def block_param(ctx: ToolContext) -> str | None:
+    """The block this check run is scoped to (`chipgraph check --block`), if any."""
+    value = ctx.params.get("block")
+    return value if isinstance(value, str) and value else None
+
+
+def _build_inputs_hash(db_path: Path) -> str | None:
+    conn = sqlite3.connect(db_path)
+    try:
+        row = conn.execute("SELECT value FROM meta WHERE key = 'build_inputs_hash'").fetchone()
+    except sqlite3.Error:
+        return None
+    finally:
+        conn.close()
+    return str(row[0]) if row else None
+
+
+__all__ = ["LoadedModel", "ModelUnavailable", "block_param", "load_model"]

chipgraph/checks/_naming_pyslang.py

@@ -0,0 +1,235 @@
+"""Classify the identifiers a SystemVerilog file *declares*, using pyslang's syntax tree.
+
+This is the point of the `naming` check: pyslang knows whether a name is a module, a
+port, a parameter, a signal or a memory; a regex over text only guesses. We parse a file
+into a syntax tree (no elaboration, so a single file with missing packages still parses)
+and walk it, yielding one `Decl` per declared identifier with its object kind and line.
+
+Only *declarations* are yielded. A reference like `.clk_i(...)` (a connection to a
+vendored module's port), `pkg::Member`, `$clog2` or `` `MACRO`` names something the file
+does not own, so it is never classified here -- matching the reference checker's rule
+that we only name what we declare.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from pyslang.syntax import SyntaxKind, SyntaxNode, SyntaxTree
+
+
+@dataclass(frozen=True, slots=True)
+class Decl:
+    """One declared identifier: its object kind, its name, and its 1-based line."""
+
+    kind: str
+    name: str
+    line: int
+
+
+@dataclass(frozen=True, slots=True)
+class ParseFailure:
+    """A parse error, with a 1-based line when the parser could locate one."""
+
+    line: int | None
+    message: str
+
+
+def parse_text(text: str, name: str = "source") -> Any:
+    """Parse `text` into a pyslang syntax tree (syntax only, no elaboration)."""
+    return SyntaxTree.fromText(text, name)
+
+
+def parse_file(path: Path) -> Any:
+    """Parse the file at `path` into a pyslang syntax tree (syntax only, no elaboration)."""
+    return SyntaxTree.fromText(path.read_text(errors="ignore"), path.as_posix())
+
+
+def parse_errors(tree: Any) -> list[ParseFailure]:
+    """Real syntax errors of `tree`, as `ParseFailure`s (never raised).
+
+    Only `Parser`- and `Lexer`-subsystem error diagnostics count: those are genuine
+    malformed SystemVerilog. `Preprocessor` diagnostics (a `` `include`` we cannot open,
+    an `` `UNKNOWN_MACRO`` directive defined in a package we were not given) are expected
+    when a single file is parsed without its include paths -- the whole point of a
+    syntax-only, single-file parse -- and are ignored, matching the reference checker,
+    which does no preprocessing at all.
+    """
+    sm = tree.sourceManager
+    out: list[ParseFailure] = []
+    for diag in tree.diagnostics:
+        if not diag.isError():
+            continue
+        subsystem = str(diag.code.getSubsystem()).rsplit(".", 1)[-1]
+        if subsystem not in ("Parser", "Lexer"):
+            continue
+        loc = getattr(diag, "location", None)
+        line = sm.getLineNumber(loc) if loc else None
+        out.append(ParseFailure(line=line, message=str(diag.code)))
+    return out
+
+
+def declared_identifiers(tree: Any) -> list[Decl]:
+    """Every identifier declared in `tree`, classified by object kind, sorted by line.
+
+    The walk dispatches on syntax node kind. It handles: module/interface/program/package
+    headers; ANSI and non-ANSI port declarations; parameter vs localparam; enum members;
+    variable/net declarations (a declarator with an unpacked dimension is a `memory`, else
+    a `signal`); genvars; and hierarchy instantiations.
+    """
+    sm = tree.sourceManager
+
+    def line_of(token: Any) -> int:
+        return int(sm.getLineNumber(token.location))
+
+    out: list[Decl] = []
+
+    def emit(kind: str, token: Any) -> None:
+        name = token.valueText
+        if name:
+            out.append(Decl(kind=kind, name=name, line=line_of(token)))
+
+    K = SyntaxKind
+    # Only a `module` declaration is checked for the module-name rule. Interface, program
+    # and package names have no rule in the source document and are not checked by the
+    # reference, so we do not classify them here.
+    header_kinds = {K.ModuleHeader}
+
+    def visit(node: Any) -> None:
+        kind = getattr(node, "kind", None)
+        if kind is None:
+            return
+
+        if kind in header_kinds:
+            _emit_header_name(node, "module", emit)
+        elif kind == K.ImplicitAnsiPort or kind == K.ExplicitAnsiPort:
+            _emit_declarator(node, "port", emit)
+        elif kind == K.PortDeclaration:
+            _emit_declarators(node, "port", emit)
+        elif kind == K.ParameterDeclaration:
+            _emit_parameter(node, emit)
+        elif kind == K.EnumType:
+            _emit_enum_members(node, emit)
+        elif kind == K.DataDeclaration:
+            _emit_signal_declarators(node, emit, is_net=False)
+        elif kind == K.NetDeclaration:
+            _emit_signal_declarators(node, emit, is_net=True)
+        elif kind == K.GenvarDeclaration:
+            _emit_genvars(node, emit)
+        elif kind == K.HierarchicalInstance:
+            _emit_instance(node, emit)
+
+    _walk(tree.root, visit)
+    out.sort(key=lambda d: (d.line, d.kind, d.name))
+    return out
+
+
+# --------------------------------------------------------------------------------------
+# per-kind extraction helpers
+# --------------------------------------------------------------------------------------
+
+
+def _walk(node: Any, visit: Any) -> None:
+    """Depth-first walk, calling `visit(node)` on every syntax node."""
+    if node is None:
+        return
+    visit(node)
+    if isinstance(node, SyntaxNode):
+        for i in range(len(node)):
+            try:
+                child = node[i]
+            except Exception:  # pragma: no cover - defensive against odd child slots
+                child = None
+            _walk(child, visit)
+
+
+def _emit_header_name(node: Any, kind: str, emit: Any) -> None:
+    name = getattr(node, "name", None)
+    if name is not None and not name.isMissing:
+        emit(kind, name)
+
+
+def _iter_declarators(node: Any, attr: str) -> Iterator[Any]:
+    """Yield the `Declarator` items of `node.<attr>`, skipping the separator commas.
+
+    A pyslang separated list (`declarators`, `members`) iterates its comma tokens too;
+    we keep only the `Declarator` nodes.
+    """
+    for item in getattr(node, attr, []):
+        if getattr(item, "kind", None) == SyntaxKind.Declarator and not item.name.isMissing:
+            yield item
+
+
+def _emit_declarator(node: Any, kind: str, emit: Any) -> None:
+    dec = getattr(node, "declarator", None)
+    if dec is not None and not dec.name.isMissing:
+        emit(kind, dec.name)
+
+
+def _emit_declarators(node: Any, kind: str, emit: Any) -> None:
+    for dec in _iter_declarators(node, "declarators"):
+        emit(kind, dec.name)
+
+
+def _emit_parameter(node: Any, emit: Any) -> None:
+    keyword = getattr(node, "keyword", None)
+    is_local = keyword is not None and str(keyword.kind).endswith("LocalParamKeyword")
+    kind = "localparam" if is_local else "parameter"
+    for dec in _iter_declarators(node, "declarators"):
+        emit(kind, dec.name)
+
+
+def _emit_enum_members(node: Any, emit: Any) -> None:
+    for dec in _iter_declarators(node, "members"):
+        emit("enum_value", dec.name)
+
+
+_SIGNAL_TYPE_KINDS = frozenset({"LogicType", "RegType"})
+"""DataDeclaration types the check treats as signals: `logic` and `reg`. A declaration of
+a user-defined type (`my_struct_t x;`) or an integer type (`int i;`) is not a signal, so
+it is left alone -- matching the reference, which only matches `reg`/`wire`/`logic`."""
+
+
+def _emit_signal_declarators(node: Any, emit: Any, *, is_net: bool) -> None:
+    if not is_net:
+        # A DataDeclaration is only a signal when its type is `logic` or `reg`. Anything
+        # else (a named type, `int`, a struct) is not what this rule governs.
+        type_kind = str(getattr(getattr(node, "type", None), "kind", "")).rsplit(".", 1)[-1]
+        if type_kind not in _SIGNAL_TYPE_KINDS:
+            return
+    for dec in _iter_declarators(node, "declarators"):
+        # An unpacked dimension on the declarator (e.g. `logic [7:0] mem [0:15]`) makes
+        # this a memory; a plain declarator is a signal.
+        kind = "memory" if len(getattr(dec, "dimensions", [])) > 0 else "signal"
+        emit(kind, dec.name)
+
+
+def _emit_genvars(node: Any, emit: Any) -> None:
+    for ident in getattr(node, "identifiers", []):
+        if getattr(ident, "kind", None) != SyntaxKind.IdentifierName:
+            continue
+        token = getattr(ident, "identifier", None)
+        if token is not None and not token.isMissing:
+            emit("genvar", token)
+
+
+def _emit_instance(node: Any, emit: Any) -> None:
+    decl = getattr(node, "decl", None)
+    if decl is None:
+        return
+    name = getattr(decl, "name", None)
+    if name is not None and not name.isMissing:
+        emit("instance", name)
+
+
+__all__ = [
+    "Decl",
+    "ParseFailure",
+    "declared_identifiers",
+    "parse_errors",
+    "parse_file",
+    "parse_text",
+]