README.md

@@ -6,11 +6,6 @@ a vlang parser in zig
 
 because i can
 
-## variations
-
- - `for` is split between `for` and `loop` because my fucking god i cant stand
-    having *four* different variations of `for`.
-
 ## how
 
 ```

examples/hello.v

@@ -20,14 +20,4 @@ fn main(a int) int {
 
 	a && b
 	a || b
-
-	loop {}
-	loop {
-		println('Ballse')
-	}
-
-	loop a > 2 {}
-	loop a > 2 {
-		println('skirts')
-	}
 }

src/ast.zig

@@ -97,17 +97,12 @@ pub const Expr = union(ExprType) {
     Grouping: *Expr,
 };
 
-pub const Block = std.ArrayList(*Stmt);
+pub const IfBranch = std.ArrayList(*Stmt);
 
 pub const IfStmt = struct {
     condition: *Expr,
-    then_branch: Block,
-    else_branch: ?Block,
-};
-
-pub const LoopStmt = struct {
-    condition: ?*Expr,
-    then_branch: Block,
+    then_branch: IfBranch,
+    else_branch: ?IfBranch,
 };
 
 pub const Stmt = union(enum) {
@@ -115,46 +110,28 @@ pub const Stmt = union(enum) {
     Println: *Expr,
 
     If: IfStmt,
-    Loop: LoopStmt,
 
     pub fn mkPrintln(allocator: *std.mem.Allocator, expr: *Expr) !*Stmt {
-        var stmt = try allocator.create(Stmt);
-        stmt.* = Stmt{ .Println = expr };
-        return stmt;
+        var println = try allocator.create(Stmt);
+        println.* = Stmt{ .Println = expr };
+        return println;
     }
 
     pub fn mkIfStmt(
         allocator: *std.mem.Allocator,
         condition: *Expr,
-        then: Block,
-        else_branch: ?Block,
+        then: IfBranch,
+        else_branch: ?IfBranch,
     ) !*Stmt {
-        var stmt = try allocator.create(Stmt);
-        stmt.* = Stmt{
+        var println = try allocator.create(Stmt);
+        println.* = Stmt{
             .If = IfStmt{
                 .condition = condition,
                 .then_branch = then,
                 .else_branch = else_branch,
             },
         };
-
-        return stmt;
-    }
-
-    pub fn mkLoop(
-        allocator: *std.mem.Allocator,
-        condition: ?*Expr,
-        then: Block,
-    ) !*Stmt {
-        var stmt = try allocator.create(Stmt);
-        stmt.* = Stmt{
-            .Loop = LoopStmt{
-                .condition = condition,
-                .then_branch = then,
-            },
-        };
-
-        return stmt;
+        return println;
     }
 };
 
@@ -327,20 +304,6 @@ pub fn printStmt(ident: usize, stmt: *Stmt) void {
 
             std.debug.warn(")\n");
         },
-
-        .Loop => |loop| {
-            std.debug.warn("(loop ");
-            if (loop.condition) |cond| {
-                printExpr(cond);
-            } else {
-                std.debug.warn("true");
-            }
-            std.debug.warn(" ");
-
-            printBlock(ident + 1, loop.then_branch, false);
-            std.debug.warn(")\n");
-        },
-
         else => std.debug.warn("UnknownStmt-{}", @tagName(stmt.*)),
     }
 }

src/parser.zig

@@ -449,7 +449,6 @@ pub const Parser = struct {
     fn parseStmt(self: *@This()) anyerror!*Stmt {
         return switch (self.peek().ttype) {
             .If => try self.parseIfStmt(),
-            .Loop => try self.parseLoop(),
             .Println => try self.parsePrintln(),
 
             // TODO make newlines tokens and consume newline?
@@ -457,35 +456,35 @@ pub const Parser = struct {
         };
     }
 
-    /// Copy of parseBlock for blocks in statements
-    fn parseStmtBlock(self: *@This()) !ast.Block {
-        var block = ast.Block.init(self.allocator);
-        errdefer block.deinit();
+    /// Copy of parseBlock for if branches
+    fn parseIfBranch(self: *@This()) !ast.IfBranch {
+        var branch = ast.IfBranch.init(self.allocator);
+        errdefer branch.deinit();
 
         _ = try self.consumeSingle(.LeftBrace);
 
         while (self.peek().ttype != .RightBrace) {
             var stmt = try self.parseDecl();
             ast.printNode(try self.mkStmt(stmt), 0);
-            try block.append(stmt);
+            try branch.append(stmt);
         }
 
         _ = try self.consumeSingle(.RightBrace);
 
-        return block;
+        return branch;
     }
 
     fn parseIfStmt(self: *@This()) !*Stmt {
         _ = try self.consumeSingle(.If);
         var condition = (try self.parseExpr()).Expr;
 
-        const then_branch = try self.parseStmtBlock();
+        const then_branch = try self.parseIfBranch();
 
-        var else_branch: ?ast.Block = null;
+        var else_branch: ?ast.IfBranch = null;
 
         if (self.check(.Else)) {
             _ = try self.consumeSingle(.Else);
-            else_branch = try self.parseStmtBlock();
+            else_branch = try self.parseIfBranch();
         }
 
         return try Stmt.mkIfStmt(
@@ -496,22 +495,6 @@ pub const Parser = struct {
         );
     }
 
-    fn parseLoop(self: *@This()) !*Stmt {
-        _ = try self.consumeSingle(.Loop);
-        var expr: ?*Expr = null;
-        var body: ast.Block = undefined;
-
-        // infinite loop
-        if (self.check(.LeftBrace)) {
-            body = try self.parseStmtBlock();
-        } else {
-            expr = (try self.parseExpr()).Expr;
-            body = try self.parseStmtBlock();
-        }
-
-        return try Stmt.mkLoop(self.allocator, expr, body);
-    }
-
     fn parsePrintln(self: *@This()) !*Stmt {
         _ = try self.consumeSingle(.Println);
 

src/scanner.zig

@@ -50,7 +50,6 @@ const keywords = [_][]const u8{
     "false",
     "None",
     "println",
-    "loop",
 };
 
 const keyword_ttypes = [_]TokenType{
@@ -79,7 +78,6 @@ const keyword_ttypes = [_]TokenType{
     .False,
     .None,
     .Println,
-    .Loop,
 };
 
 fn getKeyword(keyword: []const u8) ?TokenType {

src/tokens.zig

@@ -55,7 +55,6 @@ pub const TokenType = enum {
     Enum,
     Fn,
     For,
-    Loop,
     Go,
     Goto,
     If,