crates.sage_test_harness.compile_tests.resolved_symbols

//# sym observes explicit path expressions starting on the target line, including local variable uses and qualified paths. It reports the definition selected by completed checking, not the spelling of an import alias. Local item identities include their kind and a crate::-qualified name. Local bindings use their name and a one-based occurrence among same-named bindings in declaration order within the body; unrelated declarations do not renumber them. External definitions use the metadata definition path. No allocation IDs or source coordinates appear. An actual resolution error is <unresolved>; missing or unsupported semantic correspondence fails the observation. A target line containing no path expression fails rather than producing an empty result. Associated local item identities are not yet supported and fail explicitly. V1 symbol selection excludes method names, field names, type syntax, patterns, and implicit calls introduced by elaboration. These can gain selectors later. Names are frozen before ending query capture, as with types.

For example, selecting both markers on module::value() produces:

src/lib.rs: path `module::value`
  symbol: fn crate::module::value
  type: fn() -> u16
src/lib.rs: call `module::value()`
  type: u16

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

Implementation

Implemented crates/sage-test-harness/src/compile/annotations.rs:1–6

sage_test_harness::compile::annotations · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.resolved_symbols`
// {anchor}`crates.sage_test_harness.compile_tests.grouped_observations`
// {anchor}`crates.sage_test_harness.compile_tests.diagnostic_counts`
use std::collections::BTreeSet;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/observe.rs:53–58

sage_test_harness::compile::observe · lib:sage_test_harness

#![allow(unused)]
fn main() {
    // {anchor}`crates.sage_test_harness.compile_tests.resolved_symbols`
    let targets: BTreeSet<_> = markers
        .iter()
        .filter(|m| matches!(m.kind, Kind::Type | Kind::Symbol))
        .map(|m| (m.file.clone(), m.line))
        .collect();

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/source.rs:4–9

sage_test_harness::compile::source · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.resolved_symbols`
// {anchor}`crates.sage_test_harness.compile_tests.starting_expressions`
use sage_ir::cst::expr::{ExprCst, ExprCstKind as C, StmtCstKind};
use sage_ir::span::RelativeSpan;
use sage_stash::Stash;


}

See more source ↗

Implemented crates/sage-test-harness/src/compile/symbols.rs:3–8

