crates.sage_ir.symbols.local_identity

A local symbol’s identity fields identify its definition. Independently tracked CST, spans, signatures, members, and bodies do not become part of that identity. Detail-only changes preserve the symbol, and consumers of unchanged sibling facts remain reusable; genuine identity changes are distinguishable.

Read in specification context · design/crates/sage_ir/symbols.sage

Implementation

Implemented crates/sage-ir/src/local_syms/associated.rs:23–28

sage_ir::local_syms::associated · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
// {anchor}`crates.sage_ir.symbols.associated_identity`
pub(crate) struct LocalAssociatedItemKey<'db> {
    pub kind: LocalAssociatedItemKind,
    pub name: Name<'db>,
    pub occurrence: u32,

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/consts.rs:12–17

sage_ir::local_syms::consts · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalConstSym<'db> {
    pub name: Name<'db>,
    pub scope: ScopeSymbol<'db>,
    pub owner: Option<LocalAssociatedOwner<'db>>,


}

See more source ↗

Implemented crates/sage-ir/src/local_syms/enums.rs:12–17

sage_ir::local_syms::enums · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalEnumSym<'db> {
    pub name: Name<'db>,
    pub scope: ScopeSymbol<'db>,

    #[tracked]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/enums.rs:98–103

sage_ir::local_syms::enums · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalVariantSym<'db> {
    pub name: Name<'db>,
    pub parent_enum: LocalEnumSym<'db>,
    #[tracked]
    #[returns(ref)]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/enums.rs:122–127

sage_ir::local_syms::enums · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalVariantCtorSym<'db> {
    pub name: Name<'db>,
    pub variant: LocalVariantSym<'db>,
}


}

See more source ↗

Implemented crates/sage-ir/src/local_syms/fns.rs:87–92

sage_ir::local_syms::fns · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
// {anchor}`crates.sage_ir.symbols.associated_identity`
// {anchor}`crates.sage_ir.modules.parse.detail_firewall`
// {anchor}`crates.sage_ir.types.spans.offset_reuse`
pub struct LocalFnSym<'db> {
    pub name: Name<'db>,

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/impls.rs:9–14

sage_ir::local_syms::impls · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalImplSym<'db> {
    pub scope: ScopeSymbol<'db>,

    #[tracked]
    #[returns(ref)]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/macro_defs.rs:11–16

sage_ir::local_syms::macro_defs · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalMacroDefSym<'db> {
    pub name: Name<'db>,
    pub scope: ScopeSymbol<'db>,

    #[tracked]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/macro_invocations.rs:15–20

sage_ir::local_syms::macro_invocations · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
// {anchor}`crates.sage_ir.types.spans.generated_identity`
pub struct LocalMacroInvocationSym<'db> {
    pub scope: ScopeSymbol<'db>,

    #[tracked]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/mods.rs:20–25

sage_ir::local_syms::mods · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalModSym<'db> {
    pub name: Name<'db>,

    /// The crate edition is copied onto modules so resolution performed while
    /// expanding the root module does not require a cyclic root-to-crate edge.

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/statics.rs:10–15

sage_ir::local_syms::statics · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalStaticSym<'db> {
    pub name: Name<'db>,
    pub scope: ScopeSymbol<'db>,

    #[tracked]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/structs.rs:13–18

sage_ir::local_syms::structs · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalStructSym<'db> {
    pub name: Name<'db>,
    pub scope: ScopeSymbol<'db>,

    #[tracked]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/traits.rs:10–15

sage_ir::local_syms::traits · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalTraitSym<'db> {
    pub name: Name<'db>,
    pub scope: ScopeSymbol<'db>,

    #[tracked]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/type_aliases.rs:12–17

sage_ir::local_syms::type_aliases · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalTypeAliasSym<'db> {
    pub name: Name<'db>,
    pub scope: ScopeSymbol<'db>,
    pub owner: Option<LocalAssociatedOwner<'db>>,


}

See more source ↗

Implemented crates/sage-ir/src/local_syms/uses.rs:13–18

