feat: Implement for-in loop with coroutine-based iteration protocol and object prototype methods.

Author: zuisong

Cargo.lock

@@ -0,0 +1,52 @@
+let io = import "stdlib/io"
+
+# 1. Test condition-based loop (Go-style while)
+let i = 0
+for i < 5 {
+    io.println("for i < 5: " + i)
+    i = i + 1
+}
+
+# 2. Test infinite loop with break
+let k = 0
+for {
+    if k >= 3 {
+        break
+    }
+    io.println("infinite for k: " + k)
+    k = k + 1
+}
+
+io.println("--- Array.iter() (Values only) ---")
+let arr = [10, 20, 30]
+for x in arr {
+    io.println("arr x: " + x)
+}
+
+io.println("--- Array.entries() (Key-Value pairs) ---")
+for entry in arr:entries() {
+    io.println("index: " + entry.key + ", value: " + entry.value)
+}
+
+io.println("--- Object.iter() (Values only) ---")
+let obj = ${ a: 1, b: 2 }
+for v in obj {
+    io.println("obj v: " + v)
+}
+
+io.println("--- Object.entries() (Key-Value pairs) ---")
+for entry in obj:entries() {
+    io.println("entry key: " + entry.key + ", value: " + entry.value)
+}
+
+io.println("--- Object.keys() ---")
+let keys = obj:keys()
+for k in keys {
+    io.println("key: " + k)
+}
+
+io.println("--- String.iter() ---")
+let s = "ABC"
+for char in s {
+    io.println("char: " + char)
+}

demo_codes/test_loops.ch

@@ -22,11 +22,12 @@ CATCH = @{ "catch" ~ !(ASCII_ALPHANUMERIC | "_") }
 FINALLY = @{ "finally" ~ !(ASCII_ALPHANUMERIC | "_") }
 THROW = @{ "throw" ~ !(ASCII_ALPHANUMERIC | "_") }
 IMPORT = @{ "import" ~ !(ASCII_ALPHANUMERIC | "_") }
+IN = @{ "in" ~ !(ASCII_ALPHANUMERIC | "_") }
 // NULL removed
 
 // 标识符 (不能是关键字)
 identifier = @{ !keyword ~ (ASCII_ALPHA | "_") ~ (ASCII_ALPHANUMERIC | "_")* }
-keyword = { LET | FOR | DEF | RETURN | IF | ELSE | TRUE | FALSE | BREAK | CONTINUE | TRY | CATCH | FINALLY | THROW | IMPORT }
+keyword = { LET | FOR | DEF | RETURN | IF | ELSE | TRUE | FALSE | BREAK | CONTINUE | TRY | CATCH | FINALLY | THROW | IMPORT | IN }
 
 // 字面量
 integer = @{ "-"? ~ ASCII_DIGIT+ }
@@ -103,7 +104,6 @@ statement = {
     continue_stmt |
     try_catch |
     throw_stmt |
-    throw_stmt |
     assignment |
     expression
 }
@@ -112,7 +112,8 @@ declaration = { LET ~ identifier ~ assign ~ NEWLINE* ~ expression }
 assignment_target = { identifier ~ postfix* }
 assignment = { assignment_target ~ assign ~ NEWLINE* ~ expression }
 
-for_loop = { FOR ~ NEWLINE* ~ expression ~ block }
+for_loop = { FOR ~ NEWLINE* (for_in_header | expression)? ~ block }
+for_in_header = { identifier ~ IN ~ expression }
 function_def = { DEF ~ identifier? ~ "(" ~ NEWLINE* ~ parameters? ~ NEWLINE* ~ ")" ~ block }
 return_stmt = { RETURN ~ NEWLINE* ~ expression }
 break_stmt = { BREAK }

src/chen.pest

@@ -380,6 +380,7 @@ impl<'a> Compiler<'a> {
                 self.emit(Instruction::Pop, loc);
             }
             Statement::Loop(e) => self.compile_loop(e),
+            Statement::ForIn(e) => self.compile_for_in(e),
             Statement::Assign(e) => self.compile_assign(e),
             Statement::Break(loc) => {
                 let end_label = self
@@ -858,6 +859,130 @@ impl<'a> Compiler<'a> {
         );
     }
 
