Struct ImplTable 

pub struct ImplTable {
    pub diags: DiagnosticBag,
    /* private fields */
}

Maps (TraitRef, Type) pairs to impl blocks and supports method dispatch.

Construction

let table = ImplTable::build_from(&air_module_node);
// inspect table.diags for coherence errors

Querying

let impl_id = resolve_impl(&TraitRef::new("Equatable"), &ty, &table)?;
let method  = resolve_method(&receiver_ty, "equals", &table)?;

Fields

diags: DiagnosticBag

Diagnostics emitted during construction (coherence errors use E4010).

Implementations

impl ImplTable

pub fn new() -> Self

Create a new, empty ImplTable.

pub fn build_from(module: &AIRNode) -> Self

Build an ImplTable by walking the top-level items of an AIR module node.

The node must have NodeKind::Module; other node kinds produce an empty table. Coherence checking (exact-type impl overlap detection) runs during construction and emits E4010 diagnostics for any duplicate (Trait, Type) pair.

pub fn register_supertrait( &mut self, sub_trait: impl Into<String>, super_trait: impl Into<String>, )

Register a direct supertrait relationship: every impl of sub_trait must also impl super_trait.

pub fn register_trait_impl( &mut self, trait_name: impl Into<String>, ty: &Type, ) -> ImplId

Programmatically register a trait impl for a concrete type.

This is a convenience method for tests and downstream passes that need to populate the table without building from AIR nodes. The registered entry is not marked canonical; use register_canonical_conformances for the compiler-provided primitive conformances.

pub fn register_param_trait_impl( &mut self, trait_name: impl Into<String>, trait_args: &[Type], ty: &Type, is_derived: bool, ) -> ImplId

Programmatically register a parameterized trait impl for a concrete type, e.g. From[Source] for Target. Like Self::register_trait_impl the entry is not marked canonical. Pass is_derived = true for an entry synthesized from another impl (e.g. the blanket Into).

pub fn fold_imported_impls(&mut self, impls: &[(String, Vec<Type>, Type)])

Fold trait impls collected from imported modules into this table (Q-xmod-impl), then re-run blanket-Into synthesis.

Each (trait_name, trait_args, target) is registered the same way a local impl would be: parameterized when trait_args is non-empty (From[A] for B), plain otherwise (Comparable for B). An entry is skipped when its slot is already occupied (a local impl, a canonical conformance, or another imported impl already covers it), so importing never clobbers a local registration and re-importing is idempotent.

After registering the imported From impls, the blanket-Into synthesis runs again so an imported From[A] for B yields the blanket Into[B] for A needed by a.into() in the importing module.

pub fn register_assoc_type( &mut self, impl_id: ImplId, name: impl Into<String>, ty: Type, )

Register an associated type binding for a given impl block.

Overrides any existing binding for (impl_id, name).

pub fn resolve_assoc_type(&self, impl_id: ImplId, name: &str) -> Option<&Type>

Look up an associated type binding by impl id and name.

Returns None if no binding has been registered.

pub fn all_supertraits(&self, trait_name: &str) -> Vec<String>

Return all supertraits of trait_name, collected transitively via BFS.

The result list is in BFS order (direct supertraits before their supertraits) with no duplicates. The original trait_name is not included.

pub fn get_entry(&self, id: ImplId) -> Option<&ImplEntry>

Get the impl entry for an id.

pub fn entries(&self) -> impl Iterator<Item = &ImplEntry>

Iterate over all registered entries.

pub fn exportable_trait_impls(&self) -> Vec<(String, Vec<Type>, Type)>

Collect the user-declared trait impls that should be visible to a module importing this one (Q-xmod-impl).

Each entry is (trait_name, trait_args, target_type). Only impls that a downstream module needs to re-register are returned:

• canonical entries (compiler-provided primitive conformances) are excluded — every module re-adds them via register_canonical_conformances / register_canonical_conversions;
• derived entries (e.g. the blanket Into[U] synthesized from a From[T] for U) are excluded — they are re-synthesized locally by the blanket-Into synthesis from the re-registered From;
• generic impls are excluded — cross-module generic-impl instantiation is out of scope for v1.

Both parameterized impls (From[A] for B) and plain trait impls (Comparable for B) are returned, so a cross-module .into() resolves and an imported generic fn’s T: Comparable bound is satisfiable by an imported impl Comparable for B.

Impls whose target type is a primitive are excluded: the compiler’s canonical primitive conversions (From[Int] for Float, …) register without the is_canonical flag set and would otherwise leak into the export, and a primitive’s conformances are re-registered locally in every module anyway (and sealing forbids user core-trait impls on primitives). The cross-module impls that matter target user-defined (Named) types.

pub fn has_any_param_trait_impl(&self, trait_name: &str, type_key: &str) -> bool

Returns true if any parameterized impl of trait_name exists for type_key, regardless of the trait’s type argument.

This backs the v1 arg-imprecise satisfaction of a parameterized bound such as T: Into[U]: because the bound’s type argument is dropped at parse time (the where-clause stores only the trait path), the checker cannot key on the exact [U]. It instead accepts the bound when the concrete T implements the trait for some argument. See the session PR notes for this documented limitation.

Trait Implementations

impl Default for ImplTable

fn default() -> Self

Returns the “default value” for a type.