crates.sage_test_harness.compile_tests.annotation_validation

Unknown or malformed directives, invalid compiler conditions, missing or unused observation expectations, and invalid selections fail the test. A fixture containing any //# ty or //# sym marker requires one combined observations: expect![...] expectation; a observations expectation without observation markers is rejected. Annotation validation is independent of snapshot blessing, and no directive is silently ignored because it is misspelled or cannot be resolved.

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

Implementation

Implemented crates/sage-test-harness/src/compile/annotations.rs:42–111

sage_test_harness::compile::annotations · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.annotation_validation`<<
pub(super) fn parse(file: &str, source: &str) -> Result<Vec<Marker>, String> {
    if source.contains('\t') {
        return Err(format!("{file}: tabs are not allowed"));
    }
    let tree = tree(source);
    let mut comments = Vec::new();
    fn walk(node: tree_sitter::Node<'_>, source: &str, comments: &mut Vec<(usize, usize, String)>) {
        if node.kind() == "line_comment" {
            let text = &source[node.byte_range()];
            if let Some(directive) = text.strip_prefix("//#") {
                comments.push((
                    node.start_position().row,
                    node.start_position().column,
                    directive.trim().into(),
                ));
            }
            return;
        }
        let mut cursor = node.walk();
        for child in node.children(&mut cursor) {
            walk(child, source, comments);
        }
    }
    walk(tree.root_node(), source, &mut comments);
    let lines: Vec<_> = source.split('\n').collect();
    let annotation_only: BTreeSet<_> = comments
        .iter()
        .filter_map(|(row, column, _)| lines[*row][..*column].trim().is_empty().then_some(*row))
        .collect();
    let mut result = Vec::new();
    for (row, column, directive) in comments {
        let words: Vec<_> = directive.split_whitespace().collect();
        // {anchor}`crates.sage_test_harness.compile_tests.compiler_conditions`
        let (kind, compiler) = match words.as_slice() {
            ["ty"] => (Kind::Type, Some(Compiler::Sage)),
            ["sym"] => (Kind::Symbol, Some(Compiler::Sage)),
            ["ERROR"] => (Kind::Error, None),
            ["ERROR", "if", "SAGE"] => (Kind::Error, Some(Compiler::Sage)),
            ["WARN"] => (Kind::Warning, None),
            ["WARN", "if", "SAGE"] => (Kind::Warning, Some(Compiler::Sage)),
            ["ERROR", "if", "rustc"] => (Kind::Error, Some(Compiler::Rustc)),
            ["WARN", "if", "rustc"] => (Kind::Warning, Some(Compiler::Rustc)),
            _ => {
                return Err(format!(
                    "{file}:{}: malformed directive: {directive}",
                    row + 1
                ));
            }
        };
        // {anchor}`crates.sage_test_harness.compile_tests.target_line`
        let target = if !lines[row][..column].trim().is_empty() {
            Some(row)
        } else {
            (0..row)
                .rev()
                .find(|line| !lines[*line].trim().is_empty() && !annotation_only.contains(line))
        };
        let target =
            target.ok_or_else(|| format!("{file}:{}: annotation has no target", row + 1))?;
        result.push(Marker {
            file: file.into(),
            line: target + 1,
            kind,
            compiler,
        });
    }
    Ok(result)
}
// >>

}

See more source ↗

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

sage_test_harness::compile::observe · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.annotation_validation`
// {anchor}`crates.sage_test_harness.compile_tests.compiler_conditions`
// {anchor}`crates.sage_test_harness.compile_tests.fixtures`
use super::annotations::Compiler;
use super::types::FrozenType;
use super::{BTreeSet, Kind, Marker, Output};

}

See more source ↗

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

sage_test_harness::compile::source · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.annotation_validation`
// {anchor}`crates.sage_test_harness.compile_tests.grouped_observations`
// {anchor}`crates.sage_test_harness.compile_tests.completed_types`
// {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};

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/symbols.rs:2–7

sage_test_harness::compile::symbols · lib:sage_test_harness

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

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/types.rs:2–7

sage_test_harness::compile::types · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.annotation_validation`
// {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::{

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/mod.rs:101–106

sage_test_harness::compile · lib:sage_test_harness

