Add support for for loops

This fixes #817.

Changelog: added

Author: yorickpeterse

ast/src/lexer.rs

@@ -115,6 +115,7 @@ pub enum TokenKind {
     If,
     Implement,
     Import,
+    In,
     Inline,
     Integer,
     Invalid,
@@ -272,6 +273,7 @@ impl TokenKind {
             TokenKind::Inline => "the 'inline' keyword",
             TokenKind::Copy => "the 'copy' keyword",
             TokenKind::Type => "the 'type' keyword",
+            TokenKind::In => "the 'in' keyword",
         }
     }
 }
@@ -341,6 +343,7 @@ impl Token {
                 | TokenKind::Inline
                 | TokenKind::Copy
                 | TokenKind::Type
+                | TokenKind::In
         )
     }
 
@@ -964,6 +967,7 @@ impl Lexer {
                 "fn" => TokenKind::Fn,
                 "if" => TokenKind::If,
                 "or" => TokenKind::Or,
+                "in" => TokenKind::In,
                 _ => TokenKind::Identifier,
             },
             3 => match value.as_str() {
@@ -1359,6 +1363,7 @@ mod tests {
         assert!(tok(TokenKind::Inline, "", 1..=1, 1..=1).is_keyword());
         assert!(tok(TokenKind::Copy, "", 1..=1, 1..=1).is_keyword());
         assert!(tok(TokenKind::Type, "", 1..=1, 1..=1).is_keyword());
+        assert!(tok(TokenKind::In, "", 1..=1, 1..=1).is_keyword());
     }
 
     #[test]
@@ -1966,6 +1971,7 @@ mod tests {
         assert_token!("fn", Fn, "fn", 1..=1, 1..=2);
         assert_token!("if", If, "if", 1..=1, 1..=2);
         assert_token!("or", Or, "or", 1..=1, 1..=2);
+        assert_token!("in", In, "in", 1..=1, 1..=2);
 
         assert_token!("and", And, "and", 1..=1, 1..=3);
         assert_token!("for", For, "for", 1..=1, 1..=3);

ast/src/nodes.rs

@@ -768,6 +768,7 @@ pub enum Expression {
     Array(Box<Array>),
     Tuple(Box<Tuple>),
     Comment(Box<Comment>),
+    For(Box<For>),
 }
 
 impl Expression {
@@ -790,13 +791,14 @@ impl Expression {
         }
     }
 
-    pub fn is_conditional(&self) -> bool {
+    pub fn is_conditional_or_loop(&self) -> bool {
         matches!(
             self,
             Expression::While(_)
                 | Expression::Loop(_)
                 | Expression::If(_)
                 | Expression::Match(_)
+                | Expression::For(_)
         )
     }
 
@@ -851,6 +853,7 @@ impl Node for Expression {
             Expression::Mut(ref typ) => typ.location(),
             Expression::Recover(ref typ) => typ.location(),
             Expression::Comment(ref n) => n.location(),
+            Expression::For(ref n) => n.location(),
         }
     }
 }
@@ -1598,3 +1601,17 @@ impl Node for Module {
         &self.location
     }
 }
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct For {
+    pub pattern: Pattern,
+    pub iterator: Expression,
+    pub body: Expressions,
+    pub location: Location,
+}
+
+impl Node for For {
+    fn location(&self) -> &Location {
+        &self.location
+    }
+}

ast/src/parser.rs

