From d602f12df8f12c3a363abec8c1976f8bc84eb2be Mon Sep 17 00:00:00 2001
From: Jimmi Holst Christensen <jhc@liab.dk>
Date: Tue, 3 Apr 2018 15:59:14 +0200
Subject: [PATCH] std.zig.ast Added ContainerDecl

---
 std/zig/ast.zig    | 69 +++++++++++++++++++++++++++++++++++++++++++++-
 std/zig/parser.zig |  4 +++
 2 files changed, 72 insertions(+), 1 deletion(-)

diff --git a/std/zig/ast.zig b/std/zig/ast.zig
index 32a8a7f110..767a797cab 100644
--- a/std/zig/ast.zig
+++ b/std/zig/ast.zig
@@ -11,6 +11,7 @@ pub const Node = struct {
     pub const Id = enum {
         Root,
         VarDecl,
+        ContainerDecl,
         Identifier,
         FnProto,
         ParamDecl,
@@ -40,6 +41,7 @@ pub const Node = struct {
         return switch (base.id) {
             Id.Root => @fieldParentPtr(NodeRoot, "base", base).iterate(index),
             Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).iterate(index),
+            Id.ContainerDecl => @fieldParentPtr(NodeContainerDecl, "base", base).iterate(index),
             Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).iterate(index),
             Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).iterate(index),
             Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).iterate(index),
@@ -70,6 +72,7 @@ pub const Node = struct {
         return switch (base.id) {
             Id.Root => @fieldParentPtr(NodeRoot, "base", base).firstToken(),
             Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).firstToken(),
+            Id.ContainerDecl => @fieldParentPtr(NodeContainerDecl, "base", base).firstToken(),
             Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).firstToken(),
             Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).firstToken(),
             Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).firstToken(),
@@ -100,6 +103,7 @@ pub const Node = struct {
         return switch (base.id) {
             Id.Root => @fieldParentPtr(NodeRoot, "base", base).lastToken(),
             Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).lastToken(),
+            Id.ContainerDecl => @fieldParentPtr(NodeContainerDecl, "base", base).lastToken(),
             Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).lastToken(),
             Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).lastToken(),
             Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).lastToken(),
@@ -196,6 +200,69 @@ pub const NodeVarDecl = struct {
     }
 };
 
+pub const NodeContainerDecl = struct {
+    base: Node,
+    kind_token: Token,
+    init_arg_expr: InitArg,
+    kind: Kind,
+    decls: ArrayList(&Node),
+    rbrace_token: Token,
+
+    // TODO: Different array lists for each kind.
+    const Kind = union(enum) {
+        Struct: ArrayList(&Node),
+        Enum: ArrayList(&Node),
+        Union: ArrayList(&Node),
+    };
+
+    const InitArg = union(enum) {
+        None,
+        Enum,
+        Type: &Node,
+    };
+
+    pub fn iterate(self: &NodeContainerDecl, index: usize) ?&Node {
+        var i = index;
+
+        switch (self.init_arg_expr) {
+            InitArg.Type => |t| {
+                if (i < 1) return t;
+                i -= 1;
+            },
+            InitArg.None,
+            InitArg.Enum => { }
+        }
+
+        if (i < self.decls.len) return self.decls.at(i);
+        i -= self.decls.len;
+
+        switch (self.kind) {
+            Kind.Struct => |fields| {
+                if (i < fields.len) return fields.at(i);
+                i -= fields.len;
+            },
+            Kind.Enum => |tags| {
+                if (i < tags.len) return tags.at(i);
+                i -= tags.len;
+            },
+            Kind.Union => |tags| {
+                if (i < tags.len) return tags.at(i);
+                i -= tags.len;
+            },
+        }
+
+        return null;
+    }
+
+    pub fn firstToken(self: &NodeContainerDecl) Token {
+        return self.kind_token;
+    }
+
+    pub fn lastToken(self: &NodeContainerDecl) Token {
+        return self.rbrace_token;
+    }
+};
+
 pub const NodeIdentifier = struct {
     base: Node,
     name_token: Token,
@@ -611,7 +678,7 @@ pub const NodeSuffixOp = struct {
                 i -= exprs.len;
             },
             SuffixOp.StructInitializer => |fields| {
-                if (i < fields.len) return fields.at(i);
+                if (i < fields.len) return &fields.at(i).base;
                 i -= fields.len;
             },
         }
diff --git a/std/zig/parser.zig b/std/zig/parser.zig
index 99ea89bf97..0b4e55913c 100644
--- a/std/zig/parser.zig
+++ b/std/zig/parser.zig
@@ -1806,6 +1806,10 @@ pub const Parser = struct {
                         try stack.append(RenderState { .Expression = grouped_expr.expr });
                         try stack.append(RenderState { .Text = "("});
                     },
+                    ast.Node.Id.ContainerDecl => {
+                        const container_decl = @fieldParentPtr(ast.NodeGroupedExpression, "base", base);
+                        @panic("TODO: ContainerDecl");
+                    },
                     ast.Node.Id.FieldInitializer => {
                         const field_init = @fieldParentPtr(ast.NodeFieldInitializer, "base", base);
                         try stream.print(".{} = ", self.tokenizer.getTokenSlice(field_init.name_token));