Skip to content

resolved_nodes

Define the semantic sidecar objects that analysis attaches to AST nodes and reuses during lowering.

Classes:

CallResolution dataclass 

CallResolution(
    callee: CallableResolution,
    signature: FunctionSignature,
    resolved_argument_types: tuple[DataType | None, ...],
    result_type: DataType,
    implicit_conversions: tuple[
        ImplicitConversion | None, ...
    ] = (),
)

Capture the canonical callee, validated argument conversions, and result type for one call site. attributes: callee: type: CallableResolution signature: type: FunctionSignature resolved_argument_types: type: tuple[astx.DataType | None, Ellipsis] result_type: type: astx.DataType implicit_conversions: type: tuple[ImplicitConversion | None, Ellipsis]

CallableResolution dataclass 

CallableResolution(
    function: SemanticFunction, signature: FunctionSignature
)

Point from one semantic site to the canonical callable identity and signature that analysis resolved. attributes: function: type: SemanticFunction signature: type: FunctionSignature

CallingConvention

Bases: str, Enum

Distinguish IRx-native callable semantics from C/native interop callables even when lowering currently emits the same LLVM calling convention.

ClassHeaderFieldKind

Bases: str, Enum

Name the reserved object-header slots that later lowering and dispatch phases can populate without changing the class object layout.

ClassInitializationSourceKind

Bases: str, Enum

Distinguish declaration-provided field initializers from implicit default construction values.

ClassMemberKind

Bases: str, Enum

ClassMemberResolutionKind

Bases: str, Enum

Distinguish members declared locally, members that override inherited declarations, and members inherited directly from the resolved MRO.

ClassObjectRepresentationKind

Bases: str, Enum

Distinguish whether class values are modeled as pointers or values.

CollectionMethodKind

Bases: str, Enum

FFIAdmissibility

Bases: str, Enum

Distinguish regular IRx callables from callables that satisfy the public FFI contract.

FFICallableInfo dataclass 

FFICallableInfo(
    admissibility: FFIAdmissibility,
    parameters: tuple[FFITypeInfo, ...],
    return_type: FFITypeInfo,
    required_runtime_features: tuple[str, ...] = (),
    link_strategy: FFILinkStrategy = SYSTEM_LINKER,
)

Record the validated FFI classification, type categories, symbol resolution strategy, and runtime-feature dependencies for one extern callable. attributes: admissibility: type: FFIAdmissibility parameters: type: tuple[FFITypeInfo, Ellipsis] return_type: type: FFITypeInfo required_runtime_features: type: tuple[str, Ellipsis] link_strategy: type: FFILinkStrategy

FFILinkStrategy

Bases: str, Enum

Describe whether an extern symbol relies only on the system linker or on one or more explicit runtime features.

FFITypeClass

Bases: str, Enum

Classify the narrow set of public ABI-safe value categories supported by IRx's current FFI contract.

FFITypeInfo dataclass 

FFITypeInfo(
    classification: FFITypeClass,
    display_name: str,
    metadata: dict[str, Any] = dict(),
)

Describe how one semantically validated public FFI type participates in the stable ABI contract. attributes: classification: type: FFITypeClass display_name: type: str metadata: type: dict[str, Any]

FunctionSignature dataclass 

FunctionSignature(
    name: str,
    parameters: tuple[ParameterSpec, ...],
    return_type: DataType,
    calling_convention: CallingConvention,
    is_variadic: bool = False,
    is_extern: bool = False,
    symbol_name: str = "",
    required_runtime_features: tuple[str, ...] = (),
    ffi: FFICallableInfo | None = None,
    metadata: dict[str, Any] = dict(),
)

Normalize the stable callable contract that semantic analysis resolves and lowering consumes. attributes: name: type: str parameters: type: tuple[ParameterSpec, Ellipsis] return_type: type: astx.DataType calling_convention: type: CallingConvention is_variadic: type: bool is_extern: type: bool symbol_name: type: str required_runtime_features: type: tuple[str, Ellipsis] ffi: type: FFICallableInfo | None metadata: type: dict[str, Any]

ImplicitConversion dataclass 

ImplicitConversion(
    source_type: DataType | None,
    target_type: DataType | None,
)

Record one source-to-target type conversion that semantic analysis validated and lowering should honor directly. attributes: source_type: type: astx.DataType | None target_type: type: astx.DataType | None

IterationKind

Bases: str, Enum

