cseq 0.0.1__py3-none-any.whl

cseq/model.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from array import array
+from enum import Enum
+from pathlib import Path
+from typing import Iterable, Any
+
+
+class ParseStatus(str, Enum):
+    OK = "OK"
+    PARTIAL = "PARTIAL"
+    ERROR_RECOVERED = "ERROR_RECOVERED"
+    OPAQUE_REGION = "OPAQUE_REGION"
+
+
+@dataclass(frozen=True, slots=True)
+class SourceFile:
+    path: Path
+    project_relative_path: str
+    suffix: str
+    size_bytes: int
+    content_hash: str
+
+
+@dataclass(frozen=True, slots=True)
+class TranslationUnit:
+    source: SourceFile
+    arguments: tuple[str, ...] = ()
+    working_directory: Path | None = None
+    configuration_name: str | None = None
+    # Ephemeral per-TU source text. Project may populate this so dependency
+    # fingerprinting and the fast parser share one file read. It is never part
+    # of persistent IR/cache identity and is released with the parse artifact.
+    source_text: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class SourceRange:
+    start_line: int | None = None
+    start_column: int | None = None
+    end_line: int | None = None
+    end_column: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class FunctionRecord:
+    name: str
+    qualified_id: str
+    source_path: str
+    source_range: SourceRange
+    storage_class: str | None = None
+    type_qualifier: str | None = None
+    parameters: tuple[str, ...] = ()
+
+
+
+
+@dataclass(frozen=True, slots=True)
+class CompactFunctionRecord:
+    """Memory-lean FunctionRecord-compatible view for conservative fast parsing.
+
+    The stable qualified id and SourceRange are derived lazily instead of being
+    stored for every function.  This materially reduces peak memory on
+    million-function projects while keeping the same public attribute contract.
+    """
+    name: str
+    source_path: str
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+    storage_class: str | None = None
+    type_qualifier: str | None = None
+    parameters: tuple[str, ...] = ()
+
+    @property
+    def source_range(self) -> SourceRange:
+        return SourceRange(self.start_line, self.start_column, self.end_line, self.end_column)
+
+    @property
+    def qualified_id(self) -> str:
+        return (
+            f"{self.source_path}:{self.start_line}:{self.start_column}:"
+            f"{self.storage_class or 'external'}:{self.name}:{self.type_qualifier or '?'}"
+        )
+
+
+class CompactFunctionTable:
+    """Columnar storage for fast-parser function metadata.
+
+    Records are materialized only when a caller iterates/addresses them.  The
+    table avoids retaining one Python object and one SourceRange per function.
+    """
+    __slots__ = (
+        "source_path", "names", "start_lines", "start_columns",
+        "end_lines", "end_columns", "meta_ids", "meta", "_meta_index"
+    )
+
+    def __init__(self, source_path: str) -> None:
+        self.source_path = source_path
+        self.names: list[str] = []
+        self.start_lines = array("I")
+        self.start_columns = array("I")
+        self.end_lines = array("I")
+        self.end_columns = array("I")
+        self.meta_ids = array("I")
+        self.meta: list[tuple[str | None, str | None, tuple[str, ...]]] = []
+        self._meta_index: dict[tuple[str | None, str | None, tuple[str, ...]], int] = {}
+
+    def append_fields(
+        self, name: str, start_line: int, start_column: int, end_line: int, end_column: int,
+        storage_class: str | None, type_qualifier: str | None, parameters: tuple[str, ...],
+    ) -> None:
+        key = (storage_class, type_qualifier, parameters)
+        meta_id = self._meta_index.get(key)
+        if meta_id is None:
+            meta_id = len(self.meta)
+            self.meta.append(key)
+            self._meta_index[key] = meta_id
+        self.names.append(name)
+        self.start_lines.append(start_line or 0)
+        self.start_columns.append(start_column or 0)
+        self.end_lines.append(end_line or 0)
+        self.end_columns.append(end_column or 0)
+        self.meta_ids.append(meta_id)
+
+    def __len__(self) -> int:
+        return len(self.names)
+
+    def __getitem__(self, index: int) -> CompactFunctionRecord:
+        if index < 0:
+            index += len(self.names)
+        storage, type_qualifier, parameters = self.meta[self.meta_ids[index]]
+        return CompactFunctionRecord(
+            self.names[index], self.source_path,
+            self.start_lines[index], self.start_columns[index],
+            self.end_lines[index], self.end_columns[index],
+            storage, type_qualifier, parameters,
+        )
+
+    def __iter__(self):
+        for i in range(len(self.names)):
+            yield self[i]
+
+    def iter_named(self, names: set[str]):
+        if not names:
+            return
+        for i, name in enumerate(self.names):
+            if name in names:
+                yield self[i]
+
+    def index_of_qid(self, qid: str) -> int:
+        # Artifacts are intentionally small enough (normally hundreds of
+        # functions/TU) that a local scan is cheaper than retaining a second
+        # project-wide qualified-id dictionary.
+        for i in range(len(self.names)):
+            if self[i].qualified_id == qid:
+                return i
+        return -1
+
+
+@dataclass(frozen=True, slots=True)
+class Diagnostic:
+    severity: str
+    message: str
+    raw: str | None = None
+
+
+class ValueSlotKind(str, Enum):
+    FUNCTION = "FUNCTION"
+    LOCAL = "LOCAL"
+    PARAMETER = "PARAMETER"
+    STRUCT_FIELD = "STRUCT_FIELD"
+    GLOBAL = "GLOBAL"
+    GLOBAL_ARRAY_ELEMENT = "GLOBAL_ARRAY_ELEMENT"
+    GLOBAL_ARRAY_SUMMARY = "GLOBAL_ARRAY_SUMMARY"
+    HEAP_ALLOCATION = "HEAP_ALLOCATION"
+    UNION_SUMMARY = "UNION_SUMMARY"
+    POINTER_MEMORY = "POINTER_MEMORY"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass(frozen=True, slots=True)
+class ValueSlot:
+    key: str
+    kind: ValueSlotKind
+    name: str
+    function_id: str | None = None
+    field_name: str | None = None
+    index: int | None = None
+
+
+class FlowEdgeKind(str, Enum):
+    ASSIGN = "ASSIGN"
+    INIT = "INIT"
+    ARG_TO_PARAM = "ARG_TO_PARAM"
+
+
+@dataclass(frozen=True, slots=True)
+class FlowEdge:
+    source_key: str
+    target_key: str
+    kind: FlowEdgeKind
+    source_path: str | None = None
+    source_range: SourceRange = SourceRange()
+
+
+class CallTargetKind(str, Enum):
+    INTERNAL_EXACT = "INTERNAL_EXACT"
+    INTERNAL_POSSIBLE = "INTERNAL_POSSIBLE"
+    INDIRECT_EXACT = "INDIRECT_EXACT"
+    INDIRECT_POSSIBLE = "INDIRECT_POSSIBLE"
+    EXTERNAL_DECLARED = "EXTERNAL_DECLARED"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass(frozen=True, slots=True)
+class CallSiteRecord:
+    caller_id: str
+    caller_name: str
+    callee_name: str | None
+    raw_text: str
+    source_path: str
+    source_range: SourceRange
+    target_kind: CallTargetKind = CallTargetKind.UNKNOWN
+    target_function_id: str | None = None
+    target_function_ids: tuple[str, ...] = ()
+    unknown_possible: bool = False
+    callee_slot_key: str | None = None
+    argument_slot_keys: tuple[str | None, ...] = ()
+    control_context: tuple[str, ...] = ()
+    macro_expanded: bool = False
+    spelling_range: SourceRange | None = None
+    expansion_range: SourceRange | None = None
+    guard_expression: str | None = None
+
+
+class CpuEvidenceLayer(str, Enum):
+    STATIC_AFFINITY = "STATIC_AFFINITY"
+    BUILD_DOMAIN = "BUILD_DOMAIN"
+    OBSERVED_RUNTIME_DOMAIN = "OBSERVED_RUNTIME_DOMAIN"
+
+
+class CpuValueKind(str, Enum):
+    CPU = "CPU"
+    CPU_GROUP = "CPU_GROUP"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass(frozen=True, slots=True)
+class CpuEvidenceRecord:
+    target_function_id: str
+    layer: CpuEvidenceLayer
+    value_kind: CpuValueKind
+    value: str
+    provenance: str
+    explicit_override: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class LinkerEvidenceRecord:
+    symbol_name: str
+    address: int
+    object_file: str | None
+    section: str | None
+    matched_function_ids: tuple[str, ...] = ()
+    provenance: str = "linker-map"
+
+
+@dataclass(frozen=True, slots=True)
+class BinaryEvidenceRecord:
+    symbol_name: str
+    address: int
+    size: int
+    symbol_kind: str
+    matched_function_ids: tuple[str, ...] = ()
+    binary_hash: str = ""
+    provenance: str = "binary"
+
+
+@dataclass(frozen=True, slots=True)
+class DwarfEvidenceRecord:
+    function_id: str
+    source_path: str
+    line: int
+    address: int
+    dwarf_file: str
+    provenance: str = "dwarf"
+
+
+@dataclass(frozen=True, slots=True)
+class GuardedSourceRegion:
+    source_path: str
+    source_range: SourceRange
+    guard_expression: str
+
+
+@dataclass(slots=True)
+class FileParseArtifact:
+    translation_unit: TranslationUnit
+    status: ParseStatus
+    functions: list[FunctionRecord | CompactFunctionRecord] | CompactFunctionTable = field(default_factory=list)
+    callsites: list[CallSiteRecord] = field(default_factory=list)
+    value_slots: list[ValueSlot] = field(default_factory=list)
+    flow_edges: list[FlowEdge] = field(default_factory=list)
+    diagnostics: list[Diagnostic] = field(default_factory=list)
+    opaque_regions: list[SourceRange] = field(default_factory=list)
+    guarded_regions: list[GuardedSourceRegion] = field(default_factory=list)
+    parser_backend: str = "unknown"
+
+    @property
+    def has_errors(self) -> bool:
+        return any(d.severity in {"error", "fatal"} for d in self.diagnostics)
+
+
+@dataclass(slots=True)
+class ProjectIndex:
+    root: Path
+    source_files: list[SourceFile] = field(default_factory=list)
+    parse_artifacts: list[FileParseArtifact] = field(default_factory=list)
+    callsites: list[CallSiteRecord] = field(default_factory=list)
+    value_slots: list[ValueSlot] = field(default_factory=list)
+    flow_edges: list[FlowEdge] = field(default_factory=list)
+    cpu_evidence: list[CpuEvidenceRecord] = field(default_factory=list)
+    linker_evidence: list[LinkerEvidenceRecord] = field(default_factory=list)
+    binary_evidence: list[BinaryEvidenceRecord] = field(default_factory=list)
+    dwarf_evidence: list[DwarfEvidenceRecord] = field(default_factory=list)
+    guarded_regions: list[GuardedSourceRegion] = field(default_factory=list)
+    static_symbol_store: Any | None = None
+
+    def functions(self) -> Iterable[FunctionRecord | CompactFunctionRecord]:
+        if self.static_symbol_store is not None:
+            yield from self.static_symbol_store.iter_functions()
+            return
+        for artifact in self.parse_artifacts:
+            yield from artifact.functions
+
+    def functions_named(self, names: set[str]) -> Iterable[FunctionRecord | CompactFunctionRecord]:
+        if not names:
+            return
+        if self.static_symbol_store is not None:
+            yield from self.static_symbol_store.iter_named(names)
+            return
+        for artifact in self.parse_artifacts:
+            funcs = artifact.functions
+            if isinstance(funcs, CompactFunctionTable):
+                yield from funcs.iter_named(names)
+            else:
+                for fn in funcs:
+                    if fn.name in names:
+                        yield fn
+
+    def functions_by_ids(self, qids: set[str]) -> Iterable[FunctionRecord | CompactFunctionRecord]:
+        if not qids:
+            return
+        if self.static_symbol_store is not None:
+            yield from self.static_symbol_store.iter_ids(qids)
+            return
+        for fn in self.functions():
+            if fn.qualified_id in qids:
+                yield fn
+
+    def function_count(self) -> int:
+        if self.static_symbol_store is not None:
+            return self.static_symbol_store.count()
+        return sum(len(a.functions) for a in self.parse_artifacts)