pycforge 0.15.2__py3-none-any.whl

pycforge/converter/containers/lowering.py

@@ -0,0 +1,290 @@
+"""C IR lowering adapter for the approved fixed local-container profile.
+
+The adapter owns only container representation mechanics. Scalar expression
+evaluation, source binding, control-flow nesting, diagnostics, and provenance
+remain services of the cumulative lowerer and are supplied explicitly.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from pycforge.converter.ir.c_ir import (
+    CAssignmentStatement,
+    CBinaryExpr,
+    CBinaryOp,
+    CBlock,
+    CForStatement,
+    CIdentifier,
+    CIdentifierRef,
+    CInitializerList,
+    CIntegerLiteral,
+    CStorage,
+    CSubscriptExpr,
+    CType,
+    CVariableDeclaration,
+)
+
+
+def _sid(prefix: str, *parts: str) -> str:
+    return prefix + hashlib.sha256("\x1f".join(parts).encode()).hexdigest()[:20]
+
+
+@dataclass(slots=True)
+class ContainerLoweringServices:
+    nodes: dict[str, dict[str, Any]]
+    shapes: dict[str, dict[str, Any]]
+    bindings: dict[str, dict[str, Any]]
+    bindings_by_assignment: dict[str, dict[str, Any]]
+    accesses: dict[str, dict[str, Any]]
+    iterations: dict[str, dict[str, Any]]
+    source_bindings_by_id: dict[str, dict[str, Any]]
+    source_bindings_by_occurrence: dict[str, dict[str, Any]]
+    generated_names: dict[str, str]
+    generated_spellings: set[str]
+    expression: Callable[..., tuple[tuple[Any, ...], Any]]
+    temporary: Callable[..., tuple[CVariableDeclaration, CIdentifierRef]]
+    category_type: Callable[[str], CType]
+    identifier: Callable[[dict[str, Any], dict[str, Any]], CIdentifier]
+    provenance: Callable[..., Any]
+    synthetic_provenance: Callable[..., Any]
+    block_statements: Callable[..., tuple[Any, ...]]
+    temporary_spelling: Callable[[str, str], str]
+    reject: Callable[..., Any]
+    control_depth: Callable[[], int]
+
+
+class ContainerCIRLowerer:
+    """Lower proved container facts without owning scalar or control semantics."""
+
+    def __init__(self, services: ContainerLoweringServices) -> None:
+        self.services = services
+        self.storage: dict[str, dict[str, Any]] = {}
+        self.component_spellings: dict[tuple[str, str], str] = {}
+
+    def declaration(self, node: dict[str, Any]) -> tuple[Any, ...]:
+        s = self.services
+        fact = s.bindings_by_assignment[node["node_id"]]
+        if not fact.get("valid"):
+            s.reject(fact.get("diagnostic_code") or "PYC3403", fact.get("reason") or "Invalid fixed container binding", node)
+        shape = s.shapes.get(fact["literal_node_id"])
+        if not shape or not shape.get("valid"):
+            s.reject(
+                (shape or {}).get("diagnostic_code") or "PYC3402",
+                (shape or {}).get("reason") or "Fixed container shape fact is absent or invalid",
+                s.nodes.get(fact["literal_node_id"], node),
+            )
+        target = s.nodes[fact["target_node_id"]]
+        binding = s.source_bindings_by_id.get(fact["binding_id"])
+        if not binding:
+            s.reject("PYC3403", "Fixed container binding cannot be resolved", target)
+        if s.control_depth():
+            s.reject("PYC3403", "A fixed container must be bound directly in a function body", node)
+
+        literal = s.nodes[fact["literal_node_id"]]
+        prelude: list[Any] = []
+        if fact["container_kind"] in {"list", "tuple"}:
+            element_refs: list[Any] = []
+            for ordinal, element_id in enumerate(shape["element_node_ids"]):
+                expression_prelude, expression = s.expression(s.nodes[element_id])
+                prelude.extend(expression_prelude)
+                declaration, reference = s.temporary(
+                    "container_item",
+                    literal,
+                    ordinal,
+                    s.category_type(fact["element_category"]),
+                    expression,
+                    (element_id, literal["node_id"]),
+                )
+                prelude.append(declaration)
+                element_refs.append(reference)
+            identifier = s.identifier(binding, target)
+            declaration = CVariableDeclaration(
+                _sid("c-container-array-", node["node_id"]),
+                identifier,
+                self._array_type(
+                    fact["element_category"],
+                    fact["capacity"],
+                    readonly=fact["container_kind"] == "tuple",
+                ),
+                CInitializerList(
+                    _sid("c-container-init-", literal["node_id"]),
+                    tuple(element_refs),
+                    s.provenance(literal),
+                ),
+                CStorage.NONE,
+                s.provenance(node),
+            )
+            self.storage[fact["binding_id"]] = {
+                "iteration": identifier,
+                "values": identifier,
+                "kind": fact["container_kind"],
+            }
+            return tuple(prelude) + (declaration,)
+
+        key_refs: list[Any] = []
+        value_refs: list[Any] = []
+        for ordinal, (key_id, value_id) in enumerate(zip(shape["key_node_ids"], shape["value_node_ids"])):
+            key_prelude, key_expression = s.expression(s.nodes[key_id])
+            prelude.extend(key_prelude)
+            key_declaration, key_reference = s.temporary(
+                "container_key",
+                literal,
+                ordinal,
+                s.category_type(fact["key_category"]),
+                key_expression,
+                (key_id, literal["node_id"]),
+            )
+            prelude.append(key_declaration)
+            key_refs.append(key_reference)
+
+            value_prelude, value_expression = s.expression(s.nodes[value_id])
+            prelude.extend(value_prelude)
+            value_declaration, value_reference = s.temporary(
+                "container_value",
+                literal,
+                ordinal,
+                s.category_type(fact["value_category"]),
+                value_expression,
+                (value_id, literal["node_id"]),
+            )
+            prelude.append(value_declaration)
+            value_refs.append(value_reference)
+
+        key_identifier = self._component_identifier(fact, literal, "keys")
+        value_identifier = self._component_identifier(fact, literal, "values")
+        key_declaration = CVariableDeclaration(
+            _sid("c-container-keys-", node["node_id"]),
+            key_identifier,
+            self._array_type(fact["key_category"], fact["capacity"], readonly=True),
+            CInitializerList(_sid("c-container-keys-init-", literal["node_id"]), tuple(key_refs), s.provenance(literal)),
+            CStorage.NONE,
+            s.provenance(node),
+        )
+        value_declaration = CVariableDeclaration(
+            _sid("c-container-values-", node["node_id"]),
+            value_identifier,
+            self._array_type(fact["value_category"], fact["capacity"], readonly=True),
+            CInitializerList(_sid("c-container-values-init-", literal["node_id"]), tuple(value_refs), s.provenance(literal)),
+            CStorage.NONE,
+            s.provenance(node),
+        )
+        self.storage[fact["binding_id"]] = {
+            "iteration": key_identifier,
+            "values": value_identifier,
+            "kind": "dict",
+        }
+        return tuple(prelude) + (key_declaration, value_declaration)
+
+    def access(self, node: dict[str, Any]) -> tuple[tuple[Any, ...], Any]:
+        s = self.services
+        fact = s.accesses.get(node["node_id"])
+        if not fact or not fact.get("supported"):
+            s.reject(
+                (fact or {}).get("diagnostic_code") or "PYC3404",
+                (fact or {}).get("reason") or "Container access lacks a static proof",
+                node,
+            )
+        storage = self.storage.get(fact["binding_id"])
+        if not storage:
+            s.reject("PYC3403", "Container access occurs before its fixed local declaration", node)
+        offset = fact.get("resolved_offset")
+        if not isinstance(offset, int) or isinstance(offset, bool):
+            s.reject("PYC3404", "Container access lacks a resolved integer offset", node)
+        provenance = s.provenance(node)
+        identifier = storage["values"]
+        container = CIdentifierRef(
+            _sid("c-container-ref-", node["node_id"], identifier.binding_id),
+            identifier.binding_id,
+            provenance,
+        )
+        index = CIntegerLiteral(
+            _sid("c-container-offset-", node["node_id"]),
+            offset,
+            "LL",
+            s.synthetic_provenance((node["node_id"],), node["node_id"]),
+        )
+        return (), CSubscriptExpr(_sid("c-subscript-", node["node_id"]), container, index, provenance)
+
+    def iteration(self, node: dict[str, Any]) -> tuple[Any, ...]:
+        s = self.services
+        fact = s.iterations[node["node_id"]]
+        if not fact.get("supported"):
+            s.reject(fact.get("diagnostic_code") or "PYC3407", fact.get("reason") or "Unsupported container iteration", node)
+        storage = self.storage.get(fact["binding_id"])
+        if not storage:
+            s.reject("PYC3403", "Container iteration occurs before its fixed local declaration", node)
+        target = s.nodes[node["fields"]["target"]]
+        target_binding = s.source_bindings_by_occurrence.get(target["node_id"])
+        if not target_binding:
+            s.reject("PYC3407", "Container loop target binding could not be resolved", target)
+
+        index_binding_id = _sid("bind-container-index-", node["node_id"])
+        index_provenance = s.synthetic_provenance((node["node_id"],), node["node_id"])
+        index_identifier = CIdentifier(
+            index_binding_id,
+            s.temporary_spelling("index", index_binding_id),
+            index_provenance,
+        )
+        zero = CIntegerLiteral(_sid("c-container-loop-zero-", node["node_id"]), 0, "LL", index_provenance)
+        one = CIntegerLiteral(_sid("c-container-loop-one-", node["node_id"]), 1, "LL", index_provenance)
+        capacity = CIntegerLiteral(_sid("c-container-loop-capacity-", node["node_id"]), fact["capacity"], "LL", index_provenance)
+        initializer = CVariableDeclaration(
+            _sid("c-container-loop-init-", node["node_id"]),
+            index_identifier,
+            CType("int64_t"),
+            zero,
+            CStorage.NONE,
+            index_provenance,
+        )
+        condition_ref = CIdentifierRef(_sid("c-container-loop-condition-ref-", node["node_id"]), index_binding_id, index_provenance)
+        condition = CBinaryExpr(_sid("c-container-loop-condition-", node["node_id"]), CBinaryOp.LESS, condition_ref, capacity, index_provenance)
+        update_left = CIdentifierRef(_sid("c-container-loop-update-left-", node["node_id"]), index_binding_id, index_provenance)
+        update_value = CBinaryExpr(_sid("c-container-loop-update-value-", node["node_id"]), CBinaryOp.ADD, update_left, one, index_provenance)
+        update_target = CIdentifierRef(_sid("c-container-loop-update-target-", node["node_id"]), index_binding_id, index_provenance)
+        update = CAssignmentStatement(_sid("c-container-loop-update-", node["node_id"]), update_target, update_value, index_provenance)
+
+        data_identifier = storage["iteration"]
+        data_ref = CIdentifierRef(_sid("c-container-loop-data-", node["node_id"]), data_identifier.binding_id, index_provenance)
+        element_index = CIdentifierRef(_sid("c-container-loop-element-index-", node["node_id"]), index_binding_id, index_provenance)
+        element = CSubscriptExpr(_sid("c-container-loop-element-", node["node_id"]), data_ref, element_index, index_provenance)
+        target_declaration = CVariableDeclaration(
+            _sid("c-container-loop-target-", node["node_id"]),
+            s.identifier(target_binding, target),
+            s.category_type(fact["target_category"]),
+            element,
+            CStorage.NONE,
+            s.provenance(target, fallback_plan_node=node["node_id"]),
+        )
+        source_body = s.block_statements(node["fields"].get("body", []), loop=True)
+        body = CBlock(
+            _sid("c-container-loop-body-", node["node_id"]),
+            (target_declaration,) + source_body,
+            s.provenance(node),
+        )
+        return (CForStatement(_sid("c-container-loop-", node["node_id"]), initializer, condition, update, body, s.provenance(node)),)
+
+    def _array_type(self, category: str, capacity: int, *, readonly: bool = False) -> CType:
+        scalar = self.services.category_type(category)
+        return CType(scalar.base, scalar.qualifiers, scalar.pointer_depth, (capacity,), readonly)
+
+    def _component_identifier(self, fact: dict[str, Any], node: dict[str, Any], component: str) -> CIdentifier:
+        s = self.services
+        binding_id = _sid("bind-container-component-", fact["binding_id"], component)
+        key = (fact["binding_id"], component)
+        spelling = self.component_spellings.get(key)
+        if spelling is None:
+            base = f"{s.generated_names[fact['binding_id']]}_{component}"
+            spelling = base
+            suffix = 1
+            while spelling in s.generated_spellings:
+                suffix += 1
+                spelling = f"{base}_{suffix}"
+            s.generated_spellings.add(spelling)
+            self.component_spellings[key] = spelling
+        return CIdentifier(binding_id, spelling, s.synthetic_provenance((node["node_id"],), fact["assignment_node_id"]))
+
+
+__all__ = ["ContainerCIRLowerer", "ContainerLoweringServices"]

pycforge/converter/containers/model.py

@@ -0,0 +1,146 @@
+"""Immutable facts for the Phase 11 fixed local-container profile."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from pycforge.converter.analysis.model import ValueCategory
+from pycforge.converter.contracts.configuration import MAX_CONTAINER_ELEMENTS
+
+
+
+@dataclass(frozen=True, slots=True)
+class ContainerShapeFact:
+    literal_node_id: str
+    container_kind: str
+    capacity: int
+    element_node_ids: tuple[str, ...]
+    key_node_ids: tuple[str, ...]
+    value_node_ids: tuple[str, ...]
+    element_category: ValueCategory
+    key_category: ValueCategory
+    value_category: ValueCategory
+    key_values: tuple[int | str, ...]
+    storage_model: str
+    mutable: bool
+    valid: bool
+    diagnostic_code: str | None
+    reason: str | None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "literal_node_id": self.literal_node_id,
+            "container_kind": self.container_kind,
+            "capacity": self.capacity,
+            "element_node_ids": list(self.element_node_ids),
+            "key_node_ids": list(self.key_node_ids),
+            "value_node_ids": list(self.value_node_ids),
+            "element_category": self.element_category.value,
+            "key_category": self.key_category.value,
+            "value_category": self.value_category.value,
+            "key_values": list(self.key_values),
+            "storage_model": self.storage_model,
+            "mutable": self.mutable,
+            "valid": self.valid,
+            "diagnostic_code": self.diagnostic_code,
+            "reason": self.reason,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ContainerBindingFact:
+    binding_id: str
+    source_name: str
+    assignment_node_id: str
+    target_node_id: str
+    literal_node_id: str
+    container_kind: str
+    capacity: int
+    element_category: ValueCategory
+    key_category: ValueCategory
+    value_category: ValueCategory
+    allowed_use_node_ids: tuple[str, ...]
+    invalid_use_node_ids: tuple[str, ...]
+    valid: bool
+    diagnostic_code: str | None
+    rejection_node_id: str | None
+    reason: str | None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "binding_id": self.binding_id,
+            "source_name": self.source_name,
+            "assignment_node_id": self.assignment_node_id,
+            "target_node_id": self.target_node_id,
+            "literal_node_id": self.literal_node_id,
+            "container_kind": self.container_kind,
+            "capacity": self.capacity,
+            "element_category": self.element_category.value,
+            "key_category": self.key_category.value,
+            "value_category": self.value_category.value,
+            "allowed_use_node_ids": list(self.allowed_use_node_ids),
+            "invalid_use_node_ids": list(self.invalid_use_node_ids),
+            "valid": self.valid,
+            "diagnostic_code": self.diagnostic_code,
+            "rejection_node_id": self.rejection_node_id,
+            "reason": self.reason,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ContainerAccessFact:
+    subscript_node_id: str
+    binding_id: str | None
+    container_kind: str | None
+    slice_node_id: str | None
+    result_category: ValueCategory
+    resolved_offset: int | None
+    source_index: int | None
+    key_value: int | str | None
+    supported: bool
+    diagnostic_code: str | None
+    reason: str | None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "subscript_node_id": self.subscript_node_id,
+            "binding_id": self.binding_id,
+            "container_kind": self.container_kind,
+            "slice_node_id": self.slice_node_id,
+            "result_category": self.result_category.value,
+            "resolved_offset": self.resolved_offset,
+            "source_index": self.source_index,
+            "key_value": self.key_value,
+            "supported": self.supported,
+            "diagnostic_code": self.diagnostic_code,
+            "reason": self.reason,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ContainerIterationFact:
+    for_node_id: str
+    binding_id: str | None
+    container_kind: str | None
+    target_node_id: str | None
+    target_category: ValueCategory
+    capacity: int
+    order_policy: str
+    supported: bool
+    diagnostic_code: str | None
+    reason: str | None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "for_node_id": self.for_node_id,
+            "binding_id": self.binding_id,
+            "container_kind": self.container_kind,
+            "target_node_id": self.target_node_id,
+            "target_category": self.target_category.value,
+            "capacity": self.capacity,
+            "order_policy": self.order_policy,
+            "supported": self.supported,
+            "diagnostic_code": self.diagnostic_code,
+            "reason": self.reason,
+        }