Classify the semantic adapter that turns one iterable expression into a backend iteration plan.

IterationOrder

Bases: str, Enum

Describe the user-visible order guarantee, if any, exposed by one iterable adapter.

MethodDispatchKind

Bases: str, Enum

Distinguish direct method calls from dispatch-table-driven instance calls.

ParameterPassingKind

Bases: str, Enum

Classify how one semantic parameter is passed across the callable boundary.

ParameterSpec dataclass 

ParameterSpec(
    name: str,
    type_: DataType,
    passing_kind: ParameterPassingKind = BY_VALUE,
    metadata: dict[str, Any] = dict(),
)

Describe one ordered callable parameter together with its declared type and passing policy, plus stable metadata such as default fingerprints. attributes: name: type: str type_: type: astx.DataType passing_kind: type: ParameterPassingKind metadata: type: dict[str, Any]

ResolvedAssignment dataclass 

ResolvedAssignment(target: SemanticSymbol)

Point from an assignment-like node back to the resolved target symbol it mutates. attributes: target: type: SemanticSymbol

ResolvedBaseClassFieldAccess dataclass 

ResolvedBaseClassFieldAccess(
    receiver_class: SemanticClass,
    base_class: SemanticClass,
    member: SemanticClassMember,
    field: SemanticClassLayoutField,
)

Point from a base-qualified instance attribute read to the selected base view, concrete receiver class, and stable flattened layout slot. attributes: receiver_class: type: SemanticClass base_class: type: SemanticClass member: type: SemanticClassMember field: type: SemanticClassLayoutField

ResolvedClassConstruction dataclass 

ResolvedClassConstruction(
    class_: SemanticClass,
    initialization: SemanticClassInitialization,
)

Capture the analyzed class identity and ordered initialization plan for one default class construction expression. attributes: class_: type: SemanticClass initialization: type: SemanticClassInitialization

ResolvedClassFieldAccess dataclass 

ResolvedClassFieldAccess(
    class_: SemanticClass,
    member: SemanticClassMember,
    field: SemanticClassLayoutField,
)

Point from a class-attribute access node to the owning class member and stable flattened layout slot. attributes: class_: type: SemanticClass member: type: SemanticClassMember field: type: SemanticClassLayoutField

ResolvedCollectionMethod dataclass 

ResolvedCollectionMethod(
    receiver_node: AST,
    receiver_type: DataType,
    method: CollectionMethodKind,
    return_type: DataType,
    argument_types: tuple[DataType, ...] = (),
    mutates: bool = False,
    extras: dict[str, Any] = dict(),
)

Attach the semantic collection operation that lowering should consume without re-resolving receiver kind or result type. attributes: receiver_node: type: astx.AST receiver_type: type: astx.DataType method: type: CollectionMethodKind return_type: type: astx.DataType argument_types: type: tuple[astx.DataType, Ellipsis] mutates: type: bool extras: type: dict[str, Any]

ResolvedContextManager dataclass 

ResolvedContextManager(
    class_: SemanticClass,
    manager_type: DataType,
    enter: ResolvedMethodCall,
    exit: ResolvedMethodCall,
    target_symbol: SemanticSymbol | None = None,
)

Capture the manager class, resolved __enter__/__exit__ methods, and optional target binding for one with statement. attributes: class_: type: SemanticClass manager_type: type: astx.DataType enter: type: ResolvedMethodCall exit: type: ResolvedMethodCall target_symbol: type: SemanticSymbol | None

ResolvedFieldAccess dataclass 

ResolvedFieldAccess(
    struct: SemanticStruct, field: SemanticStructField
)

Point from a field-access node to its owning struct and stable field metadata. attributes: struct: type: SemanticStruct field: type: SemanticStructField

ResolvedGeneratorFunction dataclass 

ResolvedGeneratorFunction(
    function: "SemanticFunction",
    yield_type: DataType,
    yield_nodes: tuple[AST, ...] = (),
)

Describe one function body that suspends at yield sites and returns a first-class generator object from call sites. attributes: function: type: SemanticFunction yield_type: type: astx.DataType yield_nodes: type: tuple[astx.AST, Ellipsis]

ResolvedImportBinding dataclass 

ResolvedImportBinding(
    local_name: str,
    requested_name: str,
    source_module_key: ModuleKey,
    binding: SemanticBinding,
)

