wip tryreturn

See #340

Author: andrewrk

README.md

@@ -16,9 +16,9 @@ Zig instead of e.g. cmake.
 
  * Compatible with C libraries with no wrapper necessary. Directly include
    C .h files and get access to the functions and symbols therein.
- * Compile units do not depend on libc unless explicitly linked.
  * Provides standard library which competes with the C standard library and is
-   always compiled against statically in source form.
+   always compiled against statically in source form. Compile units do not
+   depend on libc unless explicitly linked.
  * Nullable type instead of null pointers.
  * Tagged union type instead of raw unions.
  * Generics so that one can write efficient data structures that work for any
@@ -45,12 +45,12 @@ Zig instead of e.g. cmake.
  * Zig Build System competes with make, cmake, autotools, SCons, etc.
  * In addition to creating executables, creating a C library is a primary use
    case. You can export an auto-generated .h file.
- * Standard library supports OS abstractions for:
+ * Standard library supports Operating System abstractions for:
    * `x86_64` `linux`
    * Support for all popular operating systems and architectures is planned.
- * For Operating System development, Zig supports all architectures that LLVM
-   does. All the standard library that does not depend on an OS is available
-   to you in freestanding mode.
+ * For OS development, Zig supports all architectures that LLVM does. All the
+   standard library that does not depend on an OS is available to you in
+   freestanding mode.
 
 ## Community
 

doc/langref.md

@@ -45,7 +45,7 @@ TypeExpr = PrefixOpExpression | "var"
 
 BlockOrExpression = Block | Expression
 
-Expression = ReturnExpression | AssignmentExpression
+Expression = "return" option(Expression) | AssignmentExpression
 
 AsmExpression = "asm" option("volatile") "(" String option(AsmOutput) ")"
 
