Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

move ParamType to Node.ParamDecl

Browse Source
This commit is contained in:
Vexu 2020-05-16 12:54:51 +03:00
parent ed62081d38
commit a05011d403
No known key found for this signature in database
GPG Key ID: 59AEB8936E16A6AC
3 changed files with 33 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
lib/std/zig/ast.zig
View File

@ -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(),
}
}
};

33
lib/std/zig/parse.zig
View File

@ -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;

7
lib/std/zig/render.zig
View File

@ -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),
}
}