crates.sage_test_harness.compile_tests.checking_scope

V1 requests signatures and checks every supported body in the selected local crate, including reachable submodules, associated bodies, and expanded items, regardless of visibility or selector presence. It does not eagerly check external dependency bodies. Unsupported in-scope work must be reported as a failure or explicit diagnostic, never silently omitted as success. Adding a type marker cannot change this demand policy. A future explicit entry-point mode may select a narrower demand; it is not part of v1.

Read in specification context · design/crates/sage_test_harness/compile-tests.md

Implementation

Implemented crates/sage-ir/src/cst/enums.rs:1–6

sage_ir::cst::enums · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.checking_scope`
use sage_stash::{AllocStashData, Ptr, Slice, Stashed};

use crate::cst::attrs::AttrCst;
use crate::cst::expr::ExprCst;
use crate::cst::generics::GenericParamCst;

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/associated.rs:1–6

sage_ir::local_syms::associated · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.checking_scope`
use sage_stash::{Slice, Stash, StashCopy, Stashed};

use crate::cst::traits::TraitItemCst;
use crate::generic_param::GenericParam;
use crate::local_syms::consts::LocalConstSym;

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/uses.rs:1–6

sage_ir::local_syms::uses · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.checking_scope`
// {anchor}`crates.sage_test_harness.compile_tests.diagnostic_counts`
use sage_stash::{Slice, StashDirect, Stashed};

use crate::cst::attrs::AttrCst;
use crate::cst::uses::UseImports;

}

See more source ↗

Implemented crates/sage-ir/src/parse/items.rs:4–9

sage_ir::parse::items · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.checking_scope`
use sage_stash::{Ptr, Stash, Stashed};

use crate::cst::consts::{ConstCst, ConstCstData};
use crate::cst::enums::{EnumCstData, VariantCst};
use crate::cst::fns::{FnCstData, ParamCst};

}

See more source ↗

Implemented crates/sage-ir/src/parse/mod.rs:3–8

sage_ir::parse · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.checking_scope`
mod attrs;
mod exprs;
mod generics;
mod items;
mod paths;

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/observe.rs:156–366

sage_test_harness::compile::observe · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.checking_scope`<<
#[salsa::tracked]
fn check_crate<'db>(db: &'db dyn Db, root: sage_ir::local_syms::mods::LocalModSym<'db>) -> Checked {
    let mut checked = Checked::default();
    walk_module(db, root, &mut checked);
    checked
}