Record how one imported local name maps back to its source-module declaration. attributes: local_name: type: str requested_name: type: str source_module_key: type: ModuleKey binding: type: SemanticBinding

ResolvedIteration dataclass 

ResolvedIteration(
    iterable_node: AST,
    iterable_type: DataType,
    element_type: DataType,
    kind: IterationKind,
    is_reiterable: bool = True,
    order: IterationOrder = UNSPECIFIED,
    target_symbol: SemanticSymbol | None = None,
    extras: dict[str, Any] = dict(),
)

Attach the semantic iteration plan that a for-in loop or comprehension should consume during backend lowering. attributes: iterable_node: type: astx.AST iterable_type: type: astx.DataType element_type: type: astx.DataType kind: type: IterationKind is_reiterable: type: bool order: type: IterationOrder target_symbol: type: SemanticSymbol | None extras: type: dict[str, Any]

ResolvedMethodCall dataclass 

ResolvedMethodCall(
    class_: SemanticClass,
    member: SemanticClassMember,
    function: SemanticFunction,
    overload_key: str,
    dispatch_kind: MethodDispatchKind,
    call: CallResolution,
    candidates: tuple[SemanticClassMember, ...] = (),
    receiver_type: DataType | None = None,
    receiver_class: SemanticClass | None = None,
    slot_index: int | None = None,
)

Capture the resolved class member, lowered implementation, dispatch mode, and validated argument conversions for one method call site. attributes: class_: type: SemanticClass member: type: SemanticClassMember function: type: SemanticFunction overload_key: type: str dispatch_kind: type: MethodDispatchKind call: type: CallResolution candidates: type: tuple[SemanticClassMember, Ellipsis] receiver_type: type: astx.DataType | None receiver_class: type: SemanticClass | None slot_index: type: int | None

ResolvedModuleMemberAccess dataclass 

ResolvedModuleMemberAccess(
    module: SemanticModule,
    member_name: str,
    binding: SemanticBinding,
)

Record which imported module namespace one member access targeted and the visible binding that namespace lookup selected. attributes: module: type: SemanticModule member_name: type: str binding: type: SemanticBinding

ResolvedOperator dataclass 

ResolvedOperator(
    op_code: str,
    result_type: DataType | None = None,
    lhs_type: DataType | None = None,
    rhs_type: DataType | None = None,
    flags: SemanticFlags = SemanticFlags(),
)

Capture the normalized operator opcode, operand types, result type, and semantic flags for one expression. attributes: op_code: type: str result_type: type: astx.DataType | None lhs_type: type: astx.DataType | None rhs_type: type: astx.DataType | None flags: type: SemanticFlags

ResolvedStaticClassFieldAccess dataclass 

ResolvedStaticClassFieldAccess(
    class_: SemanticClass,
    member: SemanticClassMember,
    storage: SemanticClassStaticStorage,
)

Point from a class-qualified static attribute read to the selected class member and stable emitted storage metadata. attributes: class_: type: SemanticClass member: type: SemanticClassMember storage: type: SemanticClassStaticStorage

ResolvedYield dataclass 

ResolvedYield(
    generator: ResolvedGeneratorFunction,
    expected_type: DataType,
    value_type: DataType | None,
    site_index: int,
    implicit_conversion: ImplicitConversion | None = None,
)

Capture how one yield statement or expression maps to its enclosing generator function and yielded element type. attributes: generator: type: ResolvedGeneratorFunction expected_type: type: astx.DataType value_type: type: astx.DataType | None site_index: type: int implicit_conversion: type: ImplicitConversion | None

ReturnResolution dataclass 

ReturnResolution(
    callable: CallableResolution,
    expected_type: DataType,
    value_type: DataType | None,
    returns_void: bool,
    implicit_conversion: ImplicitConversion | None = None,
)

Capture how one return statement relates to the enclosing function signature and any implicit conversion that analysis inserted. attributes: callable: type: CallableResolution expected_type: type: astx.DataType value_type: type: astx.DataType | None returns_void: type: bool implicit_conversion: type: ImplicitConversion | None

SemanticBinding dataclass 

SemanticBinding(
    kind: str,
    module_key: ModuleKey,
    qualified_name: str,
    function: SemanticFunction | None = None,
    struct: SemanticStruct | None = None,
    class_: SemanticClass | None = None,
    module: SemanticModule | None = None,
)

