feat!: implement for i in X...Y and make upper bound exclusive

walker84837 · walker84837 · commit 770435553756 · 2026-01-05T04:45:33.000+01:00
The reason the upper bound was made exclusive is because the original
compiler had this behavior. Keeping the upper bound inclusive would've
effectively "broken" one of the Kit basic features.
diff --git a/ROADMAP.md b/ROADMAP.md
@@ -30,7 +30,7 @@ Goal: lower a well-defined subset of Kit ("Kit Core") to portable C99.
 - [X] `if` expressions / statements
 - [ ] `while` and `for` loops
   - [X] Basic implementation
-  - [ ] `for i in X...Y`
+  - [x] `for i in X...Y`
   - [ ] [`kit.iterator`](https://kitlang.dev/examples/#kititerator)
 - [X] Function calls
 - [X] `return`
diff --git a/examples/range_edge_cases.kit b/examples/range_edge_cases.kit
@@ -0,0 +1,23 @@
+include "stdio.h";
+
+function main() {
+    printf("Testing range edge cases:\n");
+
+    printf("Empty range 5...1: ");
+    for i in 5...1 {
+        printf("%d ", i);
+    }
+    printf("\n");
+
+    printf("Single element 3...3: ");
+    for i in 3...3 {
+        printf("%d ", i);
+    }
+    printf("\n");
+
+    printf("Zero range 0...0: ");
+    for i in 0...0 {
+        printf("%d ", i);
+    }
+    printf("\n");
+}
diff --git a/examples/range_edge_cases.kit.expected b/examples/range_edge_cases.kit.expected
@@ -0,0 +1,4 @@
+Testing range edge cases:
+Empty range 5...1: 
+Single element 3...3: 
+Zero range 0...0: 
diff --git a/examples/range_for.kit.expected b/examples/range_for.kit.expected
@@ -0,0 +1,6 @@
+Testing range for loops:
+Count 1 to 5: 1 2 3 4 5 
+Count 10 to 15: 10 11 12 13 14 15 
+Count 5 to 1: 
+Single element 7: 7 
+Expression range 2*2...3*3: 4 5 6 7 8 9 
diff --git a/examples/range_for_comprehensive.kit b/examples/range_for_comprehensive.kit
@@ -0,0 +1,31 @@
+include "stdio.h";
+
+function main() {
+    printf("Testing range for loops:\n");
+
+    printf("Count 1 to 5: ");
+    for i in 1...5 {
+        printf("%d ", i);
+    }
+    printf("\n");
+
+    var start = 10;
+    var end = 15;
+    printf("Count 10 to 15: ");
+    for i in start...end {
+        printf("%d ", i);
+    }
+    printf("\n");
+
+    printf("Count 5 to 1: ");
+    for i in 5...1 {
+        printf("%d ", i);
+    }
+    printf("\n");
+
+    printf("Single element 7: ");
+    for i in 7...7 {
+        printf("%d ", i);
+    }
+    printf("\n");
+}
diff --git a/examples/range_for_comprehensive.kit.expected b/examples/range_for_comprehensive.kit.expected
@@ -0,0 +1,5 @@
+Testing range for loops:
+Count 1 to 5: 1 2 3 4 
+Count 10 to 15: 10 11 12 13 14 
+Count 5 to 1: 
+Single element 7: 
diff --git a/examples/range_for_simple.kit b/examples/range_for_simple.kit
@@ -0,0 +1,10 @@
+include "stdio.h";
+
+function main() {
+    printf("Testing range for loops:\n");
+    printf("Count 1 to 5: ");
+    for i in 1...5 {
+        printf("%d ", i);
+    }
+    printf("\n");
+}
diff --git a/examples/range_for_simple.kit.expected b/examples/range_for_simple.kit.expected
@@ -0,0 +1,2 @@
+Testing range for loops:
+Count 1 to 5: 1 2 3 4 
diff --git a/examples/range_with_variables.kit b/examples/range_with_variables.kit
@@ -0,0 +1,13 @@
+include "stdio.h";
+
+function main() {
+    printf("Testing range limitations:\n");
+
+    printf("Variables in range: ");
+    var start = 1;
+    var end = 3;
+    for i in start...end {
+        printf("%d ", i);
+    }
+    printf("\n");
+}
diff --git a/examples/range_with_variables.kit.expected b/examples/range_with_variables.kit.expected
@@ -0,0 +1,2 @@
+Testing range limitations:
+Variables in range: 1 2 
diff --git a/examples/simple_range.kit b/examples/simple_range.kit
@@ -0,0 +1,8 @@
+include "stdio.h";
+
+function main() {
+    for i in 1...5 {
+        printf("%d ", i);
+    }
+    printf("\n");
+}
diff --git a/examples/simple_range.kit.expected b/examples/simple_range.kit.expected
@@ -0,0 +1 @@
+1 2 3 4 
diff --git a/examples/test_negative_range.kit b/examples/test_negative_range.kit
@@ -0,0 +1,9 @@
+include "stdio.h";
+
+function main() {
+    printf("Testing negative range:\n");
+    for i in -2...2 {
+        printf("%d ", i);
+    }
+    printf("\n");
+}
diff --git a/examples/test_negative_range.kit.expected b/examples/test_negative_range.kit.expected
@@ -0,0 +1,2 @@
+Testing negative range:
+-2 -1 0 1 
diff --git a/kitc/tests/examples.rs b/kitc/tests/examples.rs
@@ -129,3 +129,33 @@ fn test_while_loop() -> Result<(), Box<dyn std::error::Error>> {
 fn test_for_loop() -> Result<(), Box<dyn std::error::Error>> {
     run_example_test("for_loop", None)
 }
+
+#[test]
+fn test_range_basic() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("range_for_simple", None)
+}
+
+#[test]
+fn test_range_variables() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("range_with_variables", None)
+}
+
+#[test]
+fn test_range_comprehensive() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("range_for_comprehensive", None)
+}
+
+#[test]
+fn test_range_edge_cases() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("range_edge_cases", None)
+}
+
+#[test]
+fn test_range_negative() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("test_negative_range", None)
+}
+
+#[test]
+fn test_simple_range() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("simple_range", None)
+}
diff --git a/kitlang/src/codegen/frontend.rs b/kitlang/src/codegen/frontend.rs
@@ -433,11 +433,21 @@ impl Compiler {
                     else_branch: Box::new(else_branch),
                 })
             }
