authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-05-16 12:54:51+03:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-05-16 12:54:51+03:00
loga05011d403d084d75b3a3d8a5a38fa0a4bfe3380
tree003db1d9a48c615a9e50e691db982428eb58dc76
parented62081d38736b2fabb3949fa821af2cf03dbe6e
signature Commit is signed but in an unrecognized format.

move ParamType to Node.ParamDecl

3 files changed, 33 insertions(+), 32 deletions(-)

lib/std/zig/ast.zig+19-6
......@@ -986,14 +986,22 @@ pub const Node = struct {
986986 comptime_token: ?TokenIndex,
987987 noalias_token: ?TokenIndex,
988988 name_token: ?TokenIndex,
989 type_node: *Node,
990 var_args_token: ?TokenIndex,
989 param_type: ParamType,
990
991 pub const ParamType = union(enum) {
992 var_type: *Node,
993 var_args: TokenIndex,
994 type_expr: *Node,
995 };
991996
992997 pub fn iterate(self: *ParamDecl, index: usize) ?*Node {
993998 var i = index;
994999
9951000 if (i < 1) {
996 return if (self.var_args_token == null) self.type_node else null;
1001 switch (self.param_type) {
1002 .var_args => return null,
1003 .var_type, .type_expr => |node| return node,
1004 }
9971005 }
9981006 i -= 1;
9991007
......@@ -1004,12 +1012,17 @@ pub const Node = struct {
10041012 if (self.comptime_token) |comptime_token| return comptime_token;
10051013 if (self.noalias_token) |noalias_token| return noalias_token;
10061014 if (self.name_token) |name_token| return name_token;
1007 return self.type_node.firstToken();
1015 switch (self.param_type) {
1016 .var_args => |tok| return tok,
1017 .var_type, .type_expr => |node| return node.firstToken(),
1018 }
10081019 }
10091020
10101021 pub fn lastToken(self: *const ParamDecl) TokenIndex {
1011 if (self.var_args_token) |var_args_token| return var_args_token;
1012 return self.type_node.lastToken();
1022 switch (self.param_type) {
1023 .var_args => |tok| return tok,
1024 .var_type, .type_expr => |node| return node.lastToken(),
1025 }
10131026 }
10141027 };
10151028
lib/std/zig/parse.zig+11-22
......@@ -510,9 +510,10 @@ fn parseFnProto(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
510510 else
511511 R{ .Explicit = return_type_expr.? };
512512
513 const var_args_token = if (params.len > 0)
514 params.at(params.len - 1).*.cast(Node.ParamDecl).?.var_args_token
515 else
513 const var_args_token = if (params.len > 0) blk: {
514 const param_type = params.at(params.len - 1).*.cast(Node.ParamDecl).?.param_type;
515 break :blk if (param_type == .var_args) param_type.var_args else null;
516 } else
516517 null;
517518
518519 const fn_proto_node = try arena.create(Node.FnProto);
......@@ -1939,15 +1940,8 @@ fn parseParamDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19391940 .comptime_token = comptime_token,
19401941 .noalias_token = noalias_token,
19411942 .name_token = name_token,
1942 // TODO: These should be squished into a ParamType enum
1943 .type_node = undefined,
1944 .var_args_token = null,
1943 .param_type = param_type,
19451944 };
1946 switch (param_type) {
1947 .VarType => |node| param_decl.type_node = node,
1948 .TypeExpr => |node| param_decl.type_node = node,
1949 .VarArgs => |token| param_decl.var_args_token = token,
1950 }
19511945 return &param_decl.base;
19521946}
19531947
......@@ -1955,20 +1949,15 @@ fn parseParamDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19551949/// <- KEYWORD_var
19561950/// / DOT3
19571951/// / TypeExpr
1958fn parseParamType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?ParamType {
1959 if (try parseVarType(arena, it, tree)) |node| return ParamType{ .VarType = node };
1960 if (eatToken(it, .Ellipsis3)) |token| return ParamType{ .VarArgs = token };
1961 if (try parseTypeExpr(arena, it, tree)) |node| return ParamType{ .TypeExpr = node };
1952fn parseParamType(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?Node.ParamDecl.ParamType {
1953 // TODO cast from tuple to error union is broken
1954 const P = Node.ParamDecl.ParamType;
1955 if (try parseVarType(arena, it, tree)) |node| return P{ .var_type = node };
1956 if (eatToken(it, .Ellipsis3)) |token| return P{ .var_args = token };
1957 if (try parseTypeExpr(arena, it, tree)) |node| return P{ .type_expr = node };
19621958 return null;
19631959}
19641960
1965// TODO: Move to ast.Node.ParamDecl.ParamType
1966const ParamType = union(enum) {
1967 VarType: *Node,
1968 VarArgs: TokenIndex,
1969 TypeExpr: *Node,
1970};
1971
19721961/// IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
19731962fn parseIfPrefix(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
19741963 const if_token = eatToken(it, .Keyword_if) orelse return null;
lib/std/zig/render.zig+3-4
......@@ -2150,10 +2150,9 @@ fn renderParamDecl(
21502150 try renderToken(tree, stream, name_token, indent, start_col, Space.None);
21512151 try renderToken(tree, stream, tree.nextToken(name_token), indent, start_col, Space.Space); // :
21522152 }
2153 if (param_decl.var_args_token) |var_args_token| {
2154 try renderToken(tree, stream, var_args_token, indent, start_col, space);
2155 } else {
2156 try renderExpression(allocator, stream, tree, indent, start_col, param_decl.type_node, space);
2153 switch (param_decl.param_type) {
2154 .var_args => |token| try renderToken(tree, stream, token, indent, start_col, space),
2155 .var_type, .type_expr => |node| try renderExpression(allocator, stream, tree, indent, start_col, node, space),
21572156 }
21582157}
21592158