sage_test_harness::compile::symbols · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.resolved_symbols`
// {anchor}`crates.sage_test_harness.compile_tests.query_capture`
use sage_ir::{
    Db,
    scope::ScopeSymbol,
    symbol::*,

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/types.rs:3–8

sage_test_harness::compile::types · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.resolved_symbols`
// {anchor}`crates.sage_test_harness.compile_tests.completed_types`
// {anchor}`crates.sage_test_harness.compile_tests.rendering`
// {anchor}`crates.sage_test_harness.compile_tests.query_capture`
use sage_ir::{
    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::query_capture_review_tests::cold_capture_includes_discovery_and_observation_reads_without_changing_bodies

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.query_capture)]
    #[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
    fn cold_capture_includes_discovery_and_observation_reads_without_changing_bodies() {
        let source = "fn selected() -> std::cmp::Ordering {\n std::cmp::Ordering::Equal // SELECT\n}\nfn unselected() -> u16 { 33 }";
        let mut plain = CompileTest::default();
        plain.source(source);
        plain.queries(expect_test::expect![""]);
        let plain = plain.prepare().unwrap();
        let mut selected = CompileTest::default();
        selected.source(source.replace("// SELECT", "//# sym"));
        selected.observations(expect_test::expect![""]);
        selected.queries(expect_test::expect![""]);
        let selected = selected.prepare().unwrap();
        assert!(
            selected
                .observations
                .contains("symbol: variant std::cmp::Ordering::Equal"),
            "{}",
            selected.observations
        );
        // Selecting an observation must not alter the checked body set or hide
        // semantic reads performed while freezing external definition names.
        assert_eq!(plain.queries, selected.queries);
        let trace: serde_json::Value = serde_json::from_str(&selected.queries).unwrap();
        fn collect<'a>(nodes: &'a serde_json::Value, out: &mut Vec<&'a serde_json::Value>) {
            for node in nodes.as_array().unwrap() {
                out.push(node);
                collect(&node["children"], out);
            }
        }
        let mut nodes = Vec::new();
        collect(&trace, &mut nodes);
        for operation in ["setup_root_module", "::sig_", "::body_", "tcx::def_path"] {
            assert!(
                nodes.iter().any(
                    |node| node["operation"].as_str().unwrap().ends_with(operation)
                        && node["disposition"] == "executed"
                ),
                "missing cold {operation}: {}",
                selected.queries
            );
        }
        assert_eq!(
            nodes
                .iter()
                .filter(
                    |node| node["operation"].as_str().unwrap().ends_with("::body_")
                        && node["disposition"] == "executed"
                )
                .count(),
            2
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::source::tests::only_expression_paths_are_symbol_candidates

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

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
    fn only_expression_paths_are_symbol_candidates() {
        let source = "fn f(value: Kind) { let typed: Other = value.field; value.method(); match value { Pattern(binding) => value } }";
        crate::with_test_crate(source, |db, root| {
            let function = crate::local_function_named(db, root, "f");
            let (stash, cst) = function.cst(db).open_deref();
            let mut rows = Vec::new();
            super::walk(stash, stash[cst.body.unwrap()], &mut rows);
            let paths: Vec<_> = rows
                .iter()
                .filter(|row| row.kind == "path")
                .map(|row| {
                    let span = function.span(db).resolve(row.span);
                    &source[span.start as usize..span.end as usize]
                })
                .collect();
            // Neither type names, field/method names, nor pattern paths are
            // expressions. Generated calls cannot enter this source CST list.
            assert_eq!(paths, vec!["value", "value", "value", "value"]);
        });
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::symbols::tests::missing_local_correspondence_is_not_an_unresolved_name

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

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
    fn missing_local_correspondence_is_not_an_unresolved_name() {
        use sage_ir::tytree::{LocalId, PathResolution};
        let db = sage_ir::db::Database::default();
        let error = super::resolution(&db, PathResolution::Local(LocalId(0)), &[]).unwrap_err();
        assert_eq!(error, "missing local binding");
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::tests::symbol_selections_require_paths_and_expectations

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.annotation_validation)]
    #[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
    fn symbol_selections_require_paths_and_expectations() {
        let mut test = CompileTest::default();
        test.source("fn f(value: u16) -> u16 { value } //# sym");
        assert!(
            test.prepare()
                .unwrap_err()
                .contains("observations expectation")
        );
        let mut test = CompileTest::default();
        test.source("fn f() -> u16 { 22 } //# sym");
        test.observations(expect![""]);
        assert!(test.prepare().unwrap_err().contains("no path expression"));
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::tests::unresolved_paths_still_require_error_markers

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.resolved_symbols)]
    #[sage::test(crates.sage_test_harness.compile_tests.grouped_observations)]
    #[sage::test(crates.sage_test_harness.compile_tests.rendering)]
    fn unresolved_paths_still_require_error_markers() {
        let mut test = CompileTest::default();
        test.source("fn f() -> u16 {\n missing //# sym\n}");
        test.observations(expect![""]);
        assert!(
            test.prepare()
                .unwrap_err()
                .contains("Sage diagnostic markers do not match: 0 markers, 1 diagnostics")
        );
        let mut test = CompileTest::default();
        test.source("fn f() -> u16 {\n missing //# sym\n //# ERROR\n}");
        test.observations(expect![""]);
        test.diagnostics(expect![""]);
        test.queries(expect![""]);
        let output = test.prepare().unwrap();
        assert_eq!(
            output.observations,
            "src/lib.rs: path `missing`\n  symbol: <unresolved>\n"
        );
        assert!(output.diagnostics.contains("error:"));
        let queries: serde_json::Value = serde_json::from_str(&output.queries).unwrap();
        assert!(!queries.as_array().unwrap().is_empty());
        assert!(!output.diagnostics.contains("symbol: <unresolved>"));
        assert!(!output.queries.contains("symbol: <unresolved>"));
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::tests::unsupported_associated_identity_is_not_unresolved

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.resolved_symbols)]
    fn unsupported_associated_identity_is_not_unresolved() {
        use sage_ir::local_syms::{
            LocalAssociatedOwner, LocalModItemSym, associated::local_associated_items,
        };
        use sage_ir::symbol::{SymbolData, TraitSymbol};
        use sage_ir::tytree::PathResolution;
        crate::with_test_crate("trait Has { fn answer(); }", |db, root| {
            let [symbol] = root.expanded_module_items(db) else {
                panic!("one trait expected")
            };
            let SymbolData::TraitSymbol(TraitSymbol::Local(owner)) = symbol.data(db) else {
                panic!("local trait expected")
            };
            let [LocalModItemSym::Function(function)] =
                local_associated_items(db, LocalAssociatedOwner::Trait(owner))
            else {
                panic!("one associated function expected")
            };
            let error =
                super::symbols::resolution(db, PathResolution::Def((*function).into()), &[])
                    .unwrap_err();
            assert_eq!(error, "unsupported symbol identity");
        });
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::aliases_and_qualified_paths_identify_the_definition

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
fn aliases_and_qualified_paths_identify_the_definition() {
    compile_test! {
        source: indoc! {r#"
            mod first { pub fn value() -> u16 { 1 } }
            mod second { pub fn value() -> u16 { 2 } }
            use first::value as alias;
            fn example() -> u16 {
                let first = alias(); //# sym
                second::value() //# sym
            }
        "#},
        observations: expect![[r#"
            src/lib.rs: path `alias`
              symbol: fn crate::first::value
            src/lib.rs: path `second::value`
              symbol: fn crate::second::value
        "#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::external_definitions_use_metadata_paths

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
fn external_definitions_use_metadata_paths() {
    compile_test! {
        source: indoc! {r#"
            fn example() -> std::cmp::Ordering {
                std::cmp::Ordering::Less //# sym
            }
        "#},
        observations: expect![[r#"
            src/lib.rs: path `std::cmp::Ordering::Less`
              symbol: variant std::cmp::Ordering::Less
        "#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::shadowed_locals_have_distinct_stable_identities

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
fn shadowed_locals_have_distinct_stable_identities() {
    compile_test! {
        source: indoc! {r#"
            fn example(value: u16) -> u16 {
                let observed = value; //# sym
                let unrelated = 0u16;
                let value = value; //# sym
                let observed = value; //# sym
                value //# sym
            }
        "#},
        observations: expect![[r#"
            src/lib.rs: path `value`
              symbol: local value#1
            src/lib.rs: path `value`
              symbol: local value#1
            src/lib.rs: path `value`
              symbol: local value#2
            src/lib.rs: path `value`
              symbol: local value#2
        "#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::symbol_selection_excludes_field_names_types_and_let_patterns

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
fn symbol_selection_excludes_field_names_types_and_let_patterns() {
    compile_test! {
        source: indoc! {r#"
            struct Record { field: u16 }
            fn example(record: Record) -> u16 {
                let field: u16 = record.field; //# sym
                field
            }
        "#},
        observations: expect![[r#"
            src/lib.rs: path `record`
              symbol: local record#1
        "#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::symbols_and_types_share_expression_headers

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.grouped_observations)]
#[sage::test(crates.sage_test_harness.compile_tests.resolved_symbols)]
fn symbols_and_types_share_expression_headers() {
    compile_test! {
        source: indoc! {r#"
            mod module { pub fn value() -> u16 { 22 } }
            fn example() -> u16 {
                module::value() //# ty
                //# sym
                //# ty
                //# sym
            }
        "#},
        observations: expect![[r#"
            src/lib.rs: path `module::value`
              symbol: fn crate::module::value
              type: fn() -> u16
            src/lib.rs: call `module::value()`
              type: u16
        "#]],
    }
}
}

See more source ↗

Review: Accepted · Codex anchor_019 refresh.

Fresh source assessment of the current complete resolved_symbols claim, all five implementation entries, and all eleven tests after start with the current coordinator instructions. Every entry is ordinary; no TODO or N/A evidence is being treated as implemented. No source changes were necessary in this refresh.

Implementation: annotations.rs recognizes bare sym and calculates the selected source line. source.rs enumerates only explicit expression CST nodes, tagging paths and traversing receivers/arguments without treating field names, method names, type syntax, or patterns as paths. observe.rs calls completed function.body, freezes typed-path resolution using symbols.rs, matches source expressions to semantic nodes by span and kind, filters by start line and path kind, and errors for invalid/missing correspondence or a line with no path. Implicit elaboration nodes do not independently enter the source-driven output inventory. Symbols.rs uses PathResolution definitions rather than token spellings; local module items receive a kind and crate-qualified module/name, variants include their enum, external symbols use tcx.def_path, and bindings count only preceding same-named declarations plus one. Missing bindings and ambiguous tied identities error. Local associated function/constant identities are excluded by owner guards and produce unsupported errors. Actual PathResolution errors and checked error nodes are represented as <unresolved>, while unresolved/missing typed correspondence is invalid. Types.rs supplies qualified_local_name; its ancestry walk ensures nested module names appear in order. Names become owned strings within check_crate/walk_expr, before collect takes the inspection log; rendering operates on frozen values. The captured CompileTest macro/run/prepare code confirms observation expectations assert actual prepared output and cannot steer resolution.

Test mapping: aliases_and_qualified_paths_identify_the_definition asserts two distinct crate-qualified fn identities despite equal item names and an import alias, testing actual definition selection and selected source lines. shadowed_locals_have_distinct_stable_identities asserts value#1 before shadowing and value#2 afterward with unrelated intervening bindings; exact output also excludes allocation IDs and source coordinates. external_definitions_use_metadata_paths asserts the external Ordering variant metadata path. symbols_and_types_share_expression_headers asserts the precise path/call example from the claim, symbol then type, with repeated markers deduplicated. symbol_selections_require_paths_and_expectations asserts missing-expectation and literal-only/no-path errors. unresolved_paths_still_require_error_markers now specifically asserts the Sage diagnostic mismatch, then exact <unresolved> symbol output after accounting for the diagnostic, and separation from diagnostic/query text. This strengthened assertion cannot accidentally pass solely on a rustc mismatch. unsupported_associated_identity_is_not_unresolved constructs a real trait-associated function and asserts the explicit unsupported identity error. missing_local_correspondence_is_not_an_unresolved_name asserts an out-of-range local semantic reference errors instead of producing <unresolved>.

Selection exclusions are covered by symbol_selection_excludes_field_names_types_and_let_patterns, whose inline fixture expects only the receiver path on the selected declaration line, and only_expression_paths_are_symbol_candidates, whose CST traversal assertion lists exactly four value paths while excluding method/field/type/pattern identifiers. The latter is deliberately selector-level evidence, not a claim that checking every syntactic scenario is supported; generated calls cannot enter this CST enumeration. cold_capture_includes_discovery_and_observation_reads_without_changing_bodies asserts the external identity, captured executed tcx::def_path, equal traces with/without selection, and both body executions. Together with the owned-string boundary this covers freezing before query capture ends. These assertions would detect alias-spelling identities, ordinal changes from unrelated locals, extra selector categories, silently empty observations, missing-resolution placeholders, or loss of name reads from capture.

Dependencies captured through review read: CompileTest implementation and macro; with_test_crate/local_function_named and setup helpers. Other implementation helpers used for this judgment are already present in the five whole-file initial fragments. All test assertions and expectations were inspected in full. This is a source review only: I ran the review start/read/record workflow and source inspection commands, not Cargo test or build suites in this refresh. Root runs centralized validation. No requested edits remain.

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