From 6ab7cdbe20937ba4c93e8fbc86b722ed0dd24e9d Mon Sep 17 00:00:00 2001
From: Luna <git@l4.pm>
Date: Tue, 27 Aug 2019 12:19:10 -0300
Subject: [PATCH] add array parsing

---
 examples/hello.v    |  2 ++
 src/ast.zig         |  1 +
 src/ast_printer.zig |  4 ++++
 src/parser.zig      | 29 ++++++++++++++++++++++++++++-
 4 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/examples/hello.v b/examples/hello.v
index 8b3f3bf..ba91ed7 100644
--- a/examples/hello.v
+++ b/examples/hello.v
@@ -61,6 +61,8 @@ fn main(a int) int {
 	str.len -= 1
 	str.len *= 1
 	str.len /= 1
+
+	awoo := [1, 2, a(), b + 2, c(31) * d]
 }
 
 fn (v Typ) voidfunc() {}
diff --git a/src/ast.zig b/src/ast.zig
index baa49eb..bbb4956 100644
--- a/src/ast.zig
+++ b/src/ast.zig
@@ -64,6 +64,7 @@ pub const LiteralExpr = union(enum) {
     Integer: []const u8,
     Float: []const u8,
     String: []const u8,
+    Array: ExprList,
 };
 
 pub const AssignExpr = struct {
diff --git a/src/ast_printer.zig b/src/ast_printer.zig
index 25f90b4..5e41240 100644
--- a/src/ast_printer.zig
+++ b/src/ast_printer.zig
@@ -146,6 +146,10 @@ pub fn printExpr(expr: *Expr) void {
                 .Integer => |val| std.debug.warn("{}", val),
                 .Float => |val| std.debug.warn("{}", val),
                 .String => |val| std.debug.warn("'{}'", val),
+                .Array => |exprs| {
+                    parenthetize("array", exprs.toSlice());
+                },
+                else => |typ| std.debug.warn("UnknownLiteral-{}", typ),
             }
         },
 
diff --git a/src/parser.zig b/src/parser.zig
index 30c6c9c..0675378 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -350,6 +350,17 @@ pub const Parser = struct {
         return expr;
     }
 
+    fn mkArray(self: *Parser, exprs: ast.ExprList) !*ast.Expr {
+        var expr = try self.allocator.create(Expr);
+        expr.* = Expr{
+            .Literal = ast.LiteralExpr{
+                .Array = exprs,
+            },
+        };
+
+        return expr;
+    }
+
     fn mkVariable(self: *Parser, variable: Token) !*ast.Expr {
         var expr = try self.allocator.create(Expr);
         expr.* = Expr{ .Variable = variable };
@@ -1000,7 +1011,23 @@ pub const Parser = struct {
             .String => try self.mkString(lexeme),
             .Identifier => try self.mkVariable(self.peek()),
 
-            .LeftParen => blk: {
+            // type checking for arrays happens at later stages
+            .LeftSquare => {
+                _ = try self.consumeSingle(.LeftSquare);
+
+                var exprs = ast.ExprList.init(self.allocator);
+                errdefer exprs.deinit();
+
+                while (!self.check(.RightSquare)) {
+                    try exprs.append(try self.parseExpr());
+                    if (self.check(.Comma)) _ = try self.consumeSingle(.Comma);
+                }
+
+                _ = try self.consumeSingle(.RightSquare);
+                return try self.mkArray(exprs);
+            },
+
+            .LeftParen => {
                 _ = try self.nextToken();
                 var expr = try self.parseExpr();
                 _ = try self.consume(.RightParen, "Expected ')' after expression");