Commit a05011d403

@@ -986,14 +986,22 @@ pub const Node = struct {
         comptime_token: ?TokenIndex,
         noalias_token: ?TokenIndex,
         name_token: ?TokenIndex,
-        type_node: *Node,
-        var_args_token: ?TokenIndex,
+        param_type: ParamType,
+
+        pub const ParamType = union(enum) {
+            var_type: *Node,
+            var_args: TokenIndex,
+            type_expr: *Node,
+        };
 
         pub fn iterate(self: *ParamDecl, index: usize) ?*Node {
             var i = index;
 
             if (i < 1) {
-                return if (self.var_args_token == null) self.type_node else null;
+                switch (self.param_type) {
+                    .var_args => return null,
+                    .var_type, .type_expr => |node| return node,
+                }
             }
             i -= 1;
 
@@ -1004,12 +1012,17 @@ pub const Node = struct {
             if (self.comptime_token) |comptime_token| return comptime_token;
             if (self.noalias_token) |noalias_token| return noalias_token;
             if (self.name_token) |name_token| return name_token;
-            return self.type_node.firstToken();
+            switch (self.param_type) {
+                .var_args => |tok| return tok,
+                .var_type, .type_expr => |node| return node.firstToken(),
+            }
         }
 
         pub fn lastToken(self: *const ParamDecl) TokenIndex {
-            if (self.var_args_token) |var_args_token| return var_args_token;
-            return self.type_node.lastToken();
+            switch (self.param_type) {
+                .var_args => |tok| return tok,
+                .var_type, .type_expr => |node| return node.lastToken(),
+            }
         }
     };
 

@@ -510,9 +510,10 @@ fn parseFnProto(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     else
         R{ .Explicit = return_type_expr.? };
 
-    const var_args_token = if (params.len > 0)
-        params.at(params.len - 1).*.cast(Node.ParamDecl).?.var_args_token
-    else
+    const var_args_token = if (params.len > 0) blk: {
+        const param_type = params.at(params.len - 1).*.cast(Node.ParamDecl).?.param_type;
+        break :blk if (param_type == .var_args) param_type.var_args else null;
+    } else
         null;
 
     const fn_proto_node = try arena.create(Node.FnProto);
@@ -1939,15 +1940,8 @@ fn parseParamDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
         .comptime_token = comptime_token,
         .noalias_token = noalias_token,
         .name_token = name_token,
-        // TODO: These should be squished into a ParamType enum
-        .type_node = undefined,
-        .var_args_token = null,
+        .param_type = param_type,
     };
-    switch (param_type) {
-        .VarType => |node| param_decl.type_node = node,
-        .TypeExpr => |node| param_decl.type_node = node,
-        .VarArgs => |token| param_decl.var_args_token = token,
-    }
     return &param_decl.base;
 }
 
@@ -1955,20 +1949,15 @@ fn parseParamDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
 ///     <- KEYWORD_var
 ///      / DOT3
 ///      / TypeExpr
-fn parseParamType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?ParamType {
-    if (try parseVarType(arena, it, tree)) |node| return ParamType{ .VarType = node };
-    if (eatToken(it, .Ellipsis3)) |token| return ParamType{ .VarArgs = token };
-    if (try parseTypeExpr(arena, it, tree)) |node| return ParamType{ .TypeExpr = node };
+fn parseParamType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?Node.ParamDecl.ParamType {
+    // TODO cast from tuple to error union is broken
+    const P = Node.ParamDecl.ParamType;
+    if (try parseVarType(arena, it, tree)) |node| return P{ .var_type = node };
+    if (eatToken(it, .Ellipsis3)) |token| return P{ .var_args = token };
+    if (try parseTypeExpr(arena, it, tree)) |node| return P{ .type_expr = node };
     return null;
 }
 
-// TODO: Move to ast.Node.ParamDecl.ParamType
-const ParamType = union(enum) {
-    VarType: *Node,
-    VarArgs: TokenIndex,
-    TypeExpr: *Node,
-};
-
 /// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
 fn parseIfPrefix(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     const if_token = eatToken(it, .Keyword_if) orelse return null;

@@ -2150,10 +2150,9 @@ fn renderParamDecl(
         try renderToken(tree, stream, name_token, indent, start_col, Space.None);
         try renderToken(tree, stream, tree.nextToken(name_token), indent, start_col, Space.Space); // :
     }
-    if (param_decl.var_args_token) |var_args_token| {
-        try renderToken(tree, stream, var_args_token, indent, start_col, space);
-    } else {
-        try renderExpression(allocator, stream, tree, indent, start_col, param_decl.type_node, space);
+    switch (param_decl.param_type) {
+        .var_args => |token|  try renderToken(tree, stream, token, indent, start_col, space),
+        .var_type, .type_expr => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, space),
     }
 }