From a706f077cbfc0f73e2a79ce03d5af5bce2bb3cd2 Mon Sep 17 00:00:00 2001
From: Luna <git@l4.pm>
Date: Mon, 26 Aug 2019 21:31:01 -0300
Subject: [PATCH] add pub/mut modifiers to struct fields

---
 src/ast.zig    |  6 ++++--
 src/parser.zig | 33 ++++++++++++++++++++++++++++++---
 2 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/src/ast.zig b/src/ast.zig
index 91a045d..baa49eb 100644
--- a/src/ast.zig
+++ b/src/ast.zig
@@ -227,8 +227,10 @@ pub const FieldList = std.ArrayList(StructField);
 pub const StructField = struct {
     name: Token,
     typ: Token,
-    mutable: bool = true,
-    public: bool = true,
+
+    mutable: bool = false,
+    public: bool = false,
+    mutable_outside: bool = false,
 };
 
 pub const Struct = struct {
diff --git a/src/parser.zig b/src/parser.zig
index 02e9d22..a9b63c3 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -18,6 +18,12 @@ const Stmt = ast.Stmt;
 
 const TokenList = std.ArrayList(Token);
 
+const FieldState = struct {
+    public: bool = false,
+    mutable: bool = false,
+    mutable_outside: bool = false,
+};
+
 pub const Parser = struct {
     allocator: *Allocator,
     scanner: *Scanner,
@@ -405,8 +411,6 @@ pub const Parser = struct {
 
         while (self.peek().ttype != .RightParen) {
             const param_name = try self.consumeSingle(.Identifier);
-
-            // TODO dedicated function to consume a type?
             const param_type = try self.consumeSingle(.Identifier);
 
             try param_list.append(ast.ParamDecl{
@@ -495,14 +499,37 @@ pub const Parser = struct {
 
         _ = try self.consumeSingle(.LeftBrace);
 
+        var field_state = FieldState{};
+
         while (!self.check(.RightBrace)) {
-            // TODO mut and pub
+            if (self.check(.Mut)) {
+                _ = try self.consumeSingle(.Mut);
+                _ = try self.consumeSingle(.Colon);
+                if (field_state.mutable) {
+                    field_state.mutable_outside = true;
+                } else {
+                    field_state.mutable = true;
+                }
+            } else if (self.check(.Pub)) {
+                _ = try self.consumeSingle(.Pub);
+                _ = try self.consumeSingle(.Colon);
+                field_state.public = true;
+            }
+
             const field_name = try self.consumeSingle(.Identifier);
             const field_type = try self.consumeSingle(.Identifier);
 
+            // we could create a FieldState on the heap and copy our current
+            // field state into a StructField.state, but copying via this makes
+            // things so much nicer.
+
             try fields.append(ast.StructField{
                 .name = field_name,
                 .typ = field_type,
+
+                .mutable = field_state.mutable,
+                .public = field_state.public,
+                .mutable_outside = field_state.mutable_outside,
             });
         }