tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

feat(parser): Phase 152-A - Grouped assignment expression (箱化モジュール化)

Browse Source 
Implement Stage-3 grouped assignment expression `(x = expr)` following
the 箱化モジュール化 (modular box) pattern established in Phase 133/134.

**Implementation**:
- AssignmentExprParser module (Rust: 183 lines)
  - src/parser/stage3/assignment_expr_parser.rs (+183 lines)
  - src/parser/stage3/mod.rs (+9 lines)
- AST node addition: GroupedAssignmentExpr
  - src/ast.rs (+7 lines)
  - src/ast/utils.rs (+9 lines)
- MIR lowering via 1-line delegation
  - src/mir/builder/exprs.rs (+5 lines)
  - src/mir/builder/vars.rs (+4 lines)
- Parser integration via 1-line delegation
  - src/parser/expr/primary.rs (+6 lines)
  - src/parser/mod.rs (+1 line)

**Test Results**: 3/3 PASS
- assignment_expr_simple.hako: RC 1 ✅
- assignment_expr_shortcircuit.hako: RC 1 ✅
- shortcircuit_and_phi_skip.hako: RC 1 ✅ (updated to use expression context)

**Stage-3 Gate**: No impact on Stage-2/legacy
- NYASH_FEATURES=stage3 required
- Pattern: '(' IDENT '=' expr ')'
- Value/type same as rhs, side effect assigns to lhs

**箱化モジュール化パターン**:
- Dedicated module for assignment expression parsing
- Clear responsibility separation
- 1-line delegation for integration
- Testability improvement
- Follows Phase 133/134-A/134-B pattern

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
nyash-codex
2025-12-04 13:32:58 +09:00
parent a7f5da658a
commit c70e76ff57
11 changed files with 240 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
apps/tests/assignment_expr_shortcircuit.hako Normal file
View File

@ -0,0 +1,12 @@
// Phase 152-A: Grouped assignment expression with shortcircuit
// Test: (x = expr) can be used in conditional expressions
static box Main {
main() {
local x = 0
if ((x = 1) > 0) and true {
return x // Expected: RC 1
}
return -1
}
}

11
apps/tests/assignment_expr_simple.hako Normal file
View File

@ -0,0 +1,11 @@
// Phase 152-A: Grouped assignment expression simple test
// Test: (x = expr) returns value and assigns to x
static box Main {
main() {
local x = 0
local y = (x = x + 1)
// x should be 1, y should be 1
return y // Expected: RC 1
}
}

3
apps/tests/shortcircuit_and_phi_skip.hako
View File

@ -1,7 +1,8 @@
static box Main {
main(args) {
local x = 0
((x = x + 1) < 0) && ((x = x + 1) < 0)
// Phase 152-A: Use grouped assignment in expression context
local result = ((x = x + 1) < 0) && ((x = x + 1) < 0)
// LHS が false → RHS は評価されず x は 1 のまま
return x
}

9
src/ast.rs
View File

@ -523,6 +523,15 @@ pub enum ASTNode {
span: Span,
},
/// Stage-3: 括弧付き代入式: (x = expr) - Phase 152-A
/// 値・型は右辺と同じ、副作用として左辺に代入
/// 使用例: local y = (x = x + 1), if (x = next()) != null { }
GroupedAssignmentExpr {
lhs: String, // 変数名
rhs: Box<ASTNode>, // 右辺式
span: Span,
},
/// メソッド呼び出し: object.method(arguments)
MethodCall {
object: Box<ASTNode>,

10
src/ast/utils.rs
View File

@ -52,6 +52,8 @@ impl ASTNode {
ASTNode::MapLiteral { .. } => "MapLiteral",
// Optional diagnostic-only wrapper
ASTNode::ScopeBox { .. } => "ScopeBox",
// Phase 152-A: Grouped assignment expression
ASTNode::GroupedAssignmentExpr { .. } => "GroupedAssignmentExpr",
}
}
@ -91,6 +93,8 @@ impl ASTNode {
ASTNode::ArrayLiteral { .. } => E,
ASTNode::MapLiteral { .. } => E,
ASTNode::AwaitExpression { .. } => E,
// Phase 152-A: Grouped assignment expression (expression with side effect)
ASTNode::GroupedAssignmentExpr { .. } => E,
// Statement nodes - 実行可能なアクション
ASTNode::Program { .. } => S,
@ -330,6 +334,10 @@ impl ASTNode {
format!("Index(target={:?}, index={:?})", target, index)
}
ASTNode::ScopeBox { .. } => "ScopeBox".to_string(),
// Phase 152-A: Grouped assignment expression
ASTNode::GroupedAssignmentExpr { lhs, .. } => {
format!("GroupedAssignmentExpr(lhs={})", lhs)
}
}
}
@ -380,6 +388,8 @@ impl ASTNode {
ASTNode::ArrayLiteral { span, .. } => *span,
ASTNode::MapLiteral { span, .. } => *span,
ASTNode::ScopeBox { span, .. } => *span,
// Phase 152-A: Grouped assignment expression
ASTNode::GroupedAssignmentExpr { span, .. } => *span,
}
}
}