#![allow(unused)]
fn main() {
    // {anchor}`crates.sage_test_harness.compile_tests.annotation_validation`
    // {anchor}`crates.sage_test_harness.compile_tests.query_capture`
    // {anchor}`crates.sage_test_harness.compile_tests.coordinates`
    fn prepare(&self) -> Result<Output, String> {
        let files = validate_files(self.files.as_deref().ok_or("missing source or files")?)?;
        let edition = self.edition.as_deref().unwrap_or("2024");

}

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::annotations::tests::only_real_line_comment_directives_are_interpreted

crates/sage-test-harness/src/compile/annotations.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.compiler_conditions)]
    #[sage::test(crates.sage_test_harness.compile_tests.target_line)]
    fn only_real_line_comment_directives_are_interpreted() {
        let markers = parse(
            "src/lib.rs",
            r##"fn f() { let s = r#"//# invalid"#; /* //# invalid */ }"##,
        )
        .unwrap();
        assert!(markers.is_empty());
        for bad in [
            "//# ty",
            "//# sym",
            "fn f() {} //# sym[slug]",
            "fn f() {} //# sym if SAGE",
            "fn f() {} //# ERROR[SAGE]",
            "fn f() {} //# ERROR if sage",
            "fn f() {} //# ty[slug]",
            "fn f() {} //# WARN if other",
        ] {
            assert!(parse("src/lib.rs", bad).is_err(), "{bad}");
        }
        assert_eq!(
            parse("src/lib.rs", "fn café() {} //# ty").unwrap()[0].line,
            1
        );
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::tests::expectations_and_source_selections_must_agree

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.completed_types)]
    #[sage::test(crates.sage_test_harness.compile_tests.starting_expressions)]
    fn expectations_and_source_selections_must_agree() {
        let mut test = CompileTest::default();
        test.source("fn f() { 22; } //# ty");
        assert!(
            test.prepare()
                .unwrap_err()
                .contains("observations expectation")
        );
        let mut test = CompileTest::default();
        test.source("fn f() {}");
        test.observations(expect![""]);
        assert!(
            test.prepare()
                .unwrap_err()
                .contains("observations expectation")
        );
        let mut test = CompileTest::default();
        test.source("fn f() {\n}\n//# ty");
        test.observations(expect![""]);
        assert!(test.prepare().unwrap_err().contains("no expression"));
    }
}

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

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.annotation_validation)]
#[should_panic(expected = "duplicate field: observations")]
fn duplicate_observation_expectations_are_rejected() {
    sage_test_harness::compile_test! {
        source: "fn value() -> u16 { 22 } //# ty",
        observations: expect_test::expect![""],
        observations: expect_test::expect![""],
    }
}
}

See more source ↗

