1232 lines
45 KiB
Rust
1232 lines
45 KiB
Rust
use super::*;
|
||
|
||
/// Phase 60: Ownership relay threading helpers for P2 (analysis + contract)
|
||
///
|
||
/// plan_to_p2_inputs remains Fail-Fast on relay_writes (legacy contract),
|
||
/// while plan_to_p2_inputs_with_relay accepts single-hop relay and promotes them
|
||
/// to carriers (dev-only).
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase60_ownership_p2_with_relay_conversion() {
|
||
use nyash_rust::mir::join_ir::ownership::{
|
||
plan_to_p2_inputs, plan_to_p2_inputs_with_relay, OwnershipAnalyzer,
|
||
};
|
||
use serde_json::json;
|
||
|
||
// Create a simple P2 fixture JSON (loop with i and sum)
|
||
let json = json!({
|
||
"functions": [{
|
||
"name": "main",
|
||
"params": [],
|
||
"body": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{"kind": "Local", "name": "sum", "init": {"kind": "Const", "value": 0}},
|
||
{"kind": "Local", "name": "i", "init": {"kind": "Const", "value": 0}},
|
||
{
|
||
"kind": "Loop",
|
||
"condition": {
|
||
"kind": "BinaryOp",
|
||
"op": "Lt",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 3}
|
||
},
|
||
"body": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{
|
||
"kind": "If",
|
||
"condition": {
|
||
"kind": "BinaryOp",
|
||
"op": "Ge",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 2}
|
||
},
|
||
"then": {"kind": "Break"}
|
||
},
|
||
{
|
||
"kind": "Assign",
|
||
"target": "sum",
|
||
"value": {
|
||
"kind": "BinaryOp",
|
||
"op": "Add",
|
||
"lhs": {"kind": "Var", "name": "sum"},
|
||
"rhs": {"kind": "Var", "name": "i"}
|
||
}
|
||
},
|
||
{
|
||
"kind": "Assign",
|
||
"target": "i",
|
||
"value": {
|
||
"kind": "BinaryOp",
|
||
"op": "Add",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 1}
|
||
}
|
||
}
|
||
]
|
||
}
|
||
}
|
||
]
|
||
}
|
||
}]
|
||
});
|
||
|
||
// Run ownership analyzer
|
||
let mut analyzer = OwnershipAnalyzer::new();
|
||
let plans = analyzer
|
||
.analyze_json(&json)
|
||
.expect("analysis should succeed");
|
||
|
||
// Find loop plan (the one that has relay writes to function-owned sum/i)
|
||
let loop_plan = plans
|
||
.iter()
|
||
.find(|p| !p.relay_writes.is_empty())
|
||
.expect("should have a loop plan with relay writes");
|
||
|
||
eprintln!(
|
||
"[phase58/test] Loop plan: relay_writes={:?}",
|
||
loop_plan.relay_writes
|
||
);
|
||
|
||
// Legacy Fail-Fast: relay_writes should be rejected
|
||
let result = plan_to_p2_inputs(loop_plan, "i");
|
||
assert!(
|
||
result.is_err(),
|
||
"Legacy contract: relay_writes should be rejected"
|
||
);
|
||
let err = result.unwrap_err();
|
||
assert!(
|
||
err.contains("relay_writes not yet supported"),
|
||
"Error should mention relay limitation, got: {}",
|
||
err
|
||
);
|
||
|
||
// Phase 60 dev-only: with_relay should accept and include relay vars as carriers
|
||
let inputs_with_relay =
|
||
plan_to_p2_inputs_with_relay(loop_plan, "i").expect("with_relay should accept");
|
||
assert!(
|
||
inputs_with_relay.carriers.iter().any(|c| c.name == "sum"),
|
||
"relay carrier sum should be promoted"
|
||
);
|
||
|
||
eprintln!(
|
||
"[phase60/test] with_relay carriers={:?}",
|
||
inputs_with_relay
|
||
.carriers
|
||
.iter()
|
||
.map(|c| &c.name)
|
||
.collect::<Vec<_>>()
|
||
);
|
||
|
||
// Also test the case where variables ARE owned by loop (future scenario)
|
||
// This would work once we support loop-local carriers
|
||
let loop_local_json = json!({
|
||
"functions": [{
|
||
"name": "main",
|
||
"params": [],
|
||
"body": {
|
||
"kind": "Loop",
|
||
"condition": {"kind": "Const", "value": true},
|
||
"body": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{"kind": "Local", "name": "i", "init": {"kind": "Const", "value": 0}},
|
||
{"kind": "Local", "name": "sum", "init": {"kind": "Const", "value": 0}},
|
||
{
|
||
"kind": "Assign",
|
||
"target": "sum",
|
||
"value": {
|
||
"kind": "BinaryOp",
|
||
"op": "Add",
|
||
"lhs": {"kind": "Var", "name": "sum"},
|
||
"rhs": {"kind": "Var", "name": "i"}
|
||
}
|
||
},
|
||
{
|
||
"kind": "Assign",
|
||
"target": "i",
|
||
"value": {
|
||
"kind": "BinaryOp",
|
||
"op": "Add",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 1}
|
||
}
|
||
},
|
||
{"kind": "Break"}
|
||
]
|
||
}
|
||
}
|
||
}]
|
||
});
|
||
|
||
let mut analyzer2 = OwnershipAnalyzer::new();
|
||
let plans2 = analyzer2
|
||
.analyze_json(&loop_local_json)
|
||
.expect("loop-local analysis should succeed");
|
||
|
||
// Find loop plan (variables owned by loop, not function)
|
||
let loop_plan2 = plans2
|
||
.iter()
|
||
.find(|p| !p.owned_vars.is_empty())
|
||
.expect("should have a loop plan with owned vars");
|
||
|
||
eprintln!(
|
||
"[phase58/test] Loop-local plan: owned_vars={:?}",
|
||
loop_plan2
|
||
.owned_vars
|
||
.iter()
|
||
.map(|v| &v.name)
|
||
.collect::<Vec<_>>()
|
||
);
|
||
|
||
// Convert to P2 inputs (should succeed - no relay)
|
||
let inputs = plan_to_p2_inputs(loop_plan2, "i").expect("should convert successfully");
|
||
|
||
eprintln!("[phase58/test] P2 inputs: {:?}", inputs);
|
||
|
||
// Verify: i is skipped (loop var), sum becomes carrier
|
||
assert_eq!(inputs.carriers.len(), 1, "Should have 1 carrier (sum)");
|
||
assert_eq!(inputs.carriers[0].name, "sum");
|
||
|
||
eprintln!("[phase60/test] Loop-local conversion verified");
|
||
}
|
||
|
||
/// Phase 60: P2 dev-only ownership relay route matches legacy Break lowering.
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase60_break_lowering_ownership_matches_legacy() {
|
||
use nyash_rust::mir::join_ir::frontend::ast_lowerer::lower_break_legacy_for_comparison;
|
||
use nyash_rust::mir::join_ir::frontend::ast_lowerer::AstToJoinIrLowerer;
|
||
|
||
let _ctx = normalized_dev_test_ctx();
|
||
|
||
let program_json: serde_json::Value = serde_json::from_str(include_str!(
|
||
"../../docs/private/roadmap2/phases/phase-34-joinir-frontend/fixtures/loop_frontend_break.program.json"
|
||
))
|
||
.expect("fixture json");
|
||
|
||
let mut lowerer_new = AstToJoinIrLowerer::new();
|
||
let structured_new = lowerer_new.lower_program_json(&program_json);
|
||
|
||
let mut lowerer_old = AstToJoinIrLowerer::new();
|
||
let structured_old = lower_break_legacy_for_comparison(&mut lowerer_old, &program_json);
|
||
|
||
let entry_new = structured_new.entry.expect("new entry");
|
||
let entry_old = structured_old.entry.expect("old entry");
|
||
let input = vec![JoinValue::Int(5)];
|
||
|
||
let out_old = run_joinir_vm_bridge(&structured_old, entry_old, &input, false);
|
||
let out_new = run_joinir_vm_bridge(&structured_new, entry_new, &input, false);
|
||
|
||
assert_eq!(
|
||
out_old, out_new,
|
||
"ownership relay dev route must match legacy output"
|
||
);
|
||
}
|
||
|
||
/// Phase 59: P3 with outer-owned carriers (relay case) should fail-fast
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase59_ownership_p3_relay_failfast() {
|
||
use nyash_rust::mir::join_ir::ownership::{plan_to_p3_inputs, OwnershipAnalyzer};
|
||
use serde_json::json;
|
||
|
||
// P3 where sum/count are defined OUTSIDE the loop -> relay
|
||
let json = json!({
|
||
"functions": [{
|
||
"name": "main",
|
||
"params": [],
|
||
"body": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{"kind": "Local", "name": "sum", "init": {"kind": "Const", "value": 0}},
|
||
{"kind": "Local", "name": "count", "init": {"kind": "Const", "value": 0}},
|
||
{"kind": "Local", "name": "i", "init": {"kind": "Const", "value": 0}},
|
||
{
|
||
"kind": "Loop",
|
||
"condition": {
|
||
"kind": "BinaryOp", "op": "Lt",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 10}
|
||
},
|
||
"body": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{
|
||
"kind": "If",
|
||
"condition": {
|
||
"kind": "BinaryOp", "op": "Gt",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 0}
|
||
},
|
||
"then": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{"kind": "Assign", "target": "sum", "value": {
|
||
"kind": "BinaryOp", "op": "Add",
|
||
"lhs": {"kind": "Var", "name": "sum"},
|
||
"rhs": {"kind": "Var", "name": "i"}
|
||
}},
|
||
{"kind": "Assign", "target": "count", "value": {
|
||
"kind": "BinaryOp", "op": "Add",
|
||
"lhs": {"kind": "Var", "name": "count"},
|
||
"rhs": {"kind": "Const", "value": 1}
|
||
}}
|
||
]
|
||
}
|
||
},
|
||
{"kind": "Assign", "target": "i", "value": {
|
||
"kind": "BinaryOp", "op": "Add",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 1}
|
||
}}
|
||
]
|
||
}
|
||
}
|
||
]
|
||
}
|
||
}]
|
||
});
|
||
|
||
let mut analyzer = OwnershipAnalyzer::new();
|
||
let plans = analyzer
|
||
.analyze_json(&json)
|
||
.expect("analysis should succeed");
|
||
|
||
// Find loop plan
|
||
let loop_plan = plans
|
||
.iter()
|
||
.find(|p| !p.relay_writes.is_empty())
|
||
.expect("loop should have relay_writes for sum/count");
|
||
|
||
// Verify relay_writes contains sum and count
|
||
assert!(loop_plan.relay_writes.iter().any(|r| r.name == "sum"));
|
||
assert!(loop_plan.relay_writes.iter().any(|r| r.name == "count"));
|
||
|
||
// plan_to_p3_inputs should fail
|
||
let result = plan_to_p3_inputs(loop_plan, "i");
|
||
assert!(result.is_err(), "Should fail-fast on relay_writes");
|
||
assert!(
|
||
result
|
||
.unwrap_err()
|
||
.contains("relay_writes not yet supported for P3"),
|
||
"Error should mention P3 relay limitation"
|
||
);
|
||
|
||
eprintln!("[phase59/test] P3 relay fail-fast verified");
|
||
}
|
||
|
||
/// Phase 59: P3 with loop-local carriers should succeed
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase59_ownership_p3_loop_local_success() {
|
||
use nyash_rust::mir::join_ir::ownership::{plan_to_p3_inputs, OwnershipAnalyzer};
|
||
use serde_json::json;
|
||
|
||
// P3 where sum/count are defined INSIDE the loop -> no relay
|
||
let json = json!({
|
||
"functions": [{
|
||
"name": "main",
|
||
"params": [],
|
||
"body": {
|
||
"kind": "Loop",
|
||
"condition": {"kind": "Const", "value": true},
|
||
"body": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{"kind": "Local", "name": "i", "init": {"kind": "Const", "value": 0}},
|
||
{"kind": "Local", "name": "sum", "init": {"kind": "Const", "value": 0}},
|
||
{"kind": "Local", "name": "count", "init": {"kind": "Const", "value": 0}},
|
||
{
|
||
"kind": "If",
|
||
"condition": {
|
||
"kind": "BinaryOp", "op": "Gt",
|
||
"lhs": {"kind": "Var", "name": "i"},
|
||
"rhs": {"kind": "Const", "value": 0}
|
||
},
|
||
"then": {
|
||
"kind": "Block",
|
||
"statements": [
|
||
{"kind": "Assign", "target": "sum", "value": {
|
||
"kind": "BinaryOp", "op": "Add",
|
||
"lhs": {"kind": "Var", "name": "sum"},
|
||
"rhs": {"kind": "Var", "name": "i"}
|
||
}},
|
||
{"kind": "Assign", "target": "count", "value": {
|
||
"kind": "BinaryOp", "op": "Add",
|
||
"lhs": {"kind": "Var", "name": "count"},
|
||
"rhs": {"kind": "Const", "value": 1}
|
||
}}
|
||
]
|
||
}
|
||
},
|
||
{"kind": "Break"}
|
||
]
|
||
}
|
||
}
|
||
}]
|
||
});
|
||
|
||
let mut analyzer = OwnershipAnalyzer::new();
|
||
let plans = analyzer
|
||
.analyze_json(&json)
|
||
.expect("analysis should succeed");
|
||
|
||
// Find loop plan with owned vars
|
||
let loop_plan = plans
|
||
.iter()
|
||
.find(|p| p.owned_vars.iter().any(|v| v.name == "sum"))
|
||
.expect("loop should own sum");
|
||
|
||
// No relay
|
||
assert!(
|
||
loop_plan.relay_writes.is_empty(),
|
||
"No relay for loop-local vars"
|
||
);
|
||
|
||
// plan_to_p3_inputs should succeed
|
||
let inputs = plan_to_p3_inputs(loop_plan, "i").expect("Should succeed");
|
||
|
||
eprintln!("[phase59/test] P3 inputs: {:?}", inputs);
|
||
|
||
// sum and count should be carriers
|
||
assert!(inputs.carriers.iter().any(|c| c.name == "sum"));
|
||
assert!(inputs.carriers.iter().any(|c| c.name == "count"));
|
||
assert_eq!(
|
||
inputs.carriers.len(),
|
||
2,
|
||
"Should have 2 carriers (sum and count)"
|
||
);
|
||
|
||
eprintln!("[phase59/test] P3 loop-local conversion verified: sum and count correctly extracted as carriers");
|
||
}
|
||
|
||
/// Phase 60: Program(JSON v0) fixture (selfhost_if_sum_p3) should produce relay_writes and convert with single-hop relay.
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase60_ownership_p3_program_json_fixture_with_relay() {
|
||
use nyash_rust::mir::join_ir::ownership::{plan_to_p3_inputs_with_relay, OwnershipAnalyzer};
|
||
|
||
let program_json: serde_json::Value = serde_json::from_str(include_str!(
|
||
"../../docs/private/roadmap2/phases/normalized_dev/fixtures/selfhost_if_sum_p3.program.json"
|
||
))
|
||
.expect("fixture json");
|
||
|
||
let mut analyzer = OwnershipAnalyzer::new();
|
||
let plans = analyzer
|
||
.analyze_json(&program_json)
|
||
.expect("Program(JSON v0) analysis should succeed");
|
||
|
||
let loop_plan = plans
|
||
.iter()
|
||
.find(|p| !p.relay_writes.is_empty())
|
||
.expect("expected a loop plan with relay_writes");
|
||
|
||
// i/sum/count are defined outside the loop but updated in the loop body -> relay_writes
|
||
assert!(loop_plan.relay_writes.iter().any(|r| r.name == "i"));
|
||
assert!(loop_plan.relay_writes.iter().any(|r| r.name == "sum"));
|
||
assert!(loop_plan.relay_writes.iter().any(|r| r.name == "count"));
|
||
|
||
let inputs = plan_to_p3_inputs_with_relay(loop_plan, "i").expect("with_relay should succeed");
|
||
|
||
let mut carriers: Vec<&str> = inputs.carriers.iter().map(|c| c.name.as_str()).collect();
|
||
carriers.sort();
|
||
assert_eq!(carriers, vec!["count", "sum"]);
|
||
|
||
// n is read-only in loop condition -> capture + condition_capture
|
||
assert!(inputs.captures.iter().any(|n| n == "n"));
|
||
assert!(inputs.condition_captures.iter().any(|n| n == "n"));
|
||
}
|
||
|
||
/// Phase 64: P3 production route with ownership analysis (dev-only integration test)
|
||
///
|
||
/// This test verifies that `analyze_loop()` API works for simple P3 loops and that
|
||
/// multi-hop relay is correctly rejected with Fail-Fast error.
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase64_p3_ownership_prod_integration() {
|
||
use nyash_rust::ast::{ASTNode, BinaryOperator, LiteralValue, Span};
|
||
use nyash_rust::mir::join_ir::ownership::analyze_loop;
|
||
|
||
// Helper: Create literal integer node
|
||
fn lit_i(i: i64) -> ASTNode {
|
||
ASTNode::Literal {
|
||
value: LiteralValue::Integer(i),
|
||
span: Span::unknown(),
|
||
}
|
||
}
|
||
|
||
// Helper: Create variable node
|
||
fn var(name: &str) -> ASTNode {
|
||
ASTNode::Variable {
|
||
name: name.to_string(),
|
||
span: Span::unknown(),
|
||
}
|
||
}
|
||
|
||
// Simple P3 loop: loop(i < 10) { local sum=0; local i=0; sum = sum + i; i = i + 1 }
|
||
let condition = ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Less,
|
||
left: Box::new(var("i")),
|
||
right: Box::new(lit_i(10)),
|
||
span: Span::unknown(),
|
||
};
|
||
|
||
let body = vec![
|
||
ASTNode::Local {
|
||
variables: vec!["sum".to_string()],
|
||
initial_values: vec![Some(Box::new(lit_i(0)))],
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Local {
|
||
variables: vec!["i".to_string()],
|
||
initial_values: vec![Some(Box::new(lit_i(0)))],
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Assignment {
|
||
target: Box::new(var("sum")),
|
||
value: Box::new(ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Add,
|
||
left: Box::new(var("sum")),
|
||
right: Box::new(var("i")),
|
||
span: Span::unknown(),
|
||
}),
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Assignment {
|
||
target: Box::new(var("i")),
|
||
value: Box::new(ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Add,
|
||
left: Box::new(var("i")),
|
||
right: Box::new(lit_i(1)),
|
||
span: Span::unknown(),
|
||
}),
|
||
span: Span::unknown(),
|
||
},
|
||
];
|
||
|
||
// No parent-defined variables (both sum and i are loop-local)
|
||
let parent_defined = vec![];
|
||
|
||
// Analyze the loop
|
||
let plan =
|
||
analyze_loop(&condition, &body, &parent_defined).expect("P3 analysis should succeed");
|
||
|
||
// Verify basic plan structure
|
||
assert!(
|
||
!plan.owned_vars.is_empty(),
|
||
"Should have owned vars (sum, i)"
|
||
);
|
||
|
||
// Find sum and i in owned_vars
|
||
let sum_var = plan
|
||
.owned_vars
|
||
.iter()
|
||
.find(|v| v.name == "sum")
|
||
.expect("sum should be owned");
|
||
let i_var = plan
|
||
.owned_vars
|
||
.iter()
|
||
.find(|v| v.name == "i")
|
||
.expect("i should be owned");
|
||
|
||
// Both should be written
|
||
assert!(sum_var.is_written, "sum should be written");
|
||
assert!(i_var.is_written, "i should be written");
|
||
|
||
// i is used in condition -> condition_only
|
||
assert!(i_var.is_condition_only, "i should be condition_only");
|
||
|
||
// sum is NOT used in condition
|
||
assert!(
|
||
!sum_var.is_condition_only,
|
||
"sum should NOT be condition_only"
|
||
);
|
||
|
||
// No relay writes (all variables are loop-local)
|
||
assert!(
|
||
plan.relay_writes.is_empty(),
|
||
"No relay writes for loop-local variables"
|
||
);
|
||
|
||
// Verify single-hop relay constraint: if relay_writes is non-empty, verify single-hop
|
||
for relay in &plan.relay_writes {
|
||
assert!(
|
||
relay.relay_path.len() <= 1,
|
||
"Multi-hop relay should be rejected (got relay_path.len = {})",
|
||
relay.relay_path.len()
|
||
);
|
||
}
|
||
|
||
eprintln!(
|
||
"[phase64/test] P3 ownership analysis succeeded: {} owned vars, {} relay writes",
|
||
plan.owned_vars.len(),
|
||
plan.relay_writes.len()
|
||
);
|
||
}
|
||
|
||
/// Phase 64: Multi-hop relay detection test
|
||
///
|
||
/// Verifies that `analyze_loop()` correctly identifies multi-hop relay patterns.
|
||
/// The actual rejection (Fail-Fast) happens in `check_ownership_plan_consistency()`,
|
||
/// not in `analyze_loop()` itself.
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase64_p3_multihop_relay_detection() {
|
||
use nyash_rust::ast::{ASTNode, BinaryOperator, LiteralValue, Span};
|
||
use nyash_rust::mir::join_ir::ownership::AstOwnershipAnalyzer;
|
||
|
||
// Helper functions
|
||
fn lit_i(i: i64) -> ASTNode {
|
||
ASTNode::Literal {
|
||
value: LiteralValue::Integer(i),
|
||
span: Span::unknown(),
|
||
}
|
||
}
|
||
|
||
fn var(name: &str) -> ASTNode {
|
||
ASTNode::Variable {
|
||
name: name.to_string(),
|
||
span: Span::unknown(),
|
||
}
|
||
}
|
||
|
||
// Function with nested loops:
|
||
// function test() {
|
||
// local sum = 0;
|
||
// local i = 0;
|
||
// loop(i < 5) {
|
||
// local j = 0;
|
||
// loop(j < 3) {
|
||
// sum = sum + 1; // Multi-hop relay: sum defined in function scope
|
||
// j = j + 1;
|
||
// }
|
||
// i = i + 1;
|
||
// }
|
||
// }
|
||
let inner_condition = ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Less,
|
||
left: Box::new(var("j")),
|
||
right: Box::new(lit_i(3)),
|
||
span: Span::unknown(),
|
||
};
|
||
|
||
let inner_body = vec![
|
||
ASTNode::Assignment {
|
||
target: Box::new(var("sum")),
|
||
value: Box::new(ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Add,
|
||
left: Box::new(var("sum")),
|
||
right: Box::new(lit_i(1)),
|
||
span: Span::unknown(),
|
||
}),
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Assignment {
|
||
target: Box::new(var("j")),
|
||
value: Box::new(ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Add,
|
||
left: Box::new(var("j")),
|
||
right: Box::new(lit_i(1)),
|
||
span: Span::unknown(),
|
||
}),
|
||
span: Span::unknown(),
|
||
},
|
||
];
|
||
|
||
let outer_condition = ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Less,
|
||
left: Box::new(var("i")),
|
||
right: Box::new(lit_i(5)),
|
||
span: Span::unknown(),
|
||
};
|
||
|
||
let outer_body = vec![
|
||
ASTNode::Local {
|
||
variables: vec!["j".to_string()],
|
||
initial_values: vec![Some(Box::new(lit_i(0)))],
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Loop {
|
||
condition: Box::new(inner_condition),
|
||
body: inner_body,
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Assignment {
|
||
target: Box::new(var("i")),
|
||
value: Box::new(ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Add,
|
||
left: Box::new(var("i")),
|
||
right: Box::new(lit_i(1)),
|
||
span: Span::unknown(),
|
||
}),
|
||
span: Span::unknown(),
|
||
},
|
||
];
|
||
|
||
let function_body = vec![
|
||
ASTNode::Local {
|
||
variables: vec!["sum".to_string()],
|
||
initial_values: vec![Some(Box::new(lit_i(0)))],
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Local {
|
||
variables: vec!["i".to_string()],
|
||
initial_values: vec![Some(Box::new(lit_i(0)))],
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Loop {
|
||
condition: Box::new(outer_condition),
|
||
body: outer_body,
|
||
span: Span::unknown(),
|
||
},
|
||
];
|
||
|
||
let function = ASTNode::FunctionDeclaration {
|
||
name: "test".to_string(),
|
||
params: vec![],
|
||
body: function_body,
|
||
is_static: false,
|
||
is_override: false,
|
||
span: Span::unknown(),
|
||
};
|
||
|
||
// Analyze the entire function to detect nested loop relays
|
||
let mut analyzer = AstOwnershipAnalyzer::new();
|
||
let plans = analyzer
|
||
.analyze_ast(&function)
|
||
.expect("Function analysis should succeed");
|
||
|
||
// Find the inner loop plan (should have multi-hop relay for 'sum')
|
||
let inner_loop_plan = plans
|
||
.iter()
|
||
.find(|p| {
|
||
// Inner loop should have relay write for 'sum' with relay_path.len() > 1
|
||
p.relay_writes
|
||
.iter()
|
||
.any(|r| r.name == "sum" && r.relay_path.len() > 1)
|
||
})
|
||
.expect("Expected inner loop plan with multi-hop relay for 'sum'");
|
||
|
||
let sum_relay = inner_loop_plan
|
||
.relay_writes
|
||
.iter()
|
||
.find(|r| r.name == "sum")
|
||
.expect("sum should be a relay write in inner loop");
|
||
|
||
// Verify multi-hop relay (relay_path should include both inner and outer loop scopes)
|
||
assert!(
|
||
sum_relay.relay_path.len() > 1,
|
||
"sum should have multi-hop relay (got relay_path.len = {})",
|
||
sum_relay.relay_path.len()
|
||
);
|
||
|
||
eprintln!(
|
||
"[phase64/test] Multi-hop relay detected: sum relay_path.len = {}",
|
||
sum_relay.relay_path.len()
|
||
);
|
||
eprintln!(
|
||
"[phase64/test] This pattern would be rejected by check_ownership_plan_consistency()"
|
||
);
|
||
}
|
||
|
||
/// Phase 70-A: Verify that multihop relay runtime unsupported error has standardized tag.
|
||
///
|
||
/// This test builds an OwnershipPlan with multihop relay and verifies that
|
||
/// `check_ownership_plan_consistency()` returns an error with the standard tag
|
||
/// `[ownership/relay:runtime_unsupported]`.
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase70a_multihop_relay_runtime_unsupported_tag() {
|
||
use nyash_rust::mir::join_ir::ownership::{
|
||
CapturedVar, OwnershipPlan, RelayVar, ScopeId, ScopeOwnedVar,
|
||
};
|
||
|
||
// Build a plan with multihop relay (relay_path.len() == 2)
|
||
let mut plan = OwnershipPlan::new(ScopeId(2)); // Inner loop scope
|
||
plan.owned_vars.push(ScopeOwnedVar {
|
||
name: "j".to_string(),
|
||
is_written: true,
|
||
is_condition_only: false,
|
||
});
|
||
plan.relay_writes.push(RelayVar {
|
||
name: "sum".to_string(),
|
||
owner_scope: ScopeId(0), // Function scope
|
||
relay_path: vec![ScopeId(2), ScopeId(1)], // 2 hops: inner → outer
|
||
});
|
||
plan.captures.push(CapturedVar {
|
||
name: "i".to_string(),
|
||
owner_scope: ScopeId(0),
|
||
});
|
||
|
||
// Call the plan layer function (Phase 66 accepts multihop)
|
||
// The runtime check (check_ownership_plan_consistency) is private in pattern3_with_if_phi.rs,
|
||
// so we test the plan layer acceptance here.
|
||
use nyash_rust::mir::join_ir::ownership::plan_to_p3_inputs_with_relay;
|
||
|
||
let result = plan_to_p3_inputs_with_relay(&plan, "j");
|
||
|
||
// Phase 66: plan_to_p3_inputs_with_relay NOW ACCEPTS multihop (relay_path.len() > 1)
|
||
// So this should PASS (not Err)
|
||
assert!(
|
||
result.is_ok(),
|
||
"Phase 66: plan_to_p3_inputs_with_relay should accept multihop relay"
|
||
);
|
||
|
||
// Verify the relay is in the output
|
||
let inputs = result.unwrap();
|
||
let relay = inputs
|
||
.carriers
|
||
.iter()
|
||
.find(|c| c.name == "sum")
|
||
.expect("sum should be in carriers (via relay conversion)");
|
||
eprintln!(
|
||
"[phase70a/test] Multihop relay accepted in plan layer: sum role={:?}",
|
||
relay.role
|
||
);
|
||
|
||
// The RUNTIME check (check_ownership_plan_consistency in pattern3_with_if_phi.rs)
|
||
// is what produces [ownership/relay:runtime_unsupported].
|
||
// That function is private, so we document that the tag exists and
|
||
// will be hit when P3 lowering encounters this plan at runtime.
|
||
eprintln!("[phase70a/test] Runtime would fail with [ownership/relay:runtime_unsupported] tag");
|
||
}
|
||
|
||
/// Phase 70-B: Test that simple passthrough multihop relay is accepted.
|
||
///
|
||
/// This test verifies the structural detection logic in OwnershipPlanValidator
|
||
/// correctly identifies supported multihop patterns (pure passthrough, no self-updates).
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase70b_multihop_relay_simple_passthrough_succeeds() {
|
||
use nyash_rust::mir::join_ir::ownership::{
|
||
OwnershipPlan, OwnershipPlanValidator, RelayVar, ScopeId, ScopeOwnedVar,
|
||
};
|
||
|
||
// Build a plan for innermost loop (L3) with multihop relay
|
||
// L3 writes to 'counter' owned by L1, relayed through L2
|
||
let mut plan_l3 = OwnershipPlan::new(ScopeId(3)); // Inner loop scope
|
||
plan_l3.owned_vars.push(ScopeOwnedVar {
|
||
name: "i".to_string(), // loop variable
|
||
is_written: true,
|
||
is_condition_only: true,
|
||
});
|
||
plan_l3.relay_writes.push(RelayVar {
|
||
name: "counter".to_string(),
|
||
owner_scope: ScopeId(1), // L1 owns counter
|
||
relay_path: vec![ScopeId(3), ScopeId(2)], // 2 hops: L3 → L2 → L1
|
||
});
|
||
// No owned_vars for 'counter' - pure passthrough from L3's perspective
|
||
|
||
// Phase 70-B: This should be accepted (passthrough pattern)
|
||
let result = OwnershipPlanValidator::validate_relay_support(&plan_l3);
|
||
assert!(
|
||
result.is_ok(),
|
||
"Phase 70-B: Simple passthrough multihop should be accepted, got: {:?}",
|
||
result
|
||
);
|
||
|
||
eprintln!("[phase70b/test] Simple passthrough multihop relay accepted (3-layer loop)");
|
||
}
|
||
|
||
/// Phase 70-B: Test that unsupported multihop patterns are still rejected.
|
||
///
|
||
/// This test verifies that complex patterns (e.g., self-conflict where a scope
|
||
/// both owns and relays the same variable) are still rejected with the standard tag.
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase70b_multihop_relay_self_conflict_rejected() {
|
||
use nyash_rust::mir::join_ir::ownership::{
|
||
OwnershipPlan, OwnershipPlanValidator, RelayVar, ScopeId, ScopeOwnedVar,
|
||
};
|
||
|
||
// Build a plan where L3 both owns and relays 'counter' (conflict)
|
||
// L3 → L2 → L1 (multihop with self-conflict at L3)
|
||
let mut plan_l3 = OwnershipPlan::new(ScopeId(3)); // Inner loop scope
|
||
plan_l3.owned_vars.push(ScopeOwnedVar {
|
||
name: "counter".to_string(), // L3 owns counter
|
||
is_written: true,
|
||
is_condition_only: false,
|
||
});
|
||
plan_l3.relay_writes.push(RelayVar {
|
||
name: "counter".to_string(), // L3 also relays counter (conflict)
|
||
owner_scope: ScopeId(1),
|
||
relay_path: vec![ScopeId(3), ScopeId(2)], // L3 → L2 → L1 (multihop)
|
||
});
|
||
|
||
// Phase 70-B: This should be rejected (self-conflict)
|
||
let result = OwnershipPlanValidator::validate_relay_support(&plan_l3);
|
||
assert!(
|
||
result.is_err(),
|
||
"Phase 70-B: Self-conflict multihop should be rejected"
|
||
);
|
||
|
||
let err = result.unwrap_err();
|
||
assert!(
|
||
err.contains("[ownership/relay:runtime_unsupported]"),
|
||
"Error should contain standard tag: {}",
|
||
err
|
||
);
|
||
|
||
eprintln!("[phase70b/test] Self-conflict multihop relay correctly rejected");
|
||
}
|
||
|
||
/// Phase 70-C: Merge Relay (multiple inner loops → same owner)
|
||
///
|
||
/// This test verifies that OwnershipAnalyzer correctly detects the "merge relay"
|
||
/// pattern where multiple inner loops update the same owner variable.
|
||
///
|
||
/// Structure:
|
||
/// ```text
|
||
/// loop L1 {
|
||
/// local total = 0 // owned by L1
|
||
/// loop L2_A {
|
||
/// total++ // L2_A → L1 relay
|
||
/// }
|
||
/// loop L2_B {
|
||
/// total += 10 // L2_B → L1 relay
|
||
/// }
|
||
/// }
|
||
/// // L1 exit: merge both L2_A and L2_B's updates to 'total'
|
||
/// ```
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase70c_merge_relay_multiple_inner_loops_detected() {
|
||
use nyash_rust::ast::{ASTNode, BinaryOperator, LiteralValue, Span};
|
||
use nyash_rust::mir::join_ir::ownership::AstOwnershipAnalyzer;
|
||
|
||
// Build AST: loop L1 { local total=0; loop L2_A { total++ } loop L2_B { total+=10 } }
|
||
fn var(name: &str) -> ASTNode {
|
||
ASTNode::Variable {
|
||
name: name.to_string(),
|
||
span: Span::unknown(),
|
||
}
|
||
}
|
||
fn lit_i(i: i64) -> ASTNode {
|
||
ASTNode::Literal {
|
||
value: LiteralValue::Integer(i),
|
||
span: Span::unknown(),
|
||
}
|
||
}
|
||
fn lit_true() -> ASTNode {
|
||
ASTNode::Literal {
|
||
value: LiteralValue::Bool(true),
|
||
span: Span::unknown(),
|
||
}
|
||
}
|
||
|
||
let ast = ASTNode::FunctionDeclaration {
|
||
name: "test_merge_relay".to_string(),
|
||
params: vec![],
|
||
body: vec![
|
||
// L1: outer loop
|
||
ASTNode::Loop {
|
||
condition: Box::new(lit_true()),
|
||
body: vec![
|
||
// local total = 0 (L1 owns)
|
||
ASTNode::Local {
|
||
variables: vec!["total".to_string()],
|
||
initial_values: vec![Some(Box::new(lit_i(0)))],
|
||
span: Span::unknown(),
|
||
},
|
||
// L2_A: first inner loop (total++)
|
||
ASTNode::Loop {
|
||
condition: Box::new(lit_true()),
|
||
body: vec![
|
||
ASTNode::Assignment {
|
||
target: Box::new(var("total")),
|
||
value: Box::new(ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Add,
|
||
left: Box::new(var("total")),
|
||
right: Box::new(lit_i(1)),
|
||
span: Span::unknown(),
|
||
}),
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Break {
|
||
span: Span::unknown(),
|
||
},
|
||
],
|
||
span: Span::unknown(),
|
||
},
|
||
// L2_B: second inner loop (total += 10)
|
||
ASTNode::Loop {
|
||
condition: Box::new(lit_true()),
|
||
body: vec![
|
||
ASTNode::Assignment {
|
||
target: Box::new(var("total")),
|
||
value: Box::new(ASTNode::BinaryOp {
|
||
operator: BinaryOperator::Add,
|
||
left: Box::new(var("total")),
|
||
right: Box::new(lit_i(10)),
|
||
span: Span::unknown(),
|
||
}),
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Break {
|
||
span: Span::unknown(),
|
||
},
|
||
],
|
||
span: Span::unknown(),
|
||
},
|
||
ASTNode::Break {
|
||
span: Span::unknown(),
|
||
},
|
||
],
|
||
span: Span::unknown(),
|
||
},
|
||
],
|
||
is_static: false,
|
||
is_override: false,
|
||
span: Span::unknown(),
|
||
};
|
||
|
||
let mut analyzer = AstOwnershipAnalyzer::new();
|
||
let plans = analyzer.analyze_ast(&ast).expect("analysis should succeed");
|
||
|
||
// Find L1 (owner of 'total')
|
||
let l1_plan = plans
|
||
.iter()
|
||
.find(|p| p.owned_vars.iter().any(|v| v.name == "total"))
|
||
.expect("expected L1 plan with owned total");
|
||
let l1_scope_id = l1_plan.scope_id;
|
||
|
||
// Find L2_A and L2_B (both relay 'total' to L1)
|
||
let relay_plans: Vec<_> = plans
|
||
.iter()
|
||
.filter(|p| p.relay_writes.iter().any(|r| r.name == "total") && p.scope_id != l1_scope_id)
|
||
.collect();
|
||
|
||
// Verify: two inner loops relay to the same owner
|
||
assert_eq!(
|
||
relay_plans.len(),
|
||
2,
|
||
"Phase 70-C: Expected 2 inner loops relaying 'total' to L1, got {}",
|
||
relay_plans.len()
|
||
);
|
||
|
||
for (idx, plan) in relay_plans.iter().enumerate() {
|
||
let relay = plan
|
||
.relay_writes
|
||
.iter()
|
||
.find(|r| r.name == "total")
|
||
.expect("expected 'total' in relay_writes");
|
||
|
||
// Verify: both relay to the same owner (L1)
|
||
assert_eq!(
|
||
relay.owner_scope, l1_scope_id,
|
||
"Phase 70-C: relay {} should have owner_scope = L1",
|
||
idx
|
||
);
|
||
|
||
// Verify: single-hop relay (L2 → L1)
|
||
assert_eq!(
|
||
relay.relay_path.len(),
|
||
1,
|
||
"Phase 70-C: relay {} should have single-hop path",
|
||
idx
|
||
);
|
||
|
||
// Verify: relay_path[0] is this scope (L2_A or L2_B)
|
||
assert_eq!(
|
||
relay.relay_path[0], plan.scope_id,
|
||
"Phase 70-C: relay {} relay_path[0] must be this scope",
|
||
idx
|
||
);
|
||
}
|
||
|
||
// Verify: L1 owned_vars contains 'total' and is_written=true
|
||
let total_var = l1_plan
|
||
.owned_vars
|
||
.iter()
|
||
.find(|v| v.name == "total")
|
||
.expect("expected 'total' in L1 owned_vars");
|
||
assert!(
|
||
total_var.is_written,
|
||
"Phase 70-C: L1's 'total' should be is_written=true"
|
||
);
|
||
|
||
eprintln!("[phase70c/test] Merge relay pattern detected: 2 inner loops → same owner variable");
|
||
}
|
||
|
||
/// Phase 70-C: Merge Relay validation acceptance
|
||
///
|
||
/// This test verifies that OwnershipPlanValidator ACCEPTS merge relay patterns
|
||
/// (multiple inner loops → same owner) because they are PERMITTED with owner merge.
|
||
#[test]
|
||
#[cfg(feature = "normalized_dev")]
|
||
fn test_phase70c_merge_relay_same_owner_accepted() {
|
||
use nyash_rust::mir::join_ir::ownership::{
|
||
OwnershipPlan, OwnershipPlanValidator, RelayVar, ScopeId,
|
||
};
|
||
|
||
// Build two plans for L2_A and L2_B, both relaying to L1
|
||
// L2_A plan: relay 'total' to L1
|
||
let mut plan_l2a = OwnershipPlan::new(ScopeId(2));
|
||
plan_l2a.relay_writes.push(RelayVar {
|
||
name: "total".to_string(),
|
||
owner_scope: ScopeId(1), // L1 owns total
|
||
relay_path: vec![ScopeId(2)], // Single hop: L2_A → L1
|
||
});
|
||
|
||
// L2_B plan: relay 'total' to L1
|
||
let mut plan_l2b = OwnershipPlan::new(ScopeId(3));
|
||
plan_l2b.relay_writes.push(RelayVar {
|
||
name: "total".to_string(),
|
||
owner_scope: ScopeId(1), // L1 owns total (same owner)
|
||
relay_path: vec![ScopeId(3)], // Single hop: L2_B → L1
|
||
});
|
||
|
||
// Phase 70-C: Both should be accepted (single-hop relay to same owner)
|
||
let result_a = OwnershipPlanValidator::validate_relay_support(&plan_l2a);
|
||
assert!(
|
||
result_a.is_ok(),
|
||
"Phase 70-C: L2_A relay to L1 should be accepted, got: {:?}",
|
||
result_a
|
||
);
|
||
|
||
let result_b = OwnershipPlanValidator::validate_relay_support(&plan_l2b);
|
||
assert!(
|
||
result_b.is_ok(),
|
||
"Phase 70-C: L2_B relay to L1 should be accepted, got: {:?}",
|
||
result_b
|
||
);
|
||
|
||
eprintln!("[phase70c/test] Merge relay validation accepted: multiple inner loops → same owner");
|
||
}
|
||
|
||
/// Phase 80-D (P3): Test Pattern3 BindingId lookup works
|
||
///
|
||
/// Verifies that Pattern3 (if-sum) BindingId registration is operational.
|
||
/// For manual fallback detection, run with: NYASH_JOINIR_DEBUG=1
|
||
/// Expected logs: [phase80/p3] Registered ... + [binding_pilot/hit]
|
||
/// No [binding_pilot/fallback] should appear.
|
||
#[test]
|
||
fn test_phase80_p3_bindingid_lookup_works() {
|
||
let module = build_pattern3_if_sum_min_structured_for_normalized_dev();
|
||
|
||
// Basic test: Pattern3 should compile and run with BindingId registration
|
||
assert_eq!(module.functions.len(), 3, "P3 should have 3 functions");
|
||
|
||
let entry = module.entry.expect("P3 should have entry function");
|
||
assert_eq!(entry.0, 0, "Entry should be function 0");
|
||
|
||
// The fact that this compiles and runs means BindingId registration didn't break anything
|
||
// Manual verification: NYASH_JOINIR_DEBUG=1 cargo test test_phase80_p3_bindingid_lookup_works
|
||
// Should show [phase80/p3] logs and [binding_pilot/hit], NO [binding_pilot/fallback]
|
||
}
|
||
|
||
/// Phase 80-D (P3): Test Pattern4 BindingId lookup works
|
||
///
|
||
/// Verifies that Pattern4 (continue/Trim) BindingId registration is operational.
|
||
/// For manual fallback detection, run with: NYASH_JOINIR_DEBUG=1
|
||
/// Expected logs: [phase80/p4] Registered ... + [binding_pilot/hit]
|
||
/// No [binding_pilot/fallback] should appear.
|
||
#[test]
|
||
fn test_phase80_p4_bindingid_lookup_works() {
|
||
let module = build_pattern4_continue_min_structured_for_normalized_dev();
|
||
|
||
// Basic test: Pattern4 should compile and run with BindingId registration
|
||
assert_eq!(module.functions.len(), 3, "P4 should have 3 functions");
|
||
|
||
let entry = module.entry.expect("P4 should have entry function");
|
||
assert_eq!(entry.0, 0, "Entry should be function 0");
|
||
|
||
// The fact that this compiles and runs means BindingId registration didn't break anything
|
||
// Manual verification: NYASH_JOINIR_DEBUG=1 cargo test test_phase80_p4_bindingid_lookup_works
|
||
// Should show [phase80/p4] logs and [binding_pilot/hit], NO [binding_pilot/fallback]
|
||
}
|
||
|
||
// Phase 79 の "BindingId lookup の E2E（subprocess）" は、Pattern2（DigitPos/Trim）の安定化と一緒に
|
||
// Phase 80-D 以降で復活させる（このファイルは Normalized JoinIR の SSOT テストに集中させる）。
|
||
|
||
// ========== Phase 81: Pattern2 ExitLine Contract Verification ==========
|
||
|
||
/// Phase 81-B: DigitPos pattern ExitLine contract verification
|
||
///
|
||
/// Tests that promoted `is_digit_pos` carrier (ConditionOnly) is correctly
|
||
/// excluded from Exit PHI while LoopState carriers (result, i) are included.
|
||
#[test]
|
||
fn test_phase81_digitpos_exitline_contract() {
|
||
// Use existing JsonParser _atoi fixture (DigitPos pattern with indexOf)
|
||
let module = build_jsonparser_atoi_structured_for_normalized_dev();
|
||
|
||
// Verify compilation succeeds (ExitLine reconnection works)
|
||
assert!(
|
||
!module.functions.is_empty(),
|
||
"DigitPos pattern should compile successfully"
|
||
);
|
||
|
||
// Verify module structure
|
||
assert_eq!(
|
||
module.functions.len(),
|
||
3,
|
||
"DigitPos pattern should have 3 functions (k_entry, k_loop, k_body)"
|
||
);
|
||
|
||
// Verify entry function exists
|
||
let entry = module
|
||
.entry
|
||
.expect("DigitPos pattern should have entry function");
|
||
|
||
// Execute to verify correctness (DigitPos: "123" → 123)
|
||
let result = run_joinir_vm_bridge_structured_only(
|
||
&module,
|
||
entry,
|
||
&[JoinValue::Str("123".to_string()), JoinValue::Int(3)],
|
||
);
|
||
|
||
assert_eq!(
|
||
result,
|
||
JoinValue::Int(123),
|
||
"DigitPos pattern should parse '123' correctly"
|
||
);
|
||
|
||
// Manual verification: Check that is_digit_pos is NOT in exit_bindings
|
||
// NYASH_JOINIR_DEBUG=1 cargo test test_phase81_digitpos_exitline_contract -- --nocapture 2>&1 | grep exit-line
|
||
// Should show: [joinir/exit-line] skip ConditionOnly carrier 'is_digit_pos'
|
||
}
|
||
|
||
/// Phase 81-B: Trim pattern ExitLine contract verification
|
||
///
|
||
/// Tests that promoted `is_ch_match` carrier (ConditionOnly) is correctly
|
||
/// excluded from Exit PHI while LoopState carriers (i) are included.
|
||
#[test]
|
||
fn test_phase81_trim_exitline_contract() {
|
||
// Use existing JsonParser skip_ws fixture (Trim pattern with whitespace check)
|
||
let module = build_jsonparser_skip_ws_structured_for_normalized_dev();
|
||
|
||
// Verify compilation succeeds (ExitLine reconnection works)
|
||
assert!(
|
||
!module.functions.is_empty(),
|
||
"Trim pattern should compile successfully"
|
||
);
|
||
|
||
// Verify module structure
|
||
assert!(
|
||
module.functions.len() >= 3,
|
||
"Trim pattern should have at least 3 functions"
|
||
);
|
||
|
||
// Verify entry function exists
|
||
let entry = module
|
||
.entry
|
||
.expect("Trim pattern should have entry function");
|
||
|
||
// Execute to verify correctness (skip_ws fixture)
|
||
// The skip_ws fixture takes a single int parameter (test size)
|
||
let result = run_joinir_vm_bridge_structured_only(&module, entry, &[JoinValue::Int(5)]);
|
||
|
||
// skip_ws fixture returns the input value (identity function for testing)
|
||
assert_eq!(
|
||
result,
|
||
JoinValue::Int(5),
|
||
"Trim pattern fixture should return input value"
|
||
);
|
||
|
||
// Manual verification: Check that is_ch_match is NOT in exit_bindings
|
||
// NYASH_JOINIR_DEBUG=1 cargo test test_phase81_trim_exitline_contract -- --nocapture 2>&1 | grep exit-line
|
||
// Should show: [joinir/exit-line] skip ConditionOnly carrier 'is_ch_match'
|
||
}
|