crates.sage_test_harness.compile_tests.diagnostic_locations

Diagnostic markers match structured diagnostics by severity and logical source file/line. A diagnostic is eligible if its primary span intersects the target line, or if that primary span’s macro-expansion ancestry contains an invocation intersecting it. An empty span matches the line containing its position: for example, a missing-token diagnostic can point between characters without covering any character. A position at the start of a line belongs to that line; EOF belongs to the final source line (including an empty final line after a trailing newline). The same rule applies to empty invocation spans in expansion ancestry. Nested expansions retain this ancestry. For Sage, the primary span is Diagnostic::span; entries in Diagnostic::labels do not participate in matching, regardless of their label style. Labels, attached notes, and help remain in the rendered snapshot but do not supply additional matching locations or ERROR/WARN events. Matching does not parse rendered text. Each diagnostic counts once even if its primary span or expansion ancestry matches several lines. A source diagnostic with no matchable location remains unmatched and fails the test.

For rustc, only spans marked is_primary in structured JSON diagnostics and their recursive expansion invocation spans are eligible. Any eligible primary span may match. Child notes/help and secondary spans do not introduce events or eligible locations. rustc’s spanless final error/warning count summaries and failure-note explanations are presentation, not additional source diagnostics; other spanless errors or warnings fail matching. Distinct top-level diagnostics are never deduplicated by message text.

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

Implementation

Implemented crates/sage-ir/src/diagnostic.rs:7–12