+
             Rule::primary => {
                 // SAFETY: Primary rule always has exactly one child
                 let inner = pair.into_inner().next().unwrap();
                 self.parse_expr(inner)
             }
+            Rule::range_expr => {
+                let mut inner = pair.into_inner();
+                let start = self.parse_expr(inner.next().unwrap())?;
+                let end = self.parse_expr(inner.next().unwrap())?;
+                Ok(Expr::RangeLiteral {
+                    start: Box::new(start),
+                    end: Box::new(end),
+                })
+            }
             other => Err(CompilationError::ParseError(format!(
                 "Unexpected expr rule: {:?}",
                 other
@@ -594,14 +604,26 @@ impl Compiler {
                 // Translate `for i in 10` to `for (int i = 0; i < 10; ++i)`
                 // Of course, this assumes `iter` (i) is an integer literal or expression that evaluates to an integer.
                 Stmt::For { var, iter, body } => {
-                    // TODO: Right now, this is a basic implementation and might need to be expanded for more "complex" iterators, like
-                    // `for i in 1...10`, etc.
-                    let iter_str = self.transpile_expr(iter);
                     let body_code = self.transpile_block(body);
-                    code.push_str(&format!(
-                        "for (int {} = 0; {} < {}; ++{}) {{\n{}}}",
-                        var, var, iter_str, var, body_code
-                    ));
+                    match iter {
+                        Expr::RangeLiteral { start, end } => {
+                            // Handle range literals: `for i in 1...10`
+                            let start_str = self.transpile_expr(start);
+                            let end_str = self.transpile_expr(end);
+                            code.push_str(&format!(
+                                "for (int {} = {}; {} < {}; ++{}) {{\n{}}}",
+                                var, start_str, var, end_str, var, body_code
+                            ));
+                        }
+                        _ => {
+                            // Handle single integer expressions: `for i in 3`
+                            let iter_str = self.transpile_expr(iter);
+                            code.push_str(&format!(
+                                "for (int {} = 0; {} < {}; ++{}) {{\n{}}}",
+                                var, var, iter_str, var, body_code
+                            ));
+                        }
+                    }
                 }
                 Stmt::Break => {
                     code.push_str("break;\n");
@@ -650,6 +672,11 @@ impl Compiler {
                 let right_str = self.transpile_expr(right);
                 format!("({} {} {})", left_str, op.to_c_str(), right_str)
             }
+            Expr::RangeLiteral { start: _, end: _ } => {
+                // Range literals are not directly transpiled to C
+                // They are only used in for loop context
+                panic!("Range literals should only be used in for loop expressions")
+            }
         }
     }
 
diff --git a/kitlang/src/codegen/types.rs b/kitlang/src/codegen/types.rs
@@ -475,6 +475,13 @@ pub enum Expr {
         /// The expression to evaluate if the condition is false.
         else_branch: Box<Expr>,
     },
+    /// Range literal expression (e.g., `1...10`).
+    RangeLiteral {
+        /// The start of the range.
+        start: Box<Expr>,
+        /// The end of the range (inclusive).
+        end: Box<Expr>,
+    },
 }
 
 /// Represents literal values in Kit.
diff --git a/kitlang/src/grammar/kit.pest b/kitlang/src/grammar/kit.pest
@@ -50,7 +50,7 @@ return_stmt = { "return" ~ expr? ~ ";" }
 if_stmt = { "if" ~ expr ~ block ~ else_part? }
 else_part = { "else" ~ (block | if_stmt) }
 
-for_stmt = { "for" ~ identifier ~ "in" ~ expr ~ block }
+for_stmt = { "for" ~ identifier ~ "in" ~ (range_expr | expr) ~ block }
 
 while_stmt = { "while" ~ expr ~ block }
 
@@ -150,6 +150,7 @@ struct_init = { "struct" ~ type_annotation ~ "{" ~ (field_init ~ ("," ~ field_in
 union_init = { "union" ~ type_annotation ~ "{" ~ field_init ~ "}" }
 field_init = { identifier ~ ":" ~ expr }
 tuple_literal = { "(" ~ expr ~ ("," ~ expr)+ ~ ")" }
+range_expr = { identifier ~ "..." ~ identifier | expr ~ "..." ~ expr }
 
 
 literal = { number | boolean | char_literal }
diff --git a/kitlang/src/lexer.rs b/kitlang/src/lexer.rs
@@ -98,6 +98,8 @@ pub enum Token {
     Equals,
     #[token("~")]
     Tilde,
+    #[token("...")]
+    TripleDot,
 
     #[regex(r#""([^"\\]|\\.)*""#, |lex| {
         let s = lex.slice();

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+Testing range for loops:`
	`2`	`+Count 1 to 5: 1 2 3 4`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+Testing range limitations:`
	`2`	`+Variables in range: 1 2`