Normalize imported and local top-level names into one binding shape for module-visible lookup. attributes: kind: type: str module_key: type: ModuleKey qualified_name: type: str function: type: SemanticFunction | None struct: type: SemanticStruct | None class_: type: SemanticClass | None module: type: SemanticModule | None

SemanticClass dataclass 

SemanticClass(
    symbol_id: str,
    name: str,
    module_key: ModuleKey,
    qualified_name: str,
    declaration: ClassDefStmt,
    bases: tuple["SemanticClass", ...] = (),
    declared_members: tuple[SemanticClassMember, ...] = (),
    declared_member_table: dict[
        str, SemanticClassMember
    ] = dict(),
    declared_method_groups: dict[
        str, tuple[SemanticClassMember, ...]
    ] = dict(),
    member_table: dict[str, SemanticClassMember] = dict(),
    method_groups: dict[
        str, tuple[SemanticClassMember, ...]
    ] = dict(),
    member_resolution: dict[
        str, SemanticClassMemberResolution
    ] = dict(),
    method_resolution: dict[
        str, tuple[SemanticClassMemberResolution, ...]
    ] = dict(),
    instance_attributes: tuple[
        SemanticClassMember, ...
    ] = (),
    static_attributes: tuple[SemanticClassMember, ...] = (),
    instance_methods: tuple[SemanticClassMember, ...] = (),
    static_methods: tuple[SemanticClassMember, ...] = (),
    abstract_methods: tuple[SemanticClassMember, ...] = (),
    inheritance_graph: tuple[str, ...] = (),
    shared_ancestors: tuple["SemanticClass", ...] = (),
    layout: SemanticClassLayout | None = None,
    initialization: SemanticClassInitialization
    | None = None,
    mro: tuple["SemanticClass", ...] = (),
    is_structurally_resolved: bool = False,
    is_resolved: bool = False,
    is_abstract: bool = False,
)

Describe one top-level class declaration together with normalized bases, member tables, and deterministic inheritance metadata. attributes: symbol_id: type: str name: type: str module_key: type: ModuleKey qualified_name: type: str declaration: type: astx.ClassDefStmt bases: type: tuple[SemanticClass, Ellipsis] declared_members: type: tuple[SemanticClassMember, Ellipsis] declared_member_table: type: dict[str, SemanticClassMember] declared_method_groups: type: dict[str, tuple[SemanticClassMember, Ellipsis]] member_table: type: dict[str, SemanticClassMember] method_groups: type: dict[str, tuple[SemanticClassMember, Ellipsis]] member_resolution: type: dict[str, SemanticClassMemberResolution] method_resolution: type: dict[str, tuple[SemanticClassMemberResolution, Ellipsis]] instance_attributes: type: tuple[SemanticClassMember, Ellipsis] static_attributes: type: tuple[SemanticClassMember, Ellipsis] instance_methods: type: tuple[SemanticClassMember, Ellipsis] static_methods: type: tuple[SemanticClassMember, Ellipsis] abstract_methods: type: tuple[SemanticClassMember, Ellipsis] inheritance_graph: type: tuple[str, Ellipsis] shared_ancestors: type: tuple[SemanticClass, Ellipsis] layout: type: SemanticClassLayout | None initialization: type: SemanticClassInitialization | None mro: type: tuple[SemanticClass, Ellipsis] is_structurally_resolved: type: bool is_resolved: type: bool is_abstract: type: bool

SemanticClassFieldInitializer dataclass 

SemanticClassFieldInitializer(
    field: SemanticClassLayoutField,
    source_kind: ClassInitializationSourceKind,
    value: AST | None,
    owner_name: str,
    owner_qualified_name: str,
)

Record the ordered value source for one instance field during default class construction. attributes: field: type: SemanticClassLayoutField source_kind: type: ClassInitializationSourceKind value: type: astx.AST | None owner_name: type: str owner_qualified_name: type: str

SemanticClassHeaderField dataclass 

SemanticClassHeaderField(
    name: str,
    kind: ClassHeaderFieldKind,
    storage_index: int,
)

Describe one hidden header entry that occupies a stable index in every class object representation. attributes: name: type: str kind: type: ClassHeaderFieldKind storage_index: type: int

SemanticClassInitialization dataclass 

SemanticClassInitialization(
    instance_initializers: tuple[
        SemanticClassFieldInitializer, ...
    ] = (),
    static_initializers: tuple[
        SemanticClassStaticInitializer, ...
    ] = (),
)