fn walk_module<'db>(
    db: &'db dyn Db,
    module: sage_ir::local_syms::mods::LocalModSym<'db>,
    checked: &mut Checked,
) {
    if let Some(file) = module.file(db) {
        checked
            .files
            .insert(sage_ir::source::normalize_path(&format!(
                "src/{}",
                file.path(db)
            )));
    }
    for item in module.unexpanded_items(db) {
        if let LocalModItemSym::Error(span) = item {
            checked.diagnostics.push(
                Diagnostic::error(Span::Absolute(*span), "unrecognized or unsupported item")
                    .snapshot(db),
            );
        }
    }
    if !sage_ir::local_syms::mods::module_expansion_complete_for_symbol_listing(db, module) {
        checked.diagnostics.push(
            Diagnostic::error(
                Span::Absolute(module.span(db)),
                "module expansion is incomplete",
            )
            .snapshot(db),
        );
    }
    for symbol in ModSymbol::Local(module).expanded_module_items(db) {
        walk_symbol(db, *symbol, checked);
    }
}
fn walk_symbol<'db>(db: &'db dyn Db, symbol: Symbol<'db>, checked: &mut Checked) {
    match symbol.data(db) {
        SymbolData::ModSymbol(ModSymbol::Local(module)) => walk_module(db, module, checked),
        SymbolData::FnSymbol(FnSymbol::Local(function)) => {
            function.sig(db);
            let (source_stash, cst) = function.cst(db).open_deref();
            if cst.body.is_some() {
                let result = function.body(db);
                checked
                    .diagnostics
                    .extend(result.diagnostics.iter().map(|d| d.snapshot(db)));
                let (stash, body) = result.body.open_deref();
                let mut typed = Vec::new();
                walk_expr(
                    db,
                    stash,
                    body.root,
                    function.span(db),
                    &stash[body.locals],
                    &mut typed,
                );
                let mut source = Vec::new();
                super::source::walk(source_stash, source_stash[cst.body.unwrap()], &mut source);
                for expression in source {
                    let candidates: Vec<_> = typed
                        .iter()
                        .filter(|row| row.span == expression.span && row.kind != "coercion")
                        .collect();
                    let matching: Vec<_> = candidates
                        .iter()
                        .copied()
                        .filter(|row| row.kind == expression.kind)
                        .collect();
                    let candidate = if matching.len() == 1 {
                        matching.first().copied()
                    } else if candidates.len() == 1 {
                        candidates.first().copied()
                    } else {
                        None
                    };
                    if let Some(candidate) = candidate {
                        let mut row = candidate.clone();
                        row.kind = expression.kind.into();
                        row.valid &= expression.kind != "unresolved";
                        checked.types.push(row);
                        checked.types.extend(
                            typed
                                .iter()
                                .filter(|row| row.span == expression.span && row.kind == "coercion")
                                .cloned(),
                        );
                    } else if let ParseSource::SourceFile(file) = function.span(db).source {
                        let span = function.span(db).resolve(expression.span);
                        let text = file.text(db);
                        checked.types.push(TypeRow {
                            start: span.start,
                            end: span.end,
                            span: expression.span,
                            valid: false,
                            file: sage_ir::source::normalize_path(&format!(
                                "src/{}",
                                file.path(db)
                            )),
                            line: text.as_bytes()[..span.start as usize]
                                .iter()
                                .filter(|&&b| b == b'\n')
                                .count()
                                + 1,
                            kind: expression.kind.into(),
                            source: text[span.start as usize..span.end as usize].into(),
                            ty: FrozenType::Missing,
                            symbol: Err("missing semantic correspondence".into()),
                        });
                    }
                }
            }
        }
        SymbolData::StructSymbol(StructSymbol::Local(s)) => {
            s.sig(db);
            s.fields(db);
        }
        SymbolData::EnumSymbol(EnumSymbol::Local(s)) => {
            s.sig(db);
            let (stash, cst) = s.cst(db).open_deref();
            for variant in &stash[cst.variants] {
                if let Some(discriminant) = variant.discriminant {
                    checked.diagnostics.push(
                        Diagnostic::error(
                            Span::Relative(LocalModItemSym::Enum(s), stash[discriminant].span),
                            "whole-crate checking of enum discriminants is not supported",
                        )
                        .snapshot(db),
                    );
                }
            }
        }
        SymbolData::TraitSymbol(TraitSymbol::Local(s)) => {
            s.sig(db);
            walk_associated(db, LocalAssociatedOwner::Trait(s), checked);
        }
        SymbolData::ImplSymbol(ImplSymbol::Local(s)) => {
            s.sig(db);
            walk_associated(db, LocalAssociatedOwner::Impl(s), checked);
        }
        SymbolData::ConstSymbol(ConstSymbol::Local(s)) => {
            unsupported(db, LocalModItemSym::Const(s), checked)
        }
        SymbolData::StaticSymbol(StaticSymbol::Local(s)) => {
            unsupported(db, LocalModItemSym::Static(s), checked)
        }
        SymbolData::TypeAliasSymbol(TypeAliasSymbol::Local(s)) => {
            unsupported(db, LocalModItemSym::TypeAlias(s), checked)
        }
        SymbolData::FnSymbol(FnSymbol::Ext(_))
        | SymbolData::ModSymbol(ModSymbol::Ext(_))
        | SymbolData::StructSymbol(StructSymbol::Ext(_))
        | SymbolData::EnumSymbol(EnumSymbol::Ext(_))
        | SymbolData::TraitSymbol(TraitSymbol::Ext(_))
        | SymbolData::ImplSymbol(ImplSymbol::Ext(_))
        | SymbolData::ConstSymbol(ConstSymbol::Ext(_))
        | SymbolData::StaticSymbol(StaticSymbol::Ext(_))
        | SymbolData::TypeAliasSymbol(TypeAliasSymbol::Ext(_))
        | SymbolData::VariantSymbol(_)
        | SymbolData::VariantCtorSymbol(_)
        | SymbolData::MacroDefSymbol(_)
        | SymbolData::UseSymbol(UseSymbol::Ext(_))
        | SymbolData::IntrinsicTypeSymbol(_) => {}
        SymbolData::UseSymbol(UseSymbol::Local(import)) => {
            checked
                .diagnostics
                .extend(import.diagnostics(db).iter().map(|d| d.snapshot(db)));
        }
        SymbolData::MacroInvocationSymbol(invocation) => {
            unsupported(db, LocalModItemSym::MacroInvocation(invocation), checked)
        }
    }
}
fn walk_associated<'db>(db: &'db dyn Db, owner: LocalAssociatedOwner<'db>, checked: &mut Checked) {
    for item in sage_ir::local_syms::associated::local_associated_items(db, owner) {
        match item {
            LocalModItemSym::Error(span) => checked.diagnostics.push(
                Diagnostic::error(Span::Absolute(*span), "unsupported associated item")
                    .snapshot(db),
            ),
            LocalModItemSym::Function(_)
            | LocalModItemSym::Struct(_)
            | LocalModItemSym::Enum(_)
            | LocalModItemSym::Trait(_)
            | LocalModItemSym::Impl(_)
            | LocalModItemSym::TypeAlias(_)
            | LocalModItemSym::Const(_)
            | LocalModItemSym::Static(_)
            | LocalModItemSym::Mod(_)
            | LocalModItemSym::Use(_)
            | LocalModItemSym::MacroDef(_)
            | LocalModItemSym::MacroInvocation(_) => walk_symbol(db, (*item).into(), checked),
        }
    }
}
fn unsupported<'db>(db: &'db dyn Db, item: LocalModItemSym<'db>, checked: &mut Checked) {
    checked.diagnostics.push(
        Diagnostic::error(
            Span::Symbol(item),
            "whole-crate checking for this item is not supported",
        )
        .snapshot(db),
    );
}
// >>

}