+    fn compile_for_in(&mut self, for_in: ForInLoop) {
+        let loc = for_in.loc;
+        let unique_id = self.unique_id();
+        let loop_start = format!("for_in_start_{}", unique_id);
+        let loop_end = format!("for_in_end_{}", unique_id);
+        let iter_var = format!("@iter_{}", unique_id);
+
+        self.begin_scope();
+
+        // 1. Compile iterable, call :iter() on it, and store it in a hidden local variable
+        self.compile_expression(for_in.iterable);
+        self.emit(Instruction::GetMethod("iter".to_string()), loc); // [iterable, iter_fn, iterable]
+        self.emit(Instruction::CallStack(1), loc); // [coroutine]
+        let iter_loc = self.define_variable(iter_var);
+        match iter_loc {
+            VarLocation::Local(offset) => {
+                self.emit(Instruction::MovePlusFP(offset as usize), loc);
+            }
+            _ => unreachable!("Hidden iterator variable must be local"),
+        }
+
+        // loop_start label
+        self.program.syms.insert(
+            loop_start.clone(),
+            Symbol {
+                location: self.program.instructions.len() as i32,
+                narguments: 0,
+                nlocals: 0,
+                upvalues: Vec::new(),
+            },
+        );
+
+        // 2. Check status: coroutine.status(iterable)
+        self.emit(Instruction::Load("coroutine".to_string()), loc); // [coroutine]
+        self.emit(Instruction::GetField("status".to_string()), loc); // [status_fn]
+        match iter_loc {
+            VarLocation::Local(offset) => {
+                self.emit(Instruction::DupPlusFP(offset), loc); // [status_fn, iterable]
+            }
+            _ => unreachable!(),
+        }
+        self.emit(Instruction::CallStack(1), loc); // [status_val]
+        self.emit(Instruction::Push(crate::value::Value::string("dead".to_string())), loc);
+        self.emit(Instruction::Equal, loc);
+        self.emit(Instruction::JumpIfTrue(loop_end.clone()), loc);
+
+        self.emit(Instruction::Load("coroutine".to_string()), loc); // [resume_fn, iterable, coroutine]
+        self.emit(Instruction::GetField("resume".to_string()), loc); // [resume_fn, iterable, resume_fn]
+        match iter_loc {
+            VarLocation::Local(offset) => {
+                self.emit(Instruction::DupPlusFP(offset), loc); // [resume_fn, iterable, resume_fn, iterable]
+            }
+            _ => unreachable!(),
+        }
+        self.emit(Instruction::CallStack(1), loc); // [resume_fn, iterable, yielded_val]
+
+        // 3.5 Check status again after resume - if it just died, the returned value is the final result, not an iteration item.
+        self.emit(Instruction::Load("coroutine".to_string()), loc); // [resume_fn, iterable, yielded_val, coroutine]
+        self.emit(Instruction::GetField("status".to_string()), loc); // [resume_fn, iterable, yielded_val, status_fn]
+        match iter_loc {
+            VarLocation::Local(offset) => {
+                self.emit(Instruction::DupPlusFP(offset), loc); // [..., status_fn, iterable]
+            }
+            _ => unreachable!(),
+        }
+        self.emit(Instruction::CallStack(1), loc); // [resume_fn, iterable, yielded_val, status_val]
+        self.emit(Instruction::Push(crate::value::Value::string("dead".to_string())), loc);
+        self.emit(Instruction::Equal, loc);
+        let continue_label = format!("for_in_continue_{}", unique_id);
+        self.emit(Instruction::JumpIfFalse(continue_label.clone()), loc);
+        self.emit(Instruction::Pop, loc); // Pop yielded_val since coroutine is dead
+        self.emit(Instruction::Jump(loop_end.clone()), loc);
+
+        self.program.syms.insert(
+            continue_label.clone(),
+            Symbol {
+                location: self.program.instructions.len() as i32,
+                narguments: 0,
+                nlocals: 0,
+                upvalues: Vec::new(),
+            },
+        );
+
+        // 4. Define loop variable and assign yielded value
+        self.begin_scope();
+        let var_loc = self.define_variable(for_in.var);
+        match var_loc {
+            VarLocation::Local(offset) => {
+                self.emit(Instruction::MovePlusFP(offset as usize), loc);
+            }
+            VarLocation::Global(name) => {
+                self.emit(Instruction::Store(name), loc);
+            }
+            VarLocation::Upvalue(_) => unreachable!(),
+        }
+
+        self.current_state().loop_stack.push(LoopLabels {
+            start: loop_start.clone(),
+            end: loop_end.clone(),
+        });
+
+        // 5. Body
+        for stmt in for_in.body {
+            self.compile_statement(stmt);
+        }
+
+        self.end_scope(loc, false);
+        self.current_state().loop_stack.pop();
+
+        self.emit(Instruction::Jump(loop_start.clone()), loc);
+
+        // loop_end label
+        self.program.syms.insert(
+            loop_end.clone(),
+            Symbol {
+                location: self.program.instructions.len() as i32,
+                narguments: 0,
+                nlocals: 0,
+                upvalues: Vec::new(),
+            },
+        );
+        self.end_scope(loc, false);
+    }
+
     fn compile_try_catch(&mut self, tc: TryCatch) {
         let loc = tc.loc;
         let unique_id = self.unique_id();

src/compiler.rs

@@ -105,6 +105,8 @@ pub enum Statement {
     Return(Return),
     Local(Local),
     Assign(Assign),
+    /// For-In 循环: for var in iterable { body }
+    ForIn(ForInLoop),
     /// 设置属性: obj.field = value
     SetField {
         object: Expression,
@@ -160,6 +162,18 @@ pub struct Loop {
     pub loc: Location,
 }
 
+/// For-In 循环语句
+#[derive(Debug, PartialEq, Clone)]
+pub struct ForInLoop {
+    /// 循环变量名
+    pub var: String,
+    /// 可迭代对象表达式 (例如一个协程或数组)
+    pub iterable: Expression,
+    /// 循环体
+    pub body: Vec<Statement>,
+    pub loc: Location,
+}
+
 /// Try-Catch-Finally 异常处理
 #[derive(Debug, PartialEq, Clone)]
 pub struct TryCatch {

src/expression.rs

@@ -7,8 +7,8 @@
 use thiserror::Error;
 
 use crate::expression::{
-    Assign, Ast, BinaryOperation, Expression, FunctionCall, FunctionDeclaration, If, Literal, Local, Loop, MethodCall,
-    Return, Statement, TryCatch, Unary,
+    Assign, Ast, BinaryOperation, Expression, ForInLoop, FunctionCall, FunctionDeclaration, If, Literal, Local, Loop,
+    MethodCall, Return, Statement, TryCatch, Unary,
 };
 use crate::tokenizer::Keyword;
 use crate::tokenizer::Location;
@@ -284,18 +284,66 @@ impl Parser {
 
     fn parse_for(&mut self) -> Result<Statement, ParseError> {
         let start_loc = self.peek_location();
-        let condition = self.parse_expression_logic()?;
 
-        self.skip_newlines();
-        self.consume(&Token::LBig, "Expected '{' after for condition")?;
-        let body = self.parse_block()?;
-        self.consume(&Token::RBig, "Expected '}' after for block")?;
+        // 1. Check for infinite loop: for { ... }
+        if self.check(&Token::LBig) {
+            self.advance(); // consume '{'
+            let body = self.parse_block()?;
+            self.consume(&Token::RBig, "Expected '}' after for block")?;
+            return Ok(Statement::Loop(Loop {
+                test: Expression::Literal(Literal::Value(Value::Bool(true)), start_loc),
+                body,
+                loc: start_loc,
+            }));
+        }
 
-        Ok(Statement::Loop(Loop {
-            test: condition,
-            body,
-            loc: start_loc,
-        }))
+        // 2. Check for for-in or while-style:
+        // We look ahead to see if it's an Identifier followed by IN
+        let is_for_in = if let Some(Token::Identifier(_)) = self.peek() {
+            self.tokens
+                .get(self.current + 1)
+                .map(|(t, _)| t == &Token::Keyword(Keyword::IN))
+                .unwrap_or(false)
+        } else {
+            false
+        };
+
+        if is_for_in {
+            let var_name = if let Some(Token::Identifier(name)) = self.advance() {
+                name.clone()
+            } else {
+                unreachable!()
+            };
+
+            self.consume(&Token::Keyword(Keyword::IN), "Expected 'in' after variable name")?;
+            let iterable = self.parse_expression_logic()?;
+
+            self.skip_newlines();
+            self.consume(&Token::LBig, "Expected '{' after for-in iterable")?;
+            let body = self.parse_block()?;
+            self.consume(&Token::RBig, "Expected '}' after for-in block")?;
+
+            Ok(Statement::ForIn(ForInLoop {
+                var: var_name,
+                iterable,
+                body,
+                loc: start_loc,
+            }))
+        } else {
+            // While style: for condition { ... }
+            let condition = self.parse_expression_logic()?;
+
+            self.skip_newlines();
+            self.consume(&Token::LBig, "Expected '{' after for condition")?;
+            let body = self.parse_block()?;
+            self.consume(&Token::RBig, "Expected '}' after for block")?;
+
+            Ok(Statement::Loop(Loop {
+                test: condition,
+                body,
+                loc: start_loc,
+            }))
+        }
     }
 
     fn parse_function_definition(&mut self) -> Result<FunctionDeclaration, ParseError> {

src/parser/handwritten.rs

@@ -145,19 +145,39 @@ fn parse_assignment_target(pair: Pair<Rule>) -> Expression {
 
 fn parse_for_loop(pair: Pair<Rule>, loc: Location) -> Statement {
     let inner = pair.into_inner();
-    let mut test = Expression::Literal(Literal::Value(Value::Bool(false)), loc);
+    let mut test = None;
+    let mut for_in = None;
     let mut body = Vec::new();
 
     for p in inner {
         match p.as_rule() {
-            Rule::expression => test = parse_expression(p),
+            Rule::expression => test = Some(parse_expression(p)),
+            Rule::for_in_header => {
+                let mut header_inner = p.into_inner();
+                let var = header_inner.next().unwrap().as_str().to_string();
+                let iterable = parse_expression(header_inner.next().unwrap());
+                for_in = Some((var, iterable));
+            }
             Rule::block => body = parse_block(p),
-            Rule::FOR => {}
+            Rule::FOR | Rule::IN => {}
             _ => unreachable!("Unexpected rule in for_loop: {:?}", p.as_rule()),
         }
     }
 
-    Statement::Loop(Loop { test, body, loc })
+    if let Some((var, iterable)) = for_in {
+        Statement::ForIn(ForInLoop {
+            var,
+            iterable,
+            body,
+            loc,
+        })
+    } else {
+        Statement::Loop(Loop {
+            test: test.unwrap_or(Expression::Literal(Literal::Value(Value::Bool(true)), loc)),
+            body,
+            loc,
+        })
+    }
 }
 
 fn build_function_declaration(pair: Pair<Rule>) -> FunctionDeclaration {