Normalize the ordered instance-field and static-field initialization plan that semantic analysis resolves for one class. attributes: instance_initializers: type: tuple[SemanticClassFieldInitializer, Ellipsis] static_initializers: type: tuple[SemanticClassStaticInitializer, Ellipsis]

SemanticClassLayout dataclass 

SemanticClassLayout(
    llvm_name: str,
    object_representation: ClassObjectRepresentationKind,
    descriptor_global_name: str,
    dispatch_global_name: str,
    header_fields: tuple[
        SemanticClassHeaderField, ...
    ] = (),
    instance_fields: tuple[
        SemanticClassLayoutField, ...
    ] = (),
    field_slots: dict[
        str, SemanticClassLayoutField
    ] = dict(),
    visible_field_slots: dict[
        str, SemanticClassLayoutField
    ] = dict(),
    dispatch_entries: tuple[
        SemanticClassMethodDispatch, ...
    ] = (),
    dispatch_slots: dict[
        int, SemanticClassMethodDispatch
    ] = dict(),
    visible_method_slots: dict[
        str, SemanticClassMethodDispatch
    ] = dict(),
    dispatch_table_size: int = 0,
    static_fields: tuple[
        SemanticClassStaticStorage, ...
    ] = (),
    static_storage: dict[
        str, SemanticClassStaticStorage
    ] = dict(),
    visible_static_storage: dict[
        str, SemanticClassStaticStorage
    ] = dict(),
)

Normalize the low-level object representation, hidden header slots, flattened instance-field storage, and static-global storage names for one class. attributes: llvm_name: type: str object_representation: type: ClassObjectRepresentationKind descriptor_global_name: type: str dispatch_global_name: type: str header_fields: type: tuple[SemanticClassHeaderField, Ellipsis] instance_fields: type: tuple[SemanticClassLayoutField, Ellipsis] field_slots: type: dict[str, SemanticClassLayoutField] visible_field_slots: type: dict[str, SemanticClassLayoutField] dispatch_entries: type: tuple[SemanticClassMethodDispatch, Ellipsis] dispatch_slots: type: dict[int, SemanticClassMethodDispatch] visible_method_slots: type: dict[str, SemanticClassMethodDispatch] dispatch_table_size: type: int static_fields: type: tuple[SemanticClassStaticStorage, Ellipsis] static_storage: type: dict[str, SemanticClassStaticStorage] visible_static_storage: type: dict[str, SemanticClassStaticStorage]

SemanticClassLayoutField dataclass 

SemanticClassLayoutField(
    member: SemanticClassMember,
    logical_index: int,
    storage_index: int,
    owner_name: str,
    owner_qualified_name: str,
)

Record the stable storage position for one declared instance attribute in the flattened class-object layout. attributes: member: type: SemanticClassMember logical_index: type: int storage_index: type: int owner_name: type: str owner_qualified_name: type: str

SemanticClassMember dataclass 

SemanticClassMember(
    symbol_id: str,
    name: str,
    qualified_name: str,
    owner_name: str,
    owner_qualified_name: str,
    kind: ClassMemberKind,
    visibility: VisibilityKind,
    is_static: bool,
    is_abstract: bool,
    is_constant: bool,
    is_mutable: bool,
    declaration: AST,
    type_: DataType | None = None,
    signature: FunctionSignature | None = None,
    signature_key: str | None = None,
    overrides: str | None = None,
    dispatch_slot: int | None = None,
    lowered_function: "SemanticFunction" | None = None,
)

Normalize one declared class member so later phases can reason about visibility, storage, mutability, and overrides without re-reading raw AST modifier fields. attributes: symbol_id: type: str name: type: str qualified_name: type: str owner_name: type: str owner_qualified_name: type: str kind: type: ClassMemberKind visibility: type: astx.VisibilityKind is_static: type: bool is_abstract: type: bool is_constant: type: bool is_mutable: type: bool declaration: type: astx.AST type_: type: astx.DataType | None signature: type: FunctionSignature | None signature_key: type: str | None overrides: type: str | None dispatch_slot: type: int | None lowered_function: type: SemanticFunction | None

SemanticClassMemberResolution dataclass 

SemanticClassMemberResolution(
    name: str,
    kind: ClassMemberResolutionKind,
    selected: SemanticClassMember,
    candidates: tuple[SemanticClassMember, ...] = (),
    signature_key: str | None = None,
)