@@ -85,8 +85,6 @@ ForExpression(body) = "for" "(" Expression ")" option("|" option("*") Symbol opt
 
 BoolOrExpression = BoolAndExpression "or" BoolOrExpression | BoolAndExpression
 
-ReturnExpression = option("%") "return" option(Expression)
-
 Defer(body) = option("%") "defer" body
 
 IfExpression(body) = "if" "(" Expression ")" body option("else" BlockExpression(body))
@@ -141,7 +139,7 @@ ContainerInitBody = list(StructLiteralField, ",") | list(Expression, ",")
 
 StructLiteralField = "." Symbol "=" Expression
 
-PrefixOp = "!" | "-" | "~" | "*" | ("&" option("const") option("volatile")) | "?" | "%" | "%%" | "??" | "-%"
+PrefixOp = "!" | "-" | "~" | "*" | ("&" option("const") option("volatile")) | "?" | "%" | "%%" | "??" | "-%" | "tryreturn"
 
 PrimaryExpression = Number | String | CharLiteral | KeywordLiteral | GroupedExpression | GotoExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | (option("extern") FnProto) | AsmExpression | ("error" "." Symbol) | ContainerDecl
 
@@ -161,7 +159,7 @@ ContainerDecl = option("extern" | "packed") ("struct" | "enum" | "union") "{" ma
 ```
 inline x
 x() x[] x.y
-!x -x -%x ~x *x &x ?x %x %%x ??x
+!x -x -%x ~x *x &x ?x %x %%x ??x tryreturn x
 x{}
 * / % ** *%
 + - ++ +% -%

example/cat/main.zig

@@ -11,7 +11,7 @@ pub fn main() -> %void {
         const arg = os.args.at(arg_i);
         if (mem.eql(u8, arg, "-")) {
             catted_anything = true;
-            %return cat_stream(&io.stdin);
+            tryreturn cat_stream(&io.stdin);
         } else if (arg[0] == '-') {
             return usage(exe);
         } else {
@@ -22,13 +22,13 @@ pub fn main() -> %void {
             defer is.close();
 
             catted_anything = true;
-            %return cat_stream(&is);
+            tryreturn cat_stream(&is);
         }
     }
     if (!catted_anything) {
-        %return cat_stream(&io.stdin);
+        tryreturn cat_stream(&io.stdin);
     }
-    %return io.stdout.flush();
+    tryreturn io.stdout.flush();
 }
 
 fn usage(exe: []const u8) -> %void {

src/all_types.hpp

@@ -414,15 +414,8 @@ struct AstNodeBlock {
     bool last_statement_is_result_expression;
 };
 
-enum ReturnKind {
-    ReturnKindUnconditional,
-    ReturnKindError,
-};
-
 struct AstNodeReturnExpr {
-    ReturnKind kind;
-    // might be null in case of return void;
-    AstNode *expr;
+    AstNode *expr; // might be null
 };
 
 struct AstNodeDefer {
@@ -562,6 +555,7 @@ enum PrefixOp {
     PrefixOpError,
     PrefixOpUnwrapError,
     PrefixOpUnwrapMaybe,
+    PrefixOpTryReturn,
 };
 
 struct AstNodePrefixOpExpr {

src/ast_render.cpp

@@ -75,6 +75,7 @@ static const char *prefix_op_str(PrefixOp prefix_op) {
         case PrefixOpError: return "%";
         case PrefixOpUnwrapError: return "%%";
         case PrefixOpUnwrapMaybe: return "??";
+        case PrefixOpTryReturn: return "tryreturn ";
     }
     zig_unreachable();
 }
@@ -91,7 +92,7 @@ static const char *visib_mod_string(VisibMod mod) {
 static const char *return_string(ReturnKind kind) {
     switch (kind) {
         case ReturnKindUnconditional: return "return";
-        case ReturnKindError: return "%return";
+        case ReturnKindError: return "tryreturn";
     }
     zig_unreachable();
 }

src/parser.cpp

@@ -220,7 +220,6 @@ static AstNode *ast_parse_block_expr(ParseContext *pc, size_t *token_index, bool
 static AstNode *ast_parse_unwrap_expr(ParseContext *pc, size_t *token_index, bool mandatory);
 static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, size_t *token_index, bool mandatory);
 static AstNode *ast_parse_fn_proto(ParseContext *pc, size_t *token_index, bool mandatory, VisibMod visib_mod);
-static AstNode *ast_parse_return_expr(ParseContext *pc, size_t *token_index);
 static AstNode *ast_parse_grouped_expr(ParseContext *pc, size_t *token_index, bool mandatory);
 static AstNode *ast_parse_container_decl(ParseContext *pc, size_t *token_index, bool mandatory);
 
@@ -1063,6 +1062,7 @@ static PrefixOp tok_to_prefix_op(Token *token) {
         case TokenIdPercentPercent: return PrefixOpUnwrapError;
         case TokenIdDoubleQuestion: return PrefixOpUnwrapMaybe;
         case TokenIdStarStar: return PrefixOpDereference;
+        case TokenIdTryReturn: return PrefixOpTryReturn;
         default: return PrefixOpInvalid;
     }
 }
@@ -1078,13 +1078,6 @@ static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, size_t *token_index,
         return ast_parse_suffix_op_expr(pc, token_index, mandatory);
     }
 
-    if (prefix_op == PrefixOpError || prefix_op == PrefixOpMaybe) {
-        Token *maybe_return = &pc->tokens->at(*token_index + 1);
-        if (maybe_return->id == TokenIdKeywordReturn) {
-            return ast_parse_return_expr(pc, token_index);
-        }
-    }
-
     *token_index += 1;
 
 
@@ -1464,33 +1457,15 @@ static AstNode *ast_parse_if_expr(ParseContext *pc, size_t *token_index, bool ma
 }
 
 /*
-ReturnExpression : option("%") "return" option(Expression)
+ReturnExpression = "return" option(Expression)
 */
 static AstNode *ast_parse_return_expr(ParseContext *pc, size_t *token_index) {
     Token *token = &pc->tokens->at(*token_index);
-
-    NodeType node_type;
-    ReturnKind kind;
-
-    if (token->id == TokenIdPercent) {
-        Token *next_token = &pc->tokens->at(*token_index + 1);
-        if (next_token->id == TokenIdKeywordReturn) {
-            kind = ReturnKindError;
-            node_type = NodeTypeReturnExpr;
-            *token_index += 2;
-        } else {
-            return nullptr;
-        }
-    } else if (token->id == TokenIdKeywordReturn) {
-        kind = ReturnKindUnconditional;
-        node_type = NodeTypeReturnExpr;
-        *token_index += 1;
-    } else {
+    if (token->id != TokenIdKeywordReturn)
         return nullptr;
-    }
+    *token_index += 1;
 
-    AstNode *node = ast_create_node(pc, node_type, token);
-    node->data.return_expr.kind = kind;
+    AstNode *node = ast_create_node(pc, NodeTypeReturnExpr, token);
     node->data.return_expr.expr = ast_parse_expression(pc, token_index, false);
 
     return node;
@@ -2010,7 +1985,7 @@ static AstNode *ast_parse_block_or_expression(ParseContext *pc, size_t *token_in
 }
 
 /*
-Expression = ReturnExpression | AssignmentExpression
+Expression = "return" option(Expression) | AssignmentExpression
 */
 static AstNode *ast_parse_expression(ParseContext *pc, size_t *token_index, bool mandatory) {
     Token *token = &pc->tokens->at(*token_index);

src/tokenizer.cpp

@@ -139,6 +139,7 @@ static const struct ZigKeyword zig_keywords[] = {
     {"this", TokenIdKeywordThis},
     {"true", TokenIdKeywordTrue},
     {"try", TokenIdKeywordTry},
+    {"tryreturn", TokenIdKeywordTryReturn},
     {"undefined", TokenIdKeywordUndefined},
     {"union", TokenIdKeywordUnion},
     {"unreachable", TokenIdKeywordUnreachable},
@@ -1473,6 +1474,7 @@ const char * token_name(TokenId id) {
         case TokenIdKeywordThis: return "this";
         case TokenIdKeywordTrue: return "true";
         case TokenIdKeywordTry: return "try";
+        case TokenIdKeywordTryReturn: return "tryreturn";
         case TokenIdKeywordUndefined: return "undefined";
         case TokenIdKeywordUnion: return "union";
         case TokenIdKeywordUnreachable: return "unreachable";

src/tokenizer.hpp

@@ -76,6 +76,7 @@ enum TokenId {
     TokenIdKeywordThis,
     TokenIdKeywordTrue,
     TokenIdKeywordTry,
+    TokenIdKeywordTryReturn,
     TokenIdKeywordUndefined,
     TokenIdKeywordUnion,
     TokenIdKeywordUnreachable,

std/buf_map.zig

@@ -29,16 +29,16 @@ pub const BufMap = struct {
 
     pub fn set(self: &BufMap, key: []const u8, value: []const u8) -> %void {
         test (self.hash_map.get(key)) |entry| {
-            const value_copy = %return self.copy(value);
+            const value_copy = tryreturn self.copy(value);
             %defer self.free(value_copy);
-            _ = %return self.hash_map.put(key, value_copy);
+            _ = tryreturn self.hash_map.put(key, value_copy);
             self.free(entry.value);
         } else {
-            const key_copy = %return self.copy(key);
+            const key_copy = tryreturn self.copy(key);
             %defer self.free(key_copy);
-            const value_copy = %return self.copy(value);
+            const value_copy = tryreturn self.copy(value);
             %defer self.free(value_copy);
-            _ = %return self.hash_map.put(key_copy, value_copy);
+            _ = tryreturn self.hash_map.put(key_copy, value_copy);
         }
     }
 
@@ -63,7 +63,7 @@ pub const BufMap = struct {
     }
 
     fn copy(self: &BufMap, value: []const u8) -> %[]const u8 {
-        const result = %return self.hash_map.allocator.alloc(u8, value.len);
+        const result = tryreturn self.hash_map.allocator.alloc(u8, value.len);
         mem.copy(u8, result, value);
         return result;
     }

std/buf_set.zig

@@ -26,9 +26,9 @@ pub const BufSet = struct {
 
     pub fn put(self: &BufSet, key: []const u8) -> %void {
         if (self.hash_map.get(key) == null) {
-            const key_copy = %return self.copy(key);
+            const key_copy = tryreturn self.copy(key);
             %defer self.free(key_copy);
-            _ = %return self.hash_map.put(key_copy, {});
+            _ = tryreturn self.hash_map.put(key_copy, {});
         }
     }
 
@@ -52,7 +52,7 @@ pub const BufSet = struct {
     }
 
     fn copy(self: &BufSet, value: []const u8) -> %[]const u8 {
-        const result = %return self.hash_map.allocator.alloc(u8, value.len);
+        const result = tryreturn self.hash_map.allocator.alloc(u8, value.len);
         mem.copy(u8, result, value);
         return result;
     }

std/buffer.zig

@@ -10,15 +10,15 @@ pub const Buffer = struct {
 
     /// Must deinitialize with deinit.
     pub fn init(allocator: &Allocator, m: []const u8) -> %Buffer {
-        var self = %return initSize(allocator, m.len);
+        var self = tryreturn initSize(allocator, m.len);
         mem.copy(u8, self.list.items, m);
         return self;
     }
 
     /// Must deinitialize with deinit.
     pub fn initSize(allocator: &Allocator, size: usize) -> %Buffer {
         var self = initNull(allocator);
-        %return self.resize(size);
+        tryreturn self.resize(size);
         return self;
     }
 
@@ -51,7 +51,7 @@ pub const Buffer = struct {
     }
 
     pub fn resize(self: &Buffer, new_len: usize) -> %void {
-        %return self.list.resize(new_len + 1);
+        tryreturn self.list.resize(new_len + 1);
         self.list.items[self.len()] = 0;
     }
 
@@ -65,12 +65,12 @@ pub const Buffer = struct {
 
     pub fn append(self: &Buffer, m: []const u8) -> %void {
         const old_len = self.len();
-        %return self.resize(old_len + m.len);
+        tryreturn self.resize(old_len + m.len);
         mem.copy(u8, self.list.toSlice()[old_len...], m);
     }
 
     pub fn appendByte(self: &Buffer, byte: u8) -> %void {
-        %return self.resize(self.len() + 1);
+        tryreturn self.resize(self.len() + 1);
         self.list.items[self.len() - 1] = byte;
     }
 
@@ -91,7 +91,7 @@ pub const Buffer = struct {
     }
 
     pub fn replaceContents(self: &const Buffer, m: []const u8) -> %void {
-        %return self.resize(m.len);
+        tryreturn self.resize(m.len);
         mem.copy(u8, self.list.toSlice(), m);
     }
 };