crates.sage_test_harness.compile_tests.diagnostic_counts

The diagnostic set includes all source diagnostics from parsing, expansion, resolution, signature checking, and body checking. Repeated demands reporting the same diagnostic do not duplicate it. Distinct diagnostics remain distinct even when their messages and locations are identical. Malformed source is a negative-test input, not by itself an infrastructure failure.

There must be a complete one-to-one matching between applicable ERROR/WARN markers and emitted diagnostics. Each marker consumes one diagnostic, and each diagnostic consumes one marker. Multiple diagnostics on one line require multiple markers. Matching considers the complete eligibility relation, so a greedy choice cannot reject an otherwise valid assignment. Missing diagnostics, extra diagnostics, and severity mismatches fail even if their rendered output matches a snapshot. Matching never changes diagnostic output order.

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

Implementation

Implemented crates/sage-ir/src/check/sig.rs:1–6

sage_ir::check::sig · lib:sage_ir

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

use crate::diagnostic::{Diagnostic, ErrorReported, Span};
use crate::local_syms::LocalModItemSym;
use crate::resolve::Resolver;

}

See more source ↗

Implemented crates/sage-ir/src/diagnostic.rs:234–239

sage_ir::diagnostic · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.diagnostic_counts`
#[derive(Clone, Debug)]
pub struct SignatureDiagnostic(pub DiagnosticSnapshot);

/// Resolved source data: rendering this value performs no semantic queries.
#[derive(Clone, Debug, PartialEq, Eq)]

}

See more source ↗

Implemented crates/sage-ir/src/local_syms/uses.rs:2–7

sage_ir::local_syms::uses · lib:sage_ir

#![allow(unused)]
fn main() {
// {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;
use crate::scope::ScopeSymbol;

}

See more source ↗

Implemented crates/sage-ir/src/parse/mod.rs:2–7

sage_ir::parse · lib:sage_ir

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

}

See more source ↗

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

sage_test_harness::compile::annotations · lib:sage_test_harness

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Kind {
    Type,

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/observe.rs:592–665

sage_test_harness::compile::observe · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.diagnostic_counts`<<
pub(super) fn match_diagnostics(
    markers: &[Marker],
    diagnostics: &[DiagnosticSnapshot],
) -> Result<(), String> {
    match_compiler_diagnostics(Compiler::Sage, markers, diagnostics)
}

// {anchor}`crates.sage_test_harness.compile_tests.rustc_lints`
pub(super) fn match_compiler_diagnostics(
    compiler: Compiler,
    markers: &[Marker],
    diagnostics: &[DiagnosticSnapshot],
) -> Result<(), String> {
    let markers: Vec<_> = markers
        .iter()
        .filter(|m| m.applies_to(compiler) && matches!(m.kind, Kind::Error | Kind::Warning))
        .collect();
    let edges: Vec<Vec<_>> = markers
        .iter()
        .map(|marker| {
            diagnostics
                .iter()
                .enumerate()
                .filter_map(|(i, diag)| {
                    let severity = match marker.kind {
                        Kind::Error => Severity::Error,
                        Kind::Warning => Severity::Warning,
                        Kind::Type | Kind::Symbol => unreachable!(),
                    };
                    (diag.severity == severity
                        && diag.primary.iter().any(|location| {
                            location.path == marker.file && location.lines().contains(&marker.line)
                        }))
                    .then_some(i)
                })
                .collect()
        })
        .collect();
    fn augment(
        marker: usize,
        edges: &[Vec<usize>],
        assigned: &mut [Option<usize>],
        seen: &mut BTreeSet<usize>,
    ) -> bool {
        for &diag in &edges[marker] {
            if !seen.insert(diag) {
                continue;
            }
            if assigned[diag].is_none_or(|previous| augment(previous, edges, assigned, seen)) {
                assigned[diag] = Some(marker);
                return true;
            }
        }
        false
    }
    let mut assigned = vec![None; diagnostics.len()];
    let matched =
        (0..markers.len()).all(|m| augment(m, &edges, &mut assigned, &mut BTreeSet::new()));
    if !matched || assigned.iter().any(Option::is_none) {
        return Err(format!(
            "{compiler:?} diagnostic markers do not match: {} markers, {} diagnostics\n{}",
            markers.len(),
            diagnostics.len(),
            diagnostics
                .iter()
                .map(DiagnosticSnapshot::render)
                .collect::<Vec<_>>()
                .join("\n")
        ));
    }
    Ok(())
}
// >>

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/rustc.rs:80–85

