meta.language.envelopes.receiver_calls

invokes self.method(); permits a call on the current semantic receiver. A matching method on a different receiver does not satisfy that permission.

Read in specification context · design/meta/language.md

Tests and review

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

Implemented sage_meta::same_operation_entry_is_recursion_and_needs_permission

crates/sage-meta/tests/runtime_contracts.rs · test:runtime_contracts

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.language.calls.declared)]
#[sage::test(meta.contracts.cache_invocations)]
#[sage::test(meta.language.envelopes.receiver_calls)]
fn same_operation_entry_is_recursion_and_needs_permission() {
    let leaf = r#"class Tree { """Tree.""" fn walk() -> u32 { """Walk.""" envelope {} } }"#;
    let mut denied = session(model(leaf), &["Tree::walk"]);
    let a = denied.enter("demo::Tree::walk", Some("tree:1"));
    let b = denied.enter("demo::Tree::walk", Some("tree:1"));
    denied.exit(b);
    denied.exit(a);
    assert_eq!(
        denied.finish().violations[0].kind,
        ViolationKind::UndeclaredCall
    );

    let recursive = leaf.replace("envelope {}", "envelope { invokes self.walk(); }");
    let mut allowed = session(model(&recursive), &["Tree::walk"]);
    let a = allowed.enter("demo::Tree::walk", Some("tree:1"));
    let b = allowed.enter("demo::Tree::walk", Some("tree:1"));
    allowed.exit(b);
    allowed.exit(a);
    let report = allowed.finish();
    report.assert_calls_conform();
    assert_eq!(report.coverage.checked_requests, 2);
    assert!(matches!(&report.trace[1], ContractEvent::Enter(frame) if frame.parent == Some(a)));
}
}

See more source ↗

Implemented sage_meta::self_permission_rejects_different_and_unknown_receivers

crates/sage-meta/tests/runtime_contracts.rs · test:runtime_contracts

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.contracts.observation_coverage)]
#[sage::test(meta.language.envelopes.receiver_calls)]
fn self_permission_rejects_different_and_unknown_receivers() {
    let model = model(
        r#"
        class Item { """Item."""
            fn run() -> u32 { """Run.""" envelope { invokes self.read(); } }
            query read() -> u32 { """Read.""" envelope {} }
        }
    "#,
    );
    for receiver in [Some("item:other"), None] {
        let mut checked = session(model.clone(), &["Item::run"]);
        let run = checked.enter("demo::Item::run", Some("item:1"));
        let read = checked.enter("demo::Item::read", receiver);
        checked.exit(read);
        checked.exit(run);
        let report = checked.finish();
        assert!(!report.calls_conform);
        if receiver.is_some() {
            assert_eq!(report.violations[0].kind, ViolationKind::ReceiverMismatch);
        } else {
            assert!(report.coverage.gaps[0].contains("receiver identity required"));
        }
    }
}
}

See more source ↗

Review: Accepted · Codex /root/anchor_199.

Reviewed the complete two-sentence claim, both ordinary implementation associations and both ordinary associated tests; no TODO/N/A entries or deferred prerequisites exist. Independently verified exact byte equality of current contracts.rs, validate.rs and runtime_contracts.rs against the supplied historical snapshots; reassessed the historical rationale against current captured inputs. resolve_contracts resolves self.method to the owning class method target set and marks its permission same_receiver. ContractSession checks the current active caller and matching target permissions: equal known semantic receiver identities satisfy the self permission, different identities produce ReceiverMismatch, and missing identities produce an observation gap, which finish includes in nonconformance. A separate unrestricted permission may authorize a call, but a self permission alone cannot authorize another receiver. same_operation_entry_is_recursion_and_needs_permission first asserts undeclared recursion fails, then declares self.walk and asserts conformance, two checked requests and the recursive parent relationship for equal receivers. self_permission_rejects_different_and_unknown_receivers asserts nonconformance and the appropriate mismatch or identity-gap evidence for an identically named target on another or unknown receiver. These assertions detect omission of the receiver restriction and rejection of valid same-receiver calls. Captured model/session setup helpers with review read; they parse the supplied model and construct actual ContractModel/ContractSession instances without hiding behavioral assertions. Source inspection supports both claim requirements. I executed review start/read and exact snapshot comparisons, and am recording this assessment; I did not run behavior tests or a workspace build. The 321 passing functional tests and successful root build are coordinator-reported baseline execution, not my execution. No edits needed.

Browse meta anchors

116 anchors

Anchor Implementation Tests

meta (116) 102 Implemented24 TODO 103 Implemented36 TODO

meta.anchors (22) 22 Implemented 21 Implemented12 TODO

anchor_pages Implemented ImplementedTODO

Every specification anchor has a stable page identifying the rule and showing its definition, context, implementation entries, and tests/evidence. The page includes Rust excerpts and access to surrounding source, and exposes each entry’s placeholder status and explanation. Multiple sites remain individually inspectable rather than being reduced to a single coverage badge.

Symposiun AGentic Environment (SAGE)

meta.language.envelopes.receiver_calls

Implementation

Tests and review