7
src/mir/builder/exprs.rs
View File

@ -134,6 +134,13 @@ impl super::MirBuilder {
}
}
// Phase 152-A: Grouped assignment expression (x = expr)
// Stage-3 only. Value/type same as rhs, side effect assigns to lhs.
// Reuses existing build_assignment logic, returns the SSA ValueId.
ASTNode::GroupedAssignmentExpr { lhs, rhs, .. } => {
self.build_assignment(lhs.clone(), *rhs.clone())
}
ASTNode::Index { target, index, .. } => {
self.build_index_expression(*target.clone(), *index.clone())
}

4
src/mir/builder/vars.rs
View File

@ -24,6 +24,10 @@ pub(super) fn collect_free_vars(
collect_free_vars(target, used, locals);
collect_free_vars(value, used, locals);
}
// Phase 152-A: Grouped assignment expression
ASTNode::GroupedAssignmentExpr { rhs, .. } => {
collect_free_vars(rhs, used, locals);
}
ASTNode::BinaryOp { left, right, .. } => {
collect_free_vars(left, used, locals);
collect_free_vars(right, used, locals);

6
src/parser/expr/primary.rs
View File

@ -265,6 +265,12 @@ impl NyashParser {
}
}
TokenType::LPAREN => {
// Phase 152-A: Try grouped assignment first (Stage-3 only)
if let Some(assignment) = self.try_parse_grouped_assignment()? {
return Ok(assignment);
}
// Fallback: normal grouped expression
self.advance();
let expr = self.parse_expression()?;
self.consume(TokenType::RPAREN)?;

1
src/parser/mod.rs
View File

@ -27,6 +27,7 @@ mod expr;
mod expr_cursor; // TokenCursorを使用した式パーサー（実験的）
mod expressions;
mod items;
mod stage3; // Phase 152-A: Stage-3 parser extensions
mod statements; // Now uses modular structure in statements/
pub mod sugar; // Phase 12.7-B: desugar pass (basic)
pub mod sugar_gate; // thread-local gate for sugar parsing (tests/docs)

170
src/parser/stage3/assignment_expr_parser.rs Normal file
View File

@ -0,0 +1,170 @@
/*!
* Phase 152-A: Grouped Assignment Expression Parser (箱化モジュール化)
*
* Stage-3 構文: (x = expr) を expression として受け入れる
* 仕様:
* - `x = expr` は statement のまま（変更なし）
* - `(x = expr)` のみ expression として受け入れる
* - 値・型は右辺と同じ
*
* 責務:
* 1. Stage-3 gate 確認
* 2. `(` IDENT `=` expr `)` パターン検出
* 3. GroupedAssignmentExpr AST ノード生成
*/
use crate::ast::{ASTNode, Span};
use crate::parser::common::ParserUtils;
use crate::parser::{NyashParser, ParseError};
use crate::tokenizer::TokenType;
impl NyashParser {
/// Try to parse grouped assignment expression: (x = expr)
///
/// Returns Some(ASTNode) if pattern matches and Stage-3 is enabled,
/// None otherwise to allow normal grouped expression fallback.
///
/// This function is designed for 1-line delegation from primary.rs:
/// ```
/// if let Some(assignment) = self.try_parse_grouped_assignment()? {
/// return Ok(assignment);
/// }
/// ```
pub(crate) fn try_parse_grouped_assignment(&mut self) -> Result<Option<ASTNode>, ParseError> {
// Stage-3 gate check
if !crate::config::env::parser_stage3_enabled() {
return Ok(None);
}
// Look ahead pattern check: '(' IDENT '=' ...
if !self.is_grouped_assignment_pattern() {
return Ok(None);
}
// Parse: '(' IDENT '=' expr ')'
self.consume(TokenType::LPAREN)?;
let ident = match &self.current_token().token_type {
TokenType::IDENTIFIER(name) => {
let var_name = name.clone();
self.advance();
var_name
}
_ => {
let line = self.current_token().line;
return Err(ParseError::UnexpectedToken {
found: self.current_token().token_type.clone(),
expected: "identifier in grouped assignment".to_string(),
line,
});
}
};
self.consume(TokenType::ASSIGN)?;
let rhs = self.parse_expression()?;
self.consume(TokenType::RPAREN)?;
Ok(Some(ASTNode::GroupedAssignmentExpr {
lhs: ident,
rhs: Box::new(rhs),
span: Span::unknown(),
}))
}
/// Check if current token position matches grouped assignment pattern
///
/// Pattern: '(' IDENT '=' ...
fn is_grouped_assignment_pattern(&self) -> bool {
// Current token should be '('
if !self.match_token(&TokenType::LPAREN) {
return false;
}
// Next token should be IDENTIFIER
if self.current() + 1 >= self.tokens().len() {
return false;
}
if !matches!(
&self.tokens()[self.current() + 1].token_type,
TokenType::IDENTIFIER(_)
) {
return false;
}
// Token after that should be '='
if self.current() + 2 >= self.tokens().len() {
return false;
}
matches!(
&self.tokens()[self.current() + 2].token_type,
TokenType::ASSIGN
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tokenizer::Tokenizer;
#[test]
fn test_grouped_assignment_simple() {
std::env::set_var("NYASH_FEATURES", "stage3");
let input = "local y = (x = 42)";
let tokens = Tokenizer::tokenize(input).unwrap();
let mut parser = NyashParser::new(tokens);
// Skip 'local' and 'y' and '='
parser.advance(); // local
parser.advance(); // y
parser.advance(); // =
let result = parser.try_parse_grouped_assignment().unwrap();
assert!(result.is_some());
if let Some(ASTNode::GroupedAssignmentExpr { lhs, rhs, .. }) = result {
assert_eq!(lhs, "x");
// rhs should be Literal(42)
assert!(matches!(*rhs, ASTNode::Literal { .. }));
} else {
panic!("Expected GroupedAssignmentExpr");
}
}
#[test]
fn test_grouped_assignment_pattern_detection() {
std::env::set_var("NYASH_FEATURES", "stage3");
// Positive case: (x = expr)
let tokens = Tokenizer::tokenize("(x = 42)").unwrap();
let parser = NyashParser::new(tokens);
assert!(parser.is_grouped_assignment_pattern());
// Negative case: (42) - not an identifier
let tokens = Tokenizer::tokenize("(42)").unwrap();
let parser = NyashParser::new(tokens);
assert!(!parser.is_grouped_assignment_pattern());
// Negative case: x = 42 - no parenthesis
let tokens = Tokenizer::tokenize("x = 42").unwrap();
let parser = NyashParser::new(tokens);
assert!(!parser.is_grouped_assignment_pattern());
}
#[test]
fn test_stage3_gate_off() {
std::env::remove_var("NYASH_FEATURES");
std::env::remove_var("NYASH_PARSER_STAGE3");
std::env::remove_var("HAKO_PARSER_STAGE3");
let input = "(x = 42)";
let tokens = Tokenizer::tokenize(input).unwrap();
let mut parser = NyashParser::new(tokens);
let result = parser.try_parse_grouped_assignment().unwrap();
assert!(result.is_none()); // Should return None when Stage-3 is off
}
}

8
src/parser/stage3/mod.rs Normal file
View File

@ -0,0 +1,8 @@
/*!
* Stage-3 Parser Extensions
*
* Stage-3 構文の拡張機能群
* - 括弧付き代入式 (Phase 152-A)
*/
pub mod assignment_expr_parser;