See more source ↗

Tests and review

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

Implemented sage_test_harness::compile::tests::unselected_private_body_still_reports_errors

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

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
    fn unselected_private_body_still_reports_errors() {
        let mut test = CompileTest::default();
        test.source("fn good() {}\nfn bad() -> u16 { true }");
        let error = test.prepare().unwrap_err();
        assert!(
            error.contains("Sage diagnostic markers do not match: 0 markers, 1 diagnostics"),
            "{error}"
        );
        let mut selected = CompileTest::default();
        selected.source("fn good() {} //# ty\nfn bad() -> u16 { true }");
        selected.observations(expect![""]);
        let error = selected.prepare().unwrap_err();
        assert!(
            error.contains("Sage diagnostic markers do not match: 0 markers, 1 diagnostics"),
            "{error}"
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::macro_generated_errors_match_the_invocation

crates/sage-test-harness/tests/compile_tests.rs · test:compile_tests

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.diagnostic_locations)]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn macro_generated_errors_match_the_invocation() {
    compile_test! {
        source: indoc! {r#"
            macro_rules! make {
                () => { fn broken() -> u16 { true } }
            }
            make!(); //# ERROR
        "#},
        diagnostics: expect![[r#"
            error: type mismatch: expected `u16`, found `bool`
             --> src/lib.rs:4:1
              |
            4 | make!(); //# ERROR
              | ^^^^^^^
              | |
              | found `bool`
              | expected `u16` because of return type"#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::modules_and_associated_bodies

crates/sage-test-harness/tests/compile_tests.rs · test:compile_tests

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.fixtures)]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn modules_and_associated_bodies() {
    compile_test! {
        files: {
            "src/lib.rs": "mod nested;",
            "src/nested/mod.rs": indoc! {r#"
                struct Value;
                impl Value {
                    fn answer() -> u16 {
                        22 //# ty
                    }
                }
            "#},
        },
        observations: expect![[r#"
            src/nested/mod.rs: literal `22`
              type: u16
        "#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::real_std

crates/sage-test-harness/tests/compile_tests.rs · test:compile_tests

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.dependencies)]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn real_std() {
    compile_test! {
        source: "fn example(value: std::string::String) {}",
        diagnostics: expect![""],
    }
}
}

See more source ↗

Implemented sage_test_harness::signature_diagnostics_are_retained_once

crates/sage-test-harness/tests/compile_tests.rs · test:compile_tests

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.diagnostic_counts)]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn signature_diagnostics_are_retained_once() {
    compile_test! {
        source: indoc! {r#"
            fn broken(value: Missing) {} //# ERROR
            fn one() { broken(true); }
            fn two() { broken(false); }
        "#},
        diagnostics: expect![[r#"
            error: unresolved type
             --> src/lib.rs:1:18
              |
            1 | fn broken(value: Missing) {} //# ERROR
              |                  ^^^^^^^"#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::unused_import_is_checked

crates/sage-test-harness/tests/compile_tests.rs · test:compile_tests

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.diagnostic_counts)]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn unused_import_is_checked() {
    compile_test! {
        source: "use missing::Item; //# ERROR",
        diagnostics: expect![[r#"
            error: unresolved import
             --> src/lib.rs:1:5
              |
            1 | use missing::Item; //# ERROR
              |     ^^^^^^^^^^^^^"#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::enum_discriminant_body_is_not_silently_accepted

crates/sage-test-harness/tests/review_semantics.rs · test:review_semantics

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn enum_discriminant_body_is_not_silently_accepted() {
    let result = std::panic::catch_unwind(|| {
        // Account for rustc's independent error so it cannot mask Sage's omission.
        compile_test! { source: "enum Hidden { Value = missing() } //# ERROR if rustc" }
    });
    let panic = result.expect_err(
        "enum discriminant bodies must be checked or explicitly rejected as unsupported",
    );
    let message = panic.downcast_ref::<String>().unwrap();
    assert!(
        message.contains("Sage diagnostic markers do not match"),
        "{message}"
    );
    assert!(
        message.contains("whole-crate checking of enum discriminants is not supported"),
        "{message}"
    );
}
}

See more source ↗

Implemented sage_test_harness::enum_discriminants_survive_syntax_token_rendering

crates/sage-test-harness/tests/review_semantics.rs · test:review_semantics

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn enum_discriminants_survive_syntax_token_rendering() {
    use sage_ir::symbol::{EnumSymbol, SymbolData};
    use sage_ir::tokens::{StringSink, ToTokens, TokenCtx};
    let source = "enum Hidden { First = 1 + 2, Second = 7 }";
    sage_test_harness::with_test_crate(source, |db, root| {
        let symbol = root.expanded_module_items(db)[0];
        let SymbolData::EnumSymbol(EnumSymbol::Local(enum_symbol)) = symbol.data(db) else {
            panic!("expected the source enum");
        };
        let (stash, cst) = enum_symbol.cst(db).open_deref();
        let variants = &stash[cst.variants];
        assert_eq!(variants.len(), 2);
        assert!(
            variants
                .iter()
                .all(|variant| variant.discriminant.is_some())
        );
        let mut sink = StringSink::new();
        cst.to_tokens(
            &TokenCtx {
                db,
                stash,
                source_text: source,
            },
            &mut sink,
        );
        assert_eq!(
            sink.into_string(),
            "enum Hidden {First = 1 + 2, Second = 7}"
        );
    });
}
}

See more source ↗

Implemented sage_test_harness::malformed_body_is_not_silently_accepted

crates/sage-test-harness/tests/review_semantics.rs · test:review_semantics

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.diagnostic_counts)]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn malformed_body_is_not_silently_accepted() {
    let result = std::panic::catch_unwind(|| {
        compile_test! { source: "fn broken() { let = ; }" }
    });
    let panic = result.unwrap_err();
    let message = panic.downcast_ref::<String>().unwrap();
    assert!(
        message.contains("Sage diagnostic markers do not match"),
        "{message}"
    );
}
}

See more source ↗

Implemented sage_test_harness::malformed_private_enum_signature_is_checked

crates/sage-test-harness/tests/review_semantics.rs · test:review_semantics

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn malformed_private_enum_signature_is_checked() {
    let result = std::panic::catch_unwind(|| {
        compile_test! { source: "enum Hidden { Value(Missing) }" }
    });
    let panic = result.unwrap_err();
    let message = panic.downcast_ref::<String>().unwrap();
    assert!(
        message.contains("Sage diagnostic markers do not match"),
        "{message}"
    );
    assert!(message.contains("unresolved type"), "{message}");
}
}

See more source ↗

Implemented sage_test_harness::valid_enum_discriminant_reports_sage_limitation

crates/sage-test-harness/tests/review_semantics.rs · test:review_semantics

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.checking_scope)]
fn valid_enum_discriminant_reports_sage_limitation() {
    compile_test! {
        source: "enum Hidden { Value = 1 } //# ERROR if SAGE",
        diagnostics: expect_test::expect![[r#"
            error: whole-crate checking of enum discriminants is not supported
             --> src/lib.rs:1:23
              |
            1 | enum Hidden { Value = 1 } //# ERROR if SAGE
              |                       ^"#]],
    }
}
}

See more source ↗

Review: Accepted · Codex /root/macro_fix_expand_deps.

Reviewed the entire checking_scope claim, all six implementation entries and all eleven associated tests. The requirements are whole selected-local-crate signature/body demand, reachable submodules/associated bodies/generated items regardless of visibility or selector presence, no eager dependency body checking, explicit failure/diagnostics for unsupported in-scope work, and no selector-driven demand narrowing.

observe::collect unconditionally calls check_crate before inspecting observation targets. check_crate/walk_module visits the local root, emits diagnostics for parse Error items and incomplete expansion, then walks every expanded direct symbol; local modules recurse. walk_symbol requests local function signatures and, if syntax has a body, body checking; it checks struct signatures/fields and enum signatures, visits trait/impl associated items through local_associated_items, and audits local use declarations even when unused. External symbol variants are explicit no-op branches for this traversal, so fixture checking does not recursively demand dependency bodies. Supported local body demand is independent of marker sets and visibility. Residual macro invocation, const/static/type alias work is explicitly rejected by unsupported diagnostics. Enum discriminants are preserved in CST and explicitly diagnosed as unsupported, rather than silently dropped. The parser rejects malformed/unsupported top-level or associated item syntax as Error; associated_items enumeration retains ownership and supplies function symbols to the same walk_symbol dispatcher.

The changed LocalUseSym::diagnostics now performs the generated-root ambiguity audit before its unresolved-import check. It is still reached from the unconditional Use branch, and its new resolver helper only affects emitted diagnostics, not traversal or selectors. Captured resolver and expansion helpers confirm this separation. Captured CompileTest::prepare always runs the host collect path and checks both compiler results before expectations; the independent rustc result cannot hide a Sage diagnostic mismatch. Captured function/enum query implementations confirm these calls perform semantic checking. Captured test setup explains the in-memory discriminant rendering fixture.

Test evidence: unselected_private_body_still_reports_errors checks the same private bad function produces one Sage diagnostic both with and without a marker on another function. modules_and_associated_bodies requires a completed type from a private associated body in a reachable separate module. macro_generated_errors_match_the_invocation asserts an error from a generated function body. signature_diagnostics_are_retained_once demands an invalid signature used by two bodies and expects one diagnostic. unused_import_is_checked verifies an otherwise unused bad use is audited. real_std accepts a std type without attempting to check external bodies (the exhaustive external no-op branches provide the direct structural evidence for that negative guarantee). malformed_body_is_not_silently_accepted and malformed_private_enum_signature_is_checked require Sage mismatch failures, the latter specifically unresolved type. enum_discriminant_body_is_not_silently_accepted independently accounts for rustc's error and still requires Sage's explicit unsupported diagnostic. valid_enum_discriminant_reports_sage_limitation snapshots that limitation when rustc accepts. enum_discriminants_survive_syntax_token_rendering asserts both retained discriminant nodes and exact rendered expressions, preventing the syntax erasure which would bypass rejection. No TODO/N/A entries are present; the unsupported-feature behavior is explicit diagnostic behavior permitted by the claim, not claimed full language support.

Executed cargo test -p sage-test-harness --test compile_tests --test review_semantics: 14 and 8 tests passed. Executed cargo test -p sage-test-harness --lib unselected_private_body_still_reports_errors: 1 passed. These cover all eleven associated tests, with additional tests selected by the integration targets. No production changes were made. Source inspection and these assertions account for the complete demand-policy claim; 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