Implemented sage_test_harness::blessing_edits_the_inline_callsite_and_then_passes_without_updates

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.annotation_validation)]
#[sage::test(crates.sage_test_harness.compile_tests.callsite_updates)]
#[sage::test(crates.sage_test_harness.compile_tests.invocation)]
#[sage::test(crates.sage_test_harness.compile_tests.blessing_gate)]
#[sage::test(crates.sage_test_harness.compile_tests.review_visibility)]
fn blessing_edits_the_inline_callsite_and_then_passes_without_updates() {
    // Compile a disposable copy: expect-test must never update this test suite
    // while exercising update mode. The complete fixture and assertion remain
    // visibly inside the annotated function's source for anchor review.
    let project = tempfile::tempdir().unwrap();
    let harness = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
    std::fs::create_dir(project.path().join("src")).unwrap();
    std::fs::write(
        project.path().join("Cargo.toml"),
        format!(
            r#"
[package]
name = "inline_callsite_probe"
version = "0.0.0"
edition = "2024"
[workspace]
[dependencies]
sage-test-harness = {{ path = {:?} }}
expect-test = "1.5.1"
[patch.crates-io]
salsa = {{ path = {:?} }}
"#,
            harness,
            harness.join("../../vendor/salsa")
        ),
    )
    .unwrap();
    // Reuse the repository's pinned dependency resolution, not a fresh online
    // resolution of the disposable package's transitive dependencies.
    std::fs::copy(
        harness.join("../../Cargo.lock"),
        project.path().join("Cargo.lock"),
    )
    .unwrap();
    let source = r##"#![feature(rustc_private)]
use sage_test_harness::compile_test;
use expect_test::expect;
#[test]
fn inline_source() {
    compile_test! {
        source: "fn answer() -> u16 {\n    22 //# ty\n}",
        observations: expect![[r#""#]],
        diagnostics: expect![""],
    }
}
"##;
    let path = project.path().join("src/lib.rs");
    std::fs::write(&path, source).unwrap();
    let target = harness.join("../../target");
    let run = |update, expected_success| {
        let mut command = Command::new("cargo");
        command
            .args(["test", "--offline", "--lib", "--quiet"])
            .current_dir(project.path())
            .env("CARGO_TARGET_DIR", &target)
            .env("RUSTC", sage_host::metadata::our_rustc());
        if update {
            command.env("UPDATE_EXPECT", "1");
        } else {
            command.env_remove("UPDATE_EXPECT");
        }
        let output = command.output().unwrap();
        assert_eq!(
            output.status.success(),
            expected_success,
            "{}\n{}",
            String::from_utf8_lossy(&output.stdout),
            String::from_utf8_lossy(&output.stderr)
        );
        String::from_utf8_lossy(&output.stdout).to_string()
    };
    // A rustc-only warning is an unexpected diagnostic even with UPDATE_EXPECT.
    // The stale observation must remain byte-for-byte unchanged on failure.
    let unexpected = source.replace("fn answer()", "#[warn(dead_code)] fn answer()");
    std::fs::write(&path, &unexpected).unwrap();
    let failure = run(true, false);
    assert!(
        failure.contains("Rustc diagnostic markers do not match"),
        "{failure}"
    );
    assert_eq!(std::fs::read_to_string(&path).unwrap(), unexpected);
    std::fs::write(&path, source).unwrap();
    let stale = run(false, false);
    assert!(stale.contains("expect test failed"), "{stale}");
    assert_eq!(std::fs::read_to_string(&path).unwrap(), source);
    run(true, true);
    let blessed = std::fs::read_to_string(&path).unwrap();
    assert!(
        blessed.contains("src/lib.rs: literal `22`") && blessed.contains("type: u16"),
        "{blessed}"
    );
    assert!(blessed.contains("22 //# ty"));
    assert!(blessed.contains("diagnostics: expect![\"\"]"));
    assert_eq!(blessed.matches("src/lib.rs: literal").count(), 1);
    run(false, true);
    assert_eq!(std::fs::read_to_string(path).unwrap(), blessed);
}
}

See more source ↗

Review: Accepted · /root/final_quality.

Reviewed the complete annotation_validation claim, all six associated implementation entries and all five ordinary tests from fresh captured inputs. No TODO/N/A evidence is associated with this claim. This is source assessment: I ran review start/read/record commands, not Cargo test suites or a fresh build; central test results are not substituted for the assertions below.

Directive grammar and targeting: annotations.rs parses real tree-sitter line-comment nodes, recognizes only the supported ty/sym and ERROR/WARN forms, and rejects unknown syntax, forbidden condition/selector forms, tabs, unsupported compiler names and annotations without a source target. Conditions are exact SAGE/rustc spellings. Literal and block-comment text is not a directive. The associated only_real_line_comment_directives_are_interpreted test visibly exercises raw-string/block-comment non-directives, missing targets, unsupported selectors and compiler conditions, and an accepted Unicode source line. Its rejection table checks errors rather than snapshot output.

Expectation cardinality: CompileTest::prepare in mod.rs parses the markers before running the fixture and requires observation-marker presence to agree with observations presence. Type and symbol markers share one expectation. The expectation setter rejects a second observations field immediately. expectations_and_source_selections_must_agree checks missing and unused observations and a line with no selected expression; symbol_selections_require_paths_and_expectations separately checks missing observations for sym and a nonpath selection; duplicate_observation_expectations_are_rejected asserts the duplicate-field panic through compile_test itself. These assertions cover both directions of the presence rule and the one-combined-field requirement.

Selections and resolution: observe.rs rejects annotations outside the checked crate, demands a nonempty applicable expression/path selection and propagates invalid correspondence and incomplete type/symbol results as errors. Its source-to-semantic join requires a unique matching candidate and explicitly inserts invalid rows for absent/ambiguous correspondence, rather than silently dropping the source expression. The source.rs walker enumerates expression children and preserves Missing as unresolved; symbols.rs returns errors for unsupported or absent identities; types.rs recursively treats Missing/inference holes as incomplete, including nested type structure. These are the other four associated implementation entries. The captured completed_types and resolved_symbols qualifications explain that explicit compiler error values may be rendered, while missing successful results and unsupported correspondence fail. This review assesses observation validation, not the authored checker dereference implementation. The two selection tests above concretely verify no-expression/no-path failures; source inspection traces the remaining unresolved/ambiguous cases to the same error gate.

Validation versus blessing: CompileTest::run completes prepare before any Expect assertion, and prepare's errors propagate without invoking snapshot updates. Annotation parsing, expectation presence, diagnostic matching and observation collection therefore cannot be repaired by blessing. observe.rs checks complete applicable diagnostic matching and propagates failures; captured rustc.rs check/validate_output independently validates process output and delegates Rustc marker matching before success. The associated blessing_edits_the_inline_callsite_and_then_passes_without_updates test constructs a real temporary caller, forces an unmarked rustc warning with UPDATE_EXPECT enabled and asserts failure plus unchanged caller text, checks stale ordinary snapshots fail without writes, then verifies a legitimate update changes the inline observation and a subsequent non-updating run succeeds unchanged. Its visible checks include preserving annotations and the diagnostics expectation. This is meaningful evidence for the shared pre-assertion validation boundary; it does not individually run every malformed-directive variant in updating mode. Together with the parser rejection table, presence/cardinality tests and selection rejection tests, it adequately covers this claim's distinct validation mechanisms. No concrete defect or required edit found.

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