crates.sage_test_harness.compile_tests.starting_expressions

A ty observation includes every source expression whose span starts on its target line in the same file. An expression may extend across subsequent lines; its start alone determines inclusion. Expressions starting on earlier or later lines are omitted, even if they contain or intersect the target line. Multiple sibling expressions starting on one line are all included. Each selected source expression appears once, with its logical filename, expression kind and readable source description, and completed type. The snapshot omits line numbers, columns, and ranges. Blocks follow the same start-line rule; a function-body block starting earlier is not included merely because it contains the target line.

All type markers contribute to the same snapshot. Files are ordered by logical path, then marked target lines by source order. Within each target line, output follows source-tree postorder: children before parents, with siblings in source order. Repeated markers targeting the same line do not duplicate observations. Distinct source expressions remain distinct entries even if their rendered text is identical. Source nesting distinguishes expressions with equal spans. Generated elaboration nodes do not add duplicate observations, except that meaningful coercion wrappers are reported after their wrapped expression. Each wrapper belongs to the selected source expression and exposes its resulting type, preserving child-before-parent order through a chain of coercions. A target line with no expression starting on it, or lacking a reliable source-to-semantic correspondence, fails explicitly. V1 observes expressions; binding declarations and other semantic entities require future selectors.

For example, an inline marker targets the code on its own line. The observations expectation contains the complete ordered observation:

use expect_test::expect;
use indoc::indoc;

#[test]
fn tuple_types() {
    compile_test! {
        source: indoc! {r#"
            fn example() -> (u16, (bool, u8)) {
                (1u16, (true, 2u8)) //# ty
            }
        "#},
        observations: expect![[r#"
            src/lib.rs: literal `1u16`
              type: u16
            src/lib.rs: literal `true`
              type: bool
            src/lib.rs: literal `2u8`
              type: u8
            src/lib.rs: tuple `(true, 2u8)`
              type: (bool, u8)
            src/lib.rs: tuple `(1u16, (true, 2u8))`
              type: (u16, (bool, u8))
        "#]],
        diagnostics: expect![""],
    }
}

The first tuple element precedes the second element’s subtree. Within that subtree, both literals precede their tuple. The function-body block starts on the preceding line, so it is omitted. The function declaration itself is not an expression.

A multi-line call demonstrates that enclosing expressions starting on earlier lines are omitted:

use expect_test::expect;
use indoc::indoc;

#[test]
fn call_argument_types() {
    compile_test! {
        source: indoc! {r#"
            fn inner(value: u16) -> u32 { value as u32 }
            fn outer(first: u32, second: u16) -> u64 { first as u64 + second as u64 }

            fn example() -> u64 {
                outer(
                    inner(22u16), //# ty
                    33u16,
                )
            }
        "#},
        observations: expect![[r#"
            src/lib.rs: path `inner`
              type: fn(u16) -> u32
            src/lib.rs: literal `22u16`
              type: u16
            src/lib.rs: call `inner(22u16)`
              type: u32
        "#]],
        diagnostics: expect![""],
    }
}

The callee path outer, the outer(...) call, and the function-body block start on earlier lines, so they are omitted. The literal 33u16 starts on a later line and is also omitted. Moving the marker to the line immediately after outer( would instead observe the path outer followed by the complete outer(...) call, even though that call ends several lines later. These expectation literals illustrate the filename-only output. Moving an expression to another line without changing observation order does not itself change its type snapshot. Expression descriptions use the single-line rendering rules below. Type representations describe the completed types currently exposed by Sage; the runner does not manufacture distinctions absent from its typed IR.

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

Implementation

Implemented crates/sage-test-harness/src/compile/observe.rs:368–373

sage_test_harness::compile::observe · lib:sage_test_harness

#![allow(unused)]
fn main() {
// {anchor}`crates.sage_test_harness.compile_tests.starting_expressions`
// {anchor}`crates.sage_test_harness.compile_tests.completed_types`<<
fn walk_expr<'db>(
    db: &'db dyn Db,
    stash: &Stash,
    expression: Ptr<TyExpr<'db>>,

}

See more source ↗

Implemented crates/sage-test-harness/src/compile/source.rs:5–10

sage_test_harness::compile::source · lib:sage_test_harness

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

pub(super) struct SourceExpression {

}

See more source ↗

Tests and review

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

Implemented sage_test_harness::compile::tests::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::files_lines_and_identical_siblings_keep_source_order

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.starting_expressions)]
fn files_lines_and_identical_siblings_keep_source_order() {
    compile_test! {
        files: {
            "src/z.rs": "fn z() -> u8 {\n 3 //# ty\n}",
            "src/lib.rs": "mod z; mod a;",
            "src/a.rs": "fn a() -> (u8, (bool, u8)) {\n (1, (true, 1)) //# ty\n //# ty\n}\nfn b() -> u8 {\n 2 //# ty\n}",
        },
        observations: expect![[r#"
            src/a.rs: literal `1`
              type: u8
            src/a.rs: literal `true`
              type: bool
            src/a.rs: literal `1`
              type: u8
            src/a.rs: tuple `(true, 1)`
              type: (bool, u8)
            src/a.rs: tuple `(1, (true, 1))`
              type: (u8, (bool, u8))
            src/a.rs: literal `2`
              type: u8
            src/z.rs: literal `3`
              type: u8
        "#]],
    }
}
}

See more source ↗

Implemented sage_test_harness::function_declaration_is_not_an_expression

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(crates.sage_test_harness.compile_tests.starting_expressions)]
#[should_panic(expected = "no expression with a completed type starts on this line")]
fn function_declaration_is_not_an_expression() {
    compile_test! {
        source: "fn f() //# ty\n{ }",
        observations: expect![""],
    }
}
}

See more source ↗

Implemented sage_test_harness::call_argument_types