std.zig.parser understands try. zig fmt respects a double line break.

ziglang · Feb 15, 2018 · ca597e2 · ca597e2
1 parent 9fa35ad
commit ca597e2
Show file tree

Hide file tree

Showing 6 changed files with 296 additions and 40 deletions.
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
@@ -125,7 +125,6 @@ static const struct ZigKeyword zig_keywords[] = {
     {"false", TokenIdKeywordFalse},
     {"fn", TokenIdKeywordFn},
     {"for", TokenIdKeywordFor},
-    {"goto", TokenIdKeywordGoto},
     {"if", TokenIdKeywordIf},
     {"inline", TokenIdKeywordInline},
     {"nakedcc", TokenIdKeywordNakedCC},
@@ -1542,7 +1541,6 @@ const char * token_name(TokenId id) {
         case TokenIdKeywordFalse: return "false";
         case TokenIdKeywordFn: return "fn";
         case TokenIdKeywordFor: return "for";
-        case TokenIdKeywordGoto: return "goto";
         case TokenIdKeywordIf: return "if";
         case TokenIdKeywordInline: return "inline";
         case TokenIdKeywordNakedCC: return "nakedcc";

diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
@@ -66,7 +66,6 @@ enum TokenId {
     TokenIdKeywordFalse,
     TokenIdKeywordFn,
     TokenIdKeywordFor,
-    TokenIdKeywordGoto,
     TokenIdKeywordIf,
     TokenIdKeywordInline,
     TokenIdKeywordNakedCC,

diff --git a/std/debug/index.zig b/std/debug/index.zig
@@ -47,7 +47,7 @@ pub fn getSelfDebugInfo() !&ElfStackTrace {
 pub fn dumpCurrentStackTrace() void {
     const stderr = getStderrStream() catch return;
     const debug_info = getSelfDebugInfo() catch |err| {
-        stderr.print("Unable to open debug info: {}\n", @errorName(err)) catch return;
+        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
         return;
     };
     defer debug_info.close();
@@ -61,7 +61,7 @@ pub fn dumpCurrentStackTrace() void {
 pub fn dumpStackTrace(stack_trace: &const builtin.StackTrace) void {
     const stderr = getStderrStream() catch return;
     const debug_info = getSelfDebugInfo() catch |err| {
-        stderr.print("Unable to open debug info: {}\n", @errorName(err)) catch return;
+        stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
         return;
     };
     defer debug_info.close();

diff --git a/std/zig/ast.zig b/std/zig/ast.zig
@@ -38,18 +38,61 @@ pub const Node = struct {
             Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).iterate(index),
         };
     }
+
+    pub fn firstToken(base: &Node) Token {
+        return switch (base.id) {
+            Id.Root => @fieldParentPtr(NodeRoot, "base", base).firstToken(),
+            Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).firstToken(),
+            Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).firstToken(),
+            Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).firstToken(),
+            Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).firstToken(),
+            Id.Block => @fieldParentPtr(NodeBlock, "base", base).firstToken(),
+            Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).firstToken(),
+            Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).firstToken(),
+            Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).firstToken(),
+            Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).firstToken(),
+            Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).firstToken(),
+            Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).firstToken(),
+        };
+    }
+
+    pub fn lastToken(base: &Node) Token {
+        return switch (base.id) {
+            Id.Root => @fieldParentPtr(NodeRoot, "base", base).lastToken(),
+            Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).lastToken(),
+            Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).lastToken(),
+            Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).lastToken(),
+            Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).lastToken(),
+            Id.Block => @fieldParentPtr(NodeBlock, "base", base).lastToken(),
+            Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).lastToken(),
+            Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).lastToken(),
+            Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).lastToken(),
+            Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).lastToken(),
+            Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).lastToken(),
+            Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).lastToken(),
+        };
+    }
 };
 
 pub const NodeRoot = struct {
     base: Node,
     decls: ArrayList(&Node),
+    eof_token: Token,
 
     pub fn iterate(self: &NodeRoot, index: usize) ?&Node {
         if (index < self.decls.len) {
             return self.decls.items[self.decls.len - index - 1];
         }
         return null;
     }
+
+    pub fn firstToken(self: &NodeRoot) Token {
+        return if (self.decls.len == 0) self.eof_token else self.decls.at(0).firstToken();
+    }
+
+    pub fn lastToken(self: &NodeRoot) Token {
+        return if (self.decls.len == 0) self.eof_token else self.decls.at(self.decls.len - 1).lastToken();
+    }
 };
 
 pub const NodeVarDecl = struct {
@@ -64,6 +107,7 @@ pub const NodeVarDecl = struct {
     type_node: ?&Node,
     align_node: ?&Node,
     init_node: ?&Node,
+    semicolon_token: Token,
 
     pub fn iterate(self: &NodeVarDecl, index: usize) ?&Node {
         var i = index;
@@ -85,6 +129,18 @@ pub const NodeVarDecl = struct {
 
         return null;
     }
+
+    pub fn firstToken(self: &NodeVarDecl) Token {
+        if (self.visib_token) |visib_token| return visib_token;
+        if (self.comptime_token) |comptime_token| return comptime_token;
+        if (self.extern_token) |extern_token| return extern_token;
+        assert(self.lib_name == null);
+        return self.mut_token;
+    }
+
+    pub fn lastToken(self: &NodeVarDecl) Token {
+        return self.semicolon_token;
+    }
 };
 
 pub const NodeIdentifier = struct {
@@ -94,6 +150,14 @@ pub const NodeIdentifier = struct {
     pub fn iterate(self: &NodeIdentifier, index: usize) ?&Node {
         return null;
     }
+
+    pub fn firstToken(self: &NodeIdentifier) Token {
+        return self.name_token;
+    }
+
+    pub fn lastToken(self: &NodeIdentifier) Token {
+        return self.name_token;
+    }
 };
 
 pub const NodeFnProto = struct {
@@ -113,7 +177,7 @@ pub const NodeFnProto = struct {
 
     pub const ReturnType = union(enum) {
         Explicit: &Node,
-        Infer,
+        Infer: Token,
         InferErrorSet: &Node,
     };
 
@@ -153,6 +217,25 @@ pub const NodeFnProto = struct {
 
         return null;
     }
+
+    pub fn firstToken(self: &NodeFnProto) Token {
+        if (self.visib_token) |visib_token| return visib_token;
+        if (self.extern_token) |extern_token| return extern_token;
+        assert(self.lib_name == null);
+        if (self.inline_token) |inline_token| return inline_token;
+        if (self.cc_token) |cc_token| return cc_token;
+        return self.fn_token;
+    }
+
+    pub fn lastToken(self: &NodeFnProto) Token {
+        if (self.body_node) |body_node| return body_node.lastToken();
+        switch (self.return_type) {
+            // TODO allow this and next prong to share bodies since the types are the same
+            ReturnType.Explicit => |node| return node.lastToken(),
+            ReturnType.InferErrorSet => |node| return node.lastToken(),
+            ReturnType.Infer => |token| return token,
+        }
+    }
 };
 
 pub const NodeParamDecl = struct {
@@ -171,6 +254,18 @@ pub const NodeParamDecl = struct {
 
         return null;
     }
+
+    pub fn firstToken(self: &NodeParamDecl) Token {
+        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();
+    }
+
+    pub fn lastToken(self: &NodeParamDecl) Token {
+        if (self.var_args_token) |var_args_token| return var_args_token;
+        return self.type_node.lastToken();
+    }
 };
 
 pub const NodeBlock = struct {
@@ -187,6 +282,14 @@ pub const NodeBlock = struct {
 
         return null;
     }
+
+    pub fn firstToken(self: &NodeBlock) Token {
+        return self.begin_token;
+    }
+
+    pub fn lastToken(self: &NodeBlock) Token {
+        return self.end_token;
+    }
 };
 
 pub const NodeInfixOp = struct {
@@ -199,6 +302,7 @@ pub const NodeInfixOp = struct {
     const InfixOp = enum {
         EqualEqual,
         BangEqual,
+        Period,
     };
 
     pub fn iterate(self: &NodeInfixOp, index: usize) ?&Node {
@@ -208,15 +312,24 @@ pub const NodeInfixOp = struct {
         i -= 1;
 
         switch (self.op) {
-            InfixOp.EqualEqual => {},
-            InfixOp.BangEqual => {},
+            InfixOp.EqualEqual,
+            InfixOp.BangEqual,
+            InfixOp.Period => {},
         }
 
         if (i < 1) return self.rhs;
         i -= 1;
 
         return null;
     }
+
+    pub fn firstToken(self: &NodeInfixOp) Token {
+        return self.lhs.firstToken();
+    }
+
+    pub fn lastToken(self: &NodeInfixOp) Token {
+        return self.rhs.lastToken();
+    }
 };
 
 pub const NodePrefixOp = struct {
@@ -227,6 +340,7 @@ pub const NodePrefixOp = struct {
 
     const PrefixOp = union(enum) {
         Return,
+        Try,
         AddrOf: AddrOfInfo,
     };
     const AddrOfInfo = struct {
@@ -241,7 +355,8 @@ pub const NodePrefixOp = struct {
         var i = index;
 
         switch (self.op) {
-            PrefixOp.Return => {},
+            PrefixOp.Return,
+            PrefixOp.Try => {},
             PrefixOp.AddrOf => |addr_of_info| {
                 if (addr_of_info.align_expr) |align_expr| {
                     if (i < 1) return align_expr;
@@ -255,6 +370,14 @@ pub const NodePrefixOp = struct {
 
         return null;
     }
+
+    pub fn firstToken(self: &NodePrefixOp) Token {
+        return self.op_token;
+    }
+
+    pub fn lastToken(self: &NodePrefixOp) Token {
+        return self.rhs.lastToken();
+    }
 };
 
 pub const NodeIntegerLiteral = struct {
@@ -264,6 +387,14 @@ pub const NodeIntegerLiteral = struct {
     pub fn iterate(self: &NodeIntegerLiteral, index: usize) ?&Node {
         return null;
     }
+
+    pub fn firstToken(self: &NodeIntegerLiteral) Token {
+        return self.token;
+    }
+
+    pub fn lastToken(self: &NodeIntegerLiteral) Token {
+        return self.token;
+    }
 };
 
 pub const NodeFloatLiteral = struct {
@@ -273,12 +404,21 @@ pub const NodeFloatLiteral = struct {
     pub fn iterate(self: &NodeFloatLiteral, index: usize) ?&Node {
         return null;
     }
+
+    pub fn firstToken(self: &NodeFloatLiteral) Token {
+        return self.token;
+    }
+
+    pub fn lastToken(self: &NodeFloatLiteral) Token {
+        return self.token;
+    }
 };
 
 pub const NodeBuiltinCall = struct {
     base: Node,
     builtin_token: Token,
     params: ArrayList(&Node),
+    rparen_token: Token,
 
     pub fn iterate(self: &NodeBuiltinCall, index: usize) ?&Node {
         var i = index;
@@ -288,6 +428,14 @@ pub const NodeBuiltinCall = struct {
 
         return null;
     }
+
+    pub fn firstToken(self: &NodeBuiltinCall) Token {
+        return self.builtin_token;
+    }
+
+    pub fn lastToken(self: &NodeBuiltinCall) Token {
+        return self.rparen_token;
+    }
 };
 
 pub const NodeStringLiteral = struct {
@@ -297,4 +445,12 @@ pub const NodeStringLiteral = struct {
     pub fn iterate(self: &NodeStringLiteral, index: usize) ?&Node {
         return null;
     }
+
+    pub fn firstToken(self: &NodeStringLiteral) Token {
+        return self.token;
+    }
+
+    pub fn lastToken(self: &NodeStringLiteral) Token {
+        return self.token;
+    }
 };