Record the ordered candidate set that one class member name considered and the member that won after deterministic inheritance resolution. attributes: name: type: str kind: type: ClassMemberResolutionKind selected: type: SemanticClassMember candidates: type: tuple[SemanticClassMember, Ellipsis] signature_key: type: str | None

SemanticClassMethodDispatch dataclass 

SemanticClassMethodDispatch(
    member: SemanticClassMember,
    function: "SemanticFunction",
    slot_index: int,
    owner_name: str,
    owner_qualified_name: str,
)

Record the stable dispatch slot and lowered function implementation for one visible instance method. attributes: member: type: SemanticClassMember function: type: SemanticFunction slot_index: type: int owner_name: type: str owner_qualified_name: type: str

SemanticClassStaticInitializer dataclass 

SemanticClassStaticInitializer(
    storage: SemanticClassStaticStorage,
    source_kind: ClassInitializationSourceKind,
    value: AST | None,
    owner_name: str,
    owner_qualified_name: str,
)

Record the deterministic module-global initializer source for one static class attribute. attributes: storage: type: SemanticClassStaticStorage source_kind: type: ClassInitializationSourceKind value: type: astx.AST | None owner_name: type: str owner_qualified_name: type: str

SemanticClassStaticStorage dataclass 

SemanticClassStaticStorage(
    member: SemanticClassMember,
    global_name: str,
    owner_name: str,
    owner_qualified_name: str,
)

Describe the module-global storage backing one declared static class attribute. attributes: member: type: SemanticClassMember global_name: type: str owner_name: type: str owner_qualified_name: type: str

SemanticFlags dataclass 

SemanticFlags(
    unsigned: bool = False,
    fast_math: bool = False,
    fma: bool = False,
    fma_rhs: AST | None = None,
)

Store normalized semantic modifiers such as unsigned and fast-math intent. attributes: unsigned: type: bool fast_math: type: bool fma: type: bool fma_rhs: type: astx.AST | None

SemanticFunction dataclass 

SemanticFunction(
    symbol_id: str,
    name: str,
    return_type: DataType,
    args: tuple[SemanticSymbol, ...],
    signature: FunctionSignature,
    prototype: FunctionPrototype,
    definition: FunctionDef | None = None,
    module_key: ModuleKey = (lambda: "<unknown>")(),
    qualified_name: str = "",
    template_params: tuple[TemplateParam, ...] = (),
    template_bindings: tuple[
        TemplateArgumentBinding, ...
    ] = (),
    template_definition: "SemanticFunction" | None = None,
    specialization_key: TemplateSpecializationKey
    | None = None,
    specializations: dict[
        TemplateSpecializationKey, "SemanticFunction"
    ] = dict(),
)

Describe one top-level function declaration or definition together with its semantic identity, canonical signature, and argument symbols. attributes: symbol_id: type: str name: type: str return_type: type: astx.DataType args: type: tuple[SemanticSymbol, Ellipsis] signature: type: FunctionSignature prototype: type: astx.FunctionPrototype definition: type: astx.FunctionDef | None module_key: type: ModuleKey qualified_name: type: str template_params: type: tuple[astx.TemplateParam, Ellipsis] template_bindings: type: tuple[TemplateArgumentBinding, Ellipsis] template_definition: type: SemanticFunction | None specialization_key: type: TemplateSpecializationKey | None specializations: type: dict[TemplateSpecializationKey, SemanticFunction]

SemanticInfo dataclass 

SemanticInfo(
    resolved_type: DataType | None = None,
    resolved_symbol: SemanticSymbol | None = None,
    resolved_function: SemanticFunction | None = None,
    resolved_callable: CallableResolution | None = None,
    resolved_struct: SemanticStruct | None = None,
    resolved_class: SemanticClass | None = None,
    resolved_module: SemanticModule | None = None,
    resolved_imports: tuple[
        ResolvedImportBinding, ...
    ] = (),
    resolved_call: CallResolution | None = None,
    resolved_operator: ResolvedOperator | None = None,
    resolved_assignment: ResolvedAssignment | None = None,
    resolved_field_access: ResolvedFieldAccess
    | None = None,
    resolved_module_member_access: ResolvedModuleMemberAccess
    | None = None,
    resolved_class_field_access: ResolvedClassFieldAccess
    | None = None,
    resolved_base_class_field_access: ResolvedBaseClassFieldAccess
    | None = None,
    resolved_static_class_field_access: ResolvedStaticClassFieldAccess
    | None = None,
    resolved_method_call: ResolvedMethodCall | None = None,
    resolved_context_manager: ResolvedContextManager
    | None = None,
    resolved_class_construction: ResolvedClassConstruction
    | None = None,
    resolved_return: ReturnResolution | None = None,
    resolved_generator_function: ResolvedGeneratorFunction
    | None = None,
    resolved_yield: ResolvedYield | None = None,
    resolved_iteration: ResolvedIteration | None = None,
    resolved_collection_method: ResolvedCollectionMethod
    | None = None,
    semantic_flags: SemanticFlags = SemanticFlags(),
    extras: dict[str, Any] = dict(),
)

