feat(joinir): Phase 64 - Ownership P3 production integration (dev-only)
P3(if-sum) 本番ルートに OwnershipPlan 解析を接続（analysis-only）。 Key changes: - ast_analyzer.rs: Added analyze_loop() helper - Loop-specific analysis API for production integration - build_plan_for_scope() helper for single-scope extraction - pattern3_with_if_phi.rs: P3 production integration - OwnershipPlan analysis after ConditionEnv building - check_ownership_plan_consistency() for validation - Feature-gated #[cfg(feature = "normalized_dev")] Consistency checks: - Fail-Fast: Multi-hop relay (relay_path.len() > 1) - Warn-only: Carrier set mismatch (order SSOT deferred) - Warn-only: Condition captures (some patterns have extras) Tests: 49/49 PASS (2 new Phase 64 tests) - test_phase64_p3_ownership_prod_integration - test_phase64_p3_multihop_relay_detection - Zero regressions Design: Analysis-only, no behavior change - Integration point: After ConditionEnv, before JoinIR lowering - Dev-only validation for future SSOT migration Next: Phase 65+ - Carrier order SSOT, owner-based init 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
nyash-codex
@ -1520,3 +1520,293 @@ fn test_phase60_ownership_p3_program_json_fixture_with_relay() {
|
||||
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()");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user