pycforge/converter/contracts/configuration.py

@@ -0,0 +1,178 @@
+"""Versioned public configuration identities for the promoted converter.
+
+The constants in this module are deliberately data-only so the public request,
+CLI, workspace, analysis, and lowering layers cannot drift to different phase
+identities.
+"""
+
+from __future__ import annotations
+
+DEFAULT_TARGET_CONTRACT = "c11-portable-fixed-v1"
+DEFAULT_SEMANTIC_POLICY = "strict-source-v1"
+PHASE9_RULE_SET = "phase9-functions-calls-v0.9"
+PHASE11_RULE_SET = "phase11-bounded-containers-v0.11"
+PHASE12_RULE_SET = "phase12-explicit-module-bundles-v0.12"
+PHASE12_RENDERER = "c-renderer-v0.12"
+PHASE12_MODULE_POLICY = "phase12-explicit-sourcebundle-modules-v0.12"
+PHASE13_RULE_SET = "phase13-static-records-v0.13"
+PHASE13_RENDERER = "c-renderer-v0.13"
+# Phase 14A remains an explicit historical request profile after 14B becomes
+# active.  Keep these identities named rather than deriving them from the
+# defaults so a historical request cannot be silently relabeled.
+PHASE14A_RULE_SET = "phase14-bounded-numeric-v0.14"
+PHASE14A_RENDERER = "c-renderer-v0.14"
+PHASE14_RULE_SET = PHASE14A_RULE_SET
+PHASE14_RENDERER = PHASE14A_RENDERER
+PHASE14B_RULE_SET = "phase14-conditional-regions-v0.14.1"
+PHASE14B_RENDERER = "c-renderer-v0.14.1"
+PHASE14C_RULE_SET = "phase14-direct-keyword-calls-v0.14.2"
+PHASE14C_RENDERER = "c-renderer-v0.14.2"
+DEFAULT_RULE_SET = "phase14-required-keyword-only-calls-v0.14.3"
+DEFAULT_RENDERER = "c-renderer-v0.14.3"
+DEFAULT_HELPER_POLICY = "phase10-support-templates-v0.10"
+DEFAULT_CONTAINER_POLICY = "phase11-fixed-local-containers-v0.11"
+# Module, record, and numeric policies are deliberately unchanged in Phase 14B.
+DEFAULT_MODULE_POLICY = "phase13-explicit-record-modules-v0.13"
+DEFAULT_RECORD_POLICY = "phase13-immutable-automatic-records-v0.13"
+PHASE14A_NUMERIC_POLICY = "phase14-proved-floor-arithmetic-v0.14"
+DEFAULT_NUMERIC_POLICY = PHASE14A_NUMERIC_POLICY
+MAX_CONTAINER_ELEMENTS = 64
+MAX_SOURCE_DOCUMENTS = 64
+MAX_IMPORT_ITEMS = 4_096
+
+SUPPORTED_TARGET_CONTRACTS = frozenset(
+    {
+        DEFAULT_TARGET_CONTRACT,
+        # Read-compatible identity used by the earliest public request object.
+        "pycforge-c11-int64-v0.1",
+    }
+)
+SUPPORTED_SEMANTIC_POLICIES = frozenset(
+    {
+        DEFAULT_SEMANTIC_POLICY,
+        # Read-compatible identity used by the earliest public request object.
+        "strict-v0.1",
+    }
+)
+SUPPORTED_RULE_SETS = frozenset(
+    {
+        "phase3-frontend-v0.3",
+        "phase5-planning-v0.5",
+        "phase6-first-slice-v0.6",
+        "phase8-control-flow-v0.8",
+        PHASE9_RULE_SET,
+        PHASE11_RULE_SET,
+        PHASE12_RULE_SET,
+        PHASE13_RULE_SET,
+        PHASE14A_RULE_SET,
+        PHASE14B_RULE_SET,
+        PHASE14C_RULE_SET,
+        DEFAULT_RULE_SET,
+    }
+)
+SUPPORTED_RENDERERS = frozenset(
+    {
+        "phase3-none-v0.3",
+        "c-renderer-v0.6",
+        "c-renderer-v0.8",
+        "c-renderer-v0.9",
+        "c-renderer-v0.11",
+        PHASE12_RENDERER,
+        PHASE13_RENDERER,
+        PHASE14A_RENDERER,
+        PHASE14B_RENDERER,
+        PHASE14C_RENDERER,
+        DEFAULT_RENDERER,
+    }
+)
+
+# Rule-set and renderer identities are a paired compatibility profile.  Phase 5
+# is planning-only and therefore keeps the current request default renderer;
+# every rendering phase requires its exact historical renderer.
+COMPATIBLE_RENDERERS_BY_RULE_SET = {
+    "phase3-frontend-v0.3": frozenset({"phase3-none-v0.3"}),
+    "phase5-planning-v0.5": frozenset({DEFAULT_RENDERER}),
+    "phase6-first-slice-v0.6": frozenset({"c-renderer-v0.6"}),
+    "phase8-control-flow-v0.8": frozenset({"c-renderer-v0.8"}),
+    PHASE9_RULE_SET: frozenset({"c-renderer-v0.9"}),
+    PHASE11_RULE_SET: frozenset({"c-renderer-v0.11"}),
+    PHASE12_RULE_SET: frozenset({PHASE12_RENDERER}),
+    PHASE13_RULE_SET: frozenset({PHASE13_RENDERER}),
+    PHASE14A_RULE_SET: frozenset({PHASE14A_RENDERER}),
+    PHASE14B_RULE_SET: frozenset({PHASE14B_RENDERER}),
+    PHASE14C_RULE_SET: frozenset({PHASE14C_RENDERER}),
+    DEFAULT_RULE_SET: frozenset({DEFAULT_RENDERER}),
+}
+
+SUPPORTED_HELPER_POLICIES = frozenset({DEFAULT_HELPER_POLICY})
+SUPPORTED_CONTAINER_POLICIES = frozenset({DEFAULT_CONTAINER_POLICY})
+SUPPORTED_MODULE_POLICIES = frozenset({PHASE12_MODULE_POLICY, DEFAULT_MODULE_POLICY})
+SUPPORTED_RECORD_POLICIES = frozenset({DEFAULT_RECORD_POLICY})
+SUPPORTED_NUMERIC_POLICIES = frozenset({DEFAULT_NUMERIC_POLICY})
+
+
+def supports_functions(rule_set: str) -> bool:
+    return rule_set in {
+        PHASE9_RULE_SET,
+        PHASE11_RULE_SET,
+        PHASE12_RULE_SET,
+        PHASE13_RULE_SET,
+        PHASE14A_RULE_SET,
+        PHASE14B_RULE_SET,
+        PHASE14C_RULE_SET,
+        DEFAULT_RULE_SET,
+    }
+
+
+def supports_containers(rule_set: str) -> bool:
+    return rule_set in {
+        PHASE11_RULE_SET,
+        PHASE12_RULE_SET,
+        PHASE13_RULE_SET,
+        PHASE14A_RULE_SET,
+        PHASE14B_RULE_SET,
+        PHASE14C_RULE_SET,
+        DEFAULT_RULE_SET,
+    }
+
+
+def supports_modules(rule_set: str) -> bool:
+    return rule_set in {
+        PHASE12_RULE_SET,
+        PHASE13_RULE_SET,
+        PHASE14A_RULE_SET,
+        PHASE14B_RULE_SET,
+        PHASE14C_RULE_SET,
+        DEFAULT_RULE_SET,
+    }
+
+
+def supports_records(rule_set: str) -> bool:
+    return rule_set in {
+        PHASE13_RULE_SET,
+        PHASE14A_RULE_SET,
+        PHASE14B_RULE_SET,
+        PHASE14C_RULE_SET,
+        DEFAULT_RULE_SET,
+    }
+
+
+def supports_numeric(rule_set: str) -> bool:
+    return rule_set in {
+        PHASE14A_RULE_SET,
+        PHASE14B_RULE_SET,
+        PHASE14C_RULE_SET,
+        DEFAULT_RULE_SET,
+    }
+
+
+def supports_conditional_regions(rule_set: str) -> bool:
+    return rule_set in {PHASE14B_RULE_SET, PHASE14C_RULE_SET, DEFAULT_RULE_SET}
+
+
+def supports_keyword_calls(rule_set: str) -> bool:
+    return rule_set in {PHASE14C_RULE_SET, DEFAULT_RULE_SET}
+
+
+def supports_keyword_only_calls(rule_set: str) -> bool:
+    return rule_set == DEFAULT_RULE_SET