sage_ir::local_syms::uses · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_ir.symbols.local_identity`
pub struct LocalUseSym<'db> {
    pub scope: ScopeSymbol<'db>,

    #[tracked]
    #[returns(ref)]

}

See more source ↗

Tests and review

Indexed tests and the implementation-completeness and test-adequacy review; no test run is implied.

TODO sage_meta::todo::symbols_local_identity

crates/sage-meta/tests/representation_spec.rs · test:representation_spec

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_ir.symbols.local_identity)]
    fn symbols_local_identity() {
        // TODO: Extend the per-kind detail matrix to sibling insertion/reordering and
        // signature/member/body reuse for every local kind.
    }
}

See more source ↗

Implemented sage_test_harness::trait_system_tests::detail_edits_preserve_local_symbol_query_keys

crates/sage-test-harness/src/lib.rs · lib:sage_test_harness

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_ir.symbols.local_identity)]
    #[sage::test(crates.sage_ir.modules.parse.detail_firewall)]
    fn detail_edits_preserve_local_symbol_query_keys() {
        use salsa::Setter as _;

        struct Case {
            label: &'static str,
            before: &'static str,
            after: &'static str,
            item_index: usize,
        }

        fn force_observer(db: &dyn Db, source_file: SourceFile, item_index: usize) {
            let (_, root) = setup_root_module(db, source_file);
            let ModSymbol::Local(root) = root else {
                panic!("expected a local root module")
            };
            let item = root
                .unexpanded_items(db)
                .get(item_index)
                .copied()
                .expect("expected observed item");
            assert!(
                !matches!(item, sage_ir::local_syms::LocalModItemSym::Error(_)),
                "expected a represented item, got a parse error"
            );
            let symbol: Symbol<'_> = item.into();
            observe_symbol_identity(db, ObservedSymbol::new(db, symbol));
        }

        let cases = [
            Case {
                label: "function",
                before: "fn item() -> bool { false }",
                after: "fn item() -> bool { true }",
                item_index: 0,
            },
            Case {
                label: "struct",
                before: "struct Item { value: bool }",
                after: "struct Item { value: u32 }",
                item_index: 0,
            },
            Case {
                label: "enum",
                before: "enum Item { Value(bool) }",
                after: "enum Item { Value(u32) }",
                item_index: 0,
            },
            Case {
                label: "trait",
                before: "trait Item { fn value() -> bool; }",
                after: "trait Item { fn value() -> u32; }",
                item_index: 0,
            },
            Case {
                label: "impl",
                before: "struct Item; impl Item { fn value() -> bool { false } }",
                after: "struct Item; impl Item { fn value() -> bool { true } }",
                item_index: 1,
            },
            Case {
                label: "type alias",
                before: "type Item = bool;",
                after: "type Item = u32;",
                item_index: 0,
            },
            Case {
                label: "const",
                before: "const ITEM: bool = false;",
                after: "const ITEM: bool = true;",
                item_index: 0,
            },
            Case {
                label: "static",
                before: "static ITEM: bool = false;",
                after: "static ITEM: bool = true;",
                item_index: 0,
            },
            Case {
                label: "module",
                before: "#[doc = \"before\"] mod item {}",
                after: "#[doc = \"after\"] mod item {}",
                item_index: 0,
            },
            Case {
                label: "use",
                before: "use crate::before;",
                after: "use crate::after;",
                item_index: 0,
            },
            Case {
                label: "macro definition",
                before: "macro_rules! item { () => { struct Before; } }",
                after: "macro_rules! item { () => { struct After; } }",
                item_index: 0,
            },
            Case {
                label: "macro invocation",
                before: "item!(before);",
                after: "item!(after);",
                item_index: 0,
            },
        ];

        for case in cases {
            let mut database = Database::default();
            let source_file = database.add_source_file("lib.rs".to_owned(), case.before.to_owned());
            database.attach(|db| force_observer(db, source_file, case.item_index));
            database.take_query_log();

            database.attach(|db| force_observer(db, source_file, case.item_index));
            assert_eq!(
                database.take_query_log(),
                "",
                "{} must have a warm observer",
                case.label
            );

            source_file
                .set_text(&mut database)
                .to(case.after.to_owned());
            database.attach(|db| force_observer(db, source_file, case.item_index));
            let edit_trace = database.take_query_log();
            assert!(
                !edit_trace.contains("observe_symbol_identity"),
                "{} detail edit reminted its symbol:\n{edit_trace}",
                case.label
            );
        }
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::trait_system_tests::enum_detail_edits_preserve_variant_query_keys

crates/sage-test-harness/src/lib.rs · lib:sage_test_harness

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_ir.symbols.local_identity)]
    fn enum_detail_edits_preserve_variant_query_keys() {
        use sage_ir::local_syms::enums::enum_variants;
        use sage_ir::symbol::EnumSymbol;
        use salsa::Setter as _;

        fn force_variant_observers(db: &dyn Db, source_file: SourceFile) {
            let (_, root) = setup_root_module(db, source_file);
            let [symbol] = root.expanded_module_items(db) else {
                panic!("expected one enum")
            };
            let SymbolData::EnumSymbol(EnumSymbol::Local(local_enum)) = symbol.data(db) else {
                panic!("expected a local enum")
            };
            for symbol in enum_variants(db, local_enum) {
                if let SymbolData::VariantSymbol(sage_ir::symbol::VariantSymbol::Local(variant)) =
                    symbol.data(db)
                {
                    assert!(variant.has_fields(db));
                }
                observe_symbol_identity(db, ObservedSymbol::new(db, *symbol));
            }
        }

        let mut database = Database::default();
        let source_file =
            database.add_source_file("lib.rs".to_owned(), "enum Item { Value(bool) }".to_owned());
        database.attach(|db| force_variant_observers(db, source_file));
        database.take_query_log();

        source_file
            .set_text(&mut database)
            .to("enum Item { Value(u32) }".to_owned());
        database.attach(|db| force_variant_observers(db, source_file));
        let edit_trace = database.take_query_log();
        assert!(
            !edit_trace.contains("observe_symbol_identity"),
            "enum detail edit reminted a variant or constructor:\n{edit_trace}"
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::trait_system_tests::local_function_identity_changes_are_distinguishable

crates/sage-test-harness/src/lib.rs · lib:sage_test_harness

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_ir.symbols.local_identity)]
    fn local_function_identity_changes_are_distinguishable() {
        use salsa::Setter as _;

        let mut database = Database::default();
        let source_file =
            database.add_source_file("lib.rs".to_owned(), "fn before() {}".to_owned());
        database.attach(|db| {
            let (_, root) = setup_root_module(db, source_file);
            let function = local_function_named(db, root, "before");
            observe_symbol_identity(db, ObservedSymbol::new(db, Symbol::from(function)));
        });
        assert!(
            database
                .take_query_log()
                .contains("observe_symbol_identity")
        );

        source_file
            .set_text(&mut database)
            .to("fn after() {}".to_owned());
        database.attach(|db| {
            let (_, root) = setup_root_module(db, source_file);
            let function = local_function_named(db, root, "after");
            assert_eq!(function.name(db).text(db), "after");
            observe_symbol_identity(db, ObservedSymbol::new(db, Symbol::from(function)));
        });
        assert!(
            database
                .take_query_log()
                .contains("observe_symbol_identity"),
            "renaming the definition must create a distinguishable identity"
        );

        source_file
            .set_text(&mut database)
            .to("fn same() {} mod nested { fn same() {} }".to_owned());
        database.attach(|db| {
            let (_, root) = setup_root_module(db, source_file);
            let outer = local_function_named(db, root, "same");
            let nested = root
                .expanded_module_items(db)
                .iter()
                .find_map(|symbol| match symbol.data(db) {
                    SymbolData::ModSymbol(module) => Some(module),
                    _ => None,
                })
                .expect("nested module");
            let inner = local_function_named(db, nested, "same");
            assert_eq!(outer.name(db), inner.name(db));
            assert_ne!(outer.scope(db), inner.scope(db));
            assert_ne!(
                outer, inner,
                "same-name definitions in different scopes are distinct"
            );
        });
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::trait_system_tests::moving_associated_items_preserves_symbol_query_keys

crates/sage-test-harness/src/lib.rs · lib:sage_test_harness

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_ir.symbols.local_identity)]
    #[sage::test(crates.sage_ir.symbols.associated_identity)]
    #[sage::test(crates.sage_ir.types.spans.relative_composition)]
    fn moving_associated_items_preserves_symbol_query_keys() {
        use sage_ir::local_syms::LocalAssociatedOwner;
        use sage_ir::symbol::{ConstSymbol, TypeAliasSymbol};
        use sage_ir::ty::TraitItemDef;
        use salsa::Setter as _;

        fn force_target_observer(db: &dyn Db, source_file: SourceFile) {
            let (_, root) = setup_root_module(db, source_file);
            let (owner, items) = root
                .expanded_module_items(db)
                .iter()
                .find_map(|symbol| match symbol.data(db) {
                    SymbolData::TraitSymbol(TraitSymbol::Local(owner)) => {
                        Some((LocalAssociatedOwner::Trait(owner), owner.items(db)))
                    }
                    SymbolData::ImplSymbol(sage_ir::symbol::ImplSymbol::Local(owner)) => {
                        Some((LocalAssociatedOwner::Impl(owner), owner.items(db)))
                    }
                    _ => None,
                })
                .expect("expected a trait or impl owner");
            let (stash, binder) = items.open();
            let symbol = stash[binder.value]
                .iter()
                .find_map(|item| {
                    let symbol = match *item {
                        TraitItemDef::Function(FnSymbol::Local(symbol)) => {
                            assert_eq!(symbol.owner(db), Some(owner));
                            Symbol::from(FnSymbol::Local(symbol))
                        }
                        TraitItemDef::Type(TypeAliasSymbol::Local(symbol)) => {
                            assert_eq!(symbol.owner(db), Some(owner));
                            Symbol::from(TypeAliasSymbol::Local(symbol))
                        }
                        TraitItemDef::Const(ConstSymbol::Local(symbol)) => {
                            assert_eq!(symbol.owner(db), Some(owner));
                            Symbol::from(ConstSymbol::Local(symbol))
                        }
                        _ => panic!("expected local associated items"),
                    };
                    let name = symbol.name(db)?.0.text(db);
                    name.eq_ignore_ascii_case("target").then_some(symbol)
                })
                .expect("expected a target associated item");
            observe_symbol_identity(db, ObservedSymbol::new(db, symbol));
        }

        let cases = [
            (
                "trait function",
                "trait HasItems { fn earlier(); fn target(&self) -> bool { true } }",
                "trait HasItems { fn earlier(); fn added(); fn target(&self) -> bool { true } }",
            ),
            (
                "trait type",
                "trait HasItems { type Earlier; type Target; }",
                "trait HasItems { type Earlier; type Added; type Target; }",
            ),
            (
                "trait const",
                "trait HasItems { const EARLIER: bool; const TARGET: bool; }",
                "trait HasItems { const EARLIER: bool; const ADDED: bool; const TARGET: bool; }",
            ),
            (
                "impl function",
                "struct HasItems; impl HasItems { fn earlier() {} fn target(&self) -> bool { true } }",
                "struct HasItems; impl HasItems { fn earlier() {} fn added() {} fn target(&self) -> bool { true } }",
            ),
            (
                "impl type",
                "struct HasItems; impl HasItems { type Earlier = bool; type Target = bool; }",
                "struct HasItems; impl HasItems { type Earlier = bool; type Added = bool; type Target = bool; }",
            ),
            (
                "impl const",
                "struct HasItems; impl HasItems { const EARLIER: bool = true; const TARGET: bool = true; }",
                "struct HasItems; impl HasItems { const EARLIER: bool = true; const ADDED: bool = true; const TARGET: bool = true; }",
            ),
            (
                "trait function reorder",
                "trait HasItems { fn earlier(); fn target(&self) -> bool { true } }",
                "trait HasItems { fn target(&self) -> bool { true } fn earlier(); }",
            ),
            (
                "trait type reorder",
                "trait HasItems { type Earlier; type Target; }",
                "trait HasItems { type Target; type Earlier; }",
            ),
            (
                "trait const reorder",
                "trait HasItems { const EARLIER: bool; const TARGET: bool; }",
                "trait HasItems { const TARGET: bool; const EARLIER: bool; }",
            ),
            (
                "impl function reorder",
                "struct HasItems; impl HasItems { fn earlier() {} fn target(&self) -> bool { true } }",
                "struct HasItems; impl HasItems { fn target(&self) -> bool { true } fn earlier() {} }",
            ),
            (
                "impl type reorder",
                "struct HasItems; impl HasItems { type Earlier = bool; type Target = bool; }",
                "struct HasItems; impl HasItems { type Target = bool; type Earlier = bool; }",
            ),
            (
                "impl const reorder",
                "struct HasItems; impl HasItems { const EARLIER: bool = true; const TARGET: bool = true; }",
                "struct HasItems; impl HasItems { const TARGET: bool = true; const EARLIER: bool = true; }",
            ),
        ];

        for (label, before, after) in cases {
            let mut database = Database::default();
            let source_file = database.add_source_file("lib.rs".to_owned(), before.to_owned());
            database.attach(|db| force_target_observer(db, source_file));
            database.take_query_log();

            source_file.set_text(&mut database).to(after.to_owned());
            database.attach(|db| force_target_observer(db, source_file));
            let edit_trace = database.take_query_log();
            assert!(
                !edit_trace.contains("observe_symbol_identity"),
                "moving an unchanged associated {label} reminted it:\n{edit_trace}"
            );

            source_file.set_text(&mut database).to(before.to_owned());
            database.attach(|db| force_target_observer(db, source_file));
            let reverse_trace = database.take_query_log();
            assert!(
                !reverse_trace.contains("observe_symbol_identity"),
                "reversing the associated {label} edit reminted it:\n{reverse_trace}"
            );
        }
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Review: Accepted · Codex /root/macro_fix_expand_deps.

Reviewed the full local_identity claim and all sixteen implementation associations across thirteen local-symbol files, all four executable associated tests, and the explicit TODO test. Requirements are definition-based identity; independent CST/span/signature/member/body detail; identity preservation after detail edits; reuse for unchanged sibling facts; and distinguishable real identity changes.

Functions, consts and type aliases identify by name/scope/associated owner while CST and span are tracked detail. Structs, enums, traits and statics likewise keep name/scope distinct from tracked CST/span. Modules retain name/edition/parent identity, with body_source, attrs and span as tracked detail. Uses, macro invocations and impls carry scope identity with imports/CST/span separately tracked; macro definitions retain name/scope and independently tracked attrs/body tokens/span. Variants use name and parent-enum identity while CST/span/is_tuple are tracked; constructors use name and variant identity. Associated-item helpers use owner plus kind/name/occurrence, then reconstruct CST and span behind the keyed query boundary, so inserting/reordering a differently named sibling does not change the target's key. Separate signature/items/body operations are downstream queries keyed by these symbols rather than fields in their identity. The new import diagnostics and symbol_local_item helper only inspect existing identities/provenance and introduce no new identity field or constructor.

Captured parser constructors pass stable name/scope/owner values separately from reconstructed CST/spans; captured Symbol conversion retains local handles. Captured Scope/LocalAssociatedOwner definitions establish owner identity. Captured setup_root_module reconstructs a root in a tracked context and specifies parsed children. ObservedSymbol interns only Symbol, and observe_symbol_identity is a tracked no-detail query; Database records WillExecute events, so asserting the observer did not reexecute after reconstruction tests key reuse rather than comparing display strings.

The per-kind detail test explicitly exercises twelve local kinds, rejects parse-error substitutes, checks an unchanged warm trace, edits source and asserts no identity-observer execution. The enum test forces variant and constructor observers before/after a field-type edit. The identity-change test verifies cold observation, rename-triggered observer execution, and distinct same-name definitions in distinct scopes. The associated-item test covers insertion and reordering for functions/types/consts under both traits and impls, checks owner links, and checks no target observer execution in both edit directions. These test assertions would detect accidental CST/span inclusion in identity for those scenarios. They do not prove the full per-kind sibling signature/member/body reuse matrix: todo::symbols_local_identity explicitly retains sibling insertion/reordering and signature/member/body reuse for every local kind as deferred work. Completing it requires observers of each independent fact, not simply adding more successful compilations. No N/A evidence exists.

Executed cargo test -p sage-test-harness --lib query_keys: 4 passed, including the three associated query-key tests and one unrelated matched test. Executed cargo test -p sage-test-harness --lib local_function_identity_changes_are_distinguishable: 1 passed. These runs complement, not replace, the above source assessment. No production edits were made and no new identity violation found. Existing TODO remains visible; no requested edits.

Browse crates anchors

139 anchors

Specification anchors and declared coverage
AnchorImplementationTests
crates (139)114 Implemented37 TODO2 N/A74 Implemented107 TODO
crates.sage_inspector (15)13 Implemented1 TODO2 N/A3 Implemented15 TODO
crates.sage_inspector.inspection (15)13 Implemented1 TODO2 N/A3 Implemented15 TODO
balanced_tracesImplementedTODO
canonical_ownershipImplementedImplementedTODO
derive_reflectionImplementedImplementedTODO
detail_free_indexImplementedTODO
deterministic_traceImplementedTODO
durable_navigationN/ATODO
generic_browserN/ATODO
owned_reflectionImplementedImplementedTODO
product_availabilityImplementedTODO
revision_and_demandImplementedTODO
semantic_phase_boundaryImplementedTODO
source_evidenceImplementedTODO
typed_serviceImplementedTODO
unknown_workImplementedTODOTODO
workspace_actorImplementedTODO
crates.sage_ir (90)67 Implemented34 TODO40 Implemented88 TODO
crates.sage_ir.checking (12)12 Implemented3 TODO5 Implemented12 TODO
crates.sage_ir.checking.body (5)5 Implemented2 TODO3 Implemented5 TODO
elaborationImplementedImplementedTODO
expected_typesImplementedTODOTODO
interface_dependenciesImplementedImplementedTODO
isolated_completionImplementedImplementedTODO
operator_callsImplementedTODOTODO
identity_mintingImplementedTODO
owned_productsImplementedImplementedTODO
crates.sage_ir.checking.signature (4)4 Implemented1 TODO1 Implemented4 TODO
body_independenceImplementedTODO
narrow_detailImplementedTODOTODO
owner_binderImplementedImplementedTODO
storageImplementedTODO
symbol_keyed_interfacesImplementedTODO
crates.sage_ir.crate (9)9 TODO9 TODO
explicit_restrictionsTODOTODO
identity_before_detailTODOTODO
incremental_evidenceTODOTODO
narrow_demandsTODOTODO
reexecution_and_invalidationTODOTODO
represented_completenessTODOTODO
restrictions_and_gapsTODOTODO
semantic_query_boundariesTODOTODO
terminal_incompletenessTODOTODO
crates.sage_ir.inference (8)8 Implemented6 Implemented8 TODO
atomic_checkingImplementedImplementedTODO
body_local_quiescenceImplementedImplementedTODO
canonical_boundaryImplementedImplementedTODO
completed_body_boundaryImplementedTODO
numeric_domainsImplementedImplementedTODO
subtyping_and_coercionImplementedImplementedTODO
terminal_obligationsImplementedTODO
transaction_isolationImplementedImplementedTODO
crates.sage_ir.metadata (4)4 Implemented1 TODO4 TODO
explicit_incompletenessImplementedTODO
keyed_reuseImplementedTODOTODO
product_boundariesImplementedTODO
provider_authorityImplementedTODO
crates.sage_ir.modules (8)7 Implemented1 TODO4 Implemented8 TODO
crates.sage_ir.modules.expand (4)4 Implemented2 Implemented4 TODO
completenessImplementedImplementedTODO
dependenciesImplementedTODO
direct_membersImplementedTODO
recursion_and_fixpointImplementedImplementedTODO
crates.sage_ir.modules.parse (4)3 Implemented1 TODO2 Implemented4 TODO
dependenciesImplementedTODO
detail_firewallImplementedImplementedTODO
recovery_completenessTODOTODO
syntax_identitiesImplementedImplementedTODO
crates.sage_ir.resolution (5)5 Implemented1 TODO3 Implemented4 TODO
crates.sage_ir.resolution.lookup (5)5 Implemented1 TODO3 Implemented4 TODO
completenessImplementedTODOImplementedTODO
dependenciesImplementedTODO
expansion_import_ambiguityImplementedImplemented
identity_onlyImplementedTODO
precedenceImplementedImplementedTODO
crates.sage_ir.solver (9)7 Implemented7 TODO5 Implemented9 TODO
alternative_isolationImplementedTODOImplementedTODO
bounded_completenessImplementedTODOTODO
candidate_completenessImplementedTODO
canonical_cyclesTODOTODO
canonical_outputsImplementedImplementedTODO
local_index_firewallTODOTODO
normalization_demandImplementedTODOImplementedTODO
schedule_independenceImplementedTODOImplementedTODO
shared_final_resultImplementedTODOImplementedTODO
crates.sage_ir.symbols (8)8 Implemented4 Implemented7 TODO
associated_identityImplementedImplemented
associated_interfacesImplementedTODO
body_interfacesImplementedImplementedTODO
definition_identityImplementedTODO
external_fact_queriesImplementedTODO
external_identityImplementedTODO
kind_wrappersImplementedImplementedTODO
local_identityImplementedImplementedTODO
crates.sage_ir.types (27)16 Implemented12 TODO13 Implemented27 TODO
crates.sage_ir.types.aliases (2)1 Implemented1 TODO1 Implemented2 TODO
identityImplementedImplementedTODO
revelationTODOTODO
crates.sage_ir.types.binder (1)1 Implemented1 TODO1 Implemented1 TODO
owner_parametersImplementedTODOImplementedTODO
crates.sage_ir.types.body (13)4 Implemented9 TODO3 Implemented13 TODO
awaitTODOTODO
closuresTODOTODO
conditional_patternsTODOTODO
coroutinesTODOTODO
diagnosed_recoveryImplementedImplementedTODO
elaboratedTODOImplementedTODO
for_iterationTODOTODO
indexingTODOTODO
macro_expansionTODOTODO
no_inferenceImplementedImplementedTODO
resolved_referencesImplementedTODO
try_residualTODOTODO
typed_provenanceImplementedTODO
crates.sage_ir.types.calls (2)1 Implemented1 TODO1 Implemented2 TODO
dispatch_familiesTODOTODO
selected_semanticsImplementedImplementedTODO
crates.sage_ir.types.lifetimes (2)2 Implemented2 Implemented2 TODO
dummyImplementedImplementedTODO
unchecked_borrowsImplementedImplementedTODO
crates.sage_ir.types.operators (2)2 Implemented1 Implemented2 TODO
lazy_control_flowImplementedTODO
trait_callsImplementedImplementedTODO
scoped_identitiesImplementedTODO
crates.sage_ir.types.spans (4)4 Implemented4 Implemented4 TODO
generated_identityImplementedImplementedTODO
item_originImplementedImplementedTODO
offset_reuseImplementedImplementedTODO
relative_compositionImplementedImplementedTODO
crates.sage_oracle_harness (4)4 Implemented2 TODO1 Implemented4 TODO
crates.sage_oracle_harness.crate (4)4 Implemented2 TODO1 Implemented4 TODO
deterministic_emissionImplementedTODO
exact_comparisonImplementedTODOImplementedTODO
fixed_projectionImplementedTODO
independent_coverageImplementedTODOTODO
crates.sage_stash (5)5 Implemented5 Implemented
crates.sage_stash.storage (5)5 Implemented5 Implemented
handle_ownershipImplementedImplemented
immutable_entriesImplementedImplemented
query_valueImplementedImplemented
rooted_equalityImplementedImplemented
typed_interningImplementedImplemented
crates.sage_test_harness (25)25 Implemented25 Implemented
crates.sage_test_harness.compile_tests (25)25 Implemented25 Implemented
annotation_validationImplementedImplemented
blessing_gateImplementedImplemented
callsite_updatesImplementedImplemented
checking_scopeImplementedImplemented
compiler_conditionsImplementedImplemented
completed_typesImplementedImplemented
coordinatesImplementedImplemented
dependenciesImplementedImplemented
diagnostic_countsImplementedImplemented
diagnostic_locationsImplementedImplemented
editionImplementedImplemented
fixturesImplementedImplemented
grouped_observationsImplementedImplemented
invocationImplementedImplemented
production_executionImplementedImplemented
project_isolationImplementedImplemented
query_captureImplementedImplemented
query_projectionImplementedImplemented
renderingImplementedImplemented
resolved_symbolsImplementedImplemented
review_visibilityImplementedImplemented
rustc_executionImplementedImplemented
rustc_lintsImplementedImplemented
starting_expressionsImplementedImplemented
target_lineImplementedImplemented