sage_ir::diagnostic · lib:sage_ir

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.diagnostic_locations`
// {anchor}`crates.sage_test_harness.compile_tests.rendering`
use crate::local_syms::LocalModItemSym;
use crate::span::{AbsoluteSpan, RelativeSpan};

// ---------------------------------------------------------------------------

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/observe.rs:591–596

sage_test_harness::compile::observe · lib:sage_test_harness

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

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/rustc.rs:79–84

sage_test_harness::compile::rustc · lib:sage_test_harness

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

}

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::observe::tests::empty_spans_match_positions_including_eof

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_locations)]
    fn empty_spans_match_positions_including_eof() {
        let mut diagnostic = diagnostic(1, 1, Severity::Error);
        diagnostic.primary[0].start = 2;
        diagnostic.primary[0].end = 2;
        assert!(match_diagnostics(&[marker(2, Kind::Error)], &[diagnostic.clone()]).is_ok());
        diagnostic.primary[0].start = 6;
        diagnostic.primary[0].end = 6;
        assert!(match_diagnostics(&[marker(4, Kind::Error)], &[diagnostic]).is_ok());
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::observe::tests::labels_and_notes_do_not_supply_matching_locations

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_locations)]
    #[sage::test(crates.sage_test_harness.compile_tests.rendering)]
    fn labels_and_notes_do_not_supply_matching_locations() {
        let mut diagnostic = diagnostic(1, 1, Severity::Error);
        let other = self::diagnostic(2, 2, Severity::Warning);
        diagnostic.labels.push((
            other.primary.clone(),
            "related declaration".into(),
            LabelStyle::Primary,
        ));
        diagnostic.notes.push(other);
        assert!(match_diagnostics(&[marker(1, Kind::Error)], &[diagnostic.clone()]).is_ok());
        assert!(match_diagnostics(&[marker(2, Kind::Error)], &[diagnostic.clone()]).is_err());
        let rendered = diagnostic.render();
        assert!(rendered.contains("related declaration"));
        assert!(rendered.contains("warning"));
    }
}

Conditional source: #[cfg(test)]

See more source ↗

Implemented sage_test_harness::compile::rustc::tests::empty_primary_and_nested_invocation_spans_keep_position_lines

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)]
    fn empty_primary_and_nested_invocation_spans_keep_position_lines() {
        for (source, position, line) in [
            ("ab\ncd", 1, 1),
            ("ab\ncd", 3, 2),
            ("ab\ncd", 5, 2),
            ("ab\ncd\n", 6, 3),
        ] {
            let files = BTreeMap::from([("src/lib.rs".into(), source.into())]);
            for expansion in [false, true] {
                let mut primary = span(position, position, true);
                if expansion {
                    let mut inner = span(0, 1, false);
                    inner["expansion"] = json!({"span": primary});
                    primary = span(0, 1, true);
                    primary["expansion"] = json!({"span": inner});
                }
                let diagnostics = parse(&diagnostic(vec![primary]).to_string(), &files).unwrap();
                assert_eq!(diagnostics.len(), 1);
                let location = diagnostics[0].primary.last().unwrap();
                assert_eq!(location.lines(), line..=line);
                let marker = Marker {
                    file: "src/lib.rs".into(),
                    line,
                    kind: super::super::annotations::Kind::Error,
                    compiler: None,
                };
                assert!(
                    super::super::observe::match_compiler_diagnostics(
                        Compiler::Rustc,
                        &[marker.clone()],
                        &diagnostics,
                    )
                    .is_ok()
                );
                assert!(
                    super::super::observe::match_compiler_diagnostics(
                        Compiler::Rustc,
                        &[marker.clone(), marker],
                        &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::only_spanless_summaries_and_failure_notes_are_presentation

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)]
    fn only_spanless_summaries_and_failure_notes_are_presentation() {
        let files = BTreeMap::from([("src/lib.rs".into(), "x".into())]);
        for (level, message) in [
            ("error", "aborting due to 1 previous error"),
            (
                "error",
                "aborting due to 2 previous errors; 1 warning emitted",
            ),
            ("warning", "1 warning emitted"),
            ("warning", "2 warnings emitted"),
            (
                "failure-note",
                "For more information about this error, try rustc --explain E0308.",
            ),
        ] {
            let mut summary = diagnostic(vec![]);
            summary["level"] = json!(level);
            summary["message"] = json!(message);
            assert!(parse(&summary.to_string(), &files).unwrap().is_empty());
        }
        for level in ["error", "warning"] {
            let mut source_diagnostic = diagnostic(vec![]);
            source_diagnostic["level"] = json!(level);
            let diagnostics = parse(&source_diagnostic.to_string(), &files).unwrap();
            assert_eq!(diagnostics.len(), 1);
            assert!(
                super::super::observe::match_compiler_diagnostics(
                    Compiler::Rustc,
                    &[],
                    &diagnostics,
                )
                .is_err()
            );
        }
        let mut located_warning = diagnostic(vec![span(0, 1, true)]);
        located_warning["level"] = json!("warning");
        located_warning["message"] = json!("1 warning emitted");
        let diagnostics = parse(&located_warning.to_string(), &files).unwrap();
        assert_eq!(diagnostics.len(), 1);
        assert_eq!(diagnostics[0].severity, Severity::Warning);
        let mut marker = Marker {
            file: "src/lib.rs".into(),
            line: 1,
            kind: super::super::annotations::Kind::Warning,
            compiler: None,
        };
        assert!(
            super::super::observe::match_compiler_diagnostics(
                Compiler::Rustc,
                &[marker.clone()],
                &diagnostics,
            )
            .is_ok()
        );
        marker.kind = super::super::annotations::Kind::Error;
        assert!(
            super::super::observe::match_compiler_diagnostics(
                Compiler::Rustc,
                &[marker],
                &diagnostics,
            )
            .is_err()
        );
    }
}

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

Review: Accepted · /root/final_quality.

Fresh review of the complete diagnostic_locations claim, all three ordinary implementation entries and all eight associated tests. Additional dependencies captured: span representation/composition, logical path normalization and annotation parsing/applicability. No TODO/N/A evidence is present. No source edits, build or tests run in this review; conclusions are from source/assertion inspection. One out-of-bounds source capture request was retried successfully using the whole file.

Sage locations: diagnostic.rs freezes Diagnostic::span separately from labels and notes. Span::resolve composes relative offsets against the owning item. Snapshot location conversion follows BangMacro invocation and Derive source-item ancestry until reaching the actual fixture source file, including nested generated sources; generated buffers are not exposed as fixture filenames. SourceLocation::lines counts newlines before start and before end-1 for a nonempty range, or before start for an empty range. Thus nonempty ranges use half-open intersection, a zero-width position at a line start belongs to that line, and EOF uses the final source line, including a trailing empty line. Snapshot rendering keeps labels and recursively rendered notes, but matching uses only the separate primary locations. Prefixing normalizes fixture-relative paths without changing text.

observe.rs builds eligibility using applicable marker severity, exact logical filename and any intersecting primary location. It never parses rendered diagnostics or consults labels/notes for edges. Matching assigns by diagnostic index, so several eligible lines/ancestry locations still describe one event; locationless events remain unmatched and fail. This separates diagnostic rendering choices, including primary-styled labels, from eligibility.

rustc.rs parses structured top-level JSON and selects only spans whose is_primary flag is true. For each selected span it walks recursive expansion.span ancestry, accepting relative paths in the fixture file map and validating byte offsets/character boundaries. Invocation spans need not themselves have is_primary true once reached through ancestry. Locations share SourceLocation::lines, so empty invocation and primary spans follow the same positional rule. Child notes/help and secondary spans do not add locations/events. Every ordinary top-level error/warning appends one event without message deduplication. Only spanless, uncoded recognized count-summary forms and failure-note presentation are omitted; other spanless errors/warnings remain unmatched. A source-located diagnostic with summary-like text is retained.

All tests assessed: empty_spans_match_positions_including_eof checks an empty span at the second line's start and trailing-newline EOF through Sage matching. labels_and_notes_do_not_supply_matching_locations rejects matching at a primary-styled label/note location while accepting the true primary and retaining label/note rendering. empty_primary_and_nested_invocation_spans_keep_position_lines covers midline, line start, EOF without newline and EOF with newline for both direct and nested invocation spans; each matches one marker and rejects two, checking event identity. nested_macro_errors_match_invocations_and_multiple_errors_need_multiple_markers runs the real pinned-compiler helper for nested macros and same-line multiple errors. only_spanless_summaries_and_failure_notes_are_presentation checks summary/failure-note filtering, retention and rejection of arbitrary spanless errors and warnings, and retention plus warning-only matching of located summary-like text. primary_spans_and_ancestry_match_but_labels_and_children_do_not asserts exact extracted primary/ancestry line numbers, excludes a secondary span and child event, preserves duplicate top-level events and rejects locationless ones. invalid_source_reaches_sage supplies a real multiline primary body mismatch matching a marker on an intersected line while retaining detailed rendering. macro_generated_errors_match_the_invocation supplies a generated body mismatch and asserts the invocation-based Sage snapshot through normal compilation. The visible test helpers create the stated source offsets and invoke the production parser/checker or matcher. Source inspection plus these assertions accounts for logical location, severity, empty spans, ancestry, event count, presentation exclusions and unmatched failures. 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