sage_test_harness::compile::rustc · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.diagnostic_counts`
fn parse(
    stderr: &str,
    files: &BTreeMap<String, String>,
) -> Result<Vec<DiagnosticSnapshot>, String> {
    let mut diagnostics = Vec::new();

}

See more source ↗

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

sage_test_harness::compile · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.diagnostic_counts`
// {anchor}`crates.sage_test_harness.compile_tests.completed_types`
// {anchor}`crates.sage_test_harness.compile_tests.grouped_observations`
mod annotations;
mod observe;
mod rustc;

}

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::diagnostic_count_review_tests::incomplete_expansion_is_a_source_diagnostic

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.diagnostic_counts)]
    fn incomplete_expansion_is_a_source_diagnostic() {
        let mut test = CompileTest::default();
        test.source("missing!();");
        let error = test.prepare().unwrap_err();
        assert!(
            error.contains("Sage diagnostic markers do not match"),
            "{error}"
        );
        assert!(error.contains("module expansion is incomplete"), "{error}");
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::diagnostic_count_review_tests::matching_preserves_identical_diagnostics_and_output_order

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.diagnostic_counts)]
    #[sage::test(crates.sage_test_harness.compile_tests.rendering)]
    fn matching_preserves_identical_diagnostics_and_output_order() {
        let source = "fn f() {} //# ERROR\n//# ERROR\n//# ERROR";
        let markers = annotations::parse("src/lib.rs", source).unwrap();
        let first = DiagnosticSnapshot {
            severity: Severity::Error,
            primary: vec![SourceLocation {
                path: "src/lib.rs".into(),
                source: source.into(),
                start: 0,
                end: 1,
            }],
            message: "first".into(),
            labels: vec![],
            notes: vec![],
        };
        let mut second = first.clone();
        second.message = "second".into();
        let diagnostics = vec![first.clone(), second, first];
        let before = diagnostics
            .iter()
            .map(DiagnosticSnapshot::render)
            .collect::<Vec<_>>();
        observe::match_diagnostics(&markers, &diagnostics).unwrap();
        assert_eq!(
            diagnostics
                .iter()
                .map(DiagnosticSnapshot::render)
                .collect::<Vec<_>>(),
            before
        );
        assert!(observe::match_diagnostics(&markers[..2], &diagnostics).is_err());
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::diagnostic_count_review_tests::matching_snapshot_cannot_hide_missing_diagnostic

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.diagnostic_counts)]
    fn matching_snapshot_cannot_hide_missing_diagnostic() {
        let mut test = CompileTest::default();
        test.source("fn f() {} //# ERROR");
        // The actual diagnostic rendering is empty, exactly as this expectation.
        test.diagnostics(expect_test::expect![""]);
        let error = test.prepare().unwrap_err();
        assert!(
            error.contains("Sage diagnostic markers do not match: 1 markers, 0 diagnostics"),
            "{error}"
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::observe::tests::overlapping_locations_require_global_matching_and_exact_counts

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

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_test_harness.compile_tests.diagnostic_counts)]
    fn overlapping_locations_require_global_matching_and_exact_counts() {
        let diagnostics = [
            diagnostic(1, 2, Severity::Error),
            diagnostic(1, 1, Severity::Error),
        ];
        let markers = [marker(1, Kind::Error), marker(2, Kind::Error)];
        assert!(match_diagnostics(&markers, &diagnostics).is_ok());
        assert!(match_diagnostics(&markers[..1], &diagnostics).is_err());
        assert!(match_diagnostics(&markers, &diagnostics[..1]).is_err());
        assert!(
            match_diagnostics(
                &[marker(1, Kind::Warning), marker(2, Kind::Error)],
                &diagnostics
            )
            .is_err()
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::rustc::tests::nested_macro_errors_match_invocations_and_multiple_errors_need_multiple_markers

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

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_test_harness.compile_tests.diagnostic_locations)]
    #[sage::test(crates.sage_test_harness.compile_tests.diagnostic_counts)]
    fn nested_macro_errors_match_invocations_and_multiple_errors_need_multiple_markers() {
        run("macro_rules! inner { () => { fn bad() -> u8 { true } } }\nmacro_rules! outer { () => { inner!(); } }\nouter!(); //# ERROR", "2024").unwrap();
        let source = "fn f() { let _: u8 = true; let _: bool = 1; } //# ERROR\n//# ERROR";
        run(source, "2024").unwrap();
        assert!(
            run(source.trim_end_matches("\n//# ERROR"), "2024")
                .unwrap_err()
                .contains("1 markers, 2 diagnostics")
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::rustc::tests::primary_spans_and_ancestry_match_but_labels_and_children_do_not

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

#![allow(unused)]
fn main() {
#[test]
    #[sage::test(crates.sage_test_harness.compile_tests.diagnostic_locations)]
    #[sage::test(crates.sage_test_harness.compile_tests.diagnostic_counts)]
    fn primary_spans_and_ancestry_match_but_labels_and_children_do_not() {
        let files = BTreeMap::from([("src/lib.rs".into(), "a\nb\nc\n".into())]);
        let mut origin = span(0, 1, true);
        origin["expansion"] = json!({"span":span(4, 5, false)});
        let mut diag = diagnostic(vec![origin, span(2, 3, false), span(6, 6, true)]);
        diag["children"] = json!([diagnostic(vec![span(2, 3, true)])]);
        let result = parse(&diag.to_string(), &files).unwrap();
        assert_eq!(result.len(), 1);
        assert_eq!(
            result[0]
                .primary
                .iter()
                .map(|p| *p.lines().start())
                .collect::<Vec<_>>(),
            vec![1, 3, 4]
        );
        let duplicate = format!("{diag}\n{diag}");
        assert_eq!(parse(&duplicate, &files).unwrap().len(), 2);
        let locationless = parse(&diagnostic(vec![]).to_string(), &files).unwrap();
        assert_eq!(locationless.len(), 1);
        assert!(
            super::super::observe::match_compiler_diagnostics(Compiler::Rustc, &[], &locationless)
                .is_err()
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::invalid_source_reaches_sage

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.production_execution)]
#[sage::test(crates.sage_test_harness.compile_tests.diagnostic_counts)]
#[sage::test(crates.sage_test_harness.compile_tests.diagnostic_locations)]
#[sage::test(crates.sage_test_harness.compile_tests.rendering)]
fn invalid_source_reaches_sage() {
    compile_test! {
        source: indoc! {r#"
            fn example() -> u16 {
                true //# ERROR
            }
        "#},
        diagnostics: expect![[r#"
            error: type mismatch: expected `u16`, found `bool`
             --> src/lib.rs:1:21
              |
            1 |   fn example() -> u16 {
              |  _________________---_^
              | |                 |
              | |                 expected `u16` because of return type
            2 | |     true //# ERROR
            3 | | }
              | | ^
              | |_|
              |   found `bool`"#]],
    }
}
}

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::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 ↗

Review: Accepted · Codex /root/macro_fix_expand_deps.

Reviewed the complete diagnostic_counts claim, all eight implementation entries and all ten associated tests. Requirements are retention of parsing/expansion/resolution/signature/body diagnostics; repeated-demand deduplication without collapsing distinct equal diagnostics; malformed-source handling as test input; exhaustive one-to-one applicable marker matching including severity and multiple same-line diagnostics; global rather than greedy assignment; independent failure before snapshots; unchanged output order.

collect unconditionally runs tracked check_crate, retaining walker diagnostics and appending SignatureDiagnostic accumulations. The walker emits parse Error/incomplete expansion diagnostics, asks local signatures/bodies and includes their results, and calls LocalUseSym::diagnostics for imports. Signature Check::report accumulates at the producing query, while SignatureDiagnostic is a Salsa accumulator: repeated demands reuse that producer's emissions rather than manually deduplicating equal snapshots. Diagnostic::report appends, the collection/render paths retain vectors, and rustc's JSON parser pushes each source diagnostic record independently; no content-based deduplication collapses distinct equal diagnostics. The new import-root audit emits one ambiguity diagnostic then continues to the next import, avoiding a second unresolved-import diagnostic for the same audited import. Captured resolver/module helpers show this is a source resolution check, not an infrastructure failure.

Parser errors are represented as Error items and the walker snapshots them. Expansion failures become incomplete-expansion source diagnostics. Rustc normal error exit is accepted only with matching error diagnostics, whereas malformed transport/unexpected exit is infrastructure failure. Compiler conditions are applied before counting; ERROR and WARN retain separate severity. Each marker's candidate list includes all eligible diagnostic indices. The augmenting-path matcher can reassign a previously chosen diagnostic, giving complete bipartite matching; all markers must match and no diagnostic may remain unassigned. Matching receives an immutable diagnostic slice and only mutates a parallel assignment vector, so rendering order is preserved. CompileTest prepares both compiler results and validates markers before calling expectations, so an equal snapshot cannot bypass count failure.

Tests: incomplete_expansion_is_a_source_diagnostic requires both a Sage marker mismatch and an explicit incomplete-expansion message for missing!(). matching_preserves_identical_diagnostics_and_output_order retains a first/second/first vector, verifies three markers succeed, two fail, and rendering order is identical. matching_snapshot_cannot_hide_missing_diagnostic requires a missing-diagnostic failure despite an empty matching rendering snapshot. overlapping_locations_require_global_matching_and_exact_counts forces reassignment (first diagnostic eligible on two lines, second only one), then checks both count mismatch directions and severity mismatch. The rustc nested macro/count test requires two markers for two real errors; the structured primary/ancestry test verifies child/label exclusion, duplicate records surviving parse, and locationless diagnostics failing exhaustiveness. invalid_source_reaches_sage snapshots a real body error. signature_diagnostics_are_retained_once uses a bad signature from two callers but expects exactly one diagnostic. unused_import_is_checked snapshots an unused unresolved import. malformed_body_is_not_silently_accepted explicitly requires Sage diagnostic-marker failure rather than treating malformed input as successful. All scenarios/expectations are visible in test bodies; helper implementations are captured by the initial whole-file inputs. No TODO/N/A entries exist.

Executed cargo test -p sage-test-harness --lib compile::: 38 passed, including all six associated unit tests. During the immediately preceding checking-scope review on the same unchanged implementation, executed cargo test -p sage-test-harness --test compile_tests --test review_semantics: 14 and 8 passed, including the four associated integration tests. Those executions supplement the source inspection. No production edits or weakened tests; 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