@@ -1703,6 +1703,7 @@ impl Parser {
             TokenKind::Try => self.try_expression(start)?,
             TokenKind::While => self.while_expression(start)?,
             TokenKind::Let => self.define_variable(start)?,
+            TokenKind::For => self.for_expression(start)?,
             TokenKind::Comment => Expression::Comment(self.comment(start)),
             _ => {
                 error!(start.location, "'{}' can't be used here", start.value)
@@ -2527,6 +2528,7 @@ impl Parser {
             | TokenKind::True
             | TokenKind::Try
             | TokenKind::While
+            | TokenKind::For
                 if same_line =>
             {
                 let token = self.next();
@@ -2910,6 +2912,28 @@ impl Parser {
         Ok(Expression::While(Box::new(While { condition, body, location })))
     }
 
+    fn for_expression(
+        &mut self,
+        start: Token,
+    ) -> Result<Expression, ParseError> {
+        let pattern = self.pattern()?;
+
+        self.expect(TokenKind::In)?;
+
+        let iter_tok = self.require()?;
+        let iter = self.expression(iter_tok)?;
+        let body_tok = self.expect(TokenKind::CurlyOpen)?;
+        let body = self.expressions(body_tok)?;
+        let location = Location::start_end(&start.location, body.location());
+
+        Ok(Expression::For(Box::new(For {
+            pattern,
+            iterator: iter,
+            body,
+            location,
+        })))
+    }
+
     fn if_condition(&mut self) -> Result<IfCondition, ParseError> {
         let cond_start = self.require()?;
         let condition = self.expression(cond_start)?;
@@ -9720,6 +9744,36 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_for_expression() {
+        assert_eq!(
+            expr("for x in y { 20 }"),
+            Expression::For(Box::new(For {
+                pattern: Pattern::Identifier(Box::new(IdentifierPattern {
+                    name: Identifier {
+                        name: "x".to_string(),
+                        location: cols(5, 5)
+                    },
+                    mutable: false,
+                    value_type: None,
+                    location: cols(5, 5)
+                })),
+                iterator: Expression::Identifier(Box::new(Identifier {
+                    name: "y".to_string(),
+                    location: cols(10, 10)
+                })),
+                body: Expressions {
+                    values: vec![Expression::Int(Box::new(IntLiteral {
+                        value: "20".to_string(),
+                        location: cols(14, 15)
+                    }))],
+                    location: cols(12, 17)
+                },
+                location: cols(1, 17)
+            }))
+        );
+    }
+
     #[test]
     fn test_invalid_while_expression() {
         assert_error_expr!("while 10 20 }", cols(10, 11));

compiler/src/format.rs

@@ -1254,7 +1254,9 @@ impl Document {
                         (Expression::Comment(_), _) => Node::HardLine,
                         // Conditionals are surrounded by an empty line as to
                         // make them stand out more.
-                        _ if expr.is_conditional() || next.is_conditional() => {
+                        _ if expr.is_conditional_or_loop()
+                            || next.is_conditional_or_loop() =>
+                        {
                             Node::EmptyLine
                         }
                         // `let` and comments are grouped together.
@@ -1272,7 +1274,7 @@ impl Document {
                 };
 
                 vals.push(sep);
-            } else if nodes.len() == 1 && expr.is_conditional() {
+            } else if nodes.len() == 1 && expr.is_conditional_or_loop() {
                 // Conditionals inside bodies are a bit difficult to read due to
                 // all the curly braces, so for expressions such as
                 // `if foo { loop { ... } }` we force wrapping across lines.
@@ -1330,6 +1332,7 @@ impl Document {
             Expression::Try(n) => self.try_value(n),
             Expression::Match(n) => self.match_value(n),
             Expression::Scope(n) => self.scope(n),
+            Expression::For(n) => self.for_loop(n),
         }
     }
 
@@ -1568,6 +1571,30 @@ impl Document {
         Node::Group(gid, group)
     }
 
+    fn for_loop(&mut self, node: &nodes::For) -> Node {
+        let gid = self.new_group_id();
+        let pat = self.pattern(&node.pattern);
+        let col = self.expression(&node.iterator);
+        let header = vec![
+            Node::text("for"),
+            Node::SpaceOrLine,
+            Node::Indent(vec![pat]),
+            Node::SpaceOrLine,
+            Node::text("in"),
+            Node::SpaceOrLine,
+            Node::Indent(vec![col]),
+            Node::SpaceOrLine,
+            Node::text("{"),
+        ];
+        let body = self.body(&node.body.values);
+        let group = vec![
+            self.group(header),
+            Node::WrapIf(gid, Box::new(self.group(body))),
+        ];
+
+        Node::Group(gid, group)
+    }
+
     fn if_else(&mut self, node: &nodes::If) -> Node {
         let gid = self.new_group_id();
         let mut group = vec![Node::Nodes(self.conditional(

compiler/src/hir.rs

@@ -14,6 +14,10 @@ use types::{ARRAY_INTERNAL_NAME, ARRAY_PUSH, ARRAY_WITH_CAPACITY};
 
 const BUILTIN_RECEIVER: &str = "_INKO";
 const ARRAY_LIT_VAR: &str = "$array";
+const ITER_VAR: &str = "$iter";
+const NEXT_CALL: &str = "next";
+const SOME_CONS: &str = "Some";
+const INTO_ITER_CALL: &str = "into_iter";
 
 struct Comments {
     nodes: Vec<ast::Comment>,
@@ -2476,6 +2480,9 @@ impl<'a> LowerToHir<'a> {
             ast::Expression::While(node) => {
                 Expression::Loop(self.while_expression(*node))
             }
+            ast::Expression::For(node) => {
+                Expression::Scope(self.for_expression(*node))
+            }
             ast::Expression::Scope(node) => {
                 Expression::Scope(self.scope(*node))
             }
@@ -3176,6 +3183,100 @@ impl<'a> LowerToHir<'a> {
         Box::new(Loop { body, location: node.location })
     }
 
+    fn for_expression(&mut self, node: ast::For) -> Box<Scope> {
+        let pat_loc = *node.pattern.location();
+        let iter_loc = *node.iterator.location();
+        let def_var = Expression::DefineVariable(Box::new(DefineVariable {
+            resolved_type: types::TypeRef::Unknown,
+            variable_id: None,
+            mutable: false,
+            name: Identifier { name: ITER_VAR.to_string(), location: pat_loc },
+            value_type: None,
+            value: Expression::Call(Box::new(Call {
+                kind: types::CallKind::Unknown,
+                receiver: Some(self.expression(node.iterator)),
+                name: Identifier {
+                    name: INTO_ITER_CALL.to_string(),
+                    location: iter_loc,
+                },
+                arguments: Vec::new(),
+                parens: false,
+                in_mut: false,
+                usage: Usage::Used,
+                location: iter_loc,
+            })),
+            location: pat_loc,
+        }));
+
+        let loop_expr = Expression::Loop(Box::new(Loop {
+            body: vec![Expression::Match(Box::new(Match {
+                resolved_type: types::TypeRef::Unknown,
+                // iter.next
+                expression: Expression::Call(Box::new(Call {
+                    kind: types::CallKind::Unknown,
+                    receiver: Some(Expression::IdentifierRef(Box::new(
+                        IdentifierRef {
+                            name: ITER_VAR.to_string(),
+                            kind: types::IdentifierKind::Unknown,
+                            usage: Usage::Used,
+                            location: iter_loc,
+                        },
+                    ))),
+                    name: Identifier {
+                        name: NEXT_CALL.to_string(),
+                        location: iter_loc,
+                    },
+                    arguments: Vec::new(),
+                    parens: false,
+                    in_mut: false,
+                    usage: Usage::Used,
+                    location: iter_loc,
+                })),
+                cases: vec![
+                    // case Some(...) -> body
+                    MatchCase {
+                        variable_ids: Vec::new(),
+                        pattern: Pattern::Constructor(Box::new(
+                            ConstructorPattern {
+                                constructor_id: None,
+                                name: Constant {
+                                    name: SOME_CONS.to_string(),
+                                    location: node.location,
+                                },
+                                values: vec![self.pattern(node.pattern)],
+                                location: node.location,
+                            },
+                        )),
+                        guard: None,
+                        body: self.expressions(node.body),
+                        location: pat_loc,
+                    },
+                    // case _ -> break
+                    MatchCase {
+                        variable_ids: Vec::new(),
+                        pattern: Pattern::Wildcard(Box::new(WildcardPattern {
+                            location: node.location,
+                        })),
+                        guard: None,
+                        body: vec![Expression::Break(Box::new(Break {
+                            location: node.location,
+                        }))],
+                        location: node.location,
+                    },
+                ],
+                location: node.location,
+                write_result: false,
+            }))],
+            location: node.location,
+        }));
+
+        Box::new(Scope {
+            resolved_type: types::TypeRef::Unknown,
+            body: vec![def_var, loop_expr],
+            location: node.location,
+        })
+    }
+
     fn scope(&mut self, node: ast::Scope) -> Box<Scope> {
         Box::new(Scope {
             resolved_type: types::TypeRef::Unknown,

std/fixtures/fmt/for_loops/input.inko

@@ -0,0 +1,23 @@
+fn example {
+  for aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {
+    foo
+  }
+
+  for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {
+    foo
+  }
+
+  for aaaa in bbbb {
+    # comment
+    foo
+  }
+  for aaaa in bbbb {
+    # comment
+    foo
+  }
+
+  for aaaa in bbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccccccccccccc.ddddddddddddddddddddd(10, 20) {
+    # comment
+    foo
+  }
+}