pycforge/converter/contracts/identifiers.py

@@ -0,0 +1,68 @@
+"""Data-only ISO C11 identifier reservations shared by planning and validation."""
+
+from __future__ import annotations
+
+
+C_KEYWORDS = frozenset({
+    "auto", "break", "case", "char", "const", "continue", "default", "do",
+    "double", "else", "enum", "extern", "float", "for", "goto", "if",
+    "inline", "int", "long", "register", "restrict", "return", "short",
+    "signed", "sizeof", "static", "struct", "switch", "typedef", "union",
+    "unsigned", "void", "volatile", "while", "_Alignas", "_Alignof",
+    "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary", "_Noreturn",
+    "_Static_assert", "_Thread_local",
+})
+
+TARGET_RESERVED_NAMES = {
+    "bool", "true", "false", "size_t",
+    "int8_t", "uint8_t", "int16_t", "uint16_t", "int32_t", "uint32_t",
+    "int64_t", "uint64_t",
+}
+for _width in (8, 16, 32, 64):
+    TARGET_RESERVED_NAMES.update({
+        f"int_least{_width}_t", f"uint_least{_width}_t", f"int_fast{_width}_t", f"uint_fast{_width}_t",
+        f"INT{_width}_MIN", f"INT{_width}_MAX", f"UINT{_width}_MAX", f"INT{_width}_C", f"UINT{_width}_C",
+        f"INT_LEAST{_width}_MIN", f"INT_LEAST{_width}_MAX", f"UINT_LEAST{_width}_MAX",
+        f"INT_FAST{_width}_MIN", f"INT_FAST{_width}_MAX", f"UINT_FAST{_width}_MAX",
+    })
+TARGET_RESERVED_NAMES.update({
+    "intptr_t", "uintptr_t", "intmax_t", "uintmax_t", "INTPTR_MIN", "INTPTR_MAX", "UINTPTR_MAX",
+    "INTMAX_MIN", "INTMAX_MAX", "UINTMAX_MAX", "INTMAX_C", "UINTMAX_C", "PTRDIFF_MIN", "PTRDIFF_MAX",
+    "SIG_ATOMIC_MIN", "SIG_ATOMIC_MAX", "SIZE_MAX", "WCHAR_MIN", "WCHAR_MAX", "WINT_MIN", "WINT_MAX",
+})
+TARGET_RESERVED_NAMES = frozenset(TARGET_RESERVED_NAMES)
+
+# ISO C library identifiers with external linkage are reserved even when their
+# declaring header is not included. `main` is included as the hosted entry point.
+C11_EXTERNAL_IDENTIFIERS = frozenset("""
+main errno stdin stdout stderr
+isalnum isalpha isblank iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper
+feclearexcept fegetexceptflag feraiseexcept fesetexceptflag fetestexcept fegetround fesetround fegetenv feholdexcept fesetenv feupdateenv
+imaxabs imaxdiv strtoimax strtoumax wcstoimax wcstoumax setlocale localeconv setjmp longjmp signal raise
+remove rename tmpfile tmpnam fclose fflush fopen freopen setbuf setvbuf fprintf fscanf printf scanf snprintf sprintf sscanf
+vfprintf vfscanf vprintf vscanf vsnprintf vsprintf vsscanf fgetc fgets fputc fputs getc getchar putc putchar puts ungetc
+fread fwrite fgetpos fseek fsetpos ftell rewind clearerr feof ferror perror
+atof atoi atol atoll strtod strtof strtold strtol strtoll strtoul strtoull rand srand aligned_alloc calloc free malloc realloc
+abort atexit at_quick_exit exit _Exit getenv quick_exit system bsearch qsort abs labs llabs div ldiv lldiv
+mblen mbtowc wctomb mbstowcs wcstombs
+memcpy memmove strcpy strncpy strcat strncat memcmp strcmp strcoll strncmp strxfrm memchr strchr strcspn strpbrk strrchr strspn strstr strtok memset strerror strlen
+call_once cnd_broadcast cnd_destroy cnd_init cnd_signal cnd_timedwait cnd_wait mtx_destroy mtx_init mtx_lock mtx_timedlock mtx_trylock mtx_unlock
+thrd_create thrd_current thrd_detach thrd_equal thrd_exit thrd_join thrd_sleep thrd_yield tss_create tss_delete tss_get tss_set
+clock difftime mktime time timespec_get asctime ctime gmtime localtime strftime
+mbrtoc16 c16rtomb mbrtoc32 c32rtomb
+fwprintf fwscanf swprintf swscanf vfwprintf vfwscanf vswprintf vswscanf vwprintf vwscanf wprintf wscanf
+fgetwc fgetws fputwc fputws fwide getwc getwchar putwc putwchar ungetwc
+wcstod wcstof wcstold wcstol wcstoll wcstoul wcstoull wcscpy wcsncpy wmemcpy wmemmove wcscat wcsncat
+wmemcmp wcscmp wcscoll wcsncmp wcsxfrm wmemchr wcschr wcscspn wcspbrk wcsrchr wcsspn wcsstr wcstok wmemset wcslen wcsftime
+btowc wctob mbsinit mbrlen mbrtowc wcrtomb mbsrtowcs wcsrtombs
+iswalnum iswalpha iswblank iswcntrl iswctype iswdigit iswgraph iswlower iswprint iswpunct iswspace iswupper iswxdigit towlower towupper towctrans wctype wctrans
+""".split())
+
+_MATH_EXTERNAL_BASES = frozenset("""
+acos asin atan atan2 cos sin tan acosh asinh atanh exp exp2 expm1 frexp ilogb ldexp log log10 log1p log2 logb modf scalbn scalbln
+cbrt fabs hypot pow sqrt erf erfc lgamma tgamma ceil floor nearbyint rint lrint llrint round lround llround trunc
+fmod remainder remquo copysign nan nextafter nexttoward fdim fmax fmin fma
+cacos casin catan ccos csin ctan cacosh casinh catanh cexp clog cabs cpow csqrt carg cimag conj cproj creal
+""".split())
+C11_EXTERNAL_IDENTIFIERS |= frozenset(name + suffix for name in _MATH_EXTERNAL_BASES for suffix in ("", "f", "l"))
+