Struct ImportedProvider 

pub struct ImportedProvider {
    pub name: String,
    pub backend: BackendId,
    pub kernel_source: &'static str,
    pub revision_base: Option<String>,
    pub link_registry: Option<String>,
    pub primitives: Vec<ResolvedPrimitive>,
    pub fused: Vec<ResolvedFused>,
    pub warnings: Vec<ImportWarning>,
}

A parsed + validated provider bundle, holding the resolved per-kernel records ready to register. Construction (import_*) already ran the parse + restricted-YAML pre-pass + lowering (string → typed dispatch records); Self::register_into only does the registry inserts + the duplicate-detection gate.

Fields

name: String

provider.name (front-matter).

backend: BackendId

provider.backend (front-matter), the registry key backend.

kernel_source: &'static str

provider.kernel_source (front-matter), interned to &'static.

revision_base: Option<String>

provider.revision_base (front-matter) — the provider build id folded into kernel_revision_hash.

Retained on the imported provider specifically so import_glob can enforce §9.2’s “front-matter must agree across files”. It was previously consumed during lowering and dropped, which made that agreement structurally uncheckable: two files of one globbed provider could declare different bases, and since revision_base feeds kernel_revision_hash — the key the verification ledger is looked up by — the merged provider would silently carry kernels whose revision hashes were computed against different roots.

link_registry: Option<String>

provider.link_registry (front-matter) — the symbol path of the table this file’s entry_points are declared to resolve against.

Retained for the same reason as Self::revision_base: §9.2 requires it to AGREE across a glob’s files, and a field that is consumed during lowering and dropped cannot be compared at merge time. import_glob binds every file it merges through the single registry its caller supplied, so disagreement here means at least one file’s entry points were resolved against a table its author never named.

primitives: Vec<ResolvedPrimitive>

Lowered op_kind contracts → the binding table.

fused: Vec<ResolvedFused>

Lowered fused_op contracts → the fused registry.

warnings: Vec<ImportWarning>

Soft import diagnostics (§3.5 warns, precision downgrades, etc.).

Implementations

impl ImportedProvider

pub fn register_into( &self, table: &mut KernelBindingTable, fused: &mut FusedKernelRegistry, ) -> Result<(), FkcError>

Register every primitive contract into table and every fused contract into fused, then run the duplicate-detection gate.

Describe-only sections (registrable: false, §3.10) are already excluded before this point: lower_file (called by the import_* constructors) filters them out, so self.primitives / self.fused contain only registrable kernels. A documentation-only section therefore never reaches the binding table / fused registry or the duplicate- KernelRef gate — it is honest docs, not a dispatch decision point.

Per slice (§2.1 / §2.2): each primitive becomes a KernelBindingTable::register_full_with_source insert; each fused op becomes a FusedKernelRegistry::register of a BackendImpl. Cost is the sentinel for every kernel this slice — unknown_cost for primitives, fused_unknown_cost for fused ops (see the module-level cost note); the parsed cost AST stays on the Resolved* record.

register_full_with_source is append-only and returns () today; the same KernelRef driven onto one (op, dtypes, backend) key twice is detected by KernelBindingTable::finalize, which this method calls after all inserts and maps to FkcError::DuplicateKernelRef (never a panic — the import path is Result end-to-end).

Trait Implementations

impl Clone for ImportedProvider

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ImportedProvider

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.