Added while loop

Author: noituri

Cargo.toml

@@ -8,4 +8,5 @@ edition = "2021"
 [dependencies]
 ash_core = { "path" = "./crates/ash_core" }
 argh = "0.1"
-ariadne = "0.1"
+ariadne = "0.1"
+anyhow = "1.0"

crates/ash_core/src/core/source.rs

@@ -1,5 +1,5 @@
 use std::error::Error;
-use std::fs;
+use std::{fs, io};
 use std::path::PathBuf;
 
 use once_cell::sync::OnceCell;
@@ -13,7 +13,7 @@ pub struct Source {
 }
 
 impl Source {
-    pub fn from_file(path: PathBuf) -> Result<Self, Box<dyn Error>> {
+    pub fn from_file(path: PathBuf) -> Result<Self, io::Error> {
         let source = fs::read_to_string(&path)?;
         let location = path.as_os_str().to_str().map(ToOwned::to_owned);
         let source = Self {

crates/ash_core/src/ir/ast.rs

@@ -26,6 +26,7 @@ pub(crate) enum Stmt {
         name: Spanned<String>,
         value: Expr,
     },
+    While(Spanned<Expr>, Vec<Spanned<Stmt>>),
     If(If<Expr, Stmt>),
     Return(Option<Expr>, Ty),
     Expression(Expr, Ty),
@@ -40,7 +41,6 @@ pub(crate) enum Expr {
         args: Vec<Expr>,
         ty: Ty,
     },
-    Block(Vec<Spanned<Stmt>>, Ty),
     Unary {
         op: UnaryOp,
         right: Box<Expr>,

crates/ash_core/src/ir/ir.rs

@@ -135,6 +135,13 @@ impl<'a> IR<'a> {
                 let proto_stmt = ir::Stmt::ProtoFunction(proto);
                 DesugaredAst::returns((proto_stmt, span))
             }
+            ty::Stmt::While(mut cond, body) => {
+                let cond_expr = self.desugar_expr(cond.0);
+                let body = self.desugar_statements(body);
+                let r#while = ir::Stmt::While((cond_expr.returns.unwrap(), cond.1), body);
+
+                DesugaredAst::new((r#while, span), cond_expr.rest)
+            }
             ty::Stmt::Return(expr, ty) => match expr {
                 Some(expr) => {
                     let DesugaredAst { returns, rest } = self.desugar_expr(expr);

crates/ash_core/src/lexer/keyword.rs

@@ -13,6 +13,7 @@ pub(super) fn keyword_lexer() -> impl Parser<char, Token, Error = Simple<char>>
             "let" => Token::Let,
             "if" => Token::If,
             "else" => Token::Else,
+            "while" => Token::While,
             _ => Token::Identifier {
                 value: ident,
                 space_sufix: !space.is_empty(),

crates/ash_core/src/lexer/token.rs

@@ -29,6 +29,7 @@ pub(crate) enum Token {
     Function,
     If,
     Else,
+    While,
     Let,
     String(String),
     I32(String),
@@ -64,6 +65,7 @@ impl fmt::Display for Token {
             Token::Function => "fun",
             Token::If => "if",
             Token::Else => "else",
+            Token::While => "while",
             Token::Let => "let",
             Token::String(_) => "String",
             Token::I32(_) => "I32",

crates/ash_core/src/parser/loops.rs

@@ -0,0 +1,13 @@
+use crate::{lexer::token::Token, core::Spanned};
+
+use super::{common::block_parser, expression_parser, Stmt, StmtRecursive};
+use chumsky::prelude::*;
+
+pub(super) fn while_parser<'a>(
+    stmt: StmtRecursive<'a>,
+) -> impl Parser<Token, Spanned<Stmt>, Error = Simple<Token>> + 'a {
+    just(Token::While)
+        .ignore_then(expression_parser().map_with_span(|e, s| (e, s)))
+        .then(block_parser(stmt))
+        .map_with_span(|(cond, body), span| (Stmt::While(cond, body.block_data()), span))
+}

crates/ash_core/src/parser/mod.rs

@@ -12,3 +12,4 @@ pub(crate) mod operator;
 pub(crate) mod parser;
 pub(crate) mod stmt;
 mod variable;
+mod loops;

crates/ash_core/src/parser/stmt.rs

@@ -14,14 +14,15 @@ use super::{
     conditional::if_parser,
     expr::{expression_parser, Expr},
     function::{function_parser, function_proto_parser, return_parser},
-    variable::{variable_assign_parse, variable_decl_parse},
+    variable::{variable_assign_parse, variable_decl_parse}, loops::while_parser,
 };
 
 #[derive(Debug, Clone)]
 pub(crate) enum Stmt {
     Annotation(Spanned<Annotation>, Box<Spanned<Stmt>>),
     ProtoFunction(ProtoFunction),
     Function(Box<Function<Stmt>>),
+    While(Spanned<Expr>, Vec<Spanned<Stmt>>),
     VariableDecl {
         id: Id,
         name: String,
@@ -57,6 +58,7 @@ pub(super) fn statement_parser() -> impl Parser<Token, Spanned<Stmt>, Error = Si
         annotation_parser(stmt.clone())
             .or(function_parser(stmt.clone()))
             .or(function_proto_parser())
+            .or(while_parser(stmt.clone()))
             .or(variable_decl_parse(stmt.clone()))
             .or(variable_assign_parse(stmt.clone()))
             .or(return_parser(stmt))

crates/ash_core/src/resolver/resolver.rs

@@ -158,6 +158,10 @@ impl<'a> Resolver<'a> {
                 }
                 self.current_function = prev;
             }
+            Stmt::While((cond, span), body) => {
+                self.resolve_expr(cond, span);
+                self.resolve_statements(body);
+            }
             Stmt::Return(expr) => {
                 if self.current_function.is_none() {
                     self.new_error("return can not be used outside of function", span.clone())