Aggregate all semantic sidecar fields that analysis may attach to a single AST node. attributes: resolved_type: type: astx.DataType | None resolved_symbol: type: SemanticSymbol | None resolved_function: type: SemanticFunction | None resolved_callable: type: CallableResolution | None resolved_struct: type: SemanticStruct | None resolved_class: type: SemanticClass | None resolved_module: type: SemanticModule | None resolved_imports: type: tuple[ResolvedImportBinding, Ellipsis] resolved_call: type: CallResolution | None resolved_operator: type: ResolvedOperator | None resolved_assignment: type: ResolvedAssignment | None resolved_field_access: type: ResolvedFieldAccess | None resolved_module_member_access: type: ResolvedModuleMemberAccess | None resolved_class_field_access: type: ResolvedClassFieldAccess | None resolved_base_class_field_access: type: ResolvedBaseClassFieldAccess | None resolved_static_class_field_access: type: ResolvedStaticClassFieldAccess | None resolved_method_call: type: ResolvedMethodCall | None resolved_context_manager: type: ResolvedContextManager | None resolved_class_construction: type: ResolvedClassConstruction | None resolved_return: type: ReturnResolution | None resolved_generator_function: type: ResolvedGeneratorFunction | None resolved_yield: type: ResolvedYield | None resolved_iteration: type: ResolvedIteration | None resolved_collection_method: type: ResolvedCollectionMethod | None semantic_flags: type: SemanticFlags extras: type: dict[str, Any]

SemanticModule dataclass 

SemanticModule(
    module_key: ModuleKey, display_name: str | None = None
)

Represent a module binding that plain imports introduce into a module namespace. attributes: module_key: type: ModuleKey display_name: type: str | None

SemanticStruct dataclass 

SemanticStruct(
    symbol_id: str,
    name: str,
    module_key: ModuleKey,
    qualified_name: str,
    declaration: StructDefStmt,
    fields: tuple["SemanticStructField", ...] = (),
    field_indices: dict[str, int] = dict(),
)

Describe one top-level struct declaration with module-aware identity. attributes: symbol_id: type: str name: type: str module_key: type: ModuleKey qualified_name: type: str declaration: type: astx.StructDefStmt fields: type: tuple[SemanticStructField, Ellipsis] field_indices: type: dict[str, int]

SemanticStructField dataclass 

SemanticStructField(
    name: str,
    index: int,
    type_: DataType,
    declaration: VariableDeclaration,
)

Describe one ordered field within a semantic struct, including its stable index and resolved field type. attributes: name: type: str index: type: int type_: type: astx.DataType declaration: type: astx.VariableDeclaration

SemanticSymbol dataclass 

SemanticSymbol(
    symbol_id: str,
    name: str,
    type_: DataType,
    is_mutable: bool,
    kind: str,
    declaration: AST | None = None,
    module_key: ModuleKey = (lambda: "<unknown>")(),
    qualified_name: str = "",
)

Describe one resolved variable-like symbol, including its stable semantic id and declared type. attributes: symbol_id: type: str name: type: str type_: type: astx.DataType is_mutable: type: bool kind: type: str declaration: type: astx.AST | None module_key: type: ModuleKey qualified_name: type: str

TemplateArgumentBinding dataclass 

TemplateArgumentBinding(name: str, type_: DataType)

Record the concrete type selected for one named template parameter in a specialization. attributes: name: type: str type_: type: astx.DataType

TemplateSpecializationKey dataclass 

TemplateSpecializationKey(
    qualified_name: str, arg_type_names: tuple[str, ...]
)

Identify one concrete specialization of a template function by the original semantic function name and the ordered concrete type names. attributes: qualified_name: type: str arg_type_names: type: tuple[str, Ellipsis]