For loop syntax

crates/concrete_ast/src/statements.rs

@@ -53,10 +53,11 @@ pub struct Binding {
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ForStmt {
-    pub name: Ident,
-    pub from: Expression,
-    pub to: Expression,
+    pub init: Option<LetStmt>,
+    pub condition: Option<Expression>,
+    pub post: Option<AssignStmt>,
     pub contents: Vec<Statement>,
+    pub span: Span,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]

crates/concrete_parser/src/grammar.lalrpop

@@ -517,6 +517,7 @@ pub(crate) Statement: ast::statements::Statement = {
   <MatchExpr> ";"? => ast::statements::Statement::Match(<>),
   <IfExpr> ";"? => ast::statements::Statement::If(<>),
   <WhileStmt> ";"? => ast::statements::Statement::While(<>),
+  <ForStmt> ";"? => ast::statements::Statement::For(<>),
   <LetStmt> ";" => ast::statements::Statement::Let(<>),
   <AssignStmt> ";" => ast::statements::Statement::Assign(<>),
   <FnCallOp> ";" => ast::statements::Statement::FnCall(<>),
@@ -574,3 +575,34 @@ pub(crate) WhileStmt: ast::statements::WhileStmt = {
     }
   }
 }
+
+
+pub(crate) ForStmt: ast::statements::ForStmt = {
+  <lo:@L> "for" "(" <init:LetStmt?> ";" <condition:Expression?> ";" <post:AssignStmt?> ")" "{" <contents:StatementList> "}" <hi:@R> => {
+    ast::statements::ForStmt {
+      init,
+      condition,
+      post,
+      contents,
+      span: Span::new(lo, hi)
+    }
+  },
+  <lo:@L> "for" "(" <condition:Expression> ")" "{" <contents:StatementList> "}" <hi:@R> => {
+    ast::statements::ForStmt {
+      init: None,
+      condition: Some(condition),
+      post: None,
+      contents,
+      span: Span::new(lo, hi)
+    }
+  },
+  <lo:@L> "for" "{" <contents:StatementList> "}" <hi:@R> => {
+    ast::statements::ForStmt {
+      init: None,
+      condition: None,
+      post: None,
+      contents,
+      span: Span::new(lo, hi)
+    }
+  }
+}

crates/concrete_parser/src/lib.rs

@@ -150,6 +150,75 @@ mod ModuleName {
     fn parse_empty_fn() {
         let source = r##"mod MyMod {
             fn hello() {}
+}"##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        parser.parse(lexer).unwrap();
+    }
+
+    #[test]
+    fn parse_for() {
+        let source = r##"mod MyMod {
+    fn hello() {
+        let mut result: i64 = 0;
+
+        for (let n: usize = 1; n <= limit; n = n + 1) {
+            result = result + n;
+        }
+
+        return result;
+    }
+}"##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        parser.parse(lexer).unwrap();
+    }
+
+    #[test]
+    fn parse_for_while() {
+        let source = r##"mod MyMod {
+    fn hello() {
+        let mut result: i64 = 0;
+
+        let n: i64 = 1;
+        for (; n <= limit ;) {
+            result = result + n;
+            n = n + 1;
+        }
+
+        n = 1;
+        for (n <= limit) {
+            result = result + n;
+            n = n + 1;
+        }
+
+        return result;
+    }
+}"##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        parser.parse(lexer).unwrap();
+    }
+
+    #[test]
+    fn parse_for_loop() {
+        let source = r##"mod MyMod {
+    fn hello() {
+        let mut result: i64 = 0;
+
+        let n: i64 = 1;
+        for (;;) {
+            result = result + n;
+            n = n + 1;
+        }
+
+        for {
+            result = result + n;
+            n = n + 1;
+        }
+
+        return result;
+    }
 }"##;
         let lexer = Lexer::new(source);
         let parser = grammar::ProgramParser::new();

examples/for.con

@@ -0,0 +1,15 @@
+mod Example {
+    fn main() -> i64 {
+        return sum_to(4);
+    }
+
+    fn sum_to(limit: i64) -> i64 {
+        let mut result: i64 = 0;
+
+        for (let n: i64 = 1; n <= limit; n = n + 1) {
+            result = result + n;
+        }
+
+        return result;
+    }
+}

examples/for_loop.con

@@ -0,0 +1,22 @@
+mod Example {
+    fn main() -> i64 {
+        return sum_to(4);
+    }
+
+    fn sum_to(limit: i64) -> i64 {
+        let mut result: i64 = 0;
+
+        let n: i64 = 1;
+        for (;;) {
+            result = result + n;
+            n = n + 1;
+        }
+
+        for {
+            result = result + n;
+            n = n + 1;
+        }
+
+        return result;
+    }
+}

examples/for_while.con

@@ -0,0 +1,23 @@
+mod Example {
+    fn main() -> i64 {
+        return sum_to(4);
+    }
+
+    fn sum_to(limit: i64) -> i64 {
+        let mut result: i64 = 0;
+
+        let n: i64 = 1;
+        for (; n <= limit ;) {
+            result = result + n;
+            n = n + 1;
+        }
+
+        n = 1;
+        for (n <= limit) {
+            result = result + n;
+            n = n + 1;
+        }
+
+        return result;
+    }
+}