From 8e2c441b2eae7af27fe311c4539f6932a7f47cea Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 6 Oct 2019 16:39:27 -0400
Subject: stage1 parser supports doc comments

---
 src/parser.cpp | 45 +++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 41 insertions(+), 4 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/src/parser.cpp b/src/parser.cpp
index 96071daa07..c4be117069 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -37,7 +37,7 @@ static AstNode *ast_parse_root(ParseContext *pc);
 static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc);
 static AstNode *ast_parse_test_decl(ParseContext *pc);
 static AstNode *ast_parse_top_level_comptime(ParseContext *pc);
-static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod);
+static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, Buf *doc_comments);
 static AstNode *ast_parse_fn_proto(ParseContext *pc);
 static AstNode *ast_parse_var_decl(ParseContext *pc);
 static AstNode *ast_parse_container_field(ParseContext *pc);
@@ -497,6 +497,19 @@ static AstNode *ast_parse_root(ParseContext *pc) {
     return node;
 }
 
+static Token *ast_parse_doc_comments(ParseContext *pc, Buf *buf) {
+    Token *doc_token = nullptr;
+    while ((doc_token = eat_token_if(pc, TokenIdDocComment))) {
+        if (buf->list.length == 0) {
+            buf_resize(buf, 0);
+        }
+        // chops off '///' and '\n'
+        buf_append_mem(buf, buf_ptr(pc->buf) + doc_token->start_pos + 3,
+                doc_token->end_pos - doc_token->start_pos - 4);
+    }
+    return doc_token;
+}
+
 // ContainerMembers
 //     <- TestDecl ContainerMembers
 //      / TopLevelComptime ContainerMembers
@@ -519,10 +532,13 @@ static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
             continue;
         }
 
+        Buf doc_comment_buf = BUF_INIT;
+        ast_parse_doc_comments(pc, &doc_comment_buf);
+
         Token *visib_token = eat_token_if(pc, TokenIdKeywordPub);
         VisibMod visib_mod = visib_token != nullptr ? VisibModPub : VisibModPrivate;
 
-        AstNode *top_level_decl = ast_parse_top_level_decl(pc, visib_mod);
+        AstNode *top_level_decl = ast_parse_top_level_decl(pc, visib_mod, &doc_comment_buf);
         if (top_level_decl != nullptr) {
             res.decls.append(top_level_decl);
             continue;
@@ -532,6 +548,7 @@ static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
         if (container_field != nullptr) {
             assert(container_field->type == NodeTypeStructField);
             container_field->data.struct_field.visib_mod = visib_mod;
+            container_field->data.struct_field.doc_comments = doc_comment_buf;
             res.fields.append(container_field);
             if (eat_token_if(pc, TokenIdComma) != nullptr) {
                 continue;
@@ -581,7 +598,7 @@ static AstNode *ast_parse_top_level_comptime(ParseContext *pc) {
 //     <- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
 //      / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? KEYWORD_threadlocal? VarDecl
 //      / KEYWORD_use Expr SEMICOLON
-static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
+static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, Buf *doc_comments) {
     Token *first = eat_token_if(pc, TokenIdKeywordExport);
     if (first == nullptr)
         first = eat_token_if(pc, TokenIdKeywordExtern);
@@ -603,6 +620,7 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
                 var_decl->column = first->start_column;
                 var_decl->data.variable_declaration.threadlocal_tok = thread_local_kw;
                 var_decl->data.variable_declaration.visib_mod = visib_mod;
+                var_decl->data.variable_declaration.doc_comments = *doc_comments;
                 var_decl->data.variable_declaration.is_extern = first->id == TokenIdKeywordExtern;
                 var_decl->data.variable_declaration.is_export = first->id == TokenIdKeywordExport;
                 var_decl->data.variable_declaration.lib_name = token_buf(lib_name);
@@ -623,6 +641,7 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
             fn_proto->line = first->start_line;
             fn_proto->column = first->start_column;
             fn_proto->data.fn_proto.visib_mod = visib_mod;
+            fn_proto->data.fn_proto.doc_comments = *doc_comments;
             fn_proto->data.fn_proto.is_extern = first->id == TokenIdKeywordExtern;
             fn_proto->data.fn_proto.is_export = first->id == TokenIdKeywordExport;
             switch (first->id) {
@@ -657,6 +676,7 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
     if (var_decl != nullptr) {
         assert(var_decl->type == NodeTypeVariableDeclaration);
         var_decl->data.variable_declaration.visib_mod = visib_mod;
+        var_decl->data.variable_declaration.doc_comments = *doc_comments;
         var_decl->data.variable_declaration.threadlocal_tok = thread_local_kw;
         return var_decl;
     }
@@ -672,6 +692,7 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
 
         assert(fn_proto->type == NodeTypeFnProto);
         fn_proto->data.fn_proto.visib_mod = visib_mod;
+        fn_proto->data.fn_proto.doc_comments = *doc_comments;
         AstNode *res = fn_proto;
         if (body != nullptr) {
             res = ast_create_node_copy_line_info(pc, NodeTypeFnDef, fn_proto);
@@ -1719,11 +1740,20 @@ static AstNode *ast_parse_error_set_decl(ParseContext *pc) {
     }
 
     ZigList<AstNode *> decls = ast_parse_list<AstNode>(pc, TokenIdComma, [](ParseContext *context) {
+        Buf doc_comment_buf = BUF_INIT;
+        Token *doc_token = ast_parse_doc_comments(context, &doc_comment_buf);
         Token *ident = eat_token_if(context, TokenIdSymbol);
         if (ident == nullptr)
             return (AstNode*)nullptr;
 
-        return token_symbol(context, ident);
+        AstNode *symbol_node = token_symbol(context, ident);
+        if (doc_token == nullptr)
+            return symbol_node;
+
+        AstNode *field_node = ast_create_node(context, NodeTypeErrorSetField, doc_token);
+        field_node->data.err_set_field.field_name = symbol_node;
+        field_node->data.err_set_field.doc_comments = doc_comment_buf;
+        return field_node;
     });
     expect_token(pc, TokenIdRBrace);
 
@@ -2057,6 +2087,9 @@ static Optional<AstNodeFnProto> ast_parse_fn_cc(ParseContext *pc) {
 
 // ParamDecl <- (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
 static AstNode *ast_parse_param_decl(ParseContext *pc) {
+    Buf doc_comments = BUF_INIT;
+    ast_parse_doc_comments(pc, &doc_comments);
+
     Token *first = eat_token_if(pc, TokenIdKeywordNoAlias);
     if (first == nullptr)
         first = eat_token_if(pc, TokenIdKeywordCompTime);
@@ -2089,6 +2122,7 @@ static AstNode *ast_parse_param_decl(ParseContext *pc) {
     res->line = first->start_line;
     res->column = first->start_column;
     res->data.param_decl.name = token_buf(name);
+    res->data.param_decl.doc_comments = doc_comments;
     res->data.param_decl.is_noalias = first->id == TokenIdKeywordNoAlias;
     res->data.param_decl.is_comptime = first->id == TokenIdKeywordCompTime;
     return res;
@@ -3029,6 +3063,9 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
         case NodeTypeErrorSetDecl:
             visit_node_list(&node->data.err_set_decl.decls, visit, context);
             break;
+        case NodeTypeErrorSetField:
+            visit_field(&node->data.err_set_field.field_name, visit, context);
+            break;
         case NodeTypeResume:
             visit_field(&node->data.resume_expr.expr, visit, context);
             break;
-- 
cgit v1.2.3


From 2ccb48ddc3f3b543bca0538da948013447afe429 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 7 Oct 2019 12:20:59 -0400
Subject: generated docs: show doc comments on functions

---
 lib/std/special/docs/index.html |  2 ++
 lib/std/special/docs/main.js    | 23 +++++++++---
 src/all_types.hpp               |  3 ++
 src/analyze.cpp                 |  8 +++++
 src/buffer.hpp                  |  6 ++++
 src/dump_analysis.cpp           | 80 ++++++++++++++++++++++++++++++++++++++---
 src/parser.cpp                  |  4 +--
 7 files changed, 115 insertions(+), 11 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/special/docs/index.html b/lib/std/special/docs/index.html
index db80ec9550..d159637249 100644
--- a/lib/std/special/docs/index.html
+++ b/lib/std/special/docs/index.html
@@ -7,6 +7,7 @@
     <style type="text/css">
         body {
             font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
+            max-width: 60em;
         }
         .hidden {
             display: none;
@@ -64,6 +65,7 @@
     <div id="fnProto" class="hidden">
       <pre id="fnProtoCode"></pre>
     </div>
+    <div id="fnDocs" class="hidden"></div>
     <div id="sectPkgs" class="hidden">
         <h2>Packages</h2>
         <ul id="listPkgs">
diff --git a/lib/std/special/docs/main.js b/lib/std/special/docs/main.js
index 50002f6841..4dca1e8452 100644
--- a/lib/std/special/docs/main.js
+++ b/lib/std/special/docs/main.js
@@ -10,6 +10,7 @@
     var domListFns = document.getElementById("listFns");
     var domFnProto = document.getElementById("fnProto");
     var domFnProtoCode = document.getElementById("fnProtoCode");
+    var domFnDocs = document.getElementById("fnDocs");
 
     var typeKindTypeId;
     var typeKindFnId;
@@ -53,6 +54,11 @@
     function render() {
         domStatus.classList.add("hidden");
         domFnProto.classList.add("hidden");
+        domFnDocs.classList.add("hidden");
+        domSectPkgs.classList.add("hidden");
+        domSectTypes.classList.add("hidden");
+        domSectFns.classList.add("hidden");
+
 
         renderTitle();
 
@@ -107,13 +113,15 @@
     }
 
     function renderFn(fnDecl) {
-        domSectPkgs.classList.add("hidden");
-        domSectTypes.classList.add("hidden");
-        domSectFns.classList.add("hidden");
-
         var typeObj = zigAnalysis.types[fnDecl.type];
         domFnProtoCode.textContent = "fn " + fnDecl.name + typeObj.name.substring(2);
 
+        var srcNode = zigAnalysis.astNodes[fnDecl.src];
+        if (srcNode.docs != null) {
+            domFnDocs.innerHTML = markdown(srcNode.docs);
+            domFnDocs.classList.remove("hidden");
+        }
+
         domFnProto.classList.remove("hidden");
     }
 
@@ -379,4 +387,11 @@
         }
         return list;
     }
+
+    var escapeHtmlReplacements = { "&": "&amp;", '"': "&quot;", "<": "&lt;", ">": "&gt;" };
+    function markdown(mdText) {
+        return mdText.replace(/[&"<>]/g, function (m) {
+            return escapeHtmlReplacements[m];
+        });
+    }
 })();
diff --git a/src/all_types.hpp b/src/all_types.hpp
index f927fc2914..0e9df94176 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -1322,6 +1322,9 @@ bool pkg_ptr_eql(const ZigPackage *a, const ZigPackage *b);
 uint32_t tld_ptr_hash(const Tld *ptr);
 bool tld_ptr_eql(const Tld *a, const Tld *b);
 
+uint32_t node_ptr_hash(const AstNode *ptr);
+bool node_ptr_eql(const AstNode *a, const AstNode *b);
+
 struct ZigTypeUnion {
     AstNode *decl_node;
     TypeUnionField *fields;
diff --git a/src/analyze.cpp b/src/analyze.cpp
index c3206eac49..38739b56eb 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -7320,6 +7320,14 @@ bool tld_ptr_eql(const Tld *a, const Tld *b) {
     return a == b;
 }
 
+uint32_t node_ptr_hash(const AstNode *ptr) {
+    return hash_ptr((void*)ptr);
+}
+
+bool node_ptr_eql(const AstNode *a, const AstNode *b) {
+    return a == b;
+}
+
 ConstExprValue *get_builtin_value(CodeGen *codegen, const char *name) {
     Tld *tld = get_container_scope(codegen->compile_var_import)->decl_table.get(buf_create_from_str(name));
     resolve_top_level_decl(codegen, tld, nullptr, false);
diff --git a/src/buffer.hpp b/src/buffer.hpp
index 251b5c2f27..6442e4f123 100644
--- a/src/buffer.hpp
+++ b/src/buffer.hpp
@@ -38,6 +38,12 @@ static inline char *buf_ptr(Buf *buf) {
     return buf->list.items;
 }
 
+static inline const char *buf_ptr(const Buf *buf) {
+    assert(buf);
+    assert(buf->list.length);
+    return buf->list.items;
+}
+
 static inline void buf_resize(Buf *buf, size_t new_len) {
     buf->list.resize(new_len + 1);
     buf->list.at(buf_len(buf)) = 0;
diff --git a/src/dump_analysis.cpp b/src/dump_analysis.cpp
index 220019c184..136b735bb3 100644
--- a/src/dump_analysis.cpp
+++ b/src/dump_analysis.cpp
@@ -351,6 +351,9 @@ struct AnalDumpCtx {
 
     ZigList<Tld *> decl_list;
     HashMap<const Tld *, uint32_t, tld_ptr_hash, tld_ptr_eql> decl_map;
+
+    ZigList<AstNode *> node_list;
+    HashMap<const AstNode *, uint32_t, node_ptr_hash, node_ptr_eql> node_map;
 };
 
 static uint32_t anal_dump_get_type_id(AnalDumpCtx *ctx, ZigType *ty);
@@ -416,6 +419,17 @@ static uint32_t anal_dump_get_file_id(AnalDumpCtx *ctx, Buf *file) {
     return file_id;
 }
 
+static uint32_t anal_dump_get_node_id(AnalDumpCtx *ctx, AstNode *node) {
+    uint32_t node_id = ctx->node_list.length;
+    auto existing_entry = ctx->node_map.put_unique(node, node_id);
+    if (existing_entry == nullptr) {
+        ctx->node_list.append(node);
+    } else {
+        node_id = existing_entry->value;
+    }
+    return node_id;
+}
+
 static uint32_t anal_dump_get_decl_id(AnalDumpCtx *ctx, Tld *tld) {
     uint32_t decl_id = ctx->decl_list.length;
     auto existing_entry = ctx->decl_map.put_unique(tld, decl_id);
@@ -475,6 +489,11 @@ static void anal_dump_file_ref(AnalDumpCtx *ctx, Buf *file) {
     jw_int(&ctx->jw, file_id);
 }
 
+static void anal_dump_node_ref(AnalDumpCtx *ctx, AstNode *node) {
+    uint32_t node_id = anal_dump_get_node_id(ctx, node);
+    jw_int(&ctx->jw, node_id);
+}
+
 static void anal_dump_decl_ref(AnalDumpCtx *ctx, Tld *tld) {
     uint32_t decl_id = anal_dump_get_decl_id(ctx, tld);
     jw_int(&ctx->jw, decl_id);
@@ -536,11 +555,8 @@ static void anal_dump_decl(AnalDumpCtx *ctx, Tld *tld) {
         jw_object_field(jw, "import");
         anal_dump_type_ref(ctx, tld->import);
 
-        jw_object_field(jw, "line");
-        jw_int(jw, tld->source_node->line);
-
-        jw_object_field(jw, "col");
-        jw_int(jw, tld->source_node->column);
+        jw_object_field(jw, "src");
+        anal_dump_node_ref(ctx, tld->source_node);
 
         jw_object_field(jw, "name");
         jw_string(jw, buf_ptr(tld->name));
@@ -712,6 +728,50 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
     jw_end_object(jw);
 }
 
+void anal_dump_node(AnalDumpCtx *ctx, const AstNode *node) {
+    JsonWriter *jw = &ctx->jw;
+
+    jw_begin_object(jw);
+
+    jw_object_field(jw, "file");
+    anal_dump_file_ref(ctx, node->owner->data.structure.root_struct->path);
+
+    jw_object_field(jw, "line");
+    jw_int(jw, node->line);
+
+    jw_object_field(jw, "col");
+    jw_int(jw, node->column);
+
+    const Buf *doc_comments_buf;
+    switch (node->type) {
+        case NodeTypeParamDecl:
+            doc_comments_buf = &node->data.param_decl.doc_comments;
+            break;
+        case NodeTypeFnProto:
+            doc_comments_buf = &node->data.fn_proto.doc_comments;
+            break;
+        case NodeTypeVariableDeclaration:
+            doc_comments_buf = &node->data.variable_declaration.doc_comments;
+            break;
+        case NodeTypeErrorSetField:
+            doc_comments_buf = &node->data.err_set_field.doc_comments;
+            break;
+        case NodeTypeStructField:
+            doc_comments_buf = &node->data.struct_field.doc_comments;
+            break;
+        default:
+            doc_comments_buf = nullptr;
+            break;
+    }
+    if (doc_comments_buf->list.length != 0) {
+        jw_object_field(jw, "docs");
+        jw_string(jw, buf_ptr(doc_comments_buf));
+    }
+
+    jw_end_object(jw);
+}
+
+
 void zig_print_analysis_dump(CodeGen *g, FILE *f, const char *one_indent, const char *nl) {
     Error err;
     AnalDumpCtx ctx = {};
@@ -722,6 +782,7 @@ void zig_print_analysis_dump(CodeGen *g, FILE *f, const char *one_indent, const
     ctx.pkg_map.init(16);
     ctx.file_map.init(16);
     ctx.decl_map.init(16);
+    ctx.node_map.init(16);
 
     jw_begin_object(jw);
 
@@ -794,5 +855,14 @@ void zig_print_analysis_dump(CodeGen *g, FILE *f, const char *one_indent, const
     }
     jw_end_array(jw);
 
+    jw_object_field(jw, "astNodes");
+    jw_begin_array(jw);
+    for (uint32_t i = 0; i < ctx.node_list.length; i += 1) {
+        const AstNode *node = ctx.node_list.at(i);
+        jw_array_elem(jw);
+        anal_dump_node(&ctx, node);
+    }
+    jw_end_array(jw);
+
     jw_end_object(jw);
 }
diff --git a/src/parser.cpp b/src/parser.cpp
index c4be117069..2aab416f20 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -503,9 +503,9 @@ static Token *ast_parse_doc_comments(ParseContext *pc, Buf *buf) {
         if (buf->list.length == 0) {
             buf_resize(buf, 0);
         }
-        // chops off '///' and '\n'
+        // chops off '///' but leaves '\n'
         buf_append_mem(buf, buf_ptr(pc->buf) + doc_token->start_pos + 3,
-                doc_token->end_pos - doc_token->start_pos - 4);
+                doc_token->end_pos - doc_token->start_pos - 3);
     }
     return doc_token;
 }
-- 
cgit v1.2.3


From e0f0e2aace9e819545388c46547188ee6296178b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 8 Oct 2019 18:09:08 -0400
Subject: generated docs: error sets in fn docs

---
 lib/std/os.zig                  | 150 +++++++++++-----------------------------
 lib/std/special/docs/index.html |  17 ++++-
 lib/std/special/docs/main.js    |  74 ++++++++++++++++++--
 src/all_types.hpp               |   1 +
 src/dump_analysis.cpp           |   3 +
 src/ir.cpp                      |  53 +++++++++-----
 src/parser.cpp                  |   6 +-
 7 files changed, 172 insertions(+), 132 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/os.zig b/lib/std/os.zig
index c520e1d635..4a47f854cc 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -183,7 +183,7 @@ pub fn abort() noreturn {
     exit(127);
 }
 
-pub const RaiseError = error{Unexpected};
+pub const RaiseError = UnexpectedError;
 
 pub fn raise(sig: u8) RaiseError!void {
     if (builtin.link_libc) {
@@ -215,10 +215,7 @@ pub fn raise(sig: u8) RaiseError!void {
     @compileError("std.os.raise unimplemented for this target");
 }
 
-pub const KillError = error{
-    PermissionDenied,
-    Unexpected,
-};
+pub const KillError = error{PermissionDenied} || UnexpectedError;
 
 pub fn kill(pid: pid_t, sig: u8) KillError!void {
     switch (errno(system.kill(pid, sig))) {
@@ -266,9 +263,7 @@ pub const ReadError = error{
     /// This error occurs when no global event loop is configured,
     /// and reading from the file descriptor would block.
     WouldBlock,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Returns the number of bytes that were read, which can be less than
 /// buf.len. If 0 bytes were read, that means EOF.
@@ -385,8 +380,7 @@ pub const WriteError = error{
     BrokenPipe,
     SystemResources,
     OperationAborted,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Write to a file descriptor. Keeps trying if it gets interrupted.
 /// This function is for blocking file descriptors only.
@@ -548,8 +542,7 @@ pub const OpenError = error{
     NotDir,
     PathAlreadyExists,
     DeviceBusy,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Open and possibly create a file. Keeps trying if it gets interrupted.
 /// See also `openC`.
@@ -748,9 +741,7 @@ pub const ExecveError = error{
     ProcessFdQuotaExceeded,
     SystemFdQuotaExceeded,
     NameTooLong,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 fn execveErrnoToErr(err: usize) ExecveError {
     assert(err > 0);
@@ -808,8 +799,7 @@ pub fn getenvC(key: [*]const u8) ?[]const u8 {
 pub const GetCwdError = error{
     NameTooLong,
     CurrentWorkingDirectoryUnlinked,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// The result is a slice of out_buffer, indexed from 0.
 pub fn getcwd(out_buffer: []u8) GetCwdError![]u8 {
@@ -846,8 +836,7 @@ pub const SymLinkError = error{
     NameTooLong,
     InvalidUtf8,
     BadPathName,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Creates a symbolic link named `sym_link_path` which contains the string `target_path`.
 /// A symbolic link (also known as a soft link) may point to an existing file or to a nonexistent
@@ -932,7 +921,6 @@ pub const UnlinkError = error{
     NotDir,
     SystemResources,
     ReadOnlyFileSystem,
-    Unexpected,
 
     /// On Windows, file paths must be valid Unicode.
     InvalidUtf8,
@@ -940,7 +928,7 @@ pub const UnlinkError = error{
     /// On Windows, file paths cannot contain these characters:
     /// '/', '*', '?', '"', '<', '>', '|'
     BadPathName,
-};
+} || UnexpectedError;
 
 /// Delete a name and possibly the file it refers to.
 /// See also `unlinkC`.
@@ -996,8 +984,7 @@ const RenameError = error{
     RenameAcrossMountPoints,
     InvalidUtf8,
     BadPathName,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Change the name or location of a file.
 pub fn rename(old_path: []const u8, new_path: []const u8) RenameError!void {
@@ -1064,8 +1051,7 @@ pub const MakeDirError = error{
     ReadOnlyFileSystem,
     InvalidUtf8,
     BadPathName,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Create a directory.
 /// `mode` is ignored on Windows.
@@ -1116,8 +1102,7 @@ pub const DeleteDirError = error{
     ReadOnlyFileSystem,
     InvalidUtf8,
     BadPathName,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Deletes an empty directory.
 pub fn rmdir(dir_path: []const u8) DeleteDirError!void {
@@ -1163,8 +1148,7 @@ pub const ChangeCurDirError = error{
     FileNotFound,
     SystemResources,
     NotDir,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Changes the current working directory of the calling process.
 /// `dir_path` is recommended to be a UTF-8 encoded string.
@@ -1206,8 +1190,7 @@ pub const ReadLinkError = error{
     FileNotFound,
     SystemResources,
     NotDir,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Read value of a symbolic link.
 /// The return value is a slice of `out_buffer` from index 0.
@@ -1247,8 +1230,7 @@ pub const SetIdError = error{
     ResourceLimitReached,
     InvalidUserId,
     PermissionDenied,
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn setuid(uid: u32) SetIdError!void {
     switch (errno(system.setuid(uid))) {
@@ -1357,9 +1339,7 @@ pub const SocketError = error{
 
     /// The protocol type or the specified protocol is not supported within this domain.
     ProtocolNotSupported,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn socket(domain: u32, socket_type: u32, protocol: u32) SocketError!i32 {
     const rc = system.socket(domain, socket_type, protocol);
@@ -1409,9 +1389,7 @@ pub const BindError = error{
 
     /// The socket inode would reside on a read-only filesystem.
     ReadOnlyFileSystem,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// addr is `*const T` where T is one of the sockaddr
 pub fn bind(fd: i32, addr: *const sockaddr) BindError!void {
@@ -1448,9 +1426,7 @@ const ListenError = error{
 
     /// The socket is not of a type that supports the listen() operation.
     OperationNotSupported,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn listen(sockfd: i32, backlog: u32) ListenError!void {
     const rc = system.listen(sockfd, backlog);
@@ -1487,9 +1463,7 @@ pub const AcceptError = error{
 
     /// Firewall rules forbid connection.
     BlockedByFirewall,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Accept a connection on a socket. `fd` must be opened in blocking mode.
 /// See also `accept4_async`.
@@ -1559,9 +1533,7 @@ pub const EpollCreateError = error{
 
     /// There was insufficient memory to create the kernel object.
     SystemResources,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn epoll_create1(flags: u32) EpollCreateError!i32 {
     const rc = system.epoll_create1(flags);
@@ -1600,9 +1572,7 @@ pub const EpollCtlError = error{
     /// The target file fd does not support epoll.  This error can occur if fd refers to,
     /// for example, a regular file or a directory.
     FileDescriptorIncompatibleWithEpoll,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn epoll_ctl(epfd: i32, op: u32, fd: i32, event: ?*epoll_event) EpollCtlError!void {
     const rc = system.epoll_ctl(epfd, op, fd, event);
@@ -1643,8 +1613,7 @@ pub const EventFdError = error{
     SystemResources,
     ProcessFdQuotaExceeded,
     SystemFdQuotaExceeded,
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn eventfd(initval: u32, flags: u32) EventFdError!i32 {
     const rc = system.eventfd(initval, flags);
@@ -1663,9 +1632,7 @@ pub fn eventfd(initval: u32, flags: u32) EventFdError!i32 {
 pub const GetSockNameError = error{
     /// Insufficient resources were available in the system to perform the operation.
     SystemResources,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn getsockname(sockfd: i32) GetSockNameError!sockaddr {
     var addr: sockaddr = undefined;
@@ -1714,9 +1681,7 @@ pub const ConnectError = error{
     /// Timeout  while  attempting  connection.   The server may be too busy to accept new connections.  Note
     /// that for IP sockets the timeout may be very long when syncookies are enabled on the server.
     ConnectionTimedOut,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Initiate a connection on a socket.
 /// This is for blocking file descriptors only.
@@ -1824,10 +1789,7 @@ pub fn waitpid(pid: i32, flags: u32) u32 {
     }
 }
 
-pub const FStatError = error{
-    SystemResources,
-    Unexpected,
-};
+pub const FStatError = error{SystemResources} || UnexpectedError;
 
 pub fn fstat(fd: fd_t) FStatError!Stat {
     var stat: Stat = undefined;
@@ -1856,9 +1818,7 @@ pub const KQueueError = error{
 
     /// The system-wide limit on the total number of open files has been reached.
     SystemFdQuotaExceeded,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn kqueue() KQueueError!i32 {
     const rc = system.kqueue();
@@ -1922,8 +1882,7 @@ pub const INotifyInitError = error{
     ProcessFdQuotaExceeded,
     SystemFdQuotaExceeded,
     SystemResources,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// initialize an inotify instance
 pub fn inotify_init1(flags: u32) INotifyInitError!i32 {
@@ -1944,8 +1903,7 @@ pub const INotifyAddWatchError = error{
     FileNotFound,
     SystemResources,
     UserResourceLimitReached,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// add a watch to an initialized inotify instance
 pub fn inotify_add_watch(inotify_fd: i32, pathname: []const u8, mask: u32) INotifyAddWatchError!i32 {
@@ -1992,8 +1950,7 @@ pub const MProtectError = error{
     /// dle of a region currently protected as PROT_READ|PROT_WRITE would result in three map‐
     /// pings: two read/write mappings at each end and a read-only mapping in the middle.)
     OutOfMemory,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// `memory.len` must be page-aligned.
 pub fn mprotect(memory: []align(mem.page_size) u8, protection: u32) MProtectError!void {
@@ -2007,10 +1964,7 @@ pub fn mprotect(memory: []align(mem.page_size) u8, protection: u32) MProtectErro
     }
 }
 
-pub const ForkError = error{
-    SystemResources,
-    Unexpected,
-};
+pub const ForkError = error{SystemResources} || UnexpectedError;
 
 pub fn fork() ForkError!pid_t {
     const rc = system.fork();
@@ -2037,8 +1991,7 @@ pub const MMapError = error{
     PermissionDenied,
     LockedMemoryLimitExceeded,
     OutOfMemory,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Map files or devices into memory.
 /// Use of a mapped region can result in these signals:
@@ -2101,9 +2054,7 @@ pub const AccessError = error{
 
     /// On Windows, file paths must be valid Unicode.
     InvalidUtf8,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// check user's permissions for a file
 /// TODO currently this assumes `mode` is `F_OK` on Windows.
@@ -2161,8 +2112,7 @@ pub fn accessW(path: [*]const u16, mode: u32) windows.GetFileAttributesError!voi
 pub const PipeError = error{
     SystemFdQuotaExceeded,
     ProcessFdQuotaExceeded,
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Creates a unidirectional data channel that can be used for interprocess communication.
 pub fn pipe() PipeError![2]fd_t {
@@ -2193,8 +2143,7 @@ pub const SysCtlError = error{
     PermissionDenied,
     SystemResources,
     NameTooLong,
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn sysctl(
     name: []const c_int,
@@ -2237,10 +2186,7 @@ pub fn gettimeofday(tv: ?*timeval, tz: ?*timezone) void {
     }
 }
 
-pub const SeekError = error{
-    Unseekable,
-    Unexpected,
-};
+pub const SeekError = error{Unseekable} || UnexpectedError;
 
 /// Repositions read/write file offset relative to the beginning.
 pub fn lseek_SET(fd: fd_t, offset: u64) SeekError!void {
@@ -2382,9 +2328,7 @@ pub const RealPathError = error{
     InvalidUtf8,
 
     PathAlreadyExists,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 /// Return the canonicalized absolute pathname.
 /// Expands all symbolic links and resolves references to `.`, `..`, and
@@ -2548,10 +2492,7 @@ pub fn dl_iterate_phdr(comptime T: type, callback: extern fn (info: *dl_phdr_inf
     return last_r;
 }
 
-pub const ClockGetTimeError = error{
-    UnsupportedClock,
-    Unexpected,
-};
+pub const ClockGetTimeError = error{UnsupportedClock} || UnexpectedError;
 
 pub fn clock_gettime(clk_id: i32, tp: *timespec) ClockGetTimeError!void {
     switch (errno(system.clock_gettime(clk_id, tp))) {
@@ -2571,10 +2512,7 @@ pub fn clock_getres(clk_id: i32, res: *timespec) ClockGetTimeError!void {
     }
 }
 
-pub const SchedGetAffinityError = error{
-    PermissionDenied,
-    Unexpected,
-};
+pub const SchedGetAffinityError = error{PermissionDenied} || UnexpectedError;
 
 pub fn sched_getaffinity(pid: pid_t) SchedGetAffinityError!cpu_set_t {
     var set: cpu_set_t = undefined;
@@ -2628,8 +2566,7 @@ pub const SigaltstackError = error{
 
     /// Attempted to change the signal stack while it was active.
     PermissionDenied,
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn sigaltstack(ss: ?*stack_t, old_ss: ?*stack_t) SigaltstackError!void {
     if (windows.is_the_target or uefi.is_the_target or wasi.is_the_target)
@@ -2677,9 +2614,7 @@ pub const FutimensError = error{
     PermissionDenied,
 
     ReadOnlyFileSystem,
-
-    Unexpected,
-};
+} || UnexpectedError;
 
 pub fn futimens(fd: fd_t, times: *const [2]timespec) FutimensError!void {
     switch (errno(system.futimens(fd, times))) {
@@ -2694,10 +2629,7 @@ pub fn futimens(fd: fd_t, times: *const [2]timespec) FutimensError!void {
     }
 }
 
-pub const GetHostNameError = error{
-    PermissionDenied,
-    Unexpected,
-};
+pub const GetHostNameError = error{PermissionDenied} || UnexpectedError;
 
 pub fn gethostname(name_buffer: *[HOST_NAME_MAX]u8) GetHostNameError![]u8 {
     if (builtin.link_libc) {
diff --git a/lib/std/special/docs/index.html b/lib/std/special/docs/index.html
index 0239788a82..6e134af5b3 100644
--- a/lib/std/special/docs/index.html
+++ b/lib/std/special/docs/index.html
@@ -87,7 +87,7 @@
       #listPkgs li a {
         display: block;
         color: #000;
-        padding: 8px 16px;
+        padding: 0.5em 1em;
         text-decoration: none;
       }
       #listPkgs li a:hover {
@@ -145,6 +145,13 @@
       #listSearchResults li.selected {
         background-color: #93e196;
       }
+
+      #tableFnErrors tr td:first-child{
+        text-align: right;
+        font-weight: bold;
+        vertical-align: top;
+      }
+
       .tok-kw {
           color: #333;
           font-weight: bold;
@@ -262,7 +269,13 @@
     </div>
     <h1 id="hdrName" class="hidden"></h1>
     <div id="fnDocs" class="hidden"></div>
-    <div id="fnErrors" class="hidden"></div>
+    <div id="sectFnErrors" class="hidden">
+      <h2>Errors</h2>
+      <div id="fnErrorsAnyError">
+        <p><span class="tok-type">anyerror</span> means the error set is known only at runtime.</p>
+      </div>
+      <table id="tableFnErrors"><tbody id="listFnErrors"></tbody></table>
+    </div>
     <div id="fnExamples" class="hidden"></div>
     <div id="fnNoExamples" class="hidden">
       <p>This function is not tested or referenced.</p>
diff --git a/lib/std/special/docs/main.js b/lib/std/special/docs/main.js
index f2a17cf7cd..679e6f35c7 100644
--- a/lib/std/special/docs/main.js
+++ b/lib/std/special/docs/main.js
@@ -13,7 +13,10 @@
     var domFnProto = document.getElementById("fnProto");
     var domFnProtoCode = document.getElementById("fnProtoCode");
     var domFnDocs = document.getElementById("fnDocs");
-    var domFnErrors = document.getElementById("fnErrors");
+    var domSectFnErrors = document.getElementById("sectFnErrors");
+    var domListFnErrors = document.getElementById("listFnErrors");
+    var domTableFnErrors = document.getElementById("tableFnErrors");
+    var domFnErrorsAnyError = document.getElementById("fnErrorsAnyError");
     var domFnExamples = document.getElementById("fnExamples");
     var domFnNoExamples = document.getElementById("fnNoExamples");
     var domSearch = document.getElementById("search");
@@ -36,6 +39,7 @@
     var typeKindFloatId;
     var typeKindIntId;
     var typeKindBoolId;
+    var typeKindVoidId;
     var typeKindErrSetId;
     var typeKindErrUnionId;
     findTypeKinds();
@@ -102,9 +106,11 @@
         domSectInfo.classList.add("hidden");
         domHdrName.classList.add("hidden");
         domSectNav.classList.add("hidden");
-        domFnErrors.classList.add("hidden");
+        domSectFnErrors.classList.add("hidden");
         domFnExamples.classList.add("hidden");
         domFnNoExamples.classList.add("hidden");
+        domFnErrorsAnyError.classList.add("hidden");
+        domTableFnErrors.classList.add("hidden");
 
         renderTitle();
         renderInfo();
@@ -202,6 +208,51 @@
             docsSource = srcNode.docs;
         }
 
+        var errSetTypeIndex = null;
+        if (typeObj.ret != null) {
+            var retType = zigAnalysis.types[typeObj.ret];
+            if (retType.kind === typeKindErrSetId) {
+                errSetTypeIndex = typeObj.ret;
+            } else if (retType.kind === typeKindErrUnionId) {
+                errSetTypeIndex = retType.err;
+            }
+        }
+        if (errSetTypeIndex != null) {
+            var errSetType = zigAnalysis.types[errSetTypeIndex];
+            if (errSetType.errors == null) {
+                domFnErrorsAnyError.classList.remove("hidden");
+            } else {
+                var errorList = [];
+                for (var i = 0; i < errSetType.errors.length; i += 1) {
+                    var errObj = zigAnalysis.errors[errSetType.errors[i]];
+                    var srcObj = zigAnalysis.astNodes[errObj.src];
+                    errorList.push({
+                        err: errObj,
+                        docs: srcObj.docs,
+                    });
+                }
+                errorList.sort(function(a, b) {
+                    return operatorCompare(a.err.name.toLowerCase(), b.err.name.toLowerCase());
+                });
+
+                resizeDomList(domListFnErrors, errorList.length, '<tr><td></td><td></td></tr>');
+                for (var i = 0; i < errorList.length; i += 1) {
+                    var trDom = domListFnErrors.children[i];
+                    var nameTdDom = trDom.children[0];
+                    var descTdDom = trDom.children[1];
+                    nameTdDom.textContent = errorList[i].err.name;
+                    var docs = errorList[i].docs;
+                    if (docs != null) {
+                        descTdDom.innerHTML = markdown(docs);
+                    } else {
+                        descTdDom.textContent = "";
+                    }
+                }
+                domTableFnErrors.classList.remove("hidden");
+            }
+            domSectFnErrors.classList.remove("hidden");
+        }
+
         var protoSrcIndex;
         if (typeIsGenericFn(fnDecl.type)) {
             protoSrcIndex = fnDecl.value;
@@ -285,9 +336,11 @@
         var list = [];
         for (var key in rootPkg.table) {
             if (key === "root" && rootIsStd) continue;
+            var pkgIndex = rootPkg.table[key];
+            if (zigAnalysis.packages[pkgIndex] == null) continue;
             list.push({
                 name: key,
-                pkg: rootPkg.table[key],
+                pkg: pkgIndex,
             });
         }
         list.sort(function(a, b) {
@@ -447,6 +500,12 @@
                 } else {
                     return "bool";
                 }
+            case typeKindVoidId:
+                if (wantHtml) {
+                    return '<span class="tok-type">void</span>';
+                } else {
+                    return "void";
+                }
             case typeKindErrSetId:
                 if (typeObj.errors == null) {
                     if (wantHtml) {
@@ -580,6 +639,7 @@
             return false;
         }
         var stdPkg = zigAnalysis.packages[rootPkg.table["std"]];
+        if (stdPkg == null) return false;
         return rootPkg.file === stdPkg.file;
     }
 
@@ -597,6 +657,8 @@
                 typeKindIntId = i;
             } else if (zigAnalysis.typeKinds[i] === "Bool") {
                 typeKindBoolId = i;
+            } else if (zigAnalysis.typeKinds[i] === "Void") {
+                typeKindVoidId = i;
             } else if (zigAnalysis.typeKinds[i] === "ErrorSet") {
                 typeKindErrSetId = i;
             } else if (zigAnalysis.typeKinds[i] === "ErrorUnion") {
@@ -621,6 +683,9 @@
         if (typeKindBoolId == null) {
             throw new Error("No type kind 'Bool' found");
         }
+        if (typeKindVoidId == null) {
+            throw new Error("No type kind 'Void' found");
+        }
         if (typeKindErrSetId == null) {
             throw new Error("No type kind 'ErrorSet' found");
         }
@@ -702,10 +767,11 @@
             for (var key in item.pkg.table) {
                 var childPkgIndex = item.pkg.table[key];
                 if (list[childPkgIndex] != null) continue;
+                var childPkg = zigAnalysis.packages[childPkgIndex];
+                if (childPkg == null) continue;
 
                 var newPath = item.path.concat([key])
                 list[childPkgIndex] = newPath;
-                var childPkg = zigAnalysis.packages[childPkgIndex];
                 stack.push({
                     path: newPath,
                     pkg: childPkg,
diff --git a/src/all_types.hpp b/src/all_types.hpp
index e6fdc43ea7..c9f905118f 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -2146,6 +2146,7 @@ struct ErrorTableEntry {
     Buf name;
     uint32_t value;
     AstNode *decl_node;
+    ErrorTableEntry *other; // null, or another error decl that was merged into this
     ZigType *set_with_only_this_in_it;
     // If we generate a constant error name value for this error, we memoize it here.
     // The type of this is array
diff --git a/src/dump_analysis.cpp b/src/dump_analysis.cpp
index 78f69d60a7..168d86a21f 100644
--- a/src/dump_analysis.cpp
+++ b/src/dump_analysis.cpp
@@ -892,6 +892,9 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
             if (type_is_global_error_set(ty)) {
                 break;
             }
+            jw_object_field(jw, "name");
+            jw_string(jw, buf_ptr(&ty->name));
+
             if (ty->data.error_set.infer_fn != nullptr) {
                 jw_object_field(jw, "fn");
                 anal_dump_fn_ref(ctx, ty->data.error_set.infer_fn);
diff --git a/src/ir.cpp b/src/ir.cpp
index 7e2b39fe1b..f29870e039 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -7892,11 +7892,14 @@ static ZigType *get_error_set_union(CodeGen *g, ErrorTableEntry **errors, ZigTyp
     }
 
     uint32_t index = set1->data.error_set.err_count;
+    bool need_comma = false;
     for (uint32_t i = 0; i < set2->data.error_set.err_count; i += 1) {
         ErrorTableEntry *error_entry = set2->data.error_set.errors[i];
         if (errors[error_entry->value] == nullptr) {
             errors[error_entry->value] = error_entry;
-            buf_appendf(&err_set_type->name, "%s,", buf_ptr(&error_entry->name));
+            const char *comma = need_comma ? "," : "";
+            need_comma = true;
+            buf_appendf(&err_set_type->name, "%s%s", comma, buf_ptr(&error_entry->name));
             err_set_type->data.error_set.errors[index] = error_entry;
             index += 1;
         }
@@ -7927,6 +7930,17 @@ static ZigType *make_err_set_with_one_item(CodeGen *g, Scope *parent_scope, AstN
     return err_set_type;
 }
 
+static AstNode *ast_field_to_symbol_node(AstNode *err_set_field_node) {
+    if (err_set_field_node->type == NodeTypeSymbol) {
+        return err_set_field_node;
+    } else if (err_set_field_node->type == NodeTypeErrorSetField) {
+        assert(err_set_field_node->data.err_set_field.field_name->type == NodeTypeSymbol);
+        return err_set_field_node->data.err_set_field.field_name;
+    } else {
+        return err_set_field_node;
+    }
+}
+
 static IrInstruction *ir_gen_err_set_decl(IrBuilder *irb, Scope *parent_scope, AstNode *node) {
     assert(node->type == NodeTypeErrorSetDecl);
 
@@ -7946,18 +7960,10 @@ static IrInstruction *ir_gen_err_set_decl(IrBuilder *irb, Scope *parent_scope, A
 
     for (uint32_t i = 0; i < err_count; i += 1) {
         AstNode *field_node = node->data.err_set_decl.decls.at(i);
-        AstNode *symbol_node;
-        if (field_node->type == NodeTypeSymbol) {
-            symbol_node = field_node;
-        } else if (field_node->type == NodeTypeErrorSetField) {
-            symbol_node = field_node->data.err_set_field.field_name;
-        } else {
-            zig_unreachable();
-        }
-        assert(symbol_node->type == NodeTypeSymbol);
+        AstNode *symbol_node = ast_field_to_symbol_node(field_node);
         Buf *err_name = symbol_node->data.symbol_expr.symbol;
         ErrorTableEntry *err = allocate<ErrorTableEntry>(1);
-        err->decl_node = symbol_node;
+        err->decl_node = field_node;
         buf_init_from_buf(&err->name, err_name);
 
         auto existing_entry = irb->codegen->error_table.put_unique(err_name, err);
@@ -7973,8 +7979,10 @@ static IrInstruction *ir_gen_err_set_decl(IrBuilder *irb, Scope *parent_scope, A
 
         ErrorTableEntry *prev_err = errors[err->value];
         if (prev_err != nullptr) {
-            ErrorMsg *msg = add_node_error(irb->codegen, err->decl_node, buf_sprintf("duplicate error: '%s'", buf_ptr(&err->name)));
-            add_error_note(irb->codegen, msg, prev_err->decl_node, buf_sprintf("other error here"));
+            ErrorMsg *msg = add_node_error(irb->codegen, ast_field_to_symbol_node(err->decl_node),
+                    buf_sprintf("duplicate error: '%s'", buf_ptr(&err->name)));
+            add_error_note(irb->codegen, msg, ast_field_to_symbol_node(prev_err->decl_node),
+                    buf_sprintf("other error here"));
             return irb->codegen->invalid_instruction;
         }
         errors[err->value] = err;
@@ -9479,6 +9487,14 @@ static void populate_error_set_table(ErrorTableEntry **errors, ZigType *set) {
     }
 }
 
+static ErrorTableEntry *better_documented_error(ErrorTableEntry *preferred, ErrorTableEntry *other) {
+    if (preferred->decl_node->type == NodeTypeErrorSetField)
+        return preferred;
+    if (other->decl_node->type == NodeTypeErrorSetField)
+        return other;
+    return preferred;
+}
+
 static ZigType *get_error_set_intersection(IrAnalyze *ira, ZigType *set1, ZigType *set2,
         AstNode *source_node)
 {
@@ -9505,12 +9521,17 @@ static ZigType *get_error_set_intersection(IrAnalyze *ira, ZigType *set1, ZigTyp
     buf_resize(&err_set_type->name, 0);
     buf_appendf(&err_set_type->name, "error{");
 
+    bool need_comma = false;
     for (uint32_t i = 0; i < set2->data.error_set.err_count; i += 1) {
         ErrorTableEntry *error_entry = set2->data.error_set.errors[i];
         ErrorTableEntry *existing_entry = errors[error_entry->value];
         if (existing_entry != nullptr) {
-            intersection_list.append(existing_entry);
-            buf_appendf(&err_set_type->name, "%s,", buf_ptr(&existing_entry->name));
+            // prefer the one with docs
+            const char *comma = need_comma ? "," : "";
+            need_comma = true;
+            ErrorTableEntry *existing_entry_with_docs = better_documented_error(existing_entry, error_entry);
+            intersection_list.append(existing_entry_with_docs);
+            buf_appendf(&err_set_type->name, "%s%s", comma, buf_ptr(&existing_entry_with_docs->name));
         }
     }
     free(errors);
@@ -12058,7 +12079,7 @@ static void report_recursive_error(IrAnalyze *ira, AstNode *source_node, ConstCa
             ZigList<ErrorTableEntry *> *missing_errors = &cast_result->data.error_set_mismatch->missing_errors;
             for (size_t i = 0; i < missing_errors->length; i += 1) {
                 ErrorTableEntry *error_entry = missing_errors->at(i);
-                add_error_note(ira->codegen, parent_msg, error_entry->decl_node,
+                add_error_note(ira->codegen, parent_msg, ast_field_to_symbol_node(error_entry->decl_node),
                     buf_sprintf("'error.%s' not a member of destination error set", buf_ptr(&error_entry->name)));
             }
             break;
diff --git a/src/parser.cpp b/src/parser.cpp
index 2aab416f20..9fcf233e2d 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -498,8 +498,12 @@ static AstNode *ast_parse_root(ParseContext *pc) {
 }
 
 static Token *ast_parse_doc_comments(ParseContext *pc, Buf *buf) {
+    Token *first_doc_token = nullptr;
     Token *doc_token = nullptr;
     while ((doc_token = eat_token_if(pc, TokenIdDocComment))) {
+        if (first_doc_token == nullptr) {
+            first_doc_token = doc_token;
+        }
         if (buf->list.length == 0) {
             buf_resize(buf, 0);
         }
@@ -507,7 +511,7 @@ static Token *ast_parse_doc_comments(ParseContext *pc, Buf *buf) {
         buf_append_mem(buf, buf_ptr(pc->buf) + doc_token->start_pos + 3,
                 doc_token->end_pos - doc_token->start_pos - 3);
     }
-    return doc_token;
+    return first_doc_token;
 }
 
 // ContainerMembers
-- 
cgit v1.2.3


From 2550cb4638e12e94073cbca5c0ee3aa263c25dbe Mon Sep 17 00:00:00 2001
From: Vexu <15308111+Vexu@users.noreply.github.com>
Date: Mon, 21 Oct 2019 22:22:08 +0300
Subject: remove pub syntax for container fields

---
 doc/langref.html.in            |  4 ++--
 lib/std/child_process.zig      | 32 ++++++++++++++++----------------
 lib/std/heap.zig               |  2 +-
 lib/std/http/headers.zig       |  6 +++---
 lib/std/io.zig                 | 20 ++++++++++----------
 lib/std/io/seekable_stream.zig |  4 ++--
 lib/std/zig/ast.zig            |  4 +---
 lib/std/zig/parse.zig          | 16 +++++++---------
 lib/std/zig/parser_test.zig    |  6 +++---
 lib/std/zig/render.zig         |  8 ++------
 src/all_types.hpp              |  2 --
 src/parser.cpp                 | 16 +++++++---------
 12 files changed, 54 insertions(+), 66 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/doc/langref.html.in b/doc/langref.html.in
index a30670b0c7..17792d6470 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -10086,8 +10086,8 @@ ContainerMembers
     &lt;- TestDecl ContainerMembers
      / TopLevelComptime ContainerMembers
      / KEYWORD_pub? TopLevelDecl ContainerMembers
-     / KEYWORD_pub? ContainerField COMMA ContainerMembers
-     / KEYWORD_pub? ContainerField
+     / ContainerField COMMA ContainerMembers
+     / ContainerField
      /
 
 TestDecl &lt;- KEYWORD_test STRINGLITERAL Block
diff --git a/lib/std/child_process.zig b/lib/std/child_process.zig
index 7fb663ac28..d786c3f4de 100644
--- a/lib/std/child_process.zig
+++ b/lib/std/child_process.zig
@@ -17,35 +17,35 @@ const TailQueue = std.TailQueue;
 const maxInt = std.math.maxInt;
 
 pub const ChildProcess = struct {
-    pub pid: if (os.windows.is_the_target) void else i32,
-    pub handle: if (os.windows.is_the_target) windows.HANDLE else void,
-    pub thread_handle: if (os.windows.is_the_target) windows.HANDLE else void,
+    pid: if (os.windows.is_the_target) void else i32,
+    handle: if (os.windows.is_the_target) windows.HANDLE else void,
+    thread_handle: if (os.windows.is_the_target) windows.HANDLE else void,
 
-    pub allocator: *mem.Allocator,
+    allocator: *mem.Allocator,
 
-    pub stdin: ?File,
-    pub stdout: ?File,
-    pub stderr: ?File,
+    stdin: ?File,
+    stdout: ?File,
+    stderr: ?File,
 
-    pub term: ?(SpawnError!Term),
+    term: ?(SpawnError!Term),
 
-    pub argv: []const []const u8,
+    argv: []const []const u8,
 
     /// Leave as null to use the current env map using the supplied allocator.
-    pub env_map: ?*const BufMap,
+    env_map: ?*const BufMap,
 
-    pub stdin_behavior: StdIo,
-    pub stdout_behavior: StdIo,
-    pub stderr_behavior: StdIo,
+    stdin_behavior: StdIo,
+    stdout_behavior: StdIo,
+    stderr_behavior: StdIo,
 
     /// Set to change the user id when spawning the child process.
-    pub uid: if (os.windows.is_the_target) void else ?u32,
+    uid: if (os.windows.is_the_target) void else ?u32,
 
     /// Set to change the group id when spawning the child process.
-    pub gid: if (os.windows.is_the_target) void else ?u32,
+    gid: if (os.windows.is_the_target) void else ?u32,
 
     /// Set to change the current working directory when spawning the child process.
-    pub cwd: ?[]const u8,
+    cwd: ?[]const u8,
 
     err_pipe: if (os.windows.is_the_target) void else [2]os.fd_t,
     llnode: if (os.windows.is_the_target) void else TailQueue(*ChildProcess).Node,
diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index b968b6242f..f3a0d457d2 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -338,7 +338,7 @@ pub const HeapAllocator = switch (builtin.os) {
 /// This allocator takes an existing allocator, wraps it, and provides an interface
 /// where you can allocate without freeing, and then free it all together.
 pub const ArenaAllocator = struct {
-    pub allocator: Allocator,
+    allocator: Allocator,
 
     child_allocator: *Allocator,
     buffer_list: std.SinglyLinkedList([]u8),
diff --git a/lib/std/http/headers.zig b/lib/std/http/headers.zig
index a8dfa68629..7ee035ce80 100644
--- a/lib/std/http/headers.zig
+++ b/lib/std/http/headers.zig
@@ -28,9 +28,9 @@ fn never_index_default(name: []const u8) bool {
 
 const HeaderEntry = struct {
     allocator: *Allocator,
-    pub name: []const u8,
-    pub value: []u8,
-    pub never_index: bool,
+    name: []const u8,
+    value: []u8,
+    never_index: bool,
 
     const Self = @This();
 
diff --git a/lib/std/io.zig b/lib/std/io.zig
index 4407e6b2b3..f9082ee952 100644
--- a/lib/std/io.zig
+++ b/lib/std/io.zig
@@ -161,7 +161,7 @@ pub fn BufferedInStreamCustom(comptime buffer_size: usize, comptime Error: type)
         const Self = @This();
         const Stream = InStream(Error);
 
-        pub stream: Stream,
+        stream: Stream,
 
         unbuffered_in_stream: *Stream,
 
@@ -273,7 +273,7 @@ pub fn PeekStream(comptime buffer_size: usize, comptime InStreamError: type) typ
         pub const Error = InStreamError;
         pub const Stream = InStream(Error);
 
-        pub stream: Stream,
+        stream: Stream,
         base: *Stream,
 
         // Right now the look-ahead space is statically allocated, but a version with dynamic allocation
@@ -336,7 +336,7 @@ pub const SliceInStream = struct {
     pub const Error = error{};
     pub const Stream = InStream(Error);
 
-    pub stream: Stream,
+    stream: Stream,
 
     pos: usize,
     slice: []const u8,
@@ -514,9 +514,9 @@ pub const SliceOutStream = struct {
     pub const Error = error{OutOfSpace};
     pub const Stream = OutStream(Error);
 
-    pub stream: Stream,
+    stream: Stream,
 
-    pub pos: usize,
+    pos: usize,
     slice: []u8,
 
     pub fn init(slice: []u8) SliceOutStream {
@@ -571,7 +571,7 @@ pub const NullOutStream = struct {
     pub const Error = error{};
     pub const Stream = OutStream(Error);
 
-    pub stream: Stream,
+    stream: Stream,
 
     pub fn init() NullOutStream {
         return NullOutStream{
@@ -595,8 +595,8 @@ pub fn CountingOutStream(comptime OutStreamError: type) type {
         pub const Stream = OutStream(Error);
         pub const Error = OutStreamError;
 
-        pub stream: Stream,
-        pub bytes_written: u64,
+        stream: Stream,
+        bytes_written: u64,
         child_stream: *Stream,
 
         pub fn init(child_stream: *Stream) Self {
@@ -635,7 +635,7 @@ pub fn BufferedOutStreamCustom(comptime buffer_size: usize, comptime OutStreamEr
         pub const Stream = OutStream(Error);
         pub const Error = OutStreamError;
 
-        pub stream: Stream,
+        stream: Stream,
 
         unbuffered_out_stream: *Stream,
 
@@ -1084,7 +1084,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
                         // safety. If it is bad, it will be caught anyway.
                         const TagInt = @TagType(TagType);
                         const tag = try self.deserializeInt(TagInt);
-                        
+
                         inline for (info.fields) |field_info| {
                             if (field_info.enum_field.?.value == tag) {
                                 const name = field_info.name;
diff --git a/lib/std/io/seekable_stream.zig b/lib/std/io/seekable_stream.zig
index 86f76d8c14..48dc31b785 100644
--- a/lib/std/io/seekable_stream.zig
+++ b/lib/std/io/seekable_stream.zig
@@ -39,8 +39,8 @@ pub const SliceSeekableInStream = struct {
     pub const Stream = InStream(Error);
     pub const SeekableInStream = SeekableStream(SeekError, GetSeekPosError);
 
-    pub stream: Stream,
-    pub seekable_stream: SeekableInStream,
+    stream: Stream,
+    seekable_stream: SeekableInStream,
 
     pos: usize,
     slice: []const u8,
diff --git a/lib/std/zig/ast.zig b/lib/std/zig/ast.zig
index 79e6647144..9f32c6e54b 100644
--- a/lib/std/zig/ast.zig
+++ b/lib/std/zig/ast.zig
@@ -290,7 +290,7 @@ pub const Error = union(enum) {
     pub const ExpectedSuffixOp = SingleTokenError("Expected pointer dereference, optional unwrap, or field access, found '{}'");
 
     pub const ExpectedParamType = SimpleError("Expected parameter type");
-    pub const ExpectedPubItem = SimpleError("Pub must be followed by fn decl, var decl, or container member");
+    pub const ExpectedPubItem = SimpleError("Expected function or variable declaration after pub");
     pub const UnattachedDocComment = SimpleError("Unattached documentation comment");
     pub const ExtraAlignQualifier = SimpleError("Extra align qualifier");
     pub const ExtraConstQualifier = SimpleError("Extra const qualifier");
@@ -757,7 +757,6 @@ pub const Node = struct {
     pub const ContainerField = struct {
         base: Node,
         doc_comments: ?*DocComment,
-        visib_token: ?TokenIndex,
         name_token: TokenIndex,
         type_expr: ?*Node,
         value_expr: ?*Node,
@@ -780,7 +779,6 @@ pub const Node = struct {
         }
 
         pub fn firstToken(self: *const ContainerField) TokenIndex {
-            if (self.visib_token) |visib_token| return visib_token;
             return self.name_token;
         }
 
diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 151784284d..71fa376361 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -138,9 +138,15 @@ fn parseContainerMembers(arena: *Allocator, it: *TokenIterator, tree: *Tree) !No
             continue;
         }
 
+        if (visib_token != null) {
+            try tree.errors.push(AstError{
+                .ExpectedPubItem = AstError.ExpectedPubItem{ .token = it.index },
+            });
+            return error.ParseError;
+        }
+
         if (try parseContainerField(arena, it, tree)) |node| {
             const field = node.cast(Node.ContainerField).?;
-            field.visib_token = visib_token;
             field.doc_comments = doc_comments;
             try list.push(node);
             const comma = eatToken(it, .Comma) orelse break;
@@ -149,13 +155,6 @@ fn parseContainerMembers(arena: *Allocator, it: *TokenIterator, tree: *Tree) !No
             continue;
         }
 
-        // Dangling pub
-        if (visib_token != null) {
-            try tree.errors.push(AstError{
-                .ExpectedPubItem = AstError.ExpectedPubItem{ .token = it.index },
-            });
-        }
-
         break;
     }
 
@@ -407,7 +406,6 @@ fn parseContainerField(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*No
     node.* = Node.ContainerField{
         .base = Node{ .id = .ContainerField },
         .doc_comments = null,
-        .visib_token = null,
         .name_token = name_token,
         .type_expr = type_expr,
         .value_expr = value_expr,
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 78f80786c5..28bd287c8a 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -1766,7 +1766,7 @@ test "zig fmt: struct declaration" {
         \\const S = struct {
         \\    const Self = @This();
         \\    f1: u8,
-        \\    pub f3: u8,
+        \\    f3: u8,
         \\
         \\    fn method(self: *Self) Self {
         \\        return self.*;
@@ -1777,14 +1777,14 @@ test "zig fmt: struct declaration" {
         \\
         \\const Ps = packed struct {
         \\    a: u8,
-        \\    pub b: u8,
+        \\    b: u8,
         \\
         \\    c: u8,
         \\};
         \\
         \\const Es = extern struct {
         \\    a: u8,
-        \\    pub b: u8,
+        \\    b: u8,
         \\
         \\    c: u8,
         \\};
diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig
index 1be4410f38..e5875fd04f 100644
--- a/lib/std/zig/render.zig
+++ b/lib/std/zig/render.zig
@@ -254,10 +254,6 @@ fn renderTopLevelDecl(allocator: *mem.Allocator, stream: var, tree: *ast.Tree, i
 
             try renderDocComments(tree, stream, field, indent, start_col);
 
-            if (field.visib_token) |visib_token| {
-                try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
-            }
-
             if (field.type_expr == null and field.value_expr == null) {
                 return renderToken(tree, stream, field.name_token, indent, start_col, Space.Comma); // name,
             } else if (field.type_expr != null and field.value_expr == null) {
@@ -2206,8 +2202,8 @@ const FindByteOutStream = struct {
     pub const Error = error{};
     pub const Stream = std.io.OutStream(Error);
 
-    pub stream: Stream,
-    pub byte_found: bool,
+    stream: Stream,
+    byte_found: bool,
     byte: u8,
 
     pub fn init(byte: u8) Self {
diff --git a/src/all_types.hpp b/src/all_types.hpp
index e2e1db48d4..267c5479be 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -990,8 +990,6 @@ struct AstNodeStructField {
     // populated if the "align(A)" is present
     AstNode *align_expr;
     Buf doc_comments;
-
-    VisibMod visib_mod;
 };
 
 struct AstNodeStringLiteral {
diff --git a/src/parser.cpp b/src/parser.cpp
index 9fcf233e2d..b6742ef1f1 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -518,8 +518,8 @@ static Token *ast_parse_doc_comments(ParseContext *pc, Buf *buf) {
 //     <- TestDecl ContainerMembers
 //      / TopLevelComptime ContainerMembers
 //      / KEYWORD_pub? TopLevelDecl ContainerMembers
-//      / KEYWORD_pub? ContainerField COMMA ContainerMembers
-//      / KEYWORD_pub? ContainerField
+//      / ContainerField COMMA ContainerMembers
+//      / ContainerField
 //      /
 static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
     AstNodeContainerDecl res = {};
@@ -548,10 +548,13 @@ static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
             continue;
         }
 
+        if (visib_token != nullptr) {
+            ast_error(pc, peek_token(pc), "expected function or variable declaration after pub");
+        }
+
         AstNode *container_field = ast_parse_container_field(pc);
         if (container_field != nullptr) {
             assert(container_field->type == NodeTypeStructField);
-            container_field->data.struct_field.visib_mod = visib_mod;
             container_field->data.struct_field.doc_comments = doc_comment_buf;
             res.fields.append(container_field);
             if (eat_token_if(pc, TokenIdComma) != nullptr) {
@@ -561,12 +564,7 @@ static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
             }
         }
 
-        // We visib_token wasn't eaten, then we haven't consumed the first token in this rule yet.
-        // It is therefore safe to return and let the caller continue parsing.
-        if (visib_token == nullptr)
-            break;
-
-        ast_invalid_token_error(pc, peek_token(pc));
+        break;
     }
 
     return res;
-- 
cgit v1.2.3


From c1e8fdf812692edb9c7e496b00294aa749e81079 Mon Sep 17 00:00:00 2001
From: Brendan Hansknecht <brendan.hansknecht@gmail.com>
Date: Thu, 31 Oct 2019 21:53:46 -0700
Subject: add token for parsing pointer dereference

---
 doc/docgen.zig                     | 1 +
 lib/std/zig/parse.zig              | 7 ++++---
 lib/std/zig/render.zig             | 9 +++++++--
 lib/std/zig/tokenizer.zig          | 7 +++++++
 src/parser.cpp                     | 6 ++++--
 src/tokenizer.cpp                  | 6 ++++++
 src/tokenizer.hpp                  | 1 +
 test/stage1/behavior/bugs/3468.zig | 6 ++++++
 8 files changed, 36 insertions(+), 7 deletions(-)
 create mode 100644 test/stage1/behavior/bugs/3468.zig

(limited to 'src/parser.cpp')

diff --git a/doc/docgen.zig b/doc/docgen.zig
index bdc2604213..07a7f23968 100644
--- a/doc/docgen.zig
+++ b/doc/docgen.zig
@@ -917,6 +917,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
             .LBracket,
             .RBracket,
             .Period,
+            .PeriodAsterisk,
             .Ellipsis2,
             .Ellipsis3,
             .Caret,
diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 71fa376361..4c6c461c01 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -2363,6 +2363,10 @@ fn parseSuffixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
             };
         }
 
+        if (eatToken(it, .PeriodAsterisk)) |period_asterisk| {
+            break :blk OpAndToken{ .op = Op{ .Deref = {} }, .token = period_asterisk };
+        }
+
         if (eatToken(it, .Period)) |period| {
             if (try parseIdentifier(arena, it, tree)) |identifier| {
                 // TODO: It's a bit weird to return an InfixOp from the SuffixOp parser.
@@ -2378,9 +2382,6 @@ fn parseSuffixOp(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
                 };
                 return &node.base;
             }
-            if (eatToken(it, .Asterisk)) |asterisk| {
-                break :blk OpAndToken{ .op = Op{ .Deref = {} }, .token = asterisk };
-            }
             if (eatToken(it, .QuestionMark)) |question_mark| {
                 break :blk OpAndToken{ .op = Op{ .UnwrapOptional = {} }, .token = question_mark };
             }
diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig
index e5875fd04f..996cfc29e4 100644
--- a/lib/std/zig/render.zig
+++ b/lib/std/zig/render.zig
@@ -617,10 +617,15 @@ fn renderExpression(
                     return renderToken(tree, stream, rbracket, indent, start_col, space); // ]
                 },
 
-                ast.Node.SuffixOp.Op.Deref, ast.Node.SuffixOp.Op.UnwrapOptional => {
+                ast.Node.SuffixOp.Op.Deref => {
+                    try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
+                    return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // .*
+                },
+
+                ast.Node.SuffixOp.Op.UnwrapOptional => {
                     try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
                     try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, start_col, Space.None); // .
-                    return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // * or ?
+                    return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // ?
                 },
 
                 @TagType(ast.Node.SuffixOp.Op).Slice => |range| {
diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 872893a607..672bd482da 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -103,6 +103,7 @@ pub const Token = struct {
         LBracket,
         RBracket,
         Period,
+        PeriodAsterisk,
         Ellipsis2,
         Ellipsis3,
         Caret,
@@ -231,6 +232,7 @@ pub const Token = struct {
                 .LBracket => "[",
                 .RBracket => "]",
                 .Period => ".",
+                .PeriodAsterisk => ".*",
                 .Ellipsis2 => "..",
                 .Ellipsis3 => "...",
                 .Caret => "^",
@@ -1033,6 +1035,11 @@ pub const Tokenizer = struct {
                     '.' => {
                         state = State.Period2;
                     },
+                    '*' => {
+                        result.id = Token.Id.PeriodAsterisk;
+                        self.index += 1;
+                        break;
+                    },
                     else => {
                         result.id = Token.Id.Period;
                         break;
diff --git a/src/parser.cpp b/src/parser.cpp
index b6742ef1f1..a1ece3ed10 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -2693,10 +2693,12 @@ static AstNode *ast_parse_suffix_op(ParseContext *pc) {
         return res;
     }
 
+    Token *dot_asterisk = eat_token_if(pc, TokenIdDotStar);
+    if (dot_asterisk != nullptr)
+        return ast_create_node(pc, NodeTypePtrDeref, dot_asterisk);
+
     Token *dot = eat_token_if(pc, TokenIdDot);
     if (dot != nullptr) {
-        if (eat_token_if(pc, TokenIdStar) != nullptr)
-            return ast_create_node(pc, NodeTypePtrDeref, dot);
         if (eat_token_if(pc, TokenIdQuestion) != nullptr)
             return ast_create_node(pc, NodeTypeUnwrapOptional, dot);
 
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 475c284d27..674f0c2b96 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -583,6 +583,11 @@ void tokenize(Buf *buf, Tokenization *out) {
                         t.state = TokenizeStateSawDotDot;
                         set_token_id(&t, t.cur_tok, TokenIdEllipsis2);
                         break;
+                    case '*':
+                        t.state = TokenizeStateStart;
+                        set_token_id(&t, t.cur_tok, TokenIdDotStar);
+                        end_token(&t);
+                        break;
                     default:
                         t.pos -= 1;
                         end_token(&t);
@@ -1603,6 +1608,7 @@ const char * token_name(TokenId id) {
         case TokenIdDivEq: return "/=";
         case TokenIdDocComment: return "DocComment";
         case TokenIdDot: return ".";
+        case TokenIdDotStar: return ".*";
         case TokenIdEllipsis2: return "..";
         case TokenIdEllipsis3: return "...";
         case TokenIdEof: return "EOF";
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index e33a82f31d..ee336123bb 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -44,6 +44,7 @@ enum TokenId {
     TokenIdDivEq,
     TokenIdDocComment,
     TokenIdDot,
+    TokenIdDotStar,
     TokenIdEllipsis2,
     TokenIdEllipsis3,
     TokenIdEof,
diff --git a/test/stage1/behavior/bugs/3468.zig b/test/stage1/behavior/bugs/3468.zig
new file mode 100644
index 0000000000..adf3db3306
--- /dev/null
+++ b/test/stage1/behavior/bugs/3468.zig
@@ -0,0 +1,6 @@
+// zig fmt: off
+test "pointer deref next to assignment" {
+    var a:i32=2;
+    var b=&a;
+    b.*=3;
+}
-- 
cgit v1.2.3


From de30438ed2efb909538f3177cced441b57eb1a5d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 6 Nov 2019 16:15:12 -0500
Subject: stage1 parser code for anon container lit

---
 src/parser.cpp | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/src/parser.cpp b/src/parser.cpp
index a1ece3ed10..484e145cfa 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -81,7 +81,7 @@ static AstNode *ast_parse_for_type_expr(ParseContext *pc);
 static AstNode *ast_parse_while_type_expr(ParseContext *pc);
 static AstNode *ast_parse_switch_expr(ParseContext *pc);
 static AstNode *ast_parse_asm_expr(ParseContext *pc);
-static AstNode *ast_parse_enum_lit(ParseContext *pc);
+static AstNode *ast_parse_anon_lit(ParseContext *pc);
 static AstNode *ast_parse_asm_output(ParseContext *pc);
 static AsmOutput *ast_parse_asm_output_item(ParseContext *pc);
 static AstNode *ast_parse_asm_input(ParseContext *pc);
@@ -1600,9 +1600,9 @@ static AstNode *ast_parse_primary_type_expr(ParseContext *pc) {
     if (container_decl != nullptr)
         return container_decl;
 
-    AstNode *enum_lit = ast_parse_enum_lit(pc);
-    if (enum_lit != nullptr)
-        return enum_lit;
+    AstNode *anon_lit = ast_parse_anon_lit(pc);
+    if (anon_lit != nullptr)
+        return anon_lit;
 
     AstNode *error_set_decl = ast_parse_error_set_decl(pc);
     if (error_set_decl != nullptr)
@@ -1876,16 +1876,22 @@ static AstNode *ast_parse_asm_expr(ParseContext *pc) {
     return res;
 }
 
-static AstNode *ast_parse_enum_lit(ParseContext *pc) {
+static AstNode *ast_parse_anon_lit(ParseContext *pc) {
     Token *period = eat_token_if(pc, TokenIdDot);
     if (period == nullptr)
         return nullptr;
 
-    Token *identifier = expect_token(pc, TokenIdSymbol);
-    AstNode *res = ast_create_node(pc, NodeTypeEnumLiteral, period);
-    res->data.enum_literal.period = period;
-    res->data.enum_literal.identifier = identifier;
-    return res;
+    // anon enum literal
+    Token *identifier = eat_token_if(pc, TokenIdSymbol);
+    if (identifier != nullptr) {
+        AstNode *res = ast_create_node(pc, NodeTypeEnumLiteral, period);
+        res->data.enum_literal.period = period;
+        res->data.enum_literal.identifier = identifier;
+        return res;
+    }
+
+    // anon container literal
+    return ast_parse_init_list(pc);
 }
 
 // AsmOutput <- COLON AsmOutputList AsmInput?
-- 
cgit v1.2.3


From e509d21f39af726da3c6001b0c20f2c765be07a5 Mon Sep 17 00:00:00 2001
From: Vexu <15308111+Vexu@users.noreply.github.com>
Date: Fri, 15 Nov 2019 14:12:14 +0200
Subject: implemented container doc comments in stage 1

---
 src/all_types.hpp |  1 +
 src/parser.cpp    | 23 ++++++++++++++++++++++-
 src/tokenizer.cpp | 32 ++++++++++++++++++++++++++++++++
 src/tokenizer.hpp |  1 +
 4 files changed, 56 insertions(+), 1 deletion(-)

(limited to 'src/parser.cpp')

diff --git a/src/all_types.hpp b/src/all_types.hpp
index a1e9d76be7..c4178cb130 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -968,6 +968,7 @@ struct AstNodeContainerDecl {
     AstNode *init_arg_expr; // enum(T), struct(endianness), or union(T), or union(enum(T))
     ZigList<AstNode *> fields;
     ZigList<AstNode *> decls;
+    Buf doc_comments;
 
     ContainerKind kind;
     ContainerLayout layout;
diff --git a/src/parser.cpp b/src/parser.cpp
index 484e145cfa..eef832e32c 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -493,6 +493,7 @@ static AstNode *ast_parse_root(ParseContext *pc) {
     node->data.container_decl.layout = ContainerLayoutAuto;
     node->data.container_decl.kind = ContainerKindStruct;
     node->data.container_decl.is_root = true;
+    node->data.container_decl.doc_comments = members.doc_comments;
 
     return node;
 }
@@ -514,6 +515,21 @@ static Token *ast_parse_doc_comments(ParseContext *pc, Buf *buf) {
     return first_doc_token;
 }
 
+static void ast_parse_container_doc_comments(ParseContext *pc, Buf *buf) {
+    if (buf_len(buf) != 0 && peek_token(pc)->id == TokenIdContainerDocComment) {
+        buf_append_char(buf, '\n');
+    }
+    Token *doc_token = nullptr;
+    while ((doc_token = eat_token_if(pc, TokenIdContainerDocComment))) {
+        if (buf->list.length == 0) {
+            buf_resize(buf, 0);
+        }
+        // chops off '//!' but leaves '\n'
+        buf_append_mem(buf, buf_ptr(pc->buf) + doc_token->start_pos + 3,
+                doc_token->end_pos - doc_token->start_pos - 3);
+    }
+}
+
 // ContainerMembers
 //     <- TestDecl ContainerMembers
 //      / TopLevelComptime ContainerMembers
@@ -523,7 +539,11 @@ static Token *ast_parse_doc_comments(ParseContext *pc, Buf *buf) {
 //      /
 static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
     AstNodeContainerDecl res = {};
+    Buf tld_doc_comment_buf = BUF_INIT;
+    buf_resize(&tld_doc_comment_buf, 0);
     for (;;) {
+        ast_parse_container_doc_comments(pc, &tld_doc_comment_buf);
+
         AstNode *test_decl = ast_parse_test_decl(pc);
         if (test_decl != nullptr) {
             res.decls.append(test_decl);
@@ -566,7 +586,7 @@ static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
 
         break;
     }
-
+    res.doc_comments = tld_doc_comment_buf;
     return res;
 }
 
@@ -2797,6 +2817,7 @@ static AstNode *ast_parse_container_decl_auto(ParseContext *pc) {
 
     res->data.container_decl.fields = members.fields;
     res->data.container_decl.decls = members.decls;
+    res->data.container_decl.doc_comments = members.doc_comments;
     return res;
 }
 
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 8b301f85ac..7ece5ff3fe 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -198,6 +198,7 @@ enum TokenizeState {
     TokenizeStateSawSlash,
     TokenizeStateSawSlash2,
     TokenizeStateSawSlash3,
+    TokenizeStateSawSlashBang,
     TokenizeStateSawBackslash,
     TokenizeStateSawPercent,
     TokenizeStateSawPlus,
@@ -209,6 +210,7 @@ enum TokenizeState {
     TokenizeStateSawBar,
     TokenizeStateSawBarBar,
     TokenizeStateDocComment,
+    TokenizeStateContainerDocComment,
     TokenizeStateLineComment,
     TokenizeStateLineString,
     TokenizeStateLineStringEnd,
@@ -938,6 +940,9 @@ void tokenize(Buf *buf, Tokenization *out) {
                     case '/':
                         t.state = TokenizeStateSawSlash3;
                         break;
+                    case '!':
+                        t.state = TokenizeStateSawSlashBang;
+                        break;
                     case '\n':
                         cancel_token(&t);
                         t.state = TokenizeStateStart;
@@ -965,6 +970,19 @@ void tokenize(Buf *buf, Tokenization *out) {
                         break;
                 }
                 break;
+            case TokenizeStateSawSlashBang:
+                switch (c) {
+                    case '\n':
+                        set_token_id(&t, t.cur_tok, TokenIdContainerDocComment);
+                        end_token(&t);
+                        t.state = TokenizeStateStart;
+                        break;
+                    default:
+                        set_token_id(&t, t.cur_tok, TokenIdContainerDocComment);
+                        t.state = TokenizeStateContainerDocComment;
+                        break;
+                }
+                break;
             case TokenizeStateSawBackslash:
                 switch (c) {
                     case '\\':
@@ -1055,6 +1073,17 @@ void tokenize(Buf *buf, Tokenization *out) {
                         break;
                 }
                 break;
+            case TokenizeStateContainerDocComment:
+                switch (c) {
+                    case '\n':
+                        end_token(&t);
+                        t.state = TokenizeStateStart;
+                        break;
+                    default:
+                        // do nothing
+                        break;
+                }
+                break;
             case TokenizeStateSymbolFirstC:
                 switch (c) {
                     case '"':
@@ -1545,6 +1574,7 @@ void tokenize(Buf *buf, Tokenization *out) {
         case TokenizeStateSawBarBar:
         case TokenizeStateLBracket:
         case TokenizeStateDocComment:
+        case TokenizeStateContainerDocComment:
             end_token(&t);
             break;
         case TokenizeStateSawDotDot:
@@ -1559,6 +1589,7 @@ void tokenize(Buf *buf, Tokenization *out) {
         case TokenizeStateLineComment:
         case TokenizeStateSawSlash2:
         case TokenizeStateSawSlash3:
+        case TokenizeStateSawSlashBang:
             break;
     }
     if (t.state != TokenizeStateError) {
@@ -1606,6 +1637,7 @@ const char * token_name(TokenId id) {
         case TokenIdDash: return "-";
         case TokenIdDivEq: return "/=";
         case TokenIdDocComment: return "DocComment";
+        case TokenIdContainerDocComment: return "ContainerDocComment";
         case TokenIdDot: return ".";
         case TokenIdDotStar: return ".*";
         case TokenIdEllipsis2: return "..";
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index ee336123bb..149e58b6a7 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -43,6 +43,7 @@ enum TokenId {
     TokenIdDash,
     TokenIdDivEq,
     TokenIdDocComment,
+    TokenIdContainerDocComment,
     TokenIdDot,
     TokenIdDotStar,
     TokenIdEllipsis2,
-- 
cgit v1.2.3


From 977b6138817c4b09d6d1e47fa3562d9f9e0268a8 Mon Sep 17 00:00:00 2001
From: Vexu <15308111+Vexu@users.noreply.github.com>
Date: Fri, 15 Nov 2019 15:03:28 +0200
Subject: add container doc comments to generated docs

---
 lib/std/special/docs/index.html |  2 +-
 lib/std/special/docs/main.js    | 31 +++++++++++++++++++------------
 lib/std/zig/ast.zig             |  1 -
 src/dump_analysis.cpp           |  1 +
 src/parser.cpp                  |  8 ++++++--
 5 files changed, 27 insertions(+), 16 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/special/docs/index.html b/lib/std/special/docs/index.html
index 81df8f30f1..b170ad4a14 100644
--- a/lib/std/special/docs/index.html
+++ b/lib/std/special/docs/index.html
@@ -484,7 +484,7 @@
               doc comments.
               </p>
             </div>
-            <div id="fnDocs" class="hidden"></div>
+            <div id="tldDocs" class="hidden"></div>
             <div id="sectFnErrors" class="hidden">
               <h2>Errors</h2>
               <div id="fnErrorsAnyError">
diff --git a/lib/std/special/docs/main.js b/lib/std/special/docs/main.js
index e0d6cdaf05..1812671227 100644
--- a/lib/std/special/docs/main.js
+++ b/lib/std/special/docs/main.js
@@ -20,7 +20,7 @@
     var domListValues = document.getElementById("listValues");
     var domFnProto = document.getElementById("fnProto");
     var domFnProtoCode = document.getElementById("fnProtoCode");
-    var domFnDocs = document.getElementById("fnDocs");
+    var domTldDocs = document.getElementById("tldDocs");
     var domSectFnErrors = document.getElementById("sectFnErrors");
     var domListFnErrors = document.getElementById("listFnErrors");
     var domTableFnErrors = document.getElementById("tableFnErrors");
@@ -34,7 +34,6 @@
     var domListSearchResults = document.getElementById("listSearchResults");
     var domSectSearchNoResults = document.getElementById("sectSearchNoResults");
     var domSectInfo = document.getElementById("sectInfo");
-    var domListInfo = document.getElementById("listInfo");
     var domTdTarget = document.getElementById("tdTarget");
     var domTdZigVer = document.getElementById("tdZigVer");
     var domHdrName = document.getElementById("hdrName");
@@ -102,7 +101,7 @@
     function render() {
         domStatus.classList.add("hidden");
         domFnProto.classList.add("hidden");
-        domFnDocs.classList.add("hidden");
+        domTldDocs.classList.add("hidden");
         domSectPkgs.classList.add("hidden");
         domSectTypes.classList.add("hidden");
         domSectNamespaces.classList.add("hidden");
@@ -190,11 +189,11 @@
 
         var docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
-            domFnDocs.innerHTML = markdown(docs);
+            domTldDocs.innerHTML = markdown(docs);
         } else {
-            domFnDocs.innerHTML = '<p>There are no doc comments for this declaration.</p>';
+            domTldDocs.innerHTML = '<p>There are no doc comments for this declaration.</p>';
         }
-        domFnDocs.classList.remove("hidden");
+        domTldDocs.classList.remove("hidden");
     }
 
     function typeIsErrSet(typeIndex) {
@@ -274,8 +273,8 @@
             docsSource = protoSrcNode.docs;
         }
         if (docsSource != null) {
-            domFnDocs.innerHTML = markdown(docsSource);
-            domFnDocs.classList.remove("hidden");
+            domTldDocs.innerHTML = markdown(docsSource);
+            domTldDocs.classList.remove("hidden");
         }
         domFnProto.classList.remove("hidden");
     }
@@ -893,8 +892,8 @@
 
         var docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
-            domFnDocs.innerHTML = markdown(docs);
-            domFnDocs.classList.remove("hidden");
+            domTldDocs.innerHTML = markdown(docs);
+            domTldDocs.classList.remove("hidden");
         }
 
         domFnProto.classList.remove("hidden");
@@ -906,8 +905,8 @@
 
         var docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
-            domFnDocs.innerHTML = markdown(docs);
-            domFnDocs.classList.remove("hidden");
+            domTldDocs.innerHTML = markdown(docs);
+            domTldDocs.classList.remove("hidden");
         }
 
         domFnProto.classList.remove("hidden");
@@ -957,6 +956,14 @@
         varsList.sort(byNameProperty);
         valsList.sort(byNameProperty);
 
+        if (container.src != null) {
+            var docs = zigAnalysis.astNodes[container.src].docs;
+            if (docs != null) {
+                domTldDocs.innerHTML = markdown(docs);
+                domTldDocs.classList.remove("hidden");
+            }
+        }
+
         if (typesList.length !== 0) {
             resizeDomList(domListTypes, typesList.length, '<li><a href="#"></a></li>');
             for (var i = 0; i < typesList.length; i += 1) {
diff --git a/lib/std/zig/ast.zig b/lib/std/zig/ast.zig
index 65fbc51606..0a7bfe2f56 100644
--- a/lib/std/zig/ast.zig
+++ b/lib/std/zig/ast.zig
@@ -2253,7 +2253,6 @@ pub const Node = struct {
 test "iterate" {
     var root = Node.Root{
         .base = Node{ .id = Node.Id.Root },
-        .doc_comments = null,
         .decls = Node.Root.DeclList.init(std.debug.global_allocator),
         .eof_token = 0,
     };
diff --git a/src/dump_analysis.cpp b/src/dump_analysis.cpp
index b5fd38e266..98bbcc6a42 100644
--- a/src/dump_analysis.cpp
+++ b/src/dump_analysis.cpp
@@ -1088,6 +1088,7 @@ static void anal_dump_node(AnalDumpCtx *ctx, const AstNode *node) {
             break;
         case NodeTypeContainerDecl:
             field_nodes = &node->data.container_decl.fields;
+            doc_comments_buf = &node->data.container_decl.doc_comments;
             break;
         default:
             break;
diff --git a/src/parser.cpp b/src/parser.cpp
index eef832e32c..04dccb0d2a 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -493,7 +493,9 @@ static AstNode *ast_parse_root(ParseContext *pc) {
     node->data.container_decl.layout = ContainerLayoutAuto;
     node->data.container_decl.kind = ContainerKindStruct;
     node->data.container_decl.is_root = true;
-    node->data.container_decl.doc_comments = members.doc_comments;
+    if (buf_len(&members.doc_comments) != 0) {
+        node->data.container_decl.doc_comments = members.doc_comments;
+    }
 
     return node;
 }
@@ -2817,7 +2819,9 @@ static AstNode *ast_parse_container_decl_auto(ParseContext *pc) {
 
     res->data.container_decl.fields = members.fields;
     res->data.container_decl.decls = members.decls;
-    res->data.container_decl.doc_comments = members.doc_comments;
+    if (buf_len(&members.doc_comments) != 0) {
+        res->data.container_decl.doc_comments = members.doc_comments;
+    }
     return res;
 }
 
-- 
cgit v1.2.3


From 6cddf9d7238a58b88064c3f3ce6e3948143598d8 Mon Sep 17 00:00:00 2001
From: Vexu <15308111+Vexu@users.noreply.github.com>
Date: Sun, 17 Nov 2019 17:07:48 +0200
Subject: properly parse anon literal in array

---
 lib/std/zig/parse.zig          |  6 +++++-
 lib/std/zig/parser_test.zig    | 10 ++++++++++
 src/parser.cpp                 |  7 ++++++-
 test/stage1/behavior/array.zig | 21 +++++++++++++++++++++
 4 files changed, 42 insertions(+), 2 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 6d5d4b5f2d..3ad82824ce 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -1630,7 +1630,11 @@ fn parseBlockLabel(arena: *Allocator, it: *TokenIterator, tree: *Tree) ?TokenInd
 /// FieldInit <- DOT IDENTIFIER EQUAL Expr
 fn parseFieldInit(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     const period_token = eatToken(it, .Period) orelse return null;
-    const name_token = try expectToken(it, tree, .Identifier);
+    const name_token = eatToken(it, .Identifier) orelse {
+        // Because of anon literals `.{` is also valid.
+        putBackToken(it, period_token);
+        return null;
+    };
     const eq_token = eatToken(it, .Equal) orelse {
         // `.Name` may also be an enum literal, which is a later rule.
         putBackToken(it, name_token);
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index cabbe823f6..6e5ef878d5 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -1,3 +1,13 @@
+test "zig fmt: anon literal in array" {
+    try testCanonical(
+        \\var arr: [2]Foo = .{
+        \\    .{ .a = 2 },
+        \\    .{ .b = 3 },
+        \\};
+        \\
+    );
+}
+
 test "zig fmt: anon struct literal syntax" {
     try testCanonical(
         \\const x = .{
diff --git a/src/parser.cpp b/src/parser.cpp
index 484e145cfa..65894bb833 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -2025,7 +2025,12 @@ static AstNode *ast_parse_field_init(ParseContext *pc) {
     if (first == nullptr)
         return nullptr;
 
-    Token *name = expect_token(pc, TokenIdSymbol);
+    Token *name = eat_token_if(pc, TokenIdSymbol);
+    if (name == nullptr) {
+        // Because of anon literals ".{" is also valid.
+        put_back_token(pc);
+        return nullptr;
+    }
     if (eat_token_if(pc, TokenIdEq) == nullptr) {
         // Because ".Name" can also be intepreted as an enum literal, we should put back
         // those two tokens again so that the parser can try to parse them as the enum
diff --git a/test/stage1/behavior/array.zig b/test/stage1/behavior/array.zig
index 0558a47fa4..3a9c9a7655 100644
--- a/test/stage1/behavior/array.zig
+++ b/test/stage1/behavior/array.zig
@@ -312,3 +312,24 @@ test "anonymous list literal syntax" {
     S.doTheTest();
     comptime S.doTheTest();
 }
+
+test "anonymous literal in array" {
+    const S = struct {
+        const Foo = struct {
+            a: usize = 2,
+            b: usize = 4,
+        };
+        fn doTheTest() void {
+            var array: [2]Foo = .{
+                .{.a = 3},
+                .{.b = 3},
+            };
+            expect(array[0].a == 3);
+            expect(array[0].b == 4);
+            expect(array[1].a == 2);
+            expect(array[1].b == 3);
+        }
+    };
+    S.doTheTest();
+    comptime S.doTheTest();
+}
-- 
cgit v1.2.3


From 1aa978f32e88b4c83fde95f62938c97c7c22164c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 14 Nov 2019 03:26:33 -0500
Subject: implement null terminated pointers

---
 lib/std/builtin.zig               |  1 +
 lib/std/meta.zig                  |  1 +
 src/all_types.hpp                 |  3 +++
 src/analyze.cpp                   |  4 +++-
 src/dump_analysis.cpp             |  4 ++++
 src/ir.cpp                        | 27 +++++++++++++++++++++++++--
 src/parser.cpp                    | 10 ++++++++++
 src/translate_c.cpp               |  2 ++
 test/compile_errors.zig           | 12 ++++++++++++
 test/stage1/behavior/pointers.zig | 14 ++++++++++++++
 10 files changed, 75 insertions(+), 3 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 8052f0b31a..9f1e52428c 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -144,6 +144,7 @@ pub const TypeInfo = union(enum) {
         alignment: comptime_int,
         child: type,
         is_allowzero: bool,
+        is_null_terminated: bool,
 
         /// This data structure is used by the Zig language code generation and
         /// therefore must be kept in sync with the compiler implementation.
diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index 903c3a12b3..01d240f31f 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -558,3 +558,4 @@ pub fn refAllDecls(comptime T: type) void {
     if (!builtin.is_test) return;
     _ = declarations(T);
 }
+
diff --git a/src/all_types.hpp b/src/all_types.hpp
index c4178cb130..f5c9c67414 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -55,6 +55,7 @@ enum PtrLen {
     PtrLenUnknown,
     PtrLenSingle,
     PtrLenC,
+    PtrLenNull,
 };
 
 // This one corresponds to the builtin.zig enum.
@@ -825,6 +826,7 @@ struct AstNodePointerType {
     Token *allow_zero_token;
     bool is_const;
     bool is_volatile;
+    bool is_null_terminated;
 };
 
 struct AstNodeInferredArrayType {
@@ -838,6 +840,7 @@ struct AstNodeArrayType {
     Token *allow_zero_token;
     bool is_const;
     bool is_volatile;
+    bool is_null_terminated;
 };
 
 struct AstNodeUsingNamespace {
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 0a8b32dca7..d84ba1d37c 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -460,6 +460,8 @@ static const char *ptr_len_to_star_str(PtrLen ptr_len) {
             return "[*]";
         case PtrLenC:
             return "[*c]";
+        case PtrLenNull:
+            return "[*]null ";
     }
     zig_unreachable();
 }
@@ -7032,7 +7034,7 @@ uint32_t type_id_hash(TypeId x) {
             return hash_ptr(x.data.error_union.err_set_type) ^ hash_ptr(x.data.error_union.payload_type);
         case ZigTypeIdPointer:
             return hash_ptr(x.data.pointer.child_type) +
-                ((x.data.pointer.ptr_len == PtrLenSingle) ? (uint32_t)1120226602 : (uint32_t)3200913342) +
+                (uint32_t)x.data.pointer.ptr_len * 1120226602u +
                 (x.data.pointer.is_const ? (uint32_t)2749109194 : (uint32_t)4047371087) +
                 (x.data.pointer.is_volatile ? (uint32_t)536730450 : (uint32_t)1685612214) +
                 (x.data.pointer.allow_zero ? (uint32_t)3324284834 : (uint32_t)3584904923) +
diff --git a/src/dump_analysis.cpp b/src/dump_analysis.cpp
index 98bbcc6a42..825ae4baa5 100644
--- a/src/dump_analysis.cpp
+++ b/src/dump_analysis.cpp
@@ -992,6 +992,10 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
                     jw_object_field(jw, "len");
                     jw_int(jw, 3);
                     break;
+                case PtrLenNull:
+                    jw_object_field(jw, "len");
+                    jw_int(jw, 4);
+                    break;
             }
             anal_dump_pointer_attrs(ctx, ty);
             break;
diff --git a/src/ir.cpp b/src/ir.cpp
index 7bca551852..77fc1307ca 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -6043,13 +6043,25 @@ static PtrLen star_token_to_ptr_len(TokenId token_id) {
 
 static IrInstruction *ir_gen_pointer_type(IrBuilder *irb, Scope *scope, AstNode *node) {
     assert(node->type == NodeTypePointerType);
+
     PtrLen ptr_len = star_token_to_ptr_len(node->data.pointer_type.star_token->id);
+    if (node->data.pointer_type.is_null_terminated) {
+        if (ptr_len == PtrLenUnknown) {
+            ptr_len = PtrLenNull;
+        } else {
+            exec_add_error_node(irb->codegen, irb->exec, node,
+                    buf_sprintf("null-terminated pointer must be specified with [*] token"));
+            return irb->codegen->invalid_instruction;
+        }
+    }
+
     bool is_const = node->data.pointer_type.is_const;
     bool is_volatile = node->data.pointer_type.is_volatile;
     bool is_allow_zero = node->data.pointer_type.allow_zero_token != nullptr;
     AstNode *expr_node = node->data.pointer_type.op_expr;
     AstNode *align_expr = node->data.pointer_type.align_expr;
 
+
     IrInstruction *align_value;
     if (align_expr != nullptr) {
         align_value = ir_gen_node(irb, align_expr, scope);
@@ -9793,6 +9805,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
     // alignment can be decreased
     // bit offset attributes must match exactly
     // PtrLenSingle/PtrLenUnknown must match exactly, but PtrLenC matches either one
+    // PtrLenNull can coerce into PtrLenUnknown
     ZigType *wanted_ptr_type = get_src_ptr_type(wanted_type);
     ZigType *actual_ptr_type = get_src_ptr_type(actual_type);
     bool wanted_allows_zero = ptr_allows_addr_zero(wanted_type);
@@ -9843,7 +9856,10 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             return result;
         }
         bool ptr_lens_equal = actual_ptr_type->data.pointer.ptr_len == wanted_ptr_type->data.pointer.ptr_len;
-        if ((ptr_lens_equal || wanted_is_c_ptr || actual_is_c_ptr) &&
+        bool ok_null_term_ptrs =
+            actual_ptr_type->data.pointer.ptr_len == PtrLenNull ||
+            wanted_ptr_type->data.pointer.ptr_len == PtrLenUnknown;
+        if ((ptr_lens_equal || wanted_is_c_ptr || actual_is_c_ptr || ok_null_term_ptrs) &&
             type_has_bits(wanted_type) == type_has_bits(actual_type) &&
             (!actual_ptr_type->data.pointer.is_const || wanted_ptr_type->data.pointer.is_const) &&
             (!actual_ptr_type->data.pointer.is_volatile || wanted_ptr_type->data.pointer.is_volatile) &&
@@ -14532,6 +14548,7 @@ static bool is_pointer_arithmetic_allowed(ZigType *lhs_type, IrBinOp op) {
         case PtrLenSingle:
             return false;
         case PtrLenUnknown:
+        case PtrLenNull:
         case PtrLenC:
             break;
     }
@@ -21166,6 +21183,7 @@ static BuiltinPtrSize ptr_len_to_size_enum_index(PtrLen ptr_len) {
         case PtrLenSingle:
             return BuiltinPtrSizeOne;
         case PtrLenUnknown:
+        case PtrLenNull:
             return BuiltinPtrSizeMany;
         case PtrLenC:
             return BuiltinPtrSizeC;
@@ -21210,7 +21228,7 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
     result->special = ConstValSpecialStatic;
     result->type = type_info_pointer_type;
 
-    ConstExprValue **fields = alloc_const_vals_ptrs(6);
+    ConstExprValue **fields = alloc_const_vals_ptrs(7);
     result->data.x_struct.fields = fields;
 
     // size: Size
@@ -21246,6 +21264,11 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
     fields[5]->special = ConstValSpecialStatic;
     fields[5]->type = ira->codegen->builtin_types.entry_bool;
     fields[5]->data.x_bool = attrs_type->data.pointer.allow_zero;
+    // is_null_terminated: bool
+    ensure_field_index(result->type, "is_null_terminated", 6);
+    fields[6]->special = ConstValSpecialStatic;
+    fields[6]->type = ira->codegen->builtin_types.entry_bool;
+    fields[6]->data.x_bool = attrs_type->data.pointer.ptr_len == PtrLenNull;
 
     return result;
 };
diff --git a/src/parser.cpp b/src/parser.cpp
index e87c83a276..3da0d8a643 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -2618,6 +2618,11 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
     if (array != nullptr) {
         assert(array->type == NodeTypeArrayType);
         while (true) {
+            if (eat_token_if(pc, TokenIdKeywordNull) != nullptr) {
+                array->data.array_type.is_null_terminated = true;
+                continue;
+            }
+
             Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
             if (allowzero_token != nullptr) {
                 array->data.array_type.allow_zero_token = allowzero_token;
@@ -2653,6 +2658,11 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
         if (child == nullptr)
             child = ptr;
         while (true) {
+            if (eat_token_if(pc, TokenIdKeywordNull) != nullptr) {
+                child->data.pointer_type.is_null_terminated = true;
+                continue;
+            }
+
             Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
             if (allowzero_token != nullptr) {
                 child->data.pointer_type.allow_zero_token = allowzero_token;
diff --git a/src/translate_c.cpp b/src/translate_c.cpp
index 3acfb05e85..6df61ab13c 100644
--- a/src/translate_c.cpp
+++ b/src/translate_c.cpp
@@ -291,6 +291,7 @@ static TokenId ptr_len_to_token_id(PtrLen ptr_len) {
         case PtrLenSingle:
             return TokenIdStar;
         case PtrLenUnknown:
+        case PtrLenNull:
             return TokenIdBracketStarBracket;
         case PtrLenC:
             return TokenIdBracketStarCBracket;
@@ -302,6 +303,7 @@ static AstNode *trans_create_node_ptr_type(Context *c, bool is_const, bool is_vo
     AstNode *node = trans_create_node(c, NodeTypePointerType);
     node->data.pointer_type.star_token = allocate<ZigToken>(1);
     node->data.pointer_type.star_token->id = ptr_len_to_token_id(ptr_len);
+    node->data.pointer_type.is_null_terminated = (ptr_len == PtrLenNull);
     node->data.pointer_type.is_const = is_const;
     node->data.pointer_type.is_volatile = is_volatile;
     node->data.pointer_type.op_expr = child_node;
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index c23897a51a..039afe52df 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -68,6 +68,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:27: error: @atomicRmw on enum only works with .Xchg",
     );
 
+    cases.add(
+        "disallow coercion from non-null-terminated pointer to null-terminated pointer",
+        \\extern fn puts(s: [*]null const u8) c_int;
+        \\pub fn main() void {
+        \\    const no_zero_array = [_]u8{'h', 'e', 'l', 'l', 'o'};
+        \\    const no_zero_ptr: [*]const u8 = &no_zero_array;
+        \\    _ = puts(no_zero_ptr);
+        \\}
+    ,
+        "tmp.zig:5:14: error: expected type '[*]null const u8', found '[*]const u8'",
+    );
+
     cases.add(
         "atomic orderings of atomicStore Acquire or AcqRel",
         \\export fn entry() void {
diff --git a/test/stage1/behavior/pointers.zig b/test/stage1/behavior/pointers.zig
index bf292bad0d..fd11e68473 100644
--- a/test/stage1/behavior/pointers.zig
+++ b/test/stage1/behavior/pointers.zig
@@ -200,3 +200,17 @@ test "assign null directly to C pointer and test null equality" {
     }
     comptime expect((y1 orelse &othery) == y1);
 }
+
+test "null terminated pointer" {
+    const S = struct {
+        fn doTheTest() void {
+            var array_with_zero = [_]u8{'h', 'e', 'l', 'l', 'o', 0};
+            var zero_ptr: [*]null const u8 = @ptrCast([*]null const u8, &array_with_zero);
+            var no_zero_ptr: [*]const u8 = zero_ptr;
+            expect(std.mem.eql(u8, std.mem.toSliceConst(u8, no_zero_ptr), "hello"));
+        }
+    };
+    S.doTheTest();
+    // TODO test fails at comptime
+    //comptime S.doTheTest();
+}
-- 
cgit v1.2.3


From 47f06be36943f808aa9798c19172363afe6ae35c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 19 Nov 2019 20:29:08 -0500
Subject: string literals are now null terminated

this also deletes C string literals from the language, and then makes
the std lib changes and compiler changes necessary to get the behavior
tests and std lib tests passing again.
---
 lib/std/child_process.zig                  |   2 +-
 lib/std/crypto/x25519.zig                  |  12 +-
 lib/std/cstr.zig                           |   4 +-
 lib/std/fmt.zig                            | 112 ++++----
 lib/std/fs.zig                             |   6 +-
 lib/std/fs/file.zig                        |   2 +-
 lib/std/fs/path.zig                        |   2 +-
 lib/std/hash/siphash.zig                   | 256 ++++++++---------
 lib/std/io/test.zig                        |   4 +-
 lib/std/mem.zig                            |  18 +-
 lib/std/meta.zig                           |  13 +-
 lib/std/meta/trait.zig                     |   2 -
 lib/std/net.zig                            |  16 +-
 lib/std/os.zig                             |   4 +-
 lib/std/os/linux.zig                       |   2 +-
 lib/std/os/linux/test.zig                  |   4 +-
 lib/std/process.zig                        |  16 +-
 lib/std/special/c.zig                      |  10 +-
 lib/std/thread.zig                         |   2 +-
 lib/std/valgrind/memcheck.zig              |   2 +-
 src-self-hosted/codegen.zig                |   6 +-
 src-self-hosted/compilation.zig            |   4 +-
 src-self-hosted/ir.zig                     |  12 +-
 src-self-hosted/link.zig                   | 126 ++++----
 src-self-hosted/stage1.zig                 |   2 +-
 src-self-hosted/value.zig                  |   2 +-
 src/all_types.hpp                          |   9 +-
 src/analyze.cpp                            | 141 +++++----
 src/analyze.hpp                            |   9 +-
 src/ast_render.cpp                         |   3 -
 src/codegen.cpp                            |  61 ++--
 src/ir.cpp                                 | 448 +++++++++++++++++++++--------
 src/parser.cpp                             |   1 -
 src/tokenizer.cpp                          |  53 +---
 src/tokenizer.hpp                          |   1 -
 src/translate_c.cpp                        |  18 +-
 test/compare_output.zig                    |  72 ++---
 test/compile_errors.zig                    |  10 +-
 test/stage1/behavior/array.zig             |  39 ++-
 test/stage1/behavior/bugs/1076.zig         |  16 +-
 test/stage1/behavior/cast.zig              | 110 +++++--
 test/stage1/behavior/const_slice_child.zig |   9 +-
 test/stage1/behavior/eval.zig              |   2 +-
 test/stage1/behavior/misc.zig              |  17 +-
 test/stage1/behavior/pointers.zig          |   2 +-
 test/stage1/behavior/ptrcast.zig           |   2 +-
 test/stage1/behavior/slice.zig             |   2 +-
 test/stage1/behavior/struct.zig            |   2 +-
 test/stage2/compare_output.zig             |   4 +-
 test/standalone/hello_world/hello_libc.zig |   2 +-
 test/translate_c.zig                       |  28 +-
 51 files changed, 986 insertions(+), 716 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/child_process.zig b/lib/std/child_process.zig
index d329855c03..50479016ac 100644
--- a/lib/std/child_process.zig
+++ b/lib/std/child_process.zig
@@ -328,7 +328,7 @@ pub const ChildProcess = struct {
 
         const any_ignore = (self.stdin_behavior == StdIo.Ignore or self.stdout_behavior == StdIo.Ignore or self.stderr_behavior == StdIo.Ignore);
         const dev_null_fd = if (any_ignore)
-            os.openC(c"/dev/null", os.O_RDWR, 0) catch |err| switch (err) {
+            os.openC("/dev/null", os.O_RDWR, 0) catch |err| switch (err) {
                 error.PathAlreadyExists => unreachable,
                 error.NoSpaceLeft => unreachable,
                 error.FileTooBig => unreachable,
diff --git a/lib/std/crypto/x25519.zig b/lib/std/crypto/x25519.zig
index cd908b0868..73e0f033f2 100644
--- a/lib/std/crypto/x25519.zig
+++ b/lib/std/crypto/x25519.zig
@@ -610,8 +610,8 @@ test "x25519 rfc7748 vector2" {
 }
 
 test "x25519 rfc7748 one iteration" {
-    const initial_value = "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-    const expected_output = "\x42\x2c\x8e\x7a\x62\x27\xd7\xbc\xa1\x35\x0b\x3e\x2b\xb7\x27\x9f\x78\x97\xb8\x7b\xb6\x85\x4b\x78\x3c\x60\xe8\x03\x11\xae\x30\x79";
+    const initial_value = "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*;
+    const expected_output = "\x42\x2c\x8e\x7a\x62\x27\xd7\xbc\xa1\x35\x0b\x3e\x2b\xb7\x27\x9f\x78\x97\xb8\x7b\xb6\x85\x4b\x78\x3c\x60\xe8\x03\x11\xae\x30\x79".*;
 
     var k: [32]u8 = initial_value;
     var u: [32]u8 = initial_value;
@@ -634,8 +634,8 @@ test "x25519 rfc7748 1,000 iterations" {
         return error.SkipZigTest;
     }
 
-    const initial_value = "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-    const expected_output = "\x68\x4c\xf5\x9b\xa8\x33\x09\x55\x28\x00\xef\x56\x6f\x2f\x4d\x3c\x1c\x38\x87\xc4\x93\x60\xe3\x87\x5f\x2e\xb9\x4d\x99\x53\x2c\x51";
+    const initial_value = "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*;
+    const expected_output = "\x68\x4c\xf5\x9b\xa8\x33\x09\x55\x28\x00\xef\x56\x6f\x2f\x4d\x3c\x1c\x38\x87\xc4\x93\x60\xe3\x87\x5f\x2e\xb9\x4d\x99\x53\x2c\x51".*;
 
     var k: [32]u8 = initial_value;
     var u: [32]u8 = initial_value;
@@ -657,8 +657,8 @@ test "x25519 rfc7748 1,000,000 iterations" {
         return error.SkipZigTest;
     }
 
-    const initial_value = "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-    const expected_output = "\x7c\x39\x11\xe0\xab\x25\x86\xfd\x86\x44\x97\x29\x7e\x57\x5e\x6f\x3b\xc6\x01\xc0\x88\x3c\x30\xdf\x5f\x4d\xd2\xd2\x4f\x66\x54\x24";
+    const initial_value = "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*;
+    const expected_output = "\x7c\x39\x11\xe0\xab\x25\x86\xfd\x86\x44\x97\x29\x7e\x57\x5e\x6f\x3b\xc6\x01\xc0\x88\x3c\x30\xdf\x5f\x4d\xd2\xd2\x4f\x66\x54\x24".*;
 
     var k: [32]u8 = initial_value;
     var u: [32]u8 = initial_value;
diff --git a/lib/std/cstr.zig b/lib/std/cstr.zig
index dd28e50449..4229ff3ed5 100644
--- a/lib/std/cstr.zig
+++ b/lib/std/cstr.zig
@@ -27,8 +27,8 @@ test "cstr fns" {
 }
 
 fn testCStrFnsImpl() void {
-    testing.expect(cmp(c"aoeu", c"aoez") == -1);
-    testing.expect(mem.len(u8, c"123456789") == 9);
+    testing.expect(cmp("aoeu", "aoez") == -1);
+    testing.expect(mem.len(u8, "123456789") == 9);
 }
 
 /// Returns a mutable slice with 1 more byte of length which is a null byte.
diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index 743ca4d920..cbb11cba36 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -1,8 +1,6 @@
 const std = @import("std.zig");
 const math = std.math;
-const debug = std.debug;
-const assert = debug.assert;
-const testing = std.testing;
+const assert = std.debug.assert;
 const mem = std.mem;
 const builtin = @import("builtin");
 const errol = @import("fmt/errol.zig");
@@ -36,7 +34,7 @@ fn nextArg(comptime used_pos_args: *u32, comptime maybe_pos_arg: ?comptime_int,
 
 fn peekIsAlign(comptime fmt: []const u8) bool {
     // Should only be called during a state transition to the format segment.
-    std.debug.assert(fmt[0] == ':');
+    comptime assert(fmt[0] == ':');
 
     inline for (([_]u8{ 1, 2 })[0..]) |i| {
         if (fmt.len > i and (fmt[i] == '<' or fmt[i] == '^' or fmt[i] == '>')) {
@@ -1009,13 +1007,13 @@ pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) !T {
 }
 
 test "parseInt" {
-    testing.expect((parseInt(i32, "-10", 10) catch unreachable) == -10);
-    testing.expect((parseInt(i32, "+10", 10) catch unreachable) == 10);
-    testing.expect(if (parseInt(i32, " 10", 10)) |_| false else |err| err == error.InvalidCharacter);
-    testing.expect(if (parseInt(i32, "10 ", 10)) |_| false else |err| err == error.InvalidCharacter);
-    testing.expect(if (parseInt(u32, "-10", 10)) |_| false else |err| err == error.InvalidCharacter);
-    testing.expect((parseInt(u8, "255", 10) catch unreachable) == 255);
-    testing.expect(if (parseInt(u8, "256", 10)) |_| false else |err| err == error.Overflow);
+    std.testing.expect((parseInt(i32, "-10", 10) catch unreachable) == -10);
+    std.testing.expect((parseInt(i32, "+10", 10) catch unreachable) == 10);
+    std.testing.expect(if (parseInt(i32, " 10", 10)) |_| false else |err| err == error.InvalidCharacter);
+    std.testing.expect(if (parseInt(i32, "10 ", 10)) |_| false else |err| err == error.InvalidCharacter);
+    std.testing.expect(if (parseInt(u32, "-10", 10)) |_| false else |err| err == error.InvalidCharacter);
+    std.testing.expect((parseInt(u8, "255", 10) catch unreachable) == 255);
+    std.testing.expect(if (parseInt(u8, "256", 10)) |_| false else |err| err == error.Overflow);
 }
 
 const ParseUnsignedError = error{
@@ -1040,30 +1038,30 @@ pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) ParseUnsigned
 }
 
 test "parseUnsigned" {
-    testing.expect((try parseUnsigned(u16, "050124", 10)) == 50124);
-    testing.expect((try parseUnsigned(u16, "65535", 10)) == 65535);
-    testing.expectError(error.Overflow, parseUnsigned(u16, "65536", 10));
+    std.testing.expect((try parseUnsigned(u16, "050124", 10)) == 50124);
+    std.testing.expect((try parseUnsigned(u16, "65535", 10)) == 65535);
+    std.testing.expectError(error.Overflow, parseUnsigned(u16, "65536", 10));
 
-    testing.expect((try parseUnsigned(u64, "0ffffffffffffffff", 16)) == 0xffffffffffffffff);
-    testing.expectError(error.Overflow, parseUnsigned(u64, "10000000000000000", 16));
+    std.testing.expect((try parseUnsigned(u64, "0ffffffffffffffff", 16)) == 0xffffffffffffffff);
+    std.testing.expectError(error.Overflow, parseUnsigned(u64, "10000000000000000", 16));
 
-    testing.expect((try parseUnsigned(u32, "DeadBeef", 16)) == 0xDEADBEEF);
+    std.testing.expect((try parseUnsigned(u32, "DeadBeef", 16)) == 0xDEADBEEF);
 
-    testing.expect((try parseUnsigned(u7, "1", 10)) == 1);
-    testing.expect((try parseUnsigned(u7, "1000", 2)) == 8);
+    std.testing.expect((try parseUnsigned(u7, "1", 10)) == 1);
+    std.testing.expect((try parseUnsigned(u7, "1000", 2)) == 8);
 
-    testing.expectError(error.InvalidCharacter, parseUnsigned(u32, "f", 10));
-    testing.expectError(error.InvalidCharacter, parseUnsigned(u8, "109", 8));
+    std.testing.expectError(error.InvalidCharacter, parseUnsigned(u32, "f", 10));
+    std.testing.expectError(error.InvalidCharacter, parseUnsigned(u8, "109", 8));
 
-    testing.expect((try parseUnsigned(u32, "NUMBER", 36)) == 1442151747);
+    std.testing.expect((try parseUnsigned(u32, "NUMBER", 36)) == 1442151747);
 
     // these numbers should fit even though the radix itself doesn't fit in the destination type
-    testing.expect((try parseUnsigned(u1, "0", 10)) == 0);
-    testing.expect((try parseUnsigned(u1, "1", 10)) == 1);
-    testing.expectError(error.Overflow, parseUnsigned(u1, "2", 10));
-    testing.expect((try parseUnsigned(u1, "001", 16)) == 1);
-    testing.expect((try parseUnsigned(u2, "3", 16)) == 3);
-    testing.expectError(error.Overflow, parseUnsigned(u2, "4", 16));
+    std.testing.expect((try parseUnsigned(u1, "0", 10)) == 0);
+    std.testing.expect((try parseUnsigned(u1, "1", 10)) == 1);
+    std.testing.expectError(error.Overflow, parseUnsigned(u1, "2", 10));
+    std.testing.expect((try parseUnsigned(u1, "001", 16)) == 1);
+    std.testing.expect((try parseUnsigned(u2, "3", 16)) == 3);
+    std.testing.expectError(error.Overflow, parseUnsigned(u2, "4", 16));
 }
 
 pub const parseFloat = @import("fmt/parse_float.zig").parseFloat;
@@ -1134,19 +1132,19 @@ fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
 test "bufPrintInt" {
     var buffer: [100]u8 = undefined;
     const buf = buffer[0..];
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 2, false, FormatOptions{}), "-101111000110000101001110"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 10, false, FormatOptions{}), "-12345678"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, false, FormatOptions{}), "-bc614e"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, true, FormatOptions{}), "-BC614E"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 2, false, FormatOptions{}), "-101111000110000101001110"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 10, false, FormatOptions{}), "-12345678"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, false, FormatOptions{}), "-bc614e"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, true, FormatOptions{}), "-BC614E"));
 
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 12345678), 10, true, FormatOptions{}), "12345678"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 12345678), 10, true, FormatOptions{}), "12345678"));
 
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 666), 10, false, FormatOptions{ .width = 6 }), "   666"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 6 }), "  1234"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 1 }), "1234"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 666), 10, false, FormatOptions{ .width = 6 }), "   666"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 6 }), "  1234"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 1 }), "1234"));
 
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, 42), 10, false, FormatOptions{ .width = 3 }), "+42"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -42), 10, false, FormatOptions{ .width = 3 }), "-42"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, 42), 10, false, FormatOptions{ .width = 3 }), "+42"));
+    std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -42), 10, false, FormatOptions{ .width = 3 }), "-42"));
 }
 
 fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, options: FormatOptions) []u8 {
@@ -1163,7 +1161,7 @@ test "parse u64 digit too big" {
 
 test "parse unsigned comptime" {
     comptime {
-        testing.expect((try parseUnsigned(usize, "2", 10)) == 2);
+        std.testing.expect((try parseUnsigned(usize, "2", 10)) == 2);
     }
 }
 
@@ -1218,23 +1216,23 @@ test "buffer" {
         var context = BufPrintContext{ .remaining = buf1[0..] };
         try formatType(1234, "", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
         var res = buf1[0 .. buf1.len - context.remaining.len];
-        testing.expect(mem.eql(u8, res, "1234"));
+        std.testing.expect(mem.eql(u8, res, "1234"));
 
         context = BufPrintContext{ .remaining = buf1[0..] };
         try formatType('a', "c", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
         res = buf1[0 .. buf1.len - context.remaining.len];
-        testing.expect(mem.eql(u8, res, "a"));
+        std.testing.expect(mem.eql(u8, res, "a"));
 
         context = BufPrintContext{ .remaining = buf1[0..] };
         try formatType(0b1100, "b", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
         res = buf1[0 .. buf1.len - context.remaining.len];
-        testing.expect(mem.eql(u8, res, "1100"));
+        std.testing.expect(mem.eql(u8, res, "1100"));
     }
 }
 
 test "array" {
     {
-        const value: [3]u8 = "abc";
+        const value: [3]u8 = "abc".*;
         try testFmt("array: abc\n", "array: {}\n", value);
         try testFmt("array: abc\n", "array: {}\n", &value);
 
@@ -1278,8 +1276,8 @@ test "pointer" {
 }
 
 test "cstr" {
-    try testFmt("cstr: Test C\n", "cstr: {s}\n", c"Test C");
-    try testFmt("cstr: Test C    \n", "cstr: {s:10}\n", c"Test C");
+    try testFmt("cstr: Test C\n", "cstr: {s}\n", "Test C");
+    try testFmt("cstr: Test C    \n", "cstr: {s:10}\n", "Test C");
 }
 
 test "filesize" {
@@ -1479,10 +1477,10 @@ test "union" {
 
     var buf: [100]u8 = undefined;
     const uu_result = try bufPrint(buf[0..], "{}", uu_inst);
-    testing.expect(mem.eql(u8, uu_result[0..3], "UU@"));
+    std.testing.expect(mem.eql(u8, uu_result[0..3], "UU@"));
 
     const eu_result = try bufPrint(buf[0..], "{}", eu_inst);
-    testing.expect(mem.eql(u8, uu_result[0..3], "EU@"));
+    std.testing.expect(mem.eql(u8, uu_result[0..3], "EU@"));
 }
 
 test "enum" {
@@ -1569,11 +1567,11 @@ pub fn trim(buf: []const u8) []const u8 {
 }
 
 test "trim" {
-    testing.expect(mem.eql(u8, "abc", trim("\n  abc  \t")));
-    testing.expect(mem.eql(u8, "", trim("   ")));
-    testing.expect(mem.eql(u8, "", trim("")));
-    testing.expect(mem.eql(u8, "abc", trim(" abc")));
-    testing.expect(mem.eql(u8, "abc", trim("abc ")));
+    std.testing.expect(mem.eql(u8, "abc", trim("\n  abc  \t")));
+    std.testing.expect(mem.eql(u8, "", trim("   ")));
+    std.testing.expect(mem.eql(u8, "", trim("")));
+    std.testing.expect(mem.eql(u8, "abc", trim(" abc")));
+    std.testing.expect(mem.eql(u8, "abc", trim("abc ")));
 }
 
 pub fn isWhiteSpace(byte: u8) bool {
@@ -1607,7 +1605,7 @@ test "formatIntValue with comptime_int" {
 
     var buf = try std.Buffer.init(std.debug.global_allocator, "");
     try formatIntValue(value, "", FormatOptions{}, &buf, @typeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append);
-    assert(mem.eql(u8, buf.toSlice(), "123456789123456789"));
+    std.testing.expect(mem.eql(u8, buf.toSlice(), "123456789123456789"));
 }
 
 test "formatType max_depth" {
@@ -1661,19 +1659,19 @@ test "formatType max_depth" {
 
     var buf0 = try std.Buffer.init(std.debug.global_allocator, "");
     try formatType(inst, "", FormatOptions{}, &buf0, @typeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 0);
-    assert(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
+    std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
 
     var buf1 = try std.Buffer.init(std.debug.global_allocator, "");
     try formatType(inst, "", FormatOptions{}, &buf1, @typeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 1);
-    assert(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
+    std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
 
     var buf2 = try std.Buffer.init(std.debug.global_allocator, "");
     try formatType(inst, "", FormatOptions{}, &buf2, @typeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 2);
-    assert(mem.eql(u8, buf2.toSlice(), "S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }"));
+    std.testing.expect(mem.eql(u8, buf2.toSlice(), "S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }"));
 
     var buf3 = try std.Buffer.init(std.debug.global_allocator, "");
     try formatType(inst, "", FormatOptions{}, &buf3, @typeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 3);
-    assert(mem.eql(u8, buf3.toSlice(), "S{ .a = S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ .ptr = TU{ ... } } }, .e = E.Two, .vec = (10.200,2.220) }"));
+    std.testing.expect(mem.eql(u8, buf3.toSlice(), "S{ .a = S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ .ptr = TU{ ... } } }, .e = E.Two, .vec = (10.200,2.220) }"));
 }
 
 test "positional" {
diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index bc2c921d1e..0b9c6559d7 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -1240,7 +1240,7 @@ pub const OpenSelfExeError = os.OpenError || os.windows.CreateFileError || SelfE
 
 pub fn openSelfExe() OpenSelfExeError!File {
     if (builtin.os == .linux) {
-        return File.openReadC(c"/proc/self/exe");
+        return File.openReadC("/proc/self/exe");
     }
     if (builtin.os == .windows) {
         const wide_slice = selfExePathW();
@@ -1280,7 +1280,7 @@ pub fn selfExePath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]u8 {
         return mem.toSlice(u8, out_buffer);
     }
     switch (builtin.os) {
-        .linux => return os.readlinkC(c"/proc/self/exe", out_buffer),
+        .linux => return os.readlinkC("/proc/self/exe", out_buffer),
         .freebsd, .dragonfly => {
             var mib = [4]c_int{ os.CTL_KERN, os.KERN_PROC, os.KERN_PROC_PATHNAME, -1 };
             var out_len: usize = out_buffer.len;
@@ -1326,7 +1326,7 @@ pub fn selfExeDirPath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]const
         // the file path looks something like `/a/b/c/exe (deleted)`
         // This path cannot be opened, but it's valid for determining the directory
         // the executable was in when it was run.
-        const full_exe_path = try os.readlinkC(c"/proc/self/exe", out_buffer);
+        const full_exe_path = try os.readlinkC("/proc/self/exe", out_buffer);
         // Assume that /proc/self/exe has an absolute path, and therefore dirname
         // will not return null.
         return path.dirname(full_exe_path).?;
diff --git a/lib/std/fs/file.zig b/lib/std/fs/file.zig
index b25403fa02..cd50fcdece 100644
--- a/lib/std/fs/file.zig
+++ b/lib/std/fs/file.zig
@@ -172,7 +172,7 @@ pub const File = struct {
         if (self.isTty()) {
             if (self.handle == os.STDOUT_FILENO or self.handle == os.STDERR_FILENO) {
                 // Use getenvC to workaround https://github.com/ziglang/zig/issues/3511
-                if (os.getenvC(c"TERM")) |term| {
+                if (os.getenvC("TERM")) |term| {
                     if (std.mem.eql(u8, term, "dumb"))
                         return false;
                 }
diff --git a/lib/std/fs/path.zig b/lib/std/fs/path.zig
index 6a24055667..e2f1b5ac65 100644
--- a/lib/std/fs/path.zig
+++ b/lib/std/fs/path.zig
@@ -394,7 +394,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
     }
 
     // determine which disk designator we will result with, if any
-    var result_drive_buf = "_:";
+    var result_drive_buf = "_:".*;
     var result_disk_designator: []const u8 = "";
     var have_drive_kind = WindowsPath.Kind.None;
     var have_abs_path = false;
diff --git a/lib/std/hash/siphash.zig b/lib/std/hash/siphash.zig
index c3a9184fa4..6b4cc2b16b 100644
--- a/lib/std/hash/siphash.zig
+++ b/lib/std/hash/siphash.zig
@@ -202,70 +202,70 @@ const test_key = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x
 
 test "siphash64-2-4 sanity" {
     const vectors = [_][8]u8{
-        "\x31\x0e\x0e\xdd\x47\xdb\x6f\x72", // ""
-        "\xfd\x67\xdc\x93\xc5\x39\xf8\x74", // "\x00"
-        "\x5a\x4f\xa9\xd9\x09\x80\x6c\x0d", // "\x00\x01" ... etc
-        "\x2d\x7e\xfb\xd7\x96\x66\x67\x85",
-        "\xb7\x87\x71\x27\xe0\x94\x27\xcf",
-        "\x8d\xa6\x99\xcd\x64\x55\x76\x18",
-        "\xce\xe3\xfe\x58\x6e\x46\xc9\xcb",
-        "\x37\xd1\x01\x8b\xf5\x00\x02\xab",
-        "\x62\x24\x93\x9a\x79\xf5\xf5\x93",
-        "\xb0\xe4\xa9\x0b\xdf\x82\x00\x9e",
-        "\xf3\xb9\xdd\x94\xc5\xbb\x5d\x7a",
-        "\xa7\xad\x6b\x22\x46\x2f\xb3\xf4",
-        "\xfb\xe5\x0e\x86\xbc\x8f\x1e\x75",
-        "\x90\x3d\x84\xc0\x27\x56\xea\x14",
-        "\xee\xf2\x7a\x8e\x90\xca\x23\xf7",
-        "\xe5\x45\xbe\x49\x61\xca\x29\xa1",
-        "\xdb\x9b\xc2\x57\x7f\xcc\x2a\x3f",
-        "\x94\x47\xbe\x2c\xf5\xe9\x9a\x69",
-        "\x9c\xd3\x8d\x96\xf0\xb3\xc1\x4b",
-        "\xbd\x61\x79\xa7\x1d\xc9\x6d\xbb",
-        "\x98\xee\xa2\x1a\xf2\x5c\xd6\xbe",
-        "\xc7\x67\x3b\x2e\xb0\xcb\xf2\xd0",
-        "\x88\x3e\xa3\xe3\x95\x67\x53\x93",
-        "\xc8\xce\x5c\xcd\x8c\x03\x0c\xa8",
-        "\x94\xaf\x49\xf6\xc6\x50\xad\xb8",
-        "\xea\xb8\x85\x8a\xde\x92\xe1\xbc",
-        "\xf3\x15\xbb\x5b\xb8\x35\xd8\x17",
-        "\xad\xcf\x6b\x07\x63\x61\x2e\x2f",
-        "\xa5\xc9\x1d\xa7\xac\xaa\x4d\xde",
-        "\x71\x65\x95\x87\x66\x50\xa2\xa6",
-        "\x28\xef\x49\x5c\x53\xa3\x87\xad",
-        "\x42\xc3\x41\xd8\xfa\x92\xd8\x32",
-        "\xce\x7c\xf2\x72\x2f\x51\x27\x71",
-        "\xe3\x78\x59\xf9\x46\x23\xf3\xa7",
-        "\x38\x12\x05\xbb\x1a\xb0\xe0\x12",
-        "\xae\x97\xa1\x0f\xd4\x34\xe0\x15",
-        "\xb4\xa3\x15\x08\xbe\xff\x4d\x31",
-        "\x81\x39\x62\x29\xf0\x90\x79\x02",
-        "\x4d\x0c\xf4\x9e\xe5\xd4\xdc\xca",
-        "\x5c\x73\x33\x6a\x76\xd8\xbf\x9a",
-        "\xd0\xa7\x04\x53\x6b\xa9\x3e\x0e",
-        "\x92\x59\x58\xfc\xd6\x42\x0c\xad",
-        "\xa9\x15\xc2\x9b\xc8\x06\x73\x18",
-        "\x95\x2b\x79\xf3\xbc\x0a\xa6\xd4",
-        "\xf2\x1d\xf2\xe4\x1d\x45\x35\xf9",
-        "\x87\x57\x75\x19\x04\x8f\x53\xa9",
-        "\x10\xa5\x6c\xf5\xdf\xcd\x9a\xdb",
-        "\xeb\x75\x09\x5c\xcd\x98\x6c\xd0",
-        "\x51\xa9\xcb\x9e\xcb\xa3\x12\xe6",
-        "\x96\xaf\xad\xfc\x2c\xe6\x66\xc7",
-        "\x72\xfe\x52\x97\x5a\x43\x64\xee",
-        "\x5a\x16\x45\xb2\x76\xd5\x92\xa1",
-        "\xb2\x74\xcb\x8e\xbf\x87\x87\x0a",
-        "\x6f\x9b\xb4\x20\x3d\xe7\xb3\x81",
-        "\xea\xec\xb2\xa3\x0b\x22\xa8\x7f",
-        "\x99\x24\xa4\x3c\xc1\x31\x57\x24",
-        "\xbd\x83\x8d\x3a\xaf\xbf\x8d\xb7",
-        "\x0b\x1a\x2a\x32\x65\xd5\x1a\xea",
-        "\x13\x50\x79\xa3\x23\x1c\xe6\x60",
-        "\x93\x2b\x28\x46\xe4\xd7\x06\x66",
-        "\xe1\x91\x5f\x5c\xb1\xec\xa4\x6c",
-        "\xf3\x25\x96\x5c\xa1\x6d\x62\x9f",
-        "\x57\x5f\xf2\x8e\x60\x38\x1b\xe5",
-        "\x72\x45\x06\xeb\x4c\x32\x8a\x95",
+        "\x31\x0e\x0e\xdd\x47\xdb\x6f\x72".*, // ""
+        "\xfd\x67\xdc\x93\xc5\x39\xf8\x74".*, // "\x00"
+        "\x5a\x4f\xa9\xd9\x09\x80\x6c\x0d".*, // "\x00\x01" ... etc
+        "\x2d\x7e\xfb\xd7\x96\x66\x67\x85".*,
+        "\xb7\x87\x71\x27\xe0\x94\x27\xcf".*,
+        "\x8d\xa6\x99\xcd\x64\x55\x76\x18".*,
+        "\xce\xe3\xfe\x58\x6e\x46\xc9\xcb".*,
+        "\x37\xd1\x01\x8b\xf5\x00\x02\xab".*,
+        "\x62\x24\x93\x9a\x79\xf5\xf5\x93".*,
+        "\xb0\xe4\xa9\x0b\xdf\x82\x00\x9e".*,
+        "\xf3\xb9\xdd\x94\xc5\xbb\x5d\x7a".*,
+        "\xa7\xad\x6b\x22\x46\x2f\xb3\xf4".*,
+        "\xfb\xe5\x0e\x86\xbc\x8f\x1e\x75".*,
+        "\x90\x3d\x84\xc0\x27\x56\xea\x14".*,
+        "\xee\xf2\x7a\x8e\x90\xca\x23\xf7".*,
+        "\xe5\x45\xbe\x49\x61\xca\x29\xa1".*,
+        "\xdb\x9b\xc2\x57\x7f\xcc\x2a\x3f".*,
+        "\x94\x47\xbe\x2c\xf5\xe9\x9a\x69".*,
+        "\x9c\xd3\x8d\x96\xf0\xb3\xc1\x4b".*,
+        "\xbd\x61\x79\xa7\x1d\xc9\x6d\xbb".*,
+        "\x98\xee\xa2\x1a\xf2\x5c\xd6\xbe".*,
+        "\xc7\x67\x3b\x2e\xb0\xcb\xf2\xd0".*,
+        "\x88\x3e\xa3\xe3\x95\x67\x53\x93".*,
+        "\xc8\xce\x5c\xcd\x8c\x03\x0c\xa8".*,
+        "\x94\xaf\x49\xf6\xc6\x50\xad\xb8".*,
+        "\xea\xb8\x85\x8a\xde\x92\xe1\xbc".*,
+        "\xf3\x15\xbb\x5b\xb8\x35\xd8\x17".*,
+        "\xad\xcf\x6b\x07\x63\x61\x2e\x2f".*,
+        "\xa5\xc9\x1d\xa7\xac\xaa\x4d\xde".*,
+        "\x71\x65\x95\x87\x66\x50\xa2\xa6".*,
+        "\x28\xef\x49\x5c\x53\xa3\x87\xad".*,
+        "\x42\xc3\x41\xd8\xfa\x92\xd8\x32".*,
+        "\xce\x7c\xf2\x72\x2f\x51\x27\x71".*,
+        "\xe3\x78\x59\xf9\x46\x23\xf3\xa7".*,
+        "\x38\x12\x05\xbb\x1a\xb0\xe0\x12".*,
+        "\xae\x97\xa1\x0f\xd4\x34\xe0\x15".*,
+        "\xb4\xa3\x15\x08\xbe\xff\x4d\x31".*,
+        "\x81\x39\x62\x29\xf0\x90\x79\x02".*,
+        "\x4d\x0c\xf4\x9e\xe5\xd4\xdc\xca".*,
+        "\x5c\x73\x33\x6a\x76\xd8\xbf\x9a".*,
+        "\xd0\xa7\x04\x53\x6b\xa9\x3e\x0e".*,
+        "\x92\x59\x58\xfc\xd6\x42\x0c\xad".*,
+        "\xa9\x15\xc2\x9b\xc8\x06\x73\x18".*,
+        "\x95\x2b\x79\xf3\xbc\x0a\xa6\xd4".*,
+        "\xf2\x1d\xf2\xe4\x1d\x45\x35\xf9".*,
+        "\x87\x57\x75\x19\x04\x8f\x53\xa9".*,
+        "\x10\xa5\x6c\xf5\xdf\xcd\x9a\xdb".*,
+        "\xeb\x75\x09\x5c\xcd\x98\x6c\xd0".*,
+        "\x51\xa9\xcb\x9e\xcb\xa3\x12\xe6".*,
+        "\x96\xaf\xad\xfc\x2c\xe6\x66\xc7".*,
+        "\x72\xfe\x52\x97\x5a\x43\x64\xee".*,
+        "\x5a\x16\x45\xb2\x76\xd5\x92\xa1".*,
+        "\xb2\x74\xcb\x8e\xbf\x87\x87\x0a".*,
+        "\x6f\x9b\xb4\x20\x3d\xe7\xb3\x81".*,
+        "\xea\xec\xb2\xa3\x0b\x22\xa8\x7f".*,
+        "\x99\x24\xa4\x3c\xc1\x31\x57\x24".*,
+        "\xbd\x83\x8d\x3a\xaf\xbf\x8d\xb7".*,
+        "\x0b\x1a\x2a\x32\x65\xd5\x1a\xea".*,
+        "\x13\x50\x79\xa3\x23\x1c\xe6\x60".*,
+        "\x93\x2b\x28\x46\xe4\xd7\x06\x66".*,
+        "\xe1\x91\x5f\x5c\xb1\xec\xa4\x6c".*,
+        "\xf3\x25\x96\x5c\xa1\x6d\x62\x9f".*,
+        "\x57\x5f\xf2\x8e\x60\x38\x1b\xe5".*,
+        "\x72\x45\x06\xeb\x4c\x32\x8a\x95".*,
     };
 
     const siphash = SipHash64(2, 4);
@@ -281,70 +281,70 @@ test "siphash64-2-4 sanity" {
 
 test "siphash128-2-4 sanity" {
     const vectors = [_][16]u8{
-        "\xa3\x81\x7f\x04\xba\x25\xa8\xe6\x6d\xf6\x72\x14\xc7\x55\x02\x93",
-        "\xda\x87\xc1\xd8\x6b\x99\xaf\x44\x34\x76\x59\x11\x9b\x22\xfc\x45",
-        "\x81\x77\x22\x8d\xa4\xa4\x5d\xc7\xfc\xa3\x8b\xde\xf6\x0a\xff\xe4",
-        "\x9c\x70\xb6\x0c\x52\x67\xa9\x4e\x5f\x33\xb6\xb0\x29\x85\xed\x51",
-        "\xf8\x81\x64\xc1\x2d\x9c\x8f\xaf\x7d\x0f\x6e\x7c\x7b\xcd\x55\x79",
-        "\x13\x68\x87\x59\x80\x77\x6f\x88\x54\x52\x7a\x07\x69\x0e\x96\x27",
-        "\x14\xee\xca\x33\x8b\x20\x86\x13\x48\x5e\xa0\x30\x8f\xd7\xa1\x5e",
-        "\xa1\xf1\xeb\xbe\xd8\xdb\xc1\x53\xc0\xb8\x4a\xa6\x1f\xf0\x82\x39",
-        "\x3b\x62\xa9\xba\x62\x58\xf5\x61\x0f\x83\xe2\x64\xf3\x14\x97\xb4",
-        "\x26\x44\x99\x06\x0a\xd9\xba\xab\xc4\x7f\x8b\x02\xbb\x6d\x71\xed",
-        "\x00\x11\x0d\xc3\x78\x14\x69\x56\xc9\x54\x47\xd3\xf3\xd0\xfb\xba",
-        "\x01\x51\xc5\x68\x38\x6b\x66\x77\xa2\xb4\xdc\x6f\x81\xe5\xdc\x18",
-        "\xd6\x26\xb2\x66\x90\x5e\xf3\x58\x82\x63\x4d\xf6\x85\x32\xc1\x25",
-        "\x98\x69\xe2\x47\xe9\xc0\x8b\x10\xd0\x29\x93\x4f\xc4\xb9\x52\xf7",
-        "\x31\xfc\xef\xac\x66\xd7\xde\x9c\x7e\xc7\x48\x5f\xe4\x49\x49\x02",
-        "\x54\x93\xe9\x99\x33\xb0\xa8\x11\x7e\x08\xec\x0f\x97\xcf\xc3\xd9",
-        "\x6e\xe2\xa4\xca\x67\xb0\x54\xbb\xfd\x33\x15\xbf\x85\x23\x05\x77",
-        "\x47\x3d\x06\xe8\x73\x8d\xb8\x98\x54\xc0\x66\xc4\x7a\xe4\x77\x40",
-        "\xa4\x26\xe5\xe4\x23\xbf\x48\x85\x29\x4d\xa4\x81\xfe\xae\xf7\x23",
-        "\x78\x01\x77\x31\xcf\x65\xfa\xb0\x74\xd5\x20\x89\x52\x51\x2e\xb1",
-        "\x9e\x25\xfc\x83\x3f\x22\x90\x73\x3e\x93\x44\xa5\xe8\x38\x39\xeb",
-        "\x56\x8e\x49\x5a\xbe\x52\x5a\x21\x8a\x22\x14\xcd\x3e\x07\x1d\x12",
-        "\x4a\x29\xb5\x45\x52\xd1\x6b\x9a\x46\x9c\x10\x52\x8e\xff\x0a\xae",
-        "\xc9\xd1\x84\xdd\xd5\xa9\xf5\xe0\xcf\x8c\xe2\x9a\x9a\xbf\x69\x1c",
-        "\x2d\xb4\x79\xae\x78\xbd\x50\xd8\x88\x2a\x8a\x17\x8a\x61\x32\xad",
-        "\x8e\xce\x5f\x04\x2d\x5e\x44\x7b\x50\x51\xb9\xea\xcb\x8d\x8f\x6f",
-        "\x9c\x0b\x53\xb4\xb3\xc3\x07\xe8\x7e\xae\xe0\x86\x78\x14\x1f\x66",
-        "\xab\xf2\x48\xaf\x69\xa6\xea\xe4\xbf\xd3\xeb\x2f\x12\x9e\xeb\x94",
-        "\x06\x64\xda\x16\x68\x57\x4b\x88\xb9\x35\xf3\x02\x73\x58\xae\xf4",
-        "\xaa\x4b\x9d\xc4\xbf\x33\x7d\xe9\x0c\xd4\xfd\x3c\x46\x7c\x6a\xb7",
-        "\xea\x5c\x7f\x47\x1f\xaf\x6b\xde\x2b\x1a\xd7\xd4\x68\x6d\x22\x87",
-        "\x29\x39\xb0\x18\x32\x23\xfa\xfc\x17\x23\xde\x4f\x52\xc4\x3d\x35",
-        "\x7c\x39\x56\xca\x5e\xea\xfc\x3e\x36\x3e\x9d\x55\x65\x46\xeb\x68",
-        "\x77\xc6\x07\x71\x46\xf0\x1c\x32\xb6\xb6\x9d\x5f\x4e\xa9\xff\xcf",
-        "\x37\xa6\x98\x6c\xb8\x84\x7e\xdf\x09\x25\xf0\xf1\x30\x9b\x54\xde",
-        "\xa7\x05\xf0\xe6\x9d\xa9\xa8\xf9\x07\x24\x1a\x2e\x92\x3c\x8c\xc8",
-        "\x3d\xc4\x7d\x1f\x29\xc4\x48\x46\x1e\x9e\x76\xed\x90\x4f\x67\x11",
-        "\x0d\x62\xbf\x01\xe6\xfc\x0e\x1a\x0d\x3c\x47\x51\xc5\xd3\x69\x2b",
-        "\x8c\x03\x46\x8b\xca\x7c\x66\x9e\xe4\xfd\x5e\x08\x4b\xbe\xe7\xb5",
-        "\x52\x8a\x5b\xb9\x3b\xaf\x2c\x9c\x44\x73\xcc\xe5\xd0\xd2\x2b\xd9",
-        "\xdf\x6a\x30\x1e\x95\xc9\x5d\xad\x97\xae\x0c\xc8\xc6\x91\x3b\xd8",
-        "\x80\x11\x89\x90\x2c\x85\x7f\x39\xe7\x35\x91\x28\x5e\x70\xb6\xdb",
-        "\xe6\x17\x34\x6a\xc9\xc2\x31\xbb\x36\x50\xae\x34\xcc\xca\x0c\x5b",
-        "\x27\xd9\x34\x37\xef\xb7\x21\xaa\x40\x18\x21\xdc\xec\x5a\xdf\x89",
-        "\x89\x23\x7d\x9d\xed\x9c\x5e\x78\xd8\xb1\xc9\xb1\x66\xcc\x73\x42",
-        "\x4a\x6d\x80\x91\xbf\x5e\x7d\x65\x11\x89\xfa\x94\xa2\x50\xb1\x4c",
-        "\x0e\x33\xf9\x60\x55\xe7\xae\x89\x3f\xfc\x0e\x3d\xcf\x49\x29\x02",
-        "\xe6\x1c\x43\x2b\x72\x0b\x19\xd1\x8e\xc8\xd8\x4b\xdc\x63\x15\x1b",
-        "\xf7\xe5\xae\xf5\x49\xf7\x82\xcf\x37\x90\x55\xa6\x08\x26\x9b\x16",
-        "\x43\x8d\x03\x0f\xd0\xb7\xa5\x4f\xa8\x37\xf2\xad\x20\x1a\x64\x03",
-        "\xa5\x90\xd3\xee\x4f\xbf\x04\xe3\x24\x7e\x0d\x27\xf2\x86\x42\x3f",
-        "\x5f\xe2\xc1\xa1\x72\xfe\x93\xc4\xb1\x5c\xd3\x7c\xae\xf9\xf5\x38",
-        "\x2c\x97\x32\x5c\xbd\x06\xb3\x6e\xb2\x13\x3d\xd0\x8b\x3a\x01\x7c",
-        "\x92\xc8\x14\x22\x7a\x6b\xca\x94\x9f\xf0\x65\x9f\x00\x2a\xd3\x9e",
-        "\xdc\xe8\x50\x11\x0b\xd8\x32\x8c\xfb\xd5\x08\x41\xd6\x91\x1d\x87",
-        "\x67\xf1\x49\x84\xc7\xda\x79\x12\x48\xe3\x2b\xb5\x92\x25\x83\xda",
-        "\x19\x38\xf2\xcf\x72\xd5\x4e\xe9\x7e\x94\x16\x6f\xa9\x1d\x2a\x36",
-        "\x74\x48\x1e\x96\x46\xed\x49\xfe\x0f\x62\x24\x30\x16\x04\x69\x8e",
-        "\x57\xfc\xa5\xde\x98\xa9\xd6\xd8\x00\x64\x38\xd0\x58\x3d\x8a\x1d",
-        "\x9f\xec\xde\x1c\xef\xdc\x1c\xbe\xd4\x76\x36\x74\xd9\x57\x53\x59",
-        "\xe3\x04\x0c\x00\xeb\x28\xf1\x53\x66\xca\x73\xcb\xd8\x72\xe7\x40",
-        "\x76\x97\x00\x9a\x6a\x83\x1d\xfe\xcc\xa9\x1c\x59\x93\x67\x0f\x7a",
-        "\x58\x53\x54\x23\x21\xf5\x67\xa0\x05\xd5\x47\xa4\xf0\x47\x59\xbd",
-        "\x51\x50\xd1\x77\x2f\x50\x83\x4a\x50\x3e\x06\x9a\x97\x3f\xbd\x7c",
+        "\xa3\x81\x7f\x04\xba\x25\xa8\xe6\x6d\xf6\x72\x14\xc7\x55\x02\x93".*,
+        "\xda\x87\xc1\xd8\x6b\x99\xaf\x44\x34\x76\x59\x11\x9b\x22\xfc\x45".*,
+        "\x81\x77\x22\x8d\xa4\xa4\x5d\xc7\xfc\xa3\x8b\xde\xf6\x0a\xff\xe4".*,
+        "\x9c\x70\xb6\x0c\x52\x67\xa9\x4e\x5f\x33\xb6\xb0\x29\x85\xed\x51".*,
+        "\xf8\x81\x64\xc1\x2d\x9c\x8f\xaf\x7d\x0f\x6e\x7c\x7b\xcd\x55\x79".*,
+        "\x13\x68\x87\x59\x80\x77\x6f\x88\x54\x52\x7a\x07\x69\x0e\x96\x27".*,
+        "\x14\xee\xca\x33\x8b\x20\x86\x13\x48\x5e\xa0\x30\x8f\xd7\xa1\x5e".*,
+        "\xa1\xf1\xeb\xbe\xd8\xdb\xc1\x53\xc0\xb8\x4a\xa6\x1f\xf0\x82\x39".*,
+        "\x3b\x62\xa9\xba\x62\x58\xf5\x61\x0f\x83\xe2\x64\xf3\x14\x97\xb4".*,
+        "\x26\x44\x99\x06\x0a\xd9\xba\xab\xc4\x7f\x8b\x02\xbb\x6d\x71\xed".*,
+        "\x00\x11\x0d\xc3\x78\x14\x69\x56\xc9\x54\x47\xd3\xf3\xd0\xfb\xba".*,
+        "\x01\x51\xc5\x68\x38\x6b\x66\x77\xa2\xb4\xdc\x6f\x81\xe5\xdc\x18".*,
+        "\xd6\x26\xb2\x66\x90\x5e\xf3\x58\x82\x63\x4d\xf6\x85\x32\xc1\x25".*,
+        "\x98\x69\xe2\x47\xe9\xc0\x8b\x10\xd0\x29\x93\x4f\xc4\xb9\x52\xf7".*,
+        "\x31\xfc\xef\xac\x66\xd7\xde\x9c\x7e\xc7\x48\x5f\xe4\x49\x49\x02".*,
+        "\x54\x93\xe9\x99\x33\xb0\xa8\x11\x7e\x08\xec\x0f\x97\xcf\xc3\xd9".*,
+        "\x6e\xe2\xa4\xca\x67\xb0\x54\xbb\xfd\x33\x15\xbf\x85\x23\x05\x77".*,
+        "\x47\x3d\x06\xe8\x73\x8d\xb8\x98\x54\xc0\x66\xc4\x7a\xe4\x77\x40".*,
+        "\xa4\x26\xe5\xe4\x23\xbf\x48\x85\x29\x4d\xa4\x81\xfe\xae\xf7\x23".*,
+        "\x78\x01\x77\x31\xcf\x65\xfa\xb0\x74\xd5\x20\x89\x52\x51\x2e\xb1".*,
+        "\x9e\x25\xfc\x83\x3f\x22\x90\x73\x3e\x93\x44\xa5\xe8\x38\x39\xeb".*,
+        "\x56\x8e\x49\x5a\xbe\x52\x5a\x21\x8a\x22\x14\xcd\x3e\x07\x1d\x12".*,
+        "\x4a\x29\xb5\x45\x52\xd1\x6b\x9a\x46\x9c\x10\x52\x8e\xff\x0a\xae".*,
+        "\xc9\xd1\x84\xdd\xd5\xa9\xf5\xe0\xcf\x8c\xe2\x9a\x9a\xbf\x69\x1c".*,
+        "\x2d\xb4\x79\xae\x78\xbd\x50\xd8\x88\x2a\x8a\x17\x8a\x61\x32\xad".*,
+        "\x8e\xce\x5f\x04\x2d\x5e\x44\x7b\x50\x51\xb9\xea\xcb\x8d\x8f\x6f".*,
+        "\x9c\x0b\x53\xb4\xb3\xc3\x07\xe8\x7e\xae\xe0\x86\x78\x14\x1f\x66".*,
+        "\xab\xf2\x48\xaf\x69\xa6\xea\xe4\xbf\xd3\xeb\x2f\x12\x9e\xeb\x94".*,
+        "\x06\x64\xda\x16\x68\x57\x4b\x88\xb9\x35\xf3\x02\x73\x58\xae\xf4".*,
+        "\xaa\x4b\x9d\xc4\xbf\x33\x7d\xe9\x0c\xd4\xfd\x3c\x46\x7c\x6a\xb7".*,
+        "\xea\x5c\x7f\x47\x1f\xaf\x6b\xde\x2b\x1a\xd7\xd4\x68\x6d\x22\x87".*,
+        "\x29\x39\xb0\x18\x32\x23\xfa\xfc\x17\x23\xde\x4f\x52\xc4\x3d\x35".*,
+        "\x7c\x39\x56\xca\x5e\xea\xfc\x3e\x36\x3e\x9d\x55\x65\x46\xeb\x68".*,
+        "\x77\xc6\x07\x71\x46\xf0\x1c\x32\xb6\xb6\x9d\x5f\x4e\xa9\xff\xcf".*,
+        "\x37\xa6\x98\x6c\xb8\x84\x7e\xdf\x09\x25\xf0\xf1\x30\x9b\x54\xde".*,
+        "\xa7\x05\xf0\xe6\x9d\xa9\xa8\xf9\x07\x24\x1a\x2e\x92\x3c\x8c\xc8".*,
+        "\x3d\xc4\x7d\x1f\x29\xc4\x48\x46\x1e\x9e\x76\xed\x90\x4f\x67\x11".*,
+        "\x0d\x62\xbf\x01\xe6\xfc\x0e\x1a\x0d\x3c\x47\x51\xc5\xd3\x69\x2b".*,
+        "\x8c\x03\x46\x8b\xca\x7c\x66\x9e\xe4\xfd\x5e\x08\x4b\xbe\xe7\xb5".*,
+        "\x52\x8a\x5b\xb9\x3b\xaf\x2c\x9c\x44\x73\xcc\xe5\xd0\xd2\x2b\xd9".*,
+        "\xdf\x6a\x30\x1e\x95\xc9\x5d\xad\x97\xae\x0c\xc8\xc6\x91\x3b\xd8".*,
+        "\x80\x11\x89\x90\x2c\x85\x7f\x39\xe7\x35\x91\x28\x5e\x70\xb6\xdb".*,
+        "\xe6\x17\x34\x6a\xc9\xc2\x31\xbb\x36\x50\xae\x34\xcc\xca\x0c\x5b".*,
+        "\x27\xd9\x34\x37\xef\xb7\x21\xaa\x40\x18\x21\xdc\xec\x5a\xdf\x89".*,
+        "\x89\x23\x7d\x9d\xed\x9c\x5e\x78\xd8\xb1\xc9\xb1\x66\xcc\x73\x42".*,
+        "\x4a\x6d\x80\x91\xbf\x5e\x7d\x65\x11\x89\xfa\x94\xa2\x50\xb1\x4c".*,
+        "\x0e\x33\xf9\x60\x55\xe7\xae\x89\x3f\xfc\x0e\x3d\xcf\x49\x29\x02".*,
+        "\xe6\x1c\x43\x2b\x72\x0b\x19\xd1\x8e\xc8\xd8\x4b\xdc\x63\x15\x1b".*,
+        "\xf7\xe5\xae\xf5\x49\xf7\x82\xcf\x37\x90\x55\xa6\x08\x26\x9b\x16".*,
+        "\x43\x8d\x03\x0f\xd0\xb7\xa5\x4f\xa8\x37\xf2\xad\x20\x1a\x64\x03".*,
+        "\xa5\x90\xd3\xee\x4f\xbf\x04\xe3\x24\x7e\x0d\x27\xf2\x86\x42\x3f".*,
+        "\x5f\xe2\xc1\xa1\x72\xfe\x93\xc4\xb1\x5c\xd3\x7c\xae\xf9\xf5\x38".*,
+        "\x2c\x97\x32\x5c\xbd\x06\xb3\x6e\xb2\x13\x3d\xd0\x8b\x3a\x01\x7c".*,
+        "\x92\xc8\x14\x22\x7a\x6b\xca\x94\x9f\xf0\x65\x9f\x00\x2a\xd3\x9e".*,
+        "\xdc\xe8\x50\x11\x0b\xd8\x32\x8c\xfb\xd5\x08\x41\xd6\x91\x1d\x87".*,
+        "\x67\xf1\x49\x84\xc7\xda\x79\x12\x48\xe3\x2b\xb5\x92\x25\x83\xda".*,
+        "\x19\x38\xf2\xcf\x72\xd5\x4e\xe9\x7e\x94\x16\x6f\xa9\x1d\x2a\x36".*,
+        "\x74\x48\x1e\x96\x46\xed\x49\xfe\x0f\x62\x24\x30\x16\x04\x69\x8e".*,
+        "\x57\xfc\xa5\xde\x98\xa9\xd6\xd8\x00\x64\x38\xd0\x58\x3d\x8a\x1d".*,
+        "\x9f\xec\xde\x1c\xef\xdc\x1c\xbe\xd4\x76\x36\x74\xd9\x57\x53\x59".*,
+        "\xe3\x04\x0c\x00\xeb\x28\xf1\x53\x66\xca\x73\xcb\xd8\x72\xe7\x40".*,
+        "\x76\x97\x00\x9a\x6a\x83\x1d\xfe\xcc\xa9\x1c\x59\x93\x67\x0f\x7a".*,
+        "\x58\x53\x54\x23\x21\xf5\x67\xa0\x05\xd5\x47\xa4\xf0\x47\x59\xbd".*,
+        "\x51\x50\xd1\x77\x2f\x50\x83\x4a\x50\x3e\x06\x9a\x97\x3f\xbd\x7c".*,
     };
 
     const siphash = SipHash128(2, 4);
diff --git a/lib/std/io/test.zig b/lib/std/io/test.zig
index 28b8371d9d..d2374f0a3f 100644
--- a/lib/std/io/test.zig
+++ b/lib/std/io/test.zig
@@ -595,8 +595,8 @@ test "Deserializer bad data" {
 test "c out stream" {
     if (!builtin.link_libc) return error.SkipZigTest;
 
-    const filename = c"tmp_io_test_file.txt";
-    const out_file = std.c.fopen(filename, c"w") orelse return error.UnableToOpenTestFile;
+    const filename = "tmp_io_test_file.txt";
+    const out_file = std.c.fopen(filename, "w") orelse return error.UnableToOpenTestFile;
     defer {
         _ = std.c.fclose(out_file);
         fs.deleteFileC(filename) catch {};
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 19e9634d5a..160b8e6e5e 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1408,7 +1408,9 @@ test "toBytes" {
 fn BytesAsValueReturnType(comptime T: type, comptime B: type) type {
     const size = @as(usize, @sizeOf(T));
 
-    if (comptime !trait.is(builtin.TypeId.Pointer)(B) or meta.Child(B) != [size]u8) {
+    if (comptime !trait.is(builtin.TypeId.Pointer)(B) or
+        (meta.Child(B) != [size]u8 and meta.Child(B) != [size]null u8))
+    {
         @compileError("expected *[N]u8 " ++ ", passed " ++ @typeName(B));
     }
 
@@ -1430,12 +1432,12 @@ test "bytesAsValue" {
         builtin.Endian.Little => "\xEF\xBE\xAD\xDE",
     };
 
-    testing.expect(deadbeef == bytesAsValue(u32, &deadbeef_bytes).*);
+    testing.expect(deadbeef == bytesAsValue(u32, deadbeef_bytes).*);
 
-    var codeface_bytes = switch (builtin.endian) {
+    var codeface_bytes: [4]u8 = switch (builtin.endian) {
         builtin.Endian.Big => "\xC0\xDE\xFA\xCE",
         builtin.Endian.Little => "\xCE\xFA\xDE\xC0",
-    };
+    }.*;
     var codeface = bytesAsValue(u32, &codeface_bytes);
     testing.expect(codeface.* == 0xC0DEFACE);
     codeface.* = 0;
@@ -1456,14 +1458,14 @@ test "bytesAsValue" {
         .d = 0xA1,
     };
     const inst_bytes = "\xBE\xEF\xDE\xA1";
-    const inst2 = bytesAsValue(S, &inst_bytes);
+    const inst2 = bytesAsValue(S, inst_bytes);
     testing.expect(meta.eql(inst, inst2.*));
 }
 
 ///Given a pointer to an array of bytes, returns a value of the specified type backed by a
 /// copy of those bytes.
 pub fn bytesToValue(comptime T: type, bytes: var) T {
-    return bytesAsValue(T, &bytes).*;
+    return bytesAsValue(T, bytes).*;
 }
 test "bytesToValue" {
     const deadbeef_bytes = switch (builtin.endian) {
@@ -1491,11 +1493,11 @@ pub fn subArrayPtr(ptr: var, comptime start: usize, comptime length: usize) SubA
 }
 
 test "subArrayPtr" {
-    const a1 = "abcdef";
+    const a1: [6]u8 = "abcdef".*;
     const sub1 = subArrayPtr(&a1, 2, 3);
     testing.expect(eql(u8, sub1.*, "cde"));
 
-    var a2 = "abcdef";
+    var a2: [6]u8 = "abcdef".*;
     var sub2 = subArrayPtr(&a2, 2, 3);
 
     testing.expect(eql(u8, sub2, "cde"));
diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index 01d240f31f..b770b97a47 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -469,19 +469,19 @@ test "std.meta.eql" {
     const s_1 = S{
         .a = 134,
         .b = 123.3,
-        .c = "12345",
+        .c = "12345".*,
     };
 
     const s_2 = S{
         .a = 1,
         .b = 123.3,
-        .c = "54321",
+        .c = "54321".*,
     };
 
     const s_3 = S{
         .a = 134,
         .b = 123.3,
-        .c = "12345",
+        .c = "12345".*,
     };
 
     const u_1 = U{ .f = 24 };
@@ -494,9 +494,9 @@ test "std.meta.eql" {
     testing.expect(eql(u_1, u_3));
     testing.expect(!eql(u_1, u_2));
 
-    var a1 = "abcdef";
-    var a2 = "abcdef";
-    var a3 = "ghijkl";
+    var a1 = "abcdef".*;
+    var a2 = "abcdef".*;
+    var a3 = "ghijkl".*;
 
     testing.expect(eql(a1, a2));
     testing.expect(!eql(a1, a3));
@@ -558,4 +558,3 @@ pub fn refAllDecls(comptime T: type) void {
     if (!builtin.is_test) return;
     _ = declarations(T);
 }
-
diff --git a/lib/std/meta/trait.zig b/lib/std/meta/trait.zig
index 8857b4aa9e..2388acbeb6 100644
--- a/lib/std/meta/trait.zig
+++ b/lib/std/meta/trait.zig
@@ -319,7 +319,6 @@ test "std.meta.trait.isNumber" {
     testing.expect(!isNumber(NotANumber));
 }
 
-///
 pub fn isConstPtr(comptime T: type) bool {
     if (!comptime is(builtin.TypeId.Pointer)(T)) return false;
     const info = @typeInfo(T);
@@ -335,7 +334,6 @@ test "std.meta.trait.isConstPtr" {
     testing.expect(!isConstPtr(@typeOf(6)));
 }
 
-///
 pub fn isContainer(comptime T: type) bool {
     const info = @typeInfo(T);
     return switch (info) {
diff --git a/lib/std/net.zig b/lib/std/net.zig
index f4cd09482b..5e194d73ca 100644
--- a/lib/std/net.zig
+++ b/lib/std/net.zig
@@ -666,35 +666,35 @@ const Policy = struct {
 
 const defined_policies = [_]Policy{
     Policy{
-        .addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01",
+        .addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01".*,
         .len = 15,
         .mask = 0xff,
         .prec = 50,
         .label = 0,
     },
     Policy{
-        .addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00",
+        .addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00".*,
         .len = 11,
         .mask = 0xff,
         .prec = 35,
         .label = 4,
     },
     Policy{
-        .addr = "\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+        .addr = "\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
         .len = 1,
         .mask = 0xff,
         .prec = 30,
         .label = 2,
     },
     Policy{
-        .addr = "\x20\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+        .addr = "\x20\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
         .len = 3,
         .mask = 0xff,
         .prec = 5,
         .label = 5,
     },
     Policy{
-        .addr = "\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+        .addr = "\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
         .len = 0,
         .mask = 0xfe,
         .prec = 3,
@@ -708,7 +708,7 @@ const defined_policies = [_]Policy{
     // { "\x3f\xfe", 1, 0xff, 1, 12 },
     // Last rule must match all addresses to stop loop.
     Policy{
-        .addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+        .addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
         .len = 0,
         .mask = 0,
         .prec = 40,
@@ -812,7 +812,7 @@ fn linuxLookupNameFromHosts(
     family: os.sa_family_t,
     port: u16,
 ) !void {
-    const file = fs.File.openReadC(c"/etc/hosts") catch |err| switch (err) {
+    const file = fs.File.openReadC("/etc/hosts") catch |err| switch (err) {
         error.FileNotFound,
         error.NotDir,
         error.AccessDenied,
@@ -1006,7 +1006,7 @@ fn getResolvConf(allocator: *mem.Allocator, rc: *ResolvConf) !void {
     };
     errdefer rc.deinit();
 
-    const file = fs.File.openReadC(c"/etc/resolv.conf") catch |err| switch (err) {
+    const file = fs.File.openReadC("/etc/resolv.conf") catch |err| switch (err) {
         error.FileNotFound,
         error.NotDir,
         error.AccessDenied,
diff --git a/lib/std/os.zig b/lib/std/os.zig
index 68a3a6e9f6..28a88beb04 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -157,7 +157,7 @@ pub fn getrandom(buffer: []u8) GetRandomError!void {
 }
 
 fn getRandomBytesDevURandom(buf: []u8) !void {
-    const fd = try openC(c"/dev/urandom", O_RDONLY | O_CLOEXEC, 0);
+    const fd = try openC("/dev/urandom", O_RDONLY | O_CLOEXEC, 0);
     defer close(fd);
 
     const st = try fstat(fd);
@@ -2674,7 +2674,7 @@ pub fn dl_iterate_phdr(
     if (it.end()) {
         var info = dl_phdr_info{
             .dlpi_addr = elf_base,
-            .dlpi_name = c"/proc/self/exe",
+            .dlpi_name = "/proc/self/exe",
             .dlpi_phdr = phdrs.ptr,
             .dlpi_phnum = ehdr.e_phnum,
         };
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 7e2f14021f..1de66b8d2e 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1053,7 +1053,7 @@ pub fn dl_iterate_phdr(comptime T: type, callback: extern fn (info: *dl_phdr_inf
     if (it.end()) {
         var info = dl_phdr_info{
             .dlpi_addr = elf_base,
-            .dlpi_name = c"/proc/self/exe",
+            .dlpi_name = "/proc/self/exe",
             .dlpi_phdr = @intToPtr([*]elf.Phdr, elf_base + __ehdr_start.e_phoff),
             .dlpi_phnum = __ehdr_start.e_phnum,
         };
diff --git a/lib/std/os/linux/test.zig b/lib/std/os/linux/test.zig
index bccb7beb1e..8281851d6b 100644
--- a/lib/std/os/linux/test.zig
+++ b/lib/std/os/linux/test.zig
@@ -56,7 +56,7 @@ test "statx" {
     }
 
     var statx_buf: linux.Statx = undefined;
-    switch (linux.getErrno(linux.statx(file.handle, c"", linux.AT_EMPTY_PATH, linux.STATX_BASIC_STATS, &statx_buf))) {
+    switch (linux.getErrno(linux.statx(file.handle, "", linux.AT_EMPTY_PATH, linux.STATX_BASIC_STATS, &statx_buf))) {
         0 => {},
         // The statx syscall was only introduced in linux 4.11
         linux.ENOSYS => return error.SkipZigTest,
@@ -64,7 +64,7 @@ test "statx" {
     }
 
     var stat_buf: linux.Stat = undefined;
-    switch (linux.getErrno(linux.fstatat(file.handle, c"", &stat_buf, linux.AT_EMPTY_PATH))) {
+    switch (linux.getErrno(linux.fstatat(file.handle, "", &stat_buf, linux.AT_EMPTY_PATH))) {
         0 => {},
         else => unreachable,
     }
diff --git a/lib/std/process.zig b/lib/std/process.zig
index fca10a240d..3f065de8fc 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -473,14 +473,14 @@ pub fn argsFree(allocator: *mem.Allocator, args_alloc: []const []u8) void {
 }
 
 test "windows arg parsing" {
-    testWindowsCmdLine(c"a   b\tc d", [_][]const u8{ "a", "b", "c", "d" });
-    testWindowsCmdLine(c"\"abc\" d e", [_][]const u8{ "abc", "d", "e" });
-    testWindowsCmdLine(c"a\\\\\\b d\"e f\"g h", [_][]const u8{ "a\\\\\\b", "de fg", "h" });
-    testWindowsCmdLine(c"a\\\\\\\"b c d", [_][]const u8{ "a\\\"b", "c", "d" });
-    testWindowsCmdLine(c"a\\\\\\\\\"b c\" d e", [_][]const u8{ "a\\\\b c", "d", "e" });
-    testWindowsCmdLine(c"a   b\tc \"d f", [_][]const u8{ "a", "b", "c", "\"d", "f" });
-
-    testWindowsCmdLine(c"\".\\..\\zig-cache\\build\" \"bin\\zig.exe\" \".\\..\" \".\\..\\zig-cache\" \"--help\"", [_][]const u8{
+    testWindowsCmdLine("a   b\tc d", [_][]const u8{ "a", "b", "c", "d" });
+    testWindowsCmdLine("\"abc\" d e", [_][]const u8{ "abc", "d", "e" });
+    testWindowsCmdLine("a\\\\\\b d\"e f\"g h", [_][]const u8{ "a\\\\\\b", "de fg", "h" });
+    testWindowsCmdLine("a\\\\\\\"b c d", [_][]const u8{ "a\\\"b", "c", "d" });
+    testWindowsCmdLine("a\\\\\\\\\"b c\" d e", [_][]const u8{ "a\\\\b c", "d", "e" });
+    testWindowsCmdLine("a   b\tc \"d f", [_][]const u8{ "a", "b", "c", "\"d", "f" });
+
+    testWindowsCmdLine("\".\\..\\zig-cache\\build\" \"bin\\zig.exe\" \".\\..\" \".\\..\\zig-cache\" \"--help\"", [_][]const u8{
         ".\\..\\zig-cache\\build",
         "bin\\zig.exe",
         ".\\..",
diff --git a/lib/std/special/c.zig b/lib/std/special/c.zig
index 145c8897d5..8ac00c4e04 100644
--- a/lib/std/special/c.zig
+++ b/lib/std/special/c.zig
@@ -66,14 +66,14 @@ extern fn strncmp(_l: [*]const u8, _r: [*]const u8, _n: usize) c_int {
 }
 
 extern fn strerror(errnum: c_int) [*]const u8 {
-    return c"TODO strerror implementation";
+    return "TODO strerror implementation";
 }
 
 test "strncmp" {
-    std.testing.expect(strncmp(c"a", c"b", 1) == -1);
-    std.testing.expect(strncmp(c"a", c"c", 1) == -2);
-    std.testing.expect(strncmp(c"b", c"a", 1) == 1);
-    std.testing.expect(strncmp(c"\xff", c"\x02", 1) == 253);
+    std.testing.expect(strncmp("a", "b", 1) == -1);
+    std.testing.expect(strncmp("a", "c", 1) == -2);
+    std.testing.expect(strncmp("b", "a", 1) == 1);
+    std.testing.expect(strncmp("\xff", "\x02", 1) == 253);
 }
 
 // Avoid dragging in the runtime safety mechanisms into this .o file,
diff --git a/lib/std/thread.zig b/lib/std/thread.zig
index 4e15354055..fe976a6839 100644
--- a/lib/std/thread.zig
+++ b/lib/std/thread.zig
@@ -353,7 +353,7 @@ pub const Thread = struct {
         }
         var count: c_int = undefined;
         var count_len: usize = @sizeOf(c_int);
-        const name = if (comptime std.Target.current.isDarwin()) c"hw.logicalcpu" else c"hw.ncpu";
+        const name = if (comptime std.Target.current.isDarwin()) "hw.logicalcpu" else "hw.ncpu";
         os.sysctlbynameC(name, &count, &count_len, null, 0) catch |err| switch (err) {
             error.NameTooLong => unreachable,
             else => |e| return e,
diff --git a/lib/std/valgrind/memcheck.zig b/lib/std/valgrind/memcheck.zig
index a15a6cca0e..e0aefa7d5f 100644
--- a/lib/std/valgrind/memcheck.zig
+++ b/lib/std/valgrind/memcheck.zig
@@ -3,7 +3,7 @@ const testing = std.testing;
 const valgrind = std.valgrind;
 
 pub const MemCheckClientRequest = extern enum {
-    MakeMemNoAccess = valgrind.ToolBase("MC"),
+    MakeMemNoAccess = valgrind.ToolBase("MC".*),
     MakeMemUndefined,
     MakeMemDefined,
     Discard,
diff --git a/src-self-hosted/codegen.zig b/src-self-hosted/codegen.zig
index 90f5309faf..212a54b1aa 100644
--- a/src-self-hosted/codegen.zig
+++ b/src-self-hosted/codegen.zig
@@ -52,7 +52,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
         u32(c.ZIG_VERSION_MINOR),
         u32(c.ZIG_VERSION_PATCH),
     );
-    const flags = c"";
+    const flags = "";
     const runtime_version = 0;
     const compile_unit_file = llvm.CreateFile(
         dibuilder,
@@ -68,7 +68,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
         is_optimized,
         flags,
         runtime_version,
-        c"",
+        "",
         0,
         !comp.strip,
     ) orelse return error.OutOfMemory;
@@ -402,7 +402,7 @@ pub fn getHandleValue(ofile: *ObjectFile, ptr: *llvm.Value, ptr_type: *Type.Poin
     if (child_type.handleIsPtr()) {
         return ptr;
     }
-    return try renderLoad(ofile, ptr, ptr_type, c"");
+    return try renderLoad(ofile, ptr, ptr_type, "");
 }
 
 pub fn renderStoreUntyped(
diff --git a/src-self-hosted/compilation.zig b/src-self-hosted/compilation.zig
index 1e71a5e561..24c57f98ba 100644
--- a/src-self-hosted/compilation.zig
+++ b/src-self-hosted/compilation.zig
@@ -511,8 +511,8 @@ pub const Compilation = struct {
         comp.target_machine = llvm.CreateTargetMachine(
             comp.llvm_target,
             comp.llvm_triple.ptr(),
-            target_specific_cpu_args orelse c"",
-            target_specific_cpu_features orelse c"",
+            target_specific_cpu_args orelse "",
+            target_specific_cpu_features orelse "",
             opt_level,
             reloc_mode,
             llvm.CodeModelDefault,
diff --git a/src-self-hosted/ir.zig b/src-self-hosted/ir.zig
index df4d436b50..a650a3999d 100644
--- a/src-self-hosted/ir.zig
+++ b/src-self-hosted/ir.zig
@@ -331,7 +331,7 @@ pub const Inst = struct {
                 @intCast(c_uint, args.len),
                 llvm_cc,
                 fn_inline,
-                c"",
+                "",
             ) orelse error.OutOfMemory;
         }
     };
@@ -1410,7 +1410,7 @@ pub const Builder = struct {
         if (block.label) |label| {
             block_scope.incoming_values = std.ArrayList(*Inst).init(irb.arena());
             block_scope.incoming_blocks = std.ArrayList(*BasicBlock).init(irb.arena());
-            block_scope.end_block = try irb.createBasicBlock(parent_scope, c"BlockEnd");
+            block_scope.end_block = try irb.createBasicBlock(parent_scope, "BlockEnd");
             block_scope.is_comptime = try irb.buildConstBool(
                 parent_scope,
                 Span.token(block.lbrace),
@@ -1542,8 +1542,8 @@ pub const Builder = struct {
                 const defer_counts = irb.countDefers(scope, outer_scope);
                 const have_err_defers = defer_counts.error_exit != 0;
                 if (have_err_defers or irb.comp.have_err_ret_tracing) {
-                    const err_block = try irb.createBasicBlock(scope, c"ErrRetErr");
-                    const ok_block = try irb.createBasicBlock(scope, c"ErrRetOk");
+                    const err_block = try irb.createBasicBlock(scope, "ErrRetErr");
+                    const ok_block = try irb.createBasicBlock(scope, "ErrRetOk");
                     if (!have_err_defers) {
                         _ = try await (async irb.genDefersForBlock(scope, outer_scope, Scope.Defer.Kind.ScopeExit) catch unreachable);
                     }
@@ -1564,7 +1564,7 @@ pub const Builder = struct {
                         .is_comptime = err_is_comptime,
                     });
 
-                    const ret_stmt_block = try irb.createBasicBlock(scope, c"RetStmt");
+                    const ret_stmt_block = try irb.createBasicBlock(scope, "RetStmt");
 
                     try irb.setCursorAtEndAndAppendBlock(err_block);
                     if (have_err_defers) {
@@ -2530,7 +2530,7 @@ pub async fn gen(
     var irb = try Builder.init(comp, tree_scope, scope);
     errdefer irb.abort();
 
-    const entry_block = try irb.createBasicBlock(scope, c"Entry");
+    const entry_block = try irb.createBasicBlock(scope, "Entry");
     entry_block.ref(&irb); // Entry block gets a reference because we enter it to begin.
     try irb.setCursorAtEndAndAppendBlock(entry_block);
 
diff --git a/src-self-hosted/link.zig b/src-self-hosted/link.zig
index 1f5f07eff0..3af1842b9d 100644
--- a/src-self-hosted/link.zig
+++ b/src-self-hosted/link.zig
@@ -55,7 +55,7 @@ pub async fn link(comp: *Compilation) !void {
 
     // even though we're calling LLD as a library it thinks the first
     // argument is its own exe name
-    try ctx.args.append(c"lld");
+    try ctx.args.append("lld");
 
     if (comp.haveLibC()) {
         ctx.libc = ctx.comp.override_libc orelse blk: {
@@ -145,7 +145,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
     //    lj->args.append("-T");
     //    lj->args.append(g->linker_script);
     //}
-    try ctx.args.append(c"--gc-sections");
+    try ctx.args.append("--gc-sections");
 
     //lj->args.append("-m");
     //lj->args.append(getLDMOption(&g->zig_target));
@@ -155,9 +155,9 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
     //Buf *soname = nullptr;
     if (ctx.comp.is_static) {
         if (ctx.comp.target.isArmOrThumb()) {
-            try ctx.args.append(c"-Bstatic");
+            try ctx.args.append("-Bstatic");
         } else {
-            try ctx.args.append(c"-static");
+            try ctx.args.append("-static");
         }
     }
     //} else if (shared) {
@@ -170,7 +170,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
     //    soname = buf_sprintf("lib%s.so.%" ZIG_PRI_usize "", buf_ptr(g->root_out_name), g->version_major);
     //}
 
-    try ctx.args.append(c"-o");
+    try ctx.args.append("-o");
     try ctx.args.append(ctx.out_file_path.ptr());
 
     if (ctx.link_in_crt) {
@@ -213,10 +213,10 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
     //}
 
     if (ctx.comp.haveLibC()) {
-        try ctx.args.append(c"-L");
+        try ctx.args.append("-L");
         try ctx.args.append((try std.cstr.addNullByte(&ctx.arena.allocator, ctx.libc.lib_dir.?)).ptr);
 
-        try ctx.args.append(c"-L");
+        try ctx.args.append("-L");
         try ctx.args.append((try std.cstr.addNullByte(&ctx.arena.allocator, ctx.libc.static_lib_dir.?)).ptr);
 
         if (!ctx.comp.is_static) {
@@ -225,7 +225,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
                 if (ctx.comp.target.getDynamicLinkerPath()) |dl| break :blk dl;
                 return error.LibCMissingDynamicLinker;
             };
-            try ctx.args.append(c"-dynamic-linker");
+            try ctx.args.append("-dynamic-linker");
             try ctx.args.append((try std.cstr.addNullByte(&ctx.arena.allocator, dl)).ptr);
         }
     }
@@ -272,23 +272,23 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
     // libc dep
     if (ctx.comp.haveLibC()) {
         if (ctx.comp.is_static) {
-            try ctx.args.append(c"--start-group");
-            try ctx.args.append(c"-lgcc");
-            try ctx.args.append(c"-lgcc_eh");
-            try ctx.args.append(c"-lc");
-            try ctx.args.append(c"-lm");
-            try ctx.args.append(c"--end-group");
+            try ctx.args.append("--start-group");
+            try ctx.args.append("-lgcc");
+            try ctx.args.append("-lgcc_eh");
+            try ctx.args.append("-lc");
+            try ctx.args.append("-lm");
+            try ctx.args.append("--end-group");
         } else {
-            try ctx.args.append(c"-lgcc");
-            try ctx.args.append(c"--as-needed");
-            try ctx.args.append(c"-lgcc_s");
-            try ctx.args.append(c"--no-as-needed");
-            try ctx.args.append(c"-lc");
-            try ctx.args.append(c"-lm");
-            try ctx.args.append(c"-lgcc");
-            try ctx.args.append(c"--as-needed");
-            try ctx.args.append(c"-lgcc_s");
-            try ctx.args.append(c"--no-as-needed");
+            try ctx.args.append("-lgcc");
+            try ctx.args.append("--as-needed");
+            try ctx.args.append("-lgcc_s");
+            try ctx.args.append("--no-as-needed");
+            try ctx.args.append("-lc");
+            try ctx.args.append("-lm");
+            try ctx.args.append("-lgcc");
+            try ctx.args.append("--as-needed");
+            try ctx.args.append("-lgcc_s");
+            try ctx.args.append("--no-as-needed");
         }
     }
 
@@ -299,14 +299,14 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
     }
 
     if (ctx.comp.target != Target.Native) {
-        try ctx.args.append(c"--allow-shlib-undefined");
+        try ctx.args.append("--allow-shlib-undefined");
     }
 
     if (ctx.comp.target.getOs() == .zen) {
-        try ctx.args.append(c"-e");
-        try ctx.args.append(c"_start");
+        try ctx.args.append("-e");
+        try ctx.args.append("_start");
 
-        try ctx.args.append(c"--image-base=0x10000000");
+        try ctx.args.append("--image-base=0x10000000");
     }
 }
 
@@ -317,23 +317,23 @@ fn addPathJoin(ctx: *Context, dirname: []const u8, basename: []const u8) !void {
 }
 
 fn constructLinkerArgsCoff(ctx: *Context) !void {
-    try ctx.args.append(c"-NOLOGO");
+    try ctx.args.append("-NOLOGO");
 
     if (!ctx.comp.strip) {
-        try ctx.args.append(c"-DEBUG");
+        try ctx.args.append("-DEBUG");
     }
 
     switch (ctx.comp.target.getArch()) {
-        builtin.Arch.i386 => try ctx.args.append(c"-MACHINE:X86"),
-        builtin.Arch.x86_64 => try ctx.args.append(c"-MACHINE:X64"),
-        builtin.Arch.aarch64 => try ctx.args.append(c"-MACHINE:ARM"),
+        builtin.Arch.i386 => try ctx.args.append("-MACHINE:X86"),
+        builtin.Arch.x86_64 => try ctx.args.append("-MACHINE:X64"),
+        builtin.Arch.aarch64 => try ctx.args.append("-MACHINE:ARM"),
         else => return error.UnsupportedLinkArchitecture,
     }
 
     if (ctx.comp.windows_subsystem_windows) {
-        try ctx.args.append(c"/SUBSYSTEM:windows");
+        try ctx.args.append("/SUBSYSTEM:windows");
     } else if (ctx.comp.windows_subsystem_console) {
-        try ctx.args.append(c"/SUBSYSTEM:console");
+        try ctx.args.append("/SUBSYSTEM:console");
     }
 
     const is_library = ctx.comp.kind == Compilation.Kind.Lib;
@@ -367,14 +367,14 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
 
         // Visual C++ 2015 Conformance Changes
         // https://msdn.microsoft.com/en-us/library/bb531344.aspx
-        try ctx.args.append(c"legacy_stdio_definitions.lib");
+        try ctx.args.append("legacy_stdio_definitions.lib");
 
         // msvcrt depends on kernel32
-        try ctx.args.append(c"kernel32.lib");
+        try ctx.args.append("kernel32.lib");
     } else {
-        try ctx.args.append(c"-NODEFAULTLIB");
+        try ctx.args.append("-NODEFAULTLIB");
         if (!is_library) {
-            try ctx.args.append(c"-ENTRY:WinMainCRTStartup");
+            try ctx.args.append("-ENTRY:WinMainCRTStartup");
             // TODO
             //if (g->have_winmain) {
             //    lj->args.append("-ENTRY:WinMain");
@@ -385,7 +385,7 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
     }
 
     if (is_library and !ctx.comp.is_static) {
-        try ctx.args.append(c"-DLL");
+        try ctx.args.append("-DLL");
     }
 
     //for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
@@ -463,18 +463,18 @@ fn constructLinkerArgsCoff(ctx: *Context) !void {
 }
 
 fn constructLinkerArgsMachO(ctx: *Context) !void {
-    try ctx.args.append(c"-demangle");
+    try ctx.args.append("-demangle");
 
     if (ctx.comp.linker_rdynamic) {
-        try ctx.args.append(c"-export_dynamic");
+        try ctx.args.append("-export_dynamic");
     }
 
     const is_lib = ctx.comp.kind == Compilation.Kind.Lib;
     const shared = !ctx.comp.is_static and is_lib;
     if (ctx.comp.is_static) {
-        try ctx.args.append(c"-static");
+        try ctx.args.append("-static");
     } else {
-        try ctx.args.append(c"-dynamic");
+        try ctx.args.append("-dynamic");
     }
 
     //if (is_lib) {
@@ -503,7 +503,7 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
     //    }
     //}
 
-    try ctx.args.append(c"-arch");
+    try ctx.args.append("-arch");
     const darwin_arch_str = try std.cstr.addNullByte(
         &ctx.arena.allocator,
         ctx.comp.target.getDarwinArchString(),
@@ -512,22 +512,22 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
 
     const platform = try DarwinPlatform.get(ctx.comp);
     switch (platform.kind) {
-        DarwinPlatform.Kind.MacOS => try ctx.args.append(c"-macosx_version_min"),
-        DarwinPlatform.Kind.IPhoneOS => try ctx.args.append(c"-iphoneos_version_min"),
-        DarwinPlatform.Kind.IPhoneOSSimulator => try ctx.args.append(c"-ios_simulator_version_min"),
+        DarwinPlatform.Kind.MacOS => try ctx.args.append("-macosx_version_min"),
+        DarwinPlatform.Kind.IPhoneOS => try ctx.args.append("-iphoneos_version_min"),
+        DarwinPlatform.Kind.IPhoneOSSimulator => try ctx.args.append("-ios_simulator_version_min"),
     }
     const ver_str = try std.fmt.allocPrint(&ctx.arena.allocator, "{}.{}.{}\x00", platform.major, platform.minor, platform.micro);
     try ctx.args.append(ver_str.ptr);
 
     if (ctx.comp.kind == Compilation.Kind.Exe) {
         if (ctx.comp.is_static) {
-            try ctx.args.append(c"-no_pie");
+            try ctx.args.append("-no_pie");
         } else {
-            try ctx.args.append(c"-pie");
+            try ctx.args.append("-pie");
         }
     }
 
-    try ctx.args.append(c"-o");
+    try ctx.args.append("-o");
     try ctx.args.append(ctx.out_file_path.ptr());
 
     //for (size_t i = 0; i < g->rpath_list.length; i += 1) {
@@ -537,27 +537,27 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
     //add_rpath(lj, &lj->out_file);
 
     if (shared) {
-        try ctx.args.append(c"-headerpad_max_install_names");
+        try ctx.args.append("-headerpad_max_install_names");
     } else if (ctx.comp.is_static) {
-        try ctx.args.append(c"-lcrt0.o");
+        try ctx.args.append("-lcrt0.o");
     } else {
         switch (platform.kind) {
             DarwinPlatform.Kind.MacOS => {
                 if (platform.versionLessThan(10, 5)) {
-                    try ctx.args.append(c"-lcrt1.o");
+                    try ctx.args.append("-lcrt1.o");
                 } else if (platform.versionLessThan(10, 6)) {
-                    try ctx.args.append(c"-lcrt1.10.5.o");
+                    try ctx.args.append("-lcrt1.10.5.o");
                 } else if (platform.versionLessThan(10, 8)) {
-                    try ctx.args.append(c"-lcrt1.10.6.o");
+                    try ctx.args.append("-lcrt1.10.6.o");
                 }
             },
             DarwinPlatform.Kind.IPhoneOS => {
                 if (ctx.comp.target.getArch() == builtin.Arch.aarch64) {
                     // iOS does not need any crt1 files for arm64
                 } else if (platform.versionLessThan(3, 1)) {
-                    try ctx.args.append(c"-lcrt1.o");
+                    try ctx.args.append("-lcrt1.o");
                 } else if (platform.versionLessThan(6, 0)) {
-                    try ctx.args.append(c"-lcrt1.3.1.o");
+                    try ctx.args.append("-lcrt1.3.1.o");
                 }
             },
             DarwinPlatform.Kind.IPhoneOSSimulator => {}, // no crt1.o needed
@@ -589,7 +589,7 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
                 // to make syscalls because the syscall numbers are not documented
                 // and change between versions.
                 // so we always link against libSystem
-                try ctx.args.append(c"-lSystem");
+                try ctx.args.append("-lSystem");
             } else {
                 if (mem.indexOfScalar(u8, lib.name, '/') == null) {
                     const arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-l{}\x00", lib.name);
@@ -601,15 +601,15 @@ fn constructLinkerArgsMachO(ctx: *Context) !void {
             }
         }
     } else {
-        try ctx.args.append(c"-undefined");
-        try ctx.args.append(c"dynamic_lookup");
+        try ctx.args.append("-undefined");
+        try ctx.args.append("dynamic_lookup");
     }
 
     if (platform.kind == DarwinPlatform.Kind.MacOS) {
         if (platform.versionLessThan(10, 5)) {
-            try ctx.args.append(c"-lgcc_s.10.4");
+            try ctx.args.append("-lgcc_s.10.4");
         } else if (platform.versionLessThan(10, 6)) {
-            try ctx.args.append(c"-lgcc_s.10.5");
+            try ctx.args.append("-lgcc_s.10.5");
         }
     } else {
         @panic("TODO");
diff --git a/src-self-hosted/stage1.zig b/src-self-hosted/stage1.zig
index 37945bf029..49ad23a19d 100644
--- a/src-self-hosted/stage1.zig
+++ b/src-self-hosted/stage1.zig
@@ -28,7 +28,7 @@ comptime {
 // ABI warning
 export fn stage2_zen(ptr: *[*]const u8, len: *usize) void {
     const info_zen = @import("main.zig").info_zen;
-    ptr.* = &info_zen;
+    ptr.* = info_zen;
     len.* = info_zen.len;
 }
 
diff --git a/src-self-hosted/value.zig b/src-self-hosted/value.zig
index 6908307c56..63aefbe717 100644
--- a/src-self-hosted/value.zig
+++ b/src-self-hosted/value.zig
@@ -474,7 +474,7 @@ pub const Value = struct {
                         dont_null_terminate,
                     ) orelse return error.OutOfMemory;
                     const str_init_type = llvm.TypeOf(llvm_str_init);
-                    const global = llvm.AddGlobal(ofile.module, str_init_type, c"") orelse return error.OutOfMemory;
+                    const global = llvm.AddGlobal(ofile.module, str_init_type, "") orelse return error.OutOfMemory;
                     llvm.SetInitializer(global, llvm_str_init);
                     llvm.SetLinkage(global, llvm.PrivateLinkage);
                     llvm.SetGlobalConstant(global, 1);
diff --git a/src/all_types.hpp b/src/all_types.hpp
index 0fe43eaa3e..4047a7d4a5 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -102,6 +102,10 @@ struct IrExecutable {
     bool is_inline;
     bool is_generic_instantiation;
     bool need_err_code_spill;
+
+    // This is a function for use in the debugger to print
+    // the source location.
+    void src();
 };
 
 enum OutType {
@@ -237,9 +241,6 @@ struct ConstPtrValue {
         struct {
             ConstExprValue *array_val;
             size_t elem_index;
-            // This helps us preserve the null byte when performing compile-time
-            // concatenation on C strings.
-            bool is_cstr;
         } base_array;
         struct {
             ConstExprValue *struct_val;
@@ -1001,7 +1002,6 @@ struct AstNodeStructField {
 
 struct AstNodeStringLiteral {
     Buf *buf;
-    bool c;
 };
 
 struct AstNodeCharLiteral {
@@ -1956,6 +1956,7 @@ struct CodeGen {
     HashMap<Buf *, Tld *, buf_hash, buf_eql_buf> external_prototypes;
     HashMap<Buf *, ConstExprValue *, buf_hash, buf_eql_buf> string_literals_table;
     HashMap<const ZigType *, ConstExprValue *, type_ptr_hash, type_ptr_eql> type_info_cache;
+    HashMap<const ZigType *, ConstExprValue *, type_ptr_hash, type_ptr_eql> one_possible_values;
 
     ZigList<Tld *> resolve_queue;
     size_t resolve_queue_index;
diff --git a/src/analyze.cpp b/src/analyze.cpp
index f67c4a035e..9c42177d11 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -767,10 +767,18 @@ ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, bo
 
     ZigType *entry = new_type_table_entry(ZigTypeIdArray);
 
+    const char *null_str = is_null_terminated ? "null " : "";
+
     buf_resize(&entry->name, 0);
-    buf_appendf(&entry->name, "[%" ZIG_PRI_u64 "]%s", array_size, buf_ptr(&child_type->name));
+    buf_appendf(&entry->name, "[%" ZIG_PRI_u64 "]%s%s", array_size, null_str, buf_ptr(&child_type->name));
+
+    size_t full_array_size;
+    if (array_size == 0) {
+        full_array_size = 0;
+    } else {
+        full_array_size = array_size + (is_null_terminated ? 1 : 0);
+    }
 
-    size_t full_array_size = array_size + (is_null_terminated ? 1 : 0);
     entry->size_in_bits = child_type->size_in_bits * full_array_size;
     entry->abi_align = child_type->abi_align;
     entry->abi_size = child_type->abi_size * full_array_size;
@@ -5046,7 +5054,6 @@ static uint32_t hash_const_val_ptr(ConstExprValue *const_val) {
             hash_val += (uint32_t)1764906839;
             hash_val += hash_ptr(const_val->data.x_ptr.data.base_array.array_val);
             hash_val += hash_size(const_val->data.x_ptr.data.base_array.elem_index);
-            hash_val += const_val->data.x_ptr.data.base_array.is_cstr ? 1297263887 : 200363492;
             return hash_val;
         case ConstPtrSpecialBaseStruct:
             hash_val += (uint32_t)3518317043;
@@ -5550,6 +5557,18 @@ OnePossibleValue type_has_one_possible_value(CodeGen *g, ZigType *type_entry) {
     zig_unreachable();
 }
 
+ConstExprValue *get_the_one_possible_value(CodeGen *g, ZigType *type_entry) {
+    auto entry = g->one_possible_values.maybe_get(type_entry);
+    if (entry != nullptr) {
+        return entry->value;
+    }
+    ConstExprValue *result = create_const_vals(1);
+    result->type = type_entry;
+    result->special = ConstValSpecialStatic;
+    g->one_possible_values.put(type_entry, result);
+    return result;
+}
+
 ReqCompTime type_requires_comptime(CodeGen *g, ZigType *ty) {
     Error err;
     switch (ty->id) {
@@ -5617,52 +5636,26 @@ void init_const_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *str) {
         return;
     }
 
-    const_val->special = ConstValSpecialStatic;
-    const_val->type = get_array_type(g, g->builtin_types.entry_u8, buf_len(str), false);
-    const_val->data.x_array.special = ConstArraySpecialBuf;
-    const_val->data.x_array.data.s_buf = str;
-
-    g->string_literals_table.put(str, const_val);
-}
-
-ConstExprValue *create_const_str_lit(CodeGen *g, Buf *str) {
-    ConstExprValue *const_val = create_const_vals(1);
-    init_const_str_lit(g, const_val, str);
-    return const_val;
-}
-
-void init_const_c_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *str) {
     // first we build the underlying array
-    size_t len_with_null = buf_len(str) + 1;
     ConstExprValue *array_val = create_const_vals(1);
     array_val->special = ConstValSpecialStatic;
-    array_val->type = get_array_type(g, g->builtin_types.entry_u8, len_with_null, false);
-    // TODO buf optimization
-    array_val->data.x_array.data.s_none.elements = create_const_vals(len_with_null);
-    for (size_t i = 0; i < buf_len(str); i += 1) {
-        ConstExprValue *this_char = &array_val->data.x_array.data.s_none.elements[i];
-        this_char->special = ConstValSpecialStatic;
-        this_char->type = g->builtin_types.entry_u8;
-        bigint_init_unsigned(&this_char->data.x_bigint, (uint8_t)buf_ptr(str)[i]);
-    }
-    ConstExprValue *null_char = &array_val->data.x_array.data.s_none.elements[len_with_null - 1];
-    null_char->special = ConstValSpecialStatic;
-    null_char->type = g->builtin_types.entry_u8;
-    bigint_init_unsigned(&null_char->data.x_bigint, 0);
+    array_val->type = get_array_type(g, g->builtin_types.entry_u8, buf_len(str), true);
+    array_val->data.x_array.special = ConstArraySpecialBuf;
+    array_val->data.x_array.data.s_buf = str;
 
     // then make the pointer point to it
     const_val->special = ConstValSpecialStatic;
-    // TODO make this `[*]null u8` instead of `[*]u8`
-    const_val->type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
-            PtrLenUnknown, 0, 0, 0, false);
-    const_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
-    const_val->data.x_ptr.data.base_array.array_val = array_val;
-    const_val->data.x_ptr.data.base_array.elem_index = 0;
-    const_val->data.x_ptr.data.base_array.is_cstr = true;
+    const_val->type = get_pointer_to_type_extra2(g, array_val->type, true, false,
+            PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, nullptr);
+    const_val->data.x_ptr.special = ConstPtrSpecialRef;
+    const_val->data.x_ptr.data.ref.pointee = array_val;
+
+    g->string_literals_table.put(str, const_val);
 }
-ConstExprValue *create_const_c_str_lit(CodeGen *g, Buf *str) {
+
+ConstExprValue *create_const_str_lit(CodeGen *g, Buf *str) {
     ConstExprValue *const_val = create_const_vals(1);
-    init_const_c_str_lit(g, const_val, str);
+    init_const_str_lit(g, const_val, str);
     return const_val;
 }
 
@@ -5712,6 +5705,18 @@ ConstExprValue *create_const_signed(ZigType *type, int64_t x) {
     return const_val;
 }
 
+void init_const_null(ConstExprValue *const_val, ZigType *type) {
+    const_val->special = ConstValSpecialStatic;
+    const_val->type = type;
+    const_val->data.x_optional = nullptr;
+}
+
+ConstExprValue *create_const_null(ZigType *type) {
+    ConstExprValue *const_val = create_const_vals(1);
+    init_const_null(const_val, type);
+    return const_val;
+}
+
 void init_const_float(ConstExprValue *const_val, ZigType *type, double value) {
     const_val->special = ConstValSpecialStatic;
     const_val->type = type;
@@ -6446,8 +6451,6 @@ bool ir_get_var_is_comptime(ZigVar *var) {
 bool const_values_equal_ptr(ConstExprValue *a, ConstExprValue *b) {
     if (a->data.x_ptr.special != b->data.x_ptr.special)
         return false;
-    if (a->data.x_ptr.mut != b->data.x_ptr.mut)
-        return false;
     switch (a->data.x_ptr.special) {
         case ConstPtrSpecialInvalid:
             zig_unreachable();
@@ -6464,8 +6467,6 @@ bool const_values_equal_ptr(ConstExprValue *a, ConstExprValue *b) {
             }
             if (a->data.x_ptr.data.base_array.elem_index != b->data.x_ptr.data.base_array.elem_index)
                 return false;
-            if (a->data.x_ptr.data.base_array.is_cstr != b->data.x_ptr.data.base_array.is_cstr)
-                return false;
             return true;
         case ConstPtrSpecialBaseStruct:
             if (a->data.x_ptr.data.base_struct.struct_val != b->data.x_ptr.data.base_struct.struct_val &&
@@ -6544,6 +6545,16 @@ bool const_values_equal(CodeGen *g, ConstExprValue *a, ConstExprValue *b) {
     assert(a->type->id == b->type->id);
     assert(a->special == ConstValSpecialStatic);
     assert(b->special == ConstValSpecialStatic);
+    if (a->type == b->type) {
+        switch (type_has_one_possible_value(g, a->type)) {
+            case OnePossibleValueInvalid:
+                zig_unreachable();
+            case OnePossibleValueNo:
+                break;
+            case OnePossibleValueYes:
+                return true;
+        }
+    }
     switch (a->type->id) {
         case ZigTypeIdOpaque:
             zig_unreachable();
@@ -6709,15 +6720,10 @@ static void render_const_val_ptr(CodeGen *g, Buf *buf, ConstExprValue *const_val
             render_const_value(g, buf, const_ptr_pointee(nullptr, g, const_val, nullptr));
             return;
         case ConstPtrSpecialBaseArray:
-            if (const_val->data.x_ptr.data.base_array.is_cstr) {
-                buf_appendf(buf, "*(c str lit)");
-                return;
-            } else {
-                buf_appendf(buf, "*");
-                // TODO we need a source node for const_ptr_pointee because it can generate compile errors
-                render_const_value(g, buf, const_ptr_pointee(nullptr, g, const_val, nullptr));
-                return;
-            }
+            buf_appendf(buf, "*");
+            // TODO we need a source node for const_ptr_pointee because it can generate compile errors
+            render_const_value(g, buf, const_ptr_pointee(nullptr, g, const_val, nullptr));
+            return;
         case ConstPtrSpecialHardCodedAddr:
             buf_appendf(buf, "(%s)(%" ZIG_PRI_x64 ")", buf_ptr(&type_entry->name),
                     const_val->data.x_ptr.data.hard_coded_addr.addr);
@@ -8653,14 +8659,16 @@ static void resolve_llvm_types_array(CodeGen *g, ZigType *type) {
 
     ZigType *elem_type = type->data.array.child_type;
 
+    uint64_t extra_len_from_null = type->data.array.is_null_terminated ? 1 : 0;
+    uint64_t full_len = type->data.array.len + extra_len_from_null;
     // TODO https://github.com/ziglang/zig/issues/1424
-    type->llvm_type = LLVMArrayType(get_llvm_type(g, elem_type), (unsigned)type->data.array.len);
+    type->llvm_type = LLVMArrayType(get_llvm_type(g, elem_type), (unsigned)full_len);
 
     uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, type->llvm_type);
     uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, type->llvm_type);
 
     type->llvm_di_type = ZigLLVMCreateDebugArrayType(g->dbuilder, debug_size_in_bits,
-            debug_align_in_bits, get_llvm_di_type(g, elem_type), (int)type->data.array.len);
+            debug_align_in_bits, get_llvm_di_type(g, elem_type), (int)full_len);
 }
 
 static void resolve_llvm_types_fn_type(CodeGen *g, ZigType *fn_type) {
@@ -9150,3 +9158,24 @@ Error analyze_import(CodeGen *g, ZigType *source_import, Buf *import_target_str,
     *out_import = add_source_file(g, target_package, resolved_path, import_code, source_kind);
     return ErrorNone;
 }
+
+
+void IrExecutable::src() {
+    IrExecutable *it;
+    for (it = this; it != nullptr && it->source_node != nullptr; it = it->parent_exec) {
+        it->source_node->src();
+    }
+}
+
+ConstExprValue *get_null_value(ZigType *ty) {
+    if (ty->id == ZigTypeIdInt || ty->id == ZigTypeIdComptimeInt) {
+        return create_const_unsigned_negative(ty, 0, false);
+    } else if (ty->id == ZigTypeIdFloat || ty->id == ZigTypeIdComptimeFloat) {
+        return create_const_float(ty, NAN);
+    } else if (ty->id == ZigTypeIdOptional) {
+        return create_const_null(ty);
+    } else {
+        zig_unreachable();
+    }
+}
+
diff --git a/src/analyze.hpp b/src/analyze.hpp
index a1e38a43d7..a3d4621178 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -126,9 +126,6 @@ ScopeExpr *create_expr_scope(CodeGen *g, AstNode *node, Scope *parent);
 void init_const_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *str);
 ConstExprValue *create_const_str_lit(CodeGen *g, Buf *str);
 
-void init_const_c_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *c_str);
-ConstExprValue *create_const_c_str_lit(CodeGen *g, Buf *c_str);
-
 void init_const_bigint(ConstExprValue *const_val, ZigType *type, const BigInt *bigint);
 ConstExprValue *create_const_bigint(ZigType *type, const BigInt *bigint);
 
@@ -176,6 +173,9 @@ ConstExprValue *create_const_slice(CodeGen *g, ConstExprValue *array_val, size_t
 void init_const_arg_tuple(CodeGen *g, ConstExprValue *const_val, size_t arg_index_start, size_t arg_index_end);
 ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_t arg_index_end);
 
+void init_const_null(ConstExprValue *const_val, ZigType *type);
+ConstExprValue *create_const_null(ZigType *type);
+
 ConstExprValue *create_const_vals(size_t count);
 ConstExprValue **alloc_const_vals_ptrs(size_t count);
 ConstExprValue **realloc_const_vals_ptrs(ConstExprValue **ptr, size_t old_count, size_t new_count);
@@ -275,5 +275,6 @@ IrInstruction *ir_create_alloca(CodeGen *g, Scope *scope, AstNode *source_node,
         ZigType *var_type, const char *name_hint);
 Error analyze_import(CodeGen *codegen, ZigType *source_import, Buf *import_target_str,
         ZigType **out_import, Buf **out_import_target_path, Buf *out_full_path);
-
+ConstExprValue *get_the_one_possible_value(CodeGen *g, ZigType *type_entry);
+ConstExprValue *get_null_value(ZigType *ty);
 #endif
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index 34cbed245a..53388fa033 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -619,9 +619,6 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
             break;
         case NodeTypeStringLiteral:
             {
-                if (node->data.string_literal.c) {
-                    fprintf(ar->f, "c");
-                }
                 Buf tmp_buf = BUF_INIT;
                 string_literal_escape(node->data.string_literal.buf, &tmp_buf);
                 fprintf(ar->f, "\"%s\"", buf_ptr(&tmp_buf));
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 5def04575e..4fc3b968c1 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -949,7 +949,7 @@ static LLVMValueRef get_panic_msg_ptr_val(CodeGen *g, PanicMsgId msg_id) {
     if (!val->global_refs->llvm_global) {
 
         Buf *buf_msg = panic_msg_buf(msg_id);
-        ConstExprValue *array_val = create_const_str_lit(g, buf_msg);
+        ConstExprValue *array_val = create_const_str_lit(g, buf_msg)->data.x_ptr.data.ref.pointee;
         init_const_slice(g, val, array_val, 0, buf_len(buf_msg), true);
 
         render_const_val(g, val, "");
@@ -2784,14 +2784,6 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutable *executable,
     IrInstruction *op1 = bin_op_instruction->op1;
     IrInstruction *op2 = bin_op_instruction->op2;
 
-    assert(op1->value.type == op2->value.type || op_id == IrBinOpBitShiftLeftLossy ||
-        op_id == IrBinOpBitShiftLeftExact || op_id == IrBinOpBitShiftRightLossy ||
-        op_id == IrBinOpBitShiftRightExact ||
-        (op1->value.type->id == ZigTypeIdErrorSet && op2->value.type->id == ZigTypeIdErrorSet) ||
-        (op1->value.type->id == ZigTypeIdPointer &&
-            (op_id == IrBinOpAdd || op_id == IrBinOpSub) &&
-            op1->value.type->data.pointer.ptr_len != PtrLenSingle)
-    );
     ZigType *operand_type = op1->value.type;
     ZigType *scalar_type = (operand_type->id == ZigTypeIdVector) ? operand_type->data.vector.elem_type : operand_type;
 
@@ -2848,7 +2840,6 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutable *executable,
                 AddSubMulMul;
 
             if (scalar_type->id == ZigTypeIdPointer) {
-                assert(scalar_type->data.pointer.ptr_len != PtrLenSingle);
                 LLVMValueRef subscript_value;
                 if (operand_type->id == ZigTypeIdVector)
                     zig_panic("TODO: Implement vector operations on pointers.");
@@ -3077,7 +3068,14 @@ static LLVMValueRef ir_render_cast(CodeGen *g, IrExecutable *executable,
         case CastOpNumLitToConcrete:
             zig_unreachable();
         case CastOpNoop:
-            return expr_val;
+            if (actual_type->id == ZigTypeIdPointer && wanted_type->id == ZigTypeIdPointer &&
+                actual_type->data.pointer.child_type->id == ZigTypeIdArray &&
+                wanted_type->data.pointer.child_type->id == ZigTypeIdArray)
+            {
+                return LLVMBuildBitCast(g->builder, expr_val, get_llvm_type(g, wanted_type), "");
+            } else {
+                return expr_val;
+            }
         case CastOpIntToFloat:
             assert(actual_type->id == ZigTypeIdInt);
             if (actual_type->data.integral.is_signed) {
@@ -3709,8 +3707,9 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutable *executable, IrI
             array_type = array_type->data.pointer.child_type;
         }
         if (safety_check_on) {
-            LLVMValueRef end = LLVMConstInt(g->builtin_types.entry_usize->llvm_type,
-                    array_type->data.array.len, false);
+            uint64_t extra_len_from_null = array_type->data.array.is_null_terminated ? 1 : 0;
+            uint64_t full_len = array_type->data.array.len + extra_len_from_null;
+            LLVMValueRef end = LLVMConstInt(g->builtin_types.entry_usize->llvm_type, full_len, false);
             add_bounds_check(g, subscript_value, LLVMIntEQ, nullptr, LLVMIntULT, end);
         }
         if (array_ptr_type->data.pointer.host_int_bytes != 0) {
@@ -6637,11 +6636,20 @@ static LLVMValueRef gen_const_val_ptr(CodeGen *g, ConstExprValue *const_val, con
                 ConstExprValue *array_const_val = const_val->data.x_ptr.data.base_array.array_val;
                 assert(array_const_val->type->id == ZigTypeIdArray);
                 if (!type_has_bits(array_const_val->type)) {
-                    // make this a null pointer
-                    ZigType *usize = g->builtin_types.entry_usize;
-                    const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->llvm_type),
-                            get_llvm_type(g, const_val->type));
-                    return const_val->global_refs->llvm_value;
+                    if (array_const_val->type->data.array.is_null_terminated) {
+                        ConstExprValue *pointee = get_null_value(array_const_val->type->data.array.child_type);
+                        render_const_val(g, pointee, "");
+                        render_const_val_global(g, pointee, "");
+                        const_val->global_refs->llvm_value = LLVMConstBitCast(pointee->global_refs->llvm_global,
+                                get_llvm_type(g, const_val->type));
+                        return const_val->global_refs->llvm_value;
+                    } else {
+                        // make this a null pointer
+                        ZigType *usize = g->builtin_types.entry_usize;
+                        const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->llvm_type),
+                                get_llvm_type(g, const_val->type));
+                        return const_val->global_refs->llvm_value;
+                    }
                 }
                 size_t elem_index = const_val->data.x_ptr.data.base_array.elem_index;
                 LLVMValueRef uncasted_ptr_val = gen_const_ptr_array_recursive(g, array_const_val, elem_index);
@@ -6955,7 +6963,9 @@ check: switch (const_val->special) {
                     case ConstArraySpecialUndef:
                         return LLVMGetUndef(get_llvm_type(g, type_entry));
                     case ConstArraySpecialNone: {
-                        LLVMValueRef *values = allocate<LLVMValueRef>(len);
+                        uint64_t extra_len_from_null = type_entry->data.array.is_null_terminated ? 1 : 0;
+                        uint64_t full_len = len + extra_len_from_null;
+                        LLVMValueRef *values = allocate<LLVMValueRef>(full_len);
                         LLVMTypeRef element_type_ref = get_llvm_type(g, type_entry->data.array.child_type);
                         bool make_unnamed_struct = false;
                         for (uint64_t i = 0; i < len; i += 1) {
@@ -6964,15 +6974,19 @@ check: switch (const_val->special) {
                             values[i] = val;
                             make_unnamed_struct = make_unnamed_struct || is_llvm_value_unnamed_type(g, elem_value->type, val);
                         }
+                        if (type_entry->data.array.is_null_terminated) {
+                            values[len] = LLVMConstNull(element_type_ref);
+                        }
                         if (make_unnamed_struct) {
-                            return LLVMConstStruct(values, len, true);
+                            return LLVMConstStruct(values, full_len, true);
                         } else {
-                            return LLVMConstArray(element_type_ref, values, (unsigned)len);
+                            return LLVMConstArray(element_type_ref, values, (unsigned)full_len);
                         }
                     }
                     case ConstArraySpecialBuf: {
                         Buf *buf = const_val->data.x_array.data.s_buf;
-                        return LLVMConstString(buf_ptr(buf), (unsigned)buf_len(buf), true);
+                        return LLVMConstString(buf_ptr(buf), (unsigned)buf_len(buf),
+                                !type_entry->data.array.is_null_terminated);
                     }
                 }
                 zig_unreachable();
@@ -9092,7 +9106,7 @@ static void create_test_compile_var_and_add_test_runner(CodeGen *g) {
         this_val->data.x_struct.fields = alloc_const_vals_ptrs(2);
 
         ConstExprValue *name_field = this_val->data.x_struct.fields[0];
-        ConstExprValue *name_array_val = create_const_str_lit(g, &test_fn_entry->symbol_name);
+        ConstExprValue *name_array_val = create_const_str_lit(g, &test_fn_entry->symbol_name)->data.x_ptr.data.ref.pointee;
         init_const_slice(g, name_field, name_array_val, 0, buf_len(&test_fn_entry->symbol_name), true);
 
         ConstExprValue *fn_field = this_val->data.x_struct.fields[1];
@@ -10415,6 +10429,7 @@ CodeGen *codegen_create(Buf *main_pkg_path, Buf *root_src_path, const ZigTarget
     g->external_prototypes.init(8);
     g->string_literals_table.init(16);
     g->type_info_cache.init(32);
+    g->one_possible_values.init(32);
     g->is_test_build = is_test_build;
     g->is_single_threaded = false;
     buf_resize(&g->global_asm, 0);
diff --git a/src/ir.cpp b/src/ir.cpp
index c910d4800d..4a3d89c0c1 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -66,6 +66,8 @@ enum ConstCastResultId {
     ConstCastResultIdUnresolvedInferredErrSet,
     ConstCastResultIdAsyncAllocatorType,
     ConstCastResultIdBadAllowsZero,
+    ConstCastResultIdArrayChild,
+    ConstCastResultIdBadNullTermArrays,
 };
 
 struct ConstCastOnly;
@@ -87,7 +89,9 @@ struct ConstCastErrUnionErrSetMismatch;
 struct ConstCastErrUnionPayloadMismatch;
 struct ConstCastErrSetMismatch;
 struct ConstCastTypeMismatch;
+struct ConstCastArrayMismatch;
 struct ConstCastBadAllowsZero;
+struct ConstCastBadNullTermArrays;
 
 struct ConstCastOnly {
     ConstCastResultId id;
@@ -99,11 +103,13 @@ struct ConstCastOnly {
         ConstCastErrUnionPayloadMismatch *error_union_payload;
         ConstCastErrUnionErrSetMismatch *error_union_error_set;
         ConstCastTypeMismatch *type_mismatch;
+        ConstCastArrayMismatch *array_mismatch;
         ConstCastOnly *return_type;
         ConstCastOnly *null_wrap_ptr_child;
         ConstCastArg fn_arg;
         ConstCastArgNoAlias arg_no_alias;
         ConstCastBadAllowsZero *bad_allows_zero;
+        ConstCastBadNullTermArrays *bad_null_term_arrays;
     } data;
 };
 
@@ -130,6 +136,12 @@ struct ConstCastSliceMismatch {
     ZigType *actual_child;
 };
 
+struct ConstCastArrayMismatch {
+    ConstCastOnly child;
+    ZigType *wanted_child;
+    ZigType *actual_child;
+};
+
 struct ConstCastErrUnionErrSetMismatch {
     ConstCastOnly child;
     ZigType *wanted_err_set;
@@ -151,6 +163,12 @@ struct ConstCastBadAllowsZero {
     ZigType *actual_type;
 };
 
+struct ConstCastBadNullTermArrays {
+    ConstCastOnly child;
+    ZigType *wanted_type;
+    ZigType *actual_type;
+};
+
 
 static IrInstruction *ir_gen_node(IrBuilder *irb, AstNode *node, Scope *scope);
 static IrInstruction *ir_gen_node_extra(IrBuilder *irb, AstNode *node, Scope *scope, LVal lval,
@@ -217,10 +235,7 @@ static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *c
         case OnePossibleValueInvalid:
             zig_unreachable();
         case OnePossibleValueYes:
-            result = create_const_vals(1);
-            result->type = const_val->type->data.pointer.child_type;
-            result->special = ConstValSpecialStatic;
-            return result;
+            return get_the_one_possible_value(g, const_val->type->data.pointer.child_type);
         case OnePossibleValueNo:
             break;
     }
@@ -233,8 +248,13 @@ static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *c
             break;
         case ConstPtrSpecialBaseArray: {
             ConstExprValue *array_val = const_val->data.x_ptr.data.base_array.array_val;
-            expand_undef_array(g, array_val);
-            result = &array_val->data.x_array.data.s_none.elements[const_val->data.x_ptr.data.base_array.elem_index];
+            if (const_val->data.x_ptr.data.base_array.elem_index == array_val->type->data.array.len) {
+                assert(array_val->type->data.array.is_null_terminated);
+                result = get_null_value(array_val->type->data.array.child_type);
+            } else {
+                expand_undef_array(g, array_val);
+                result = &array_val->data.x_array.data.s_none.elements[const_val->data.x_ptr.data.base_array.elem_index];
+            }
             break;
         }
         case ConstPtrSpecialBaseStruct: {
@@ -282,20 +302,20 @@ static bool slice_is_const(ZigType *type) {
 
 // This function returns true when you can change the type of a ConstExprValue and the
 // value remains meaningful.
-static bool types_have_same_zig_comptime_repr(ZigType *a, ZigType *b) {
-    if (a == b)
+static bool types_have_same_zig_comptime_repr(ZigType *expected, ZigType *actual) {
+    if (expected == actual)
         return true;
 
-    if (get_codegen_ptr_type(a) != nullptr && get_codegen_ptr_type(b) != nullptr)
+    if (get_codegen_ptr_type(expected) != nullptr && get_codegen_ptr_type(actual) != nullptr)
         return true;
 
-    if (is_opt_err_set(a) && is_opt_err_set(b))
+    if (is_opt_err_set(expected) && is_opt_err_set(actual))
         return true;
 
-    if (a->id != b->id)
+    if (expected->id != actual->id)
         return false;
 
-    switch (a->id) {
+    switch (expected->id) {
         case ZigTypeIdInvalid:
         case ZigTypeIdUnreachable:
             zig_unreachable();
@@ -314,12 +334,11 @@ static bool types_have_same_zig_comptime_repr(ZigType *a, ZigType *b) {
         case ZigTypeIdAnyFrame:
             return true;
         case ZigTypeIdFloat:
-            return a->data.floating.bit_count == b->data.floating.bit_count;
+            return expected->data.floating.bit_count == actual->data.floating.bit_count;
         case ZigTypeIdInt:
-            return a->data.integral.is_signed == b->data.integral.is_signed;
+            return expected->data.integral.is_signed == actual->data.integral.is_signed;
         case ZigTypeIdStruct:
-            return is_slice(a) && is_slice(b);
-        case ZigTypeIdArray:
+            return is_slice(expected) && is_slice(actual);
         case ZigTypeIdOptional:
         case ZigTypeIdErrorUnion:
         case ZigTypeIdEnum:
@@ -329,6 +348,10 @@ static bool types_have_same_zig_comptime_repr(ZigType *a, ZigType *b) {
         case ZigTypeIdVector:
         case ZigTypeIdFnFrame:
             return false;
+        case ZigTypeIdArray:
+            return expected->data.array.len == actual->data.array.len &&
+                expected->data.array.child_type == actual->data.array.child_type &&
+                (!expected->data.array.is_null_terminated || actual->data.array.is_null_terminated);
     }
     zig_unreachable();
 }
@@ -1299,12 +1322,6 @@ static IrInstruction *ir_build_const_str_lit(IrBuilder *irb, Scope *scope, AstNo
     return instruction;
 }
 
-static IrInstruction *ir_build_const_c_str_lit(IrBuilder *irb, Scope *scope, AstNode *source_node, Buf *str) {
-    IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
-    init_const_c_str_lit(irb->codegen, &const_instruction->base.value, str);
-    return &const_instruction->base;
-}
-
 static IrInstruction *ir_build_bin_op(IrBuilder *irb, Scope *scope, AstNode *source_node, IrBinOp op_id,
         IrInstruction *op1, IrInstruction *op2, bool safety_check_on)
 {
@@ -6932,11 +6949,7 @@ static IrInstruction *ir_gen_enum_literal(IrBuilder *irb, Scope *scope, AstNode
 static IrInstruction *ir_gen_string_literal(IrBuilder *irb, Scope *scope, AstNode *node) {
     assert(node->type == NodeTypeStringLiteral);
 
-    if (node->data.string_literal.c) {
-        return ir_build_const_c_str_lit(irb, scope, node, node->data.string_literal.buf);
-    } else {
-        return ir_build_const_str_lit(irb, scope, node, node->data.string_literal.buf);
-    }
+    return ir_build_const_str_lit(irb, scope, node, node->data.string_literal.buf);
 }
 
 static IrInstruction *ir_gen_array_type(IrBuilder *irb, Scope *scope, AstNode *node) {
@@ -8662,7 +8675,15 @@ ConstExprValue *const_ptr_pointee(IrAnalyze *ira, CodeGen *codegen, ConstExprVal
     assert(val != nullptr);
     assert(const_val->type->id == ZigTypeIdPointer);
     ZigType *expected_type = const_val->type->data.pointer.child_type;
-    if (!types_have_same_zig_comptime_repr(val->type, expected_type)) {
+    switch (type_has_one_possible_value(codegen, expected_type)) {
+        case OnePossibleValueInvalid:
+            return nullptr;
+        case OnePossibleValueNo:
+            break;
+        case OnePossibleValueYes:
+            return get_the_one_possible_value(codegen, expected_type);
+    }
+    if (!types_have_same_zig_comptime_repr(expected_type, val->type)) {
         if ((err = eval_comptime_ptr_reinterpret(ira, codegen, source_node, const_val)))
             return nullptr;
         return const_ptr_pointee_unchecked(codegen, const_val);
@@ -9876,6 +9897,35 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
         }
     }
 
+    // arrays
+    if (wanted_type->id == ZigTypeIdArray && actual_type->id == ZigTypeIdArray &&
+        wanted_type->data.array.len == actual_type->data.array.len)
+    {
+        ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.array.child_type,
+                actual_type->data.array.child_type, source_node, wanted_is_mutable);
+        if (child.id == ConstCastResultIdInvalid)
+            return child;
+        if (child.id != ConstCastResultIdOk) {
+            result.id = ConstCastResultIdArrayChild;
+            result.data.array_mismatch = allocate_nonzero<ConstCastArrayMismatch>(1);
+            result.data.array_mismatch->child = child;
+            result.data.array_mismatch->wanted_child = wanted_type->data.array.child_type;
+            result.data.array_mismatch->actual_child = actual_type->data.array.child_type;
+            return result;
+        }
+        bool ok_null_terminated = !wanted_type->data.array.is_null_terminated ||
+            actual_type->data.array.is_null_terminated;
+        if (!ok_null_terminated) {
+            result.id = ConstCastResultIdBadNullTermArrays;
+            result.data.bad_null_term_arrays = allocate_nonzero<ConstCastBadNullTermArrays>(1);
+            result.data.bad_null_term_arrays->child = child;
+            result.data.bad_null_term_arrays->wanted_type = wanted_type;
+            result.data.bad_null_term_arrays->actual_type = actual_type;
+            return result;
+        }
+        return result;
+    }
+
     // slice const
     if (is_slice(wanted_type) && is_slice(actual_type)) {
         ZigType *actual_ptr_type = actual_type->data.structure.fields[slice_ptr_index]->type_entry;
@@ -10692,6 +10742,42 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
             continue;
         }
 
+
+        // *[N]T and *[M]T
+        if (cur_type->id == ZigTypeIdPointer && cur_type->data.pointer.ptr_len == PtrLenSingle &&
+                cur_type->data.pointer.child_type->id == ZigTypeIdArray &&
+            prev_type->id == ZigTypeIdPointer && prev_type->data.pointer.ptr_len == PtrLenSingle &&
+                prev_type->data.pointer.child_type->id == ZigTypeIdArray &&
+            (cur_type->data.pointer.is_const || !prev_type->data.pointer.is_const ||
+                prev_type->data.pointer.child_type->data.array.len == 0) &&
+            (cur_type->data.pointer.child_type->data.array.is_null_terminated ||
+                !prev_type->data.pointer.child_type->data.array.is_null_terminated) &&
+            types_match_const_cast_only(ira,
+                cur_type->data.pointer.child_type->data.array.child_type,
+                prev_type->data.pointer.child_type->data.array.child_type,
+                source_node, !cur_type->data.pointer.is_const).id == ConstCastResultIdOk)
+        {
+            prev_inst = cur_inst;
+            convert_to_const_slice = true;
+            continue;
+        }
+        if (prev_type->id == ZigTypeIdPointer && prev_type->data.pointer.ptr_len == PtrLenSingle &&
+                prev_type->data.pointer.child_type->id == ZigTypeIdArray &&
+            cur_type->id == ZigTypeIdPointer && cur_type->data.pointer.ptr_len == PtrLenSingle &&
+                cur_type->data.pointer.child_type->id == ZigTypeIdArray &&
+            (prev_type->data.pointer.is_const || !cur_type->data.pointer.is_const ||
+                cur_type->data.pointer.child_type->data.array.len == 0) &&
+            (prev_type->data.pointer.child_type->data.array.is_null_terminated ||
+                !cur_type->data.pointer.child_type->data.array.is_null_terminated) &&
+            types_match_const_cast_only(ira,
+                prev_type->data.pointer.child_type->data.array.child_type,
+                cur_type->data.pointer.child_type->data.array.child_type,
+                source_node, !prev_type->data.pointer.is_const).id == ConstCastResultIdOk)
+        {
+            convert_to_const_slice = true;
+            continue;
+        }
+
         // [N]T to []T
         if (prev_type->id == ZigTypeIdArray && is_slice(cur_type) &&
             (cur_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.is_const ||
@@ -10740,16 +10826,33 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
     free(errors);
 
     if (convert_to_const_slice) {
-        assert(prev_inst->value.type->id == ZigTypeIdArray);
-        ZigType *ptr_type = get_pointer_to_type_extra(
-                ira->codegen, prev_inst->value.type->data.array.child_type,
-                true, false, PtrLenUnknown,
-                0, 0, 0, false);
-        ZigType *slice_type = get_slice_type(ira->codegen, ptr_type);
-        if (err_set_type != nullptr) {
-            return get_error_union_type(ira->codegen, err_set_type, slice_type);
+        if (prev_inst->value.type->id == ZigTypeIdArray) {
+            ZigType *ptr_type = get_pointer_to_type_extra(
+                    ira->codegen, prev_inst->value.type->data.array.child_type,
+                    true, false, PtrLenUnknown,
+                    0, 0, 0, false);
+            ZigType *slice_type = get_slice_type(ira->codegen, ptr_type);
+            if (err_set_type != nullptr) {
+                return get_error_union_type(ira->codegen, err_set_type, slice_type);
+            } else {
+                return slice_type;
+            }
+        } else if (prev_inst->value.type->id == ZigTypeIdPointer) {
+            ZigType *array_type = prev_inst->value.type->data.pointer.child_type;
+            src_assert(array_type->id == ZigTypeIdArray, source_node);
+            ZigType *ptr_type = get_pointer_to_type_extra(
+                    ira->codegen, array_type->data.array.child_type,
+                    prev_inst->value.type->data.pointer.is_const, false,
+                    array_type->data.array.is_null_terminated ? PtrLenNull : PtrLenUnknown,
+                    0, 0, 0, false);
+            ZigType *slice_type = get_slice_type(ira->codegen, ptr_type);
+            if (err_set_type != nullptr) {
+                return get_error_union_type(ira->codegen, err_set_type, slice_type);
+            } else {
+                return slice_type;
+            }
         } else {
-            return slice_type;
+            zig_unreachable();
         }
     } else if (err_set_type != nullptr) {
         if (prev_inst->value.type->id == ZigTypeIdErrorSet) {
@@ -10970,7 +11073,6 @@ static IrInstruction *ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze *ira,
             result->value.data.x_ptr.mut = value->value.data.x_ptr.mut;
             result->value.data.x_ptr.data.base_array.array_val = pointee;
             result->value.data.x_ptr.data.base_array.elem_index = 0;
-            result->value.data.x_ptr.data.base_array.is_cstr = false;
             return result;
         }
     }
@@ -10982,31 +11084,31 @@ static IrInstruction *ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze *ira,
 }
 
 static IrInstruction *ir_resolve_ptr_of_array_to_slice(IrAnalyze *ira, IrInstruction *source_instr,
-        IrInstruction *value, ZigType *wanted_type, ResultLoc *result_loc)
+        IrInstruction *array_ptr, ZigType *wanted_type, ResultLoc *result_loc)
 {
     Error err;
 
-    if ((err = type_resolve(ira->codegen, value->value.type->data.pointer.child_type,
+    if ((err = type_resolve(ira->codegen, array_ptr->value.type->data.pointer.child_type,
                     ResolveStatusAlignmentKnown)))
     {
         return ira->codegen->invalid_instruction;
     }
 
-    wanted_type = adjust_slice_align(ira->codegen, wanted_type, get_ptr_align(ira->codegen, value->value.type));
+    wanted_type = adjust_slice_align(ira->codegen, wanted_type, get_ptr_align(ira->codegen, array_ptr->value.type));
 
-    if (instr_is_comptime(value)) {
-        ConstExprValue *pointee = const_ptr_pointee(ira, ira->codegen, &value->value, source_instr->source_node);
+    if (instr_is_comptime(array_ptr)) {
+        ConstExprValue *pointee = const_ptr_pointee(ira, ira->codegen, &array_ptr->value, source_instr->source_node);
         if (pointee == nullptr)
             return ira->codegen->invalid_instruction;
         if (pointee->special != ConstValSpecialRuntime) {
-            assert(value->value.type->id == ZigTypeIdPointer);
-            ZigType *array_type = value->value.type->data.pointer.child_type;
+            assert(array_ptr->value.type->id == ZigTypeIdPointer);
+            ZigType *array_type = array_ptr->value.type->data.pointer.child_type;
             assert(is_slice(wanted_type));
             bool is_const = wanted_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.is_const;
 
             IrInstruction *result = ir_const(ira, source_instr, wanted_type);
             init_const_slice(ira->codegen, &result->value, pointee, 0, array_type->data.array.len, is_const);
-            result->value.data.x_struct.fields[slice_ptr_index]->data.x_ptr.mut = value->value.data.x_ptr.mut;
+            result->value.data.x_struct.fields[slice_ptr_index]->data.x_ptr.mut = array_ptr->value.data.x_ptr.mut;
             result->value.type = wanted_type;
             return result;
         }
@@ -11018,7 +11120,7 @@ static IrInstruction *ir_resolve_ptr_of_array_to_slice(IrAnalyze *ira, IrInstruc
     if (type_is_invalid(result_loc_inst->value.type) || instr_is_unreachable(result_loc_inst)) {
         return result_loc_inst;
     }
-    return ir_build_ptr_of_array_to_slice(ira, source_instr, wanted_type, value, result_loc_inst);
+    return ir_build_ptr_of_array_to_slice(ira, source_instr, wanted_type, array_ptr, result_loc_inst);
 }
 
 static IrBasicBlock *ir_get_new_bb(IrAnalyze *ira, IrBasicBlock *old_bb, IrInstruction *ref_old_instruction) {
@@ -12483,6 +12585,8 @@ static void report_recursive_error(IrAnalyze *ira, AstNode *source_node, ConstCa
         case ConstCastResultIdFnArgNoAlias: // TODO
         case ConstCastResultIdUnresolvedInferredErrSet: // TODO
         case ConstCastResultIdAsyncAllocatorType: // TODO
+        case ConstCastResultIdArrayChild: // TODO
+        case ConstCastResultIdBadNullTermArrays: // TODO
             break;
     }
 }
@@ -12795,7 +12899,6 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         return ir_analyze_widen_or_shorten(ira, source_instr, value, wanted_type);
     }
 
-
     // cast from [N]T to []const T
     // TODO: once https://github.com/ziglang/zig/issues/265 lands, remove this
     if (is_slice(wanted_type) && actual_type->id == ZigTypeIdArray) {
@@ -12834,23 +12937,46 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         }
     }
 
-    // *[N]T to [*]T and [*c]T
-    if (wanted_type->id == ZigTypeIdPointer &&
-        (wanted_type->data.pointer.ptr_len == PtrLenUnknown || wanted_type->data.pointer.ptr_len == PtrLenC) &&
+    // *[N]T to ?[]const T
+    if (wanted_type->id == ZigTypeIdOptional &&
+        is_slice(wanted_type->data.maybe.child_type) &&
         actual_type->id == ZigTypeIdPointer &&
         actual_type->data.pointer.ptr_len == PtrLenSingle &&
         actual_type->data.pointer.child_type->id == ZigTypeIdArray)
     {
-        if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
+        IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value, nullptr);
+        if (type_is_invalid(cast1->value.type))
             return ira->codegen->invalid_instruction;
-        if ((err = type_resolve(ira->codegen, wanted_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
+
+        IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
+        if (type_is_invalid(cast2->value.type))
             return ira->codegen->invalid_instruction;
-        if (get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, wanted_type) &&
-            types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
-                actual_type->data.pointer.child_type->data.array.child_type, source_node,
-                !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
+
+        return cast2;
+    }
+
+    // *[N]T to [*]T and [*c]T
+    if (wanted_type->id == ZigTypeIdPointer &&
+        (wanted_type->data.pointer.ptr_len == PtrLenUnknown || wanted_type->data.pointer.ptr_len == PtrLenC ||
+            wanted_type->data.pointer.ptr_len == PtrLenNull) &&
+        actual_type->id == ZigTypeIdPointer &&
+        actual_type->data.pointer.ptr_len == PtrLenSingle &&
+        actual_type->data.pointer.child_type->id == ZigTypeIdArray)
+    {
+        if (wanted_type->data.pointer.ptr_len != PtrLenNull ||
+            actual_type->data.pointer.child_type->data.array.is_null_terminated)
         {
-            return ir_resolve_ptr_of_array_to_unknown_len_ptr(ira, source_instr, value, wanted_type);
+            if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
+                return ira->codegen->invalid_instruction;
+            if ((err = type_resolve(ira->codegen, wanted_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
+                return ira->codegen->invalid_instruction;
+            if (get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, wanted_type) &&
+                types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
+                    actual_type->data.pointer.child_type->data.array.child_type, source_node,
+                    !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
+            {
+                return ir_resolve_ptr_of_array_to_unknown_len_ptr(ira, source_instr, value, wanted_type);
+            }
         }
     }
 
@@ -14544,8 +14670,6 @@ static bool ok_float_op(IrBinOp op) {
 }
 
 static bool is_pointer_arithmetic_allowed(ZigType *lhs_type, IrBinOp op) {
-    if (lhs_type->id != ZigTypeIdPointer)
-        return false;
     switch (op) {
         case IrBinOpAdd:
         case IrBinOpSub:
@@ -14553,15 +14677,17 @@ static bool is_pointer_arithmetic_allowed(ZigType *lhs_type, IrBinOp op) {
         default:
             return false;
     }
+    if (lhs_type->id != ZigTypeIdPointer)
+        return false;
     switch (lhs_type->data.pointer.ptr_len) {
         case PtrLenSingle:
-            return false;
+            return lhs_type->data.pointer.child_type->id == ZigTypeIdArray;
         case PtrLenUnknown:
         case PtrLenNull:
         case PtrLenC:
-            break;
+            return true;
     }
-    return true;
+    zig_unreachable();
 }
 
 static IrInstruction *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *instruction) {
@@ -14823,6 +14949,7 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
     if (!op2_val)
         return ira->codegen->invalid_instruction;
 
+    bool is_null_terminated = false;
     ConstExprValue *op1_array_val;
     size_t op1_array_index;
     size_t op1_array_end;
@@ -14834,13 +14961,14 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op1_array_end = op1_type->data.array.len;
     } else if (op1_type->id == ZigTypeIdPointer &&
         op1_type->data.pointer.child_type == ira->codegen->builtin_types.entry_u8 &&
-        op1_val->data.x_ptr.special == ConstPtrSpecialBaseArray &&
-        op1_val->data.x_ptr.data.base_array.is_cstr)
+        op1_type->data.pointer.ptr_len == PtrLenNull &&
+        op1_val->data.x_ptr.special == ConstPtrSpecialBaseArray)
     {
         child_type = op1_type->data.pointer.child_type;
         op1_array_val = op1_val->data.x_ptr.data.base_array.array_val;
         op1_array_index = op1_val->data.x_ptr.data.base_array.elem_index;
-        op1_array_end = op1_array_val->type->data.array.len - 1;
+        op1_array_end = op1_array_val->type->data.array.len;
+        is_null_terminated = true;
     } else if (is_slice(op1_type)) {
         ZigType *ptr_type = op1_type->data.structure.fields[slice_ptr_index]->type_entry;
         child_type = ptr_type->data.pointer.child_type;
@@ -14850,9 +14978,20 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op1_array_index = ptr_val->data.x_ptr.data.base_array.elem_index;
         ConstExprValue *len_val = op1_val->data.x_struct.fields[slice_len_index];
         op1_array_end = op1_array_index + bigint_as_usize(&len_val->data.x_bigint);
+    } else if (op1_type->id == ZigTypeIdPointer && op1_type->data.pointer.ptr_len == PtrLenSingle &&
+            op1_type->data.pointer.child_type->id == ZigTypeIdArray)
+    {
+        ZigType *array_type = op1_type->data.pointer.child_type;
+        child_type = array_type->data.array.child_type;
+        op1_array_val = const_ptr_pointee(ira, ira->codegen, op1_val, op1->source_node);
+        if (op1_array_val == nullptr)
+            return ira->codegen->invalid_instruction;
+        op1_array_index = 0;
+        op1_array_end = array_type->data.array.len;
+        is_null_terminated = is_null_terminated || array_type->data.array.is_null_terminated;
     } else {
         ir_add_error(ira, op1,
-            buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op1->value.type->name)));
+            buf_sprintf("expected array, found '%s'", buf_ptr(&op1->value.type->name)));
         return ira->codegen->invalid_instruction;
     }
 
@@ -14866,14 +15005,14 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op2_array_index = 0;
         op2_array_end = op2_array_val->type->data.array.len;
     } else if (op2_type->id == ZigTypeIdPointer &&
-        op2_type->data.pointer.child_type == ira->codegen->builtin_types.entry_u8 &&
-        op2_val->data.x_ptr.special == ConstPtrSpecialBaseArray &&
-        op2_val->data.x_ptr.data.base_array.is_cstr)
+        op2_type->data.pointer.ptr_len == PtrLenNull &&
+        op2_val->data.x_ptr.special == ConstPtrSpecialBaseArray)
     {
-        op2_type_valid = child_type == ira->codegen->builtin_types.entry_u8;
+        op2_type_valid = op2_type->data.pointer.child_type == child_type;
         op2_array_val = op2_val->data.x_ptr.data.base_array.array_val;
         op2_array_index = op2_val->data.x_ptr.data.base_array.elem_index;
-        op2_array_end = op2_array_val->type->data.array.len - 1;
+        op2_array_end = op2_array_val->type->data.array.len;
+        is_null_terminated = true;
     } else if (is_slice(op2_type)) {
         ZigType *ptr_type = op2_type->data.structure.fields[slice_ptr_index]->type_entry;
         op2_type_valid = ptr_type->data.pointer.child_type == child_type;
@@ -14883,6 +15022,17 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op2_array_index = ptr_val->data.x_ptr.data.base_array.elem_index;
         ConstExprValue *len_val = op2_val->data.x_struct.fields[slice_len_index];
         op2_array_end = op2_array_index + bigint_as_usize(&len_val->data.x_bigint);
+    } else if (op2_type->id == ZigTypeIdPointer && op2_type->data.pointer.ptr_len == PtrLenSingle &&
+            op2_type->data.pointer.child_type->id == ZigTypeIdArray)
+    {
+        ZigType *array_type = op2_type->data.pointer.child_type;
+        op2_type_valid = array_type->data.array.child_type == child_type;
+        op2_array_val = const_ptr_pointee(ira, ira->codegen, op2_val, op2->source_node);
+        if (op2_array_val == nullptr)
+            return ira->codegen->invalid_instruction;
+        op2_array_index = 0;
+        op2_array_end = array_type->data.array.len;
+        is_null_terminated = is_null_terminated || array_type->data.array.is_null_terminated;
     } else {
         ir_add_error(ira, op2,
             buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op2->value.type->name)));
@@ -14905,6 +15055,14 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         result->value.type = get_array_type(ira->codegen, child_type, new_len, false);
 
         out_array_val = out_val;
+    } else if (op1_type->id == ZigTypeIdPointer || op2_type->id == ZigTypeIdPointer) {
+        out_array_val = create_const_vals(1);
+        out_array_val->special = ConstValSpecialStatic;
+        out_array_val->type = get_array_type(ira->codegen, child_type, new_len, is_null_terminated);
+
+        out_val->data.x_ptr.special = ConstPtrSpecialRef;
+        out_val->data.x_ptr.data.ref.pointee = out_array_val;
+        out_val->type = get_pointer_to_type(ira->codegen, out_array_val->type, true);
     } else if (is_slice(op1_type) || is_slice(op2_type)) {
         ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
                 true, false, PtrLenUnknown, 0, 0, 0, false);
@@ -14925,22 +15083,20 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         out_val->data.x_struct.fields[slice_len_index]->special = ConstValSpecialStatic;
         bigint_init_unsigned(&out_val->data.x_struct.fields[slice_len_index]->data.x_bigint, new_len);
     } else {
-        new_len += 1; // null byte
-
-        // TODO make this `[*]null T` instead of `[*]T`
-        result->value.type = get_pointer_to_type_extra(ira->codegen, child_type, true, false, PtrLenUnknown, 0, 0, 0, false);
+        result->value.type = get_pointer_to_type_extra(ira->codegen, child_type, true, false, PtrLenNull,
+                0, 0, 0, false);
 
         out_array_val = create_const_vals(1);
         out_array_val->special = ConstValSpecialStatic;
         out_array_val->type = get_array_type(ira->codegen, child_type, new_len, false);
         out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
-        out_val->data.x_ptr.data.base_array.is_cstr = true;
         out_val->data.x_ptr.data.base_array.array_val = out_array_val;
         out_val->data.x_ptr.data.base_array.elem_index = 0;
     }
 
     if (op1_array_val->data.x_array.special == ConstArraySpecialUndef &&
-        op2_array_val->data.x_array.special == ConstArraySpecialUndef) {
+        op2_array_val->data.x_array.special == ConstArraySpecialUndef)
+    {
         out_array_val->data.x_array.special = ConstArraySpecialUndef;
         return result;
     }
@@ -14978,20 +15134,34 @@ static IrInstruction *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *
     if (type_is_invalid(op2->value.type))
         return ira->codegen->invalid_instruction;
 
-    ConstExprValue *array_val = ir_resolve_const(ira, op1, UndefBad);
-    if (!array_val)
+    bool want_ptr_to_array = false;
+    ZigType *array_type;
+    ConstExprValue *array_val;
+    if (op1->value.type->id == ZigTypeIdArray) {
+        array_type = op1->value.type;
+        array_val = ir_resolve_const(ira, op1, UndefOk);
+        if (array_val == nullptr)
+            return ira->codegen->invalid_instruction;
+    } else if (op1->value.type->id == ZigTypeIdPointer && op1->value.type->data.pointer.ptr_len == PtrLenSingle &&
+        op1->value.type->data.pointer.child_type->id == ZigTypeIdArray)
+    {
+        array_type = op1->value.type->data.pointer.child_type;
+        IrInstruction *array_inst = ir_get_deref(ira, op1, op1, nullptr);
+        if (type_is_invalid(array_inst->value.type))
+            return ira->codegen->invalid_instruction;
+        array_val = ir_resolve_const(ira, array_inst, UndefOk);
+        if (array_val == nullptr)
+            return ira->codegen->invalid_instruction;
+        want_ptr_to_array = true;
+    } else {
+        ir_add_error(ira, op1, buf_sprintf("expected array type, found '%s'", buf_ptr(&op1->value.type->name)));
         return ira->codegen->invalid_instruction;
+    }
 
     uint64_t mult_amt;
     if (!ir_resolve_usize(ira, op2, &mult_amt))
         return ira->codegen->invalid_instruction;
 
-    ZigType *array_type = op1->value.type;
-    if (array_type->id != ZigTypeIdArray) {
-        ir_add_error(ira, op1, buf_sprintf("expected array type, found '%s'", buf_ptr(&op1->value.type->name)));
-        return ira->codegen->invalid_instruction;
-    }
-
     uint64_t old_array_len = array_type->data.array.len;
     uint64_t new_array_len;
 
@@ -15001,42 +15171,59 @@ static IrInstruction *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *
     }
 
     ZigType *child_type = array_type->data.array.child_type;
+    ZigType *result_array_type = get_array_type(ira->codegen, child_type, new_array_len,
+            array_type->data.array.is_null_terminated);
 
-    IrInstruction *result = ir_const(ira, &instruction->base,
-        get_array_type(ira->codegen, child_type, new_array_len, false));
-    ConstExprValue *out_val = &result->value;
-    if (array_val->data.x_array.special == ConstArraySpecialUndef) {
-        out_val->data.x_array.special = ConstArraySpecialUndef;
-        return result;
-    }
+    IrInstruction *array_result;
+    if (array_val->special == ConstValSpecialUndef || array_val->data.x_array.special == ConstArraySpecialUndef) {
+        array_result = ir_const_undef(ira, &instruction->base, result_array_type);
+    } else {
+        array_result = ir_const(ira, &instruction->base, result_array_type);
+        ConstExprValue *out_val = &array_result->value;
 
-    switch (type_has_one_possible_value(ira->codegen, result->value.type)) {
-        case OnePossibleValueInvalid:
-            return ira->codegen->invalid_instruction;
-        case OnePossibleValueYes:
-            return result;
-        case OnePossibleValueNo:
-            break;
-    }
+        switch (type_has_one_possible_value(ira->codegen, result_array_type)) {
+            case OnePossibleValueInvalid:
+                return ira->codegen->invalid_instruction;
+            case OnePossibleValueYes:
+                goto skip_computation;
+            case OnePossibleValueNo:
+                break;
+        }
 
-    // TODO optimize the buf case
-    expand_undef_array(ira->codegen, array_val);
-    out_val->data.x_array.data.s_none.elements = create_const_vals(new_array_len);
+        // TODO optimize the buf case
+        expand_undef_array(ira->codegen, array_val);
+        size_t extra_null_term = array_type->data.array.is_null_terminated ? 1 : 0;
+        out_val->data.x_array.data.s_none.elements = create_const_vals(new_array_len + extra_null_term);
 
-    uint64_t i = 0;
-    for (uint64_t x = 0; x < mult_amt; x += 1) {
-        for (uint64_t y = 0; y < old_array_len; y += 1) {
+        uint64_t i = 0;
+        for (uint64_t x = 0; x < mult_amt; x += 1) {
+            for (uint64_t y = 0; y < old_array_len; y += 1) {
+                ConstExprValue *elem_dest_val = &out_val->data.x_array.data.s_none.elements[i];
+                copy_const_val(elem_dest_val, &array_val->data.x_array.data.s_none.elements[y], false);
+                elem_dest_val->parent.id = ConstParentIdArray;
+                elem_dest_val->parent.data.p_array.array_val = out_val;
+                elem_dest_val->parent.data.p_array.elem_index = i;
+                i += 1;
+            }
+        }
+        assert(i == new_array_len);
+
+        if (array_type->data.array.is_null_terminated) {
+            ConstExprValue *null_value = get_null_value(array_type->data.array.child_type);
             ConstExprValue *elem_dest_val = &out_val->data.x_array.data.s_none.elements[i];
-            copy_const_val(elem_dest_val, &array_val->data.x_array.data.s_none.elements[y], false);
+            copy_const_val(elem_dest_val, null_value, false);
             elem_dest_val->parent.id = ConstParentIdArray;
             elem_dest_val->parent.data.p_array.array_val = out_val;
             elem_dest_val->parent.data.p_array.elem_index = i;
             i += 1;
         }
     }
-    assert(i == new_array_len);
-
-    return result;
+skip_computation:
+    if (want_ptr_to_array) {
+        return ir_get_ref(ira, &instruction->base, array_result, true, false);
+    } else {
+        return array_result;
+    }
 }
 
 static IrInstruction *ir_analyze_instruction_merge_err_sets(IrAnalyze *ira,
@@ -17309,6 +17496,7 @@ static Error ir_read_const_ptr(IrAnalyze *ira, CodeGen *codegen, AstNode *source
     assert(out_val->type != nullptr);
 
     ConstExprValue *pointee = const_ptr_pointee_unchecked(codegen, ptr_val);
+    src_assert(pointee->type != nullptr, source_node);
 
     if ((err = type_resolve(codegen, pointee->type, ResolveStatusSizeKnown)))
         return ErrorSemanticAnalyzeFail;
@@ -17319,7 +17507,7 @@ static Error ir_read_const_ptr(IrAnalyze *ira, CodeGen *codegen, AstNode *source
     size_t dst_size = type_size(codegen, out_val->type);
 
     if (dst_size <= src_size) {
-        if (src_size == dst_size && types_have_same_zig_comptime_repr(pointee->type, out_val->type)) {
+        if (src_size == dst_size && types_have_same_zig_comptime_repr(out_val->type, pointee->type)) {
             copy_const_val(out_val, pointee, ptr_val->data.x_ptr.mut != ConstPtrMutComptimeVar);
             return ErrorNone;
         }
@@ -18070,6 +18258,12 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
         uint64_t index = bigint_as_u64(&casted_elem_index->value.data.x_bigint);
         if (array_type->id == ZigTypeIdArray) {
             uint64_t array_len = array_type->data.array.len;
+            if (index == array_len && array_type->data.array.is_null_terminated) {
+                ZigType *elem_type = array_type->data.array.child_type;
+                IrInstruction *null_element = ir_const(ira, &elem_ptr_instruction->base, elem_type);
+                null_element->value = *get_null_value(elem_type);
+                return ir_get_ref(ira, &elem_ptr_instruction->base, null_element, true, false);
+            }
             if (index >= array_len) {
                 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
                     buf_sprintf("index %" ZIG_PRI_u64 " outside array of size %" ZIG_PRI_u64,
@@ -18203,7 +18397,11 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
                             {
                                 size_t offset = array_ptr_val->data.x_ptr.data.base_array.elem_index;
                                 new_index = offset + index;
-                                mem_size = array_ptr_val->data.x_ptr.data.base_array.array_val->type->data.array.len;
+                                ZigType *array_type = array_ptr_val->data.x_ptr.data.base_array.array_val->type;
+                                mem_size = array_type->data.array.len;
+                                if (array_type->data.array.is_null_terminated) {
+                                    mem_size += 1;
+                                }
                                 old_size = mem_size - offset;
 
                                 assert(array_ptr_val->data.x_ptr.data.base_array.array_val);
@@ -18212,8 +18410,6 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
                                 out_val->data.x_ptr.data.base_array.array_val =
                                     array_ptr_val->data.x_ptr.data.base_array.array_val;
                                 out_val->data.x_ptr.data.base_array.elem_index = new_index;
-                                out_val->data.x_ptr.data.base_array.is_cstr =
-                                    array_ptr_val->data.x_ptr.data.base_array.is_cstr;
 
                                 break;
                             }
@@ -18277,8 +18473,6 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
                                 out_val->data.x_ptr.data.base_array.array_val =
                                     ptr_field->data.x_ptr.data.base_array.array_val;
                                 out_val->data.x_ptr.data.base_array.elem_index = new_index;
-                                out_val->data.x_ptr.data.base_array.is_cstr =
-                                    ptr_field->data.x_ptr.data.base_array.is_cstr;
                                 break;
                             }
                         case ConstPtrSpecialBaseStruct:
@@ -19550,7 +19744,7 @@ static IrInstruction *ir_analyze_unwrap_optional_payload(IrAnalyze *ira, IrInstr
     ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
             ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile, PtrLenSingle, 0, 0, 0, false);
 
-    bool same_comptime_repr = types_have_same_zig_comptime_repr(type_entry, child_type);
+    bool same_comptime_repr = types_have_same_zig_comptime_repr(child_type, type_entry);
 
     if (instr_is_comptime(base_ptr)) {
         ConstExprValue *ptr_val = ir_resolve_const(ira, base_ptr, UndefBad);
@@ -20685,7 +20879,7 @@ static IrInstruction *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstruct
             return ira->codegen->invalid_instruction;
         ErrorTableEntry *err = casted_value->value.data.x_err_set;
         if (!err->cached_error_name_val) {
-            ConstExprValue *array_val = create_const_str_lit(ira->codegen, &err->name);
+            ConstExprValue *array_val = create_const_str_lit(ira->codegen, &err->name)->data.x_ptr.data.ref.pointee;
             err->cached_error_name_val = create_const_slice(ira->codegen, array_val, 0, buf_len(&err->name), true);
         }
         IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
@@ -20714,7 +20908,7 @@ static IrInstruction *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrIns
         if ((err = type_resolve(ira->codegen, target->value.type, ResolveStatusZeroBitsKnown)))
             return ira->codegen->invalid_instruction;
         TypeEnumField *field = find_enum_field_by_tag(target->value.type, &target->value.data.x_bigint);
-        ConstExprValue *array_val = create_const_str_lit(ira->codegen, field->name);
+        ConstExprValue *array_val = create_const_str_lit(ira->codegen, field->name)->data.x_ptr.data.ref.pointee;
         IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
         init_const_slice(ira->codegen, &result->value, array_val, 0, buf_len(field->name), true);
         return result;
@@ -21019,7 +21213,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
         declaration_val->type = type_info_declaration_type;
 
         ConstExprValue **inner_fields = alloc_const_vals_ptrs(3);
-        ConstExprValue *name = create_const_str_lit(ira->codegen, curr_entry->key);
+        ConstExprValue *name = create_const_str_lit(ira->codegen, curr_entry->key)->data.x_ptr.data.ref.pointee;
         init_const_slice(ira->codegen, inner_fields[0], name, 0, buf_len(curr_entry->key), true);
         inner_fields[1]->special = ConstValSpecialStatic;
         inner_fields[1]->type = ira->codegen->builtin_types.entry_bool;
@@ -21122,7 +21316,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
                     fn_decl_fields[6]->type = get_optional_type(ira->codegen, get_slice_type(ira->codegen, u8_ptr));
                     if (fn_node->is_extern && fn_node->lib_name != nullptr && buf_len(fn_node->lib_name) > 0) {
                         fn_decl_fields[6]->data.x_optional = create_const_vals(1);
-                        ConstExprValue *lib_name = create_const_str_lit(ira->codegen, fn_node->lib_name);
+                        ConstExprValue *lib_name = create_const_str_lit(ira->codegen, fn_node->lib_name)->data.x_ptr.data.ref.pointee;
                         init_const_slice(ira->codegen, fn_decl_fields[6]->data.x_optional, lib_name, 0,
                                 buf_len(fn_node->lib_name), true);
                     } else {
@@ -21149,7 +21343,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
                         ZigVar *arg_var = fn_entry->variable_list.at(fn_arg_index);
                         ConstExprValue *fn_arg_name_val = &fn_arg_name_array->data.x_array.data.s_none.elements[fn_arg_index];
                         ConstExprValue *arg_name = create_const_str_lit(ira->codegen,
-                                buf_create_from_str(arg_var->name));
+                                buf_create_from_str(arg_var->name))->data.x_ptr.data.ref.pointee;
                         init_const_slice(ira->codegen, fn_arg_name_val, arg_name, 0, strlen(arg_var->name), true);
                         fn_arg_name_val->parent.id = ConstParentIdArray;
                         fn_arg_name_val->parent.data.p_array.array_val = fn_arg_name_array;
@@ -21294,7 +21488,7 @@ static void make_enum_field_val(IrAnalyze *ira, ConstExprValue *enum_field_val,
     inner_fields[1]->special = ConstValSpecialStatic;
     inner_fields[1]->type = ira->codegen->builtin_types.entry_num_lit_int;
 
-    ConstExprValue *name = create_const_str_lit(ira->codegen, enum_field->name);
+    ConstExprValue *name = create_const_str_lit(ira->codegen, enum_field->name)->data.x_ptr.data.ref.pointee;
     init_const_slice(ira->codegen, inner_fields[0], name, 0, buf_len(enum_field->name), true);
 
     bigint_init_bigint(&inner_fields[1]->data.x_bigint, &enum_field->value);
@@ -21560,7 +21754,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
                     if (error->cached_error_name_val != nullptr)
                         name = error->cached_error_name_val;
                     if (name == nullptr)
-                        name = create_const_str_lit(ira->codegen, &error->name);
+                        name = create_const_str_lit(ira->codegen, &error->name)->data.x_ptr.data.ref.pointee;
                     init_const_slice(ira->codegen, inner_fields[0], name, 0, buf_len(&error->name), true);
                     bigint_init_unsigned(&inner_fields[1]->data.x_bigint, error->value);
 
@@ -21666,7 +21860,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
                     inner_fields[2]->type = ira->codegen->builtin_types.entry_type;
                     inner_fields[2]->data.x_type = union_field->type_entry;
 
-                    ConstExprValue *name = create_const_str_lit(ira->codegen, union_field->name);
+                    ConstExprValue *name = create_const_str_lit(ira->codegen, union_field->name)->data.x_ptr.data.ref.pointee;
                     init_const_slice(ira->codegen, inner_fields[0], name, 0, buf_len(union_field->name), true);
 
                     union_field_val->data.x_struct.fields = inner_fields;
@@ -21752,7 +21946,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
                     inner_fields[2]->type = ira->codegen->builtin_types.entry_type;
                     inner_fields[2]->data.x_type = struct_field->type_entry;
 
-                    ConstExprValue *name = create_const_str_lit(ira->codegen, struct_field->name);
+                    ConstExprValue *name = create_const_str_lit(ira->codegen, struct_field->name)->data.x_ptr.data.ref.pointee;
                     init_const_slice(ira->codegen, inner_fields[0], name, 0, buf_len(struct_field->name), true);
 
                     struct_field_val->data.x_struct.fields = inner_fields;
diff --git a/src/parser.cpp b/src/parser.cpp
index 3da0d8a643..c3f719425b 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -1718,7 +1718,6 @@ static AstNode *ast_parse_primary_type_expr(ParseContext *pc) {
     if (string_lit != nullptr) {
         AstNode *res = ast_create_node(pc, NodeTypeStringLiteral, string_lit);
         res->data.string_literal.buf = token_buf(string_lit);
-        res->data.string_literal.c = string_lit->data.str_lit.is_c_str;
         return res;
     }
 
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 7ece5ff3fe..5088fbdbf8 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -33,10 +33,10 @@
          '0': \
     case DIGIT_NON_ZERO
 
-#define ALPHA_EXCEPT_C \
+#define ALPHA \
          'a': \
     case 'b': \
-  /*case 'c':*/ \
+    case 'c': \
     case 'd': \
     case 'e': \
     case 'f': \
@@ -87,10 +87,6 @@
     case 'Y': \
     case 'Z'
 
-#define ALPHA \
-    ALPHA_EXCEPT_C: \
-    case 'c'
-
 #define SYMBOL_CHAR \
     ALPHA: \
     case DIGIT: \
@@ -180,7 +176,6 @@ static bool is_symbol_char(uint8_t c) {
 enum TokenizeState {
     TokenizeStateStart,
     TokenizeStateSymbol,
-    TokenizeStateSymbolFirstC,
     TokenizeStateZero, // "0", which might lead to "0x"
     TokenizeStateNumber, // "123", "0x123"
     TokenizeStateNumberDot,
@@ -279,7 +274,6 @@ static void set_token_id(Tokenize *t, Token *token, TokenId id) {
     } else if (id == TokenIdStringLiteral || id == TokenIdSymbol) {
         memset(&token->data.str_lit.str, 0, sizeof(Buf));
         buf_resize(&token->data.str_lit.str, 0);
-        token->data.str_lit.is_c_str = false;
     }
 }
 
@@ -429,12 +423,7 @@ void tokenize(Buf *buf, Tokenization *out) {
                 switch (c) {
                     case WHITESPACE:
                         break;
-                    case 'c':
-                        t.state = TokenizeStateSymbolFirstC;
-                        begin_token(&t, TokenIdSymbol);
-                        buf_append_char(&t.cur_tok->data.str_lit.str, c);
-                        break;
-                    case ALPHA_EXCEPT_C:
+                    case ALPHA:
                     case '_':
                         t.state = TokenizeStateSymbol;
                         begin_token(&t, TokenIdSymbol);
@@ -1007,19 +996,7 @@ void tokenize(Buf *buf, Tokenization *out) {
                 switch (c) {
                     case WHITESPACE:
                         break;
-                    case 'c':
-                        if (!t.cur_tok->data.str_lit.is_c_str) {
-                            t.pos -= 1;
-                            end_token(&t);
-                            t.state = TokenizeStateStart;
-                            break;
-                        }
-                        t.state = TokenizeStateLineStringContinueC;
-                        break;
                     case '\\':
-                        if (t.cur_tok->data.str_lit.is_c_str) {
-                            invalid_char_error(&t, c);
-                        }
                         t.state = TokenizeStateLineStringContinue;
                         break;
                     default:
@@ -1084,29 +1061,6 @@ void tokenize(Buf *buf, Tokenization *out) {
                         break;
                 }
                 break;
-            case TokenizeStateSymbolFirstC:
-                switch (c) {
-                    case '"':
-                        set_token_id(&t, t.cur_tok, TokenIdStringLiteral);
-                        t.cur_tok->data.str_lit.is_c_str = true;
-                        t.state = TokenizeStateString;
-                        break;
-                    case '\\':
-                        set_token_id(&t, t.cur_tok, TokenIdStringLiteral);
-                        t.cur_tok->data.str_lit.is_c_str = true;
-                        t.state = TokenizeStateSawBackslash;
-                        break;
-                    case SYMBOL_CHAR:
-                        t.state = TokenizeStateSymbol;
-                        buf_append_char(&t.cur_tok->data.str_lit.str, c);
-                        break;
-                    default:
-                        t.pos -= 1;
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        continue;
-                }
-                break;
             case TokenizeStateSawAtSign:
                 switch (c) {
                     case '"':
@@ -1544,7 +1498,6 @@ void tokenize(Buf *buf, Tokenization *out) {
             tokenize_error(&t, "unterminated character literal");
             break;
         case TokenizeStateSymbol:
-        case TokenizeStateSymbolFirstC:
         case TokenizeStateZero:
         case TokenizeStateNumber:
         case TokenizeStateFloatFraction:
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index 149e58b6a7..b152eb079c 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -149,7 +149,6 @@ struct TokenIntLit {
 
 struct TokenStrLit {
     Buf str;
-    bool is_c_str;
 };
 
 struct TokenCharLit {
diff --git a/src/translate_c.cpp b/src/translate_c.cpp
index 6df61ab13c..5dd6064984 100644
--- a/src/translate_c.cpp
+++ b/src/translate_c.cpp
@@ -323,17 +323,9 @@ static AstNode *trans_create_node_bool(Context *c, bool value) {
     return bool_node;
 }
 
-static AstNode *trans_create_node_str_lit_c(Context *c, Buf *buf) {
+static AstNode *trans_create_node_str_lit(Context *c, Buf *buf) {
     AstNode *node = trans_create_node(c, NodeTypeStringLiteral);
     node->data.string_literal.buf = buf;
-    node->data.string_literal.c = true;
-    return node;
-}
-
-static AstNode *trans_create_node_str_lit_non_c(Context *c, Buf *buf) {
-    AstNode *node = trans_create_node(c, NodeTypeStringLiteral);
-    node->data.string_literal.buf = buf;
-    node->data.string_literal.c = false;
     return node;
 }
 
@@ -632,7 +624,7 @@ static AstNode *qual_type_to_log2_int_ref(Context *c, const ZigClangQualType qt,
 //        zig_type_node
 
     AstNode *import_fn_call = trans_create_node_builtin_fn_call_str(c, "import");
-    import_fn_call->data.fn_call_expr.params.append(trans_create_node_str_lit_non_c(c, buf_create_from_str("std")));
+    import_fn_call->data.fn_call_expr.params.append(trans_create_node_str_lit(c, buf_create_from_str("std")));
     AstNode *inner_field_access = trans_create_node_field_access_str(c, import_fn_call, "math");
     AstNode *outer_field_access = trans_create_node_field_access_str(c, inner_field_access, "Log2Int");
     AstNode *log2int_fn_call = trans_create_node_fn_call_1(c, outer_field_access, zig_type_node);
@@ -3391,7 +3383,7 @@ static AstNode *trans_string_literal(Context *c, ResultUsed result_used, TransSc
         case ZigClangStringLiteral_StringKind_UTF8: {
             size_t str_len;
             const char *str_ptr = ZigClangStringLiteral_getString_bytes_begin_size(stmt, &str_len);
-            AstNode *node = trans_create_node_str_lit_c(c, buf_create_from_mem(str_ptr, str_len));
+            AstNode *node = trans_create_node_str_lit(c, buf_create_from_mem(str_ptr, str_len));
             return maybe_suppress_result(c, result_used, node);
         }
         case ZigClangStringLiteral_StringKind_UTF16:
@@ -4890,7 +4882,7 @@ static AstNode *parse_ctok_primary_expr(Context *c, CTokenize *ctok, size_t *tok
             return trans_create_node_unsigned(c, tok->data.char_lit);
         case CTokIdStrLit:
             *tok_i += 1;
-            return trans_create_node_str_lit_c(c, buf_create_from_buf(&tok->data.str_lit));
+            return trans_create_node_str_lit(c, buf_create_from_buf(&tok->data.str_lit));
         case CTokIdMinus:
             *tok_i += 1;
             return parse_ctok_num_lit(c, ctok, tok_i, true);
@@ -4937,7 +4929,7 @@ static AstNode *parse_ctok_primary_expr(Context *c, CTokenize *ctok, size_t *tok
                 //    (dest)(x)
 
                 AstNode *import_builtin = trans_create_node_builtin_fn_call_str(c, "import");
-                import_builtin->data.fn_call_expr.params.append(trans_create_node_str_lit_non_c(c, buf_create_from_str("builtin")));
+                import_builtin->data.fn_call_expr.params.append(trans_create_node_str_lit(c, buf_create_from_str("builtin")));
                 AstNode *typeid_type = trans_create_node_field_access_str(c, import_builtin, "TypeId");
                 AstNode *typeid_pointer = trans_create_node_field_access_str(c, typeid_type, "Pointer");
                 AstNode *typeid_integer = trans_create_node_field_access_str(c, typeid_type, "Int");
diff --git a/test/compare_output.zig b/test/compare_output.zig
index 0842fc4629..1535d0ae52 100644
--- a/test/compare_output.zig
+++ b/test/compare_output.zig
@@ -7,7 +7,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
     cases.addC("hello world with libc",
         \\const c = @cImport(@cInclude("stdio.h"));
         \\export fn main(argc: c_int, argv: [*][*]u8) c_int {
-        \\    _ = c.puts(c"Hello, world!");
+        \\    _ = c.puts("Hello, world!");
         \\    return 0;
         \\}
     , "Hello, world!" ++ std.cstr.line_sep);
@@ -144,75 +144,75 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
         \\        // we want actual \n, not \r\n
         \\        _ = c._setmode(1, c._O_BINARY);
         \\    }
-        \\    _ = c.printf(c"0: %llu\n",
+        \\    _ = c.printf("0: %llu\n",
         \\             @as(u64, 0));
-        \\    _ = c.printf(c"320402575052271: %llu\n",
+        \\    _ = c.printf("320402575052271: %llu\n",
         \\         @as(u64, 320402575052271));
-        \\    _ = c.printf(c"0x01236789abcdef: %llu\n",
+        \\    _ = c.printf("0x01236789abcdef: %llu\n",
         \\         @as(u64, 0x01236789abcdef));
-        \\    _ = c.printf(c"0xffffffffffffffff: %llu\n",
+        \\    _ = c.printf("0xffffffffffffffff: %llu\n",
         \\         @as(u64, 0xffffffffffffffff));
-        \\    _ = c.printf(c"0x000000ffffffffffffffff: %llu\n",
+        \\    _ = c.printf("0x000000ffffffffffffffff: %llu\n",
         \\         @as(u64, 0x000000ffffffffffffffff));
-        \\    _ = c.printf(c"0o1777777777777777777777: %llu\n",
+        \\    _ = c.printf("0o1777777777777777777777: %llu\n",
         \\         @as(u64, 0o1777777777777777777777));
-        \\    _ = c.printf(c"0o0000001777777777777777777777: %llu\n",
+        \\    _ = c.printf("0o0000001777777777777777777777: %llu\n",
         \\         @as(u64, 0o0000001777777777777777777777));
-        \\    _ = c.printf(c"0b1111111111111111111111111111111111111111111111111111111111111111: %llu\n",
+        \\    _ = c.printf("0b1111111111111111111111111111111111111111111111111111111111111111: %llu\n",
         \\         @as(u64, 0b1111111111111111111111111111111111111111111111111111111111111111));
-        \\    _ = c.printf(c"0b0000001111111111111111111111111111111111111111111111111111111111111111: %llu\n",
+        \\    _ = c.printf("0b0000001111111111111111111111111111111111111111111111111111111111111111: %llu\n",
         \\         @as(u64, 0b0000001111111111111111111111111111111111111111111111111111111111111111));
         \\
-        \\    _ = c.printf(c"\n");
+        \\    _ = c.printf("\n");
         \\
-        \\    _ = c.printf(c"0.0: %.013a\n",
+        \\    _ = c.printf("0.0: %.013a\n",
         \\         @as(f64, 0.0));
-        \\    _ = c.printf(c"0e0: %.013a\n",
+        \\    _ = c.printf("0e0: %.013a\n",
         \\         @as(f64, 0e0));
-        \\    _ = c.printf(c"0.0e0: %.013a\n",
+        \\    _ = c.printf("0.0e0: %.013a\n",
         \\         @as(f64, 0.0e0));
-        \\    _ = c.printf(c"000000000000000000000000000000000000000000000000000000000.0e0: %.013a\n",
+        \\    _ = c.printf("000000000000000000000000000000000000000000000000000000000.0e0: %.013a\n",
         \\         @as(f64, 000000000000000000000000000000000000000000000000000000000.0e0));
-        \\    _ = c.printf(c"0.000000000000000000000000000000000000000000000000000000000e0: %.013a\n",
+        \\    _ = c.printf("0.000000000000000000000000000000000000000000000000000000000e0: %.013a\n",
         \\         @as(f64, 0.000000000000000000000000000000000000000000000000000000000e0));
-        \\    _ = c.printf(c"0.0e000000000000000000000000000000000000000000000000000000000: %.013a\n",
+        \\    _ = c.printf("0.0e000000000000000000000000000000000000000000000000000000000: %.013a\n",
         \\         @as(f64, 0.0e000000000000000000000000000000000000000000000000000000000));
-        \\    _ = c.printf(c"1.0: %.013a\n",
+        \\    _ = c.printf("1.0: %.013a\n",
         \\         @as(f64, 1.0));
-        \\    _ = c.printf(c"10.0: %.013a\n",
+        \\    _ = c.printf("10.0: %.013a\n",
         \\         @as(f64, 10.0));
-        \\    _ = c.printf(c"10.5: %.013a\n",
+        \\    _ = c.printf("10.5: %.013a\n",
         \\         @as(f64, 10.5));
-        \\    _ = c.printf(c"10.5e5: %.013a\n",
+        \\    _ = c.printf("10.5e5: %.013a\n",
         \\         @as(f64, 10.5e5));
-        \\    _ = c.printf(c"10.5e+5: %.013a\n",
+        \\    _ = c.printf("10.5e+5: %.013a\n",
         \\         @as(f64, 10.5e+5));
-        \\    _ = c.printf(c"50.0e-2: %.013a\n",
+        \\    _ = c.printf("50.0e-2: %.013a\n",
         \\         @as(f64, 50.0e-2));
-        \\    _ = c.printf(c"50e-2: %.013a\n",
+        \\    _ = c.printf("50e-2: %.013a\n",
         \\         @as(f64, 50e-2));
         \\
-        \\    _ = c.printf(c"\n");
+        \\    _ = c.printf("\n");
         \\
-        \\    _ = c.printf(c"0x1.0: %.013a\n",
+        \\    _ = c.printf("0x1.0: %.013a\n",
         \\         @as(f64, 0x1.0));
-        \\    _ = c.printf(c"0x10.0: %.013a\n",
+        \\    _ = c.printf("0x10.0: %.013a\n",
         \\         @as(f64, 0x10.0));
-        \\    _ = c.printf(c"0x100.0: %.013a\n",
+        \\    _ = c.printf("0x100.0: %.013a\n",
         \\         @as(f64, 0x100.0));
-        \\    _ = c.printf(c"0x103.0: %.013a\n",
+        \\    _ = c.printf("0x103.0: %.013a\n",
         \\         @as(f64, 0x103.0));
-        \\    _ = c.printf(c"0x103.7: %.013a\n",
+        \\    _ = c.printf("0x103.7: %.013a\n",
         \\         @as(f64, 0x103.7));
-        \\    _ = c.printf(c"0x103.70: %.013a\n",
+        \\    _ = c.printf("0x103.70: %.013a\n",
         \\         @as(f64, 0x103.70));
-        \\    _ = c.printf(c"0x103.70p4: %.013a\n",
+        \\    _ = c.printf("0x103.70p4: %.013a\n",
         \\         @as(f64, 0x103.70p4));
-        \\    _ = c.printf(c"0x103.70p5: %.013a\n",
+        \\    _ = c.printf("0x103.70p5: %.013a\n",
         \\         @as(f64, 0x103.70p5));
-        \\    _ = c.printf(c"0x103.70p+5: %.013a\n",
+        \\    _ = c.printf("0x103.70p+5: %.013a\n",
         \\         @as(f64, 0x103.70p+5));
-        \\    _ = c.printf(c"0x103.70p-5: %.013a\n",
+        \\    _ = c.printf("0x103.70p-5: %.013a\n",
         \\         @as(f64, 0x103.70p-5));
         \\
         \\    return 0;
@@ -323,7 +323,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
         \\    const x: f64 = small;
         \\    const y = @floatToInt(i32, x);
         \\    const z = @intToFloat(f64, y);
-        \\    _ = c.printf(c"%.2f\n%d\n%.2f\n%.2f\n", x, y, z, @as(f64, -0.4));
+        \\    _ = c.printf("%.2f\n%d\n%.2f\n%.2f\n", x, y, z, @as(f64, -0.4));
         \\    return 0;
         \\}
     , "3.25\n3\n3.00\n-0.40\n");
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 039afe52df..3343580991 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -164,7 +164,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     cases.add(
         "using an unknown len ptr type instead of array",
         \\const resolutions = [*][*]const u8{
-        \\    c"[320 240  ]",
+        \\    "[320 240  ]",
         \\    null,
         \\};
         \\comptime {
@@ -781,7 +781,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "peer cast then implicit cast const pointer to mutable C pointer",
         \\export fn func() void {
         \\    var strValue: [*c]u8 = undefined;
-        \\    strValue = strValue orelse c"";
+        \\    strValue = strValue orelse "";
         \\}
     ,
         "tmp.zig:3:32: error: cast discards const qualifier",
@@ -1115,7 +1115,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "libc headers note",
             \\const c = @cImport(@cInclude("stdio.h"));
             \\export fn entry() void {
-            \\    _ = c.printf(c"hello, world!\n");
+            \\    _ = c.printf("hello, world!\n");
             \\}
         ,
             "tmp.zig:1:11: error: C import failed",
@@ -3352,7 +3352,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     cases.add(
         "variable has wrong type",
         \\export fn f() i32 {
-        \\    const a = c"a";
+        \\    const a = "a";
         \\    return a;
         \\}
     ,
@@ -4786,7 +4786,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     cases.add(
         "assign through constant pointer",
         \\export fn f() void {
-        \\  var cstr = c"Hat";
+        \\  var cstr = "Hat";
         \\  cstr[0] = 'W';
         \\}
     ,
diff --git a/test/stage1/behavior/array.zig b/test/stage1/behavior/array.zig
index 3a9c9a7655..b9000125b3 100644
--- a/test/stage1/behavior/array.zig
+++ b/test/stage1/behavior/array.zig
@@ -132,9 +132,16 @@ test "single-item pointer to array indexing and slicing" {
 }
 
 fn testSingleItemPtrArrayIndexSlice() void {
-    var array = "aaaa";
-    doSomeMangling(&array);
-    expect(mem.eql(u8, "azya", array));
+    {
+        var array: [4]u8 = "aaaa".*;
+        doSomeMangling(&array);
+        expect(mem.eql(u8, "azya", &array));
+    }
+    {
+        var array = "aaaa".*;
+        doSomeMangling(&array);
+        expect(mem.eql(u8, "azya", &array));
+    }
 }
 
 fn doSomeMangling(array: *[4]u8) void {
@@ -294,9 +301,16 @@ test "read/write through global variable array of struct fields initialized via
 }
 
 test "implicit cast zero sized array ptr to slice" {
-    var b = "";
-    const c: []const u8 = &b;
-    expect(c.len == 0);
+    {
+        var b = "".*;
+        const c: []const u8 = &b;
+        expect(c.len == 0);
+    }
+    {
+        var b: [0]u8 = "".*;
+        const c: []const u8 = &b;
+        expect(c.len == 0);
+    }
 }
 
 test "anonymous list literal syntax" {
@@ -333,3 +347,16 @@ test "anonymous literal in array" {
     S.doTheTest();
     comptime S.doTheTest();
 }
+
+test "access the null element of a null terminated array" {
+    const S = struct {
+        fn doTheTest() void {
+            var array: [4]null u8 = .{'a', 'o', 'e', 'u'};
+            comptime expect(array[4] == 0);
+            var len: usize = 4;
+            expect(array[len] == 0);
+        }
+    };
+    S.doTheTest();
+    comptime S.doTheTest();
+}
diff --git a/test/stage1/behavior/bugs/1076.zig b/test/stage1/behavior/bugs/1076.zig
index 550ee9703a..fa3caf0df8 100644
--- a/test/stage1/behavior/bugs/1076.zig
+++ b/test/stage1/behavior/bugs/1076.zig
@@ -8,8 +8,16 @@ test "comptime code should not modify constant data" {
 }
 
 fn testCastPtrOfArrayToSliceAndPtr() void {
-    var array = "aoeu";
-    const x: [*]u8 = &array;
-    x[0] += 1;
-    expect(mem.eql(u8, array[0..], "boeu"));
+    {
+        var array = "aoeu".*;
+        const x: [*]u8 = &array;
+        x[0] += 1;
+        expect(mem.eql(u8, array[0..], "boeu"));
+    }
+    {
+        var array: [4]u8 = "aoeu".*;
+        const x: [*]u8 = &array;
+        x[0] += 1;
+        expect(mem.eql(u8, array[0..], "boeu"));
+    }
 }
diff --git a/test/stage1/behavior/cast.zig b/test/stage1/behavior/cast.zig
index 98d987a73f..affd7afe5e 100644
--- a/test/stage1/behavior/cast.zig
+++ b/test/stage1/behavior/cast.zig
@@ -179,18 +179,24 @@ fn gimmeErrOrSlice() anyerror![]u8 {
 }
 
 test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
-    {
-        var data = "hi";
-        const slice = data[0..];
-        expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
-        expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
-    }
-    comptime {
-        var data = "hi";
-        const slice = data[0..];
-        expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
-        expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
-    }
+    const S = struct {
+        fn doTheTest() anyerror!void {
+            {
+                var data = "hi".*;
+                const slice = data[0..];
+                expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
+                expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
+            }
+            {
+                var data: [2]u8 = "hi".*;
+                const slice = data[0..];
+                expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
+                expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
+            }
+        }
+    };
+    try S.doTheTest();
+    try comptime S.doTheTest();
 }
 fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
     if (a) {
@@ -217,11 +223,20 @@ test "implicit cast from &const [N]T to []const T" {
 }
 
 fn testCastConstArrayRefToConstSlice() void {
-    const blah = "aoeu";
-    const const_array_ref = &blah;
-    expect(@typeOf(const_array_ref) == *const [4]u8);
-    const slice: []const u8 = const_array_ref;
-    expect(mem.eql(u8, slice, "aoeu"));
+    {
+        const blah = "aoeu".*;
+        const const_array_ref = &blah;
+        expect(@typeOf(const_array_ref) == *const [4]null u8);
+        const slice: []const u8 = const_array_ref;
+        expect(mem.eql(u8, slice, "aoeu"));
+    }
+    {
+        const blah: [4]u8 = "aoeu".*;
+        const const_array_ref = &blah;
+        expect(@typeOf(const_array_ref) == *const [4]u8);
+        const slice: []const u8 = const_array_ref;
+        expect(mem.eql(u8, slice, "aoeu"));
+    }
 }
 
 test "peer type resolution: error and [N]T" {
@@ -310,17 +325,28 @@ test "single-item pointer of array to slice and to unknown length pointer" {
 }
 
 fn testCastPtrOfArrayToSliceAndPtr() void {
-    var array = "aoeu";
-    const x: [*]u8 = &array;
-    x[0] += 1;
-    expect(mem.eql(u8, array[0..], "boeu"));
-    const y: []u8 = &array;
-    y[0] += 1;
-    expect(mem.eql(u8, array[0..], "coeu"));
+    {
+        var array = "aoeu".*;
+        const x: [*]u8 = &array;
+        x[0] += 1;
+        expect(mem.eql(u8, array[0..], "boeu"));
+        const y: []u8 = &array;
+        y[0] += 1;
+        expect(mem.eql(u8, array[0..], "coeu"));
+    }
+    {
+        var array: [4]u8 = "aoeu".*;
+        const x: [*]u8 = &array;
+        x[0] += 1;
+        expect(mem.eql(u8, array[0..], "boeu"));
+        const y: []u8 = &array;
+        y[0] += 1;
+        expect(mem.eql(u8, array[0..], "coeu"));
+    }
 }
 
 test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
-    const window_name = [1][*]const u8{c"window name"};
+    const window_name = [1][*]const u8{"window name"};
     const x: [*]const ?[*]const u8 = &window_name;
     expect(mem.eql(u8, std.mem.toSliceConst(u8, x[0].?), "window name"));
 }
@@ -545,7 +571,7 @@ test "implicit cast *[0]T to E![]const u8" {
 }
 
 test "peer cast *[0]T to E![]const T" {
-    var buffer: [5]u8 = "abcde";
+    var buffer: [5]u8 = "abcde".*;
     var buf: anyerror![]const u8 = buffer[0..];
     var b = false;
     var y = if (b) &[0]u8{} else buf;
@@ -553,7 +579,7 @@ test "peer cast *[0]T to E![]const T" {
 }
 
 test "peer cast *[0]T to []const T" {
-    var buffer: [5]u8 = "abcde";
+    var buffer: [5]u8 = "abcde".*;
     var buf: []const u8 = buffer[0..];
     var b = false;
     var y = if (b) &[0]u8{} else buf;
@@ -565,3 +591,33 @@ test "cast from array reference to fn" {
     const f = @ptrCast(extern fn () void, &global_array);
     expect(@ptrToInt(f) == @ptrToInt(&global_array));
 }
+
+test "*const [N]null u8 to ?[]const u8" {
+    const S = struct {
+        fn doTheTest() void {
+            var a = "Hello";
+            var b: ?[]const u8 = a;
+            expect(mem.eql(u8, b.?, "Hello"));
+        }
+    };
+    S.doTheTest();
+    comptime S.doTheTest();
+}
+
+test "peer resolution of string literals" {
+    const S = struct {
+        const E = extern enum { a, b, c, d};
+
+        fn doTheTest(e: E) void {
+            const cmd = switch (e) {
+                .a => "one",
+                .b => "two",
+                .c => "three",
+                .d => "four",
+            };
+            expect(mem.eql(u8, cmd, "two"));
+        }
+    };
+    S.doTheTest(.b);
+    comptime S.doTheTest(.b);
+}
diff --git a/test/stage1/behavior/const_slice_child.zig b/test/stage1/behavior/const_slice_child.zig
index 13713e1ee7..6720667187 100644
--- a/test/stage1/behavior/const_slice_child.zig
+++ b/test/stage1/behavior/const_slice_child.zig
@@ -6,12 +6,11 @@ var argv: [*]const [*]const u8 = undefined;
 
 test "const slice child" {
     const strs = [_][*]const u8{
-        c"one",
-        c"two",
-        c"three",
+        "one",
+        "two",
+        "three",
     };
-    // TODO this should implicitly cast
-    argv = @ptrCast([*]const [*]const u8, &strs);
+    argv = &strs;
     bar(strs.len);
 }
 
diff --git a/test/stage1/behavior/eval.zig b/test/stage1/behavior/eval.zig
index fa899d0cb2..b7bce26568 100644
--- a/test/stage1/behavior/eval.zig
+++ b/test/stage1/behavior/eval.zig
@@ -736,7 +736,7 @@ test "comptime pointer cast array and then slice" {
 
 test "slice bounds in comptime concatenation" {
     const bs = comptime blk: {
-        const b = c"........1........";
+        const b = "........1........";
         break :blk b[8..9];
     };
     const str = "" ++ bs;
diff --git a/test/stage1/behavior/misc.zig b/test/stage1/behavior/misc.zig
index 1a227a5b93..a0188dcedd 100644
--- a/test/stage1/behavior/misc.zig
+++ b/test/stage1/behavior/misc.zig
@@ -204,11 +204,11 @@ test "multiline string" {
 
 test "multiline C string" {
     const s1 =
-        c\\one
-        c\\two)
-        c\\three
+        \\one
+        \\two)
+        \\three
     ;
-    const s2 = c"one\ntwo)\nthree";
+    const s2 = "one\ntwo)\nthree";
     expect(std.cstr.cmp(s1, s2) == 0);
 }
 
@@ -358,9 +358,12 @@ fn ptrEql(a: *const []const u8, b: *const []const u8) bool {
     return a == b;
 }
 
-test "C string concatenation" {
-    const a = c"OK" ++ c" IT " ++ c"WORKED";
-    const b = c"OK IT WORKED";
+test "string concatenation" {
+    const a = "OK" ++ " IT " ++ "WORKED";
+    const b = "OK IT WORKED";
+
+    comptime expect(@typeOf(a) == *const [12]null u8);
+    comptime expect(@typeOf(b) == *const [12]null u8);
 
     const len = mem.len(u8, b);
     const len_with_null = len + 1;
diff --git a/test/stage1/behavior/pointers.zig b/test/stage1/behavior/pointers.zig
index fd11e68473..7d8bdea569 100644
--- a/test/stage1/behavior/pointers.zig
+++ b/test/stage1/behavior/pointers.zig
@@ -15,7 +15,7 @@ fn testDerefPtr() void {
 }
 
 test "pointer arithmetic" {
-    var ptr = c"abcd";
+    var ptr: [*]const u8 = "abcd";
 
     expect(ptr[0] == 'a');
     ptr += 1;
diff --git a/test/stage1/behavior/ptrcast.zig b/test/stage1/behavior/ptrcast.zig
index bf92888214..ddb5a63eee 100644
--- a/test/stage1/behavior/ptrcast.zig
+++ b/test/stage1/behavior/ptrcast.zig
@@ -60,7 +60,7 @@ test "comptime ptrcast keeps larger alignment" {
 }
 
 test "implicit optional pointer to optional c_void pointer" {
-    var buf: [4]u8 = "aoeu";
+    var buf: [4]u8 = "aoeu".*;
     var x: ?[*]u8 = &buf;
     var y: ?*c_void = x;
     var z = @ptrCast(*[4]u8, y);
diff --git a/test/stage1/behavior/slice.zig b/test/stage1/behavior/slice.zig
index d4a8353ca7..ea0a6fe9f4 100644
--- a/test/stage1/behavior/slice.zig
+++ b/test/stage1/behavior/slice.zig
@@ -36,7 +36,7 @@ fn assertLenIsZero(msg: []const u8) void {
 }
 
 test "C pointer" {
-    var buf: [*c]const u8 = c"kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
+    var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
     var len: u32 = 10;
     var slice = buf[0..len];
     expectEqualSlices(u8, "kjdhfkjdhf", slice);
diff --git a/test/stage1/behavior/struct.zig b/test/stage1/behavior/struct.zig
index 722f44d352..e42bd4e9d7 100644
--- a/test/stage1/behavior/struct.zig
+++ b/test/stage1/behavior/struct.zig
@@ -493,7 +493,7 @@ test "non-byte-aligned array inside packed struct" {
         fn doTheTest() void {
             var foo = Foo{
                 .a = true,
-                .b = "abcdefghijklmnopqurstu",
+                .b = "abcdefghijklmnopqurstu".*,
             };
             bar(foo.b);
         }
diff --git a/test/stage2/compare_output.zig b/test/stage2/compare_output.zig
index fdc3d49145..a86811b27b 100644
--- a/test/stage2/compare_output.zig
+++ b/test/stage2/compare_output.zig
@@ -6,7 +6,7 @@ pub fn addCases(ctx: *TestContext) !void {
     try ctx.testCompareOutputLibC(
         \\extern fn puts([*]const u8) void;
         \\export fn main() c_int {
-        \\    puts(c"Hello, world!");
+        \\    puts("Hello, world!");
         \\    return 0;
         \\}
     , "Hello, world!" ++ std.cstr.line_sep);
@@ -15,7 +15,7 @@ pub fn addCases(ctx: *TestContext) !void {
     try ctx.testCompareOutputLibC(
         \\extern fn puts(s: [*]const u8) void;
         \\export fn main() c_int {
-        \\    return foo(c"OK");
+        \\    return foo("OK");
         \\}
         \\fn foo(s: [*]const u8) c_int {
         \\    puts(s);
diff --git a/test/standalone/hello_world/hello_libc.zig b/test/standalone/hello_world/hello_libc.zig
index 05356bf529..c6f290f70e 100644
--- a/test/standalone/hello_world/hello_libc.zig
+++ b/test/standalone/hello_world/hello_libc.zig
@@ -5,7 +5,7 @@ const c = @cImport({
     @cInclude("string.h");
 });
 
-const msg = c"Hello, world!\n";
+const msg = "Hello, world!\n";
 
 export fn main(argc: c_int, argv: **u8) c_int {
     if (c.printf(msg) != @intCast(c_int, c.strlen(msg))) return -1;
diff --git a/test/translate_c.zig b/test/translate_c.zig
index f78e2181eb..f543fbc74e 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -47,7 +47,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub fn foo() void {
         \\    var a: c_int = undefined;
         \\    _ = 1;
-        \\    _ = c"hey";
+        \\    _ = "hey";
         \\    _ = (1 + 1);
         \\    _ = (1 - 1);
         \\    a = 1;
@@ -213,9 +213,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\}
     ,
         \\pub fn foo() void {
-        \\    _ = c"foo";
-        \\    _ = c"foo";
-        \\    _ = c"void foo(void)";
+        \\    _ = "foo";
+        \\    _ = "foo";
+        \\    _ = "void foo(void)";
         \\}
     );
 
@@ -232,7 +232,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub fn foo() void {
         \\    var a: c_int = undefined;
         \\    _ = 1;
-        \\    _ = c"hey";
+        \\    _ = "hey";
         \\    _ = (1 + 1);
         \\    _ = (1 - 1);
         \\    a = 1;
@@ -543,7 +543,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     cases.add("#define string",
         \\#define  foo  "a string"
     ,
-        \\pub const foo = c"a string";
+        \\pub const foo = "a string";
     );
 
     cases.add("__cdecl doesn't mess up function pointers",
@@ -617,9 +617,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\#define FOO2 "aoeu\x0007a derp"
         \\#define FOO_CHAR '\xfF'
     ,
-        \\pub const FOO = c"aoeu\xab derp";
+        \\pub const FOO = "aoeu\xab derp";
     ,
-        \\pub const FOO2 = c"aoeuz derp";
+        \\pub const FOO2 = "aoeuz derp";
     ,
         \\pub const FOO_CHAR = 255;
     );
@@ -629,9 +629,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\#define FOO2 "aoeu\0234 derp"
         \\#define FOO_CHAR '\077'
     ,
-        \\pub const FOO = c"aoeu\x13 derp";
+        \\pub const FOO = "aoeu\x13 derp";
     ,
-        \\pub const FOO2 = c"aoeu\x134 derp";
+        \\pub const FOO2 = "aoeu\x134 derp";
     ,
         \\pub const FOO_CHAR = 63;
     );
@@ -1351,7 +1351,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\}
     ,
         \\pub fn foo() [*c]const u8 {
-        \\    return c"bar";
+        \\    return "bar";
         \\}
     );
 
@@ -1523,7 +1523,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     cases.add("const ptr initializer",
         \\static const char *v0 = "0.0.0";
     ,
-        \\pub var v0: [*c]const u8 = c"0.0.0";
+        \\pub var v0: [*c]const u8 = "0.0.0";
     );
 
     cases.add("static incomplete array inside function",
@@ -1532,7 +1532,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\}
     ,
         \\pub fn foo() void {
-        \\    const v2: [*c]const u8 = c"2.2.2";
+        \\    const v2: [*c]const u8 = "2.2.2";
         \\}
     );
 
@@ -1809,7 +1809,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    var i: u8 = @as(u8, '\x0b');
         \\    var j: u8 = @as(u8, '\x00');
         \\    var k: u8 = @as(u8, '\"');
-        \\    return c"\'\\\x07\x08\x0c\n\r\t\x0b\x00\"";
+        \\    return "\'\\\x07\x08\x0c\n\r\t\x0b\x00\"";
         \\}
         \\
     );
-- 
cgit v1.2.3


From 7597735badd1f6aa6750f354a7e9c85fec705c55 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 23 Nov 2019 04:45:35 -0500
Subject: update the stage1 implementation to the new proposal

See #3731
---
 lib/std/builtin.zig                |  14 +-
 lib/std/c.zig                      |   2 +-
 lib/std/mem.zig                    |   2 +-
 lib/std/zig/parser_test.zig        |   6 +-
 src/all_types.hpp                  |  27 ++-
 src/analyze.cpp                    | 221 +++++++++---------
 src/analyze.hpp                    |   6 +-
 src/ast_render.cpp                 |   4 +-
 src/codegen.cpp                    |  27 ++-
 src/dump_analysis.cpp              |   4 -
 src/ir.cpp                         | 454 +++++++++++++++++++++++++------------
 src/parser.cpp                     | 184 +++++++++------
 src/tokenizer.cpp                  |  69 +-----
 src/tokenizer.hpp                  |   3 -
 src/translate_c.cpp                |   6 +-
 test/stage1/behavior/array.zig     |   2 +-
 test/stage1/behavior/cast.zig      |   2 +-
 test/stage1/behavior/misc.zig      |   4 +-
 test/stage1/behavior/pointers.zig  |   2 +-
 test/stage1/behavior/type.zig      |   8 +-
 test/stage1/behavior/type_info.zig |  10 +-
 21 files changed, 614 insertions(+), 443 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 56c3426d8b..64fc68e4cc 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -144,7 +144,12 @@ pub const TypeInfo = union(enum) {
         alignment: comptime_int,
         child: type,
         is_allowzero: bool,
-        is_null_terminated: bool,
+        /// The type of the sentinel is the element type of the pointer, which is
+        /// the value of the `child` field in this struct. However there is no way
+        /// to refer to that type here, so this is a pointer to an opaque value.
+        /// It will be known at compile-time to be the correct type. Dereferencing
+        /// this pointer will work at compile-time.
+        sentinel: ?*const c_void,
 
         /// This data structure is used by the Zig language code generation and
         /// therefore must be kept in sync with the compiler implementation.
@@ -161,7 +166,12 @@ pub const TypeInfo = union(enum) {
     pub const Array = struct {
         len: comptime_int,
         child: type,
-        is_null_terminated: bool,
+        /// The type of the sentinel is the element type of the array, which is
+        /// the value of the `child` field in this struct. However there is no way
+        /// to refer to that type here, so this is a pointer to an opaque value.
+        /// It will be known at compile-time to be the correct type. Dereferencing
+        /// this pointer will work at compile-time.
+        sentinel: ?*const c_void,
     };
 
     /// This data structure is used by the Zig language code generation and
diff --git a/lib/std/c.zig b/lib/std/c.zig
index 1faf45a489..fac13efc69 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -63,7 +63,7 @@ pub extern "c" fn fclose(stream: *FILE) c_int;
 pub extern "c" fn fwrite(ptr: [*]const u8, size_of_type: usize, item_count: usize, stream: *FILE) usize;
 pub extern "c" fn fread(ptr: [*]u8, size_of_type: usize, item_count: usize, stream: *FILE) usize;
 
-pub extern "c" fn printf(format: [*]null const u8, ...) c_int;
+pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
 pub extern "c" fn abort() noreturn;
 pub extern "c" fn exit(code: c_int) noreturn;
 pub extern "c" fn isatty(fd: fd_t) c_int;
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 160b8e6e5e..f790dd683b 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1409,7 +1409,7 @@ fn BytesAsValueReturnType(comptime T: type, comptime B: type) type {
     const size = @as(usize, @sizeOf(T));
 
     if (comptime !trait.is(builtin.TypeId.Pointer)(B) or
-        (meta.Child(B) != [size]u8 and meta.Child(B) != [size]null u8))
+        (meta.Child(B) != [size]u8 and meta.Child(B) != [size:0]u8))
     {
         @compileError("expected *[N]u8 " ++ ", passed " ++ @typeName(B));
     }
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index ebe396e145..ce19588722 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -1552,7 +1552,7 @@ test "zig fmt: pointer attributes" {
         \\extern fn f2(s: **align(1) *const *volatile u8) c_int;
         \\extern fn f3(s: *align(1) const *align(1) volatile *const volatile u8) c_int;
         \\extern fn f4(s: *align(1) const volatile u8) c_int;
-        \\extern fn f5(s: [*]null align(1) const volatile u8) c_int;
+        \\extern fn f5(s: [*:0]align(1) const volatile u8) c_int;
         \\
     );
 }
@@ -1563,7 +1563,7 @@ test "zig fmt: slice attributes" {
         \\extern fn f2(s: **align(1) *const *volatile u8) c_int;
         \\extern fn f3(s: *align(1) const *align(1) volatile *const volatile u8) c_int;
         \\extern fn f4(s: *align(1) const volatile u8) c_int;
-        \\extern fn f5(s: [*]null align(1) const volatile u8) c_int;
+        \\extern fn f5(s: [*:0]align(1) const volatile u8) c_int;
         \\
     );
 }
@@ -1885,7 +1885,7 @@ test "zig fmt: arrays" {
         \\        2,
         \\    };
         \\    const a: [0]u8 = []u8{};
-        \\    const x: [4]null u8 = undefined;
+        \\    const x: [4:0]u8 = undefined;
         \\}
         \\
     );
diff --git a/src/all_types.hpp b/src/all_types.hpp
index 4047a7d4a5..1f785a63f3 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -55,7 +55,6 @@ enum PtrLen {
     PtrLenUnknown,
     PtrLenSingle,
     PtrLenC,
-    PtrLenNull,
 };
 
 // This one corresponds to the builtin.zig enum.
@@ -353,19 +352,20 @@ struct LazyValueSliceType {
     LazyValue base;
 
     IrAnalyze *ira;
+    IrInstruction *sentinel; // can be null
     IrInstruction *elem_type;
     IrInstruction *align_inst; // can be null
 
     bool is_const;
     bool is_volatile;
     bool is_allowzero;
-    bool is_null_terminated;
 };
 
 struct LazyValuePtrType {
     LazyValue base;
 
     IrAnalyze *ira;
+    IrInstruction *sentinel; // can be null
     IrInstruction *elem_type;
     IrInstruction *align_inst; // can be null
 
@@ -821,6 +821,7 @@ struct AstNodePrefixOpExpr {
 
 struct AstNodePointerType {
     Token *star_token;
+    AstNode *sentinel;
     AstNode *align_expr;
     BigInt *bit_offset_start;
     BigInt *host_int_bytes;
@@ -828,21 +829,21 @@ struct AstNodePointerType {
     Token *allow_zero_token;
     bool is_const;
     bool is_volatile;
-    bool is_null_terminated;
 };
 
 struct AstNodeInferredArrayType {
+    AstNode *sentinel; // can be null
     AstNode *child_type;
 };
 
 struct AstNodeArrayType {
     AstNode *size;
+    AstNode *sentinel;
     AstNode *child_type;
     AstNode *align_expr;
     Token *allow_zero_token;
     bool is_const;
     bool is_volatile;
-    bool is_null_terminated;
 };
 
 struct AstNodeUsingNamespace {
@@ -1208,6 +1209,11 @@ struct ZigTypePointer {
     // struct.
     InferredStructField *inferred_struct_field;
 
+    // This can be null. If it is non-null, it means the pointer is terminated by this
+    // sentinel value. This is most commonly used for C-style strings, with a 0 byte
+    // to specify the length of the memory pointed to.
+    ConstExprValue *sentinel;
+
     PtrLen ptr_len;
     uint32_t explicit_alignment; // 0 means use ABI alignment
 
@@ -1235,7 +1241,7 @@ struct ZigTypeFloat {
 struct ZigTypeArray {
     ZigType *child_type;
     uint64_t len;
-    bool is_null_terminated;
+    ConstExprValue *sentinel;
 };
 
 struct TypeStructField {
@@ -1761,8 +1767,10 @@ struct TypeId {
 
     union {
         struct {
+            CodeGen *codegen;
             ZigType *child_type;
             InferredStructField *inferred_struct_field;
+            ConstExprValue *sentinel;
             PtrLen ptr_len;
             uint32_t alignment;
 
@@ -1775,9 +1783,10 @@ struct TypeId {
             bool allow_zero;
         } pointer;
         struct {
+            CodeGen *codegen;
             ZigType *child_type;
             uint64_t size;
-            bool is_null_terminated;
+            ConstExprValue *sentinel;
         } array;
         struct {
             bool is_signed;
@@ -2033,6 +2042,7 @@ struct CodeGen {
     IrInstruction *invalid_instruction;
     IrInstruction *unreach_instruction;
 
+    ConstExprValue const_zero_byte;
     ConstExprValue const_void_val;
     ConstExprValue panic_msg_vals[PanicMsgIdCount];
 
@@ -2989,13 +2999,14 @@ struct IrInstructionArrayType {
     IrInstruction base;
 
     IrInstruction *size;
+    IrInstruction *sentinel;
     IrInstruction *child_type;
-    bool is_null_terminated;
 };
 
 struct IrInstructionPtrType {
     IrInstruction base;
 
+    IrInstruction *sentinel;
     IrInstruction *align_value;
     IrInstruction *child_type;
     uint32_t bit_offset_start;
@@ -3015,12 +3026,12 @@ struct IrInstructionAnyFrameType {
 struct IrInstructionSliceType {
     IrInstruction base;
 
+    IrInstruction *sentinel;
     IrInstruction *align_value;
     IrInstruction *child_type;
     bool is_const;
     bool is_volatile;
     bool is_allow_zero;
-    bool is_null_terminated;
 };
 
 struct IrInstructionGlobalAsm {
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 9c42177d11..aa58d64aa4 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -452,20 +452,6 @@ ZigType *get_any_frame_type(CodeGen *g, ZigType *result_type) {
     return entry;
 }
 
-static const char *ptr_len_to_star_str(PtrLen ptr_len) {
-    switch (ptr_len) {
-        case PtrLenSingle:
-            return "*";
-        case PtrLenUnknown:
-            return "[*]";
-        case PtrLenC:
-            return "[*c]";
-        case PtrLenNull:
-            return "[*]null ";
-    }
-    zig_unreachable();
-}
-
 ZigType *get_fn_frame_type(CodeGen *g, ZigFn *fn) {
     if (fn->frame_type != nullptr) {
         return fn->frame_type;
@@ -485,10 +471,47 @@ ZigType *get_fn_frame_type(CodeGen *g, ZigFn *fn) {
     return entry;
 }
 
+static void append_ptr_type_attrs(Buf *type_name, ZigType *ptr_type) {
+    const char *const_str = ptr_type->data.pointer.is_const ? "const " : "";
+    const char *volatile_str = ptr_type->data.pointer.is_volatile ? "volatile " : "";
+    const char *allow_zero_str;
+    if (ptr_type->data.pointer.ptr_len == PtrLenC) {
+        assert(ptr_type->data.pointer.allow_zero);
+        allow_zero_str = "";
+    } else {
+        allow_zero_str = ptr_type->data.pointer.allow_zero ? "allowzero " : "";
+    }
+    if (ptr_type->data.pointer.explicit_alignment != 0 || ptr_type->data.pointer.host_int_bytes != 0 ||
+            ptr_type->data.pointer.vector_index != VECTOR_INDEX_NONE)
+    {
+        buf_appendf(type_name, "align(");
+        if (ptr_type->data.pointer.explicit_alignment != 0) {
+            buf_appendf(type_name, "%" PRIu32, ptr_type->data.pointer.explicit_alignment);
+        }
+        if (ptr_type->data.pointer.host_int_bytes != 0) {
+            buf_appendf(type_name, ":%" PRIu32 ":%" PRIu32, ptr_type->data.pointer.bit_offset_in_host, ptr_type->data.pointer.host_int_bytes);
+        }
+        if (ptr_type->data.pointer.vector_index == VECTOR_INDEX_RUNTIME) {
+            buf_appendf(type_name, ":?");
+        } else if (ptr_type->data.pointer.vector_index != VECTOR_INDEX_NONE) {
+            buf_appendf(type_name, ":%" PRIu32, ptr_type->data.pointer.vector_index);
+        }
+        buf_appendf(type_name, ")");
+    }
+    buf_appendf(type_name, "%s%s%s", const_str, volatile_str, allow_zero_str);
+    if (ptr_type->data.pointer.inferred_struct_field != nullptr) {
+        buf_appendf(type_name, " field '%s' of %s)",
+                buf_ptr(ptr_type->data.pointer.inferred_struct_field->field_name),
+                buf_ptr(&ptr_type->data.pointer.inferred_struct_field->inferred_struct_type->name));
+    } else {
+        buf_appendf(type_name, "%s", buf_ptr(&ptr_type->data.pointer.child_type->name));
+    }
+}
+
 ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type, bool is_const,
         bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment,
         uint32_t bit_offset_in_host, uint32_t host_int_bytes, bool allow_zero,
-        uint32_t vector_index, InferredStructField *inferred_struct_field)
+        uint32_t vector_index, InferredStructField *inferred_struct_field, ConstExprValue *sentinel)
 {
     assert(ptr_len != PtrLenC || allow_zero);
     assert(!type_is_invalid(child_type));
@@ -511,9 +534,11 @@ ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type, bool is_con
     TypeId type_id = {};
     ZigType **parent_pointer = nullptr;
     if (host_int_bytes != 0 || is_volatile || byte_alignment != 0 || ptr_len != PtrLenSingle ||
-        allow_zero || vector_index != VECTOR_INDEX_NONE || inferred_struct_field != nullptr)
+        allow_zero || vector_index != VECTOR_INDEX_NONE || inferred_struct_field != nullptr ||
+        sentinel != nullptr)
     {
         type_id.id = ZigTypeIdPointer;
+        type_id.data.pointer.codegen = g;
         type_id.data.pointer.child_type = child_type;
         type_id.data.pointer.is_const = is_const;
         type_id.data.pointer.is_volatile = is_volatile;
@@ -524,6 +549,7 @@ ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type, bool is_con
         type_id.data.pointer.allow_zero = allow_zero;
         type_id.data.pointer.vector_index = vector_index;
         type_id.data.pointer.inferred_struct_field = inferred_struct_field;
+        type_id.data.pointer.sentinel = sentinel;
 
         auto existing_entry = g->type_table.maybe_get(type_id);
         if (existing_entry)
@@ -539,57 +565,36 @@ ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type, bool is_con
 
     ZigType *entry = new_type_table_entry(ZigTypeIdPointer);
 
-    const char *star_str = ptr_len_to_star_str(ptr_len);
-    const char *const_str = is_const ? "const " : "";
-    const char *volatile_str = is_volatile ? "volatile " : "";
-    const char *allow_zero_str;
-    if (ptr_len == PtrLenC) {
-        assert(allow_zero);
-        allow_zero_str = "";
-    } else {
-        allow_zero_str = allow_zero ? "allowzero " : "";
-    }
     buf_resize(&entry->name, 0);
-    if (host_int_bytes == 0 && byte_alignment == 0 && vector_index == VECTOR_INDEX_NONE) {
-        if (inferred_struct_field == nullptr) {
-            buf_appendf(&entry->name, "%s%s%s%s%s",
-                    star_str, const_str, volatile_str, allow_zero_str, buf_ptr(&child_type->name));
-        } else {
-            buf_appendf(&entry->name, "(%s%s%s%s field '%s' of %s)",
-                    star_str, const_str, volatile_str, allow_zero_str,
-                    buf_ptr(inferred_struct_field->field_name),
-                    buf_ptr(&inferred_struct_field->inferred_struct_type->name));
-        }
-    } else if (host_int_bytes == 0 && vector_index == VECTOR_INDEX_NONE) {
-        buf_appendf(&entry->name, "%salign(%" PRIu32 ") %s%s%s%s", star_str, byte_alignment,
-                const_str, volatile_str, allow_zero_str, buf_ptr(&child_type->name));
-    } else if (byte_alignment == 0) {
-        assert(vector_index == VECTOR_INDEX_NONE);
-        buf_appendf(&entry->name, "%salign(:%" PRIu32 ":%" PRIu32 ") %s%s%s%s",
-                star_str,
-                bit_offset_in_host, host_int_bytes,
-                const_str, volatile_str, allow_zero_str,
-                buf_ptr(&child_type->name));
-    } else if (vector_index == VECTOR_INDEX_NONE) {
-        buf_appendf(&entry->name, "%salign(%" PRIu32 ":%" PRIu32 ":%" PRIu32 ") %s%s%s%s",
-                star_str, byte_alignment,
-                bit_offset_in_host, host_int_bytes,
-                const_str, volatile_str, allow_zero_str,
-                buf_ptr(&child_type->name));
-    } else if (vector_index == VECTOR_INDEX_RUNTIME) {
-        buf_appendf(&entry->name, "%salign(%" PRIu32 ":%" PRIu32 ":%" PRIu32 ":?) %s%s%s%s",
-                star_str, byte_alignment,
-                bit_offset_in_host, host_int_bytes,
-                const_str, volatile_str, allow_zero_str,
-                buf_ptr(&child_type->name));
-    } else {
-        buf_appendf(&entry->name, "%salign(%" PRIu32 ":%" PRIu32 ":%" PRIu32 ":%" PRIu32 ") %s%s%s%s",
-                star_str, byte_alignment,
-                bit_offset_in_host, host_int_bytes, vector_index,
-                const_str, volatile_str, allow_zero_str,
-                buf_ptr(&child_type->name));
+    if (inferred_struct_field != nullptr) {
+        buf_appendf(&entry->name, "(");
+    }
+    switch (ptr_len) {
+        case PtrLenSingle:
+            buf_appendf(&entry->name, "*");
+            break;
+        case PtrLenUnknown:
+            buf_appendf(&entry->name, "[*");
+            break;
+        case PtrLenC:
+            assert(sentinel == nullptr);
+            buf_appendf(&entry->name, "[*c]");
+            break;
+    }
+    if (sentinel != nullptr) {
+        buf_appendf(&entry->name, ":");
+        render_const_value(g, &entry->name, sentinel);
+    }
+    switch (ptr_len) {
+        case PtrLenSingle:
+        case PtrLenC:
+            break;
+        case PtrLenUnknown:
+            buf_appendf(&entry->name, "]");
+            break;
     }
 
+
     if (type_is_resolved(child_type, ResolveStatusZeroBitsKnown)) {
         if (type_has_bits(child_type)) {
             entry->abi_size = g->builtin_types.entry_usize->abi_size;
@@ -617,6 +622,9 @@ ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type, bool is_con
     entry->data.pointer.allow_zero = allow_zero;
     entry->data.pointer.vector_index = vector_index;
     entry->data.pointer.inferred_struct_field = inferred_struct_field;
+    entry->data.pointer.sentinel = sentinel;
+
+    append_ptr_type_attrs(&entry->name, entry);
 
     if (parent_pointer) {
         *parent_pointer = entry;
@@ -631,12 +639,12 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
         uint32_t bit_offset_in_host, uint32_t host_int_bytes, bool allow_zero)
 {
     return get_pointer_to_type_extra2(g, child_type, is_const, is_volatile, ptr_len,
-            byte_alignment, bit_offset_in_host, host_int_bytes, allow_zero, VECTOR_INDEX_NONE, nullptr);
+            byte_alignment, bit_offset_in_host, host_int_bytes, allow_zero, VECTOR_INDEX_NONE, nullptr, nullptr);
 }
 
 ZigType *get_pointer_to_type(CodeGen *g, ZigType *child_type, bool is_const) {
     return get_pointer_to_type_extra2(g, child_type, is_const, false, PtrLenSingle, 0, 0, 0, false,
-            VECTOR_INDEX_NONE, nullptr);
+            VECTOR_INDEX_NONE, nullptr, nullptr);
 }
 
 ZigType *get_optional_type(CodeGen *g, ZigType *child_type) {
@@ -752,12 +760,13 @@ ZigType *get_error_union_type(CodeGen *g, ZigType *err_set_type, ZigType *payloa
     return entry;
 }
 
-ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, bool is_null_terminated) {
+ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, ConstExprValue *sentinel) {
     TypeId type_id = {};
     type_id.id = ZigTypeIdArray;
+    type_id.data.array.codegen = g;
     type_id.data.array.child_type = child_type;
     type_id.data.array.size = array_size;
-    type_id.data.array.is_null_terminated = is_null_terminated;
+    type_id.data.array.sentinel = sentinel;
     auto existing_entry = g->type_table.maybe_get(type_id);
     if (existing_entry) {
         return existing_entry->value;
@@ -767,16 +776,19 @@ ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, bo
 
     ZigType *entry = new_type_table_entry(ZigTypeIdArray);
 
-    const char *null_str = is_null_terminated ? "null " : "";
-
     buf_resize(&entry->name, 0);
-    buf_appendf(&entry->name, "[%" ZIG_PRI_u64 "]%s%s", array_size, null_str, buf_ptr(&child_type->name));
+    buf_appendf(&entry->name, "[%" ZIG_PRI_u64, array_size);
+    if (sentinel != nullptr) {
+        buf_appendf(&entry->name, ":");
+        render_const_value(g, &entry->name, sentinel);
+    }
+    buf_appendf(&entry->name, "]%s", buf_ptr(&child_type->name));
 
     size_t full_array_size;
     if (array_size == 0) {
         full_array_size = 0;
     } else {
-        full_array_size = array_size + (is_null_terminated ? 1 : 0);
+        full_array_size = array_size + ((sentinel != nullptr) ? 1 : 0);
     }
 
     entry->size_in_bits = child_type->size_in_bits * full_array_size;
@@ -785,7 +797,7 @@ ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, bo
 
     entry->data.array.child_type = child_type;
     entry->data.array.len = array_size;
-    entry->data.array.is_null_terminated = is_null_terminated;
+    entry->data.array.sentinel = sentinel;
 
     g->type_table.put(type_id, entry);
     return entry;
@@ -793,7 +805,7 @@ ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, bo
 
 ZigType *get_slice_type(CodeGen *g, ZigType *ptr_type) {
     assert(ptr_type->id == ZigTypeIdPointer);
-    assert(ptr_type->data.pointer.ptr_len == PtrLenUnknown || ptr_type->data.pointer.ptr_len == PtrLenNull);
+    assert(ptr_type->data.pointer.ptr_len == PtrLenUnknown);
 
     ZigType **parent_pointer = &ptr_type->data.pointer.slice_parent;
     if (*parent_pointer) {
@@ -802,10 +814,14 @@ ZigType *get_slice_type(CodeGen *g, ZigType *ptr_type) {
 
     ZigType *entry = new_type_table_entry(ZigTypeIdStruct);
 
-    // replace the & with [] to go from a ptr type name to a slice type name
     buf_resize(&entry->name, 0);
-    size_t name_offset = (ptr_type->data.pointer.ptr_len == PtrLenSingle) ? 1 : 3;
-    buf_appendf(&entry->name, "[]%s", buf_ptr(&ptr_type->name) + name_offset);
+    buf_appendf(&entry->name, "[");
+    if (ptr_type->data.pointer.sentinel != nullptr) {
+        buf_appendf(&entry->name, ":");
+        render_const_value(g, &entry->name, ptr_type->data.pointer.sentinel);
+    }
+    buf_appendf(&entry->name, "]");
+    append_ptr_type_attrs(&entry->name, ptr_type);
 
     unsigned element_count = 2;
     Buf *ptr_field_name = buf_create_from_str("ptr");
@@ -5639,14 +5655,14 @@ void init_const_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *str) {
     // first we build the underlying array
     ConstExprValue *array_val = create_const_vals(1);
     array_val->special = ConstValSpecialStatic;
-    array_val->type = get_array_type(g, g->builtin_types.entry_u8, buf_len(str), true);
+    array_val->type = get_array_type(g, g->builtin_types.entry_u8, buf_len(str), &g->const_zero_byte);
     array_val->data.x_array.special = ConstArraySpecialBuf;
     array_val->data.x_array.data.s_buf = str;
 
     // then make the pointer point to it
     const_val->special = ConstValSpecialStatic;
     const_val->type = get_pointer_to_type_extra2(g, array_val->type, true, false,
-            PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, nullptr);
+            PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, nullptr, nullptr);
     const_val->data.x_ptr.special = ConstPtrSpecialRef;
     const_val->data.x_ptr.data.ref.pointee = array_val;
 
@@ -6079,7 +6095,7 @@ static Error resolve_async_frame(CodeGen *g, ZigType *frame_type) {
 
             fields.append({"@stack_trace", get_stack_trace_type(g), 0});
             fields.append({"@instruction_addresses",
-                    get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count, false), 0});
+                    get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count, nullptr), 0});
         }
 
         frame_type->data.frame.locals_struct = get_struct_type(g, buf_ptr(&frame_type->name),
@@ -6287,7 +6303,7 @@ static Error resolve_async_frame(CodeGen *g, ZigType *frame_type) {
     if (codegen_fn_has_err_ret_tracing_stack(g, fn, true)) {
         fields.append({"@stack_trace", get_stack_trace_type(g), 0});
         fields.append({"@instruction_addresses",
-                get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count, false), 0});
+                get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count, nullptr), 0});
     }
 
     for (size_t alloca_i = 0; alloca_i < fn->alloca_gen_list.length; alloca_i += 1) {
@@ -7050,11 +7066,12 @@ uint32_t type_id_hash(TypeId x) {
                 (((uint32_t)x.data.pointer.alignment) ^ (uint32_t)0x777fbe0e) +
                 (((uint32_t)x.data.pointer.bit_offset_in_host) ^ (uint32_t)2639019452) +
                 (((uint32_t)x.data.pointer.vector_index) ^ (uint32_t)0x19199716) +
-                (((uint32_t)x.data.pointer.host_int_bytes) ^ (uint32_t)529908881);
+                (((uint32_t)x.data.pointer.host_int_bytes) ^ (uint32_t)529908881) *
+                (x.data.pointer.sentinel ? hash_const_val(x.data.pointer.sentinel) : (uint32_t)2955491856);
         case ZigTypeIdArray:
             return hash_ptr(x.data.array.child_type) *
                 ((uint32_t)x.data.array.size ^ (uint32_t)2122979968) *
-                ((uint32_t)x.data.array.is_null_terminated ^ (uint32_t)2048352596);
+                (x.data.array.sentinel ? hash_const_val(x.data.array.sentinel) : (uint32_t)1927201585);
         case ZigTypeIdInt:
             return (x.data.integer.is_signed ? (uint32_t)2652528194 : (uint32_t)163929201) +
                     (((uint32_t)x.data.integer.bit_count) ^ (uint32_t)2998081557);
@@ -7105,6 +7122,11 @@ bool type_id_eql(TypeId a, TypeId b) {
                 a.data.pointer.bit_offset_in_host == b.data.pointer.bit_offset_in_host &&
                 a.data.pointer.vector_index == b.data.pointer.vector_index &&
                 a.data.pointer.host_int_bytes == b.data.pointer.host_int_bytes &&
+                (
+                    a.data.pointer.sentinel == b.data.pointer.sentinel ||
+                    (a.data.pointer.sentinel != nullptr && b.data.pointer.sentinel != nullptr &&
+                     const_values_equal(a.data.pointer.codegen, a.data.pointer.sentinel, b.data.pointer.sentinel))
+                ) &&
                 (
                     a.data.pointer.inferred_struct_field == b.data.pointer.inferred_struct_field ||
                     (a.data.pointer.inferred_struct_field != nullptr &&
@@ -7117,7 +7139,11 @@ bool type_id_eql(TypeId a, TypeId b) {
         case ZigTypeIdArray:
             return a.data.array.child_type == b.data.array.child_type &&
                 a.data.array.size == b.data.array.size &&
-                a.data.array.is_null_terminated == b.data.array.is_null_terminated;
+                (
+                    a.data.array.sentinel == b.data.array.sentinel ||
+                    (a.data.array.sentinel != nullptr && b.data.array.sentinel != nullptr &&
+                     const_values_equal(a.data.array.codegen, a.data.array.sentinel, b.data.array.sentinel))
+                );
         case ZigTypeIdInt:
             return a.data.integer.is_signed == b.data.integer.is_signed &&
                 a.data.integer.bit_count == b.data.integer.bit_count;
@@ -8303,7 +8329,7 @@ static void resolve_llvm_types_union(CodeGen *g, ZigType *union_type, ResolveSta
         size_t padding_bytes = union_type->data.unionation.union_abi_size - most_aligned_union_member->type_entry->abi_size;
         if (padding_bytes > 0) {
             ZigType *u8_type = get_int_type(g, false, 8);
-            ZigType *padding_array = get_array_type(g, u8_type, padding_bytes, false);
+            ZigType *padding_array = get_array_type(g, u8_type, padding_bytes, nullptr);
             LLVMTypeRef union_element_types[] = {
                 most_aligned_union_member->type_entry->llvm_type,
                 get_llvm_type(g, padding_array),
@@ -8337,7 +8363,7 @@ static void resolve_llvm_types_union(CodeGen *g, ZigType *union_type, ResolveSta
         union_type_ref = get_llvm_type(g, most_aligned_union_member->type_entry);
     } else {
         ZigType *u8_type = get_int_type(g, false, 8);
-        ZigType *padding_array = get_array_type(g, u8_type, padding_bytes, false);
+        ZigType *padding_array = get_array_type(g, u8_type, padding_bytes, nullptr);
         LLVMTypeRef union_element_types[] = {
             get_llvm_type(g, most_aligned_union_member->type_entry),
             get_llvm_type(g, padding_array),
@@ -8418,19 +8444,19 @@ static void resolve_llvm_types_pointer(CodeGen *g, ZigType *type, ResolveStatus
     if (type->data.pointer.is_const || type->data.pointer.is_volatile ||
         type->data.pointer.explicit_alignment != 0 || type->data.pointer.ptr_len != PtrLenSingle ||
         type->data.pointer.bit_offset_in_host != 0 || type->data.pointer.allow_zero ||
-        type->data.pointer.vector_index != VECTOR_INDEX_NONE)
+        type->data.pointer.vector_index != VECTOR_INDEX_NONE || type->data.pointer.sentinel != nullptr)
     {
         assertNoError(type_resolve(g, elem_type, ResolveStatusLLVMFwdDecl));
         ZigType *peer_type;
         if (type->data.pointer.vector_index == VECTOR_INDEX_NONE) {
             peer_type = get_pointer_to_type_extra2(g, elem_type, false, false,
                 PtrLenSingle, 0, 0, type->data.pointer.host_int_bytes, false,
-                VECTOR_INDEX_NONE, nullptr);
+                VECTOR_INDEX_NONE, nullptr, nullptr);
         } else {
             uint32_t host_vec_len = type->data.pointer.host_int_bytes;
             ZigType *host_vec_type = get_vector_type(g, host_vec_len, elem_type);
             peer_type = get_pointer_to_type_extra2(g, host_vec_type, false, false,
-                PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, nullptr);
+                PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, nullptr, nullptr);
         }
         type->llvm_type = get_llvm_type(g, peer_type);
         type->llvm_di_type = get_llvm_di_type(g, peer_type);
@@ -8659,8 +8685,8 @@ static void resolve_llvm_types_array(CodeGen *g, ZigType *type) {
 
     ZigType *elem_type = type->data.array.child_type;
 
-    uint64_t extra_len_from_null = type->data.array.is_null_terminated ? 1 : 0;
-    uint64_t full_len = type->data.array.len + extra_len_from_null;
+    uint64_t extra_len_from_sentinel = (type->data.array.sentinel != nullptr) ? 1 : 0;
+    uint64_t full_len = type->data.array.len + extra_len_from_sentinel;
     // TODO https://github.com/ziglang/zig/issues/1424
     type->llvm_type = LLVMArrayType(get_llvm_type(g, elem_type), (unsigned)full_len);
 
@@ -9166,16 +9192,3 @@ void IrExecutable::src() {
         it->source_node->src();
     }
 }
-
-ConstExprValue *get_null_value(ZigType *ty) {
-    if (ty->id == ZigTypeIdInt || ty->id == ZigTypeIdComptimeInt) {
-        return create_const_unsigned_negative(ty, 0, false);
-    } else if (ty->id == ZigTypeIdFloat || ty->id == ZigTypeIdComptimeFloat) {
-        return create_const_float(ty, NAN);
-    } else if (ty->id == ZigTypeIdOptional) {
-        return create_const_null(ty);
-    } else {
-        zig_unreachable();
-    }
-}
-
diff --git a/src/analyze.hpp b/src/analyze.hpp
index a3d4621178..fcf993eac4 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -24,7 +24,8 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type,
 ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type,
         bool is_const, bool is_volatile, PtrLen ptr_len,
         uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count,
-        bool allow_zero, uint32_t vector_index, InferredStructField *inferred_struct_field);
+        bool allow_zero, uint32_t vector_index, InferredStructField *inferred_struct_field,
+        ConstExprValue *sentinel);
 uint64_t type_size(CodeGen *g, ZigType *type_entry);
 uint64_t type_size_bits(CodeGen *g, ZigType *type_entry);
 ZigType *get_int_type(CodeGen *g, bool is_signed, uint32_t size_in_bits);
@@ -33,7 +34,7 @@ ZigType **get_c_int_type_ptr(CodeGen *g, CIntType c_int_type);
 ZigType *get_c_int_type(CodeGen *g, CIntType c_int_type);
 ZigType *get_fn_type(CodeGen *g, FnTypeId *fn_type_id);
 ZigType *get_optional_type(CodeGen *g, ZigType *child_type);
-ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, bool is_null_terminated);
+ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size, ConstExprValue *sentinel);
 ZigType *get_slice_type(CodeGen *g, ZigType *ptr_type);
 ZigType *get_partial_container_type(CodeGen *g, Scope *scope, ContainerKind kind,
         AstNode *decl_node, const char *full_name, Buf *bare_name, ContainerLayout layout);
@@ -276,5 +277,4 @@ IrInstruction *ir_create_alloca(CodeGen *g, Scope *scope, AstNode *source_node,
 Error analyze_import(CodeGen *codegen, ZigType *source_import, Buf *import_target_str,
         ZigType **out_import, Buf **out_import_target_path, Buf *out_full_path);
 ConstExprValue *get_the_one_possible_value(CodeGen *g, ZigType *type_entry);
-ConstExprValue *get_null_value(ZigType *ty);
 #endif
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index 53388fa033..f4f97c3730 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -147,9 +147,9 @@ static const char *token_to_ptr_len_str(Token *tok) {
         case TokenIdStar:
         case TokenIdStarStar:
             return "*";
-        case TokenIdBracketStarBracket:
+        case TokenIdLBracket:
             return "[*]";
-        case TokenIdBracketStarCBracket:
+        case TokenIdSymbol:
             return "[*c]";
         default:
             zig_unreachable();
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 4fc3b968c1..9a269ec41f 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -3707,8 +3707,8 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutable *executable, IrI
             array_type = array_type->data.pointer.child_type;
         }
         if (safety_check_on) {
-            uint64_t extra_len_from_null = array_type->data.array.is_null_terminated ? 1 : 0;
-            uint64_t full_len = array_type->data.array.len + extra_len_from_null;
+            uint64_t extra_len_from_sentinel = (array_type->data.array.sentinel != nullptr) ? 1 : 0;
+            uint64_t full_len = array_type->data.array.len + extra_len_from_sentinel;
             LLVMValueRef end = LLVMConstInt(g->builtin_types.entry_usize->llvm_type, full_len, false);
             add_bounds_check(g, subscript_value, LLVMIntEQ, nullptr, LLVMIntULT, end);
         }
@@ -6636,8 +6636,8 @@ static LLVMValueRef gen_const_val_ptr(CodeGen *g, ConstExprValue *const_val, con
                 ConstExprValue *array_const_val = const_val->data.x_ptr.data.base_array.array_val;
                 assert(array_const_val->type->id == ZigTypeIdArray);
                 if (!type_has_bits(array_const_val->type)) {
-                    if (array_const_val->type->data.array.is_null_terminated) {
-                        ConstExprValue *pointee = get_null_value(array_const_val->type->data.array.child_type);
+                    if (array_const_val->type->data.array.sentinel != nullptr) {
+                        ConstExprValue *pointee = array_const_val->type->data.array.sentinel;
                         render_const_val(g, pointee, "");
                         render_const_val_global(g, pointee, "");
                         const_val->global_refs->llvm_value = LLVMConstBitCast(pointee->global_refs->llvm_global,
@@ -6963,8 +6963,8 @@ check: switch (const_val->special) {
                     case ConstArraySpecialUndef:
                         return LLVMGetUndef(get_llvm_type(g, type_entry));
                     case ConstArraySpecialNone: {
-                        uint64_t extra_len_from_null = type_entry->data.array.is_null_terminated ? 1 : 0;
-                        uint64_t full_len = len + extra_len_from_null;
+                        uint64_t extra_len_from_sentinel = (type_entry->data.array.sentinel != nullptr) ? 1 : 0;
+                        uint64_t full_len = len + extra_len_from_sentinel;
                         LLVMValueRef *values = allocate<LLVMValueRef>(full_len);
                         LLVMTypeRef element_type_ref = get_llvm_type(g, type_entry->data.array.child_type);
                         bool make_unnamed_struct = false;
@@ -6974,8 +6974,8 @@ check: switch (const_val->special) {
                             values[i] = val;
                             make_unnamed_struct = make_unnamed_struct || is_llvm_value_unnamed_type(g, elem_value->type, val);
                         }
-                        if (type_entry->data.array.is_null_terminated) {
-                            values[len] = LLVMConstNull(element_type_ref);
+                        if (type_entry->data.array.sentinel != nullptr) {
+                            values[len] = gen_const_val(g, type_entry->data.array.sentinel, "");
                         }
                         if (make_unnamed_struct) {
                             return LLVMConstStruct(values, full_len, true);
@@ -6986,7 +6986,7 @@ check: switch (const_val->special) {
                     case ConstArraySpecialBuf: {
                         Buf *buf = const_val->data.x_array.data.s_buf;
                         return LLVMConstString(buf_ptr(buf), (unsigned)buf_len(buf),
-                                !type_entry->data.array.is_null_terminated);
+                                type_entry->data.array.sentinel == nullptr);
                     }
                 }
                 zig_unreachable();
@@ -7479,7 +7479,7 @@ static void do_code_gen(CodeGen *g) {
             !is_async && !have_err_ret_trace_arg;
         LLVMValueRef err_ret_array_val = nullptr;
         if (have_err_ret_trace_stack) {
-            ZigType *array_type = get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count, false);
+            ZigType *array_type = get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count, nullptr);
             err_ret_array_val = build_alloca(g, array_type, "error_return_trace_addresses", get_abi_alignment(g, array_type));
 
             (void)get_llvm_type(g, get_stack_trace_type(g));
@@ -8642,6 +8642,11 @@ static void init(CodeGen *g) {
     g->const_void_val.type = g->builtin_types.entry_void;
     g->const_void_val.global_refs = allocate<ConstGlobalRefs>(1);
 
+    g->const_zero_byte.special = ConstValSpecialStatic;
+    g->const_zero_byte.type = g->builtin_types.entry_u8;
+    g->const_zero_byte.global_refs = allocate<ConstGlobalRefs>(1);
+    bigint_init_unsigned(&g->const_zero_byte.data.x_bigint, 0);
+
     {
         ConstGlobalRefs *global_refs = allocate<ConstGlobalRefs>(PanicMsgIdCount);
         for (size_t i = 0; i < PanicMsgIdCount; i += 1) {
@@ -9081,7 +9086,7 @@ static void create_test_compile_var_and_add_test_runner(CodeGen *g) {
         zig_unreachable();
 
     ConstExprValue *test_fn_array = create_const_vals(1);
-    test_fn_array->type = get_array_type(g, struct_type, g->test_fns.length, false);
+    test_fn_array->type = get_array_type(g, struct_type, g->test_fns.length, nullptr);
     test_fn_array->special = ConstValSpecialStatic;
     test_fn_array->data.x_array.data.s_none.elements = create_const_vals(g->test_fns.length);
 
diff --git a/src/dump_analysis.cpp b/src/dump_analysis.cpp
index 825ae4baa5..98bbcc6a42 100644
--- a/src/dump_analysis.cpp
+++ b/src/dump_analysis.cpp
@@ -992,10 +992,6 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
                     jw_object_field(jw, "len");
                     jw_int(jw, 3);
                     break;
-                case PtrLenNull:
-                    jw_object_field(jw, "len");
-                    jw_int(jw, 4);
-                    break;
             }
             anal_dump_pointer_attrs(ctx, ty);
             break;
diff --git a/src/ir.cpp b/src/ir.cpp
index 03ec3c0436..a7a3fc51e4 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -67,9 +67,10 @@ enum ConstCastResultId {
     ConstCastResultIdAsyncAllocatorType,
     ConstCastResultIdBadAllowsZero,
     ConstCastResultIdArrayChild,
-    ConstCastResultIdBadNullTermArrays,
+    ConstCastResultIdSentinelArrays,
     ConstCastResultIdPtrLens,
     ConstCastResultIdCV,
+    ConstCastResultIdPtrSentinel,
 };
 
 struct ConstCastOnly;
@@ -94,8 +95,8 @@ struct ConstCastTypeMismatch;
 struct ConstCastArrayMismatch;
 struct ConstCastBadAllowsZero;
 struct ConstCastBadNullTermArrays;
-struct ConstCastBadPtrLens;
 struct ConstCastBadCV;
+struct ConstCastPtrSentinel;
 
 struct ConstCastOnly {
     ConstCastResultId id;
@@ -113,9 +114,9 @@ struct ConstCastOnly {
         ConstCastArg fn_arg;
         ConstCastArgNoAlias arg_no_alias;
         ConstCastBadAllowsZero *bad_allows_zero;
-        ConstCastBadNullTermArrays *bad_null_term_arrays;
-        ConstCastBadPtrLens *bad_ptr_lens;
+        ConstCastBadNullTermArrays *sentinel_arrays;
         ConstCastBadCV *bad_cv;
+        ConstCastPtrSentinel *bad_ptr_sentinel;
     } data;
 };
 
@@ -175,14 +176,13 @@ struct ConstCastBadNullTermArrays {
     ZigType *actual_type;
 };
 
-struct ConstCastBadPtrLens {
+struct ConstCastBadCV {
     ZigType *wanted_type;
     ZigType *actual_type;
 };
 
-struct ConstCastBadCV {
+struct ConstCastPtrSentinel {
     ZigType *wanted_type;
-    ZigType *actual_type;
 };
 
 static IrInstruction *ir_gen_node(IrBuilder *irb, AstNode *node, Scope *scope);
@@ -264,8 +264,7 @@ static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *c
         case ConstPtrSpecialBaseArray: {
             ConstExprValue *array_val = const_val->data.x_ptr.data.base_array.array_val;
             if (const_val->data.x_ptr.data.base_array.elem_index == array_val->type->data.array.len) {
-                assert(array_val->type->data.array.is_null_terminated);
-                result = get_null_value(array_val->type->data.array.child_type);
+                result = array_val->type->data.array.sentinel;
             } else {
                 expand_undef_array(g, array_val);
                 result = &array_val->data.x_array.data.s_none.elements[const_val->data.x_ptr.data.base_array.elem_index];
@@ -317,7 +316,7 @@ static bool slice_is_const(ZigType *type) {
 
 // This function returns true when you can change the type of a ConstExprValue and the
 // value remains meaningful.
-static bool types_have_same_zig_comptime_repr(ZigType *expected, ZigType *actual) {
+static bool types_have_same_zig_comptime_repr(CodeGen *codegen, ZigType *expected, ZigType *actual) {
     if (expected == actual)
         return true;
 
@@ -366,7 +365,8 @@ static bool types_have_same_zig_comptime_repr(ZigType *expected, ZigType *actual
         case ZigTypeIdArray:
             return expected->data.array.len == actual->data.array.len &&
                 expected->data.array.child_type == actual->data.array.child_type &&
-                (!expected->data.array.is_null_terminated || actual->data.array.is_null_terminated);
+                (expected->data.array.sentinel == nullptr || (actual->data.array.sentinel != nullptr &&
+                     const_values_equal(codegen, expected->data.array.sentinel, actual->data.array.sentinel)));
     }
     zig_unreachable();
 }
@@ -1576,9 +1576,11 @@ static IrInstruction *ir_build_br(IrBuilder *irb, Scope *scope, AstNode *source_
 
 static IrInstruction *ir_build_ptr_type(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *child_type, bool is_const, bool is_volatile, PtrLen ptr_len,
-        IrInstruction *align_value, uint32_t bit_offset_start, uint32_t host_int_bytes, bool is_allow_zero)
+        IrInstruction *sentinel, IrInstruction *align_value,
+        uint32_t bit_offset_start, uint32_t host_int_bytes, bool is_allow_zero)
 {
     IrInstructionPtrType *ptr_type_of_instruction = ir_build_instruction<IrInstructionPtrType>(irb, scope, source_node);
+    ptr_type_of_instruction->sentinel = sentinel;
     ptr_type_of_instruction->align_value = align_value;
     ptr_type_of_instruction->child_type = child_type;
     ptr_type_of_instruction->is_const = is_const;
@@ -1588,6 +1590,7 @@ static IrInstruction *ir_build_ptr_type(IrBuilder *irb, Scope *scope, AstNode *s
     ptr_type_of_instruction->host_int_bytes = host_int_bytes;
     ptr_type_of_instruction->is_allow_zero = is_allow_zero;
 
+    if (sentinel) ir_ref_instruction(sentinel, irb->current_basic_block);
     if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);
     ir_ref_instruction(child_type, irb->current_basic_block);
 
@@ -1804,14 +1807,15 @@ static IrInstruction *ir_build_set_float_mode(IrBuilder *irb, Scope *scope, AstN
 }
 
 static IrInstruction *ir_build_array_type(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *size,
-        IrInstruction *child_type, bool is_null_terminated)
+        IrInstruction *sentinel, IrInstruction *child_type)
 {
     IrInstructionArrayType *instruction = ir_build_instruction<IrInstructionArrayType>(irb, scope, source_node);
     instruction->size = size;
+    instruction->sentinel = sentinel;
     instruction->child_type = child_type;
-    instruction->is_null_terminated = is_null_terminated;
 
     ir_ref_instruction(size, irb->current_basic_block);
+    if (sentinel != nullptr) ir_ref_instruction(sentinel, irb->current_basic_block);
     ir_ref_instruction(child_type, irb->current_basic_block);
 
     return &instruction->base;
@@ -1827,20 +1831,22 @@ static IrInstruction *ir_build_anyframe_type(IrBuilder *irb, Scope *scope, AstNo
 
     return &instruction->base;
 }
+
 static IrInstruction *ir_build_slice_type(IrBuilder *irb, Scope *scope, AstNode *source_node,
-        IrInstruction *child_type, bool is_const, bool is_volatile, IrInstruction *align_value, bool is_allow_zero,
-        bool is_null_terminated)
+        IrInstruction *child_type, bool is_const, bool is_volatile,
+        IrInstruction *sentinel, IrInstruction *align_value, bool is_allow_zero)
 {
     IrInstructionSliceType *instruction = ir_build_instruction<IrInstructionSliceType>(irb, scope, source_node);
     instruction->is_const = is_const;
     instruction->is_volatile = is_volatile;
     instruction->child_type = child_type;
+    instruction->sentinel = sentinel;
     instruction->align_value = align_value;
     instruction->is_allow_zero = is_allow_zero;
-    instruction->is_null_terminated = is_null_terminated;
 
+    if (sentinel != nullptr) ir_ref_instruction(sentinel, irb->current_basic_block);
+    if (align_value != nullptr) ir_ref_instruction(align_value, irb->current_basic_block);
     ir_ref_instruction(child_type, irb->current_basic_block);
-    if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);
 
     return &instruction->base;
 }
@@ -6067,9 +6073,9 @@ static PtrLen star_token_to_ptr_len(TokenId token_id) {
         case TokenIdStar:
         case TokenIdStarStar:
             return PtrLenSingle;
-        case TokenIdBracketStarBracket:
+        case TokenIdLBracket:
             return PtrLenUnknown;
-        case TokenIdBracketStarCBracket:
+        case TokenIdSymbol:
             return PtrLenC;
         default:
             zig_unreachable();
@@ -6080,22 +6086,22 @@ static IrInstruction *ir_gen_pointer_type(IrBuilder *irb, Scope *scope, AstNode
     assert(node->type == NodeTypePointerType);
 
     PtrLen ptr_len = star_token_to_ptr_len(node->data.pointer_type.star_token->id);
-    if (node->data.pointer_type.is_null_terminated) {
-        if (ptr_len == PtrLenUnknown) {
-            ptr_len = PtrLenNull;
-        } else {
-            exec_add_error_node(irb->codegen, irb->exec, node,
-                    buf_sprintf("null-terminated pointer must be specified with [*] token"));
-            return irb->codegen->invalid_instruction;
-        }
-    }
 
     bool is_const = node->data.pointer_type.is_const;
     bool is_volatile = node->data.pointer_type.is_volatile;
     bool is_allow_zero = node->data.pointer_type.allow_zero_token != nullptr;
+    AstNode *sentinel_expr = node->data.pointer_type.sentinel;
     AstNode *expr_node = node->data.pointer_type.op_expr;
     AstNode *align_expr = node->data.pointer_type.align_expr;
 
+    IrInstruction *sentinel;
+    if (sentinel_expr != nullptr) {
+        sentinel = ir_gen_node(irb, sentinel_expr, scope);
+        if (sentinel == irb->codegen->invalid_instruction)
+            return sentinel;
+    } else {
+        sentinel = nullptr;
+    }
 
     IrInstruction *align_value;
     if (align_expr != nullptr) {
@@ -6141,7 +6147,7 @@ static IrInstruction *ir_gen_pointer_type(IrBuilder *irb, Scope *scope, AstNode
     }
 
     return ir_build_ptr_type(irb, scope, node, child_type, is_const, is_volatile,
-            ptr_len, align_value, bit_offset_start, host_int_bytes, is_allow_zero);
+            ptr_len, sentinel, align_value, bit_offset_start, host_int_bytes, is_allow_zero);
 }
 
 static IrInstruction *ir_gen_catch_unreachable(IrBuilder *irb, Scope *scope, AstNode *source_node,
@@ -6245,13 +6251,22 @@ static IrInstruction *ir_gen_container_init_expr(IrBuilder *irb, Scope *scope, A
                         buf_sprintf("initializing array with struct syntax"));
                 return irb->codegen->invalid_instruction;
             }
+            IrInstruction *sentinel;
+            if (container_init_expr->type->data.inferred_array_type.sentinel != nullptr) {
+                sentinel = ir_gen_node(irb, container_init_expr->type->data.inferred_array_type.sentinel, scope);
+                if (sentinel == irb->codegen->invalid_instruction)
+                    return sentinel;
+            } else {
+                sentinel = nullptr;
+            }
+
             IrInstruction *elem_type = ir_gen_node(irb,
                     container_init_expr->type->data.inferred_array_type.child_type, scope);
             if (elem_type == irb->codegen->invalid_instruction)
                 return elem_type;
             size_t item_count = container_init_expr->entries.length;
             IrInstruction *item_count_inst = ir_build_const_usize(irb, scope, node, item_count);
-            container_type = ir_build_array_type(irb, scope, node, item_count_inst, elem_type, false);
+            container_type = ir_build_array_type(irb, scope, node, item_count_inst, sentinel, elem_type);
         } else {
             container_type = ir_gen_node(irb, container_init_expr->type, scope);
             if (container_type == irb->codegen->invalid_instruction)
@@ -6975,10 +6990,20 @@ static IrInstruction *ir_gen_array_type(IrBuilder *irb, Scope *scope, AstNode *n
     bool is_const = node->data.array_type.is_const;
     bool is_volatile = node->data.array_type.is_volatile;
     bool is_allow_zero = node->data.array_type.allow_zero_token != nullptr;
-    bool is_null_terminated = node->data.array_type.is_null_terminated;
+    AstNode *sentinel_expr = node->data.array_type.sentinel;
     AstNode *align_expr = node->data.array_type.align_expr;
 
     Scope *comptime_scope = create_comptime_scope(irb->codegen, node, scope);
+
+    IrInstruction *sentinel;
+    if (sentinel_expr != nullptr) {
+        sentinel = ir_gen_node(irb, sentinel_expr, comptime_scope);
+        if (sentinel == irb->codegen->invalid_instruction)
+            return sentinel;
+    } else {
+        sentinel = nullptr;
+    }
+
     if (size_node) {
         if (is_const) {
             add_node_error(irb->codegen, node, buf_create_from_str("const qualifier invalid on array type"));
@@ -7005,7 +7030,7 @@ static IrInstruction *ir_gen_array_type(IrBuilder *irb, Scope *scope, AstNode *n
         if (child_type == irb->codegen->invalid_instruction)
             return child_type;
 
-        return ir_build_array_type(irb, scope, node, size_value, child_type, is_null_terminated);
+        return ir_build_array_type(irb, scope, node, size_value, sentinel, child_type);
     } else {
         IrInstruction *align_value;
         if (align_expr != nullptr) {
@@ -7020,8 +7045,8 @@ static IrInstruction *ir_gen_array_type(IrBuilder *irb, Scope *scope, AstNode *n
         if (child_type == irb->codegen->invalid_instruction)
             return child_type;
 
-        return ir_build_slice_type(irb, scope, node, child_type, is_const, is_volatile, align_value, is_allow_zero,
-                is_null_terminated);
+        return ir_build_slice_type(irb, scope, node, child_type, is_const, is_volatile, sentinel,
+                align_value, is_allow_zero);
     }
 }
 
@@ -8698,7 +8723,7 @@ ConstExprValue *const_ptr_pointee(IrAnalyze *ira, CodeGen *codegen, ConstExprVal
         case OnePossibleValueYes:
             return get_the_one_possible_value(codegen, expected_type);
     }
-    if (!types_have_same_zig_comptime_repr(expected_type, val->type)) {
+    if (!types_have_same_zig_comptime_repr(codegen, expected_type, val->type)) {
         if ((err = eval_comptime_ptr_reinterpret(ira, codegen, source_node, const_val)))
             return nullptr;
         return const_ptr_pointee_unchecked(codegen, const_val);
@@ -9846,7 +9871,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
     // alignment can be decreased
     // bit offset attributes must match exactly
     // PtrLenSingle/PtrLenUnknown must match exactly, but PtrLenC matches either one
-    // PtrLenNull can coerce into PtrLenUnknown
+    // sentinel-terminated pointers can coerce into PtrLenUnknown
     ZigType *wanted_ptr_type = get_src_ptr_type(wanted_type);
     ZigType *actual_ptr_type = get_src_ptr_type(actual_type);
     bool wanted_allows_zero = ptr_allows_addr_zero(wanted_type);
@@ -9858,15 +9883,20 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
     bool actual_opt_or_ptr = actual_ptr_type != nullptr &&
         (actual_type->id == ZigTypeIdPointer || actual_type->id == ZigTypeIdOptional);
     if (wanted_opt_or_ptr && actual_opt_or_ptr) {
-        bool ptr_lens_equal = actual_ptr_type->data.pointer.ptr_len == wanted_ptr_type->data.pointer.ptr_len;
         bool ok_null_term_ptrs =
-            actual_ptr_type->data.pointer.ptr_len == PtrLenNull ||
-            wanted_ptr_type->data.pointer.ptr_len == PtrLenUnknown;
-        if (!(ptr_lens_equal || wanted_is_c_ptr || actual_is_c_ptr || ok_null_term_ptrs)) {
+            wanted_ptr_type->data.pointer.sentinel == nullptr ||
+            (actual_ptr_type->data.pointer.sentinel != nullptr &&
+             const_values_equal(ira->codegen, wanted_ptr_type->data.pointer.sentinel,
+                 actual_ptr_type->data.pointer.sentinel));
+        if (!ok_null_term_ptrs) {
+            result.id = ConstCastResultIdPtrSentinel;
+            result.data.bad_ptr_sentinel = allocate_nonzero<ConstCastPtrSentinel>(1);
+            result.data.bad_ptr_sentinel->wanted_type = wanted_type;
+            return result;
+        }
+        bool ptr_lens_equal = actual_ptr_type->data.pointer.ptr_len == wanted_ptr_type->data.pointer.ptr_len;
+        if (!(ptr_lens_equal || wanted_is_c_ptr || actual_is_c_ptr)) {
             result.id = ConstCastResultIdPtrLens;
-            result.data.bad_ptr_lens = allocate_nonzero<ConstCastBadPtrLens>(1);
-            result.data.bad_ptr_lens->wanted_type = wanted_type;
-            result.data.bad_ptr_lens->actual_type = actual_type;
             return result;
         }
 
@@ -9944,14 +9974,15 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             result.data.array_mismatch->actual_child = actual_type->data.array.child_type;
             return result;
         }
-        bool ok_null_terminated = !wanted_type->data.array.is_null_terminated ||
-            actual_type->data.array.is_null_terminated;
+        bool ok_null_terminated = (wanted_type->data.array.sentinel == nullptr) ||
+            (actual_type->data.array.sentinel != nullptr &&
+            const_values_equal(ira->codegen, wanted_type->data.array.sentinel, actual_type->data.array.sentinel));
         if (!ok_null_terminated) {
-            result.id = ConstCastResultIdBadNullTermArrays;
-            result.data.bad_null_term_arrays = allocate_nonzero<ConstCastBadNullTermArrays>(1);
-            result.data.bad_null_term_arrays->child = child;
-            result.data.bad_null_term_arrays->wanted_type = wanted_type;
-            result.data.bad_null_term_arrays->actual_type = actual_type;
+            result.id = ConstCastResultIdSentinelArrays;
+            result.data.sentinel_arrays = allocate_nonzero<ConstCastBadNullTermArrays>(1);
+            result.data.sentinel_arrays->child = child;
+            result.data.sentinel_arrays->wanted_type = wanted_type;
+            result.data.sentinel_arrays->actual_type = actual_type;
             return result;
         }
         return result;
@@ -10781,8 +10812,12 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
                 prev_type->data.pointer.child_type->id == ZigTypeIdArray &&
             (cur_type->data.pointer.is_const || !prev_type->data.pointer.is_const ||
                 prev_type->data.pointer.child_type->data.array.len == 0) &&
-            (cur_type->data.pointer.child_type->data.array.is_null_terminated ||
-                !prev_type->data.pointer.child_type->data.array.is_null_terminated) &&
+            (
+                prev_type->data.pointer.child_type->data.array.sentinel == nullptr ||
+                (cur_type->data.pointer.child_type->data.array.sentinel != nullptr &&
+                const_values_equal(ira->codegen, prev_type->data.pointer.child_type->data.array.sentinel,
+                    cur_type->data.pointer.child_type->data.array.sentinel))
+            ) &&
             types_match_const_cast_only(ira,
                 cur_type->data.pointer.child_type->data.array.child_type,
                 prev_type->data.pointer.child_type->data.array.child_type,
@@ -10798,8 +10833,12 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
                 cur_type->data.pointer.child_type->id == ZigTypeIdArray &&
             (prev_type->data.pointer.is_const || !cur_type->data.pointer.is_const ||
                 cur_type->data.pointer.child_type->data.array.len == 0) &&
-            (prev_type->data.pointer.child_type->data.array.is_null_terminated ||
-                !cur_type->data.pointer.child_type->data.array.is_null_terminated) &&
+            (
+                cur_type->data.pointer.child_type->data.array.sentinel == nullptr ||
+                (prev_type->data.pointer.child_type->data.array.sentinel != nullptr &&
+                const_values_equal(ira->codegen, cur_type->data.pointer.child_type->data.array.sentinel,
+                    prev_type->data.pointer.child_type->data.array.sentinel))
+            ) &&
             types_match_const_cast_only(ira,
                 prev_type->data.pointer.child_type->data.array.child_type,
                 cur_type->data.pointer.child_type->data.array.child_type,
@@ -10871,11 +10910,12 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
         } else if (prev_inst->value.type->id == ZigTypeIdPointer) {
             ZigType *array_type = prev_inst->value.type->data.pointer.child_type;
             src_assert(array_type->id == ZigTypeIdArray, source_node);
-            ZigType *ptr_type = get_pointer_to_type_extra(
+            ZigType *ptr_type = get_pointer_to_type_extra2(
                     ira->codegen, array_type->data.array.child_type,
                     prev_inst->value.type->data.pointer.is_const, false,
-                    array_type->data.array.is_null_terminated ? PtrLenNull : PtrLenUnknown,
-                    0, 0, 0, false);
+                    PtrLenUnknown,
+                    0, 0, 0, false,
+                    VECTOR_INDEX_NONE, nullptr, array_type->data.array.sentinel);
             ZigType *slice_type = get_slice_type(ira->codegen, ptr_type);
             if (err_set_type != nullptr) {
                 return get_error_union_type(ira->codegen, err_set_type, slice_type);
@@ -11682,7 +11722,7 @@ static IrInstruction *ir_analyze_optional_wrap(IrAnalyze *ira, IrInstruction *so
         IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
                 source_instr->scope, source_instr->source_node);
         const_instruction->base.value.special = ConstValSpecialStatic;
-        if (types_have_same_zig_comptime_repr(wanted_type, payload_type)) {
+        if (types_have_same_zig_comptime_repr(ira->codegen, wanted_type, payload_type)) {
             copy_const_val(&const_instruction->base.value, val, val->data.x_ptr.mut == ConstPtrMutComptimeConst);
         } else {
             const_instruction->base.value.data.x_optional = val;
@@ -12601,14 +12641,24 @@ static void report_recursive_error(IrAnalyze *ira, AstNode *source_node, ConstCa
             break;
         }
         case ConstCastResultIdPtrLens: {
-            ZigType *wanted_type = cast_result->data.bad_ptr_lens->wanted_type;
-            ZigType *actual_type = cast_result->data.bad_ptr_lens->actual_type;
-            bool wanted_null_term = wanted_type->data.pointer.ptr_len == PtrLenNull;
-            bool actual_null_term = actual_type->data.pointer.ptr_len == PtrLenNull;
-            if (wanted_null_term && !actual_null_term) {
-                add_error_note(ira->codegen, parent_msg, source_node,
-                        buf_sprintf("destination type requires null termination"));
-            }
+            add_error_note(ira->codegen, parent_msg, source_node,
+                    buf_sprintf("pointer length mismatch"));
+            break;
+        }
+        case ConstCastResultIdPtrSentinel: {
+            ZigType *wanted_type = cast_result->data.bad_ptr_sentinel->wanted_type;
+            Buf *msg = buf_sprintf("destination pointer requires a terminating '");
+            render_const_value(ira->codegen, msg, wanted_type->data.pointer.sentinel);
+            buf_appendf(msg, "' sentinel value");
+            add_error_note(ira->codegen, parent_msg, source_node, msg);
+            break;
+        }
+        case ConstCastResultIdSentinelArrays: {
+            ZigType *wanted_type = cast_result->data.sentinel_arrays->wanted_type;
+            Buf *msg = buf_sprintf("destination array requires a terminating '");
+            render_const_value(ira->codegen, msg, wanted_type->data.pointer.sentinel);
+            buf_appendf(msg, "' sentinel value");
+            add_error_note(ira->codegen, parent_msg, source_node, msg);
             break;
         }
         case ConstCastResultIdCV: {
@@ -12642,7 +12692,6 @@ static void report_recursive_error(IrAnalyze *ira, AstNode *source_node, ConstCa
         case ConstCastResultIdUnresolvedInferredErrSet: // TODO
         case ConstCastResultIdAsyncAllocatorType: // TODO
         case ConstCastResultIdArrayChild: // TODO
-        case ConstCastResultIdBadNullTermArrays: // TODO
             break;
     }
 }
@@ -13013,16 +13062,18 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
 
     // *[N]T to [*]T and [*c]T
     if (wanted_type->id == ZigTypeIdPointer &&
-        (wanted_type->data.pointer.ptr_len == PtrLenUnknown || wanted_type->data.pointer.ptr_len == PtrLenC ||
-            wanted_type->data.pointer.ptr_len == PtrLenNull) &&
+        (wanted_type->data.pointer.ptr_len == PtrLenUnknown || wanted_type->data.pointer.ptr_len == PtrLenC) &&
         actual_type->id == ZigTypeIdPointer &&
         actual_type->data.pointer.ptr_len == PtrLenSingle &&
         actual_type->data.pointer.child_type->id == ZigTypeIdArray &&
         (!actual_type->data.pointer.is_const || wanted_type->data.pointer.is_const) &&
         (!actual_type->data.pointer.is_volatile || wanted_type->data.pointer.is_volatile))
     {
-        if (wanted_type->data.pointer.ptr_len != PtrLenNull ||
-            actual_type->data.pointer.child_type->data.array.is_null_terminated)
+        ZigType *actual_array_type = actual_type->data.pointer.child_type;
+        if (wanted_type->data.pointer.sentinel == nullptr ||
+            (actual_array_type->data.array.sentinel != nullptr &&
+             const_values_equal(ira->codegen, wanted_type->data.pointer.sentinel,
+                 actual_array_type->data.array.sentinel)))
         {
             if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
                 return ira->codegen->invalid_instruction;
@@ -14741,7 +14792,6 @@ static bool is_pointer_arithmetic_allowed(ZigType *lhs_type, IrBinOp op) {
         case PtrLenSingle:
             return lhs_type->data.pointer.child_type->id == ZigTypeIdArray;
         case PtrLenUnknown:
-        case PtrLenNull:
         case PtrLenC:
             return true;
     }
@@ -15007,7 +15057,7 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
     if (!op2_val)
         return ira->codegen->invalid_instruction;
 
-    bool is_null_terminated = false;
+    ConstExprValue *sentinel1 = nullptr;
     ConstExprValue *op1_array_val;
     size_t op1_array_index;
     size_t op1_array_end;
@@ -15017,16 +15067,17 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op1_array_val = op1_val;
         op1_array_index = 0;
         op1_array_end = op1_type->data.array.len;
+        sentinel1 = op1_type->data.array.sentinel;
     } else if (op1_type->id == ZigTypeIdPointer &&
         op1_type->data.pointer.child_type == ira->codegen->builtin_types.entry_u8 &&
-        op1_type->data.pointer.ptr_len == PtrLenNull &&
+        op1_type->data.pointer.sentinel != nullptr &&
         op1_val->data.x_ptr.special == ConstPtrSpecialBaseArray)
     {
         child_type = op1_type->data.pointer.child_type;
         op1_array_val = op1_val->data.x_ptr.data.base_array.array_val;
         op1_array_index = op1_val->data.x_ptr.data.base_array.elem_index;
         op1_array_end = op1_array_val->type->data.array.len;
-        is_null_terminated = true;
+        sentinel1 = op1_type->data.pointer.sentinel;
     } else if (is_slice(op1_type)) {
         ZigType *ptr_type = op1_type->data.structure.fields[slice_ptr_index]->type_entry;
         child_type = ptr_type->data.pointer.child_type;
@@ -15036,6 +15087,7 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op1_array_index = ptr_val->data.x_ptr.data.base_array.elem_index;
         ConstExprValue *len_val = op1_val->data.x_struct.fields[slice_len_index];
         op1_array_end = op1_array_index + bigint_as_usize(&len_val->data.x_bigint);
+        sentinel1 = ptr_type->data.pointer.sentinel;
     } else if (op1_type->id == ZigTypeIdPointer && op1_type->data.pointer.ptr_len == PtrLenSingle &&
             op1_type->data.pointer.child_type->id == ZigTypeIdArray)
     {
@@ -15046,13 +15098,14 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
             return ira->codegen->invalid_instruction;
         op1_array_index = 0;
         op1_array_end = array_type->data.array.len;
-        is_null_terminated = is_null_terminated || array_type->data.array.is_null_terminated;
+        sentinel1 = array_type->data.array.sentinel;
     } else {
         ir_add_error(ira, op1,
             buf_sprintf("expected array, found '%s'", buf_ptr(&op1->value.type->name)));
         return ira->codegen->invalid_instruction;
     }
 
+    ConstExprValue *sentinel2 = nullptr;
     ConstExprValue *op2_array_val;
     size_t op2_array_index;
     size_t op2_array_end;
@@ -15062,15 +15115,17 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op2_array_val = op2_val;
         op2_array_index = 0;
         op2_array_end = op2_array_val->type->data.array.len;
+        sentinel2 = op2_type->data.array.sentinel;
     } else if (op2_type->id == ZigTypeIdPointer &&
-        op2_type->data.pointer.ptr_len == PtrLenNull &&
+        op2_type->data.pointer.sentinel != nullptr &&
         op2_val->data.x_ptr.special == ConstPtrSpecialBaseArray)
     {
         op2_type_valid = op2_type->data.pointer.child_type == child_type;
         op2_array_val = op2_val->data.x_ptr.data.base_array.array_val;
         op2_array_index = op2_val->data.x_ptr.data.base_array.elem_index;
         op2_array_end = op2_array_val->type->data.array.len;
-        is_null_terminated = true;
+
+        sentinel2 = op2_type->data.pointer.sentinel;
     } else if (is_slice(op2_type)) {
         ZigType *ptr_type = op2_type->data.structure.fields[slice_ptr_index]->type_entry;
         op2_type_valid = ptr_type->data.pointer.child_type == child_type;
@@ -15080,6 +15135,8 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         op2_array_index = ptr_val->data.x_ptr.data.base_array.elem_index;
         ConstExprValue *len_val = op2_val->data.x_struct.fields[slice_len_index];
         op2_array_end = op2_array_index + bigint_as_usize(&len_val->data.x_bigint);
+
+        sentinel2 = ptr_type->data.pointer.sentinel;
     } else if (op2_type->id == ZigTypeIdPointer && op2_type->data.pointer.ptr_len == PtrLenSingle &&
             op2_type->data.pointer.child_type->id == ZigTypeIdArray)
     {
@@ -15090,7 +15147,8 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
             return ira->codegen->invalid_instruction;
         op2_array_index = 0;
         op2_array_end = array_type->data.array.len;
-        is_null_terminated = is_null_terminated || array_type->data.array.is_null_terminated;
+
+        sentinel2 = array_type->data.array.sentinel;
     } else {
         ir_add_error(ira, op2,
             buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op2->value.type->name)));
@@ -15103,6 +15161,19 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         return ira->codegen->invalid_instruction;
     }
 
+    ConstExprValue *sentinel;
+    if (sentinel1 != nullptr && sentinel2 != nullptr) {
+        // When there is a sentinel mismatch, no sentinel on the result. The type system
+        // will catch this if it is a problem.
+        sentinel = const_values_equal(ira->codegen, sentinel1, sentinel2) ? sentinel1 : nullptr;
+    } else if (sentinel1 != nullptr) {
+        sentinel = sentinel1;
+    } else if (sentinel2 != nullptr) {
+        sentinel = sentinel2;
+    } else {
+        sentinel = nullptr;
+    }
+
     // The type of result is populated in the following if blocks
     IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
     ConstExprValue *out_val = &result->value;
@@ -15110,24 +15181,25 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
     ConstExprValue *out_array_val;
     size_t new_len = (op1_array_end - op1_array_index) + (op2_array_end - op2_array_index);
     if (op1_type->id == ZigTypeIdArray || op2_type->id == ZigTypeIdArray) {
-        result->value.type = get_array_type(ira->codegen, child_type, new_len, false);
+        result->value.type = get_array_type(ira->codegen, child_type, new_len, sentinel);
 
         out_array_val = out_val;
     } else if (op1_type->id == ZigTypeIdPointer || op2_type->id == ZigTypeIdPointer) {
         out_array_val = create_const_vals(1);
         out_array_val->special = ConstValSpecialStatic;
-        out_array_val->type = get_array_type(ira->codegen, child_type, new_len, is_null_terminated);
+        out_array_val->type = get_array_type(ira->codegen, child_type, new_len, sentinel);
 
         out_val->data.x_ptr.special = ConstPtrSpecialRef;
         out_val->data.x_ptr.data.ref.pointee = out_array_val;
         out_val->type = get_pointer_to_type(ira->codegen, out_array_val->type, true);
     } else if (is_slice(op1_type) || is_slice(op2_type)) {
-        ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
-                true, false, PtrLenUnknown, 0, 0, 0, false);
+        ZigType *ptr_type = get_pointer_to_type_extra2(ira->codegen, child_type,
+                true, false, PtrLenUnknown, 0, 0, 0, false,
+                VECTOR_INDEX_NONE, nullptr, sentinel);
         result->value.type = get_slice_type(ira->codegen, ptr_type);
         out_array_val = create_const_vals(1);
         out_array_val->special = ConstValSpecialStatic;
-        out_array_val->type = get_array_type(ira->codegen, child_type, new_len, false);
+        out_array_val->type = get_array_type(ira->codegen, child_type, new_len, sentinel);
 
         out_val->data.x_struct.fields = alloc_const_vals_ptrs(2);
 
@@ -15141,12 +15213,12 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         out_val->data.x_struct.fields[slice_len_index]->special = ConstValSpecialStatic;
         bigint_init_unsigned(&out_val->data.x_struct.fields[slice_len_index]->data.x_bigint, new_len);
     } else {
-        result->value.type = get_pointer_to_type_extra(ira->codegen, child_type, true, false, PtrLenNull,
-                0, 0, 0, false);
+        result->value.type = get_pointer_to_type_extra2(ira->codegen, child_type, true, false, PtrLenUnknown,
+                0, 0, 0, false, VECTOR_INDEX_NONE, nullptr, sentinel);
 
         out_array_val = create_const_vals(1);
         out_array_val->special = ConstValSpecialStatic;
-        out_array_val->type = get_array_type(ira->codegen, child_type, new_len, false);
+        out_array_val->type = get_array_type(ira->codegen, child_type, new_len, sentinel);
         out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
         out_val->data.x_ptr.data.base_array.array_val = out_array_val;
         out_val->data.x_ptr.data.base_array.elem_index = 0;
@@ -15159,26 +15231,36 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
         return result;
     }
 
-    out_array_val->data.x_array.data.s_none.elements = create_const_vals(new_len);
+    uint64_t full_len = new_len + ((sentinel != nullptr) ? 1 : 0);
+    out_array_val->data.x_array.data.s_none.elements = create_const_vals(full_len);
     // TODO handle the buf case here for an optimization
     expand_undef_array(ira->codegen, op1_array_val);
     expand_undef_array(ira->codegen, op2_array_val);
 
     size_t next_index = 0;
     for (size_t i = op1_array_index; i < op1_array_end; i += 1, next_index += 1) {
-        copy_const_val(&out_array_val->data.x_array.data.s_none.elements[next_index],
-                &op1_array_val->data.x_array.data.s_none.elements[i], true);
+        ConstExprValue *elem_dest_val = &out_array_val->data.x_array.data.s_none.elements[next_index];
+        copy_const_val(elem_dest_val, &op1_array_val->data.x_array.data.s_none.elements[i], false);
+        elem_dest_val->parent.id = ConstParentIdArray;
+        elem_dest_val->parent.data.p_array.array_val = out_array_val;
+        elem_dest_val->parent.data.p_array.elem_index = next_index;
     }
     for (size_t i = op2_array_index; i < op2_array_end; i += 1, next_index += 1) {
-        copy_const_val(&out_array_val->data.x_array.data.s_none.elements[next_index],
-                &op2_array_val->data.x_array.data.s_none.elements[i], true);
-    }
-    if (next_index < new_len) {
-        ConstExprValue *null_byte = &out_array_val->data.x_array.data.s_none.elements[next_index];
-        init_const_unsigned_negative(null_byte, child_type, 0, false);
+        ConstExprValue *elem_dest_val = &out_array_val->data.x_array.data.s_none.elements[next_index];
+        copy_const_val(elem_dest_val, &op2_array_val->data.x_array.data.s_none.elements[i], false);
+        elem_dest_val->parent.id = ConstParentIdArray;
+        elem_dest_val->parent.data.p_array.array_val = out_array_val;
+        elem_dest_val->parent.data.p_array.elem_index = next_index;
+    }
+    if (next_index < full_len) {
+        ConstExprValue *elem_dest_val = &out_array_val->data.x_array.data.s_none.elements[next_index];
+        copy_const_val(elem_dest_val, sentinel, false);
+        elem_dest_val->parent.id = ConstParentIdArray;
+        elem_dest_val->parent.data.p_array.array_val = out_array_val;
+        elem_dest_val->parent.data.p_array.elem_index = next_index;
         next_index += 1;
     }
-    assert(next_index == new_len);
+    assert(next_index == full_len);
 
     return result;
 }
@@ -15230,7 +15312,7 @@ static IrInstruction *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *
 
     ZigType *child_type = array_type->data.array.child_type;
     ZigType *result_array_type = get_array_type(ira->codegen, child_type, new_array_len,
-            array_type->data.array.is_null_terminated);
+            array_type->data.array.sentinel);
 
     IrInstruction *array_result;
     if (array_val->special == ConstValSpecialUndef || array_val->data.x_array.special == ConstArraySpecialUndef) {
@@ -15250,7 +15332,7 @@ static IrInstruction *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *
 
         // TODO optimize the buf case
         expand_undef_array(ira->codegen, array_val);
-        size_t extra_null_term = array_type->data.array.is_null_terminated ? 1 : 0;
+        size_t extra_null_term = (array_type->data.array.sentinel != nullptr) ? 1 : 0;
         out_val->data.x_array.data.s_none.elements = create_const_vals(new_array_len + extra_null_term);
 
         uint64_t i = 0;
@@ -15266,10 +15348,9 @@ static IrInstruction *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *
         }
         assert(i == new_array_len);
 
-        if (array_type->data.array.is_null_terminated) {
-            ConstExprValue *null_value = get_null_value(array_type->data.array.child_type);
+        if (array_type->data.array.sentinel != nullptr) {
             ConstExprValue *elem_dest_val = &out_val->data.x_array.data.s_none.elements[i];
-            copy_const_val(elem_dest_val, null_value, false);
+            copy_const_val(elem_dest_val, array_type->data.array.sentinel, false);
             elem_dest_val->parent.id = ConstParentIdArray;
             elem_dest_val->parent.data.p_array.array_val = out_val;
             elem_dest_val->parent.data.p_array.elem_index = i;
@@ -17565,7 +17646,7 @@ static Error ir_read_const_ptr(IrAnalyze *ira, CodeGen *codegen, AstNode *source
     size_t dst_size = type_size(codegen, out_val->type);
 
     if (dst_size <= src_size) {
-        if (src_size == dst_size && types_have_same_zig_comptime_repr(out_val->type, pointee->type)) {
+        if (src_size == dst_size && types_have_same_zig_comptime_repr(codegen, out_val->type, pointee->type)) {
             copy_const_val(out_val, pointee, ptr_val->data.x_ptr.mut != ConstPtrMutComptimeVar);
             return ErrorNone;
         }
@@ -18316,11 +18397,11 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
         uint64_t index = bigint_as_u64(&casted_elem_index->value.data.x_bigint);
         if (array_type->id == ZigTypeIdArray) {
             uint64_t array_len = array_type->data.array.len;
-            if (index == array_len && array_type->data.array.is_null_terminated) {
+            if (index == array_len && array_type->data.array.sentinel != nullptr) {
                 ZigType *elem_type = array_type->data.array.child_type;
-                IrInstruction *null_element = ir_const(ira, &elem_ptr_instruction->base, elem_type);
-                null_element->value = *get_null_value(elem_type);
-                return ir_get_ref(ira, &elem_ptr_instruction->base, null_element, true, false);
+                IrInstruction *sentinel_elem = ir_const(ira, &elem_ptr_instruction->base, elem_type);
+                copy_const_val(&sentinel_elem->value, array_type->data.array.sentinel, false);
+                return ir_get_ref(ira, &elem_ptr_instruction->base, sentinel_elem, true, false);
             }
             if (index >= array_len) {
                 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
@@ -18337,7 +18418,7 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
                 ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
                 elem_ptr_instruction->ptr_len,
                 get_ptr_align(ira->codegen, ptr_type), 0, host_vec_len, false, (uint32_t)index,
-                nullptr);
+                nullptr, nullptr);
         } else if (return_type->data.pointer.explicit_alignment != 0) {
             // figure out the largest alignment possible
 
@@ -18457,7 +18538,7 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
                                 new_index = offset + index;
                                 ZigType *array_type = array_ptr_val->data.x_ptr.data.base_array.array_val->type;
                                 mem_size = array_type->data.array.len;
-                                if (array_type->data.array.is_null_terminated) {
+                                if (array_type->data.array.sentinel != nullptr) {
                                     mem_size += 1;
                                 }
                                 old_size = mem_size - offset;
@@ -18579,7 +18660,7 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
             ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
             elem_ptr_instruction->ptr_len,
             get_ptr_align(ira->codegen, ptr_type), 0, host_vec_len, false, VECTOR_INDEX_RUNTIME,
-            nullptr);
+            nullptr, nullptr);
     } else {
         // runtime known element index
         switch (type_requires_comptime(ira->codegen, return_type)) {
@@ -18783,7 +18864,7 @@ static IrInstruction *ir_analyze_inferred_field_ptr(IrAnalyze *ira, Buf *field_n
     ZigType *elem_type = ira->codegen->builtin_types.entry_var;
     ZigType *field_ptr_type = get_pointer_to_type_extra2(ira->codegen, elem_type,
         container_ptr_type->data.pointer.is_const, container_ptr_type->data.pointer.is_volatile,
-        PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, inferred_struct_field);
+        PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE, inferred_struct_field, nullptr);
 
     if (instr_is_comptime(container_ptr)) {
         IrInstruction *result = ir_const(ira, source_instr, field_ptr_type);
@@ -19565,6 +19646,12 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira,
             return ira->codegen->invalid_instruction;
     }
 
+    if (slice_type_instruction->sentinel != nullptr) {
+        lazy_slice_type->sentinel = slice_type_instruction->sentinel->child;
+        if (ir_resolve_const(ira, lazy_slice_type->sentinel, LazyOk) == nullptr)
+            return ira->codegen->invalid_instruction;
+    }
+
     lazy_slice_type->elem_type = slice_type_instruction->child_type->child;
     if (ir_resolve_type_lazy(ira, lazy_slice_type->elem_type) == nullptr)
         return ira->codegen->invalid_instruction;
@@ -19572,7 +19659,6 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira,
     lazy_slice_type->is_const = slice_type_instruction->is_const;
     lazy_slice_type->is_volatile = slice_type_instruction->is_volatile;
     lazy_slice_type->is_allowzero = slice_type_instruction->is_allow_zero;
-    lazy_slice_type->is_null_terminated = slice_type_instruction->is_null_terminated;
 
     return result;
 }
@@ -19647,6 +19733,22 @@ static IrInstruction *ir_analyze_instruction_array_type(IrAnalyze *ira,
     ZigType *child_type = ir_resolve_type(ira, child_type_value);
     if (type_is_invalid(child_type))
         return ira->codegen->invalid_instruction;
+
+    ConstExprValue *sentinel_val;
+    if (array_type_instruction->sentinel != nullptr) {
+        IrInstruction *uncasted_sentinel = array_type_instruction->sentinel->child;
+        if (type_is_invalid(uncasted_sentinel->value.type))
+            return ira->codegen->invalid_instruction;
+        IrInstruction *sentinel = ir_implicit_cast(ira, uncasted_sentinel, child_type);
+        if (type_is_invalid(sentinel->value.type))
+            return ira->codegen->invalid_instruction;
+        sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
+        if (sentinel_val == nullptr)
+            return ira->codegen->invalid_instruction;
+    } else {
+        sentinel_val = nullptr;
+    }
+
     switch (child_type->id) {
         case ZigTypeIdInvalid: // handled above
             zig_unreachable();
@@ -19682,8 +19784,7 @@ static IrInstruction *ir_analyze_instruction_array_type(IrAnalyze *ira,
             {
                 if ((err = type_resolve(ira->codegen, child_type, ResolveStatusSizeKnown)))
                     return ira->codegen->invalid_instruction;
-                ZigType *result_type = get_array_type(ira->codegen, child_type, size,
-                        array_type_instruction->is_null_terminated);
+                ZigType *result_type = get_array_type(ira->codegen, child_type, size, sentinel_val);
                 return ir_const_type(ira, &array_type_instruction->base, result_type);
             }
     }
@@ -19802,7 +19903,7 @@ static IrInstruction *ir_analyze_unwrap_optional_payload(IrAnalyze *ira, IrInstr
     ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
             ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile, PtrLenSingle, 0, 0, 0, false);
 
-    bool same_comptime_repr = types_have_same_zig_comptime_repr(child_type, type_entry);
+    bool same_comptime_repr = types_have_same_zig_comptime_repr(ira->codegen, child_type, type_entry);
 
     if (instr_is_comptime(base_ptr)) {
         ConstExprValue *ptr_val = ir_resolve_const(ira, base_ptr, UndefBad);
@@ -20759,7 +20860,7 @@ static IrInstruction *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
     if (container_type->id == ZigTypeIdArray) {
         ZigType *child_type = container_type->data.array.child_type;
         if (container_type->data.array.len != elem_count) {
-            ZigType *literal_type = get_array_type(ira->codegen, child_type, elem_count, false);
+            ZigType *literal_type = get_array_type(ira->codegen, child_type, elem_count, nullptr);
 
             ir_add_error(ira, &instruction->base,
                 buf_sprintf("expected %s literal, found %s literal",
@@ -21246,7 +21347,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
 
     ConstExprValue *declaration_array = create_const_vals(1);
     declaration_array->special = ConstValSpecialStatic;
-    declaration_array->type = get_array_type(ira->codegen, type_info_declaration_type, declaration_count, false);
+    declaration_array->type = get_array_type(ira->codegen, type_info_declaration_type, declaration_count, nullptr);
     declaration_array->data.x_array.special = ConstArraySpecialNone;
     declaration_array->data.x_array.data.s_none.elements = create_const_vals(declaration_count);
     init_const_slice(ira->codegen, out_val, declaration_array, 0, declaration_count, false);
@@ -21391,7 +21492,7 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
                     ConstExprValue *fn_arg_name_array = create_const_vals(1);
                     fn_arg_name_array->special = ConstValSpecialStatic;
                     fn_arg_name_array->type = get_array_type(ira->codegen,
-                            get_slice_type(ira->codegen, u8_ptr), fn_arg_count, false);
+                            get_slice_type(ira->codegen, u8_ptr), fn_arg_count, nullptr);
                     fn_arg_name_array->data.x_array.special = ConstArraySpecialNone;
                     fn_arg_name_array->data.x_array.data.s_none.elements = create_const_vals(fn_arg_count);
 
@@ -21446,7 +21547,6 @@ static BuiltinPtrSize ptr_len_to_size_enum_index(PtrLen ptr_len) {
         case PtrLenSingle:
             return BuiltinPtrSizeOne;
         case PtrLenUnknown:
-        case PtrLenNull:
             return BuiltinPtrSizeMany;
         case PtrLenC:
             return BuiltinPtrSizeC;
@@ -21527,11 +21627,21 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
     fields[5]->special = ConstValSpecialStatic;
     fields[5]->type = ira->codegen->builtin_types.entry_bool;
     fields[5]->data.x_bool = attrs_type->data.pointer.allow_zero;
-    // is_null_terminated: bool
-    ensure_field_index(result->type, "is_null_terminated", 6);
+    // sentinel: ?*const c_void
+    ZigType *ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_c_void, true);
+    ensure_field_index(result->type, "sentinel", 6);
     fields[6]->special = ConstValSpecialStatic;
-    fields[6]->type = ira->codegen->builtin_types.entry_bool;
-    fields[6]->data.x_bool = attrs_type->data.pointer.ptr_len == PtrLenNull;
+    fields[6]->type = get_optional_type(ira->codegen, ptr_type);
+    if (attrs_type->data.pointer.sentinel == nullptr) {
+        fields[6]->data.x_optional = nullptr;
+    } else {
+        ConstExprValue *ptr_val = create_const_vals(1);
+        fields[6]->data.x_optional = ptr_val;
+        ptr_val->data.x_ptr.special = ConstPtrSpecialRef;
+        ptr_val->data.x_ptr.mut = ConstPtrMutComptimeConst;
+        ptr_val->data.x_ptr.data.ref.pointee = create_const_vals(1);
+        copy_const_val(ptr_val->data.x_ptr.data.ref.pointee, attrs_type->data.pointer.sentinel, false);
+    }
 
     return result;
 };
@@ -21652,11 +21762,22 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
                 fields[1]->special = ConstValSpecialStatic;
                 fields[1]->type = ira->codegen->builtin_types.entry_type;
                 fields[1]->data.x_type = type_entry->data.array.child_type;
-                // is_null_terminated: bool
-                ensure_field_index(result->type, "is_null_terminated", 2);
+                // sentinel: ?*const c_void
                 fields[2]->special = ConstValSpecialStatic;
-                fields[2]->type = ira->codegen->builtin_types.entry_bool;
-                fields[2]->data.x_bool = type_entry->data.array.is_null_terminated;
+                ZigType *ptr_type = get_pointer_to_type(ira->codegen,
+                        ira->codegen->builtin_types.entry_c_void, true);
+                fields[2]->type = get_optional_type(ira->codegen, ptr_type);
+                if (type_entry->data.array.sentinel == nullptr) {
+                    fields[2]->data.x_optional = nullptr;
+                } else {
+                    ConstExprValue *ptr_val = create_const_vals(1);
+                    fields[2]->data.x_optional = ptr_val;
+                    ptr_val->type = ptr_type;
+                    ptr_val->data.x_ptr.special = ConstPtrSpecialRef;
+                    ptr_val->data.x_ptr.mut = ConstPtrMutComptimeConst;
+                    ptr_val->data.x_ptr.data.ref.pointee = create_const_vals(1);
+                    copy_const_val(ptr_val->data.x_ptr.data.ref.pointee, type_entry->data.array.sentinel, false);
+                }
 
                 break;
             }
@@ -21744,7 +21865,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
 
                 ConstExprValue *enum_field_array = create_const_vals(1);
                 enum_field_array->special = ConstValSpecialStatic;
-                enum_field_array->type = get_array_type(ira->codegen, type_info_enum_field_type, enum_field_count, false);
+                enum_field_array->type = get_array_type(ira->codegen, type_info_enum_field_type, enum_field_count, nullptr);
                 enum_field_array->data.x_array.special = ConstArraySpecialNone;
                 enum_field_array->data.x_array.data.s_none.elements = create_const_vals(enum_field_count);
 
@@ -21792,7 +21913,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
                 uint32_t error_count = type_entry->data.error_set.err_count;
                 ConstExprValue *error_array = create_const_vals(1);
                 error_array->special = ConstValSpecialStatic;
-                error_array->type = get_array_type(ira->codegen, type_info_error_type, error_count, false);
+                error_array->type = get_array_type(ira->codegen, type_info_error_type, error_count, nullptr);
                 error_array->data.x_array.special = ConstArraySpecialNone;
                 error_array->data.x_array.data.s_none.elements = create_const_vals(error_count);
 
@@ -21888,7 +22009,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
 
                 ConstExprValue *union_field_array = create_const_vals(1);
                 union_field_array->special = ConstValSpecialStatic;
-                union_field_array->type = get_array_type(ira->codegen, type_info_union_field_type, union_field_count, false);
+                union_field_array->type = get_array_type(ira->codegen, type_info_union_field_type, union_field_count, nullptr);
                 union_field_array->data.x_array.special = ConstArraySpecialNone;
                 union_field_array->data.x_array.data.s_none.elements = create_const_vals(union_field_count);
 
@@ -21968,7 +22089,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
 
                 ConstExprValue *struct_field_array = create_const_vals(1);
                 struct_field_array->special = ConstValSpecialStatic;
-                struct_field_array->type = get_array_type(ira->codegen, type_info_struct_field_type, struct_field_count, false);
+                struct_field_array->type = get_array_type(ira->codegen, type_info_struct_field_type, struct_field_count, nullptr);
                 struct_field_array->data.x_array.special = ConstArraySpecialNone;
                 struct_field_array->data.x_array.data.s_none.elements = create_const_vals(struct_field_count);
 
@@ -22071,7 +22192,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
 
                 ConstExprValue *fn_arg_array = create_const_vals(1);
                 fn_arg_array->special = ConstValSpecialStatic;
-                fn_arg_array->type = get_array_type(ira->codegen, type_info_fn_arg_type, fn_arg_count, false);
+                fn_arg_array->type = get_array_type(ira->codegen, type_info_fn_arg_type, fn_arg_count, nullptr);
                 fn_arg_array->data.x_array.special = ConstArraySpecialNone;
                 fn_arg_array->data.x_array.data.s_none.elements = create_const_vals(fn_arg_count);
 
@@ -22169,6 +22290,17 @@ static ConstExprValue *get_const_field(IrAnalyze *ira, ConstExprValue *struct_va
     return struct_value->data.x_struct.fields[field_index];
 }
 
+static ConstExprValue *get_const_field_variant(IrAnalyze *ira, ConstExprValue *struct_value,
+        const char *name, size_t field_index)
+{
+    ConstExprValue *field_val = get_const_field(ira, struct_value, name, field_index);
+    assert(field_val->type->id == ZigTypeIdOptional);
+    ConstExprValue *opt_val = field_val->data.x_optional;
+    if (opt_val == nullptr) return nullptr;
+    assert(opt_val->type->id == ZigTypeIdPointer);
+    return const_ptr_pointee_unchecked(ira->codegen, opt_val);
+}
+
 static bool get_const_field_bool(IrAnalyze *ira, ConstExprValue *struct_value, const char *name, size_t field_index)
 {
     ConstExprValue *value = get_const_field(ira, struct_value, name, field_index);
@@ -22232,7 +22364,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInstruction *instruction, Zi
                 assert(size_value->type == ir_type_info_get_type(ira, "Size", type_info_pointer_type));
                 BuiltinPtrSize size_enum_index = (BuiltinPtrSize)bigint_as_u32(&size_value->data.x_enum_tag);
                 PtrLen ptr_len = size_enum_index_to_ptr_len(size_enum_index);
-                ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen,
+                ZigType *ptr_type = get_pointer_to_type_extra2(ira->codegen,
                     get_const_field_meta_type(ira, payload, "child", 4),
                     get_const_field_bool(ira, payload, "is_const", 1),
                     get_const_field_bool(ira, payload, "is_volatile", 2),
@@ -22240,7 +22372,10 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInstruction *instruction, Zi
                     bigint_as_u32(get_const_field_lit_int(ira, payload, "alignment", 3)),
                     0, // bit_offset_in_host
                     0, // host_int_bytes
-                    get_const_field_bool(ira, payload, "is_allowzero", 5)
+                    get_const_field_bool(ira, payload, "is_allowzero", 5),
+                    VECTOR_INDEX_NONE,
+                    nullptr,
+                    get_const_field_variant(ira, payload, "sentinel", 6)
                 );
                 if (size_enum_index != 2)
                     return ptr_type;
@@ -22252,7 +22387,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInstruction *instruction, Zi
             return get_array_type(ira->codegen,
                 get_const_field_meta_type(ira, payload, "child", 1),
                 bigint_as_u64(get_const_field_lit_int(ira, payload, "len", 0)),
-                get_const_field_bool(ira, payload, "is_null_terminated", 2)
+                get_const_field_variant(ira, payload, "sentinel", 2)
             );
         case ZigTypeIdComptimeFloat:
             return ira->codegen->builtin_types.entry_num_lit_float;
@@ -22635,7 +22770,7 @@ static IrInstruction *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstru
     }
 
     ZigType *result_type = get_array_type(ira->codegen,
-            ira->codegen->builtin_types.entry_u8, buf_len(file_contents), false);
+            ira->codegen->builtin_types.entry_u8, buf_len(file_contents), nullptr);
     IrInstruction *result = ir_const(ira, &instruction->base, result_type);
     init_const_str_lit(ira->codegen, &result->value, file_contents);
     return result;
@@ -25858,6 +25993,12 @@ static IrInstruction *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstruct
     result->value.data.x_lazy = &lazy_ptr_type->base;
     lazy_ptr_type->base.id = LazyValueIdPtrType;
 
+    if (instruction->sentinel != nullptr) {
+        lazy_ptr_type->sentinel = instruction->sentinel->child;
+        if (ir_resolve_const(ira, lazy_ptr_type->sentinel, LazyOk) == nullptr)
+            return ira->codegen->invalid_instruction;
+    }
+
     lazy_ptr_type->elem_type = instruction->child_type->child;
     if (ir_resolve_type_lazy(ira, lazy_ptr_type->elem_type) == nullptr)
         return ira->codegen->invalid_instruction;
@@ -27804,6 +27945,20 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
             if (type_is_invalid(elem_type))
                 return ErrorSemanticAnalyzeFail;
 
+            ConstExprValue *sentinel_val;
+            if (lazy_slice_type->sentinel != nullptr) {
+                if (type_is_invalid(lazy_slice_type->sentinel->value.type))
+                    return ErrorSemanticAnalyzeFail;
+                IrInstruction *sentinel = ir_implicit_cast(ira, lazy_slice_type->sentinel, elem_type);
+                if (type_is_invalid(sentinel->value.type))
+                    return ErrorSemanticAnalyzeFail;
+                sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
+                if (sentinel_val == nullptr)
+                    return ErrorSemanticAnalyzeFail;
+            } else {
+                sentinel_val = nullptr;
+            }
+
             uint32_t align_bytes = 0;
             if (lazy_slice_type->align_inst != nullptr) {
                 if (!ir_resolve_align(ira, lazy_slice_type->align_inst, elem_type, &align_bytes))
@@ -27849,11 +28004,12 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
                 ResolveStatusZeroBitsKnown : ResolveStatusAlignmentKnown;
             if ((err = type_resolve(ira->codegen, elem_type, needed_status)))
                 return err;
-            ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, elem_type,
+            ZigType *slice_ptr_type = get_pointer_to_type_extra2(ira->codegen, elem_type,
                     lazy_slice_type->is_const, lazy_slice_type->is_volatile,
-                    lazy_slice_type->is_null_terminated ? PtrLenNull : PtrLenUnknown,
+                    PtrLenUnknown,
                     align_bytes,
-                    0, 0, lazy_slice_type->is_allowzero);
+                    0, 0, lazy_slice_type->is_allowzero,
+                    VECTOR_INDEX_NONE, nullptr, sentinel_val);
             val->special = ConstValSpecialStatic;
             assert(val->type->id == ZigTypeIdMetaType);
             val->data.x_type = get_slice_type(ira->codegen, slice_ptr_type);
@@ -27867,6 +28023,20 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
             if (type_is_invalid(elem_type))
                 return ErrorSemanticAnalyzeFail;
 
+            ConstExprValue *sentinel_val;
+            if (lazy_ptr_type->sentinel != nullptr) {
+                if (type_is_invalid(lazy_ptr_type->sentinel->value.type))
+                    return ErrorSemanticAnalyzeFail;
+                IrInstruction *sentinel = ir_implicit_cast(ira, lazy_ptr_type->sentinel, elem_type);
+                if (type_is_invalid(sentinel->value.type))
+                    return ErrorSemanticAnalyzeFail;
+                sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
+                if (sentinel_val == nullptr)
+                    return ErrorSemanticAnalyzeFail;
+            } else {
+                sentinel_val = nullptr;
+            }
+
             uint32_t align_bytes = 0;
             if (lazy_ptr_type->align_inst != nullptr) {
                 if (!ir_resolve_align(ira, lazy_ptr_type->align_inst, elem_type, &align_bytes))
@@ -27909,10 +28079,10 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
             }
             bool allow_zero = lazy_ptr_type->is_allowzero || lazy_ptr_type->ptr_len == PtrLenC;
             assert(val->type->id == ZigTypeIdMetaType);
-            val->data.x_type = get_pointer_to_type_extra(ira->codegen, elem_type,
+            val->data.x_type = get_pointer_to_type_extra2(ira->codegen, elem_type,
                     lazy_ptr_type->is_const, lazy_ptr_type->is_volatile, lazy_ptr_type->ptr_len, align_bytes,
                     lazy_ptr_type->bit_offset_in_host, lazy_ptr_type->host_int_bytes,
-                    allow_zero);
+                    allow_zero, VECTOR_INDEX_NONE, nullptr, sentinel_val);
             val->special = ConstValSpecialStatic;
             return ErrorNone;
         }
diff --git a/src/parser.cpp b/src/parser.cpp
index c3f719425b..61f3120d0e 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -1833,8 +1833,10 @@ static AstNode *ast_parse_labeled_type_expr(ParseContext *pc) {
         return loop;
     }
 
-    if (label != nullptr)
-        ast_invalid_token_error(pc, peek_token(pc));
+    if (label != nullptr) {
+        put_back_token(pc);
+        put_back_token(pc);
+    }
     return nullptr;
 }
 
@@ -1931,15 +1933,11 @@ static AstNode *ast_parse_asm_output(ParseContext *pc) {
 
 // AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
 static AsmOutput *ast_parse_asm_output_item(ParseContext *pc) {
-    Token *sym_name = eat_token_if(pc, TokenIdBracketUnderscoreBracket);
-    if (sym_name == nullptr) {
-        if (eat_token_if(pc, TokenIdLBracket) == nullptr) {
-            return nullptr;
-        } else {
-            sym_name = expect_token(pc, TokenIdSymbol);
-            expect_token(pc, TokenIdRBracket);
-        }
-    }
+    if (eat_token_if(pc, TokenIdLBracket) == nullptr)
+        return nullptr;
+
+    Token *sym_name = expect_token(pc, TokenIdSymbol);
+    expect_token(pc, TokenIdRBracket);
 
     Token *str = expect_token(pc, TokenIdStringLiteral);
     expect_token(pc, TokenIdLParen);
@@ -1954,7 +1952,7 @@ static AsmOutput *ast_parse_asm_output_item(ParseContext *pc) {
     expect_token(pc, TokenIdRParen);
 
     AsmOutput *res = allocate<AsmOutput>(1);
-    res->asm_symbolic_name = (sym_name->id == TokenIdBracketUnderscoreBracket) ? buf_create_from_str("_") : token_buf(sym_name);
+    res->asm_symbolic_name = token_buf(sym_name);
     res->constraint = token_buf(str);
     res->variable_name = token_buf(var_name);
     res->return_type = return_type;
@@ -1977,15 +1975,11 @@ static AstNode *ast_parse_asm_input(ParseContext *pc) {
 
 // AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
 static AsmInput *ast_parse_asm_input_item(ParseContext *pc) {
-    Token *sym_name = eat_token_if(pc, TokenIdBracketUnderscoreBracket);
-    if (sym_name == nullptr) {
-        if (eat_token_if(pc, TokenIdLBracket) == nullptr) {
-            return nullptr;
-        } else {
-            sym_name = expect_token(pc, TokenIdSymbol);
-            expect_token(pc, TokenIdRBracket);
-        }
-    }
+    if (eat_token_if(pc, TokenIdLBracket) == nullptr)
+        return nullptr;
+
+    Token *sym_name = expect_token(pc, TokenIdSymbol);
+    expect_token(pc, TokenIdRBracket);
 
     Token *constraint = expect_token(pc, TokenIdStringLiteral);
     expect_token(pc, TokenIdLParen);
@@ -1993,7 +1987,7 @@ static AsmInput *ast_parse_asm_input_item(ParseContext *pc) {
     expect_token(pc, TokenIdRParen);
 
     AsmInput *res = allocate<AsmInput>(1);
-    res->asm_symbolic_name = (sym_name->id == TokenIdBracketUnderscoreBracket) ? buf_create_from_str("_") : token_buf(sym_name);
+    res->asm_symbolic_name = token_buf(sym_name);
     res->constraint = token_buf(constraint);
     res->expr = expr;
     return res;
@@ -2613,42 +2607,28 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
         put_back_token(pc);
     }
 
-    AstNode *array = ast_parse_array_type_start(pc);
-    if (array != nullptr) {
-        assert(array->type == NodeTypeArrayType);
-        while (true) {
-            if (eat_token_if(pc, TokenIdKeywordNull) != nullptr) {
-                array->data.array_type.is_null_terminated = true;
-                continue;
-            }
-
-            Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
-            if (allowzero_token != nullptr) {
-                array->data.array_type.allow_zero_token = allowzero_token;
-                continue;
-            }
-
-            AstNode *align_expr = ast_parse_byte_align(pc);
-            if (align_expr != nullptr) {
-                array->data.array_type.align_expr = align_expr;
-                continue;
-            }
-
-            if (eat_token_if(pc, TokenIdKeywordConst) != nullptr) {
-                array->data.array_type.is_const = true;
-                continue;
-            }
-
-            if (eat_token_if(pc, TokenIdKeywordVolatile) != nullptr) {
-                array->data.array_type.is_volatile = true;
-                continue;
+    Token *arr_init_lbracket = eat_token_if(pc, TokenIdLBracket);
+    if (arr_init_lbracket != nullptr) {
+        Token *underscore = eat_token_if(pc, TokenIdSymbol);
+        if (underscore == nullptr) {
+            put_back_token(pc);
+        } else if (!buf_eql_str(token_buf(underscore), "_")) {
+            put_back_token(pc);
+            put_back_token(pc);
+        } else {
+            AstNode *sentinel = nullptr;
+            Token *colon = eat_token_if(pc, TokenIdColon);
+            if (colon != nullptr) {
+                sentinel = ast_expect(pc, ast_parse_expr);
             }
-            break;
+            expect_token(pc, TokenIdRBracket);
+            AstNode *node = ast_create_node(pc, NodeTypeInferredArrayType, arr_init_lbracket);
+            node->data.inferred_array_type.sentinel = sentinel;
+            return node;
         }
-
-        return array;
     }
 
+
     AstNode *ptr = ast_parse_ptr_type_start(pc);
     if (ptr != nullptr) {
         assert(ptr->type == NodeTypePointerType);
@@ -2657,11 +2637,6 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
         if (child == nullptr)
             child = ptr;
         while (true) {
-            if (eat_token_if(pc, TokenIdKeywordNull) != nullptr) {
-                child->data.pointer_type.is_null_terminated = true;
-                continue;
-            }
-
             Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
             if (allowzero_token != nullptr) {
                 child->data.pointer_type.allow_zero_token = allowzero_token;
@@ -2699,9 +2674,35 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
         return ptr;
     }
 
-    Token *arr_init = eat_token_if(pc, TokenIdBracketUnderscoreBracket);
-    if (arr_init != nullptr) {
-        return ast_create_node(pc, NodeTypeInferredArrayType, arr_init);
+    AstNode *array = ast_parse_array_type_start(pc);
+    if (array != nullptr) {
+        assert(array->type == NodeTypeArrayType);
+        while (true) {
+            Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
+            if (allowzero_token != nullptr) {
+                array->data.array_type.allow_zero_token = allowzero_token;
+                continue;
+            }
+
+            AstNode *align_expr = ast_parse_byte_align(pc);
+            if (align_expr != nullptr) {
+                array->data.array_type.align_expr = align_expr;
+                continue;
+            }
+
+            if (eat_token_if(pc, TokenIdKeywordConst) != nullptr) {
+                array->data.array_type.is_const = true;
+                continue;
+            }
+
+            if (eat_token_if(pc, TokenIdKeywordVolatile) != nullptr) {
+                array->data.array_type.is_volatile = true;
+                continue;
+            }
+            break;
+        }
+
+        return array;
     }
 
 
@@ -2775,9 +2776,15 @@ static AstNode *ast_parse_array_type_start(ParseContext *pc) {
         return nullptr;
 
     AstNode *size = ast_parse_expr(pc);
+    AstNode *sentinel = nullptr;
+    Token *colon = eat_token_if(pc, TokenIdColon);
+    if (colon != nullptr) {
+        sentinel = ast_expect(pc, ast_parse_expr);
+    }
     expect_token(pc, TokenIdRBracket);
     AstNode *res = ast_create_node(pc, NodeTypeArrayType, lbracket);
     res->data.array_type.size = size;
+    res->data.array_type.sentinel = sentinel;
     return res;
 }
 
@@ -2787,35 +2794,63 @@ static AstNode *ast_parse_array_type_start(ParseContext *pc) {
 //      / PTRUNKNOWN
 //      / PTRC
 static AstNode *ast_parse_ptr_type_start(ParseContext *pc) {
+    AstNode *sentinel = nullptr;
+
     Token *asterisk = eat_token_if(pc, TokenIdStar);
     if (asterisk != nullptr) {
+        Token *colon = eat_token_if(pc, TokenIdColon);
+        if (colon != nullptr) {
+            sentinel = ast_expect(pc, ast_parse_expr);
+        }
         AstNode *res = ast_create_node(pc, NodeTypePointerType, asterisk);
         res->data.pointer_type.star_token = asterisk;
+        res->data.pointer_type.sentinel = sentinel;
         return res;
     }
 
     Token *asterisk2 = eat_token_if(pc, TokenIdStarStar);
     if (asterisk2 != nullptr) {
+        Token *colon = eat_token_if(pc, TokenIdColon);
+        if (colon != nullptr) {
+            sentinel = ast_expect(pc, ast_parse_expr);
+        }
         AstNode *res = ast_create_node(pc, NodeTypePointerType, asterisk2);
         AstNode *res2 = ast_create_node(pc, NodeTypePointerType, asterisk2);
         res->data.pointer_type.star_token = asterisk2;
         res2->data.pointer_type.star_token = asterisk2;
+        res2->data.pointer_type.sentinel = sentinel;
         res->data.pointer_type.op_expr = res2;
         return res;
     }
 
-    Token *multptr = eat_token_if(pc, TokenIdBracketStarBracket);
-    if (multptr != nullptr) {
-        AstNode *res = ast_create_node(pc, NodeTypePointerType, multptr);
-        res->data.pointer_type.star_token = multptr;
-        return res;
-    }
+    Token *lbracket = eat_token_if(pc, TokenIdLBracket);
+    if (lbracket != nullptr) {
+        Token *star = eat_token_if(pc, TokenIdStar);
+        if (star == nullptr) {
+            put_back_token(pc);
+        } else {
+            Token *c_tok = eat_token_if(pc, TokenIdSymbol);
+            if (c_tok != nullptr) {
+                if (!buf_eql_str(token_buf(c_tok), "c")) {
+                    put_back_token(pc); // c symbol
+                } else {
+                    expect_token(pc, TokenIdRBracket);
+                    AstNode *res = ast_create_node(pc, NodeTypePointerType, lbracket);
+                    res->data.pointer_type.star_token = c_tok;
+                    return res;
+                }
+            }
 
-    Token *cptr = eat_token_if(pc, TokenIdBracketStarCBracket);
-    if (cptr != nullptr) {
-        AstNode *res = ast_create_node(pc, NodeTypePointerType, cptr);
-        res->data.pointer_type.star_token = cptr;
-        return res;
+            Token *colon = eat_token_if(pc, TokenIdColon);
+            if (colon != nullptr) {
+                sentinel = ast_expect(pc, ast_parse_expr);
+            }
+            expect_token(pc, TokenIdRBracket);
+            AstNode *res = ast_create_node(pc, NodeTypePointerType, lbracket);
+            res->data.pointer_type.star_token = lbracket;
+            res->data.pointer_type.sentinel = sentinel;
+            return res;
+        }
     }
 
     return nullptr;
@@ -3093,10 +3128,12 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
             break;
         case NodeTypeArrayType:
             visit_field(&node->data.array_type.size, visit, context);
+            visit_field(&node->data.array_type.sentinel, visit, context);
             visit_field(&node->data.array_type.child_type, visit, context);
             visit_field(&node->data.array_type.align_expr, visit, context);
             break;
         case NodeTypeInferredArrayType:
+            visit_field(&node->data.array_type.sentinel, visit, context);
             visit_field(&node->data.array_type.child_type, visit, context);
             break;
         case NodeTypeAnyFrameType:
@@ -3106,6 +3143,7 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
             // none
             break;
         case NodeTypePointerType:
+            visit_field(&node->data.pointer_type.sentinel, visit, context);
             visit_field(&node->data.pointer_type.align_expr, visit, context);
             visit_field(&node->data.pointer_type.op_expr, visit, context);
             break;
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 5088fbdbf8..f8b5059bf1 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -222,10 +222,6 @@ enum TokenizeState {
     TokenizeStateSawAtSign,
     TokenizeStateCharCode,
     TokenizeStateError,
-    TokenizeStateLBracket,
-    TokenizeStateLBracketStar,
-    TokenizeStateLBracketStarC,
-    TokenizeStateLBracketUnderscore,
 };
 
 
@@ -480,8 +476,8 @@ void tokenize(Buf *buf, Tokenization *out) {
                         end_token(&t);
                         break;
                     case '[':
-                        t.state = TokenizeStateLBracket;
                         begin_token(&t, TokenIdLBracket);
+                        end_token(&t);
                         break;
                     case ']':
                         begin_token(&t, TokenIdRBracket);
@@ -775,62 +771,6 @@ void tokenize(Buf *buf, Tokenization *out) {
                         continue;
                 }
                 break;
-            case TokenizeStateLBracket:
-                switch (c) {
-                    case '*':
-                        t.state = TokenizeStateLBracketStar;
-                        break;
-                    case '_':
-                        t.state = TokenizeStateLBracketUnderscore;
-                        break;
-                    default:
-                        // reinterpret as just an lbracket
-                        t.pos -= 1;
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        continue;
-                }
-                break;
-            case TokenizeStateLBracketUnderscore:
-                switch (c) {
-                    case ']':
-                        set_token_id(&t, t.cur_tok, TokenIdBracketUnderscoreBracket);
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        break;
-                    default:
-                        // reinterpret as just an lbracket
-                        t.pos -= 2;
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        continue;
-                }
-                break;
-            case TokenizeStateLBracketStar:
-                switch (c) {
-                    case 'c':
-                        t.state = TokenizeStateLBracketStarC;
-                        set_token_id(&t, t.cur_tok, TokenIdBracketStarCBracket);
-                        break;
-                    case ']':
-                        set_token_id(&t, t.cur_tok, TokenIdBracketStarBracket);
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        break;
-                    default:
-                        invalid_char_error(&t, c);
-                }
-                break;
-            case TokenizeStateLBracketStarC:
-                switch (c) {
-                    case ']':
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        break;
-                    default:
-                        invalid_char_error(&t, c);
-                }
-                break;
             case TokenizeStateSawPlusPercent:
                 switch (c) {
                     case '=':
@@ -1525,7 +1465,6 @@ void tokenize(Buf *buf, Tokenization *out) {
         case TokenizeStateLineString:
         case TokenizeStateLineStringEnd:
         case TokenizeStateSawBarBar:
-        case TokenizeStateLBracket:
         case TokenizeStateDocComment:
         case TokenizeStateContainerDocComment:
             end_token(&t);
@@ -1534,9 +1473,6 @@ void tokenize(Buf *buf, Tokenization *out) {
         case TokenizeStateSawBackslash:
         case TokenizeStateLineStringContinue:
         case TokenizeStateLineStringContinueC:
-        case TokenizeStateLBracketStar:
-        case TokenizeStateLBracketStarC:
-        case TokenizeStateLBracketUnderscore:
             tokenize_error(&t, "unexpected EOF");
             break;
         case TokenizeStateLineComment:
@@ -1576,8 +1512,6 @@ const char * token_name(TokenId id) {
         case TokenIdBitShiftRight: return ">>";
         case TokenIdBitShiftRightEq: return ">>=";
         case TokenIdBitXorEq: return "^=";
-        case TokenIdBracketStarBracket: return "[*]";
-        case TokenIdBracketStarCBracket: return "[*c]";
         case TokenIdCharLiteral: return "CharLiteral";
         case TokenIdCmpEq: return "==";
         case TokenIdCmpGreaterOrEq: return ">=";
@@ -1681,7 +1615,6 @@ const char * token_name(TokenId id) {
         case TokenIdTimesPercent: return "*%";
         case TokenIdTimesPercentEq: return "*%=";
         case TokenIdBarBarEq: return "||=";
-        case TokenIdBracketUnderscoreBracket: return "[_]";
         case TokenIdCount:
             zig_unreachable();
     }
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index b152eb079c..084512a576 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -28,9 +28,6 @@ enum TokenId {
     TokenIdBitShiftRight,
     TokenIdBitShiftRightEq,
     TokenIdBitXorEq,
-    TokenIdBracketStarBracket,
-    TokenIdBracketStarCBracket,
-    TokenIdBracketUnderscoreBracket,
     TokenIdCharLiteral,
     TokenIdCmpEq,
     TokenIdCmpGreaterOrEq,
diff --git a/src/translate_c.cpp b/src/translate_c.cpp
index 5dd6064984..3fe5fced07 100644
--- a/src/translate_c.cpp
+++ b/src/translate_c.cpp
@@ -291,10 +291,9 @@ static TokenId ptr_len_to_token_id(PtrLen ptr_len) {
         case PtrLenSingle:
             return TokenIdStar;
         case PtrLenUnknown:
-        case PtrLenNull:
-            return TokenIdBracketStarBracket;
+            return TokenIdLBracket;
         case PtrLenC:
-            return TokenIdBracketStarCBracket;
+            return TokenIdSymbol;
     }
     zig_unreachable();
 }
@@ -303,7 +302,6 @@ static AstNode *trans_create_node_ptr_type(Context *c, bool is_const, bool is_vo
     AstNode *node = trans_create_node(c, NodeTypePointerType);
     node->data.pointer_type.star_token = allocate<ZigToken>(1);
     node->data.pointer_type.star_token->id = ptr_len_to_token_id(ptr_len);
-    node->data.pointer_type.is_null_terminated = (ptr_len == PtrLenNull);
     node->data.pointer_type.is_const = is_const;
     node->data.pointer_type.is_volatile = is_volatile;
     node->data.pointer_type.op_expr = child_node;
diff --git a/test/stage1/behavior/array.zig b/test/stage1/behavior/array.zig
index b9000125b3..47e74cd310 100644
--- a/test/stage1/behavior/array.zig
+++ b/test/stage1/behavior/array.zig
@@ -351,7 +351,7 @@ test "anonymous literal in array" {
 test "access the null element of a null terminated array" {
     const S = struct {
         fn doTheTest() void {
-            var array: [4]null u8 = .{'a', 'o', 'e', 'u'};
+            var array: [4:0]u8 = .{'a', 'o', 'e', 'u'};
             comptime expect(array[4] == 0);
             var len: usize = 4;
             expect(array[len] == 0);
diff --git a/test/stage1/behavior/cast.zig b/test/stage1/behavior/cast.zig
index affd7afe5e..9fccff51e3 100644
--- a/test/stage1/behavior/cast.zig
+++ b/test/stage1/behavior/cast.zig
@@ -226,7 +226,7 @@ fn testCastConstArrayRefToConstSlice() void {
     {
         const blah = "aoeu".*;
         const const_array_ref = &blah;
-        expect(@typeOf(const_array_ref) == *const [4]null u8);
+        expect(@typeOf(const_array_ref) == *const [4:0]u8);
         const slice: []const u8 = const_array_ref;
         expect(mem.eql(u8, slice, "aoeu"));
     }
diff --git a/test/stage1/behavior/misc.zig b/test/stage1/behavior/misc.zig
index a0188dcedd..6ac745f5c5 100644
--- a/test/stage1/behavior/misc.zig
+++ b/test/stage1/behavior/misc.zig
@@ -362,8 +362,8 @@ test "string concatenation" {
     const a = "OK" ++ " IT " ++ "WORKED";
     const b = "OK IT WORKED";
 
-    comptime expect(@typeOf(a) == *const [12]null u8);
-    comptime expect(@typeOf(b) == *const [12]null u8);
+    comptime expect(@typeOf(a) == *const [12:0]u8);
+    comptime expect(@typeOf(b) == *const [12:0]u8);
 
     const len = mem.len(u8, b);
     const len_with_null = len + 1;
diff --git a/test/stage1/behavior/pointers.zig b/test/stage1/behavior/pointers.zig
index 7d8bdea569..6529a59059 100644
--- a/test/stage1/behavior/pointers.zig
+++ b/test/stage1/behavior/pointers.zig
@@ -205,7 +205,7 @@ test "null terminated pointer" {
     const S = struct {
         fn doTheTest() void {
             var array_with_zero = [_]u8{'h', 'e', 'l', 'l', 'o', 0};
-            var zero_ptr: [*]null const u8 = @ptrCast([*]null const u8, &array_with_zero);
+            var zero_ptr: [*:0]const u8 = @ptrCast([*:0]const u8, &array_with_zero);
             var no_zero_ptr: [*]const u8 = zero_ptr;
             expect(std.mem.eql(u8, std.mem.toSliceConst(u8, no_zero_ptr), "hello"));
         }
diff --git a/test/stage1/behavior/type.zig b/test/stage1/behavior/type.zig
index b1bb2e85bd..e3ce4d0904 100644
--- a/test/stage1/behavior/type.zig
+++ b/test/stage1/behavior/type.zig
@@ -98,21 +98,21 @@ test "Type.Array" {
         .Array = TypeInfo.Array{
             .len = 123,
             .child = u8,
-            .is_null_terminated = false,
+            .sentinel = null,
         },
     }));
     testing.expect([2]u32 == @Type(TypeInfo{
         .Array = TypeInfo.Array{
             .len = 2,
             .child = u32,
-            .is_null_terminated = false,
+            .sentinel = null,
         },
     }));
-    testing.expect([2]null u32 == @Type(TypeInfo{
+    testing.expect([2:0]u32 == @Type(TypeInfo{
         .Array = TypeInfo.Array{
             .len = 2,
             .child = u32,
-            .is_null_terminated = true,
+            .sentinel = &0,
         },
     }));
     testTypes([_]type{ [1]u8, [30]usize, [7]bool });
diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig
index 4da2bb3ca2..dcd4da3d0f 100644
--- a/test/stage1/behavior/type_info.zig
+++ b/test/stage1/behavior/type_info.zig
@@ -71,17 +71,17 @@ test "type info: null terminated pointer type info" {
 }
 
 fn testNullTerminatedPtr() void {
-    const ptr_info = @typeInfo([*]null u8);
+    const ptr_info = @typeInfo([*:0]u8);
     expect(@as(TypeId, ptr_info) == TypeId.Pointer);
     expect(ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many);
     expect(ptr_info.Pointer.is_const == false);
     expect(ptr_info.Pointer.is_volatile == false);
     expect(ptr_info.Pointer.is_null_terminated == true);
 
-    expect(@typeInfo([]null u8).Pointer.is_null_terminated == true);
-    expect(@typeInfo([10]null u8).Array.is_null_terminated == true);
-    expect(@typeInfo([10]null u8).Array.len == 10);
-    expect(@sizeOf([10]null u8) == 11);
+    expect(@typeInfo([:0]u8).Pointer.sentinel != null);
+    expect(@typeInfo([10:0]u8).Array.sentinel != null);
+    expect(@typeInfo([10:0]u8).Array.len == 10);
+    expect(@sizeOf([10:0]u8) == 11);
 }
 
 test "type info: C pointer type info" {
-- 
cgit v1.2.3


From f25182f46dd672eb5b10533c67ed462a3e5df999 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 23 Nov 2019 17:51:37 -0500
Subject: structs can have fields with type `var`

behavior tests passing now
---
 lib/std/builtin.zig                |  12 ++--
 src/all_types.hpp                  |   1 +
 src/analyze.cpp                    |   8 +++
 src/ast_render.cpp                 |   6 ++
 src/ir.cpp                         | 115 +++++++++++++++++++++----------------
 src/parser.cpp                     |   8 ++-
 test/stage1/behavior/type.zig      |   2 +-
 test/stage1/behavior/type_info.zig |   6 +-
 8 files changed, 97 insertions(+), 61 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 64fc68e4cc..af045c5231 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -146,10 +146,8 @@ pub const TypeInfo = union(enum) {
         is_allowzero: bool,
         /// The type of the sentinel is the element type of the pointer, which is
         /// the value of the `child` field in this struct. However there is no way
-        /// to refer to that type here, so this is a pointer to an opaque value.
-        /// It will be known at compile-time to be the correct type. Dereferencing
-        /// this pointer will work at compile-time.
-        sentinel: ?*const c_void,
+        /// to refer to that type here, so we use `var`.
+        sentinel: var,
 
         /// This data structure is used by the Zig language code generation and
         /// therefore must be kept in sync with the compiler implementation.
@@ -168,10 +166,8 @@ pub const TypeInfo = union(enum) {
         child: type,
         /// The type of the sentinel is the element type of the array, which is
         /// the value of the `child` field in this struct. However there is no way
-        /// to refer to that type here, so this is a pointer to an opaque value.
-        /// It will be known at compile-time to be the correct type. Dereferencing
-        /// this pointer will work at compile-time.
-        sentinel: ?*const c_void,
+        /// to refer to that type here, so we use `var`.
+        sentinel: var,
     };
 
     /// This data structure is used by the Zig language code generation and
diff --git a/src/all_types.hpp b/src/all_types.hpp
index 1f785a63f3..3b5a067ffc 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -601,6 +601,7 @@ enum NodeType {
     NodeTypeSuspend,
     NodeTypeAnyFrameType,
     NodeTypeEnumLiteral,
+    NodeTypeVarFieldType,
 };
 
 enum CallingConvention {
diff --git a/src/analyze.cpp b/src/analyze.cpp
index aa58d64aa4..d065f85c67 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -1179,6 +1179,10 @@ Error type_val_resolve_zero_bits(CodeGen *g, ConstExprValue *type_val, ZigType *
 Error type_val_resolve_is_opaque_type(CodeGen *g, ConstExprValue *type_val, bool *is_opaque_type) {
     if (type_val->special != ConstValSpecialLazy) {
         assert(type_val->special == ConstValSpecialStatic);
+        if (type_val->data.x_type == g->builtin_types.entry_var) {
+            *is_opaque_type = false;
+            return ErrorNone;
+        }
         *is_opaque_type = (type_val->data.x_type->id == ZigTypeIdOpaque);
         return ErrorNone;
     }
@@ -3667,6 +3671,7 @@ void scan_decls(CodeGen *g, ScopeDecls *decls_scope, AstNode *node) {
         case NodeTypeEnumLiteral:
         case NodeTypeAnyFrameType:
         case NodeTypeErrorSetField:
+        case NodeTypeVarFieldType:
             zig_unreachable();
     }
 }
@@ -5587,6 +5592,9 @@ ConstExprValue *get_the_one_possible_value(CodeGen *g, ZigType *type_entry) {
 
 ReqCompTime type_requires_comptime(CodeGen *g, ZigType *ty) {
     Error err;
+    if (ty == g->builtin_types.entry_var) {
+        return ReqCompTimeYes;
+    }
     switch (ty->id) {
         case ZigTypeIdInvalid:
             zig_unreachable();
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index f4f97c3730..531fcf1852 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -268,6 +268,8 @@ static const char *node_type_str(NodeType node_type) {
             return "EnumLiteral";
         case NodeTypeErrorSetField:
             return "ErrorSetField";
+        case NodeTypeVarFieldType:
+            return "VarFieldType";
     }
     zig_unreachable();
 }
@@ -1184,6 +1186,10 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
                 fprintf(ar->f, ".%s", buf_ptr(&node->data.enum_literal.identifier->data.str_lit.str));
                 break;
             }
+        case NodeTypeVarFieldType: {
+            fprintf(ar->f, "var");
+            break;
+        }
         case NodeTypeParamDecl:
         case NodeTypeTestDecl:
         case NodeTypeStructField:
diff --git a/src/ir.cpp b/src/ir.cpp
index a7a3fc51e4..df76d3f963 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -8556,6 +8556,9 @@ static IrInstruction *ir_gen_node_raw(IrBuilder *irb, AstNode *node, Scope *scop
             add_node_error(irb->codegen, node,
                 buf_sprintf("inferred array size invalid here"));
             return irb->codegen->invalid_instruction;
+        case NodeTypeVarFieldType:
+            return ir_lval_wrap(irb, scope,
+                    ir_build_const_type(irb, scope, node, irb->codegen->builtin_types.entry_var), lval, result_loc);
     }
     zig_unreachable();
 }
@@ -8715,6 +8718,9 @@ ConstExprValue *const_ptr_pointee(IrAnalyze *ira, CodeGen *codegen, ConstExprVal
     assert(val != nullptr);
     assert(const_val->type->id == ZigTypeIdPointer);
     ZigType *expected_type = const_val->type->data.pointer.child_type;
+    if (expected_type == codegen->builtin_types.entry_var) {
+        return val;
+    }
     switch (type_has_one_possible_value(codegen, expected_type)) {
         case OnePossibleValueInvalid:
             return nullptr;
@@ -13502,6 +13508,9 @@ static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruc
         }
         if (ptr->value.data.x_ptr.mut != ConstPtrMutRuntimeVar) {
             ConstExprValue *pointee = const_ptr_pointee_unchecked(ira->codegen, &ptr->value);
+            if (child_type == ira->codegen->builtin_types.entry_var) {
+                child_type = pointee->type;
+            }
             if (pointee->special != ConstValSpecialRuntime) {
                 IrInstruction *result = ir_const(ira, source_instruction, child_type);
 
@@ -19857,13 +19866,24 @@ static IrInstruction *ir_analyze_instruction_test_non_null(IrAnalyze *ira, IrIns
     return ir_analyze_test_non_null(ira, &instruction->base, value);
 }
 
+static ZigType *get_ptr_elem_type(CodeGen *g, IrInstruction *ptr) {
+    ir_assert(ptr->value.type->id == ZigTypeIdPointer, ptr);
+    ZigType *elem_type = ptr->value.type->data.pointer.child_type;
+    if (elem_type != g->builtin_types.entry_var)
+        return elem_type;
+
+    if (ir_resolve_lazy(g, ptr->source_node, &ptr->value))
+        return g->builtin_types.entry_invalid;
+
+    assert(value_is_comptime(&ptr->value));
+    ConstExprValue *pointee = const_ptr_pointee_unchecked(g, &ptr->value);
+    return pointee->type;
+}
+
 static IrInstruction *ir_analyze_unwrap_optional_payload(IrAnalyze *ira, IrInstruction *source_instr,
         IrInstruction *base_ptr, bool safety_check_on, bool initializing)
 {
-    ZigType *ptr_type = base_ptr->value.type;
-    assert(ptr_type->id == ZigTypeIdPointer);
-
-    ZigType *type_entry = ptr_type->data.pointer.child_type;
+    ZigType *type_entry = get_ptr_elem_type(ira->codegen, base_ptr);
     if (type_is_invalid(type_entry))
         return ira->codegen->invalid_instruction;
 
@@ -19901,7 +19921,8 @@ static IrInstruction *ir_analyze_unwrap_optional_payload(IrAnalyze *ira, IrInstr
 
     ZigType *child_type = type_entry->data.maybe.child_type;
     ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
-            ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile, PtrLenSingle, 0, 0, 0, false);
+            base_ptr->value.type->data.pointer.is_const, base_ptr->value.type->data.pointer.is_volatile,
+            PtrLenSingle, 0, 0, 0, false);
 
     bool same_comptime_repr = types_have_same_zig_comptime_repr(ira->codegen, child_type, type_entry);
 
@@ -21627,20 +21648,15 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
     fields[5]->special = ConstValSpecialStatic;
     fields[5]->type = ira->codegen->builtin_types.entry_bool;
     fields[5]->data.x_bool = attrs_type->data.pointer.allow_zero;
-    // sentinel: ?*const c_void
-    ZigType *ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_c_void, true);
+    // sentinel: var
     ensure_field_index(result->type, "sentinel", 6);
     fields[6]->special = ConstValSpecialStatic;
-    fields[6]->type = get_optional_type(ira->codegen, ptr_type);
-    if (attrs_type->data.pointer.sentinel == nullptr) {
-        fields[6]->data.x_optional = nullptr;
+    if (attrs_type->data.pointer.sentinel != nullptr) {
+        fields[6]->type = get_optional_type(ira->codegen, attrs_type->data.pointer.child_type);
+        fields[6]->data.x_optional = attrs_type->data.pointer.sentinel;
     } else {
-        ConstExprValue *ptr_val = create_const_vals(1);
-        fields[6]->data.x_optional = ptr_val;
-        ptr_val->data.x_ptr.special = ConstPtrSpecialRef;
-        ptr_val->data.x_ptr.mut = ConstPtrMutComptimeConst;
-        ptr_val->data.x_ptr.data.ref.pointee = create_const_vals(1);
-        copy_const_val(ptr_val->data.x_ptr.data.ref.pointee, attrs_type->data.pointer.sentinel, false);
+        fields[6]->type = ira->codegen->builtin_types.entry_null;
+        fields[6]->data.x_optional = nullptr;
     }
 
     return result;
@@ -21762,23 +21778,10 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
                 fields[1]->special = ConstValSpecialStatic;
                 fields[1]->type = ira->codegen->builtin_types.entry_type;
                 fields[1]->data.x_type = type_entry->data.array.child_type;
-                // sentinel: ?*const c_void
+                // sentinel: var
                 fields[2]->special = ConstValSpecialStatic;
-                ZigType *ptr_type = get_pointer_to_type(ira->codegen,
-                        ira->codegen->builtin_types.entry_c_void, true);
-                fields[2]->type = get_optional_type(ira->codegen, ptr_type);
-                if (type_entry->data.array.sentinel == nullptr) {
-                    fields[2]->data.x_optional = nullptr;
-                } else {
-                    ConstExprValue *ptr_val = create_const_vals(1);
-                    fields[2]->data.x_optional = ptr_val;
-                    ptr_val->type = ptr_type;
-                    ptr_val->data.x_ptr.special = ConstPtrSpecialRef;
-                    ptr_val->data.x_ptr.mut = ConstPtrMutComptimeConst;
-                    ptr_val->data.x_ptr.data.ref.pointee = create_const_vals(1);
-                    copy_const_val(ptr_val->data.x_ptr.data.ref.pointee, type_entry->data.array.sentinel, false);
-                }
-
+                fields[2]->type = get_optional_type(ira->codegen, type_entry->data.array.child_type);
+                fields[2]->data.x_optional = type_entry->data.array.sentinel;
                 break;
             }
         case ZigTypeIdVector: {
@@ -22290,15 +22293,18 @@ static ConstExprValue *get_const_field(IrAnalyze *ira, ConstExprValue *struct_va
     return struct_value->data.x_struct.fields[field_index];
 }
 
-static ConstExprValue *get_const_field_variant(IrAnalyze *ira, ConstExprValue *struct_value,
-        const char *name, size_t field_index)
+static Error get_const_field_sentinel(IrAnalyze *ira, IrInstruction *source_instr, ConstExprValue *struct_value,
+        const char *name, size_t field_index, ZigType *elem_type, ConstExprValue **result)
 {
     ConstExprValue *field_val = get_const_field(ira, struct_value, name, field_index);
-    assert(field_val->type->id == ZigTypeIdOptional);
-    ConstExprValue *opt_val = field_val->data.x_optional;
-    if (opt_val == nullptr) return nullptr;
-    assert(opt_val->type->id == ZigTypeIdPointer);
-    return const_ptr_pointee_unchecked(ira->codegen, opt_val);
+    IrInstruction *field_inst = ir_const(ira, source_instr, field_val->type);
+    IrInstruction *casted_field_inst = ir_implicit_cast(ira, field_inst,
+            get_optional_type(ira->codegen, elem_type));
+    if (type_is_invalid(casted_field_inst->value.type))
+        return ErrorSemanticAnalyzeFail;
+
+    *result = casted_field_inst->value.data.x_optional;
+    return ErrorNone;
 }
 
 static bool get_const_field_bool(IrAnalyze *ira, ConstExprValue *struct_value, const char *name, size_t field_index)
@@ -22323,6 +22329,7 @@ static ZigType *get_const_field_meta_type(IrAnalyze *ira, ConstExprValue *struct
 }
 
 static ZigType *type_info_to_type(IrAnalyze *ira, IrInstruction *instruction, ZigTypeId tagTypeId, ConstExprValue *payload) {
+    Error err;
     switch (tagTypeId) {
         case ZigTypeIdInvalid:
             zig_unreachable();
@@ -22364,8 +22371,16 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInstruction *instruction, Zi
                 assert(size_value->type == ir_type_info_get_type(ira, "Size", type_info_pointer_type));
                 BuiltinPtrSize size_enum_index = (BuiltinPtrSize)bigint_as_u32(&size_value->data.x_enum_tag);
                 PtrLen ptr_len = size_enum_index_to_ptr_len(size_enum_index);
+                ZigType *elem_type = get_const_field_meta_type(ira, payload, "child", 4);
+                ConstExprValue *sentinel;
+                if ((err = get_const_field_sentinel(ira, instruction, payload, "sentinel", 6,
+                                elem_type, &sentinel)))
+                {
+                    return nullptr;
+                }
+
                 ZigType *ptr_type = get_pointer_to_type_extra2(ira->codegen,
-                    get_const_field_meta_type(ira, payload, "child", 4),
+                    elem_type,
                     get_const_field_bool(ira, payload, "is_const", 1),
                     get_const_field_bool(ira, payload, "is_volatile", 2),
                     ptr_len,
@@ -22373,22 +22388,26 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInstruction *instruction, Zi
                     0, // bit_offset_in_host
                     0, // host_int_bytes
                     get_const_field_bool(ira, payload, "is_allowzero", 5),
-                    VECTOR_INDEX_NONE,
-                    nullptr,
-                    get_const_field_variant(ira, payload, "sentinel", 6)
-                );
+                    VECTOR_INDEX_NONE, nullptr, sentinel);
                 if (size_enum_index != 2)
                     return ptr_type;
                 return get_slice_type(ira->codegen, ptr_type);
             }
-        case ZigTypeIdArray:
+        case ZigTypeIdArray: {
             assert(payload->special == ConstValSpecialStatic);
             assert(payload->type == ir_type_info_get_type(ira, "Array", nullptr));
+            ZigType *elem_type = get_const_field_meta_type(ira, payload, "child", 1);
+            ConstExprValue *sentinel;
+            if ((err = get_const_field_sentinel(ira, instruction, payload, "sentinel", 2,
+                            elem_type, &sentinel)))
+            {
+                return nullptr;
+            }
             return get_array_type(ira->codegen,
-                get_const_field_meta_type(ira, payload, "child", 1),
+                elem_type,
                 bigint_as_u64(get_const_field_lit_int(ira, payload, "len", 0)),
-                get_const_field_variant(ira, payload, "sentinel", 2)
-            );
+                sentinel);
+        }
         case ZigTypeIdComptimeFloat:
             return ira->codegen->builtin_types.entry_num_lit_float;
         case ZigTypeIdComptimeInt:
diff --git a/src/parser.cpp b/src/parser.cpp
index 61f3120d0e..429566ecc1 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -848,7 +848,12 @@ static AstNode *ast_parse_container_field(ParseContext *pc) {
 
     AstNode *type_expr = nullptr;
     if (eat_token_if(pc, TokenIdColon) != nullptr) {
-        type_expr = ast_expect(pc, ast_parse_type_expr);
+        Token *var_tok = eat_token_if(pc, TokenIdKeywordVar);
+        if (var_tok != nullptr) {
+            type_expr = ast_create_node(pc, NodeTypeVarFieldType, var_tok);
+        } else {
+            type_expr = ast_expect(pc, ast_parse_type_expr);
+        }
     }
     AstNode *align_expr = ast_parse_byte_align(pc);
     AstNode *expr = nullptr;
@@ -3163,6 +3168,7 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
             visit_field(&node->data.suspend.block, visit, context);
             break;
         case NodeTypeEnumLiteral:
+        case NodeTypeVarFieldType:
             break;
     }
 }
diff --git a/test/stage1/behavior/type.zig b/test/stage1/behavior/type.zig
index e3ce4d0904..f083359d1d 100644
--- a/test/stage1/behavior/type.zig
+++ b/test/stage1/behavior/type.zig
@@ -112,7 +112,7 @@ test "Type.Array" {
         .Array = TypeInfo.Array{
             .len = 2,
             .child = u32,
-            .sentinel = &0,
+            .sentinel = 0,
         },
     }));
     testTypes([_]type{ [1]u8, [30]usize, [7]bool });
diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig
index dcd4da3d0f..598bbca6be 100644
--- a/test/stage1/behavior/type_info.zig
+++ b/test/stage1/behavior/type_info.zig
@@ -46,7 +46,7 @@ fn testPointer() void {
     expect(u32_ptr_info.Pointer.is_volatile == false);
     expect(u32_ptr_info.Pointer.alignment == @alignOf(u32));
     expect(u32_ptr_info.Pointer.child == u32);
-    expect(u32_ptr_info.Pointer.is_null_terminated == false);
+    expect(u32_ptr_info.Pointer.sentinel == null);
 }
 
 test "type info: unknown length pointer type info" {
@@ -60,7 +60,7 @@ fn testUnknownLenPtr() void {
     expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many);
     expect(u32_ptr_info.Pointer.is_const == true);
     expect(u32_ptr_info.Pointer.is_volatile == true);
-    expect(u32_ptr_info.Pointer.is_null_terminated == false);
+    expect(u32_ptr_info.Pointer.sentinel == null);
     expect(u32_ptr_info.Pointer.alignment == @alignOf(f64));
     expect(u32_ptr_info.Pointer.child == f64);
 }
@@ -76,7 +76,7 @@ fn testNullTerminatedPtr() void {
     expect(ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many);
     expect(ptr_info.Pointer.is_const == false);
     expect(ptr_info.Pointer.is_volatile == false);
-    expect(ptr_info.Pointer.is_null_terminated == true);
+    expect(ptr_info.Pointer.sentinel.? == 0);
 
     expect(@typeInfo([:0]u8).Pointer.sentinel != null);
     expect(@typeInfo([10:0]u8).Array.sentinel != null);
-- 
cgit v1.2.3


From 26c8930b9594ab320b0e3add682e99063491142e Mon Sep 17 00:00:00 2001
From: LemonBoy <thatlemon@gmail.com>
Date: Mon, 2 Dec 2019 21:07:44 +0100
Subject: Accept comptime-known expression for asm

---
 lib/std/zig/parse.zig       |   6 +-
 lib/std/zig/parser_test.zig |  23 +++++++
 src/all_types.hpp           |  18 +++--
 src/ast_render.cpp          |   4 +-
 src/codegen.cpp             |   8 +--
 src/ir.cpp                  | 159 +++++++++++++++++++++++++++-----------------
 src/ir_print.cpp            |  61 ++++++++++++++---
 src/parser.cpp              |   2 +-
 8 files changed, 193 insertions(+), 88 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 3ece8d150b..829ad2acbe 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -1495,13 +1495,13 @@ fn parseSwitchExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     return &node.base;
 }
 
-/// AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN STRINGLITERAL AsmOutput? RPAREN
+/// AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
 fn parseAsmExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     const asm_token = eatToken(it, .Keyword_asm) orelse return null;
     const volatile_token = eatToken(it, .Keyword_volatile);
     _ = try expectToken(it, tree, .LParen);
-    const template = try expectNode(arena, it, tree, parseStringLiteral, AstError{
-        .ExpectedStringLiteral = AstError.ExpectedStringLiteral{ .token = it.index },
+    const template = try expectNode(arena, it, tree, parseExpr, AstError{
+        .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
     });
 
     const node = try arena.create(Node.Asm);
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 0d38ec5ccb..4e20d16354 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -1,3 +1,26 @@
+test "zig fmt: asm expression with comptime content" {
+    try testCanonical(
+        \\comptime {
+        \\    asm ("foo" ++ "bar");
+        \\}
+        \\pub fn main() void {
+        \\    asm volatile ("foo" ++ "bar");
+        \\    asm volatile ("foo" ++ "bar"
+        \\        : [_] "" (x)
+        \\    );
+        \\    asm volatile ("foo" ++ "bar"
+        \\        : [_] "" (x)
+        \\        : [_] "" (y)
+        \\    );
+        \\    asm volatile ("foo" ++ "bar"
+        \\        : [_] "" (x)
+        \\        : [_] "" (y)
+        \\        : "h", "e", "l", "l", "o"
+        \\    );
+        \\}
+        \\
+    );
+}
 test "zig fmt: var struct field" {
     try testCanonical(
         \\pub const Pointer = struct {
diff --git a/src/all_types.hpp b/src/all_types.hpp
index cc11741870..5a248f9cd2 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -949,7 +949,7 @@ struct AsmToken {
 
 struct AstNodeAsmExpr {
     Token *volatile_token;
-    Token *asm_template;
+    AstNode *asm_template;
     ZigList<AsmOutput*> output_list;
     ZigList<AsmInput*> input_list;
     ZigList<Buf*> clobber_list;
@@ -2496,8 +2496,8 @@ enum IrInstructionId {
     IrInstructionIdArrayType,
     IrInstructionIdAnyFrameType,
     IrInstructionIdSliceType,
-    IrInstructionIdGlobalAsm,
-    IrInstructionIdAsm,
+    IrInstructionIdAsmSrc,
+    IrInstructionIdAsmGen,
     IrInstructionIdSizeOf,
     IrInstructionIdTestNonNull,
     IrInstructionIdOptionalUnwrapPtr,
@@ -3049,13 +3049,19 @@ struct IrInstructionSliceType {
     bool is_allow_zero;
 };
 
-struct IrInstructionGlobalAsm {
+struct IrInstructionAsmSrc {
     IrInstruction base;
 
-    Buf *asm_code;
+    IrInstruction *asm_template;
+    IrInstruction **input_list;
+    IrInstruction **output_types;
+    ZigVar **output_vars;
+    size_t return_count;
+    bool has_side_effects;
+    bool is_global;
 };
 
-struct IrInstructionAsm {
+struct IrInstructionAsmGen {
     IrInstruction base;
 
     Buf *asm_template;
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index 531fcf1852..a8fb899ec3 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -884,7 +884,9 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
             {
                 AstNodeAsmExpr *asm_expr = &node->data.asm_expr;
                 const char *volatile_str = (asm_expr->volatile_token != nullptr) ? " volatile" : "";
-                fprintf(ar->f, "asm%s (\"%s\"\n", volatile_str, buf_ptr(&asm_expr->asm_template->data.str_lit.str));
+                fprintf(ar->f, "asm%s (", volatile_str);
+                render_node_ungrouped(ar, asm_expr->asm_template);
+                fprintf(ar->f, ")");
                 print_indent(ar);
                 fprintf(ar->f, ": ");
                 for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 06834a7e4b..dc29e8f4b1 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -4437,7 +4437,7 @@ static size_t find_asm_index(CodeGen *g, AstNode *node, AsmToken *tok, Buf *src_
     return SIZE_MAX;
 }
 
-static LLVMValueRef ir_render_asm(CodeGen *g, IrExecutable *executable, IrInstructionAsm *instruction) {
+static LLVMValueRef ir_render_asm_gen(CodeGen *g, IrExecutable *executable, IrInstructionAsmGen *instruction) {
     AstNode *asm_node = instruction->base.source_node;
     assert(asm_node->type == NodeTypeAsmExpr);
     AstNodeAsmExpr *asm_expr = &asm_node->data.asm_expr;
@@ -6135,7 +6135,6 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
         case IrInstructionIdPtrCastSrc:
         case IrInstructionIdCmpxchgSrc:
         case IrInstructionIdLoadPtr:
-        case IrInstructionIdGlobalAsm:
         case IrInstructionIdHasDecl:
         case IrInstructionIdUndeclaredIdent:
         case IrInstructionIdCallSrc:
@@ -6156,6 +6155,7 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
         case IrInstructionIdAwaitSrc:
         case IrInstructionIdSplatSrc:
         case IrInstructionIdMergeErrSets:
+        case IrInstructionIdAsmSrc:
             zig_unreachable();
 
         case IrInstructionIdDeclVarGen:
@@ -6192,8 +6192,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_struct_field_ptr(g, executable, (IrInstructionStructFieldPtr *)instruction);
         case IrInstructionIdUnionFieldPtr:
             return ir_render_union_field_ptr(g, executable, (IrInstructionUnionFieldPtr *)instruction);
-        case IrInstructionIdAsm:
-            return ir_render_asm(g, executable, (IrInstructionAsm *)instruction);
+        case IrInstructionIdAsmGen:
+            return ir_render_asm_gen(g, executable, (IrInstructionAsmGen *)instruction);
         case IrInstructionIdTestNonNull:
             return ir_render_test_non_null(g, executable, (IrInstructionTestNonNull *)instruction);
         case IrInstructionIdOptionalUnwrapPtr:
diff --git a/src/ir.cpp b/src/ir.cpp
index a40836c9e1..044caa4d4e 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -339,10 +339,10 @@ static void destroy_instruction(IrInstruction *inst) {
             return destroy(reinterpret_cast<IrInstructionSliceType *>(inst), name);
         case IrInstructionIdAnyFrameType:
             return destroy(reinterpret_cast<IrInstructionAnyFrameType *>(inst), name);
-        case IrInstructionIdGlobalAsm:
-            return destroy(reinterpret_cast<IrInstructionGlobalAsm *>(inst), name);
-        case IrInstructionIdAsm:
-            return destroy(reinterpret_cast<IrInstructionAsm *>(inst), name);
+        case IrInstructionIdAsmSrc:
+            return destroy(reinterpret_cast<IrInstructionAsmSrc *>(inst), name);
+        case IrInstructionIdAsmGen:
+            return destroy(reinterpret_cast<IrInstructionAsmGen *>(inst), name);
         case IrInstructionIdSizeOf:
             return destroy(reinterpret_cast<IrInstructionSizeOf *>(inst), name);
         case IrInstructionIdTestNonNull:
@@ -1028,12 +1028,12 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionSliceType *) {
     return IrInstructionIdSliceType;
 }
 
-static constexpr IrInstructionId ir_instruction_id(IrInstructionGlobalAsm *) {
-    return IrInstructionIdGlobalAsm;
+static constexpr IrInstructionId ir_instruction_id(IrInstructionAsmSrc *) {
+    return IrInstructionIdAsmSrc;
 }
 
-static constexpr IrInstructionId ir_instruction_id(IrInstructionAsm *) {
-    return IrInstructionIdAsm;
+static constexpr IrInstructionId ir_instruction_id(IrInstructionAsmGen *) {
+    return IrInstructionIdAsmGen;
 }
 
 static constexpr IrInstructionId ir_instruction_id(IrInstructionSizeOf *) {
@@ -2268,18 +2268,39 @@ static IrInstruction *ir_build_slice_type(IrBuilder *irb, Scope *scope, AstNode
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_global_asm(IrBuilder *irb, Scope *scope, AstNode *source_node, Buf *asm_code) {
-    IrInstructionGlobalAsm *instruction = ir_build_instruction<IrInstructionGlobalAsm>(irb, scope, source_node);
-    instruction->asm_code = asm_code;
+static IrInstruction *ir_build_asm_src(IrBuilder *irb, Scope *scope, AstNode *source_node,
+        IrInstruction *asm_template, IrInstruction **input_list, IrInstruction **output_types,
+        ZigVar **output_vars, size_t return_count, bool has_side_effects, bool is_global)
+{
+    IrInstructionAsmSrc *instruction = ir_build_instruction<IrInstructionAsmSrc>(irb, scope, source_node);
+    instruction->asm_template = asm_template;
+    instruction->input_list = input_list;
+    instruction->output_types = output_types;
+    instruction->output_vars = output_vars;
+    instruction->return_count = return_count;
+    instruction->has_side_effects = has_side_effects;
+    instruction->is_global = is_global;
+
+    assert(source_node->type == NodeTypeAsmExpr);
+    for (size_t i = 0; i < source_node->data.asm_expr.output_list.length; i += 1) {
+        IrInstruction *output_type = output_types[i];
+        if (output_type) ir_ref_instruction(output_type, irb->current_basic_block);
+    }
+
+    for (size_t i = 0; i < source_node->data.asm_expr.input_list.length; i += 1) {
+        IrInstruction *input_value = input_list[i];
+        ir_ref_instruction(input_value, irb->current_basic_block);
+    }
+
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_asm(IrBuilder *irb, Scope *scope, AstNode *source_node,
+static IrInstruction *ir_build_asm_gen(IrAnalyze *ira, Scope *scope, AstNode *source_node,
         Buf *asm_template, AsmToken *token_list, size_t token_list_len,
         IrInstruction **input_list, IrInstruction **output_types, ZigVar **output_vars, size_t return_count,
         bool has_side_effects)
 {
-    IrInstructionAsm *instruction = ir_build_instruction<IrInstructionAsm>(irb, scope, source_node);
+    IrInstructionAsmGen *instruction = ir_build_instruction<IrInstructionAsmGen>(&ira->new_irb, scope, source_node);
     instruction->asm_template = asm_template;
     instruction->token_list = token_list;
     instruction->token_list_len = token_list_len;
@@ -2292,12 +2313,12 @@ static IrInstruction *ir_build_asm(IrBuilder *irb, Scope *scope, AstNode *source
     assert(source_node->type == NodeTypeAsmExpr);
     for (size_t i = 0; i < source_node->data.asm_expr.output_list.length; i += 1) {
         IrInstruction *output_type = output_types[i];
-        if (output_type) ir_ref_instruction(output_type, irb->current_basic_block);
+        if (output_type) ir_ref_instruction(output_type, ira->new_irb.current_basic_block);
     }
 
     for (size_t i = 0; i < source_node->data.asm_expr.input_list.length; i += 1) {
         IrInstruction *input_value = input_list[i];
-        ir_ref_instruction(input_value, irb->current_basic_block);
+        ir_ref_instruction(input_value, ira->new_irb.current_basic_block);
     }
 
     return &instruction->base;
@@ -7494,7 +7515,7 @@ static IrInstruction *ir_gen_undefined_literal(IrBuilder *irb, Scope *scope, Ast
     return ir_build_const_undefined(irb, scope, node);
 }
 
-static Error parse_asm_template(IrBuilder *irb, AstNode *source_node, Buf *asm_template,
+static Error parse_asm_template(IrAnalyze *ira, AstNode *source_node, Buf *asm_template,
         ZigList<AsmToken> *tok_list)
 {
     // TODO Connect the errors in this function back up to the actual source location
@@ -7542,7 +7563,7 @@ static Error parse_asm_template(IrBuilder *irb, AstNode *source_node, Buf *asm_t
                     cur_tok->end = i;
                     state = StateStart;
                 } else {
-                    add_node_error(irb->codegen, source_node,
+                    add_node_error(ira->codegen, source_node,
                         buf_create_from_str("expected a '%' or '['"));
                     return ErrorSemanticAnalyzeFail;
                 }
@@ -7565,7 +7586,7 @@ static Error parse_asm_template(IrBuilder *irb, AstNode *source_node, Buf *asm_t
                 {
                     // do nothing
                 } else {
-                    add_node_error(irb->codegen, source_node,
+                    add_node_error(ira->codegen, source_node,
                         buf_sprintf("invalid substitution character: '%c'", c));
                     return ErrorSemanticAnalyzeFail;
                 }
@@ -7578,7 +7599,7 @@ static Error parse_asm_template(IrBuilder *irb, AstNode *source_node, Buf *asm_t
             break;
         case StatePercent:
         case StateVar:
-            add_node_error(irb->codegen, source_node, buf_sprintf("unexpected end of assembly template"));
+            add_node_error(ira->codegen, source_node, buf_sprintf("unexpected end of assembly template"));
             return ErrorSemanticAnalyzeFail;
         case StateTemplate:
             cur_tok->end = buf_len(asm_template);
@@ -7607,14 +7628,16 @@ static size_t find_asm_index(CodeGen *g, AstNode *node, AsmToken *tok, Buf *src_
 }
 
 static IrInstruction *ir_gen_asm_expr(IrBuilder *irb, Scope *scope, AstNode *node) {
-    Error err;
     assert(node->type == NodeTypeAsmExpr);
     AstNodeAsmExpr *asm_expr = &node->data.asm_expr;
+
+    IrInstruction *asm_template = ir_gen_node(irb, asm_expr->asm_template, scope);
+    if (asm_template == irb->codegen->invalid_instruction)
+        return irb->codegen->invalid_instruction;
+
     bool is_volatile = asm_expr->volatile_token != nullptr;
     bool in_fn_scope = (scope_fn_entry(scope) != nullptr);
 
-    Buf *template_buf = &asm_expr->asm_template->data.str_lit.str;
-
     if (!in_fn_scope) {
         if (is_volatile) {
             add_token_error(irb->codegen, node->owner, asm_expr->volatile_token,
@@ -7630,12 +7653,8 @@ static IrInstruction *ir_gen_asm_expr(IrBuilder *irb, Scope *scope, AstNode *nod
             return irb->codegen->invalid_instruction;
         }
 
-        return ir_build_global_asm(irb, scope, node, template_buf);
-    }
-
-    ZigList<AsmToken> tok_list = {};
-    if ((err = parse_asm_template(irb, node, template_buf, &tok_list))) {
-        return irb->codegen->invalid_instruction;
+        return ir_build_asm_src(irb, scope, node, asm_template, nullptr, nullptr,
+                                nullptr, 0, is_volatile, true);
     }
 
     IrInstruction **input_list = allocate<IrInstruction *>(asm_expr->input_list.length);
@@ -7693,24 +7712,8 @@ static IrInstruction *ir_gen_asm_expr(IrBuilder *irb, Scope *scope, AstNode *nod
         input_list[i] = input_value;
     }
 
-    for (size_t token_i = 0; token_i < tok_list.length; token_i += 1) {
-        AsmToken asm_token = tok_list.at(token_i);
-        if (asm_token.id == AsmTokenIdVar) {
-            size_t index = find_asm_index(irb->codegen, node, &asm_token, template_buf);
-            if (index == SIZE_MAX) {
-                const char *ptr = buf_ptr(template_buf) + asm_token.start + 2;
-                uint32_t len = asm_token.end - asm_token.start - 2;
-
-                add_node_error(irb->codegen, node,
-                    buf_sprintf("could not find '%.*s' in the inputs or outputs",
-                        len, ptr));
-                return irb->codegen->invalid_instruction;
-            }
-        }
-    }
-
-    return ir_build_asm(irb, scope, node, template_buf, tok_list.items, tok_list.length,
-            input_list, output_types, output_vars, return_count, is_volatile);
+    return ir_build_asm_src(irb, scope, node, asm_template, input_list, output_types,
+                            output_vars, return_count, is_volatile, false);
 }
 
 static IrInstruction *ir_gen_if_optional_expr(IrBuilder *irb, Scope *scope, AstNode *node, LVal lval,
@@ -20150,21 +20153,49 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira,
     return result;
 }
 
-static IrInstruction *ir_analyze_instruction_global_asm(IrAnalyze *ira, IrInstructionGlobalAsm *instruction) {
-    buf_append_char(&ira->codegen->global_asm, '\n');
-    buf_append_buf(&ira->codegen->global_asm, instruction->asm_code);
-
-    return ir_const_void(ira, &instruction->base);
-}
+static IrInstruction *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsmSrc *asm_instruction) {
+    Error err;
 
-static IrInstruction *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm_instruction) {
     assert(asm_instruction->base.source_node->type == NodeTypeAsmExpr);
 
+    AstNode *node = asm_instruction->base.source_node;
     AstNodeAsmExpr *asm_expr = &asm_instruction->base.source_node->data.asm_expr;
 
+    Buf *template_buf = ir_resolve_str(ira, asm_instruction->asm_template->child);
+    if (template_buf == nullptr)
+        return ira->codegen->invalid_instruction;
+
+    if (asm_instruction->is_global) {
+        buf_append_char(&ira->codegen->global_asm, '\n');
+        buf_append_buf(&ira->codegen->global_asm, template_buf);
+
+        return ir_const_void(ira, &asm_instruction->base);
+    }
+
     if (!ir_emit_global_runtime_side_effect(ira, &asm_instruction->base))
         return ira->codegen->invalid_instruction;
 
+    ZigList<AsmToken> tok_list = {};
+    if ((err = parse_asm_template(ira, node, template_buf, &tok_list))) {
+        return ira->codegen->invalid_instruction;
+    }
+
+    for (size_t token_i = 0; token_i < tok_list.length; token_i += 1) {
+        AsmToken asm_token = tok_list.at(token_i);
+        if (asm_token.id == AsmTokenIdVar) {
+            size_t index = find_asm_index(ira->codegen, node, &asm_token, template_buf);
+            if (index == SIZE_MAX) {
+                const char *ptr = buf_ptr(template_buf) + asm_token.start + 2;
+                uint32_t len = asm_token.end - asm_token.start - 2;
+
+                add_node_error(ira->codegen, node,
+                    buf_sprintf("could not find '%.*s' in the inputs or outputs",
+                        len, ptr));
+                return ira->codegen->invalid_instruction;
+            }
+        }
+    }
+
     // TODO validate the output types and variable types
 
     IrInstruction **input_list = allocate<IrInstruction *>(asm_expr->input_list.length);
@@ -20197,9 +20228,9 @@ static IrInstruction *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAs
         input_list[i] = input_value;
     }
 
-    IrInstruction *result = ir_build_asm(&ira->new_irb,
+    IrInstruction *result = ir_build_asm_gen(ira,
         asm_instruction->base.scope, asm_instruction->base.source_node,
-        asm_instruction->asm_template, asm_instruction->token_list, asm_instruction->token_list_len,
+        template_buf, tok_list.items, tok_list.length,
         input_list, output_types, asm_instruction->output_vars, asm_instruction->return_count,
         asm_instruction->has_side_effects);
     result->value->type = return_type;
@@ -27722,6 +27753,7 @@ static IrInstruction *ir_analyze_instruction_base(IrAnalyze *ira, IrInstruction
         case IrInstructionIdSplatGen:
         case IrInstructionIdVectorExtractElem:
         case IrInstructionIdVectorStoreElem:
+        case IrInstructionIdAsmGen:
             zig_unreachable();
 
         case IrInstructionIdReturn:
@@ -27768,10 +27800,8 @@ static IrInstruction *ir_analyze_instruction_base(IrAnalyze *ira, IrInstruction
             return ir_analyze_instruction_any_frame_type(ira, (IrInstructionAnyFrameType *)instruction);
         case IrInstructionIdSliceType:
             return ir_analyze_instruction_slice_type(ira, (IrInstructionSliceType *)instruction);
-        case IrInstructionIdGlobalAsm:
-            return ir_analyze_instruction_global_asm(ira, (IrInstructionGlobalAsm *)instruction);
-        case IrInstructionIdAsm:
-            return ir_analyze_instruction_asm(ira, (IrInstructionAsm *)instruction);
+        case IrInstructionIdAsmSrc:
+            return ir_analyze_instruction_asm(ira, (IrInstructionAsmSrc *)instruction);
         case IrInstructionIdArrayType:
             return ir_analyze_instruction_array_type(ira, (IrInstructionArrayType *)instruction);
         case IrInstructionIdSizeOf:
@@ -28183,7 +28213,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdAssertZero:
         case IrInstructionIdAssertNonNull:
         case IrInstructionIdResizeSlice:
-        case IrInstructionIdGlobalAsm:
         case IrInstructionIdUndeclaredIdent:
         case IrInstructionIdEndExpr:
         case IrInstructionIdPtrOfArrayToSlice:
@@ -28303,9 +28332,15 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdVectorExtractElem:
             return false;
 
-        case IrInstructionIdAsm:
+        case IrInstructionIdAsmSrc:
+            {
+                IrInstructionAsmSrc *asm_instruction = (IrInstructionAsmSrc *)instruction;
+                return asm_instruction->has_side_effects;
+            }
+
+        case IrInstructionIdAsmGen:
             {
-                IrInstructionAsm *asm_instruction = (IrInstructionAsm *)instruction;
+                IrInstructionAsmGen *asm_instruction = (IrInstructionAsmGen *)instruction;
                 return asm_instruction->has_side_effects;
             }
         case IrInstructionIdUnwrapErrPayload:
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
index 1ce111e1fd..bacdd82251 100644
--- a/src/ir_print.cpp
+++ b/src/ir_print.cpp
@@ -124,10 +124,10 @@ const char* ir_instruction_type_str(IrInstructionId id) {
             return "AnyFrameType";
         case IrInstructionIdSliceType:
             return "SliceType";
-        case IrInstructionIdGlobalAsm:
-            return "GlobalAsm";
-        case IrInstructionIdAsm:
-            return "Asm";
+        case IrInstructionIdAsmSrc:
+            return "AsmSrc";
+        case IrInstructionIdAsmGen:
+            return "AsmGen";
         case IrInstructionIdSizeOf:
             return "SizeOf";
         case IrInstructionIdTestNonNull:
@@ -888,11 +888,50 @@ static void ir_print_any_frame_type(IrPrint *irp, IrInstructionAnyFrameType *ins
     }
 }
 
-static void ir_print_global_asm(IrPrint *irp, IrInstructionGlobalAsm *instruction) {
-    fprintf(irp->f, "asm(\"%s\")", buf_ptr(instruction->asm_code));
+static void ir_print_asm_src(IrPrint *irp, IrInstructionAsmSrc *instruction) {
+    assert(instruction->base.source_node->type == NodeTypeAsmExpr);
+    AstNodeAsmExpr *asm_expr = &instruction->base.source_node->data.asm_expr;
+    const char *volatile_kw = instruction->has_side_effects ? " volatile" : "";
+    fprintf(irp->f, "asm%s (", volatile_kw);
+    ir_print_other_instruction(irp, instruction->asm_template);
+
+    for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
+        AsmOutput *asm_output = asm_expr->output_list.at(i);
+        if (i != 0) fprintf(irp->f, ", ");
+
+        fprintf(irp->f, "[%s] \"%s\" (",
+                buf_ptr(asm_output->asm_symbolic_name),
+                buf_ptr(asm_output->constraint));
+        if (asm_output->return_type) {
+            fprintf(irp->f, "-> ");
+            ir_print_other_instruction(irp, instruction->output_types[i]);
+        } else {
+            fprintf(irp->f, "%s", buf_ptr(asm_output->variable_name));
+        }
+        fprintf(irp->f, ")");
+    }
+
+    fprintf(irp->f, " : ");
+    for (size_t i = 0; i < asm_expr->input_list.length; i += 1) {
+        AsmInput *asm_input = asm_expr->input_list.at(i);
+
+        if (i != 0) fprintf(irp->f, ", ");
+        fprintf(irp->f, "[%s] \"%s\" (",
+                buf_ptr(asm_input->asm_symbolic_name),
+                buf_ptr(asm_input->constraint));
+        ir_print_other_instruction(irp, instruction->input_list[i]);
+        fprintf(irp->f, ")");
+    }
+    fprintf(irp->f, " : ");
+    for (size_t i = 0; i < asm_expr->clobber_list.length; i += 1) {
+        Buf *reg_name = asm_expr->clobber_list.at(i);
+        if (i != 0) fprintf(irp->f, ", ");
+        fprintf(irp->f, "\"%s\"", buf_ptr(reg_name));
+    }
+    fprintf(irp->f, ")");
 }
 
-static void ir_print_asm(IrPrint *irp, IrInstructionAsm *instruction) {
+static void ir_print_asm_gen(IrPrint *irp, IrInstructionAsmGen *instruction) {
     assert(instruction->base.source_node->type == NodeTypeAsmExpr);
     AstNodeAsmExpr *asm_expr = &instruction->base.source_node->data.asm_expr;
     const char *volatile_kw = instruction->has_side_effects ? " volatile" : "";
@@ -2121,11 +2160,11 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction, bool
         case IrInstructionIdAnyFrameType:
             ir_print_any_frame_type(irp, (IrInstructionAnyFrameType *)instruction);
             break;
-        case IrInstructionIdGlobalAsm:
-            ir_print_global_asm(irp, (IrInstructionGlobalAsm *)instruction);
+        case IrInstructionIdAsmSrc:
+            ir_print_asm_src(irp, (IrInstructionAsmSrc *)instruction);
             break;
-        case IrInstructionIdAsm:
-            ir_print_asm(irp, (IrInstructionAsm *)instruction);
+        case IrInstructionIdAsmGen:
+            ir_print_asm_gen(irp, (IrInstructionAsmGen *)instruction);
             break;
         case IrInstructionIdSizeOf:
             ir_print_size_of(irp, (IrInstructionSizeOf *)instruction);
diff --git a/src/parser.cpp b/src/parser.cpp
index 429566ecc1..665e048a89 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -1891,7 +1891,7 @@ static AstNode *ast_parse_asm_expr(ParseContext *pc) {
 
     Token *volatile_token = eat_token_if(pc, TokenIdKeywordVolatile);
     expect_token(pc, TokenIdLParen);
-    Token *asm_template = expect_token(pc, TokenIdStringLiteral);
+    AstNode *asm_template = ast_expect(pc, ast_parse_expr);
     AstNode *res = ast_parse_asm_output(pc);
     if (res == nullptr)
         res = ast_create_node_no_line_info(pc, NodeTypeAsmExpr);
-- 
cgit v1.2.3


From fe8d65556dc49bb0da7ee621597c3b24f0e879f6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 8 Dec 2019 12:13:34 -0500
Subject: add syntax for comptime struct fields

---
 src/all_types.hpp               |  1 +
 src/analyze.cpp                 | 10 ++++++++++
 src/ir.cpp                      | 36 ++++++++++++++++++------------------
 src/parser.cpp                  | 14 ++++++++++++--
 test/compile_errors.zig         | 11 ++++++++++-
 test/stage1/behavior/struct.zig | 10 ++++++++++
 6 files changed, 61 insertions(+), 21 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/src/all_types.hpp b/src/all_types.hpp
index ebccbaa37f..6e1bfb5ad5 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -1006,6 +1006,7 @@ struct AstNodeStructField {
     // populated if the "align(A)" is present
     AstNode *align_expr;
     Buf doc_comments;
+    Token *comptime_token;
 };
 
 struct AstNodeStringLiteral {
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 37c93c638a..cf7296a9f8 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -2736,6 +2736,16 @@ static Error resolve_struct_zero_bits(CodeGen *g, ZigType *struct_type) {
             field_node = decl_node->data.container_decl.fields.at(i);
             type_struct_field->name = field_node->data.struct_field.name;
             type_struct_field->decl_node = field_node;
+            if (field_node->data.struct_field.comptime_token != nullptr) {
+                if (field_node->data.struct_field.value == nullptr) {
+                    add_token_error(g, field_node->owner,
+                        field_node->data.struct_field.comptime_token,
+                        buf_sprintf("comptime struct field missing initialization value"));
+                    struct_type->data.structure.resolve_status = ResolveStatusInvalid;
+                    return ErrorSemanticAnalyzeFail;
+                }
+                type_struct_field->is_comptime = true;
+            }
 
             if (field_node->data.struct_field.type == nullptr) {
                 add_node_error(g, field_node, buf_sprintf("struct field missing type"));
diff --git a/src/ir.cpp b/src/ir.cpp
index 5f398bb11a..cd9d895fd4 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -19514,6 +19514,18 @@ static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira,
     return ira->codegen->invalid_instruction;
 }
 
+static void memoize_field_init_val(CodeGen *codegen, ZigType *container_type, TypeStructField *field) {
+    if (field->init_val != nullptr) return;
+    if (field->decl_node->type != NodeTypeStructField) return;
+    AstNode *init_node = field->decl_node->data.struct_field.value;
+    if (init_node == nullptr) return;
+    // scope is not the scope of the struct init, it's the scope of the struct type decl
+    Scope *analyze_scope = &get_container_scope(container_type)->base;
+    // memoize it
+    field->init_val = analyze_const_value(codegen, analyze_scope, init_node,
+            field->type_entry, nullptr, UndefOk);
+}
+
 static IrInstruction *ir_analyze_struct_field_ptr(IrAnalyze *ira, IrInstruction *source_instr,
         TypeStructField *field, IrInstruction *struct_ptr, ZigType *struct_type, bool initializing)
 {
@@ -19523,6 +19535,7 @@ static IrInstruction *ir_analyze_struct_field_ptr(IrAnalyze *ira, IrInstruction
         return ira->codegen->invalid_instruction;
     if (field->is_comptime) {
         IrInstruction *elem = ir_const(ira, source_instr, field_type);
+        memoize_field_init_val(ira->codegen, struct_type, field);
         copy_const_val(elem->value, field->init_val);
         return ir_get_ref(ira, source_instr, elem, true, false);
     }
@@ -21556,25 +21569,12 @@ static IrInstruction *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruc
 
         // look for a default field value
         TypeStructField *field = container_type->data.structure.fields[i];
+        memoize_field_init_val(ira->codegen, container_type, field);
         if (field->init_val == nullptr) {
-            // it's not memoized. time to go analyze it
-            AstNode *init_node;
-            if (field->decl_node->type == NodeTypeStructField) {
-                init_node = field->decl_node->data.struct_field.value;
-            } else {
-                init_node = nullptr;
-            }
-            if (init_node == nullptr) {
-                ir_add_error_node(ira, instruction->source_node,
-                    buf_sprintf("missing field: '%s'", buf_ptr(container_type->data.structure.fields[i]->name)));
-                any_missing = true;
-                continue;
-            }
-            // scope is not the scope of the struct init, it's the scope of the struct type decl
-            Scope *analyze_scope = &get_container_scope(container_type)->base;
-            // memoize it
-            field->init_val = analyze_const_value(ira->codegen, analyze_scope, init_node,
-                    field->type_entry, nullptr, UndefOk);
+            ir_add_error_node(ira, instruction->source_node,
+                buf_sprintf("missing field: '%s'", buf_ptr(container_type->data.structure.fields[i]->name)));
+            any_missing = true;
+            continue;
         }
         if (type_is_invalid(field->init_val->type))
             return ira->codegen->invalid_instruction;
diff --git a/src/parser.cpp b/src/parser.cpp
index 665e048a89..1786e38d4b 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -536,8 +536,8 @@ static void ast_parse_container_doc_comments(ParseContext *pc, Buf *buf) {
 //     <- TestDecl ContainerMembers
 //      / TopLevelComptime ContainerMembers
 //      / KEYWORD_pub? TopLevelDecl ContainerMembers
-//      / ContainerField COMMA ContainerMembers
-//      / ContainerField
+//      / KEYWORD_comptime? ContainerField COMMA ContainerMembers
+//      / KEYWORD_comptime? ContainerField
 //      /
 static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
     AstNodeContainerDecl res = {};
@@ -574,10 +574,13 @@ static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
             ast_error(pc, peek_token(pc), "expected function or variable declaration after pub");
         }
 
+        Token *comptime_token = eat_token_if(pc, TokenIdKeywordCompTime);
+
         AstNode *container_field = ast_parse_container_field(pc);
         if (container_field != nullptr) {
             assert(container_field->type == NodeTypeStructField);
             container_field->data.struct_field.doc_comments = doc_comment_buf;
+            container_field->data.struct_field.comptime_token = comptime_token;
             res.fields.append(container_field);
             if (eat_token_if(pc, TokenIdComma) != nullptr) {
                 continue;
@@ -612,6 +615,13 @@ static AstNode *ast_parse_top_level_comptime(ParseContext *pc) {
     if (comptime == nullptr)
         return nullptr;
 
+    // 1 token lookahead because it could be a comptime struct field
+    Token *lbrace = peek_token(pc);
+    if (lbrace->id != TokenIdLBrace) {
+        put_back_token(pc);
+        return nullptr;
+    }
+
     AstNode *block = ast_expect(pc, ast_parse_block_expr);
     AstNode *res = ast_create_node(pc, NodeTypeCompTime, comptime);
     res->data.comptime_expr.expr = block;
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 13e666f49e..3cdf8723ac 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -2,6 +2,15 @@ const tests = @import("tests.zig");
 const builtin = @import("builtin");
 
 pub fn addCases(cases: *tests.CompileErrorContext) void {
+    cases.add("comptime struct field, no init value",
+        \\const Foo = struct {
+        \\    comptime b: i32,
+        \\};
+        \\export fn entry() void {
+        \\    var f: Foo = undefined;
+        \\}
+    , "tmp.zig:2:5: error: comptime struct field missing initialization value");
+
     cases.add(
         "bad usage of @call",
         \\export fn entry1() void {
@@ -32,7 +41,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:15:43: error: unable to evaluate constant expression",
     );
 
-    cases.add(
+    cases.add("exported async function",
         \\export async fn foo() void {}
     , "tmp.zig:1:1: error: exported function cannot be async");
 
diff --git a/test/stage1/behavior/struct.zig b/test/stage1/behavior/struct.zig
index 8ac14583c5..91f00006da 100644
--- a/test/stage1/behavior/struct.zig
+++ b/test/stage1/behavior/struct.zig
@@ -789,3 +789,13 @@ test "struct with var field" {
     expect(pt.x == 1);
     expect(pt.y == 2);
 }
+
+test "comptime struct field" {
+    const T = struct {
+        a: i32,
+        comptime b: i32 = 1234,
+    };
+
+    var foo: T = undefined;
+    comptime expect(foo.b == 1234);
+}
-- 
cgit v1.2.3


From a3f6a58c7785e7958f9d0b96d54356944bf34e32 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 9 Dec 2019 14:55:51 -0500
Subject: remove var args from the language

closes #208
---
 doc/langref.html.in                 |    5 +-
 lib/std/builtin.zig                 |    1 -
 lib/std/fmt.zig                     |   10 +-
 lib/std/hash/auto_hash.zig          |    1 -
 lib/std/special/docs/main.js        |    2 +-
 lib/std/testing.zig                 |    1 -
 src-self-hosted/type.zig            |   12 -
 src/all_types.hpp                   |    2 -
 src/analyze.cpp                     |   66 +-
 src/analyze.hpp                     |    3 -
 src/codegen.cpp                     |   10 -
 src/ir.cpp                          |  238 +--
 src/parser.cpp                      |    6 -
 test/compile_errors.zig             | 3841 +++++++++++++++--------------------
 test/gen_h.zig                      |   32 +-
 test/stage1/behavior/eval.zig       |    4 +-
 test/stage1/behavior/reflection.zig |    2 -
 test/stage1/behavior/type_info.zig  |    2 +-
 test/stage1/behavior/var_args.zig   |   53 +-
 test/tests.zig                      |  110 +-
 test/translate_c.zig                |  468 ++---
 21 files changed, 2049 insertions(+), 2820 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/doc/langref.html.in b/doc/langref.html.in
index bc23865a84..e51e59d562 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -5862,7 +5862,7 @@ pub fn main() void {
 
       {#code_begin|syntax#}
 /// Calls print and then flushes the buffer.
-pub fn printf(self: *OutStream, comptime format: []const u8, args: ...) anyerror!void {
+pub fn printf(self: *OutStream, comptime format: []const u8, args: var) anyerror!void {
     const State = enum {
         Start,
         OpenBrace,
@@ -8277,7 +8277,6 @@ test "integer truncation" {
           <li>{#link|union#}</li>
           <li>{#link|Functions#}</li>
           <li>BoundFn</li>
-          <li>ArgTuple</li>
           <li>{#link|struct#}</li>
       </ul>
       {#header_close#}
@@ -8310,7 +8309,6 @@ pub const TypeId = enum {
     Fn,
     Block,
     BoundFn,
-    ArgTuple,
     Opaque,
 };
       {#code_end#}
@@ -8343,7 +8341,6 @@ pub const TypeInfo = union(TypeId) {
     Union: Union,
     Fn: Fn,
     BoundFn: Fn,
-    ArgTuple: void,
     Opaque: void,
     Promise: Promise,
     Vector: Vector,
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 4c57915f92..36fa46e953 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -116,7 +116,6 @@ pub const TypeInfo = union(enum) {
     Union: Union,
     Fn: Fn,
     BoundFn: Fn,
-    ArgTuple: void,
     Opaque: void,
     Frame: void,
     AnyFrame: AnyFrame,
diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index f557e716a5..f01510b02c 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -94,9 +94,7 @@ pub fn format(
     args: var,
 ) Errors!void {
     const ArgSetType = @IntType(false, 32);
-    const args_fields = std.meta.fields(@typeOf(args));
-    const args_len = args_fields.len;
-    if (args_len > ArgSetType.bit_count) {
+    if (args.len > ArgSetType.bit_count) {
         @compileError("32 arguments max are supported per format call");
     }
 
@@ -160,14 +158,14 @@ pub fn format(
                     maybe_pos_arg.? += c - '0';
                     specifier_start = i + 1;
 
-                    if (maybe_pos_arg.? >= args_len) {
+                    if (maybe_pos_arg.? >= args.len) {
                         @compileError("Positional value refers to non-existent argument");
                     }
                 },
                 '}' => {
                     const arg_to_print = comptime nextArg(&used_pos_args, maybe_pos_arg, &next_arg);
 
-                    if (arg_to_print >= args_len) {
+                    if (arg_to_print >= args.len) {
                         @compileError("Too few arguments");
                     }
 
@@ -304,7 +302,7 @@ pub fn format(
             used_pos_args |= 1 << i;
         }
 
-        if (@popCount(ArgSetType, used_pos_args) != args_len) {
+        if (@popCount(ArgSetType, used_pos_args) != args.len) {
             @compileError("Unused arguments");
         }
         if (state != State.Start) {
diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index 07ee1d3d00..696a5e81dc 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -79,7 +79,6 @@ pub fn hash(hasher: var, key: var, comptime strat: HashStrategy) void {
         .NoReturn,
         .Opaque,
         .Undefined,
-        .ArgTuple,
         .Void,
         .Null,
         .BoundFn,
diff --git a/lib/std/special/docs/main.js b/lib/std/special/docs/main.js
index 349f496de0..8ea4598ee0 100644
--- a/lib/std/special/docs/main.js
+++ b/lib/std/special/docs/main.js
@@ -1194,7 +1194,7 @@
         // This is just for debugging purposes, not needed to function
         var assertList = ["Type","Void","Bool","NoReturn","Int","Float","Pointer","Array","Struct",
             "ComptimeFloat","ComptimeInt","Undefined","Null","Optional","ErrorUnion","ErrorSet","Enum",
-            "Union","Fn","BoundFn","ArgTuple","Opaque","Frame","AnyFrame","Vector","EnumLiteral"];
+            "Union","Fn","BoundFn","Opaque","Frame","AnyFrame","Vector","EnumLiteral"];
         for (var i = 0; i < assertList.length; i += 1) {
             if (map[assertList[i]] == null) throw new Error("No type kind '" + assertList[i] + "' found");
         }
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index e808930b60..7ffe022011 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -33,7 +33,6 @@ pub fn expectEqual(expected: var, actual: @typeOf(expected)) void {
     switch (@typeInfo(@typeOf(actual))) {
         .NoReturn,
         .BoundFn,
-        .ArgTuple,
         .Opaque,
         .Frame,
         .AnyFrame,
diff --git a/src-self-hosted/type.zig b/src-self-hosted/type.zig
index fa8e133b69..84efeea68a 100644
--- a/src-self-hosted/type.zig
+++ b/src-self-hosted/type.zig
@@ -41,7 +41,6 @@ pub const Type = struct {
             .Enum => @fieldParentPtr(Enum, "base", base).destroy(comp),
             .Union => @fieldParentPtr(Union, "base", base).destroy(comp),
             .BoundFn => @fieldParentPtr(BoundFn, "base", base).destroy(comp),
-            .ArgTuple => @fieldParentPtr(ArgTuple, "base", base).destroy(comp),
             .Opaque => @fieldParentPtr(Opaque, "base", base).destroy(comp),
             .Frame => @fieldParentPtr(Frame, "base", base).destroy(comp),
             .AnyFrame => @fieldParentPtr(AnyFrame, "base", base).destroy(comp),
@@ -76,7 +75,6 @@ pub const Type = struct {
             .Enum => return @fieldParentPtr(Enum, "base", base).getLlvmType(allocator, llvm_context),
             .Union => return @fieldParentPtr(Union, "base", base).getLlvmType(allocator, llvm_context),
             .BoundFn => return @fieldParentPtr(BoundFn, "base", base).getLlvmType(allocator, llvm_context),
-            .ArgTuple => unreachable,
             .Opaque => return @fieldParentPtr(Opaque, "base", base).getLlvmType(allocator, llvm_context),
             .Frame => return @fieldParentPtr(Frame, "base", base).getLlvmType(allocator, llvm_context),
             .AnyFrame => return @fieldParentPtr(AnyFrame, "base", base).getLlvmType(allocator, llvm_context),
@@ -93,7 +91,6 @@ pub const Type = struct {
             .Undefined,
             .Null,
             .BoundFn,
-            .ArgTuple,
             .Opaque,
             => unreachable,
 
@@ -128,7 +125,6 @@ pub const Type = struct {
             .Undefined,
             .Null,
             .BoundFn,
-            .ArgTuple,
             .Opaque,
             => unreachable,
 
@@ -1004,14 +1000,6 @@ pub const Type = struct {
         }
     };
 
-    pub const ArgTuple = struct {
-        base: Type,
-
-        pub fn destroy(self: *ArgTuple, comp: *Compilation) void {
-            comp.gpa().destroy(self);
-        }
-    };
-
     pub const Opaque = struct {
         base: Type,
 
diff --git a/src/all_types.hpp b/src/all_types.hpp
index a7945e700d..e364b3d362 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -1471,7 +1471,6 @@ enum ZigTypeId {
     ZigTypeIdUnion,
     ZigTypeIdFn,
     ZigTypeIdBoundFn,
-    ZigTypeIdArgTuple,
     ZigTypeIdOpaque,
     ZigTypeIdFnFrame,
     ZigTypeIdAnyFrame,
@@ -2039,7 +2038,6 @@ struct CodeGen {
         ZigType *entry_null;
         ZigType *entry_var;
         ZigType *entry_global_error_set;
-        ZigType *entry_arg_tuple;
         ZigType *entry_enum_literal;
         ZigType *entry_any_frame;
     } builtin_types;
diff --git a/src/analyze.cpp b/src/analyze.cpp
index fefa5352da..64a0f14372 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -323,7 +323,6 @@ AstNode *type_decl_node(ZigType *type_entry) {
         case ZigTypeIdErrorSet:
         case ZigTypeIdFn:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdVector:
         case ZigTypeIdAnyFrame:
             return nullptr;
@@ -392,7 +391,6 @@ bool type_is_resolved(ZigType *type_entry, ResolveStatus status) {
         case ZigTypeIdErrorSet:
         case ZigTypeIdFn:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdVector:
         case ZigTypeIdAnyFrame:
             return true;
@@ -1558,7 +1556,6 @@ static Error emit_error_unless_type_allowed_in_packed_container(CodeGen *g, ZigT
         case ZigTypeIdErrorUnion:
         case ZigTypeIdErrorSet:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
         case ZigTypeIdFnFrame:
         case ZigTypeIdAnyFrame:
@@ -1661,7 +1658,6 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
         case ZigTypeIdErrorUnion:
         case ZigTypeIdErrorSet:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdVoid:
         case ZigTypeIdFnFrame:
         case ZigTypeIdAnyFrame:
@@ -1786,12 +1782,9 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
             if (fn_type_id.cc == CallingConventionC) {
                 fn_type_id.param_count = fn_type_id.next_param_index;
                 continue;
-            } else if (calling_convention_allows_zig_types(fn_type_id.cc)) {
-                return get_generic_fn_type(g, &fn_type_id);
             } else {
                 add_node_error(g, param_node,
-                        buf_sprintf("var args not allowed in function with calling convention '%s'",
-                            calling_convention_name(fn_type_id.cc)));
+                        buf_sprintf("var args only allowed in functions with C calling convention"));
                 return g->builtin_types.entry_invalid;
             }
         } else if (param_node->data.param_decl.var_token != nullptr) {
@@ -1838,7 +1831,6 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
             case ZigTypeIdUnreachable:
             case ZigTypeIdUndefined:
             case ZigTypeIdNull:
-            case ZigTypeIdArgTuple:
             case ZigTypeIdOpaque:
                 add_node_error(g, param_node->data.param_decl.type,
                     buf_sprintf("parameter of type '%s' not allowed", buf_ptr(&type_entry->name)));
@@ -1913,7 +1905,6 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
 
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
-        case ZigTypeIdArgTuple:
             add_node_error(g, fn_proto->return_type,
                 buf_sprintf("return type '%s' not allowed", buf_ptr(&specified_return_type->name)));
             return g->builtin_types.entry_invalid;
@@ -1963,7 +1954,6 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
         case ZigTypeIdInvalid:
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
             zig_unreachable();
 
@@ -3720,7 +3710,6 @@ ZigType *validate_var_type(CodeGen *g, AstNode *source_node, ZigType *type_entry
         case ZigTypeIdUnreachable:
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
             add_node_error(g, source_node, buf_sprintf("variable of type '%s' not allowed",
                 buf_ptr(&type_entry->name)));
@@ -4275,7 +4264,6 @@ bool is_container(ZigType *type_entry) {
         case ZigTypeIdErrorSet:
         case ZigTypeIdFn:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
         case ZigTypeIdVector:
         case ZigTypeIdFnFrame:
@@ -4982,7 +4970,6 @@ bool handle_is_ptr(ZigType *type_entry) {
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
              zig_unreachable();
         case ZigTypeIdUnreachable:
@@ -5201,9 +5188,6 @@ static uint32_t hash_const_val(ZigValue *const_val) {
                 memcpy(&ints[0], &f128, 16);
                 return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xed8b3dfb;
             }
-        case ZigTypeIdArgTuple:
-            return (uint32_t)const_val->data.x_arg_tuple.start_index * (uint32_t)281907309 +
-                (uint32_t)const_val->data.x_arg_tuple.end_index * (uint32_t)2290442768;
         case ZigTypeIdFn:
             assert(const_val->data.x_ptr.mut == ConstPtrMutComptimeConst);
             assert(const_val->data.x_ptr.special == ConstPtrSpecialFunction);
@@ -5357,9 +5341,6 @@ static bool can_mutate_comptime_var_state(ZigValue *value) {
 
         case ZigTypeIdUnion:
             return can_mutate_comptime_var_state(value->data.x_union.payload);
-
-        case ZigTypeIdArgTuple:
-            zig_panic("TODO var args at comptime is currently not supported");
     }
     zig_unreachable();
 }
@@ -5400,9 +5381,6 @@ static bool return_type_is_cacheable(ZigType *return_type) {
 
         case ZigTypeIdErrorUnion:
             return return_type_is_cacheable(return_type->data.error_union.payload_type);
-
-        case ZigTypeIdArgTuple:
-            zig_panic("TODO var args at comptime is currently not supported");
     }
     zig_unreachable();
 }
@@ -5540,7 +5518,6 @@ OnePossibleValue type_has_one_possible_value(CodeGen *g, ZigType *type_entry) {
         case ZigTypeIdEnumLiteral:
         case ZigTypeIdMetaType:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOptional:
         case ZigTypeIdFn:
         case ZigTypeIdBool:
@@ -5626,7 +5603,6 @@ ReqCompTime type_requires_comptime(CodeGen *g, ZigType *ty) {
         case ZigTypeIdNull:
         case ZigTypeIdMetaType:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
             return ReqCompTimeYes;
         case ZigTypeIdArray:
             return type_requires_comptime(g, ty->data.array.child_type);
@@ -5918,20 +5894,6 @@ ZigValue *create_const_ptr_hard_coded_addr(CodeGen *g, ZigType *pointee_type,
     return const_val;
 }
 
-void init_const_arg_tuple(CodeGen *g, ZigValue *const_val, size_t arg_index_start, size_t arg_index_end) {
-    const_val->special = ConstValSpecialStatic;
-    const_val->type = g->builtin_types.entry_arg_tuple;
-    const_val->data.x_arg_tuple.start_index = arg_index_start;
-    const_val->data.x_arg_tuple.end_index = arg_index_end;
-}
-
-ZigValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_t arg_index_end) {
-    ZigValue *const_val = create_const_vals(1);
-    init_const_arg_tuple(g, const_val, arg_index_start, arg_index_end);
-    return const_val;
-}
-
-
 ZigValue *create_const_vals(size_t count) {
     return allocate<ZigValue>(count, "ZigValue");
 }
@@ -6679,9 +6641,6 @@ bool const_values_equal(CodeGen *g, ZigValue *a, ZigValue *b) {
             }
         case ZigTypeIdErrorUnion:
             zig_panic("TODO");
-        case ZigTypeIdArgTuple:
-            return a->data.x_arg_tuple.start_index == b->data.x_arg_tuple.start_index &&
-                   a->data.x_arg_tuple.end_index == b->data.x_arg_tuple.end_index;
         case ZigTypeIdBoundFn:
         case ZigTypeIdInvalid:
         case ZigTypeIdUnreachable:
@@ -7008,11 +6967,6 @@ void render_const_value(CodeGen *g, Buf *buf, ZigValue *const_val) {
             }
         case ZigTypeIdErrorSet:
             return render_const_val_err_set(g, buf, const_val, type_entry);
-        case ZigTypeIdArgTuple:
-            {
-                buf_appendf(buf, "(args value)");
-                return;
-            }
         case ZigTypeIdFnFrame:
             buf_appendf(buf, "(TODO: async function frame value)");
             return;
@@ -7075,7 +7029,6 @@ uint32_t type_id_hash(TypeId x) {
         case ZigTypeIdUnion:
         case ZigTypeIdFn:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdFnFrame:
         case ZigTypeIdAnyFrame:
             zig_unreachable();
@@ -7127,7 +7080,6 @@ bool type_id_eql(TypeId a, TypeId b) {
         case ZigTypeIdUnion:
         case ZigTypeIdFn:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
         case ZigTypeIdFnFrame:
         case ZigTypeIdAnyFrame:
@@ -7350,7 +7302,6 @@ static const ZigTypeId all_type_ids[] = {
     ZigTypeIdUnion,
     ZigTypeIdFn,
     ZigTypeIdBoundFn,
-    ZigTypeIdArgTuple,
     ZigTypeIdOpaque,
     ZigTypeIdFnFrame,
     ZigTypeIdAnyFrame,
@@ -7413,18 +7364,16 @@ size_t type_id_index(ZigType *entry) {
             return 18;
         case ZigTypeIdBoundFn:
             return 19;
-        case ZigTypeIdArgTuple:
-            return 20;
         case ZigTypeIdOpaque:
-            return 21;
+            return 20;
         case ZigTypeIdFnFrame:
-            return 22;
+            return 21;
         case ZigTypeIdAnyFrame:
-            return 23;
+            return 22;
         case ZigTypeIdVector:
-            return 24;
+            return 23;
         case ZigTypeIdEnumLiteral:
-            return 25;
+            return 24;
     }
     zig_unreachable();
 }
@@ -7475,8 +7424,6 @@ const char *type_id_name(ZigTypeId id) {
             return "Fn";
         case ZigTypeIdBoundFn:
             return "BoundFn";
-        case ZigTypeIdArgTuple:
-            return "ArgTuple";
         case ZigTypeIdOpaque:
             return "Opaque";
         case ZigTypeIdVector:
@@ -9064,7 +9011,6 @@ static void resolve_llvm_types(CodeGen *g, ZigType *type, ResolveStatus wanted_r
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
             zig_unreachable();
         case ZigTypeIdFloat:
         case ZigTypeIdOpaque:
diff --git a/src/analyze.hpp b/src/analyze.hpp
index 2fdaa00ab2..8f07434203 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -171,9 +171,6 @@ void init_const_slice(CodeGen *g, ZigValue *const_val, ZigValue *array_val,
         size_t start, size_t len, bool is_const);
 ZigValue *create_const_slice(CodeGen *g, ZigValue *array_val, size_t start, size_t len, bool is_const);
 
-void init_const_arg_tuple(CodeGen *g, ZigValue *const_val, size_t arg_index_start, size_t arg_index_end);
-ZigValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_t arg_index_end);
-
 void init_const_null(ZigValue *const_val, ZigType *type);
 ZigValue *create_const_null(ZigType *type);
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 387d10a189..a7bf7a50c4 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -6539,7 +6539,6 @@ static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, Zig
         case ZigTypeIdErrorUnion:
         case ZigTypeIdErrorSet:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdVoid:
         case ZigTypeIdOpaque:
             zig_unreachable();
@@ -7182,7 +7181,6 @@ check: switch (const_val->special) {
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
             zig_unreachable();
         case ZigTypeIdFnFrame:
@@ -7887,11 +7885,6 @@ static void define_builtin_types(CodeGen *g) {
         buf_init_from_str(&entry->name, "(var)");
         g->builtin_types.entry_var = entry;
     }
-    {
-        ZigType *entry = new_type_table_entry(ZigTypeIdArgTuple);
-        buf_init_from_str(&entry->name, "(args)");
-        g->builtin_types.entry_arg_tuple = entry;
-    }
 
     for (size_t i = 0; i < array_length(c_int_type_infos); i += 1) {
         const CIntTypeInfo *info = &c_int_type_infos[i];
@@ -9532,7 +9525,6 @@ static void prepend_c_type_to_decl_list(CodeGen *g, GenH *gen_h, ZigType *type_e
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdErrorUnion:
         case ZigTypeIdErrorSet:
         case ZigTypeIdFnFrame:
@@ -9721,7 +9713,6 @@ static void get_c_type(CodeGen *g, GenH *gen_h, ZigType *type_entry, Buf *out_bu
         case ZigTypeIdEnumLiteral:
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdFnFrame:
         case ZigTypeIdAnyFrame:
             zig_unreachable();
@@ -9781,7 +9772,6 @@ static void gen_h_file_types(CodeGen* g, GenH* gen_h, Buf* out_buf) {
             case ZigTypeIdErrorUnion:
             case ZigTypeIdErrorSet:
             case ZigTypeIdBoundFn:
-            case ZigTypeIdArgTuple:
             case ZigTypeIdOptional:
             case ZigTypeIdFn:
             case ZigTypeIdVector:
diff --git a/src/ir.cpp b/src/ir.cpp
index 241ef73ce2..154b258327 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -780,7 +780,6 @@ static bool types_have_same_zig_comptime_repr(CodeGen *codegen, ZigType *expecte
         case ZigTypeIdErrorUnion:
         case ZigTypeIdEnum:
         case ZigTypeIdUnion:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdVector:
         case ZigTypeIdFnFrame:
             return false;
@@ -14791,7 +14790,6 @@ static IrInstruction *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *
         case ZigTypeIdFn:
         case ZigTypeIdOpaque:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdEnum:
         case ZigTypeIdEnumLiteral:
         case ZigTypeIdAnyFrame:
@@ -16437,7 +16435,6 @@ static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructio
                 case ZigTypeIdErrorUnion:
                 case ZigTypeIdErrorSet:
                 case ZigTypeIdBoundFn:
-                case ZigTypeIdArgTuple:
                 case ZigTypeIdOpaque:
                 case ZigTypeIdFnFrame:
                 case ZigTypeIdAnyFrame:
@@ -16462,7 +16459,6 @@ static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructio
         case ZigTypeIdVector:
             zig_panic("TODO export const value of type %s", buf_ptr(&target->value->type->name));
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
         case ZigTypeIdEnumLiteral:
         case ZigTypeIdFnFrame:
@@ -16609,7 +16605,6 @@ static bool type_can_bit_cast(ZigType *t) {
         case ZigTypeIdMetaType:
         case ZigTypeIdOpaque:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdUnreachable:
         case ZigTypeIdComptimeFloat:
         case ZigTypeIdComptimeInt:
@@ -17416,23 +17411,6 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
     return true;
 }
 
-static ZigVar *get_fn_var_by_index(ZigFn *fn_entry, size_t index) {
-    FnTypeParamInfo *src_param_info = &fn_entry->type_entry->data.fn.fn_type_id.param_info[index];
-    if (!type_has_bits(src_param_info->type))
-        return nullptr;
-
-    size_t next_var_i = 0;
-    for (size_t param_i = 0; param_i < index; param_i += 1) {
-        FnTypeParamInfo *src_param_info = &fn_entry->type_entry->data.fn.fn_type_id.param_info[param_i];
-        if (!type_has_bits(src_param_info->type)) {
-            continue;
-        }
-
-        next_var_i += 1;
-    }
-    return fn_entry->variable_list.at(next_var_i);
-}
-
 static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction, ZigVar *var) {
     while (var->next_var != nullptr) {
         var = var->next_var;
@@ -17690,16 +17668,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
         var_args_1_or_0 = fn_type_id->is_var_args ? 1 : 0;
     }
     size_t src_param_count = fn_type_id->param_count - var_args_1_or_0;
-
     size_t call_param_count = args_len + first_arg_1_or_0;
-    for (size_t i = 0; i < args_len; i += 1) {
-        ZigValue *arg_tuple_value = args_ptr[i]->value;
-        if (arg_tuple_value->type->id == ZigTypeIdArgTuple) {
-            call_param_count -= 1;
-            call_param_count += arg_tuple_value->data.x_arg_tuple.end_index -
-                arg_tuple_value->data.x_arg_tuple.start_index;
-        }
-    }
     AstNode *source_node = source_instr->source_node;
 
     AstNode *fn_proto_node = fn_entry ? fn_entry->proto_node : nullptr;;
@@ -17854,16 +17823,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
             return ira->codegen->invalid_instruction;
         }
 
-        // Count the arguments of the function type id we are creating
-        size_t new_fn_arg_count = first_arg_1_or_0;
-        for (size_t call_i = 0; call_i < args_len; call_i += 1) {
-            IrInstruction *arg = args_ptr[call_i];
-            if (arg->value->type->id == ZigTypeIdArgTuple) {
-                new_fn_arg_count += arg->value->data.x_arg_tuple.end_index - arg->value->data.x_arg_tuple.start_index;
-            } else {
-                new_fn_arg_count += 1;
-            }
-        }
+        size_t new_fn_arg_count = first_arg_1_or_0 + args_len;
 
         IrInstruction **casted_args = allocate<IrInstruction *>(new_fn_arg_count);
 
@@ -17914,76 +17874,19 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
             }
         }
 
-        bool found_first_var_arg = false;
-        size_t first_var_arg;
-
         ZigFn *parent_fn_entry = exec_fn_entry(ira->new_irb.exec);
         assert(parent_fn_entry);
         for (size_t call_i = 0; call_i < args_len; call_i += 1) {
             IrInstruction *arg = args_ptr[call_i];
 
-            if (arg->value->type->id == ZigTypeIdArgTuple) {
-                for (size_t arg_tuple_i = arg->value->data.x_arg_tuple.start_index;
-                    arg_tuple_i < arg->value->data.x_arg_tuple.end_index; arg_tuple_i += 1)
-                {
-                    AstNode *param_decl_node = fn_proto_node->data.fn_proto.params.at(next_proto_i);
-                    assert(param_decl_node->type == NodeTypeParamDecl);
-                    bool is_var_args = param_decl_node->data.param_decl.is_var_args;
-                    if (is_var_args && !found_first_var_arg) {
-                        first_var_arg = inst_fn_type_id.param_count;
-                        found_first_var_arg = true;
-                    }
-
-                    ZigVar *arg_var = get_fn_var_by_index(parent_fn_entry, arg_tuple_i);
-                    if (arg_var == nullptr) {
-                        ir_add_error(ira, arg,
-                            buf_sprintf("compiler bug: var args can't handle void. https://github.com/ziglang/zig/issues/557"));
-                        return ira->codegen->invalid_instruction;
-                    }
-                    IrInstruction *arg_var_ptr_inst = ir_get_var_ptr(ira, arg, arg_var);
-                    if (type_is_invalid(arg_var_ptr_inst->value->type))
-                        return ira->codegen->invalid_instruction;
-
-                    IrInstruction *arg_tuple_arg = ir_get_deref(ira, arg, arg_var_ptr_inst, nullptr);
-                    if (type_is_invalid(arg_tuple_arg->value->type))
-                        return ira->codegen->invalid_instruction;
-
-                    if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg_tuple_arg, &impl_fn->child_scope,
-                        &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
-                    {
-                        return ira->codegen->invalid_instruction;
-                    }
-                }
-            } else {
-                AstNode *param_decl_node = fn_proto_node->data.fn_proto.params.at(next_proto_i);
-                assert(param_decl_node->type == NodeTypeParamDecl);
-                bool is_var_args = param_decl_node->data.param_decl.is_var_args;
-                if (is_var_args && !found_first_var_arg) {
-                    first_var_arg = inst_fn_type_id.param_count;
-                    found_first_var_arg = true;
-                }
-
-                if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg, &impl_fn->child_scope,
-                    &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
-                {
-                    return ira->codegen->invalid_instruction;
-                }
-            }
-        }
-
-        if (fn_proto_node->data.fn_proto.is_var_args) {
             AstNode *param_decl_node = fn_proto_node->data.fn_proto.params.at(next_proto_i);
-            Buf *param_name = param_decl_node->data.param_decl.name;
+            assert(param_decl_node->type == NodeTypeParamDecl);
 
-            if (!found_first_var_arg) {
-                first_var_arg = inst_fn_type_id.param_count;
+            if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg, &impl_fn->child_scope,
+                &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
+            {
+                return ira->codegen->invalid_instruction;
             }
-
-            ZigValue *var_args_val = create_const_arg_tuple(ira->codegen,
-                    first_var_arg, inst_fn_type_id.param_count);
-            ZigVar *var = add_variable(ira->codegen, param_decl_node,
-                impl_fn->child_scope, param_name, true, var_args_val, nullptr, var_args_val->type);
-            impl_fn->child_scope = var->child_scope;
         }
 
         if (fn_proto_node->data.fn_proto.align_expr != nullptr) {
@@ -18153,55 +18056,20 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
         if (type_is_invalid(old_arg->value->type))
             return ira->codegen->invalid_instruction;
 
-        if (old_arg->value->type->id == ZigTypeIdArgTuple) {
-            for (size_t arg_tuple_i = old_arg->value->data.x_arg_tuple.start_index;
-                arg_tuple_i < old_arg->value->data.x_arg_tuple.end_index; arg_tuple_i += 1)
-            {
-                ZigVar *arg_var = get_fn_var_by_index(parent_fn_entry, arg_tuple_i);
-                if (arg_var == nullptr) {
-                    ir_add_error(ira, old_arg,
-                        buf_sprintf("compiler bug: var args can't handle void. https://github.com/ziglang/zig/issues/557"));
-                    return ira->codegen->invalid_instruction;
-                }
-                IrInstruction *arg_var_ptr_inst = ir_get_var_ptr(ira, old_arg, arg_var);
-                if (type_is_invalid(arg_var_ptr_inst->value->type))
-                    return ira->codegen->invalid_instruction;
-
-                IrInstruction *arg_tuple_arg = ir_get_deref(ira, old_arg, arg_var_ptr_inst, nullptr);
-                if (type_is_invalid(arg_tuple_arg->value->type))
-                    return ira->codegen->invalid_instruction;
-
-                IrInstruction *casted_arg;
-                if (next_arg_index < src_param_count) {
-                    ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
-                    if (type_is_invalid(param_type))
-                        return ira->codegen->invalid_instruction;
-                    casted_arg = ir_implicit_cast(ira, arg_tuple_arg, param_type);
-                    if (type_is_invalid(casted_arg->value->type))
-                        return ira->codegen->invalid_instruction;
-                } else {
-                    casted_arg = arg_tuple_arg;
-                }
-
-                casted_args[next_arg_index] = casted_arg;
-                next_arg_index += 1;
-            }
+        IrInstruction *casted_arg;
+        if (next_arg_index < src_param_count) {
+            ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
+            if (type_is_invalid(param_type))
+                return ira->codegen->invalid_instruction;
+            casted_arg = ir_implicit_cast(ira, old_arg, param_type);
+            if (type_is_invalid(casted_arg->value->type))
+                return ira->codegen->invalid_instruction;
         } else {
-            IrInstruction *casted_arg;
-            if (next_arg_index < src_param_count) {
-                ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
-                if (type_is_invalid(param_type))
-                    return ira->codegen->invalid_instruction;
-                casted_arg = ir_implicit_cast(ira, old_arg, param_type);
-                if (type_is_invalid(casted_arg->value->type))
-                    return ira->codegen->invalid_instruction;
-            } else {
-                casted_arg = old_arg;
-            }
-
-            casted_args[next_arg_index] = casted_arg;
-            next_arg_index += 1;
+            casted_arg = old_arg;
         }
+
+        casted_args[next_arg_index] = casted_arg;
+        next_arg_index += 1;
     }
 
     assert(next_arg_index == call_param_count);
@@ -19186,37 +19054,6 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
     } else if (is_slice(array_type)) {
         return_type = adjust_ptr_len(ira->codegen, array_type->data.structure.fields[slice_ptr_index]->type_entry,
                 elem_ptr_instruction->ptr_len);
-    } else if (array_type->id == ZigTypeIdArgTuple) {
-        ZigValue *ptr_val = ir_resolve_const(ira, array_ptr, UndefBad);
-        if (!ptr_val)
-            return ira->codegen->invalid_instruction;
-        ZigValue *args_val = const_ptr_pointee(ira, ira->codegen, ptr_val, elem_ptr_instruction->base.source_node);
-        if (args_val == nullptr)
-            return ira->codegen->invalid_instruction;
-        size_t start = args_val->data.x_arg_tuple.start_index;
-        size_t end = args_val->data.x_arg_tuple.end_index;
-        uint64_t elem_index_val;
-        if (!ir_resolve_usize(ira, elem_index, &elem_index_val))
-            return ira->codegen->invalid_instruction;
-        size_t index = elem_index_val;
-        size_t len = end - start;
-        if (index >= len) {
-            ir_add_error(ira, &elem_ptr_instruction->base,
-                buf_sprintf("index %" ZIG_PRI_usize " outside argument list of size %" ZIG_PRI_usize "", index, len));
-            return ira->codegen->invalid_instruction;
-        }
-        size_t abs_index = start + index;
-        ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
-        assert(fn_entry);
-        ZigVar *var = get_fn_var_by_index(fn_entry, abs_index);
-        bool is_const = true;
-        bool is_volatile = false;
-        if (var) {
-            return ir_get_var_ptr(ira, &elem_ptr_instruction->base, var);
-        } else {
-            return ir_get_const_ptr(ira, &elem_ptr_instruction->base, ira->codegen->intern.for_void(),
-                    ira->codegen->builtin_types.entry_void, ConstPtrMutComptimeConst, is_const, is_volatile, 0);
-        }
     } else if (array_type->id == ZigTypeIdVector) {
         // This depends on whether the element index is comptime, so it is computed later.
         return_type = nullptr;
@@ -20025,6 +19862,10 @@ static IrInstruction *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstruc
 
     if (type_is_invalid(container_type)) {
         return ira->codegen->invalid_instruction;
+    } else if (is_tuple(container_type) && !field_ptr_instruction->initializing && buf_eql_str(field_name, "len")) {
+        IrInstruction *len_inst = ir_const_unsigned(ira, &field_ptr_instruction->base,
+                container_type->data.structure.src_field_count);
+        return ir_get_ref(ira, &field_ptr_instruction->base, len_inst, true, false);
     } else if (is_slice(container_type) || is_container_ref(container_type)) {
         assert(container_ptr->value->type->id == ZigTypeIdPointer);
         if (container_type->id == ZigTypeIdPointer) {
@@ -20045,32 +19886,6 @@ static IrInstruction *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstruc
                 init_const_usize(ira->codegen, len_val, container_type->data.array.len);
             }
 
-            ZigType *usize = ira->codegen->builtin_types.entry_usize;
-            bool ptr_is_const = true;
-            bool ptr_is_volatile = false;
-            return ir_get_const_ptr(ira, &field_ptr_instruction->base, len_val,
-                    usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
-        } else {
-            ir_add_error_node(ira, source_node,
-                buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
-                    buf_ptr(&container_type->name)));
-            return ira->codegen->invalid_instruction;
-        }
-    } else if (container_type->id == ZigTypeIdArgTuple) {
-        ZigValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
-        if (!container_ptr_val)
-            return ira->codegen->invalid_instruction;
-
-        assert(container_ptr->value->type->id == ZigTypeIdPointer);
-        ZigValue *child_val = const_ptr_pointee(ira, ira->codegen, container_ptr_val, source_node);
-        if (child_val == nullptr)
-            return ira->codegen->invalid_instruction;
-
-        if (buf_eql_str(field_name, "len")) {
-            ZigValue *len_val = create_const_vals(1);
-            size_t len = child_val->data.x_arg_tuple.end_index - child_val->data.x_arg_tuple.start_index;
-            init_const_usize(ira->codegen, len_val, len);
-
             ZigType *usize = ira->codegen->builtin_types.entry_usize;
             bool ptr_is_const = true;
             bool ptr_is_volatile = false;
@@ -21258,7 +21073,6 @@ static IrInstruction *ir_analyze_instruction_switch_target(IrAnalyze *ira,
         case ZigTypeIdNull:
         case ZigTypeIdOptional:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
         case ZigTypeIdVector:
         case ZigTypeIdFnFrame:
@@ -22580,7 +22394,6 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
         case ZigTypeIdEnumLiteral:
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
             result = ira->codegen->intern.for_void();
             break;
@@ -23357,7 +23170,6 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInstruction *instruction, Zi
         case ZigTypeIdUnion:
         case ZigTypeIdFn:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdStruct:
             ir_add_error(ira, instruction, buf_sprintf(
                 "@Type not availble for 'TypeInfo.%s'", type_id_name(tagTypeId)));
@@ -26452,7 +26264,6 @@ static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ZigValue *val)
         case ZigTypeIdMetaType:
         case ZigTypeIdOpaque:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdUnreachable:
         case ZigTypeIdComptimeFloat:
         case ZigTypeIdComptimeInt:
@@ -26609,7 +26420,6 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
         case ZigTypeIdMetaType:
         case ZigTypeIdOpaque:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
         case ZigTypeIdUnreachable:
         case ZigTypeIdComptimeFloat:
         case ZigTypeIdComptimeInt:
@@ -28838,7 +28648,6 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) {
                     case ZigTypeIdUndefined:
                     case ZigTypeIdNull:
                     case ZigTypeIdBoundFn:
-                    case ZigTypeIdArgTuple:
                     case ZigTypeIdVoid:
                     case ZigTypeIdOpaque:
                         ir_add_error(ira, lazy_align_of->target_type,
@@ -28890,7 +28699,6 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) {
                     case ZigTypeIdUndefined:
                     case ZigTypeIdNull:
                     case ZigTypeIdBoundFn:
-                    case ZigTypeIdArgTuple:
                     case ZigTypeIdOpaque:
                         ir_add_error(ira, lazy_size_of->target_type,
                             buf_sprintf("no size available for type '%s'",
@@ -28969,7 +28777,6 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) {
                 case ZigTypeIdUnreachable:
                 case ZigTypeIdUndefined:
                 case ZigTypeIdNull:
-                case ZigTypeIdArgTuple:
                 case ZigTypeIdOpaque:
                     ir_add_error(ira, lazy_slice_type->elem_type,
                         buf_sprintf("slice of type '%s' not allowed", buf_ptr(&elem_type->name)));
@@ -29102,7 +28909,6 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) {
                 case ZigTypeIdUnreachable:
                 case ZigTypeIdUndefined:
                 case ZigTypeIdNull:
-                case ZigTypeIdArgTuple:
                 case ZigTypeIdOpaque:
                     ir_add_error(ira, lazy_array_type->elem_type,
                                  buf_sprintf("array of type '%s' not allowed",
diff --git a/src/parser.cpp b/src/parser.cpp
index 1786e38d4b..96162632b9 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -802,12 +802,6 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc) {
     res->data.fn_proto.auto_err_set = exmark != nullptr;
     res->data.fn_proto.return_type = return_type;
 
-    // It seems that the Zig compiler expects varargs to be the
-    // last parameter in the decl list. This is not encoded in
-    // the grammar, which allows varargs anywhere in the decl.
-    // Since varargs is gonna be removed at some point, I'm not
-    // gonna encode this "varargs is always last" rule in the
-    // grammar, and just enforce it here, until varargs is removed.
     for (size_t i = 0; i < params.length; i++) {
         AstNode *param_decl = params.at(i);
         assert(param_decl->type == NodeTypeParamDecl);
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index ebc57d264d..b89287949b 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -2,6 +2,15 @@ const tests = @import("tests.zig");
 const builtin = @import("builtin");
 
 pub fn addCases(cases: *tests.CompileErrorContext) void {
+    cases.add("var args without c calling conv",
+        \\fn foo(args: ...) void {}
+        \\comptime {
+        \\    _ = foo;
+        \\}
+    , &[_][]const u8{
+        "tmp.zig:1:8: error: var args only allowed in functions with C calling convention",
+    });
+
     cases.add("comptime struct field, no init value",
         \\const Foo = struct {
         \\    comptime b: i32,
@@ -9,10 +18,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var f: Foo = undefined;
         \\}
-    , "tmp.zig:2:5: error: comptime struct field missing initialization value");
+    , &[_][]const u8{
+        "tmp.zig:2:5: error: comptime struct field missing initialization value",
+    });
 
-    cases.add(
-        "bad usage of @call",
+    cases.add("bad usage of @call",
         \\export fn entry1() void {
         \\    @call(.{}, foo, {});
         \\}
@@ -33,24 +43,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\inline fn bar() void {}
         \\fn baz1() void {}
         \\fn baz2() void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: expected tuple or struct, found 'void'",
         "tmp.zig:5:14: error: unable to perform 'never_inline' call at compile-time",
         "tmp.zig:8:14: error: unable to perform 'never_tail' call at compile-time",
         "tmp.zig:11:5: error: no-inline call of inline function",
         "tmp.zig:15:43: error: unable to evaluate constant expression",
-    );
+    });
 
     cases.add("exported async function",
         \\export async fn foo() void {}
-    , "tmp.zig:1:1: error: exported function cannot be async");
+    , &[_][]const u8{
+        "tmp.zig:1:1: error: exported function cannot be async",
+    });
 
-    cases.addExe(
-        "main missing name",
+    cases.addExe("main missing name",
         \\pub fn (main) void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:5: error: missing function name",
-    );
+    });
 
     cases.addCase(x: {
         var tc = cases.create("call with new stack on unsupported target",
@@ -59,7 +70,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             \\    @call(.{.stack = &buf}, foo, .{});
             \\}
             \\fn foo() void {}
-        , "tmp.zig:3:5: error: target arch 'wasm32' does not support calling with a new stack");
+        , &[_][]const u8{
+            "tmp.zig:3:5: error: target arch 'wasm32' does not support calling with a new stack",
+        });
         tc.target = tests.Target{
             .Cross = tests.CrossTarget{
                 .arch = .wasm32,
@@ -72,8 +85,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
 
     // Note: One of the error messages here is backwards. It would be nice to fix, but that's not
     // going to stop me from merging this branch which fixes a bunch of other stuff.
-    cases.add(
-        "incompatible sentinels",
+    cases.add("incompatible sentinels",
         \\export fn entry1(ptr: [*:255]u8) [*:0]u8 {
         \\    return ptr;
         \\}
@@ -86,7 +98,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry4() void {
         \\    var array: [2:0]u8 = [_]u8{1, 2};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: expected type '[*:0]u8', found '[*:255]u8'",
         "tmp.zig:2:12: note: destination pointer requires a terminating '0' sentinel, but source pointer has a terminating '255' sentinel",
         "tmp.zig:5:12: error: expected type '[*:0]u8', found '[*]u8'",
@@ -96,20 +108,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:35: note: destination array requires a terminating '255' sentinel, but source array has a terminating '0' sentinel",
         "tmp.zig:11:31: error: expected type '[2:0]u8', found '[2]u8'",
         "tmp.zig:11:31: note: destination array requires a terminating '0' sentinel",
-    );
+    });
 
-    cases.add(
-        "empty switch on an integer",
+    cases.add("empty switch on an integer",
         \\export fn entry() void {
         \\    var x: u32 = 0;
         \\    switch(x) {}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: switch must handle all possibilities",
-    );
+    });
 
-    cases.add(
-        "incorrect return type",
+    cases.add("incorrect return type",
         \\ pub export fn entry() void{
         \\     _ = foo();
         \\ }
@@ -125,12 +135,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\ fn bar() B {
         \\     unreachable;
         \\ }
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:16: error: expected type 'A', found 'B'",
-    );
+    });
 
-    cases.add(
-        "regression test #2980: base type u32 is not type checked properly when assigning a value within a struct",
+    cases.add("regression test #2980: base type u32 is not type checked properly when assigning a value within a struct",
         \\const Foo = struct {
         \\    ptr: ?*usize,
         \\    uval: u32,
@@ -144,12 +153,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .uval = get_uval(42),
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:11:25: error: expected type 'u32', found '@typeOf(get_uval).ReturnType.ErrorSet!u32'",
-    );
+    });
 
-    cases.add(
-        "asigning to struct or union fields that are not optionals with a function that returns an optional",
+    cases.add("asigning to struct or union fields that are not optionals with a function that returns an optional",
         \\fn maybe(is: bool) ?u8 {
         \\    if (is) return @as(u8, 10) else return null;
         \\}
@@ -163,24 +171,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var u = U{ .Ye = maybe(false) };
         \\    var s = S{ .num = maybe(false) };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:11:27: error: expected type 'u8', found '?u8'",
-    );
+    });
 
-    cases.add(
-        "missing result type for phi node",
+    cases.add("missing result type for phi node",
         \\fn foo() !void {
         \\    return anyerror.Foo;
         \\}
         \\export fn entry() void {
         \\    foo() catch 0;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:17: error: integer value 0 cannot be coerced to type 'void'",
-    );
+    });
 
-    cases.add(
-        "atomicrmw with enum op not .Xchg",
+    cases.add("atomicrmw with enum op not .Xchg",
         \\export fn entry() void {
         \\    const E = enum(u8) {
         \\        a,
@@ -191,34 +197,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x: E = .a;
         \\    _ = @atomicRmw(E, &x, .Add, .b, .SeqCst);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:27: error: @atomicRmw on enum only works with .Xchg",
-    );
+    });
 
-    cases.add(
-        "disallow coercion from non-null-terminated pointer to null-terminated pointer",
+    cases.add("disallow coercion from non-null-terminated pointer to null-terminated pointer",
         \\extern fn puts(s: [*:0]const u8) c_int;
         \\pub fn main() void {
         \\    const no_zero_array = [_]u8{'h', 'e', 'l', 'l', 'o'};
         \\    const no_zero_ptr: [*]const u8 = &no_zero_array;
         \\    _ = puts(no_zero_ptr);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:14: error: expected type '[*:0]const u8', found '[*]const u8'",
-    );
+    });
 
-    cases.add(
-        "atomic orderings of atomicStore Acquire or AcqRel",
+    cases.add("atomic orderings of atomicStore Acquire or AcqRel",
         \\export fn entry() void {
         \\    var x: u32 = 0;
         \\    @atomicStore(u32, &x, 1, .Acquire);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:30: error: @atomicStore atomic ordering must not be Acquire or AcqRel",
-    );
+    });
 
-    cases.add(
-        "missing const in slice with nested array type",
+    cases.add("missing const in slice with nested array type",
         \\const Geo3DTex2D = struct { vertices: [][2]f32 };
         \\pub fn getGeo3DTex2D() Geo3DTex2D {
         \\    return Geo3DTex2D{
@@ -230,34 +233,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var geo_data = getGeo3DTex2D();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:30: error: array literal requires address-of operator to coerce to slice type '[][2]f32'",
-    );
+    });
 
-    cases.add(
-        "slicing of global undefined pointer",
+    cases.add("slicing of global undefined pointer",
         \\var buf: *[1]u8 = undefined;
         \\export fn entry() void {
         \\    _ = buf[0..1];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:12: error: non-zero length slice of undefined pointer",
-    );
+    });
 
-    cases.add(
-        "using invalid types in function call raises an error",
+    cases.add("using invalid types in function call raises an error",
         \\const MenuEffect = enum {};
         \\fn func(effect: MenuEffect) void {}
         \\export fn entry() void {
         \\    func(MenuEffect.ThisDoesNotExist);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:20: error: enums must have 1 or more fields",
         "tmp.zig:4:20: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "store vector pointer with unknown runtime index",
+    cases.add("store vector pointer with unknown runtime index",
         \\export fn entry() void {
         \\    var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
         \\
@@ -268,12 +268,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn storev(ptr: var, val: i32) void {
         \\    ptr.* = val;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:8: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
-    );
+    });
 
-    cases.add(
-        "load vector pointer with unknown runtime index",
+    cases.add("load vector pointer with unknown runtime index",
         \\export fn entry() void {
         \\    var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
         \\
@@ -284,12 +283,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn loadv(ptr: var) i32 {
         \\    return ptr.*;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
-    );
+    });
 
-    cases.add(
-        "using an unknown len ptr type instead of array",
+    cases.add("using an unknown len ptr type instead of array",
         \\const resolutions = [*][*]const u8{
         \\    "[320 240  ]",
         \\    null,
@@ -297,22 +295,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    _ = resolutions;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:21: error: expected array type or [_], found '[*][*]const u8'",
-    );
+    });
 
-    cases.add(
-        "comparison with error union and error value",
+    cases.add("comparison with error union and error value",
         \\export fn entry() void {
         \\    var number_or_error: anyerror!i32 = error.SomethingAwful;
         \\    _ = number_or_error == error.SomethingAwful;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:25: error: operator not allowed for type 'anyerror!i32'",
-    );
+    });
 
-    cases.add(
-        "switch with overlapping case ranges",
+    cases.add("switch with overlapping case ranges",
         \\export fn entry() void {
         \\    var q: u8 = 0;
         \\    switch (q) {
@@ -320,22 +316,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        0...255 => {},
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:9: error: duplicate switch value",
-    );
+    });
 
-    cases.add(
-        "invalid optional type in extern struct",
+    cases.add("invalid optional type in extern struct",
         \\const stroo = extern struct {
         \\    moo: ?[*c]u8,
         \\};
         \\export fn testf(fluff: *stroo) void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: extern structs cannot contain fields of type '?[*c]u8'",
-    );
+    });
 
-    cases.add(
-        "attempt to negate a non-integer, non-float or non-vector type",
+    cases.add("attempt to negate a non-integer, non-float or non-vector type",
         \\fn foo() anyerror!u32 {
         \\    return 1;
         \\}
@@ -343,42 +337,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const x = -foo();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:15: error: negation of type 'anyerror!u32'",
-    );
+    });
 
-    cases.add(
-        "attempt to create 17 bit float type",
+    cases.add("attempt to create 17 bit float type",
         \\const builtin = @import("builtin");
         \\comptime {
         \\    _ = @Type(builtin.TypeInfo { .Float = builtin.TypeInfo.Float { .bits = 17 } });
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:32: error: 17-bit float unsupported",
-    );
+    });
 
-    cases.add(
-        "wrong type for @Type",
+    cases.add("wrong type for @Type",
         \\export fn entry() void {
         \\    _ = @Type(0);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected type 'std.builtin.TypeInfo', found 'comptime_int'",
-    );
+    });
 
-    cases.add(
-        "@Type with non-constant expression",
+    cases.add("@Type with non-constant expression",
         \\const builtin = @import("builtin");
         \\var globalTypeInfo : builtin.TypeInfo = undefined;
         \\export fn entry() void {
         \\    _ = @Type(globalTypeInfo);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:15: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "@Type with TypeInfo.Int",
+    cases.add("@Type with TypeInfo.Int",
         \\const builtin = @import("builtin");
         \\export fn entry() void {
         \\    _ = @Type(builtin.TypeInfo.Int {
@@ -386,21 +376,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .bits = 8,
         \\    });
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:36: error: expected type 'std.builtin.TypeInfo', found 'std.builtin.Int'",
-    );
+    });
 
-    cases.add(
-        "Struct unavailable for @Type",
+    cases.add("Struct unavailable for @Type",
         \\export fn entry() void {
         \\    _ = @Type(@typeInfo(struct { }));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: @Type not availble for 'TypeInfo.Struct'",
-    );
+    });
 
-    cases.add(
-        "wrong type for result ptr to @asyncCall",
+    cases.add("wrong type for result ptr to @asyncCall",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
@@ -411,32 +399,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn foo() i32 {
         \\    return 1234;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:37: error: expected type '*i32', found 'bool'",
-    );
+    });
 
-    cases.add(
-        "shift amount has to be an integer type",
+    cases.add("shift amount has to be an integer type",
         \\export fn entry() void {
         \\    const x = 1 << &@as(u8, 10);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: shift amount has to be an integer type, but found '*u8'",
         "tmp.zig:2:17: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "bit shifting only works on integer types",
+    cases.add("bit shifting only works on integer types",
         \\export fn entry() void {
         \\    const x = &@as(u8, 1) << 10;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:16: error: bit shifting operation expected integer type, found '*u8'",
         "tmp.zig:2:27: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "struct depends on itself via optional field",
+    cases.add("struct depends on itself via optional field",
         \\const LhsExpr = struct {
         \\    rhsExpr: ?AstObject,
         \\};
@@ -447,14 +432,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const lhsExpr = LhsExpr{ .rhsExpr = null };
         \\    const obj = AstObject{ .lhsExpr = lhsExpr };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:17: error: struct 'LhsExpr' depends on itself",
         "tmp.zig:5:5: note: while checking this field",
         "tmp.zig:2:5: note: while checking this field",
-    );
+    });
 
-    cases.add(
-        "alignment of enum field specified",
+    cases.add("alignment of enum field specified",
         \\const Number = enum {
         \\    a,
         \\    b align(i32),
@@ -462,23 +446,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry1() void {
         \\    var x: Number = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:13: error: structs and unions, not enums, support field alignment",
         "tmp.zig:1:16: note: consider 'union(enum)' here",
-    );
+    });
 
-    cases.add(
-        "bad alignment type",
+    cases.add("bad alignment type",
         \\export fn entry1() void {
         \\    var x: []align(true) i32 = undefined;
         \\}
         \\export fn entry2() void {
         \\    var x: *align(@as(f64, 12.34)) i32 = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:20: error: expected type 'u29', found 'bool'",
         "tmp.zig:5:19: error: fractional component prevents float value 12.340000 from being casted to type 'u29'",
-    );
+    });
 
     cases.addCase(x: {
         var tc = cases.create("variable in inline assembly template cannot be found",
@@ -488,7 +471,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             \\        : [bar] "=r" (-> usize)
             \\    );
             \\}
-        , "tmp.zig:2:14: error: could not find 'foo' in the inputs or outputs");
+        , &[_][]const u8{
+            "tmp.zig:2:14: error: could not find 'foo' in the inputs or outputs",
+        });
         tc.target = tests.Target{
             .Cross = tests.CrossTarget{
                 .arch = .x86_64,
@@ -499,8 +484,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         break :x tc;
     });
 
-    cases.add(
-        "indirect recursion of async functions detected",
+    cases.add("indirect recursion of async functions detected",
         \\var frame: ?anyframe = null;
         \\
         \\export fn a() void {
@@ -529,14 +513,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var child = rangeSum(x - 1);
         \\    return child + 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:1: error: '@Frame(rangeSum)' depends on itself",
         "tmp.zig:15:33: note: when analyzing type '@Frame(rangeSum)' here",
         "tmp.zig:26:25: note: when analyzing type '@Frame(rangeSumIndirect)' here",
-    );
+    });
 
-    cases.add(
-        "non-async function pointer eventually is inferred to become async",
+    cases.add("non-async function pointer eventually is inferred to become async",
         \\export fn a() void {
         \\    var non_async_fn: fn () void = undefined;
         \\    non_async_fn = func;
@@ -544,45 +527,41 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn func() void {
         \\    suspend;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:1: error: 'func' cannot be async",
         "tmp.zig:3:20: note: required to be non-async here",
         "tmp.zig:6:5: note: suspends here",
-    );
+    });
 
-    cases.add(
-        "bad alignment in @asyncCall",
+    cases.add("bad alignment in @asyncCall",
         \\export fn entry() void {
         \\    var ptr: async fn () void = func;
         \\    var bytes: [64]u8 = undefined;
         \\    _ = @asyncCall(&bytes, {}, ptr);
         \\}
         \\async fn func() void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:21: error: expected type '[]align(16) u8', found '*[64]u8'",
-    );
+    });
 
-    cases.add(
-        "atomic orderings of fence Acquire or stricter",
+    cases.add("atomic orderings of fence Acquire or stricter",
         \\export fn entry() void {
         \\    @fence(.Monotonic);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: atomic ordering must be Acquire or stricter",
-    );
+    });
 
-    cases.add(
-        "bad alignment in implicit cast from array pointer to slice",
+    cases.add("bad alignment in implicit cast from array pointer to slice",
         \\export fn a() void {
         \\    var x: [10]u8 = undefined;
         \\    var y: []align(16) u8 = &x;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:30: error: expected type '[]align(16) u8', found '*[10]u8'",
-    );
+    });
 
-    cases.add(
-        "result location incompatibility mismatching handle_is_ptr (generic call)",
+    cases.add("result location incompatibility mismatching handle_is_ptr (generic call)",
         \\export fn entry() void {
         \\    var damn = Container{
         \\        .not_optional = getOptional(i32),
@@ -594,12 +573,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\pub const Container = struct {
         \\    not_optional: i32,
         \\};
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:36: error: expected type 'i32', found '?i32'",
-    );
+    });
 
-    cases.add(
-        "result location incompatibility mismatching handle_is_ptr",
+    cases.add("result location incompatibility mismatching handle_is_ptr",
         \\export fn entry() void {
         \\    var damn = Container{
         \\        .not_optional = getOptional(),
@@ -611,12 +589,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\pub const Container = struct {
         \\    not_optional: i32,
         \\};
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:36: error: expected type 'i32', found '?i32'",
-    );
+    });
 
-    cases.add(
-        "const frame cast to anyframe",
+    cases.add("const frame cast to anyframe",
         \\export fn a() void {
         \\    const f = async func();
         \\    resume f;
@@ -628,13 +605,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn func() void {
         \\    suspend;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:12: error: expected type 'anyframe', found '*const @Frame(func)'",
         "tmp.zig:7:24: error: expected type 'anyframe', found '*const @Frame(func)'",
-    );
+    });
 
-    cases.add(
-        "prevent bad implicit casting of anyframe types",
+    cases.add("prevent bad implicit casting of anyframe types",
         \\export fn a() void {
         \\    var x: anyframe = undefined;
         \\    var y: anyframe->i32 = x;
@@ -648,14 +624,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var y: anyframe->i32 = &x;
         \\}
         \\fn func() void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:28: error: expected type 'anyframe->i32', found 'anyframe'",
         "tmp.zig:7:28: error: expected type 'anyframe->i32', found 'i32'",
         "tmp.zig:11:29: error: expected type 'anyframe->i32', found '*@Frame(func)'",
-    );
+    });
 
-    cases.add(
-        "wrong frame type used for async call",
+    cases.add("wrong frame type used for async call",
         \\export fn entry() void {
         \\    var frame: @Frame(foo) = undefined;
         \\    frame = async bar();
@@ -666,37 +641,34 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bar() void {
         \\    suspend;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: expected type '*@Frame(bar)', found '*@Frame(foo)'",
-    );
+    });
 
-    cases.add(
-        "@Frame() of generic function",
+    cases.add("@Frame() of generic function",
         \\export fn entry() void {
         \\    var frame: @Frame(func) = undefined;
         \\}
         \\fn func(comptime T: type) void {
         \\    var x: T = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:16: error: @Frame() of generic function",
-    );
+    });
 
-    cases.add(
-        "@frame() causes function to be async",
+    cases.add("@frame() causes function to be async",
         \\export fn entry() void {
         \\    func();
         \\}
         \\fn func() void {
         \\    _ = @frame();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: function with calling convention 'ccc' cannot be async",
         "tmp.zig:5:9: note: @frame() causes function to be async",
-    );
+    });
 
-    cases.add(
-        "invalid suspend in exported function",
+    cases.add("invalid suspend in exported function",
         \\export fn entry() void {
         \\    var frame = async func();
         \\    var result = await frame;
@@ -704,13 +676,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn func() void {
         \\    suspend;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: function with calling convention 'ccc' cannot be async",
         "tmp.zig:3:18: note: await here is a suspend point",
-    );
+    });
 
-    cases.add(
-        "async function indirectly depends on its own frame",
+    cases.add("async function indirectly depends on its own frame",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
@@ -720,39 +691,36 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn other() void {
         \\    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:1: error: unable to determine async function frame of 'amain'",
         "tmp.zig:5:10: note: analysis of function 'other' depends on the frame",
         "tmp.zig:8:13: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "async function depends on its own frame",
+    cases.add("async function depends on its own frame",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
         \\async fn amain() void {
         \\    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:1: error: cannot resolve '@Frame(amain)': function not fully analyzed yet",
         "tmp.zig:5:13: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "non async function pointer passed to @asyncCall",
+    cases.add("non async function pointer passed to @asyncCall",
         \\export fn entry() void {
         \\    var ptr = afunc;
         \\    var bytes: [100]u8 align(16) = undefined;
         \\    _ = @asyncCall(&bytes, {}, ptr);
         \\}
         \\fn afunc() void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:32: error: expected async function, found 'fn() void'",
-    );
+    });
 
-    cases.add(
-        "runtime-known async function called",
+    cases.add("runtime-known async function called",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
@@ -761,24 +729,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    _ = ptr();
         \\}
         \\async fn afunc() void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:12: error: function is not comptime-known; @asyncCall required",
-    );
+    });
 
-    cases.add(
-        "runtime-known function called with async keyword",
+    cases.add("runtime-known function called with async keyword",
         \\export fn entry() void {
         \\    var ptr = afunc;
         \\    _ = async ptr();
         \\}
         \\
         \\async fn afunc() void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:15: error: function is not comptime-known; @asyncCall required",
-    );
+    });
 
-    cases.add(
-        "function with ccc indirectly calling async function",
+    cases.add("function with ccc indirectly calling async function",
         \\export fn entry() void {
         \\    foo();
         \\}
@@ -788,15 +754,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bar() void {
         \\    suspend;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: function with calling convention 'ccc' cannot be async",
         "tmp.zig:2:8: note: async function call here",
         "tmp.zig:5:8: note: async function call here",
         "tmp.zig:8:5: note: suspends here",
-    );
+    });
 
-    cases.add(
-        "capture group on switch prong with incompatible payload types",
+    cases.add("capture group on switch prong with incompatible payload types",
         \\const Union = union(enum) {
         \\    A: usize,
         \\    B: isize,
@@ -807,59 +772,53 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .A, .B => |e| unreachable,
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:20: error: capture group with incompatible types",
         "tmp.zig:8:9: note: type 'usize' here",
         "tmp.zig:8:13: note: type 'isize' here",
-    );
+    });
 
-    cases.add(
-        "wrong type to @hasField",
+    cases.add("wrong type to @hasField",
         \\export fn entry() bool {
         \\    return @hasField(i32, "hi");
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:22: error: type 'i32' does not support @hasField",
-    );
+    });
 
-    cases.add(
-        "slice passed as array init type with elems",
+    cases.add("slice passed as array init type with elems",
         \\export fn entry() void {
         \\    const x = []u8{1, 2};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: array literal requires address-of operator to coerce to slice type '[]u8'",
-    );
+    });
 
-    cases.add(
-        "slice passed as array init type",
+    cases.add("slice passed as array init type",
         \\export fn entry() void {
         \\    const x = []u8{};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: array literal requires address-of operator to coerce to slice type '[]u8'",
-    );
+    });
 
-    cases.add(
-        "inferred array size invalid here",
+    cases.add("inferred array size invalid here",
         \\export fn entry() void {
         \\    const x = [_]u8;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: inferred array size invalid here",
-    );
+    });
 
-    cases.add(
-        "initializing array with struct syntax",
+    cases.add("initializing array with struct syntax",
         \\export fn entry() void {
         \\    const x = [_]u8{ .y = 2 };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: initializing array with struct syntax",
-    );
+    });
 
-    cases.add(
-        "compile error in struct init expression",
+    cases.add("compile error in struct init expression",
         \\const Foo = struct {
         \\    a: i32 = crap,
         \\    b: i32,
@@ -869,54 +828,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .b = 5,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: use of undeclared identifier 'crap'",
-    );
+    });
 
-    cases.add(
-        "undefined as field type is rejected",
+    cases.add("undefined as field type is rejected",
         \\const Foo = struct {
         \\    a: undefined,
         \\};
         \\export fn entry1() void {
         \\    const foo: Foo = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:8: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "@hasDecl with non-container",
+    cases.add("@hasDecl with non-container",
         \\export fn entry() void {
         \\    _ = @hasDecl(i32, "hi");
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:18: error: expected struct, enum, or union; found 'i32'",
-    );
+    });
 
-    cases.add(
-        "field access of slices",
+    cases.add("field access of slices",
         \\export fn entry() void {
         \\    var slice: []i32 = undefined;
         \\    const info = @typeOf(slice).unknown;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:32: error: type '[]i32' does not support field access",
-    );
+    });
 
-    cases.add(
-        "peer cast then implicit cast const pointer to mutable C pointer",
+    cases.add("peer cast then implicit cast const pointer to mutable C pointer",
         \\export fn func() void {
         \\    var strValue: [*c]u8 = undefined;
         \\    strValue = strValue orelse "";
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:32: error: expected type '[*c]u8', found '*const [0:0]u8'",
         "tmp.zig:3:32: note: cast discards const qualifier",
-    );
+    });
 
-    cases.add(
-        "overflow in enum value allocation",
+    cases.add("overflow in enum value allocation",
         \\const Moo = enum(u8) {
         \\    Last = 255,
         \\    Over,
@@ -924,32 +878,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\pub fn main() void {
         \\  var y = Moo.Last;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: enumeration value 256 too large for type 'u8'",
-    );
+    });
 
-    cases.add(
-        "attempt to cast enum literal to error",
+    cases.add("attempt to cast enum literal to error",
         \\export fn entry() void {
         \\    switch (error.Hi) {
         \\        .Hi => {},
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: expected type 'error{Hi}', found '(enum literal)'",
-    );
+    });
 
-    cases.add(
-        "@sizeOf bad type",
+    cases.add("@sizeOf bad type",
         \\export fn entry() usize {
         \\    return @sizeOf(@typeOf(null));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:20: error: no size available for type '(null)'",
-    );
+    });
 
-    cases.add(
-        "generic function where return type is self-referenced",
+    cases.add("generic function where return type is self-referenced",
         \\fn Foo(comptime T: type) Foo(T) {
         \\    return struct{ x: T };
         \\}
@@ -958,22 +909,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\      .x = 1
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:29: error: evaluation exceeded 1000 backwards branches",
         "tmp.zig:5:18: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "@ptrToInt 0 to non optional pointer",
+    cases.add("@ptrToInt 0 to non optional pointer",
         \\export fn entry() void {
         \\    var b = @intToPtr(*i32, 0);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:13: error: pointer type '*i32' does not allow address zero",
-    );
+    });
 
-    cases.add(
-        "cast enum literal to enum but it doesn't match",
+    cases.add("cast enum literal to enum but it doesn't match",
         \\const Foo = enum {
         \\    a,
         \\    b,
@@ -981,34 +930,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const x: Foo = .c;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:20: error: enum 'Foo' has no field named 'c'",
         "tmp.zig:1:13: note: 'Foo' declared here",
-    );
+    });
 
-    cases.add(
-        "discarding error value",
+    cases.add("discarding error value",
         \\export fn entry() void {
         \\    _ = foo();
         \\}
         \\fn foo() !void {
         \\    return error.OutOfMemory;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: error is discarded",
-    );
+    });
 
-    cases.add(
-        "volatile on global assembly",
+    cases.add("volatile on global assembly",
         \\comptime {
         \\    asm volatile ("");
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: volatile is meaningless on global assembly",
-    );
+    });
 
-    cases.add(
-        "invalid multiple dereferences",
+    cases.add("invalid multiple dereferences",
         \\export fn a() void {
         \\    var box = Box{ .field = 0 };
         \\    box.*.field = 1;
@@ -1021,20 +967,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\pub const Box = struct {
         \\    field: i32,
         \\};
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:8: error: attempt to dereference non-pointer type 'Box'",
         "tmp.zig:8:13: error: attempt to dereference non-pointer type 'Box'",
-    );
+    });
 
-    cases.add(
-        "usingnamespace with wrong type",
+    cases.add("usingnamespace with wrong type",
         \\usingnamespace void;
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: expected struct, enum, or union; found 'void'",
-    );
+    });
 
-    cases.add(
-        "ignored expression in while continuation",
+    cases.add("ignored expression in while continuation",
         \\export fn a() void {
         \\    while (true) : (bad()) {}
         \\}
@@ -1049,96 +993,86 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bad() anyerror!void {
         \\    return error.Bad;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:24: error: expression value is ignored",
         "tmp.zig:6:25: error: expression value is ignored",
         "tmp.zig:10:25: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "empty while loop body",
+    cases.add("empty while loop body",
         \\export fn a() void {
         \\    while(true);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:16: error: expected loop body, found ';'",
-    );
+    });
 
-    cases.add(
-        "empty for loop body",
+    cases.add("empty for loop body",
         \\export fn a() void {
         \\    for(undefined) |x|;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:23: error: expected loop body, found ';'",
-    );
+    });
 
-    cases.add(
-        "empty if body",
+    cases.add("empty if body",
         \\export fn a() void {
         \\    if(true);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:13: error: expected if body, found ';'",
-    );
+    });
 
-    cases.add(
-        "import outside package path",
+    cases.add("import outside package path",
         \\comptime{
         \\    _ = @import("../a.zig");
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: import of file outside package path: '../a.zig'",
-    );
+    });
 
-    cases.add(
-        "bogus compile var",
+    cases.add("bogus compile var",
         \\const x = @import("builtin").bogus;
         \\export fn entry() usize { return @sizeOf(@typeOf(x)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:29: error: container 'builtin' has no member called 'bogus'",
-    );
+    });
 
-    cases.add(
-        "wrong panic signature, runtime function",
+    cases.add("wrong panic signature, runtime function",
         \\test "" {}
         \\
         \\pub fn panic() void {}
         \\
-    ,
+    , &[_][]const u8{
         "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn() void'",
-    );
+    });
 
-    cases.add(
-        "wrong panic signature, generic function",
+    cases.add("wrong panic signature, generic function",
         \\pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
         \\    while (true) {}
         \\}
-    ,
+    , &[_][]const u8{
         "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,var)var'",
         "note: only one of the functions is generic",
-    );
+    });
 
-    cases.add(
-        "direct struct loop",
+    cases.add("direct struct loop",
         \\const A = struct { a : A, };
         \\export fn entry() usize { return @sizeOf(A); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:11: error: struct 'A' depends on itself",
-    );
+    });
 
-    cases.add(
-        "indirect struct loop",
+    cases.add("indirect struct loop",
         \\const A = struct { b : B, };
         \\const B = struct { c : C, };
         \\const C = struct { a : A, };
         \\export fn entry() usize { return @sizeOf(A); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:11: error: struct 'A' depends on itself",
-    );
+    });
 
-    cases.add(
-        "instantiating an undefined value for an invalid struct that contains itself",
+    cases.add("instantiating an undefined value for an invalid struct that contains itself",
         \\const Foo = struct {
         \\    x: Foo,
         \\};
@@ -1148,13 +1082,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() usize {
         \\    return @sizeOf(@typeOf(foo.x));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:13: error: struct 'Foo' depends on itself",
         "tmp.zig:8:28: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "@typeInfo causing depend on itself compile error",
+    cases.add("@typeInfo causing depend on itself compile error",
         \\const start = struct {
         \\    fn crash() bug() {
         \\        return bug;
@@ -1166,14 +1099,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var boom = start.crash();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:9: error: dependency loop detected",
         "tmp.zig:2:19: note: referenced here",
         "tmp.zig:10:21: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "enum field value references enum",
+    cases.add("enum field value references enum",
         \\pub const Foo = extern enum {
         \\    A = Foo.B,
         \\    C = D,
@@ -1181,25 +1113,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var s: Foo = Foo.E;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:17: error: enum 'Foo' depends on itself",
-    );
+    });
 
-    cases.add(
-        "top level decl dependency loop",
+    cases.add("top level decl dependency loop",
         \\const a : @typeOf(b) = 0;
         \\const b : @typeOf(a) = 0;
         \\export fn entry() void {
         \\    const c = a + b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:19: error: dependency loop detected",
         "tmp.zig:1:19: note: referenced here",
         "tmp.zig:4:15: note: referenced here",
-    );
+    });
 
-    cases.addTest(
-        "not an enum type",
+    cases.addTest("not an enum type",
         \\export fn entry() void {
         \\    var self: Error = undefined;
         \\    switch (self) {
@@ -1213,58 +1143,53 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\const InvalidToken = struct {};
         \\const ExpectedVarDeclOrFn = struct {};
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:9: error: expected type '@TagType(Error)', found 'type'",
-    );
+    });
 
-    cases.addTest(
-        "binary OR operator on error sets",
+    cases.addTest("binary OR operator on error sets",
         \\pub const A = error.A;
         \\pub const AB = A | error.B;
         \\export fn entry() void {
         \\    var x: AB = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'",
-    );
+    });
 
     if (builtin.os == builtin.Os.linux) {
-        cases.addTest(
-            "implicit dependency on libc",
+        cases.addTest("implicit dependency on libc",
             \\extern "c" fn exit(u8) void;
             \\export fn entry() void {
             \\    exit(0);
             \\}
-        ,
+        , &[_][]const u8{
             "tmp.zig:3:5: error: dependency on library c must be explicitly specified in the build command",
-        );
+        });
 
-        cases.addTest(
-            "libc headers note",
+        cases.addTest("libc headers note",
             \\const c = @cImport(@cInclude("stdio.h"));
             \\export fn entry() void {
             \\    _ = c.printf("hello, world!\n");
             \\}
-        ,
+        , &[_][]const u8{
             "tmp.zig:1:11: error: C import failed",
             "tmp.zig:1:11: note: libc headers not available; compilation does not link against libc",
-        );
+        });
     }
 
-    cases.addTest(
-        "comptime vector overflow shows the index",
+    cases.addTest("comptime vector overflow shows the index",
         \\comptime {
         \\    var a: @Vector(4, u8) = [_]u8{ 1, 2, 255, 4 };
         \\    var b: @Vector(4, u8) = [_]u8{ 5, 6, 1, 8 };
         \\    var x = a + b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:15: error: operation caused overflow",
         "tmp.zig:4:15: note: when computing vector element at index 2",
-    );
+    });
 
-    cases.addTest(
-        "packed struct with fields of not allowed types",
+    cases.addTest("packed struct with fields of not allowed types",
         \\const A = packed struct {
         \\    x: anyerror,
         \\};
@@ -1318,7 +1243,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    A,
         \\    B,
         \\};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation",
         "tmp.zig:5:5: error: array of 'u24' not allowed in packed struct due to padding bits",
         "tmp.zig:8:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation",
@@ -1327,45 +1252,41 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:17:5: error: type '?anyerror' not allowed in packed struct; no guaranteed in-memory representation",
         "tmp.zig:20:5: error: type 'Enum' not allowed in packed struct; no guaranteed in-memory representation",
         "tmp.zig:50:14: note: enum declaration does not specify an integer tag type",
-    );
+    });
 
     cases.addCase(x: {
-        var tc = cases.create(
-            "deduplicate undeclared identifier",
+        var tc = cases.create("deduplicate undeclared identifier",
             \\export fn a() void {
             \\    x += 1;
             \\}
             \\export fn b() void {
             \\    x += 1;
             \\}
-        ,
+        , &[_][]const u8{
             "tmp.zig:2:5: error: use of undeclared identifier 'x'",
-        );
+        });
         tc.expect_exact = true;
         break :x tc;
     });
 
-    cases.add(
-        "export generic function",
+    cases.add("export generic function",
         \\export fn foo(num: var) i32 {
         \\    return 0;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:15: error: parameter of type 'var' not allowed in function with calling convention 'ccc'",
-    );
+    });
 
-    cases.add(
-        "C pointer to c_void",
+    cases.add("C pointer to c_void",
         \\export fn a() void {
         \\    var x: *c_void = undefined;
         \\    var y: [*c]c_void = x;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:16: error: C pointers cannot point opaque types",
-    );
+    });
 
-    cases.add(
-        "directly embedding opaque type in struct and union",
+    cases.add("directly embedding opaque type in struct and union",
         \\const O = @OpaqueType();
         \\const Foo = struct {
         \\    o: O,
@@ -1380,13 +1301,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn b() void {
         \\    var bar: Bar = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:8: error: opaque types have unknown size and therefore cannot be directly embedded in structs",
         "tmp.zig:7:10: error: opaque types have unknown size and therefore cannot be directly embedded in unions",
-    );
+    });
 
-    cases.add(
-        "implicit cast between C pointer and Zig pointer - bad const/align/child",
+    cases.add("implicit cast between C pointer and Zig pointer - bad const/align/child",
         \\export fn a() void {
         \\    var x: [*c]u8 = undefined;
         \\    var y: *align(4) u8 = x;
@@ -1411,7 +1331,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var y: *u8 = undefined;
         \\    var x: [*c]u32 = y;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:27: error: cast increases pointer alignment",
         "tmp.zig:7:18: error: cast discards const qualifier",
         "tmp.zig:11:19: error: expected type '*u32', found '[*c]u8'",
@@ -1419,30 +1339,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:15:22: error: cast increases pointer alignment",
         "tmp.zig:19:21: error: cast discards const qualifier",
         "tmp.zig:23:22: error: expected type '[*c]u32', found '*u8'",
-    );
+    });
 
-    cases.add(
-        "implicit casting null c pointer to zig pointer",
+    cases.add("implicit casting null c pointer to zig pointer",
         \\comptime {
         \\    var c_ptr: [*c]u8 = 0;
         \\    var zig_ptr: *u8 = c_ptr;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:24: error: null pointer casted to type '*u8'",
-    );
+    });
 
-    cases.add(
-        "implicit casting undefined c pointer to zig pointer",
+    cases.add("implicit casting undefined c pointer to zig pointer",
         \\comptime {
         \\    var c_ptr: [*c]u8 = undefined;
         \\    var zig_ptr: *u8 = c_ptr;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:24: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "implicit casting C pointers which would mess up null semantics",
+    cases.add("implicit casting C pointers which would mess up null semantics",
         \\export fn entry() void {
         \\    var slice: []const u8 = "aoeu";
         \\    const opt_many_ptr: [*]const u8 = slice.ptr;
@@ -1457,17 +1374,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var ptr_opt_many_ptr = &opt_many_ptr;
         \\    var c_ptr: [*c][*c]const u8 = ptr_opt_many_ptr;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:24: error: expected type '*const [*]const u8', found '[*c]const [*c]const u8'",
         "tmp.zig:6:24: note: pointer type child '[*c]const u8' cannot cast into pointer type child '[*]const u8'",
         "tmp.zig:6:24: note: '[*c]const u8' could have null values which are illegal in type '[*]const u8'",
         "tmp.zig:13:35: error: expected type '[*c][*c]const u8', found '*[*]u8'",
         "tmp.zig:13:35: note: pointer type child '[*]u8' cannot cast into pointer type child '[*c]const u8'",
         "tmp.zig:13:35: note: mutable '[*c]const u8' allows illegal null values stored to type '[*]u8'",
-    );
+    });
 
-    cases.add(
-        "implicit casting too big integers to C pointers",
+    cases.add("implicit casting too big integers to C pointers",
         \\export fn a() void {
         \\    var ptr: [*c]u8 = (1 << 64) + 1;
         \\}
@@ -1475,25 +1391,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x: @IntType(false, 65) = 0x1234;
         \\    var ptr: [*c]u8 = x;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:33: error: integer value 18446744073709551617 cannot be coerced to type 'usize'",
         "tmp.zig:6:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'",
-    );
+    });
 
-    cases.add(
-        "C pointer pointing to non C ABI compatible type or has align attr",
+    cases.add("C pointer pointing to non C ABI compatible type or has align attr",
         \\const Foo = struct {};
         \\export fn a() void {
         \\    const T = [*c]Foo;
         \\    var t: T = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:19: error: C pointers cannot point to non-C-ABI-compatible type 'Foo'",
-    );
+    });
 
     cases.addCase(x: {
-        var tc = cases.create(
-            "compile log statement warning deduplication in generic fn",
+        var tc = cases.create("compile log statement warning deduplication in generic fn",
             \\export fn entry() void {
             \\    inner(1);
             \\    inner(2);
@@ -1502,111 +1416,100 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             \\    comptime var i = 0;
             \\    inline while (i < n) : (i += 1) { @compileLog("!@#$"); }
             \\}
-        ,
+        , &[_][]const u8{
             "tmp.zig:7:39: error: found compile log statement",
-        );
+        });
         tc.expect_exact = true;
         break :x tc;
     });
 
-    cases.add(
-        "assign to invalid dereference",
+    cases.add("assign to invalid dereference",
         \\export fn entry() void {
         \\    'a'.* = 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:8: error: attempt to dereference non-pointer type 'comptime_int'",
-    );
+    });
 
-    cases.add(
-        "take slice of invalid dereference",
+    cases.add("take slice of invalid dereference",
         \\export fn entry() void {
         \\    const x = 'a'.*[0..];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:18: error: attempt to dereference non-pointer type 'comptime_int'",
-    );
+    });
 
-    cases.add(
-        "@truncate undefined value",
+    cases.add("@truncate undefined value",
         \\export fn entry() void {
         \\    var z = @truncate(u8, @as(u16, undefined));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:27: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.addTest(
-        "return invalid type from test",
+    cases.addTest("return invalid type from test",
         \\test "example" { return 1; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:25: error: integer value 1 cannot be coerced to type 'void'",
-    );
+    });
 
-    cases.add(
-        "threadlocal qualifier on const",
+    cases.add("threadlocal qualifier on const",
         \\threadlocal const x: i32 = 1234;
         \\export fn entry() i32 {
         \\    return x;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:13: error: threadlocal variable cannot be constant",
-    );
+    });
 
-    cases.add(
-        "@bitCast same size but bit count mismatch",
+    cases.add("@bitCast same size but bit count mismatch",
         \\export fn entry(byte: u8) void {
         \\    var oops = @bitCast(u7, byte);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:25: error: destination type 'u7' has 7 bits but source type 'u8' has 8 bits",
-    );
+    });
 
-    cases.add(
-        "@bitCast with different sizes inside an expression",
+    cases.add("@bitCast with different sizes inside an expression",
         \\export fn entry() void {
         \\    var foo = (@bitCast(u8, @as(f32, 1.0)) == 0xf);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:25: error: destination type 'u8' has size 1 but source type 'f32' has size 4",
-    );
+    });
 
-    cases.add(
-        "attempted `&&`",
+    cases.add("attempted `&&`",
         \\export fn entry(a: bool, b: bool) i32 {
         \\    if (a && b) {
         \\        return 1234;
         \\    }
         \\    return 5678;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: `&&` is invalid. Note that `and` is boolean AND",
-    );
+    });
 
-    cases.add(
-        "attempted `||` on boolean values",
+    cases.add("attempted `||` on boolean values",
         \\export fn entry(a: bool, b: bool) i32 {
         \\    if (a || b) {
         \\        return 1234;
         \\    }
         \\    return 5678;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: expected error set type, found 'bool'",
         "tmp.zig:2:11: note: `||` merges error sets; `or` performs boolean OR",
-    );
+    });
 
-    cases.add(
-        "compile log a pointer to an opaque value",
+    cases.add("compile log a pointer to an opaque value",
         \\export fn entry() void {
         \\    @compileLog(@ptrCast(*const c_void, &entry));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: found compile log statement",
-    );
+    });
 
-    cases.add(
-        "duplicate boolean switch value",
+    cases.add("duplicate boolean switch value",
         \\comptime {
         \\    const x = switch (true) {
         \\        true => false,
@@ -1621,13 +1524,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        false => true,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:9: error: duplicate switch value",
         "tmp.zig:12:9: error: duplicate switch value",
-    );
+    });
 
-    cases.add(
-        "missing boolean switch value",
+    cases.add("missing boolean switch value",
         \\comptime {
         \\    const x = switch (true) {
         \\        true => false,
@@ -1638,37 +1540,34 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        false => true,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: switch must handle all possibilities",
         "tmp.zig:7:15: error: switch must handle all possibilities",
-    );
+    });
 
-    cases.add(
-        "reading past end of pointer casted array",
+    cases.add("reading past end of pointer casted array",
         \\comptime {
         \\    const array: [4]u8 = "aoeu".*;
         \\    const slice = array[1..];
         \\    const int_ptr = @ptrCast(*const u24, slice.ptr);
         \\    const deref = int_ptr.*;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:26: error: attempt to read 4 bytes from [4]u8 at index 1 which is 3 bytes",
-    );
+    });
 
-    cases.add(
-        "error note for function parameter incompatibility",
+    cases.add("error note for function parameter incompatibility",
         \\fn do_the_thing(func: fn (arg: i32) void) void {}
         \\fn bar(arg: bool) void {}
         \\export fn entry() void {
         \\    do_the_thing(bar);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:18: error: expected type 'fn(i32) void', found 'fn(bool) void",
         "tmp.zig:4:18: note: parameter 0: 'bool' cannot cast into 'i32'",
-    );
+    });
 
-    cases.add(
-        "cast negative value to unsigned integer",
+    cases.add("cast negative value to unsigned integer",
         \\comptime {
         \\    const value: i32 = -1;
         \\    const unsigned = @intCast(u32, value);
@@ -1677,13 +1576,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const value: i32 = -1;
         \\    const unsigned: u32 = value;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:36: error: cannot cast negative value -1 to unsigned integer type 'u32'",
         "tmp.zig:7:27: error: cannot cast negative value -1 to unsigned integer type 'u32'",
-    );
+    });
 
-    cases.add(
-        "integer cast truncates bits",
+    cases.add("integer cast truncates bits",
         \\export fn entry1() void {
         \\    const spartan_count: u16 = 300;
         \\    const byte = @intCast(u8, spartan_count);
@@ -1700,50 +1598,46 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var signed: i8 = -1;
         \\    var unsigned: u64 = signed;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:31: error: integer value 300 cannot be coerced to type 'u8'",
         "tmp.zig:7:22: error: integer value 300 cannot be coerced to type 'u8'",
         "tmp.zig:11:20: error: expected type 'u8', found 'u16'",
         "tmp.zig:11:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values",
         "tmp.zig:15:25: error: expected type 'u64', found 'i8'",
         "tmp.zig:15:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values",
-    );
+    });
 
-    cases.add(
-        "comptime implicit cast f64 to f32",
+    cases.add("comptime implicit cast f64 to f32",
         \\export fn entry() void {
         \\    const x: f64 = 16777217;
         \\    const y: f32 = x;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:20: error: cast of value 16777217.000000 to type 'f32' loses information",
-    );
+    });
 
-    cases.add(
-        "implicit cast from f64 to f32",
+    cases.add("implicit cast from f64 to f32",
         \\var x: f64 = 1.0;
         \\var y: f32 = x;
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(y)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: expected type 'f32', found 'f64'",
-    );
+    });
 
-    cases.add(
-        "exceeded maximum bit width of integer",
+    cases.add("exceeded maximum bit width of integer",
         \\export fn entry1() void {
         \\    const T = @IntType(false, 65536);
         \\}
         \\export fn entry2() void {
         \\    var x: i65536 = 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:31: error: integer value 65536 cannot be coerced to type 'u16'",
         "tmp.zig:5:12: error: primitive integer type 'i65536' exceeds maximum bit width of 65535",
-    );
+    });
 
-    cases.add(
-        "compile error when evaluating return type of inferred error set",
+    cases.add("compile error when evaluating return type of inferred error set",
         \\const Car = struct {
         \\    foo: *SymbolThatDoesNotExist,
         \\    pub fn init() !Car {}
@@ -1751,24 +1645,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const car = Car.init();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:11: error: use of undeclared identifier 'SymbolThatDoesNotExist'",
-    );
+    });
 
-    cases.add(
-        "don't implicit cast double pointer to *c_void",
+    cases.add("don't implicit cast double pointer to *c_void",
         \\export fn entry() void {
         \\    var a: u32 = 1;
         \\    var ptr: *c_void = &a;
         \\    var b: *u32 = @ptrCast(*u32, ptr);
         \\    var ptr2: *c_void = &b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:26: error: expected type '*c_void', found '**u32'",
-    );
+    });
 
-    cases.add(
-        "runtime index into comptime type slice",
+    cases.add("runtime index into comptime type slice",
         \\const Struct = struct {
         \\    a: u32,
         \\};
@@ -1779,12 +1671,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const index = getIndex();
         \\    const field = @typeInfo(Struct).Struct.fields[index];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:51: error: values of type 'std.builtin.StructField' must be comptime known, but index value is runtime known",
-    );
+    });
 
-    cases.add(
-        "compile log statement inside function which must be comptime evaluated",
+    cases.add("compile log statement inside function which must be comptime evaluated",
         \\fn Foo(comptime T: type) type {
         \\    @compileLog(@typeName(T));
         \\    return T;
@@ -1793,80 +1684,73 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    _ = Foo(i32);
         \\    _ = @typeName(Foo(i32));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: found compile log statement",
-    );
+    });
 
-    cases.add(
-        "comptime slice of an undefined slice",
+    cases.add("comptime slice of an undefined slice",
         \\comptime {
         \\    var a: []u8 = undefined;
         \\    var b = a[0..10];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:14: error: slice of undefined",
-    );
+    });
 
-    cases.add(
-        "implicit cast const array to mutable slice",
+    cases.add("implicit cast const array to mutable slice",
         \\export fn entry() void {
         \\    const buffer: [1]u8 = [_]u8{8};
         \\    const sliceA: []u8 = &buffer;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:27: error: expected type '[]u8', found '*const [1]u8'",
-    );
+    });
 
-    cases.add(
-        "deref slice and get len field",
+    cases.add("deref slice and get len field",
         \\export fn entry() void {
         \\    var a: []u8 = undefined;
         \\    _ = a.*.len;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:10: error: attempt to dereference non-pointer type '[]u8'",
-    );
+    });
 
-    cases.add(
-        "@ptrCast a 0 bit type to a non- 0 bit type",
+    cases.add("@ptrCast a 0 bit type to a non- 0 bit type",
         \\export fn entry() bool {
         \\    var x: u0 = 0;
         \\    const p = @ptrCast(?*u0, &x);
         \\    return p == null;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:15: error: '*u0' and '?*u0' do not have the same in-memory representation",
         "tmp.zig:3:31: note: '*u0' has no in-memory bits",
         "tmp.zig:3:24: note: '?*u0' has in-memory bits",
-    );
+    });
 
-    cases.add(
-        "comparing a non-optional pointer against null",
+    cases.add("comparing a non-optional pointer against null",
         \\export fn entry() void {
         \\    var x: i32 = 1;
         \\    _ = &x == null;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:12: error: comparison of '*i32' with null",
-    );
+    });
 
-    cases.add(
-        "non error sets used in merge error sets operator",
+    cases.add("non error sets used in merge error sets operator",
         \\export fn foo() void {
         \\    const Errors = u8 || u16;
         \\}
         \\export fn bar() void {
         \\    const Errors = error{} || u16;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:20: error: expected error set type, found type 'u8'",
         "tmp.zig:2:23: note: `||` merges error sets; `or` performs boolean OR",
         "tmp.zig:5:31: error: expected error set type, found type 'u16'",
         "tmp.zig:5:28: note: `||` merges error sets; `or` performs boolean OR",
-    );
+    });
 
-    cases.add(
-        "variable initialization compile error then referenced",
+    cases.add("variable initialization compile error then referenced",
         \\fn Undeclared() type {
         \\    return T;
         \\}
@@ -1879,23 +1763,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const S = Gen();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: use of undeclared identifier 'T'",
-    );
+    });
 
-    cases.add(
-        "refer to the type of a generic function",
+    cases.add("refer to the type of a generic function",
         \\export fn entry() void {
         \\    const Func = fn (type) void;
         \\    const f: Func = undefined;
         \\    f(i32);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "accessing runtime parameter from outer function",
+    cases.add("accessing runtime parameter from outer function",
         \\fn outer(y: u32) fn (u32) u32 {
         \\    const st = struct {
         \\        fn get(z: u32) u32 {
@@ -1908,53 +1790,48 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var func = outer(10);
         \\    var x = func(3);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:24: error: 'y' not accessible from inner function",
         "tmp.zig:3:28: note: crossed function definition here",
         "tmp.zig:1:10: note: declared here",
-    );
+    });
 
-    cases.add(
-        "non int passed to @intToFloat",
+    cases.add("non int passed to @intToFloat",
         \\export fn entry() void {
         \\    const x = @intToFloat(f32, 1.1);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:32: error: expected int type, found 'comptime_float'",
-    );
+    });
 
-    cases.add(
-        "non float passed to @floatToInt",
+    cases.add("non float passed to @floatToInt",
         \\export fn entry() void {
         \\    const x = @floatToInt(i32, @as(i32, 54));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:32: error: expected float type, found 'i32'",
-    );
+    });
 
-    cases.add(
-        "out of range comptime_int passed to @floatToInt",
+    cases.add("out of range comptime_int passed to @floatToInt",
         \\export fn entry() void {
         \\    const x = @floatToInt(i8, 200);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:31: error: integer value 200 cannot be coerced to type 'i8'",
-    );
+    });
 
-    cases.add(
-        "load too many bytes from comptime reinterpreted pointer",
+    cases.add("load too many bytes from comptime reinterpreted pointer",
         \\export fn entry() void {
         \\    const float: f32 = 5.99999999999994648725e-01;
         \\    const float_ptr = &float;
         \\    const int_ptr = @ptrCast(*const i64, float_ptr);
         \\    const int_val = int_ptr.*;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:28: error: attempt to read 8 bytes from pointer to f32 which is 4 bytes",
-    );
+    });
 
-    cases.add(
-        "invalid type used in array type",
+    cases.add("invalid type used in array type",
         \\const Item = struct {
         \\    field: SomeNonexistentType,
         \\};
@@ -1962,12 +1839,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const a = items[0];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: use of undeclared identifier 'SomeNonexistentType'",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime catch",
+    cases.add("comptime continue inside runtime catch",
         \\export fn entry(c: bool) void {
         \\    const ints = [_]u8{ 1, 2 };
         \\    inline for (ints) |_| {
@@ -1977,13 +1853,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bad() !void {
         \\    return error.Bad;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:25: error: comptime control flow inside runtime block",
         "tmp.zig:4:15: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime switch",
+    cases.add("comptime continue inside runtime switch",
         \\export fn entry() void {
         \\    var p: i32 = undefined;
         \\    comptime var q = true;
@@ -1995,13 +1870,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        q = false;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:19: error: comptime control flow inside runtime block",
         "tmp.zig:5:9: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime while error",
+    cases.add("comptime continue inside runtime while error",
         \\export fn entry() void {
         \\    var p: anyerror!usize = undefined;
         \\    comptime var q = true;
@@ -2012,13 +1886,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        q = false;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:13: error: comptime control flow inside runtime block",
         "tmp.zig:5:9: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime while optional",
+    cases.add("comptime continue inside runtime while optional",
         \\export fn entry() void {
         \\    var p: ?usize = undefined;
         \\    comptime var q = true;
@@ -2027,13 +1900,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        q = false;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:23: error: comptime control flow inside runtime block",
         "tmp.zig:5:9: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime while bool",
+    cases.add("comptime continue inside runtime while bool",
         \\export fn entry() void {
         \\    var p: usize = undefined;
         \\    comptime var q = true;
@@ -2042,13 +1914,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        q = false;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:25: error: comptime control flow inside runtime block",
         "tmp.zig:5:9: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime if error",
+    cases.add("comptime continue inside runtime if error",
         \\export fn entry() void {
         \\    var p: anyerror!i32 = undefined;
         \\    comptime var q = true;
@@ -2057,13 +1928,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        q = false;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:20: error: comptime control flow inside runtime block",
         "tmp.zig:5:9: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime if optional",
+    cases.add("comptime continue inside runtime if optional",
         \\export fn entry() void {
         \\    var p: ?i32 = undefined;
         \\    comptime var q = true;
@@ -2072,13 +1942,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        q = false;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:20: error: comptime control flow inside runtime block",
         "tmp.zig:5:9: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "comptime continue inside runtime if bool",
+    cases.add("comptime continue inside runtime if bool",
         \\export fn entry() void {
         \\    var p: usize = undefined;
         \\    comptime var q = true;
@@ -2087,13 +1956,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        q = false;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:22: error: comptime control flow inside runtime block",
         "tmp.zig:5:9: note: runtime block created here",
-    );
+    });
 
-    cases.add(
-        "switch with invalid expression parameter",
+    cases.add("switch with invalid expression parameter",
         \\export fn entry() void {
         \\    Test(i32);
         \\}
@@ -2104,43 +1972,39 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        else => unreachable,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:17: error: switch on type 'type' provides no expression parameter",
-    );
+    });
 
-    cases.add(
-        "function protoype with no body",
+    cases.add("function protoype with no body",
         \\fn foo() void;
         \\export fn entry() void {
         \\    foo();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: non-extern function has no body",
-    );
+    });
 
-    cases.add(
-        "@frame() called outside of function definition",
+    cases.add("@frame() called outside of function definition",
         \\var handle_undef: anyframe = undefined;
         \\var handle_dummy: anyframe = @frame();
         \\export fn entry() bool {
         \\    return handle_undef == handle_dummy;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:30: error: @frame() called outside of function definition",
-    );
+    });
 
-    cases.add(
-        "`_` is not a declarable symbol",
+    cases.add("`_` is not a declarable symbol",
         \\export fn f1() usize {
         \\    var _: usize = 2;
         \\    return _;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: `_` is not a declarable symbol",
-    );
+    });
 
-    cases.add(
-        "`_` should not be usable inside for",
+    cases.add("`_` should not be usable inside for",
         \\export fn returns() void {
         \\    for ([_]void{}) |_, i| {
         \\        for ([_]void{}) |_, j| {
@@ -2148,12 +2012,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        }
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:20: error: `_` may only be used to assign things to",
-    );
+    });
 
-    cases.add(
-        "`_` should not be usable inside while",
+    cases.add("`_` should not be usable inside while",
         \\export fn returns() void {
         \\    while (optionalReturn()) |_| {
         \\        while (optionalReturn()) |_| {
@@ -2164,12 +2027,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn optionalReturn() ?u32 {
         \\    return 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:20: error: `_` may only be used to assign things to",
-    );
+    });
 
-    cases.add(
-        "`_` should not be usable inside while else",
+    cases.add("`_` should not be usable inside while else",
         \\export fn returns() void {
         \\    while (optionalReturnError()) |_| {
         \\        while (optionalReturnError()) |_| {
@@ -2182,12 +2044,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn optionalReturnError() !?u32 {
         \\    return error.optionalReturnError;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:17: error: `_` may only be used to assign things to",
-    );
+    });
 
-    cases.add(
-        "while loop body expression ignored",
+    cases.add("while loop body expression ignored",
         \\fn returns() usize {
         \\    return 2;
         \\}
@@ -2202,25 +2063,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x: anyerror!i32 = error.Bad;
         \\    while (x) |_| returns() else |_| unreachable;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:25: error: expression value is ignored",
         "tmp.zig:9:26: error: expression value is ignored",
         "tmp.zig:13:26: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "missing parameter name of generic function",
+    cases.add("missing parameter name of generic function",
         \\fn dump(var) void {}
         \\export fn entry() void {
         \\    var a: u8 = 9;
         \\    dump(a);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:9: error: missing parameter name",
-    );
+    });
 
-    cases.add(
-        "non-inline for loop on a type that requires comptime",
+    cases.add("non-inline for loop on a type that requires comptime",
         \\const Foo = struct {
         \\    name: []const u8,
         \\    T: type,
@@ -2229,23 +2088,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const xx: [2]Foo = undefined;
         \\    for (xx) |f| {}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:5: error: values of type 'Foo' must be comptime known, but index value is runtime known",
-    );
+    });
 
-    cases.add(
-        "generic fn as parameter without comptime keyword",
+    cases.add("generic fn as parameter without comptime keyword",
         \\fn f(_: fn (var) void) void {}
         \\fn g(_: var) void {}
         \\export fn entry() void {
         \\    f(g);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:9: error: parameter of type 'fn(var)var' must be declared comptime",
-    );
+    });
 
-    cases.add(
-        "optional pointer to void in extern struct",
+    cases.add("optional pointer to void in extern struct",
         \\const Foo = extern struct {
         \\    x: ?*const void,
         \\};
@@ -2254,12 +2111,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    y: i32,
         \\};
         \\export fn entry(bar: *Bar) void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: extern structs cannot contain fields of type '?*const void'",
-    );
+    });
 
-    cases.add(
-        "use of comptime-known undefined function value",
+    cases.add("use of comptime-known undefined function value",
         \\const Cmd = struct {
         \\    exec: fn () void,
         \\};
@@ -2267,12 +2123,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const command = Cmd{ .exec = undefined };
         \\    command.exec();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:12: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "use of comptime-known undefined function value",
+    cases.add("use of comptime-known undefined function value",
         \\const Cmd = struct {
         \\    exec: fn () void,
         \\};
@@ -2280,41 +2135,37 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const command = Cmd{ .exec = undefined };
         \\    command.exec();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:12: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bad @alignCast at comptime",
+    cases.add("bad @alignCast at comptime",
         \\comptime {
         \\    const ptr = @intToPtr(*i32, 0x1);
         \\    const aligned = @alignCast(4, ptr);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes",
-    );
+    });
 
-    cases.add(
-        "@ptrToInt on *void",
+    cases.add("@ptrToInt on *void",
         \\export fn entry() bool {
         \\    return @ptrToInt(&{}) == @ptrToInt(&{});
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:23: error: pointer to size 0 type has no address",
-    );
+    });
 
-    cases.add(
-        "@popCount - non-integer",
+    cases.add("@popCount - non-integer",
         \\export fn entry(x: f32) u32 {
         \\    return @popCount(f32, x);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:22: error: expected integer type, found 'f32'",
-    );
+    });
 
     cases.addCase(x: {
-        const tc = cases.create(
-            "wrong same named struct",
+        const tc = cases.create("wrong same named struct",
             \\const a = @import("a.zig");
             \\const b = @import("b.zig");
             \\
@@ -2324,12 +2175,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             \\}
             \\
             \\fn bar(x: *b.Foo) void {}
-        ,
+        , &[_][]const u8{
             "tmp.zig:6:10: error: expected type '*b.Foo', found '*a.Foo'",
             "tmp.zig:6:10: note: pointer type child 'a.Foo' cannot cast into pointer type child 'b.Foo'",
             "a.zig:1:17: note: a.Foo declared here",
             "b.zig:1:17: note: b.Foo declared here",
-        );
+        });
 
         tc.addSourceFile("a.zig",
             \\pub const Foo = struct {
@@ -2346,8 +2197,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         break :x tc;
     });
 
-    cases.add(
-        "@floatToInt comptime safety",
+    cases.add("@floatToInt comptime safety",
         \\comptime {
         \\    _ = @floatToInt(i8, @as(f32, -129.1));
         \\}
@@ -2357,23 +2207,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    _ = @floatToInt(u8, @as(f32, 256.1));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: integer value '-129' cannot be stored in type 'i8'",
         "tmp.zig:5:9: error: integer value '-1' cannot be stored in type 'u8'",
         "tmp.zig:8:9: error: integer value '256' cannot be stored in type 'u8'",
-    );
+    });
 
-    cases.add(
-        "use c_void as return type of fn ptr",
+    cases.add("use c_void as return type of fn ptr",
         \\export fn entry() void {
         \\    const a: fn () c_void = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:20: error: return type cannot be opaque",
-    );
+    });
 
-    cases.add(
-        "use implicit casts to assign null to non-nullable pointer",
+    cases.add("use implicit casts to assign null to non-nullable pointer",
         \\export fn entry() void {
         \\    var x: i32 = 1234;
         \\    var p: *i32 = &x;
@@ -2381,30 +2229,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    pp.* = null;
         \\    var y = p.*;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:23: error: expected type '*?*i32', found '**i32'",
-    );
+    });
 
-    cases.add(
-        "attempted implicit cast from T to [*]const T",
+    cases.add("attempted implicit cast from T to [*]const T",
         \\export fn entry() void {
         \\    const x: [*]const bool = true;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:30: error: expected type '[*]const bool', found 'bool'",
-    );
+    });
 
-    cases.add(
-        "dereference unknown length pointer",
+    cases.add("dereference unknown length pointer",
         \\export fn entry(x: [*]i32) i32 {
         \\    return x.*;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'",
-    );
+    });
 
-    cases.add(
-        "field access of unknown length pointer",
+    cases.add("field access of unknown length pointer",
         \\const Foo = extern struct {
         \\    a: i32,
         \\};
@@ -2412,19 +2257,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry(foo: [*]Foo) void {
         \\    foo.a += 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:8: error: type '[*]Foo' does not support field access",
-    );
+    });
 
-    cases.add(
-        "unknown length pointer to opaque",
+    cases.add("unknown length pointer to opaque",
         \\export const T = [*]@OpaqueType();
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:21: error: unknown-length pointer to opaque",
-    );
+    });
 
-    cases.add(
-        "error when evaluating return type",
+    cases.add("error when evaluating return type",
         \\const Foo = struct {
         \\    map: @as(i32, i32),
         \\
@@ -2435,30 +2278,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var rule_set = try Foo.init();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:10: error: expected type 'i32', found 'type'",
-    );
+    });
 
-    cases.add(
-        "slicing single-item pointer",
+    cases.add("slicing single-item pointer",
         \\export fn entry(ptr: *i32) void {
         \\    const slice = ptr[0..2];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:22: error: slice of single-item pointer",
-    );
+    });
 
-    cases.add(
-        "indexing single-item pointer",
+    cases.add("indexing single-item pointer",
         \\export fn entry(ptr: *i32) i32 {
         \\    return ptr[1];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: index of single-item pointer",
-    );
+    });
 
-    cases.add(
-        "nested error set mismatch",
+    cases.add("nested error set mismatch",
         \\const NextError = error{NextError};
         \\const OtherError = error{OutOfMemory};
         \\
@@ -2469,15 +2309,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn foo() ?OtherError!i32 {
         \\    return null;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:34: error: expected type '?NextError!i32', found '?OtherError!i32'",
         "tmp.zig:5:34: note: optional type child 'OtherError!i32' cannot cast into optional type child 'NextError!i32'",
         "tmp.zig:5:34: note: error set 'OtherError' cannot cast into error set 'NextError'",
         "tmp.zig:2:26: note: 'error.OutOfMemory' not a member of destination error set",
-    );
+    });
 
-    cases.add(
-        "invalid deref on switch target",
+    cases.add("invalid deref on switch target",
         \\comptime {
         \\    var tile = Tile.Empty;
         \\    switch (tile.*) {
@@ -2489,19 +2328,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    Empty,
         \\    Filled,
         \\};
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:17: error: attempt to dereference non-pointer type 'Tile'",
-    );
+    });
 
-    cases.add(
-        "invalid field access in comptime",
+    cases.add("invalid field access in comptime",
         \\comptime { var x = doesnt_exist.whatever; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:20: error: use of undeclared identifier 'doesnt_exist'",
-    );
+    });
 
-    cases.add(
-        "suspend inside suspend block",
+    cases.add("suspend inside suspend block",
         \\export fn entry() void {
         \\    _ = async foo();
         \\}
@@ -2511,34 +2348,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        }
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:9: error: cannot suspend inside suspend block",
         "tmp.zig:5:5: note: other suspend block here",
-    );
+    });
 
-    cases.add(
-        "assign inline fn to non-comptime var",
+    cases.add("assign inline fn to non-comptime var",
         \\export fn entry() void {
         \\    var a = b;
         \\}
         \\inline fn b() void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: functions marked inline must be stored in const or comptime var",
         "tmp.zig:4:1: note: declared here",
-    );
+    });
 
-    cases.add(
-        "wrong type passed to @panic",
+    cases.add("wrong type passed to @panic",
         \\export fn entry() void {
         \\    var e = error.Foo;
         \\    @panic(e);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:12: error: expected type '[]const u8', found 'error{Foo}'",
-    );
+    });
 
-    cases.add(
-        "@tagName used on union with no associated enum tag",
+    cases.add("@tagName used on union with no associated enum tag",
         \\const FloatInt = extern union {
         \\    Float: f32,
         \\    Int: i32,
@@ -2547,54 +2381,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var fi = FloatInt{.Float = 123.45};
         \\    var tagName = @tagName(fi);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:19: error: union has no associated enum",
         "tmp.zig:1:18: note: declared here",
-    );
+    });
 
-    cases.add(
-        "returning error from void async function",
+    cases.add("returning error from void async function",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
         \\async fn amain() void {
         \\    return error.ShouldBeCompileError;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:17: error: expected type 'void', found 'error{ShouldBeCompileError}'",
-    );
+    });
 
-    cases.add(
-        "var makes structs required to be comptime known",
+    cases.add("var makes structs required to be comptime known",
         \\export fn entry() void {
         \\   const S = struct{v: var};
         \\   var s = S{.v=@as(i32, 10)};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:4: error: variable of type 'S' must be const or comptime",
-    );
+    });
 
-    cases.add(
-        "@ptrCast discards const qualifier",
+    cases.add("@ptrCast discards const qualifier",
         \\export fn entry() void {
         \\    const x: i32 = 1234;
         \\    const y = @ptrCast(*i32, &x);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:15: error: cast discards const qualifier",
-    );
+    });
 
-    cases.add(
-        "comptime slice of undefined pointer non-zero len",
+    cases.add("comptime slice of undefined pointer non-zero len",
         \\export fn entry() void {
         \\    const slice = @as([*]i32, undefined)[0..1];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:41: error: non-zero length slice of undefined pointer",
-    );
+    });
 
-    cases.add(
-        "type checking function pointers",
+    cases.add("type checking function pointers",
         \\fn a(b: fn (*const u8) void) void {
         \\    b('a');
         \\}
@@ -2602,12 +2431,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    a(c);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'",
-    );
+    });
 
-    cases.add(
-        "no else prong on switch on global error set",
+    cases.add("no else prong on switch on global error set",
         \\export fn entry() void {
         \\    foo(error.A);
         \\}
@@ -2616,23 +2444,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        error.A => {},
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: else prong required when switching on type 'anyerror'",
-    );
+    });
 
-    cases.add(
-        "inferred error set with no returned error",
+    cases.add("inferred error set with no returned error",
         \\export fn entry() void {
         \\    foo() catch unreachable;
         \\}
         \\fn foo() !void {
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:11: error: function with inferred error set must return at least one possible error",
-    );
+    });
 
-    cases.add(
-        "error not handled in switch",
+    cases.add("error not handled in switch",
         \\export fn entry() void {
         \\    foo(452) catch |err| switch (err) {
         \\        error.Foo => {},
@@ -2646,13 +2472,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        else => {},
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: error.Baz not handled in switch",
         "tmp.zig:2:26: error: error.Bar not handled in switch",
-    );
+    });
 
-    cases.add(
-        "duplicate error in switch",
+    cases.add("duplicate error in switch",
         \\export fn entry() void {
         \\    foo(452) catch |err| switch (err) {
         \\        error.Foo => {},
@@ -2668,10 +2493,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        else => {},
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:14: error: duplicate switch value: '@typeOf(foo).ReturnType.ErrorSet.Foo'",
         "tmp.zig:3:14: note: other value is here",
-    );
+    });
 
     cases.add("invalid cast from integral type to enum",
         \\const E = enum(usize) { One, Two };
@@ -2685,10 +2510,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        E.One => {},
         \\    }
         \\}
-    , "tmp.zig:9:10: error: expected type 'usize', found 'E'");
+    , &[_][]const u8{
+        "tmp.zig:9:10: error: expected type 'usize', found 'E'",
+    });
 
-    cases.add(
-        "range operator in switch used on error set",
+    cases.add("range operator in switch used on error set",
         \\export fn entry() void {
         \\    try foo(452) catch |err| switch (err) {
         \\        error.A ... error.B => {},
@@ -2702,41 +2528,37 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        else => {},
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:17: error: operator not allowed for errors",
-    );
+    });
 
-    cases.add(
-        "inferring error set of function pointer",
+    cases.add("inferring error set of function pointer",
         \\comptime {
         \\    const z: ?fn()!void = null;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: inferring error set of return type valid only for function definitions",
-    );
+    });
 
-    cases.add(
-        "access non-existent member of error set",
+    cases.add("access non-existent member of error set",
         \\const Foo = error{A};
         \\comptime {
         \\    const z = Foo.Bar;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:18: error: no error named 'Bar' in 'Foo'",
-    );
+    });
 
-    cases.add(
-        "error union operator with non error set LHS",
+    cases.add("error union operator with non error set LHS",
         \\comptime {
         \\    const z = i32!i32;
         \\    var x: z = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected error set type, found type 'i32'",
-    );
+    });
 
-    cases.add(
-        "error equality but sets have no common members",
+    cases.add("error equality but sets have no common members",
         \\const Set1 = error{A, C};
         \\const Set2 = error{B, D};
         \\export fn entry() void {
@@ -2747,33 +2569,30 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors",
-    );
+    });
 
-    cases.add(
-        "only equality binary operator allowed for error sets",
+    cases.add("only equality binary operator allowed for error sets",
         \\comptime {
         \\    const z = error.A > error.B;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:23: error: operator not allowed for errors",
-    );
+    });
 
-    cases.add(
-        "explicit error set cast known at comptime violates error sets",
+    cases.add("explicit error set cast known at comptime violates error sets",
         \\const Set1 = error {A, B};
         \\const Set2 = error {A, C};
         \\comptime {
         \\    var x = Set1.B;
         \\    var y = @errSetCast(Set2, x);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:13: error: error.B not a member of error set 'Set2'",
-    );
+    });
 
-    cases.add(
-        "cast error union of global error set to error union of smaller error set",
+    cases.add("cast error union of global error set to error union of smaller error set",
         \\const SmallErrorSet = error{A};
         \\export fn entry() void {
         \\    var x: SmallErrorSet!i32 = foo();
@@ -2781,14 +2600,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn foo() anyerror!i32 {
         \\    return error.B;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:35: error: expected type 'SmallErrorSet!i32', found 'anyerror!i32'",
         "tmp.zig:3:35: note: error set 'anyerror' cannot cast into error set 'SmallErrorSet'",
         "tmp.zig:3:35: note: cannot cast global error set into smaller set",
-    );
+    });
 
-    cases.add(
-        "cast global error set to error set",
+    cases.add("cast global error set to error set",
         \\const SmallErrorSet = error{A};
         \\export fn entry() void {
         \\    var x: SmallErrorSet = foo();
@@ -2796,24 +2614,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn foo() anyerror {
         \\    return error.B;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:31: error: expected type 'SmallErrorSet', found 'anyerror'",
         "tmp.zig:3:31: note: cannot cast global error set into smaller set",
-    );
-    cases.add(
-        "recursive inferred error set",
+    });
+    cases.add("recursive inferred error set",
         \\export fn entry() void {
         \\    foo() catch unreachable;
         \\}
         \\fn foo() !void {
         \\    try foo();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: cannot resolve inferred error set '@typeOf(foo).ReturnType.ErrorSet': function 'foo' not fully analyzed yet",
-    );
+    });
 
-    cases.add(
-        "implicit cast of error set not a subset",
+    cases.add("implicit cast of error set not a subset",
         \\const Set1 = error{A, B};
         \\const Set2 = error{A, C};
         \\export fn entry() void {
@@ -2822,13 +2638,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn foo(set1: Set1) void {
         \\    var x: Set2 = set1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:19: error: expected type 'Set2', found 'Set1'",
         "tmp.zig:1:23: note: 'error.B' not a member of destination error set",
-    );
+    });
 
-    cases.add(
-        "int to err global invalid number",
+    cases.add("int to err global invalid number",
         \\const Set1 = error{
         \\    A,
         \\    B,
@@ -2837,12 +2652,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x: u16 = 3;
         \\    var y = @intToError(x);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:13: error: integer value 3 represents no error",
-    );
+    });
 
-    cases.add(
-        "int to err non global invalid number",
+    cases.add("int to err non global invalid number",
         \\const Set1 = error{
         \\    A,
         \\    B,
@@ -2855,21 +2669,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x = @errorToInt(Set1.B);
         \\    var y = @errSetCast(Set2, @intToError(x));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:11:13: error: error.B not a member of error set 'Set2'",
-    );
+    });
 
-    cases.add(
-        "@memberCount of error",
+    cases.add("@memberCount of error",
         \\comptime {
         \\    _ = @memberCount(anyerror);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: global error set member count not available at comptime",
-    );
+    });
 
-    cases.add(
-        "duplicate error value in error set",
+    cases.add("duplicate error value in error set",
         \\const Foo = error {
         \\    Bar,
         \\    Bar,
@@ -2877,32 +2689,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const a: Foo = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate error: 'Bar'",
         "tmp.zig:2:5: note: other error here",
-    );
+    });
 
-    cases.add(
-        "cast negative integer literal to usize",
+    cases.add("cast negative integer literal to usize",
         \\export fn entry() void {
         \\    const x = @as(usize, -10);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: cannot cast negative value -10 to unsigned integer type 'usize'",
-    );
+    });
 
-    cases.add(
-        "use invalid number literal as array index",
+    cases.add("use invalid number literal as array index",
         \\var v = 25;
         \\export fn entry() void {
         \\    var arr: [v]u8 = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: unable to infer variable type",
-    );
+    });
 
-    cases.add(
-        "duplicate struct field",
+    cases.add("duplicate struct field",
         \\const Foo = struct {
         \\    Bar: i32,
         \\    Bar: usize,
@@ -2910,13 +2719,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const a: Foo = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate struct field: 'Bar'",
         "tmp.zig:2:5: note: other field here",
-    );
+    });
 
-    cases.add(
-        "duplicate union field",
+    cases.add("duplicate union field",
         \\const Foo = union {
         \\    Bar: i32,
         \\    Bar: usize,
@@ -2924,13 +2732,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const a: Foo = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate union field: 'Bar'",
         "tmp.zig:2:5: note: other field here",
-    );
+    });
 
-    cases.add(
-        "duplicate enum field",
+    cases.add("duplicate enum field",
         \\const Foo = enum {
         \\    Bar,
         \\    Bar,
@@ -2939,110 +2746,99 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const a: Foo = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate enum field: 'Bar'",
         "tmp.zig:2:5: note: other field here",
-    );
+    });
 
-    cases.add(
-        "calling function with naked calling convention",
+    cases.add("calling function with naked calling convention",
         \\export fn entry() void {
         \\    foo();
         \\}
         \\nakedcc fn foo() void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: unable to call function with naked calling convention",
         "tmp.zig:4:1: note: declared here",
-    );
+    });
 
-    cases.add(
-        "function with invalid return type",
+    cases.add("function with invalid return type",
         \\export fn foo() boid {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:17: error: use of undeclared identifier 'boid'",
-    );
+    });
 
-    cases.add(
-        "function with non-extern non-packed enum parameter",
+    cases.add("function with non-extern non-packed enum parameter",
         \\const Foo = enum { A, B, C };
         \\export fn entry(foo: Foo) void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'",
-    );
+    });
 
-    cases.add(
-        "function with non-extern non-packed struct parameter",
+    cases.add("function with non-extern non-packed struct parameter",
         \\const Foo = struct {
         \\    A: i32,
         \\    B: f32,
         \\    C: bool,
         \\};
         \\export fn entry(foo: Foo) void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'",
-    );
+    });
 
-    cases.add(
-        "function with non-extern non-packed union parameter",
+    cases.add("function with non-extern non-packed union parameter",
         \\const Foo = union {
         \\    A: i32,
         \\    B: f32,
         \\    C: bool,
         \\};
         \\export fn entry(foo: Foo) void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'",
-    );
+    });
 
-    cases.add(
-        "switch on enum with 1 field with no prongs",
+    cases.add("switch on enum with 1 field with no prongs",
         \\const Foo = enum { M };
         \\
         \\export fn entry() void {
         \\    var f = Foo.M;
         \\    switch (f) {}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: enumeration value 'Foo.M' not handled in switch",
-    );
+    });
 
-    cases.add(
-        "shift by negative comptime integer",
+    cases.add("shift by negative comptime integer",
         \\comptime {
         \\    var a = 1 >> -1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:18: error: shift by negative value -1",
-    );
+    });
 
-    cases.add(
-        "@panic called at compile time",
+    cases.add("@panic called at compile time",
         \\export fn entry() void {
         \\    comptime {
         \\        @panic("aoeu",);
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: encountered @panic at compile-time",
-    );
+    });
 
-    cases.add(
-        "wrong return type for main",
+    cases.add("wrong return type for main",
         \\pub fn main() f32 { }
-    ,
+    , &[_][]const u8{
         "error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'",
-    );
+    });
 
-    cases.add(
-        "double ?? on main return value",
+    cases.add("double ?? on main return value",
         \\pub fn main() ??void {
         \\}
-    ,
+    , &[_][]const u8{
         "error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'",
-    );
+    });
 
-    cases.add(
-        "bad identifier in function with struct defined inside function which references local const",
+    cases.add("bad identifier in function with struct defined inside function which references local const",
         \\export fn entry() void {
         \\    const BlockKind = u32;
         \\
@@ -3052,12 +2848,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\    bogus;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:5: error: use of undeclared identifier 'bogus'",
-    );
+    });
 
-    cases.add(
-        "labeled break not found",
+    cases.add("labeled break not found",
         \\export fn entry() void {
         \\    blah: while (true) {
         \\        while (true) {
@@ -3065,12 +2860,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        }
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:13: error: label not found: 'outer'",
-    );
+    });
 
-    cases.add(
-        "labeled continue not found",
+    cases.add("labeled continue not found",
         \\export fn entry() void {
         \\    var i: usize = 0;
         \\    blah: while (i < 10) : (i += 1) {
@@ -3079,12 +2873,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        }
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:13: error: labeled loop not found: 'outer'",
-    );
+    });
 
-    cases.add(
-        "attempt to use 0 bit type in extern fn",
+    cases.add("attempt to use 0 bit type in extern fn",
         \\extern fn foo(ptr: extern fn(*void) void) void;
         \\
         \\export fn entry() void {
@@ -3095,476 +2888,431 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry2() void {
         \\    bar(&{});
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:30: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'ccc'",
         "tmp.zig:7:18: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'ccc'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - block statement",
+    cases.add("implicit semicolon - block statement",
         \\export fn entry() void {
         \\    {}
         \\    var good = {};
         \\    ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - block expr",
+    cases.add("implicit semicolon - block expr",
         \\export fn entry() void {
         \\    _ = {};
         \\    var good = {};
         \\    _ = {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - comptime statement",
+    cases.add("implicit semicolon - comptime statement",
         \\export fn entry() void {
         \\    comptime {}
         \\    var good = {};
         \\    comptime ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - comptime expression",
+    cases.add("implicit semicolon - comptime expression",
         \\export fn entry() void {
         \\    _ = comptime {};
         \\    var good = {};
         \\    _ = comptime {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - defer",
+    cases.add("implicit semicolon - defer",
         \\export fn entry() void {
         \\    defer {}
         \\    var good = {};
         \\    defer ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if statement",
+    cases.add("implicit semicolon - if statement",
         \\export fn entry() void {
         \\    if(true) {}
         \\    var good = {};
         \\    if(true) ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if expression",
+    cases.add("implicit semicolon - if expression",
         \\export fn entry() void {
         \\    _ = if(true) {};
         \\    var good = {};
         \\    _ = if(true) {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if-else statement",
+    cases.add("implicit semicolon - if-else statement",
         \\export fn entry() void {
         \\    if(true) {} else {}
         \\    var good = {};
         \\    if(true) ({}) else ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if-else expression",
+    cases.add("implicit semicolon - if-else expression",
         \\export fn entry() void {
         \\    _ = if(true) {} else {};
         \\    var good = {};
         \\    _ = if(true) {} else {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if-else-if statement",
+    cases.add("implicit semicolon - if-else-if statement",
         \\export fn entry() void {
         \\    if(true) {} else if(true) {}
         \\    var good = {};
         \\    if(true) ({}) else if(true) ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if-else-if expression",
+    cases.add("implicit semicolon - if-else-if expression",
         \\export fn entry() void {
         \\    _ = if(true) {} else if(true) {};
         \\    var good = {};
         \\    _ = if(true) {} else if(true) {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if-else-if-else statement",
+    cases.add("implicit semicolon - if-else-if-else statement",
         \\export fn entry() void {
         \\    if(true) {} else if(true) {} else {}
         \\    var good = {};
         \\    if(true) ({}) else if(true) ({}) else ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - if-else-if-else expression",
+    cases.add("implicit semicolon - if-else-if-else expression",
         \\export fn entry() void {
         \\    _ = if(true) {} else if(true) {} else {};
         \\    var good = {};
         \\    _ = if(true) {} else if(true) {} else {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - test statement",
+    cases.add("implicit semicolon - test statement",
         \\export fn entry() void {
         \\    if (foo()) |_| {}
         \\    var good = {};
         \\    if (foo()) |_| ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - test expression",
+    cases.add("implicit semicolon - test expression",
         \\export fn entry() void {
         \\    _ = if (foo()) |_| {};
         \\    var good = {};
         \\    _ = if (foo()) |_| {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - while statement",
+    cases.add("implicit semicolon - while statement",
         \\export fn entry() void {
         \\    while(true) {}
         \\    var good = {};
         \\    while(true) ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - while expression",
+    cases.add("implicit semicolon - while expression",
         \\export fn entry() void {
         \\    _ = while(true) {};
         \\    var good = {};
         \\    _ = while(true) {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - while-continue statement",
+    cases.add("implicit semicolon - while-continue statement",
         \\export fn entry() void {
         \\    while(true):({}) {}
         \\    var good = {};
         \\    while(true):({}) ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - while-continue expression",
+    cases.add("implicit semicolon - while-continue expression",
         \\export fn entry() void {
         \\    _ = while(true):({}) {};
         \\    var good = {};
         \\    _ = while(true):({}) {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - for statement",
+    cases.add("implicit semicolon - for statement",
         \\export fn entry() void {
         \\    for(foo()) |_| {}
         \\    var good = {};
         \\    for(foo()) |_| ({})
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "implicit semicolon - for expression",
+    cases.add("implicit semicolon - for expression",
         \\export fn entry() void {
         \\    _ = for(foo()) |_| {};
         \\    var good = {};
         \\    _ = for(foo()) |_| {}
         \\    var bad = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: expected token ';', found 'var'",
-    );
+    });
 
-    cases.add(
-        "multiple function definitions",
+    cases.add("multiple function definitions",
         \\fn a() void {}
         \\fn a() void {}
         \\export fn entry() void { a(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:1: error: redefinition of 'a'",
-    );
+    });
 
-    cases.add(
-        "unreachable with return",
+    cases.add("unreachable with return",
         \\fn a() noreturn {return;}
         \\export fn entry() void { a(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:18: error: expected type 'noreturn', found 'void'",
-    );
+    });
 
-    cases.add(
-        "control reaches end of non-void function",
+    cases.add("control reaches end of non-void function",
         \\fn a() i32 {}
         \\export fn entry() void { _ = a(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:12: error: expected type 'i32', found 'void'",
-    );
+    });
 
-    cases.add(
-        "undefined function call",
+    cases.add("undefined function call",
         \\export fn a() void {
         \\    b();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: use of undeclared identifier 'b'",
-    );
+    });
 
-    cases.add(
-        "wrong number of arguments",
+    cases.add("wrong number of arguments",
         \\export fn a() void {
         \\    b(1);
         \\}
         \\fn b(a: i32, b: i32, c: i32) void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:6: error: expected 3 arguments, found 1",
-    );
+    });
 
-    cases.add(
-        "invalid type",
+    cases.add("invalid type",
         \\fn a() bogus {}
         \\export fn entry() void { _ = a(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:8: error: use of undeclared identifier 'bogus'",
-    );
+    });
 
-    cases.add(
-        "pointer to noreturn",
+    cases.add("pointer to noreturn",
         \\fn a() *noreturn {}
         \\export fn entry() void { _ = a(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:9: error: pointer to noreturn not allowed",
-    );
+    });
 
-    cases.add(
-        "unreachable code",
+    cases.add("unreachable code",
         \\export fn a() void {
         \\    return;
         \\    b();
         \\}
         \\
         \\fn b() void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:6: error: unreachable code",
-    );
+    });
 
-    cases.add(
-        "bad import",
+    cases.add("bad import",
         \\const bogus = @import("bogus-does-not-exist.zig",);
         \\export fn entry() void { bogus.bogo(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:15: error: unable to find 'bogus-does-not-exist.zig'",
-    );
+    });
 
-    cases.add(
-        "undeclared identifier",
+    cases.add("undeclared identifier",
         \\export fn a() void {
         \\    return
         \\    b +
         \\    c;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undeclared identifier 'b'",
-    );
+    });
 
-    cases.add(
-        "parameter redeclaration",
+    cases.add("parameter redeclaration",
         \\fn f(a : i32, a : i32) void {
         \\}
         \\export fn entry() void { f(1, 2); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:15: error: redeclaration of variable 'a'",
-    );
+    });
 
-    cases.add(
-        "local variable redeclaration",
+    cases.add("local variable redeclaration",
         \\export fn f() void {
         \\    const a : i32 = 0;
         \\    const a = 0;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: redeclaration of variable 'a'",
-    );
+    });
 
-    cases.add(
-        "local variable redeclares parameter",
+    cases.add("local variable redeclares parameter",
         \\fn f(a : i32) void {
         \\    const a = 0;
         \\}
         \\export fn entry() void { f(1); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: redeclaration of variable 'a'",
-    );
+    });
 
-    cases.add(
-        "variable has wrong type",
+    cases.add("variable has wrong type",
         \\export fn f() i32 {
         \\    const a = "a";
         \\    return a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:12: error: expected type 'i32', found '*const [1:0]u8'",
-    );
+    });
 
-    cases.add(
-        "if condition is bool, not int",
+    cases.add("if condition is bool, not int",
         \\export fn f() void {
         \\    if (0) {}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: expected type 'bool', found 'comptime_int'",
-    );
+    });
 
-    cases.add(
-        "assign unreachable",
+    cases.add("assign unreachable",
         \\export fn f() void {
         \\    const a = return;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: unreachable code",
-    );
+    });
 
-    cases.add(
-        "unreachable variable",
+    cases.add("unreachable variable",
         \\export fn f() void {
         \\    const a: noreturn = {};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:25: error: expected type 'noreturn', found 'void'",
-    );
+    });
 
-    cases.add(
-        "unreachable parameter",
+    cases.add("unreachable parameter",
         \\fn f(a: noreturn) void {}
         \\export fn entry() void { f(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:9: error: parameter of type 'noreturn' not allowed",
-    );
+    });
 
-    cases.add(
-        "bad assignment target",
+    cases.add("bad assignment target",
         \\export fn f() void {
         \\    3 = 3;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: cannot assign to constant",
-    );
+    });
 
-    cases.add(
-        "assign to constant variable",
+    cases.add("assign to constant variable",
         \\export fn f() void {
         \\    const a = 3;
         \\    a = 4;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: cannot assign to constant",
-    );
+    });
 
-    cases.add(
-        "use of undeclared identifier",
+    cases.add("use of undeclared identifier",
         \\export fn f() void {
         \\    b = 3;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: use of undeclared identifier 'b'",
-    );
+    });
 
-    cases.add(
-        "const is a statement, not an expression",
+    cases.add("const is a statement, not an expression",
         \\export fn f() void {
         \\    (const a = 0);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:6: error: invalid token: 'const'",
-    );
+    });
 
-    cases.add(
-        "array access of undeclared identifier",
+    cases.add("array access of undeclared identifier",
         \\export fn f() void {
         \\    i[i] = i[i];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: use of undeclared identifier 'i'",
-    );
+    });
 
-    cases.add(
-        "array access of non array",
+    cases.add("array access of non array",
         \\export fn f() void {
         \\    var bad : bool = undefined;
         \\    bad[bad] = bad[bad];
@@ -3573,13 +3321,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad : bool = undefined;
         \\    _ = bad[bad];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:8: error: array access of non-array type 'bool'",
         "tmp.zig:7:12: error: array access of non-array type 'bool'",
-    );
+    });
 
-    cases.add(
-        "array access with non integer index",
+    cases.add("array access with non integer index",
         \\export fn f() void {
         \\    var array = "aoeu";
         \\    var bad = false;
@@ -3590,24 +3337,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = false;
         \\    _ = array[bad];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:11: error: expected type 'usize', found 'bool'",
         "tmp.zig:9:15: error: expected type 'usize', found 'bool'",
-    );
+    });
 
-    cases.add(
-        "write to const global variable",
+    cases.add("write to const global variable",
         \\const x : i32 = 99;
         \\fn f() void {
         \\    x = 1;
         \\}
         \\export fn entry() void { f(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: cannot assign to constant",
-    );
+    });
 
-    cases.add(
-        "missing else clause",
+    cases.add("missing else clause",
         \\fn f(b: bool) void {
         \\    const x : i32 = if (b) h: { break :h 1; };
         \\}
@@ -3615,13 +3360,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const y = if (b) h: { break :h @as(i32, 1); };
         \\}
         \\export fn entry() void { f(true); g(true); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: expected type 'i32', found 'void'",
         "tmp.zig:5:15: error: incompatible types: 'i32' and 'void'",
-    );
+    });
 
-    cases.add(
-        "invalid struct field",
+    cases.add("invalid struct field",
         \\const A = struct { x : i32, };
         \\export fn f() void {
         \\    var a : A = undefined;
@@ -3632,38 +3376,34 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var a : A = undefined;
         \\    const y = a.bar;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:6: error: no member named 'foo' in struct 'A'",
         "tmp.zig:9:16: error: no member named 'bar' in struct 'A'",
-    );
+    });
 
-    cases.add(
-        "redefinition of struct",
+    cases.add("redefinition of struct",
         \\const A = struct { x : i32, };
         \\const A = struct { y : i32, };
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:1: error: redefinition of 'A'",
-    );
+    });
 
-    cases.add(
-        "redefinition of enums",
+    cases.add("redefinition of enums",
         \\const A = enum {};
         \\const A = enum {};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:1: error: redefinition of 'A'",
-    );
+    });
 
-    cases.add(
-        "redefinition of global variables",
+    cases.add("redefinition of global variables",
         \\var a : i32 = 1;
         \\var a : i32 = 2;
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:1: error: redefinition of 'a'",
         "tmp.zig:1:1: note: previous definition is here",
-    );
+    });
 
-    cases.add(
-        "duplicate field in struct value expression",
+    cases.add("duplicate field in struct value expression",
         \\const A = struct {
         \\    x : i32,
         \\    y : i32,
@@ -3677,12 +3417,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .z = 4,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:11:9: error: duplicate field",
-    );
+    });
 
-    cases.add(
-        "missing field in struct value expression",
+    cases.add("missing field in struct value expression",
         \\const A = struct {
         \\    x : i32,
         \\    y : i32,
@@ -3696,12 +3435,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .y = 2,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:17: error: missing field: 'x'",
-    );
+    });
 
-    cases.add(
-        "invalid field in struct value expression",
+    cases.add("invalid field in struct value expression",
         \\const A = struct {
         \\    x : i32,
         \\    y : i32,
@@ -3714,86 +3452,77 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .foo = 42,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:10:9: error: no member named 'foo' in struct 'A'",
-    );
+    });
 
-    cases.add(
-        "invalid break expression",
+    cases.add("invalid break expression",
         \\export fn f() void {
         \\    break;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: break expression outside loop",
-    );
+    });
 
-    cases.add(
-        "invalid continue expression",
+    cases.add("invalid continue expression",
         \\export fn f() void {
         \\    continue;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: continue expression outside loop",
-    );
+    });
 
-    cases.add(
-        "invalid maybe type",
+    cases.add("invalid maybe type",
         \\export fn f() void {
         \\    if (true) |x| { }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:9: error: expected optional type, found 'bool'",
-    );
+    });
 
-    cases.add(
-        "cast unreachable",
+    cases.add("cast unreachable",
         \\fn f() i32 {
         \\    return @as(i32, return 1);
         \\}
         \\export fn entry() void { _ = f(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: unreachable code",
-    );
+    });
 
-    cases.add(
-        "invalid builtin fn",
+    cases.add("invalid builtin fn",
         \\fn f() @bogus(foo) {
         \\}
         \\export fn entry() void { _ = f(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:8: error: invalid builtin function: 'bogus'",
-    );
+    });
 
-    cases.add(
-        "noalias on non pointer param",
+    cases.add("noalias on non pointer param",
         \\fn f(noalias x: i32) void {}
         \\export fn entry() void { f(1234); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:6: error: noalias on non-pointer parameter",
-    );
+    });
 
-    cases.add(
-        "struct init syntax for array",
+    cases.add("struct init syntax for array",
         \\const foo = [3]u16{ .x = 1024 };
         \\comptime {
         \\    _ = foo;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:21: error: type '[3]u16' does not support struct initialization syntax",
-    );
+    });
 
-    cases.add(
-        "type variables must be constant",
+    cases.add("type variables must be constant",
         \\var foo = u8;
         \\export fn entry() foo {
         \\    return 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: variable of type 'type' must be constant",
-    );
+    });
 
-    cases.add(
-        "variables shadowing types",
+    cases.add("variables shadowing types",
         \\const Foo = struct {};
         \\const Bar = struct {};
         \\
@@ -3804,15 +3533,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    f(1234);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:6: error: redefinition of 'Foo'",
         "tmp.zig:1:1: note: previous definition is here",
         "tmp.zig:5:5: error: redefinition of 'Bar'",
         "tmp.zig:2:1: note: previous definition is here",
-    );
+    });
 
-    cases.add(
-        "switch expression - missing enumeration prong",
+    cases.add("switch expression - missing enumeration prong",
         \\const Number = enum {
         \\    One,
         \\    Two,
@@ -3828,12 +3556,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:5: error: enumeration value 'Number.Four' not handled in switch",
-    );
+    });
 
-    cases.add(
-        "switch expression - duplicate enumeration prong",
+    cases.add("switch expression - duplicate enumeration prong",
         \\const Number = enum {
         \\    One,
         \\    Two,
@@ -3851,13 +3578,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:13:15: error: duplicate switch value",
         "tmp.zig:10:15: note: other value is here",
-    );
+    });
 
-    cases.add(
-        "switch expression - duplicate enumeration prong when else present",
+    cases.add("switch expression - duplicate enumeration prong when else present",
         \\const Number = enum {
         \\    One,
         \\    Two,
@@ -3876,13 +3602,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:13:15: error: duplicate switch value",
         "tmp.zig:10:15: note: other value is here",
-    );
+    });
 
-    cases.add(
-        "switch expression - multiple else prongs",
+    cases.add("switch expression - multiple else prongs",
         \\fn f(x: u32) void {
         \\    const value: bool = switch (x) {
         \\        1234 => false,
@@ -3893,24 +3618,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    f(1234);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:9: error: multiple else prongs in switch expression",
-    );
+    });
 
-    cases.add(
-        "switch expression - non exhaustive integer prongs",
+    cases.add("switch expression - non exhaustive integer prongs",
         \\fn foo(x: u8) void {
         \\    switch (x) {
         \\        0 => {},
         \\    }
         \\}
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: switch must handle all possibilities",
-    );
+    });
 
-    cases.add(
-        "switch expression - duplicate or overlapping integer value",
+    cases.add("switch expression - duplicate or overlapping integer value",
         \\fn foo(x: u8) u8 {
         \\    return switch (x) {
         \\        0 ... 100 => @as(u8, 0),
@@ -3920,13 +3643,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    };
         \\}
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:9: error: duplicate switch value",
         "tmp.zig:5:14: note: previous value is here",
-    );
+    });
 
-    cases.add(
-        "switch expression - switch on pointer type with no else",
+    cases.add("switch expression - switch on pointer type with no else",
         \\fn foo(x: *u8) void {
         \\    switch (x) {
         \\        &y => {},
@@ -3934,82 +3656,74 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\const y: u8 = 100;
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: else prong required when switching on type '*u8'",
-    );
+    });
 
-    cases.add(
-        "global variable initializer must be constant expression",
+    cases.add("global variable initializer must be constant expression",
         \\extern fn foo() i32;
         \\const x = foo();
         \\export fn entry() i32 { return x; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:11: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "array concatenation with wrong type",
+    cases.add("array concatenation with wrong type",
         \\const src = "aoeu";
         \\const derp: usize = 1234;
         \\const a = derp ++ "foo";
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(a)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:11: error: expected array, found 'usize'",
-    );
+    });
 
-    cases.add(
-        "non compile time array concatenation",
+    cases.add("non compile time array concatenation",
         \\fn f() []u8 {
         \\    return s ++ "foo";
         \\}
         \\var s: [10]u8 = undefined;
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "@cImport with bogus include",
+    cases.add("@cImport with bogus include",
         \\const c = @cImport(@cInclude("bogus.h"));
         \\export fn entry() usize { return @sizeOf(@typeOf(c.bogo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:11: error: C import failed",
         ".h:1:10: note: 'bogus.h' file not found",
-    );
+    });
 
-    cases.add(
-        "address of number literal",
+    cases.add("address of number literal",
         \\const x = 3;
         \\const y = &x;
         \\fn foo() *const i32 { return y; }
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:30: error: expected type '*const i32', found '*const comptime_int'",
-    );
+    });
 
-    cases.add(
-        "integer overflow error",
+    cases.add("integer overflow error",
         \\const x : u8 = 300;
         \\export fn entry() usize { return @sizeOf(@typeOf(x)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:16: error: integer value 300 cannot be coerced to type 'u8'",
-    );
+    });
 
-    cases.add(
-        "invalid shift amount error",
+    cases.add("invalid shift amount error",
         \\const x : u8 = 2;
         \\fn f() u16 {
         \\    return x << 8;
         \\}
         \\export fn entry() u16 { return f(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:14: error: RHS of shift is too large for LHS type",
         "tmp.zig:3:17: note: value 8 cannot fit into type u3",
-    );
+    });
 
-    cases.add(
-        "missing function call param",
+    cases.add("missing function call param",
         \\const Foo = struct {
         \\    a: i32,
         \\    b: i32,
@@ -4033,60 +3747,54 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:20:34: error: expected 1 arguments, found 0",
-    );
+    });
 
-    cases.add(
-        "missing function name",
+    cases.add("missing function name",
         \\fn () void {}
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: missing function name",
-    );
+    });
 
-    cases.add(
-        "missing param name",
+    cases.add("missing param name",
         \\fn f(i32) void {}
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:6: error: missing parameter name",
-    );
+    });
 
-    cases.add(
-        "wrong function type",
+    cases.add("wrong function type",
         \\const fns = [_]fn() void { a, b, c };
         \\fn a() i32 {return 0;}
         \\fn b() i32 {return 1;}
         \\fn c() i32 {return 2;}
         \\export fn entry() usize { return @sizeOf(@typeOf(fns)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:28: error: expected type 'fn() void', found 'fn() i32'",
-    );
+    });
 
-    cases.add(
-        "extern function pointer mismatch",
+    cases.add("extern function pointer mismatch",
         \\const fns = [_](fn(i32)i32) { a, b, c };
         \\pub fn a(x: i32) i32 {return x + 0;}
         \\pub fn b(x: i32) i32 {return x + 1;}
         \\export fn c(x: i32) i32 {return x + 2;}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(fns)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:37: error: expected type 'fn(i32) i32', found 'extern fn(i32) i32'",
-    );
+    });
 
-    cases.add(
-        "colliding invalid top level functions",
+    cases.add("colliding invalid top level functions",
         \\fn func() bogus {}
         \\fn func() bogus {}
         \\export fn entry() usize { return @sizeOf(@typeOf(func)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:1: error: redefinition of 'func'",
-    );
+    });
 
-    cases.add(
-        "non constant expression in array size",
+    cases.add("non constant expression in array size",
         \\const Foo = struct {
         \\    y: [get()]u8,
         \\};
@@ -4094,25 +3802,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn get() usize { return global_var; }
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(Foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:25: error: unable to evaluate constant expression",
         "tmp.zig:2:12: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "addition with non numbers",
+    cases.add("addition with non numbers",
         \\const Foo = struct {
         \\    field: i32,
         \\};
         \\const x = Foo {.field = 1} + Foo {.field = 2};
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(x)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:28: error: invalid operands to binary expression: 'Foo' and 'Foo'",
-    );
+    });
 
-    cases.add(
-        "division by zero",
+    cases.add("division by zero",
         \\const lit_int_x = 1 / 0;
         \\const lit_float_x = 1.0 / 0.0;
         \\const int_x = @as(u32, 1) / @as(u32, 0);
@@ -4122,522 +3828,471 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry2() usize { return @sizeOf(@typeOf(lit_float_x)); }
         \\export fn entry3() usize { return @sizeOf(@typeOf(int_x)); }
         \\export fn entry4() usize { return @sizeOf(@typeOf(float_x)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:21: error: division by zero",
         "tmp.zig:2:25: error: division by zero",
         "tmp.zig:3:27: error: division by zero",
         "tmp.zig:4:31: error: division by zero",
-    );
+    });
 
-    cases.add(
-        "normal string with newline",
+    cases.add("normal string with newline",
         \\const foo = "a
         \\b";
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:15: error: newline not allowed in string literal",
-    );
+    });
 
-    cases.add(
-        "invalid comparison for function pointers",
+    cases.add("invalid comparison for function pointers",
         \\fn foo() void {}
         \\const invalid = foo > foo;
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(invalid)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: operator not allowed for type 'fn() void'",
-    );
+    });
 
-    cases.add(
-        "generic function instance with non-constant expression",
+    cases.add("generic function instance with non-constant expression",
         \\fn foo(comptime x: i32, y: i32) i32 { return x + y; }
         \\fn test1(a: i32, b: i32) i32 {
         \\    return foo(a, b);
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(test1)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:16: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "assign null to non-optional pointer",
+    cases.add("assign null to non-optional pointer",
         \\const a: *u8 = null;
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(a)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:16: error: expected type '*u8', found '(null)'",
-    );
+    });
 
-    cases.add(
-        "indexing an array of size zero",
+    cases.add("indexing an array of size zero",
         \\const array = [_]u8{};
         \\export fn foo() void {
         \\    const pointer = &array[0];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:27: error: index 0 outside array of size 0",
-    );
+    });
 
-    cases.add(
-        "compile time division by zero",
+    cases.add("compile time division by zero",
         \\const y = foo(0);
         \\fn foo(x: u32) u32 {
         \\    return 1 / x;
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(y)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:14: error: division by zero",
         "tmp.zig:1:14: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "branch on undefined value",
+    cases.add("branch on undefined value",
         \\const x = if (undefined) true else false;
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(x)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:15: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "div on undefined value",
+    cases.add("div on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a / a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "div assign on undefined value",
+    cases.add("div assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a /= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "mod on undefined value",
+    cases.add("mod on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a % a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "mod assign on undefined value",
+    cases.add("mod assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a %= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "add on undefined value",
+    cases.add("add on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a + a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "add assign on undefined value",
+    cases.add("add assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a += a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "add wrap on undefined value",
+    cases.add("add wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a +% a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "add wrap assign on undefined value",
+    cases.add("add wrap assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a +%= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "sub on undefined value",
+    cases.add("sub on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a - a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "sub assign on undefined value",
+    cases.add("sub assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a -= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "sub wrap on undefined value",
+    cases.add("sub wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a -% a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "sub wrap assign on undefined value",
+    cases.add("sub wrap assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a -%= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "mult on undefined value",
+    cases.add("mult on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a * a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "mult assign on undefined value",
+    cases.add("mult assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a *= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "mult wrap on undefined value",
+    cases.add("mult wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a *% a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "mult wrap assign on undefined value",
+    cases.add("mult wrap assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a *%= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "shift left on undefined value",
+    cases.add("shift left on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a << 2;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "shift left assign on undefined value",
+    cases.add("shift left assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a <<= 2;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "shift right on undefined value",
+    cases.add("shift right on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a >> 2;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "shift left assign on undefined value",
+    cases.add("shift left assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a >>= 2;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bin and on undefined value",
+    cases.add("bin and on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a & a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bin and assign on undefined value",
+    cases.add("bin and assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a &= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bin or on undefined value",
+    cases.add("bin or on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a | a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bin or assign on undefined value",
+    cases.add("bin or assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a |= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bin xor on undefined value",
+    cases.add("bin xor on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a ^ a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bin xor assign on undefined value",
+    cases.add("bin xor assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a ^= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "equal on undefined value",
+    cases.add("equal on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a == a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "not equal on undefined value",
+    cases.add("not equal on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a != a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "greater than on undefined value",
+    cases.add("greater than on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a > a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "greater than equal on undefined value",
+    cases.add("greater than equal on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a >= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "less than on undefined value",
+    cases.add("less than on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a < a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "less than equal on undefined value",
+    cases.add("less than equal on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a <= a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "and on undefined value",
+    cases.add("and on undefined value",
         \\comptime {
         \\    var a: bool = undefined;
         \\    _ = a and a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "or on undefined value",
+    cases.add("or on undefined value",
         \\comptime {
         \\    var a: bool = undefined;
         \\    _ = a or a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "negate on undefined value",
+    cases.add("negate on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = -a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "negate wrap on undefined value",
+    cases.add("negate wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = -%a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bin not on undefined value",
+    cases.add("bin not on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = ~a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "bool not on undefined value",
+    cases.add("bool not on undefined value",
         \\comptime {
         \\    var a: bool = undefined;
         \\    _ = !a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "orelse on undefined value",
+    cases.add("orelse on undefined value",
         \\comptime {
         \\    var a: ?bool = undefined;
         \\    _ = a orelse false;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "catch on undefined value",
+    cases.add("catch on undefined value",
         \\comptime {
         \\    var a: anyerror!bool = undefined;
         \\    _ = a catch |err| false;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
-    );
+    });
 
-    cases.add(
-        "deref on undefined value",
+    cases.add("deref on undefined value",
         \\comptime {
         \\    var a: *u8 = undefined;
         \\    _ = a.*;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:9: error: attempt to dereference undefined value",
-    );
+    });
 
-    cases.add(
-        "endless loop in function evaluation",
+    cases.add("endless loop in function evaluation",
         \\const seventh_fib_number = fibbonaci(7);
         \\fn fibbonaci(x: i32) i32 {
         \\    return fibbonaci(x - 1) + fibbonaci(x - 2);
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(seventh_fib_number)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:21: error: evaluation exceeded 1000 backwards branches",
         "tmp.zig:1:37: note: referenced here",
         "tmp.zig:6:50: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "@embedFile with bogus file",
+    cases.add("@embedFile with bogus file",
         \\const resource = @embedFile("bogus.txt",);
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(resource)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:29: error: unable to find '",
         "bogus.txt'",
-    );
+    });
 
-    cases.add(
-        "non-const expression in struct literal outside function",
+    cases.add("non-const expression in struct literal outside function",
         \\const Foo = struct {
         \\    x: i32,
         \\};
@@ -4645,12 +4300,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\extern fn get_it() i32;
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(a)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:21: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "non-const expression function call with struct return value outside function",
+    cases.add("non-const expression function call with struct return value outside function",
         \\const Foo = struct {
         \\    x: i32,
         \\};
@@ -4662,25 +4316,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\var global_side_effect = false;
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(a)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:26: error: unable to evaluate constant expression",
         "tmp.zig:4:17: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "undeclared identifier error should mark fn as impure",
+    cases.add("undeclared identifier error should mark fn as impure",
         \\export fn foo() void {
         \\    test_a_thing();
         \\}
         \\fn test_a_thing() void {
         \\    bad_fn_call();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: use of undeclared identifier 'bad_fn_call'",
-    );
+    });
 
-    cases.add(
-        "illegal comparison of types",
+    cases.add("illegal comparison of types",
         \\fn bad_eql_1(a: []u8, b: []u8) bool {
         \\    return a == b;
         \\}
@@ -4694,13 +4346,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\export fn entry1() usize { return @sizeOf(@typeOf(bad_eql_1)); }
         \\export fn entry2() usize { return @sizeOf(@typeOf(bad_eql_2)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: operator not allowed for type '[]u8'",
         "tmp.zig:9:16: error: operator not allowed for type 'EnumWithData'",
-    );
+    });
 
-    cases.add(
-        "non-const switch number literal",
+    cases.add("non-const switch number literal",
         \\export fn foo() void {
         \\    const x = switch (bar()) {
         \\        1, 2 => 1,
@@ -4711,109 +4362,100 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bar() i32 {
         \\    return 2;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:17: error: cannot store runtime value in type 'comptime_int'",
-    );
+    });
 
-    cases.add(
-        "atomic orderings of cmpxchg - failure stricter than success",
+    cases.add("atomic orderings of cmpxchg - failure stricter than success",
         \\const AtomicOrder = @import("builtin").AtomicOrder;
         \\export fn f() void {
         \\    var x: i32 = 1234;
         \\    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:81: error: failure atomic ordering must be no stricter than success",
-    );
+    });
 
-    cases.add(
-        "atomic orderings of cmpxchg - success Monotonic or stricter",
+    cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",
         \\const AtomicOrder = @import("builtin").AtomicOrder;
         \\export fn f() void {
         \\    var x: i32 = 1234;
         \\    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:58: error: success atomic ordering must be Monotonic or stricter",
-    );
+    });
 
-    cases.add(
-        "negation overflow in function evaluation",
+    cases.add("negation overflow in function evaluation",
         \\const y = neg(-128);
         \\fn neg(x: i8) i8 {
         \\    return -x;
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(y)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:12: error: negation caused overflow",
         "tmp.zig:1:14: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "add overflow in function evaluation",
+    cases.add("add overflow in function evaluation",
         \\const y = add(65530, 10);
         \\fn add(a: u16, b: u16) u16 {
         \\    return a + b;
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(y)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:14: error: operation caused overflow",
         "tmp.zig:1:14: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "sub overflow in function evaluation",
+    cases.add("sub overflow in function evaluation",
         \\const y = sub(10, 20);
         \\fn sub(a: u16, b: u16) u16 {
         \\    return a - b;
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(y)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:14: error: operation caused overflow",
         "tmp.zig:1:14: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "mul overflow in function evaluation",
+    cases.add("mul overflow in function evaluation",
         \\const y = mul(300, 6000);
         \\fn mul(a: u16, b: u16) u16 {
         \\    return a * b;
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(y)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:14: error: operation caused overflow",
         "tmp.zig:1:14: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "truncate sign mismatch",
+    cases.add("truncate sign mismatch",
         \\fn f() i8 {
         \\    var x: u32 = 10;
         \\    return @truncate(i8, x);
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:26: error: expected signed integer type, found 'u32'",
-    );
+    });
 
-    cases.add(
-        "try in function with non error return type",
+    cases.add("try in function with non error return type",
         \\export fn f() void {
         \\    try something();
         \\}
         \\fn something() anyerror!void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: expected type 'void', found 'anyerror'",
         "tmp.zig:1:15: note: return type declared here",
-    );
+    });
 
-    cases.add(
-        "invalid pointer for var type",
+    cases.add("invalid pointer for var type",
         \\extern fn ext() usize;
         \\var bytes: [ext()]u8 = undefined;
         \\export fn f() void {
@@ -4821,43 +4463,39 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        b.* = @as(u8, i);
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:13: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "export function with comptime parameter",
+    cases.add("export function with comptime parameter",
         \\export fn foo(comptime x: i32, y: i32) i32{
         \\    return x + y;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'ccc'",
-    );
+    });
 
-    cases.add(
-        "extern function with comptime parameter",
+    cases.add("extern function with comptime parameter",
         \\extern fn foo(comptime x: i32, y: i32) i32;
         \\fn f() i32 {
         \\    return foo(1, 2);
         \\}
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'ccc'",
-    );
+    });
 
-    cases.add(
-        "convert fixed size array to slice with invalid size",
+    cases.add("convert fixed size array to slice with invalid size",
         \\export fn f() void {
         \\    var array: [5]u8 = undefined;
         \\    var foo = @bytesToSlice(u32, &array)[0];
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:15: error: unable to convert [5]u8 to []align(1) u32: size mismatch",
         "tmp.zig:3:29: note: u32 has size 4; remaining bytes: 1",
-    );
+    });
 
-    cases.add(
-        "non-pure function returns type",
+    cases.add("non-pure function returns type",
         \\var a: u32 = 0;
         \\pub fn List(comptime T: type) type {
         \\    a += 1;
@@ -4876,24 +4514,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var list: List(i32) = undefined;
         \\    list.length = 10;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:7: error: unable to evaluate constant expression",
         "tmp.zig:16:19: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "bogus method call on slice",
+    cases.add("bogus method call on slice",
         \\var self = "aoeu";
         \\fn f(m: []const u8) void {
         \\    m.copy(u8, self[0..], m);
         \\}
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:6: error: no member named 'copy' in '[]const u8'",
-    );
+    });
 
-    cases.add(
-        "wrong number of arguments for method fn call",
+    cases.add("wrong number of arguments for method fn call",
         \\const Foo = struct {
         \\    fn method(self: *const Foo, a: i32) void {}
         \\};
@@ -4902,39 +4538,35 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    foo.method(1, 2);
         \\}
         \\export fn entry() usize { return @sizeOf(@typeOf(f)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:15: error: expected 2 arguments, found 3",
-    );
+    });
 
-    cases.add(
-        "assign through constant pointer",
+    cases.add("assign through constant pointer",
         \\export fn f() void {
         \\  var cstr = "Hat";
         \\  cstr[0] = 'W';
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:13: error: cannot assign to constant",
-    );
+    });
 
-    cases.add(
-        "assign through constant slice",
+    cases.add("assign through constant slice",
         \\export fn f() void {
         \\  var cstr: []const u8 = "Hat";
         \\  cstr[0] = 'W';
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:13: error: cannot assign to constant",
-    );
+    });
 
-    cases.add(
-        "main function with bogus args type",
+    cases.add("main function with bogus args type",
         \\pub fn main(args: [][]bogus) !void {}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:23: error: use of undeclared identifier 'bogus'",
-    );
+    });
 
-    cases.add(
-        "misspelled type with pointer only reference",
+    cases.add("misspelled type with pointer only reference",
         \\const JasonHM = u8;
         \\const JasonList = *JsonNode;
         \\
@@ -4965,12 +4597,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:16: error: use of undeclared identifier 'JsonList'",
-    );
+    });
 
-    cases.add(
-        "method call with first arg type primitive",
+    cases.add("method call with first arg type primitive",
         \\const Foo = struct {
         \\    x: i32,
         \\
@@ -4986,12 +4617,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\    derp.init();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:14:5: error: expected type 'i32', found 'Foo'",
-    );
+    });
 
-    cases.add(
-        "method call with first arg type wrong container",
+    cases.add("method call with first arg type wrong container",
         \\pub const List = struct {
         \\    len: usize,
         \\    allocator: *Allocator,
@@ -5016,33 +4646,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x = List.init(&global_allocator);
         \\    x.init();
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:23:5: error: expected type '*Allocator', found '*List'",
-    );
+    });
 
-    cases.add(
-        "binary not on number literal",
+    cases.add("binary not on number literal",
         \\const TINY_QUANTUM_SHIFT = 4;
         \\const TINY_QUANTUM_SIZE = 1 << TINY_QUANTUM_SHIFT;
         \\var block_aligned_stuff: usize = (4 + TINY_QUANTUM_SIZE) & ~(TINY_QUANTUM_SIZE - 1);
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(block_aligned_stuff)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:60: error: unable to perform binary not operation on type 'comptime_int'",
-    );
+    });
 
     cases.addCase(x: {
-        const tc = cases.create(
-            "multiple files with private function error",
+        const tc = cases.create("multiple files with private function error",
             \\const foo = @import("foo.zig",);
             \\
             \\export fn callPrivFunction() void {
             \\    foo.privateFunction();
             \\}
-        ,
+        , &[_][]const u8{
             "tmp.zig:4:8: error: 'privateFunction' is private",
             "foo.zig:1:1: note: declared here",
-        );
+        });
 
         tc.addSourceFile("foo.zig",
             \\fn privateFunction() void { }
@@ -5051,18 +4679,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         break :x tc;
     });
 
-    cases.add(
-        "container init with non-type",
+    cases.add("container init with non-type",
         \\const zero: i32 = 0;
         \\const a = zero{1};
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(a)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:11: error: expected type 'type', found 'i32'",
-    );
+    });
 
-    cases.add(
-        "assign to constant field",
+    cases.add("assign to constant field",
         \\const Foo = struct {
         \\    field: i32,
         \\};
@@ -5070,12 +4696,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const f = Foo {.field = 1234,};
         \\    f.field = 0;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:15: error: cannot assign to constant",
-    );
+    });
 
-    cases.add(
-        "return from defer expression",
+    cases.add("return from defer expression",
         \\pub fn testTrickyDefer() !void {
         \\    defer canFail() catch {};
         \\
@@ -5091,72 +4716,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(testTrickyDefer)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:11: error: cannot return from defer expression",
-    );
-
-    cases.add(
-        "attempt to access var args out of bounds",
-        \\fn add(args: ...) i32 {
-        \\    return args[0] + args[1];
-        \\}
-        \\
-        \\fn foo() i32 {
-        \\    return add(@as(i32, 1234));
-        \\}
-        \\
-        \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
-        "tmp.zig:2:26: error: index 1 outside argument list of size 1",
-        "tmp.zig:6:15: note: called from here",
-    );
-
-    cases.add(
-        "pass integer literal to var args",
-        \\fn add(args: ...) i32 {
-        \\    var sum = @as(i32, 0);
-        \\    {comptime var i: usize = 0; inline while (i < args.len) : (i += 1) {
-        \\        sum += args[i];
-        \\    }}
-        \\    return sum;
-        \\}
-        \\
-        \\fn bar() i32 {
-        \\    return add(1, 2, 3, 4);
-        \\}
-        \\
-        \\export fn entry() usize { return @sizeOf(@typeOf(bar)); }
-    ,
-        "tmp.zig:10:16: error: compiler bug: integer and float literals in var args function must be casted",
-    );
+    });
 
-    cases.add(
-        "assign too big number to u16",
+    cases.add("assign too big number to u16",
         \\export fn foo() void {
         \\    var vga_mem: u16 = 0xB8000;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:24: error: integer value 753664 cannot be coerced to type 'u16'",
-    );
+    });
 
-    cases.add(
-        "global variable alignment non power of 2",
+    cases.add("global variable alignment non power of 2",
         \\const some_data: [100]u8 align(3) = undefined;
         \\export fn entry() usize { return @sizeOf(@typeOf(some_data)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:32: error: alignment value 3 is not a power of 2",
-    );
+    });
 
-    cases.add(
-        "function alignment non power of 2",
+    cases.add("function alignment non power of 2",
         \\extern fn foo() align(3) void;
         \\export fn entry() void { return foo(); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:23: error: alignment value 3 is not a power of 2",
-    );
+    });
 
-    cases.add(
-        "compile log",
+    cases.add("compile log",
         \\export fn foo() void {
         \\    comptime bar(12, "hi",);
         \\}
@@ -5165,14 +4751,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    @compileLog("a", a, "b", b);
         \\    @compileLog("end",);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: found compile log statement",
         "tmp.zig:6:5: error: found compile log statement",
         "tmp.zig:7:5: error: found compile log statement",
-    );
+    });
 
-    cases.add(
-        "casting bit offset pointer to regular pointer",
+    cases.add("casting bit offset pointer to regular pointer",
         \\const BitField = packed struct {
         \\    a: u3,
         \\    b: u3,
@@ -5188,12 +4773,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:26: error: expected type '*const u3', found '*align(:3:1) const u3'",
-    );
+    });
 
-    cases.add(
-        "referring to a struct that is invalid",
+    cases.add("referring to a struct that is invalid",
         \\const UsbDeviceRequest = struct {
         \\    Type: u8,
         \\};
@@ -5205,13 +4789,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn assert(ok: bool) void {
         \\    if (!ok) unreachable;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:10:14: error: unable to evaluate constant expression",
         "tmp.zig:6:20: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "control flow uses comptime var at runtime",
+    cases.add("control flow uses comptime var at runtime",
         \\export fn foo() void {
         \\    comptime var i = 0;
         \\    while (i < 5) : (i += 1) {
@@ -5220,79 +4803,71 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\fn bar() void { }
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: control flow attempts to use compile-time variable at runtime",
         "tmp.zig:3:24: note: compile-time variable assigned here",
-    );
+    });
 
-    cases.add(
-        "ignored return value",
+    cases.add("ignored return value",
         \\export fn foo() void {
         \\    bar();
         \\}
         \\fn bar() i32 { return 0; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:8: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "ignored assert-err-ok return value",
+    cases.add("ignored assert-err-ok return value",
         \\export fn foo() void {
         \\    bar() catch unreachable;
         \\}
         \\fn bar() anyerror!i32 { return 0; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:11: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "ignored statement value",
+    cases.add("ignored statement value",
         \\export fn foo() void {
         \\    1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "ignored comptime statement value",
+    cases.add("ignored comptime statement value",
         \\export fn foo() void {
         \\    comptime {1;}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "ignored comptime value",
+    cases.add("ignored comptime value",
         \\export fn foo() void {
         \\    comptime 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "ignored defered statement value",
+    cases.add("ignored defered statement value",
         \\export fn foo() void {
         \\    defer {1;}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:12: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "ignored defered function call",
+    cases.add("ignored defered function call",
         \\export fn foo() void {
         \\    defer bar();
         \\}
         \\fn bar() anyerror!i32 { return 0; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "dereference an array",
+    cases.add("dereference an array",
         \\var s_buffer: [10]u8 = undefined;
         \\pub fn pass(in: []u8) []u8 {
         \\    var out = &s_buffer;
@@ -5301,12 +4876,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(pass)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:10: error: attempt to dereference non-pointer type '[10]u8'",
-    );
+    });
 
-    cases.add(
-        "pass const ptr to mutable ptr fn",
+    cases.add("pass const ptr to mutable ptr fn",
         \\fn foo() bool {
         \\    const a = @as([]const u8, "a",);
         \\    const b = &a;
@@ -5317,22 +4891,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:19: error: expected type '*[]const u8', found '*const []const u8'",
-    );
+    });
 
     cases.addCase(x: {
-        const tc = cases.create(
-            "export collision",
+        const tc = cases.create("export collision",
             \\const foo = @import("foo.zig",);
             \\
             \\export fn bar() usize {
             \\    return foo.baz;
             \\}
-        ,
+        , &[_][]const u8{
             "foo.zig:1:1: error: exported symbol collision: 'bar'",
             "tmp.zig:3:1: note: other symbol here",
-        );
+        });
 
         tc.addSourceFile("foo.zig",
             \\export fn bar() void {}
@@ -5342,28 +4915,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         break :x tc;
     });
 
-    cases.add(
-        "implicit cast from array to mutable slice",
+    cases.add("implicit cast from array to mutable slice",
         \\var global_array: [10]i32 = undefined;
         \\fn foo(param: []i32) void {}
         \\export fn entry() void {
         \\    foo(global_array);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:9: error: expected type '[]i32', found '[10]i32'",
-    );
+    });
 
-    cases.add(
-        "ptrcast to non-pointer",
+    cases.add("ptrcast to non-pointer",
         \\export fn entry(a: *i32) usize {
         \\    return @ptrCast(usize, a);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: expected pointer, found 'usize'",
-    );
+    });
 
-    cases.add(
-        "asm at compile time",
+    cases.add("asm at compile time",
         \\comptime {
         \\    doSomeAsm();
         \\}
@@ -5375,66 +4945,60 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        \\.set aoeu, derp;
         \\    );
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:5: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "invalid member of builtin enum",
+    cases.add("invalid member of builtin enum",
         \\const builtin = @import("builtin",);
         \\export fn entry() void {
         \\    const foo = builtin.Arch.x86;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:29: error: container 'std.target.Arch' has no member called 'x86'",
-    );
+    });
 
-    cases.add(
-        "int to ptr of 0 bits",
+    cases.add("int to ptr of 0 bits",
         \\export fn foo() void {
         \\    var x: usize = 0x1000;
         \\    var y: *void = @intToPtr(*void, x);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information",
-    );
+    });
 
-    cases.add(
-        "@fieldParentPtr - non struct",
+    cases.add("@fieldParentPtr - non struct",
         \\const Foo = i32;
         \\export fn foo(a: *i32) *Foo {
         \\    return @fieldParentPtr(Foo, "a", a);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:28: error: expected struct type, found 'i32'",
-    );
+    });
 
-    cases.add(
-        "@fieldParentPtr - bad field name",
+    cases.add("@fieldParentPtr - bad field name",
         \\const Foo = extern struct {
         \\    derp: i32,
         \\};
         \\export fn foo(a: *i32) *Foo {
         \\    return @fieldParentPtr(Foo, "a", a);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:33: error: struct 'Foo' has no field 'a'",
-    );
+    });
 
-    cases.add(
-        "@fieldParentPtr - field pointer is not pointer",
+    cases.add("@fieldParentPtr - field pointer is not pointer",
         \\const Foo = extern struct {
         \\    a: i32,
         \\};
         \\export fn foo(a: i32) *Foo {
         \\    return @fieldParentPtr(Foo, "a", a);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:38: error: expected pointer, found 'i32'",
-    );
+    });
 
-    cases.add(
-        "@fieldParentPtr - comptime field ptr not based on struct",
+    cases.add("@fieldParentPtr - comptime field ptr not based on struct",
         \\const Foo = struct {
         \\    a: i32,
         \\    b: i32,
@@ -5445,12 +5009,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const field_ptr = @intToPtr(*i32, 0x1234);
         \\    const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:55: error: pointer value not based on parent struct",
-    );
+    });
 
-    cases.add(
-        "@fieldParentPtr - comptime wrong field index",
+    cases.add("@fieldParentPtr - comptime wrong field index",
         \\const Foo = struct {
         \\    a: i32,
         \\    b: i32,
@@ -5460,80 +5023,72 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:29: error: field 'b' has index 1 but pointer value is index 0 of struct 'Foo'",
-    );
+    });
 
-    cases.add(
-        "@byteOffsetOf - non struct",
+    cases.add("@byteOffsetOf - non struct",
         \\const Foo = i32;
         \\export fn foo() usize {
         \\    return @byteOffsetOf(Foo, "a",);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:26: error: expected struct type, found 'i32'",
-    );
+    });
 
-    cases.add(
-        "@byteOffsetOf - bad field name",
+    cases.add("@byteOffsetOf - bad field name",
         \\const Foo = struct {
         \\    derp: i32,
         \\};
         \\export fn foo() usize {
         \\    return @byteOffsetOf(Foo, "a",);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:31: error: struct 'Foo' has no field 'a'",
-    );
+    });
 
-    cases.addExe(
-        "missing main fn in executable",
+    cases.addExe("missing main fn in executable",
         \\
-    ,
+    , &[_][]const u8{
         "error: root source file has no member called 'main'",
-    );
+    });
 
-    cases.addExe(
-        "private main fn",
+    cases.addExe("private main fn",
         \\fn main() void {}
-    ,
+    , &[_][]const u8{
         "error: 'main' is private",
         "tmp.zig:1:1: note: declared here",
-    );
+    });
 
-    cases.add(
-        "setting a section on a local variable",
+    cases.add("setting a section on a local variable",
         \\export fn entry() i32 {
         \\    var foo: i32 linksection(".text2") = 1234;
         \\    return foo;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:30: error: cannot set section of local variable 'foo'",
-    );
+    });
 
-    cases.add(
-        "returning address of local variable - simple",
+    cases.add("returning address of local variable - simple",
         \\export fn foo() *i32 {
         \\    var a: i32 = undefined;
         \\    return &a;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:13: error: function returns address of local variable",
-    );
+    });
 
-    cases.add(
-        "returning address of local variable - phi",
+    cases.add("returning address of local variable - phi",
         \\export fn foo(c: bool) *i32 {
         \\    var a: i32 = undefined;
         \\    var b: i32 = undefined;
         \\    return if (c) &a else &b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:12: error: function returns address of local variable",
-    );
+    });
 
-    cases.add(
-        "inner struct member shadowing outer struct member",
+    cases.add("inner struct member shadowing outer struct member",
         \\fn A() type {
         \\    return struct {
         \\        b: B(),
@@ -5553,73 +5108,66 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn assert(ok: bool) void {
         \\    if (!ok) unreachable;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:17: error: redefinition of 'Self'",
         "tmp.zig:5:9: note: previous definition is here",
-    );
+    });
 
-    cases.add(
-        "while expected bool, got optional",
+    cases.add("while expected bool, got optional",
         \\export fn foo() void {
         \\    while (bar()) {}
         \\}
         \\fn bar() ?i32 { return 1; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected type 'bool', found '?i32'",
-    );
+    });
 
-    cases.add(
-        "while expected bool, got error union",
+    cases.add("while expected bool, got error union",
         \\export fn foo() void {
         \\    while (bar()) {}
         \\}
         \\fn bar() anyerror!i32 { return 1; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected type 'bool', found 'anyerror!i32'",
-    );
+    });
 
-    cases.add(
-        "while expected optional, got bool",
+    cases.add("while expected optional, got bool",
         \\export fn foo() void {
         \\    while (bar()) |x| {}
         \\}
         \\fn bar() bool { return true; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected optional type, found 'bool'",
-    );
+    });
 
-    cases.add(
-        "while expected optional, got error union",
+    cases.add("while expected optional, got error union",
         \\export fn foo() void {
         \\    while (bar()) |x| {}
         \\}
         \\fn bar() anyerror!i32 { return 1; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected optional type, found 'anyerror!i32'",
-    );
+    });
 
-    cases.add(
-        "while expected error union, got bool",
+    cases.add("while expected error union, got bool",
         \\export fn foo() void {
         \\    while (bar()) |x| {} else |err| {}
         \\}
         \\fn bar() bool { return true; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected error union type, found 'bool'",
-    );
+    });
 
-    cases.add(
-        "while expected error union, got optional",
+    cases.add("while expected error union, got optional",
         \\export fn foo() void {
         \\    while (bar()) |x| {} else |err| {}
         \\}
         \\fn bar() ?i32 { return 1; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: expected error union type, found '?i32'",
-    );
+    });
 
-    cases.add(
-        "inline fn calls itself indirectly",
+    cases.add("inline fn calls itself indirectly",
         \\export fn foo() void {
         \\    bar();
         \\}
@@ -5632,94 +5180,85 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    quux();
         \\}
         \\extern fn quux() void;
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:1: error: unable to inline function",
-    );
+    });
 
-    cases.add(
-        "save reference to inline function",
+    cases.add("save reference to inline function",
         \\export fn foo() void {
         \\    quux(@ptrToInt(bar));
         \\}
         \\inline fn bar() void { }
         \\extern fn quux(usize) void;
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:1: error: unable to inline function",
-    );
+    });
 
-    cases.add(
-        "signed integer division",
+    cases.add("signed integer division",
         \\export fn foo(a: i32, b: i32) i32 {
         \\    return a / b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact",
-    );
+    });
 
-    cases.add(
-        "signed integer remainder division",
+    cases.add("signed integer remainder division",
         \\export fn foo(a: i32, b: i32) i32 {
         \\    return a % b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod",
-    );
+    });
 
-    cases.add(
-        "compile-time division by zero",
+    cases.add("compile-time division by zero",
         \\comptime {
         \\    const a: i32 = 1;
         \\    const b: i32 = 0;
         \\    const c = a / b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:17: error: division by zero",
-    );
+    });
 
-    cases.add(
-        "compile-time remainder division by zero",
+    cases.add("compile-time remainder division by zero",
         \\comptime {
         \\    const a: i32 = 1;
         \\    const b: i32 = 0;
         \\    const c = a % b;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:17: error: division by zero",
-    );
+    });
 
-    cases.add(
-        "@setRuntimeSafety twice for same scope",
+    cases.add("@setRuntimeSafety twice for same scope",
         \\export fn foo() void {
         \\    @setRuntimeSafety(false);
         \\    @setRuntimeSafety(false);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: runtime safety set twice for same scope",
         "tmp.zig:2:5: note: first set here",
-    );
+    });
 
-    cases.add(
-        "@setFloatMode twice for same scope",
+    cases.add("@setFloatMode twice for same scope",
         \\export fn foo() void {
         \\    @setFloatMode(@import("builtin").FloatMode.Optimized);
         \\    @setFloatMode(@import("builtin").FloatMode.Optimized);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: float mode set twice for same scope",
         "tmp.zig:2:5: note: first set here",
-    );
+    });
 
-    cases.add(
-        "array access of type",
+    cases.add("array access of type",
         \\export fn foo() void {
         \\    var b: u8[40] = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: array access of non-array type 'type'",
-    );
+    });
 
-    cases.add(
-        "cannot break out of defer expression",
+    cases.add("cannot break out of defer expression",
         \\export fn foo() void {
         \\    while (true) {
         \\        defer {
@@ -5727,12 +5266,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        }
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:13: error: cannot break out of defer expression",
-    );
+    });
 
-    cases.add(
-        "cannot continue out of defer expression",
+    cases.add("cannot continue out of defer expression",
         \\export fn foo() void {
         \\    while (true) {
         \\        defer {
@@ -5740,26 +5278,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        }
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:13: error: cannot continue out of defer expression",
-    );
-
-    cases.add(
-        "calling a var args function only known at runtime",
-        \\var foos = [_]fn(...) void { foo1, foo2 };
-        \\
-        \\fn foo1(args: ...) void {}
-        \\fn foo2(args: ...) void {}
-        \\
-        \\pub fn main() !void {
-        \\    foos[0]();
-        \\}
-    ,
-        "tmp.zig:7:9: error: calling a generic function requires compile-time known function value",
-    );
+    });
 
-    cases.add(
-        "calling a generic function only known at runtime",
+    cases.add("calling a generic function only known at runtime",
         \\var foos = [_]fn(var) void { foo1, foo2 };
         \\
         \\fn foo1(arg: var) void {}
@@ -5768,12 +5291,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\pub fn main() !void {
         \\    foos[0](true);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:9: error: calling a generic function requires compile-time known function value",
-    );
+    });
 
-    cases.add(
-        "@compileError shows traceback of references that caused it",
+    cases.add("@compileError shows traceback of references that caused it",
         \\const foo = @compileError("aoeu",);
         \\
         \\const bar = baz + foo;
@@ -5782,96 +5304,86 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() i32 {
         \\    return bar;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:13: error: aoeu",
         "tmp.zig:3:19: note: referenced here",
         "tmp.zig:7:12: note: referenced here",
-    );
+    });
 
-    cases.add(
-        "float literal too large error",
+    cases.add("float literal too large error",
         \\comptime {
         \\    const a = 0x1.0p18495;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: float literal out of range of any type",
-    );
+    });
 
-    cases.add(
-        "float literal too small error (denormal)",
+    cases.add("float literal too small error (denormal)",
         \\comptime {
         \\    const a = 0x1.0p-19000;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: float literal out of range of any type",
-    );
+    });
 
-    cases.add(
-        "explicit cast float literal to integer when there is a fraction component",
+    cases.add("explicit cast float literal to integer when there is a fraction component",
         \\export fn entry() i32 {
         \\    return @as(i32, 12.34);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: fractional component prevents float value 12.340000 from being casted to type 'i32'",
-    );
+    });
 
-    cases.add(
-        "non pointer given to @ptrToInt",
+    cases.add("non pointer given to @ptrToInt",
         \\export fn entry(x: i32) usize {
         \\    return @ptrToInt(x);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:22: error: expected pointer, found 'i32'",
-    );
+    });
 
-    cases.add(
-        "@shlExact shifts out 1 bits",
+    cases.add("@shlExact shifts out 1 bits",
         \\comptime {
         \\    const x = @shlExact(@as(u8, 0b01010101), 2);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: operation caused overflow",
-    );
+    });
 
-    cases.add(
-        "@shrExact shifts out 1 bits",
+    cases.add("@shrExact shifts out 1 bits",
         \\comptime {
         \\    const x = @shrExact(@as(u8, 0b10101010), 2);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:15: error: exact shift shifted out 1 bits",
-    );
+    });
 
-    cases.add(
-        "shifting without int type or comptime known",
+    cases.add("shifting without int type or comptime known",
         \\export fn entry(x: u8) u8 {
         \\    return 0x11 << x;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:17: error: LHS of shift must be an integer type, or RHS must be compile-time known",
-    );
+    });
 
-    cases.add(
-        "shifting RHS is log2 of LHS int bit width",
+    cases.add("shifting RHS is log2 of LHS int bit width",
         \\export fn entry(x: u8, y: u8) u8 {
         \\    return x << y;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:17: error: expected type 'u3', found 'u8'",
-    );
+    });
 
-    cases.add(
-        "globally shadowing a primitive type",
+    cases.add("globally shadowing a primitive type",
         \\const u16 = @intType(false, 8);
         \\export fn entry() void {
         \\    const a: u16 = 300;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:1: error: declaration shadows primitive type 'u16'",
-    );
+    });
 
-    cases.add(
-        "implicitly increasing pointer alignment",
+    cases.add("implicitly increasing pointer alignment",
         \\const Foo = packed struct {
         \\    a: u8,
         \\    b: u32,
@@ -5885,12 +5397,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bar(x: *u32) void {
         \\    x.* += 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:13: error: expected type '*u32', found '*align(1) u32'",
-    );
+    });
 
-    cases.add(
-        "implicitly increasing slice alignment",
+    cases.add("implicitly increasing slice alignment",
         \\const Foo = packed struct {
         \\    a: u8,
         \\    b: u32,
@@ -5905,36 +5416,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bar(x: []u32) void {
         \\    x[0] += 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:26: error: cast increases pointer alignment",
         "tmp.zig:9:26: note: '*align(1) u32' has alignment 1",
         "tmp.zig:9:26: note: '*[1]u32' has alignment 4",
-    );
+    });
 
-    cases.add(
-        "increase pointer alignment in @ptrCast",
+    cases.add("increase pointer alignment in @ptrCast",
         \\export fn entry() u32 {
         \\    var bytes: [4]u8 = [_]u8{0x01, 0x02, 0x03, 0x04};
         \\    const ptr = @ptrCast(*u32, &bytes[0]);
         \\    return ptr.*;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:17: error: cast increases pointer alignment",
         "tmp.zig:3:38: note: '*u8' has alignment 1",
         "tmp.zig:3:26: note: '*u32' has alignment 4",
-    );
+    });
 
-    cases.add(
-        "@alignCast expects pointer or slice",
+    cases.add("@alignCast expects pointer or slice",
         \\export fn entry() void {
         \\    @alignCast(4, @as(u32, 3));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:19: error: expected pointer or slice, found 'u32'",
-    );
+    });
 
-    cases.add(
-        "passing an under-aligned function pointer",
+    cases.add("passing an under-aligned function pointer",
         \\export fn entry() void {
         \\    testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
         \\}
@@ -5942,45 +5450,41 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    if (ptr() != answer) unreachable;
         \\}
         \\fn alignedSmall() align(4) i32 { return 1234; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:35: error: expected type 'fn() align(8) i32', found 'fn() align(4) i32'",
-    );
+    });
 
-    cases.add(
-        "passing a not-aligned-enough pointer to cmpxchg",
+    cases.add("passing a not-aligned-enough pointer to cmpxchg",
         \\const AtomicOrder = @import("builtin").AtomicOrder;
         \\export fn entry() bool {
         \\    var x: i32 align(1) = 1234;
         \\    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
         \\    return x == 5678;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:32: error: expected type '*i32', found '*align(1) i32'",
-    );
+    });
 
-    cases.add(
-        "wrong size to an array literal",
+    cases.add("wrong size to an array literal",
         \\comptime {
         \\    const array = [2]u8{1, 2, 3};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:31: error: index 2 outside array of size 2",
-    );
+    });
 
-    cases.add(
-        "wrong pointer coerced to pointer to @OpaqueType()",
+    cases.add("wrong pointer coerced to pointer to @OpaqueType()",
         \\const Derp = @OpaqueType();
         \\extern fn bar(d: *Derp) void;
         \\export fn foo() void {
         \\    var x = @as(u8, 1);
         \\    bar(@ptrCast(*c_void, &x));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:9: error: expected type '*Derp', found '*c_void'",
-    );
+    });
 
-    cases.add(
-        "non-const variables of things that require const variables",
+    cases.add("non-const variables of things that require const variables",
         \\export fn entry1() void {
         \\   var m2 = &2;
         \\}
@@ -6012,7 +5516,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\const Foo = struct {
         \\    fn bar(self: *const Foo) void {}
         \\};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:4: error: variable of type '*comptime_int' must be const or comptime",
         "tmp.zig:5:4: error: variable of type '(undefined)' must be const or comptime",
         "tmp.zig:8:4: error: variable of type 'comptime_int' must be const or comptime",
@@ -6022,30 +5526,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:20:4: error: variable of type 'type' must be const or comptime",
         "tmp.zig:23:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime",
         "tmp.zig:26:22: error: unreachable code",
-    );
+    });
 
-    cases.add(
-        "wrong types given to atomic order args in cmpxchg",
+    cases.add("wrong types given to atomic order args in cmpxchg",
         \\export fn entry() void {
         \\    var x: i32 = 1234;
         \\    while (!@cmpxchgWeak(i32, &x, 1234, 5678, @as(u32, 1234), @as(u32, 1234))) {}
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:47: error: expected type 'std.builtin.AtomicOrder', found 'u32'",
-    );
+    });
 
-    cases.add(
-        "wrong types given to @export",
+    cases.add("wrong types given to @export",
         \\extern fn entry() void { }
         \\comptime {
         \\    @export("entry", entry, @as(u32, 1234));
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:29: error: expected type 'std.builtin.GlobalLinkage', found 'u32'",
-    );
+    });
 
-    cases.add(
-        "struct with invalid field",
+    cases.add("struct with invalid field",
         \\const std = @import("std",);
         \\const Allocator = std.mem.Allocator;
         \\const ArrayList = std.ArrayList;
@@ -6069,62 +5570,56 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .weight = HeaderWeight.H1,
         \\    };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:14:17: error: use of undeclared identifier 'HeaderValue'",
-    );
+    });
 
-    cases.add(
-        "@setAlignStack outside function",
+    cases.add("@setAlignStack outside function",
         \\comptime {
         \\    @setAlignStack(16);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: @setAlignStack outside function",
-    );
+    });
 
-    cases.add(
-        "@setAlignStack in naked function",
+    cases.add("@setAlignStack in naked function",
         \\export nakedcc fn entry() void {
         \\    @setAlignStack(16);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: @setAlignStack in naked function",
-    );
+    });
 
-    cases.add(
-        "@setAlignStack in inline function",
+    cases.add("@setAlignStack in inline function",
         \\export fn entry() void {
         \\    foo();
         \\}
         \\inline fn foo() void {
         \\    @setAlignStack(16);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:5: error: @setAlignStack in inline function",
-    );
+    });
 
-    cases.add(
-        "@setAlignStack set twice",
+    cases.add("@setAlignStack set twice",
         \\export fn entry() void {
         \\    @setAlignStack(16);
         \\    @setAlignStack(16);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: alignstack set twice",
         "tmp.zig:2:5: note: first set here",
-    );
+    });
 
-    cases.add(
-        "@setAlignStack too big",
+    cases.add("@setAlignStack too big",
         \\export fn entry() void {
         \\    @setAlignStack(511 + 1);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: attempt to @setAlignStack(512); maximum is 256",
-    );
+    });
 
-    cases.add(
-        "storing runtime value in compile time variable then using it",
+    cases.add("storing runtime value in compile time variable then using it",
         \\const Mode = @import("builtin").Mode;
         \\
         \\fn Free(comptime filename: []const u8) TestCase {
@@ -6166,12 +5661,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        }
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:37:29: error: cannot store runtime value in compile time variable",
-    );
+    });
 
-    cases.add(
-        "field access of opaque type",
+    cases.add("field access of opaque type",
         \\const MyType = @OpaqueType();
         \\
         \\export fn entry() bool {
@@ -6182,163 +5676,143 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn bar(x: *MyType) bool {
         \\    return x.blah;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:13: error: type '*MyType' does not support field access",
-    );
+    });
 
-    cases.add(
-        "carriage return special case",
-        "fn test() bool {\r\n" ++
-            "   true\r\n" ++
-            "}\r\n",
+    cases.add("carriage return special case", "fn test() bool {\r\n" ++
+        "   true\r\n" ++
+        "}\r\n", &[_][]const u8{
         "tmp.zig:1:17: error: invalid carriage return, only '\\n' line endings are supported",
-    );
+    });
 
-    cases.add(
-        "invalid legacy unicode escape",
+    cases.add("invalid legacy unicode escape",
         \\export fn entry() void {
         \\    const a = '\U1234';
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:17: error: invalid character: 'U'",
-    );
+    });
 
-    cases.add(
-        "invalid empty unicode escape",
+    cases.add("invalid empty unicode escape",
         \\export fn entry() void {
         \\    const a = '\u{}';
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:19: error: empty unicode escape sequence",
-    );
+    });
 
-    cases.add(
-        "non-printable invalid character",
-        "\xff\xfe" ++
-            \\fn test() bool {\r
-            \\    true\r
-            \\}
-        ,
+    cases.add("non-printable invalid character", "\xff\xfe" ++
+        \\fn test() bool {\r
+        \\    true\r
+        \\}
+    , &[_][]const u8{
         "tmp.zig:1:1: error: invalid character: '\\xff'",
-    );
+    });
 
-    cases.add(
-        "non-printable invalid character with escape alternative",
-        "fn test() bool {\n" ++
-            "\ttrue\n" ++
-            "}\n",
+    cases.add("non-printable invalid character with escape alternative", "fn test() bool {\n" ++
+        "\ttrue\n" ++
+        "}\n", &[_][]const u8{
         "tmp.zig:2:1: error: invalid character: '\\t'",
-    );
+    });
 
-    cases.add(
-        "@ArgType given non function parameter",
+    cases.add("@ArgType given non function parameter",
         \\comptime {
         \\    _ = @ArgType(i32, 3);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:18: error: expected function, found 'i32'",
-    );
+    });
 
-    cases.add(
-        "@ArgType arg index out of bounds",
+    cases.add("@ArgType arg index out of bounds",
         \\comptime {
         \\    _ = @ArgType(@typeOf(add), 2);
         \\}
         \\fn add(a: i32, b: i32) i32 { return a + b; }
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:32: error: arg index 2 out of bounds; 'fn(i32, i32) i32' has 2 arguments",
-    );
+    });
 
-    cases.add(
-        "@memberType on unsupported type",
+    cases.add("@memberType on unsupported type",
         \\comptime {
         \\    _ = @memberType(i32, 0);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: type 'i32' does not support @memberType",
-    );
+    });
 
-    cases.add(
-        "@memberType on enum",
+    cases.add("@memberType on enum",
         \\comptime {
         \\    _ = @memberType(Foo, 0);
         \\}
         \\const Foo = enum {A,};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: type 'Foo' does not support @memberType",
-    );
+    });
 
-    cases.add(
-        "@memberType struct out of bounds",
+    cases.add("@memberType struct out of bounds",
         \\comptime {
         \\    _ = @memberType(Foo, 0);
         \\}
         \\const Foo = struct {};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: member index 0 out of bounds; 'Foo' has 0 members",
-    );
+    });
 
-    cases.add(
-        "@memberType union out of bounds",
+    cases.add("@memberType union out of bounds",
         \\comptime {
         \\    _ = @memberType(Foo, 1);
         \\}
         \\const Foo = union {A: void,};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: member index 1 out of bounds; 'Foo' has 1 members",
-    );
+    });
 
-    cases.add(
-        "@memberName on unsupported type",
+    cases.add("@memberName on unsupported type",
         \\comptime {
         \\    _ = @memberName(i32, 0);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:21: error: type 'i32' does not support @memberName",
-    );
+    });
 
-    cases.add(
-        "@memberName struct out of bounds",
+    cases.add("@memberName struct out of bounds",
         \\comptime {
         \\    _ = @memberName(Foo, 0);
         \\}
         \\const Foo = struct {};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: member index 0 out of bounds; 'Foo' has 0 members",
-    );
+    });
 
-    cases.add(
-        "@memberName enum out of bounds",
+    cases.add("@memberName enum out of bounds",
         \\comptime {
         \\    _ = @memberName(Foo, 1);
         \\}
         \\const Foo = enum {A,};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: member index 1 out of bounds; 'Foo' has 1 members",
-    );
+    });
 
-    cases.add(
-        "@memberName union out of bounds",
+    cases.add("@memberName union out of bounds",
         \\comptime {
         \\    _ = @memberName(Foo, 1);
         \\}
         \\const Foo = union {A:i32,};
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: member index 1 out of bounds; 'Foo' has 1 members",
-    );
+    });
 
-    cases.add(
-        "calling var args extern function, passing array instead of pointer",
+    cases.add("calling var args extern function, passing array instead of pointer",
         \\export fn entry() void {
         \\    foo("hello".*,);
         \\}
         \\pub extern fn foo(format: *const u8, ...) void;
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:16: error: expected type '*const u8', found '[5:0]u8'",
-    );
+    });
 
-    cases.add(
-        "constant inside comptime function has compile error",
+    cases.add("constant inside comptime function has compile error",
         \\const ContextAllocator = MemoryPool(usize);
         \\
         \\pub fn MemoryPool(comptime T: type) type {
@@ -6352,11 +5826,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var allocator: ContextAllocator = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:25: error: aoeu",
         "tmp.zig:1:36: note: referenced here",
         "tmp.zig:12:20: note: referenced here",
-    );
+    });
 
     cases.add("specify enum tag type that is too small",
         \\const Small = enum (u2) {
@@ -6370,10 +5844,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var x = Small.One;
         \\}
-    , "tmp.zig:6:5: error: enumeration value 4 too large for type 'u2'");
+    , &[_][]const u8{
+        "tmp.zig:6:5: error: enumeration value 4 too large for type 'u2'",
+    });
 
-    cases.add(
-        "specify non-integer enum tag type",
+    cases.add("specify non-integer enum tag type",
         \\const Small = enum (f32) {
         \\    One,
         \\    Two,
@@ -6383,12 +5858,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var x = Small.One;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:21: error: expected integer, found 'f32'",
-    );
+    });
 
-    cases.add(
-        "implicitly casting enum to tag type",
+    cases.add("implicitly casting enum to tag type",
         \\const Small = enum(u2) {
         \\    One,
         \\    Two,
@@ -6399,12 +5873,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var x: u2 = Small.Two;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:9:22: error: expected type 'u2', found 'Small'",
-    );
+    });
 
-    cases.add(
-        "explicitly casting non tag type to enum",
+    cases.add("explicitly casting non tag type to enum",
         \\const Small = enum(u2) {
         \\    One,
         \\    Two,
@@ -6416,45 +5889,41 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var y = @as(u3, 3);
         \\    var x = @intToEnum(Small, y);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:10:31: error: expected type 'u2', found 'u3'",
-    );
+    });
 
-    cases.add(
-        "union fields with value assignments",
+    cases.add("union fields with value assignments",
         \\const MultipleChoice = union {
         \\    A: i32 = 20,
         \\};
         \\export fn entry() void {
         \\    var x: MultipleChoice = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:14: error: untagged union field assignment",
         "tmp.zig:1:24: note: consider 'union(enum)' here",
-    );
+    });
 
-    cases.add(
-        "enum with 0 fields",
+    cases.add("enum with 0 fields",
         \\const Foo = enum {};
         \\export fn entry() usize {
         \\    return @sizeOf(Foo);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:13: error: enums must have 1 or more fields",
-    );
+    });
 
-    cases.add(
-        "union with 0 fields",
+    cases.add("union with 0 fields",
         \\const Foo = union {};
         \\export fn entry() usize {
         \\    return @sizeOf(Foo);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:13: error: unions must have 1 or more fields",
-    );
+    });
 
-    cases.add(
-        "enum value already taken",
+    cases.add("enum value already taken",
         \\const MultipleChoice = enum(u32) {
         \\    A = 20,
         \\    B = 40,
@@ -6465,13 +5934,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var x = MultipleChoice.C;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:5: error: enum tag value 60 already taken",
         "tmp.zig:4:5: note: other occurrence here",
-    );
+    });
 
-    cases.add(
-        "union with specified enum omits field",
+    cases.add("union with specified enum omits field",
         \\const Letter = enum {
         \\    A,
         \\    B,
@@ -6484,50 +5952,46 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() usize {
         \\    return @sizeOf(Payload);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:17: error: enum field missing: 'C'",
         "tmp.zig:4:5: note: declared here",
-    );
+    });
 
-    cases.add(
-        "@TagType when union has no attached enum",
+    cases.add("@TagType when union has no attached enum",
         \\const Foo = union {
         \\    A: i32,
         \\};
         \\export fn entry() void {
         \\    const x = @TagType(Foo);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:24: error: union 'Foo' has no tag",
         "tmp.zig:1:13: note: consider 'union(enum)' here",
-    );
+    });
 
-    cases.add(
-        "non-integer tag type to automatic union enum",
+    cases.add("non-integer tag type to automatic union enum",
         \\const Foo = union(enum(f32)) {
         \\    A: i32,
         \\};
         \\export fn entry() void {
         \\    const x = @TagType(Foo);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:24: error: expected integer tag type, found 'f32'",
-    );
+    });
 
-    cases.add(
-        "non-enum tag type passed to union",
+    cases.add("non-enum tag type passed to union",
         \\const Foo = union(u32) {
         \\    A: i32,
         \\};
         \\export fn entry() void {
         \\    const x = @TagType(Foo);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:1:19: error: expected enum tag type, found 'u32'",
-    );
+    });
 
-    cases.add(
-        "union auto-enum value already taken",
+    cases.add("union auto-enum value already taken",
         \\const MultipleChoice = union(enum(u32)) {
         \\    A = 20,
         \\    B = 40,
@@ -6538,13 +6002,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var x = MultipleChoice { .C = {} };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:9: error: enum tag value 60 already taken",
         "tmp.zig:4:9: note: other occurrence here",
-    );
+    });
 
-    cases.add(
-        "union enum field does not match enum",
+    cases.add("union enum field does not match enum",
         \\const Letter = enum {
         \\    A,
         \\    B,
@@ -6559,13 +6022,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var a = Payload {.A = 1234};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:10:5: error: enum field not found: 'D'",
         "tmp.zig:1:16: note: enum declared here",
-    );
+    });
 
-    cases.add(
-        "field type supplied in an enum",
+    cases.add("field type supplied in an enum",
         \\const Letter = enum {
         \\    A: void,
         \\    B,
@@ -6574,37 +6036,34 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var b = Letter.B;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:8: error: structs and unions, not enums, support field types",
         "tmp.zig:1:16: note: consider 'union(enum)' here",
-    );
+    });
 
-    cases.add(
-        "struct field missing type",
+    cases.add("struct field missing type",
         \\const Letter = struct {
         \\    A,
         \\};
         \\export fn entry() void {
         \\    var a = Letter { .A = {} };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: struct field missing type",
-    );
+    });
 
-    cases.add(
-        "extern union field missing type",
+    cases.add("extern union field missing type",
         \\const Letter = extern union {
         \\    A,
         \\};
         \\export fn entry() void {
         \\    var a = Letter { .A = {} };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: union field missing type",
-    );
+    });
 
-    cases.add(
-        "extern union given enum tag type",
+    cases.add("extern union given enum tag type",
         \\const Letter = enum {
         \\    A,
         \\    B,
@@ -6618,12 +6077,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var a = Payload { .A = 1234 };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:30: error: extern union does not support enum tag type",
-    );
+    });
 
-    cases.add(
-        "packed union given enum tag type",
+    cases.add("packed union given enum tag type",
         \\const Letter = enum {
         \\    A,
         \\    B,
@@ -6637,12 +6095,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var a = Payload { .A = 1234 };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:30: error: packed union does not support enum tag type",
-    );
+    });
 
-    cases.add(
-        "packed union with automatic layout field",
+    cases.add("packed union with automatic layout field",
         \\const Foo = struct {
         \\    a: u32,
         \\    b: f32,
@@ -6654,12 +6111,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var a = Payload { .B = true };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:5: error: non-packed, non-extern struct 'Foo' not allowed in packed union; no guaranteed in-memory representation",
-    );
+    });
 
-    cases.add(
-        "switch on union with no attached enum",
+    cases.add("switch on union with no attached enum",
         \\const Payload = union {
         \\    A: i32,
         \\    B: f64,
@@ -6675,13 +6131,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        else => unreachable,
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:11:14: error: switch on union which has no attached enum",
         "tmp.zig:1:17: note: consider 'union(enum)' here",
-    );
+    });
 
-    cases.add(
-        "enum in field count range but not matching tag",
+    cases.add("enum in field count range but not matching tag",
         \\const Foo = enum(u32) {
         \\    A = 10,
         \\    B = 11,
@@ -6689,13 +6144,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var x = @intToEnum(Foo, 0);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:6:13: error: enum 'Foo' has no tag matching integer value 0",
         "tmp.zig:1:13: note: 'Foo' declared here",
-    );
+    });
 
-    cases.add(
-        "comptime cast enum to union but field has payload",
+    cases.add("comptime cast enum to union but field has payload",
         \\const Letter = enum { A, B, C };
         \\const Value = union(Letter) {
         \\    A: i32,
@@ -6705,13 +6159,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var x: Value = Letter.A;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:8:26: error: cast to union 'Value' must initialize 'i32' field 'A'",
         "tmp.zig:3:5: note: field 'A' declared here",
-    );
+    });
 
-    cases.add(
-        "runtime cast to union which has non-void fields",
+    cases.add("runtime cast to union which has non-void fields",
         \\const Letter = enum { A, B, C };
         \\const Value = union(Letter) {
         \\    A: i32,
@@ -6724,37 +6177,34 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\fn foo(l: Letter) void {
         \\    var x: Value = l;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:11:20: error: runtime cast to union 'Value' which has non-void fields",
         "tmp.zig:3:5: note: field 'A' has type 'i32'",
-    );
+    });
 
-    cases.add(
-        "taking byte offset of void field in struct",
+    cases.add("taking byte offset of void field in struct",
         \\const Empty = struct {
         \\    val: void,
         \\};
         \\export fn foo() void {
         \\    const fieldOffset = @byteOffsetOf(Empty, "val",);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:46: error: zero-bit field 'val' in struct 'Empty' has no offset",
-    );
+    });
 
-    cases.add(
-        "taking bit offset of void field in struct",
+    cases.add("taking bit offset of void field in struct",
         \\const Empty = struct {
         \\    val: void,
         \\};
         \\export fn foo() void {
         \\    const fieldOffset = @bitOffsetOf(Empty, "val",);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:45: error: zero-bit field 'val' in struct 'Empty' has no offset",
-    );
+    });
 
-    cases.add(
-        "invalid union field access in comptime",
+    cases.add("invalid union field access in comptime",
         \\const Foo = union {
         \\    Bar: u8,
         \\    Baz: void,
@@ -6763,60 +6213,54 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var foo = Foo {.Baz = {}};
         \\    const bar_val = foo.Bar;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set",
-    );
+    });
 
-    cases.add(
-        "getting return type of generic function",
+    cases.add("getting return type of generic function",
         \\fn generic(a: var) void {}
         \\comptime {
         \\    _ = @typeOf(generic).ReturnType;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(var)var' is generic",
-    );
+    });
 
-    cases.add(
-        "getting @ArgType of generic function",
+    cases.add("getting @ArgType of generic function",
         \\fn generic(a: var) void {}
         \\comptime {
         \\    _ = @ArgType(@typeOf(generic), 0);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic",
-    );
+    });
 
-    cases.add(
-        "unsupported modifier at start of asm output constraint",
+    cases.add("unsupported modifier at start of asm output constraint",
         \\export fn foo() void {
         \\    var bar: u32 = 3;
         \\    asm volatile ("" : [baz]"+r"(bar) : : "");
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:5: error: invalid modifier starting output constraint for 'baz': '+', only '=' is supported. Compiler TODO: see https://github.com/ziglang/zig/issues/215",
-    );
+    });
 
-    cases.add(
-        "comptime_int in asm input",
+    cases.add("comptime_int in asm input",
         \\export fn foo() void {
         \\    asm volatile ("" : : [bar]"r"(3) : "");
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:35: error: expected sized integer or sized float, found comptime_int",
-    );
+    });
 
-    cases.add(
-        "comptime_float in asm input",
+    cases.add("comptime_float in asm input",
         \\export fn foo() void {
         \\    asm volatile ("" : : [bar]"r"(3.17) : "");
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:35: error: expected sized integer or sized float, found comptime_float",
-    );
+    });
 
-    cases.add(
-        "runtime assignment to comptime struct type",
+    cases.add("runtime assignment to comptime struct type",
         \\const Foo = struct {
         \\    Bar: u8,
         \\    Baz: type,
@@ -6825,12 +6269,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x: u8 = 0;
         \\    const foo = Foo { .Bar = x, .Baz = u8 };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:23: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.add(
-        "runtime assignment to comptime union type",
+    cases.add("runtime assignment to comptime union type",
         \\const Foo = union {
         \\    Bar: u8,
         \\    Baz: type,
@@ -6839,42 +6282,39 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x: u8 = 0;
         \\    const foo = Foo { .Bar = x };
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:7:23: error: unable to evaluate constant expression",
-    );
+    });
 
-    cases.addTest(
-        "@shuffle with selected index past first vector length",
+    cases.addTest("@shuffle with selected index past first vector length",
         \\export fn entry() void {
         \\    const v: @Vector(4, u32) = [4]u32{ 10, 11, 12, 13 };
         \\    const x: @Vector(4, u32) = [4]u32{ 14, 15, 16, 17 };
         \\    var z = @shuffle(u32, v, x, [8]i32{ 0, 1, 2, 3, 7, 6, 5, 4 });
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:39: error: mask index '4' has out-of-bounds selection",
         "tmp.zig:4:27: note: selected index '7' out of bounds of @Vector(4, u32)",
         "tmp.zig:4:30: note: selections from the second vector are specified with negative numbers",
-    );
+    });
 
-    cases.addTest(
-        "nested vectors",
+    cases.addTest("nested vectors",
         \\export fn entry() void {
         \\    const V = @Vector(4, @Vector(4, u8));
         \\    var v: V = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:26: error: vector element type must be integer, float, bool, or pointer; '@Vector(4, u8)' is invalid",
-    );
+    });
 
-    cases.addTest(
-        "bad @splat type",
+    cases.addTest("bad @splat type",
         \\export fn entry() void {
         \\    const c = 4;
         \\    var v = @splat(4, c);
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:23: error: vector element type must be integer, float, bool, or pointer; 'comptime_int' is invalid",
-    );
+    });
 
     cases.add("compileLog of tagged enum doesn't crash the compiler",
         \\const Bar = union(enum(u32)) {
@@ -6888,33 +6328,32 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\pub fn main () void {
         \\    comptime testCompileLog(Bar{.X = 123});
         \\}
-    , "tmp.zig:6:5: error: found compile log statement");
+    , &[_][]const u8{
+        "tmp.zig:6:5: error: found compile log statement",
+    });
 
-    cases.add(
-        "attempted implicit cast from *const T to *[1]T",
+    cases.add("attempted implicit cast from *const T to *[1]T",
         \\export fn entry(byte: u8) void {
         \\    const w: i32 = 1234;
         \\    var x: *const i32 = &w;
         \\    var y: *[1]i32 = x;
         \\    y[0] += 1;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:4:22: error: expected type '*[1]i32', found '*const i32'",
         "tmp.zig:4:22: note: cast discards const qualifier",
-    );
+    });
 
-    cases.add(
-        "attempted implicit cast from *const T to []T",
+    cases.add("attempted implicit cast from *const T to []T",
         \\export fn entry() void {
         \\    const u: u32 = 42;
         \\    const x: []u32 = &u;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:3:23: error: expected type '[]u32', found '*const u32'",
-    );
+    });
 
-    cases.add(
-        "for loop body expression ignored",
+    cases.add("for loop body expression ignored",
         \\fn returns() usize {
         \\    return 2;
         \\}
@@ -6925,37 +6364,35 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x: anyerror!i32 = error.Bad;
         \\    for ("hello") |_| returns() else unreachable;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:5:30: error: expression value is ignored",
         "tmp.zig:9:30: error: expression value is ignored",
-    );
+    });
 
-    cases.add(
-        "aligned variable of zero-bit type",
+    cases.add("aligned variable of zero-bit type",
         \\export fn f() void {
         \\    var s: struct {} align(4) = undefined;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:5: error: variable 's' of zero-bit type 'struct:2:12' has no in-memory representation, it cannot be aligned",
-    );
+    });
 
-    cases.add(
-        "function returning opaque type",
+    cases.add("function returning opaque type",
         \\const FooType = @OpaqueType();
         \\export fn bar() !FooType {
         \\    return error.InvalidValue;
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:18: error: opaque return type 'FooType' not allowed",
         "tmp.zig:1:1: note: declared here",
-    );
+    });
 
     cases.add( // fixed bug #2032
         "compile diagnostic string for top level decl type",
         \\export fn entry() void {
         \\    var foo: u32 = @This(){};
         \\}
-    ,
+    , &[_][]const u8{
         "tmp.zig:2:27: error: type 'u32' does not support array initialization",
-    );
+    });
 }
diff --git a/test/gen_h.zig b/test/gen_h.zig
index 93ccb21a64..f519d8feb6 100644
--- a/test/gen_h.zig
+++ b/test/gen_h.zig
@@ -4,7 +4,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
     cases.add("declare enum",
         \\const Foo = extern enum { A, B, C };
         \\export fn entry(foo: Foo) void { }
-    ,
+    , &[_][]const u8{
         \\enum Foo {
         \\    A = 0,
         \\    B = 1,
@@ -12,7 +12,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
         \\};
     ,
         \\void entry(enum Foo foo);
-    );
+    });
 
     cases.add("declare struct",
         \\const Foo = extern struct {
@@ -24,7 +24,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
         \\    F: u64,
         \\};
         \\export fn entry(foo: Foo) void { }
-    ,
+    , &[_][]const u8{
         \\struct Foo {
         \\    int32_t A;
         \\    float B;
@@ -36,7 +36,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
     ,
         \\void entry(struct Foo foo);
         \\
-    );
+    });
 
     cases.add("declare union",
         \\const Big = extern struct {
@@ -53,7 +53,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
         \\    D: Big,
         \\};
         \\export fn entry(foo: Foo) void {}
-    ,
+    , &[_][]const u8{
         \\struct Big {
         \\    uint64_t A;
         \\    uint64_t B;
@@ -71,17 +71,17 @@ pub fn addCases(cases: *tests.GenHContext) void {
     ,
         \\void entry(union Foo foo);
         \\
-    );
+    });
 
     cases.add("declare opaque type",
         \\const Foo = @OpaqueType();
         \\
         \\export fn entry(foo: ?*Foo) void { }
-    ,
+    , &[_][]const u8{
         \\struct Foo;
     ,
         \\void entry(struct Foo * foo);
-    );
+    });
 
     cases.add("array field-type",
         \\const Foo = extern struct {
@@ -89,7 +89,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
         \\    B: [4]*u32,
         \\};
         \\export fn entry(foo: Foo, bar: [3]u8) void { }
-    ,
+    , &[_][]const u8{
         \\struct Foo {
         \\    int32_t A[2];
         \\    uint32_t * B[4];
@@ -97,7 +97,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
     ,
         \\void entry(struct Foo foo, uint8_t bar[]);
         \\
-    );
+    });
 
     cases.add("ptr to zig struct",
         \\const S = struct {
@@ -107,12 +107,12 @@ pub fn addCases(cases: *tests.GenHContext) void {
         \\export fn a(s: *S) u8 {
         \\    return s.a;
         \\}
-    ,
+    , &[_][]const u8{
         \\struct S;
     ,
         \\uint8_t a(struct S * s);
         \\
-    );
+    });
 
     cases.add("ptr to zig union",
         \\const U = union(enum) {
@@ -123,12 +123,12 @@ pub fn addCases(cases: *tests.GenHContext) void {
         \\export fn a(s: *U) u8 {
         \\    return s.A;
         \\}
-    ,
+    , &[_][]const u8{
         \\union U;
     ,
         \\uint8_t a(union U * s);
         \\
-    );
+    });
 
     cases.add("ptr to zig enum",
         \\const E = enum(u8) {
@@ -139,10 +139,10 @@ pub fn addCases(cases: *tests.GenHContext) void {
         \\export fn a(s: *E) u8 {
         \\    return @enumToInt(s.*);
         \\}
-    ,
+    , &[_][]const u8{
         \\enum E;
     ,
         \\uint8_t a(enum E * s);
         \\
-    );
+    });
 }
diff --git a/test/stage1/behavior/eval.zig b/test/stage1/behavior/eval.zig
index be7226d94c..44ad2f81fa 100644
--- a/test/stage1/behavior/eval.zig
+++ b/test/stage1/behavior/eval.zig
@@ -670,10 +670,10 @@ fn loopNTimes(comptime n: usize) void {
 }
 
 test "variable inside inline loop that has different types on different iterations" {
-    testVarInsideInlineLoop(true, @as(u32, 42));
+    testVarInsideInlineLoop(.{true, @as(u32, 42)});
 }
 
-fn testVarInsideInlineLoop(args: ...) void {
+fn testVarInsideInlineLoop(args: var) void {
     comptime var i = 0;
     inline while (i < args.len) : (i += 1) {
         const x = args[i];
diff --git a/test/stage1/behavior/reflection.zig b/test/stage1/behavior/reflection.zig
index 739e0b318a..12067ee51d 100644
--- a/test/stage1/behavior/reflection.zig
+++ b/test/stage1/behavior/reflection.zig
@@ -15,7 +15,6 @@ test "reflection: function return type, var args, and param types" {
     comptime {
         expect(@typeOf(dummy).ReturnType == i32);
         expect(!@typeOf(dummy).is_var_args);
-        expect(@typeOf(dummy_varargs).is_var_args);
         expect(@typeOf(dummy).arg_count == 3);
         expect(@ArgType(@typeOf(dummy), 0) == bool);
         expect(@ArgType(@typeOf(dummy), 1) == i32);
@@ -26,7 +25,6 @@ test "reflection: function return type, var args, and param types" {
 fn dummy(a: bool, b: i32, c: f32) i32 {
     return 1234;
 }
-fn dummy_varargs(args: ...) void {}
 
 test "reflection: struct member types and names" {
     comptime {
diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig
index 598bbca6be..a0fd4a4e6c 100644
--- a/test/stage1/behavior/type_info.zig
+++ b/test/stage1/behavior/type_info.zig
@@ -198,7 +198,7 @@ fn testUnion() void {
     expect(@as(TypeId, typeinfo_info) == TypeId.Union);
     expect(typeinfo_info.Union.layout == TypeInfo.ContainerLayout.Auto);
     expect(typeinfo_info.Union.tag_type.? == TypeId);
-    expect(typeinfo_info.Union.fields.len == 26);
+    expect(typeinfo_info.Union.fields.len == 25);
     expect(typeinfo_info.Union.fields[4].enum_field != null);
     expect(typeinfo_info.Union.fields[4].enum_field.?.value == 4);
     expect(typeinfo_info.Union.fields[4].field_type == @typeOf(@typeInfo(u8).Int));
diff --git a/test/stage1/behavior/var_args.zig b/test/stage1/behavior/var_args.zig
index 19df436481..0c8674a7fb 100644
--- a/test/stage1/behavior/var_args.zig
+++ b/test/stage1/behavior/var_args.zig
@@ -1,6 +1,6 @@
 const expect = @import("std").testing.expect;
 
-fn add(args: ...) i32 {
+fn add(args: var) i32 {
     var sum = @as(i32, 0);
     {
         comptime var i: usize = 0;
@@ -12,43 +12,42 @@ fn add(args: ...) i32 {
 }
 
 test "add arbitrary args" {
-    expect(add(@as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4)) == 10);
-    expect(add(@as(i32, 1234)) == 1234);
-    expect(add() == 0);
+    expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
+    expect(add(.{@as(i32, 1234)}) == 1234);
+    expect(add(.{}) == 0);
 }
 
-fn readFirstVarArg(args: ...) void {
+fn readFirstVarArg(args: var) void {
     const value = args[0];
 }
 
 test "send void arg to var args" {
-    readFirstVarArg({});
+    readFirstVarArg(.{{}});
 }
 
 test "pass args directly" {
-    expect(addSomeStuff(@as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4)) == 10);
-    expect(addSomeStuff(@as(i32, 1234)) == 1234);
-    expect(addSomeStuff() == 0);
+    expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
+    expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
+    expect(addSomeStuff(.{}) == 0);
 }
 
-fn addSomeStuff(args: ...) i32 {
+fn addSomeStuff(args: var) i32 {
     return add(args);
 }
 
 test "runtime parameter before var args" {
-    expect(extraFn(10) == 0);
-    expect(extraFn(10, false) == 1);
-    expect(extraFn(10, false, true) == 2);
+    expect(extraFn(10, .{}) == 0);
+    expect(extraFn(10, .{false}) == 1);
+    expect(extraFn(10, .{ false, true }) == 2);
 
-    // TODO issue #313
-    //comptime {
-    //    expect(extraFn(10) == 0);
-    //    expect(extraFn(10, false) == 1);
-    //    expect(extraFn(10, false, true) == 2);
-    //}
+    comptime {
+        expect(extraFn(10, .{}) == 0);
+        expect(extraFn(10, .{false}) == 1);
+        expect(extraFn(10, .{ false, true }) == 2);
+    }
 }
 
-fn extraFn(extra: u32, args: ...) usize {
+fn extraFn(extra: u32, args: var) usize {
     if (args.len >= 1) {
         expect(args[0] == false);
     }
@@ -58,27 +57,27 @@ fn extraFn(extra: u32, args: ...) usize {
     return args.len;
 }
 
-const foos = [_]fn (...) bool{
+const foos = [_]fn (var) bool{
     foo1,
     foo2,
 };
 
-fn foo1(args: ...) bool {
+fn foo1(args: var) bool {
     return true;
 }
-fn foo2(args: ...) bool {
+fn foo2(args: var) bool {
     return false;
 }
 
 test "array of var args functions" {
-    expect(foos[0]());
-    expect(!foos[1]());
+    expect(foos[0](.{}));
+    expect(!foos[1](.{}));
 }
 
 test "pass zero length array to var args param" {
-    doNothingWithFirstArg("");
+    doNothingWithFirstArg(.{""});
 }
 
-fn doNothingWithFirstArg(args: ...) void {
+fn doNothingWithFirstArg(args: var) void {
     const a = args[0];
 }
diff --git a/test/tests.zig b/test/tests.zig
index 7548be6c4b..7326b62054 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -1253,7 +1253,12 @@ pub const CompileErrorContext = struct {
         }
     };
 
-    pub fn create(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
+    pub fn create(
+        self: *CompileErrorContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) *TestCase {
         const tc = self.b.allocator.create(TestCase) catch unreachable;
         tc.* = TestCase{
             .name = name,
@@ -1266,31 +1271,46 @@ pub const CompileErrorContext = struct {
         };
 
         tc.addSourceFile("tmp.zig", source);
-        comptime var arg_i = 0;
-        inline while (arg_i < expected_lines.len) : (arg_i += 1) {
+        var arg_i: usize = 0;
+        while (arg_i < expected_lines.len) : (arg_i += 1) {
             tc.addExpectedError(expected_lines[arg_i]);
         }
         return tc;
     }
 
-    pub fn addC(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn addC(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: []const []const u8) void {
         var tc = self.create(name, source, expected_lines);
         tc.link_libc = true;
         self.addCase(tc);
     }
 
-    pub fn addExe(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn addExe(
+        self: *CompileErrorContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         var tc = self.create(name, source, expected_lines);
         tc.is_exe = true;
         self.addCase(tc);
     }
 
-    pub fn add(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn add(
+        self: *CompileErrorContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         const tc = self.create(name, source, expected_lines);
         self.addCase(tc);
     }
 
-    pub fn addTest(self: *CompileErrorContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn addTest(
+        self: *CompileErrorContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         const tc = self.create(name, source, expected_lines);
         tc.is_test = true;
         self.addCase(tc);
@@ -1549,7 +1569,14 @@ pub const TranslateCContext = struct {
         warn("\n", .{});
     }
 
-    pub fn create(self: *TranslateCContext, allow_warnings: bool, filename: []const u8, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
+    pub fn create(
+        self: *TranslateCContext,
+        allow_warnings: bool,
+        filename: []const u8,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) *TestCase {
         const tc = self.b.allocator.create(TestCase) catch unreachable;
         tc.* = TestCase{
             .name = name,
@@ -1560,24 +1587,39 @@ pub const TranslateCContext = struct {
         };
 
         tc.addSourceFile(filename, source);
-        comptime var arg_i = 0;
-        inline while (arg_i < expected_lines.len) : (arg_i += 1) {
+        var arg_i: usize = 0;
+        while (arg_i < expected_lines.len) : (arg_i += 1) {
             tc.addExpectedLine(expected_lines[arg_i]);
         }
         return tc;
     }
 
-    pub fn add(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn add(
+        self: *TranslateCContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         const tc = self.create(false, "source.h", name, source, expected_lines);
         self.addCase(tc);
     }
 
-    pub fn addC(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn addC(
+        self: *TranslateCContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         const tc = self.create(false, "source.c", name, source, expected_lines);
         self.addCase(tc);
     }
 
-    pub fn add_both(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn add_both(
+        self: *TranslateCContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         for ([_]bool{ false, true }) |stage2| {
             const tc = self.create(false, "source.h", name, source, expected_lines);
             tc.stage2 = stage2;
@@ -1585,7 +1627,12 @@ pub const TranslateCContext = struct {
         }
     }
 
-    pub fn addC_both(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn addC_both(
+        self: *TranslateCContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         for ([_]bool{ false, true }) |stage2| {
             const tc = self.create(false, "source.c", name, source, expected_lines);
             tc.stage2 = stage2;
@@ -1593,19 +1640,34 @@ pub const TranslateCContext = struct {
         }
     }
 
-    pub fn add_2(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn add_2(
+        self: *TranslateCContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         const tc = self.create(false, "source.h", name, source, expected_lines);
         tc.stage2 = true;
         self.addCase(tc);
     }
 
-    pub fn addC_2(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn addC_2(
+        self: *TranslateCContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         const tc = self.create(false, "source.c", name, source, expected_lines);
         tc.stage2 = true;
         self.addCase(tc);
     }
 
-    pub fn addAllowWarnings(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn addAllowWarnings(
+        self: *TranslateCContext,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) void {
         const tc = self.create(true, "source.h", name, source, expected_lines);
         self.addCase(tc);
     }
@@ -1723,7 +1785,13 @@ pub const GenHContext = struct {
         warn("\n", .{});
     }
 
-    pub fn create(self: *GenHContext, filename: []const u8, name: []const u8, source: []const u8, expected_lines: ...) *TestCase {
+    pub fn create(
+        self: *GenHContext,
+        filename: []const u8,
+        name: []const u8,
+        source: []const u8,
+        expected_lines: []const []const u8,
+    ) *TestCase {
         const tc = self.b.allocator.create(TestCase) catch unreachable;
         tc.* = TestCase{
             .name = name,
@@ -1732,14 +1800,14 @@ pub const GenHContext = struct {
         };
 
         tc.addSourceFile(filename, source);
-        comptime var arg_i = 0;
-        inline while (arg_i < expected_lines.len) : (arg_i += 1) {
+        var arg_i: usize = 0;
+        while (arg_i < expected_lines.len) : (arg_i += 1) {
             tc.addExpectedLine(expected_lines[arg_i]);
         }
         return tc;
     }
 
-    pub fn add(self: *GenHContext, name: []const u8, source: []const u8, expected_lines: ...) void {
+    pub fn add(self: *GenHContext, name: []const u8, source: []const u8, expected_lines: []const []const u8) void {
         const tc = self.create("test.zig", name, source, expected_lines);
         self.addCase(tc);
     }
diff --git a/test/translate_c.zig b/test/translate_c.zig
index f543fbc74e..a2ee07f219 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -13,10 +13,10 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     cases.add_both("simple function prototypes",
         \\void __attribute__((noreturn)) foo(void);
         \\int bar(void);
-    ,
+    , &[_][]const u8{
         \\pub extern fn foo() noreturn;
         \\pub extern fn bar() c_int;
-    );
+    });
 
     cases.add_both("simple var decls",
         \\void foo(void) {
@@ -25,14 +25,14 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    const int c;
         \\    const unsigned d = 440;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    var a: c_int = undefined;
         \\    var b: u8 = @as(u8, 123);
         \\    const c: c_int = undefined;
         \\    const d: c_uint = @as(c_uint, 440);
         \\}
-    );
+    });
 
     cases.add_both("ignore result, explicit function arguments",
         \\void foo(void) {
@@ -43,7 +43,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    1 - 1;
         \\    a = 1;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    var a: c_int = undefined;
         \\    _ = 1;
@@ -52,7 +52,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    _ = (1 - 1);
         \\    a = 1;
         \\}
-    );
+    });
 
     /////////////// Cases that pass for only stage2 ////////////////
     // TODO: restore these tests after removing "import mode" concept
@@ -83,12 +83,12 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\void b(void) {}
         \\void c();
         \\void d(void);
-    ,
+    , &[_][]const u8{
         \\pub fn a(...) void {}
         \\pub fn b() void {}
         \\pub extern fn c(...) void;
         \\pub extern fn d() void;
-    );
+    });
 
     /////////////// Cases for only stage1 which are TODO items for stage2 ////////////////
 
@@ -98,13 +98,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    void (*func)(void);
         \\    lws_callback_function *callback_http;
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const lws_callback_function = extern fn () void;
         \\pub const struct_Foo = extern struct {
         \\    func: ?extern fn () void,
         \\    callback_http: ?lws_callback_function,
         \\};
-    );
+    });
 
     cases.add("pointer to struct demoted to opaque due to bit fields",
         \\struct Foo {
@@ -113,26 +113,26 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\struct Bar {
         \\    struct Foo *foo;
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const struct_Foo = @OpaqueType();
         \\pub const struct_Bar = extern struct {
         \\    foo: ?*struct_Foo,
         \\};
-    );
+    });
 
     cases.add_both("simple function definition",
         \\void foo(void) {}
         \\static void bar(void) {}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {}
         \\pub fn bar() void {}
-    );
+    });
 
     cases.add("macro with left shift",
         \\#define REDISMODULE_READ (1<<0)
-    ,
+    , &[_][]const u8{
         \\pub const REDISMODULE_READ = 1 << 0;
-    );
+    });
 
     cases.add_both("casting pointers to ints and ints to pointers",
         \\void foo(void);
@@ -140,13 +140,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    void *func_ptr = foo;
         \\    void (*typed_func_ptr)(void) = (void (*)(void)) (unsigned long) func_ptr;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub extern fn foo() void;
         \\pub fn bar() void {
         \\    var func_ptr: ?*c_void = @ptrCast(?*c_void, foo);
         \\    var typed_func_ptr: ?extern fn () void = @intToPtr(?extern fn () void, @as(c_ulong, @ptrToInt(func_ptr)));
         \\}
-    );
+    });
 
     if (builtin.os != builtin.Os.windows) {
         // Windows treats this as an enum with type c_int
@@ -176,7 +176,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
             \\    VAL22 = 0xFFFFFFFFFFFFFFFF + 1,
             \\    VAL23 = 0xFFFFFFFFFFFFFFFF,
             \\};
-        ,
+        , &[_][]const u8{
             \\pub const enum_EnumWithInits = extern enum(c_longlong) {
             \\    VAL01 = 0,
             \\    VAL02 = 1,
@@ -202,7 +202,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
             \\    VAL22 = 0,
             \\    VAL23 = -1,
             \\};
-        );
+        });
     }
 
     cases.add("predefined expressions",
@@ -211,13 +211,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    __FUNCTION__;
         \\    __PRETTY_FUNCTION__;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    _ = "foo";
         \\    _ = "foo";
         \\    _ = "void foo(void)";
         \\}
-    );
+    });
 
     cases.add("ignore result, no function arguments",
         \\void foo() {
@@ -228,7 +228,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    1 - 1;
         \\    a = 1;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    var a: c_int = undefined;
         \\    _ = 1;
@@ -237,53 +237,53 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    _ = (1 - 1);
         \\    a = 1;
         \\}
-    );
+    });
 
     cases.add("for loop with var init but empty body",
         \\void foo(void) {
         \\    for (int x = 0; x < 10; x++);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    {
         \\        var x: c_int = 0;
         \\        while (x < 10) : (x += 1) {}
         \\    }
         \\}
-    );
+    });
 
     cases.add("do while with empty body",
         \\void foo(void) {
         \\    do ; while (1);
         \\}
-    , // TODO this should be if (1 != 0) break
+    , &[_][]const u8{ // TODO this should be if (1 != 0) break
         \\pub fn foo() void {
         \\    while (true) {
         \\        {}
         \\        if (!1) break;
         \\    }
         \\}
-    );
+    });
 
     cases.add("for with empty body",
         \\void foo(void) {
         \\    for (;;);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    while (true) {}
         \\}
-    );
+    });
 
     cases.add("while with empty body",
         \\void foo(void) {
         \\    while (1);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    while (1 != 0) {}
         \\}
-    );
+    });
 
     cases.add("double define struct",
         \\typedef struct Bar Bar;
@@ -296,7 +296,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\struct Bar {
         \\    Foo *a;
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const struct_Foo = extern struct {
         \\    a: [*c]Foo,
         \\};
@@ -304,7 +304,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub const struct_Bar = extern struct {
         \\    a: [*c]Foo,
         \\};
-    );
+    });
 
     cases.addAllowWarnings("simple data types",
         \\#include <stdint.h>
@@ -312,29 +312,29 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\int foo(char a, unsigned char b, signed char c); // test a duplicate prototype
         \\void bar(uint8_t a, uint16_t b, uint32_t c, uint64_t d);
         \\void baz(int8_t a, int16_t b, int32_t c, int64_t d);
-    ,
+    , &[_][]const u8{
         \\pub extern fn foo(a: u8, b: u8, c: i8) c_int;
     ,
         \\pub extern fn bar(a: u8, b: u16, c: u32, d: u64) void;
     ,
         \\pub extern fn baz(a: i8, b: i16, c: i32, d: i64) void;
-    );
+    });
 
     cases.add_both("noreturn attribute",
         \\void foo(void) __attribute__((noreturn));
-    ,
+    , &[_][]const u8{
         \\pub extern fn foo() noreturn;
-    );
+    });
 
     cases.addC("simple function",
         \\int abs(int a) {
         \\    return a < 0 ? -a : a;
         \\}
-    ,
+    , &[_][]const u8{
         \\export fn abs(a: c_int) c_int {
         \\    return if (a < 0) -a else a;
         \\}
-    );
+    });
 
     cases.add("enums",
         \\enum Foo {
@@ -342,7 +342,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    FooB,
         \\    Foo1,
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const enum_Foo = extern enum {
         \\    A,
         \\    B,
@@ -356,7 +356,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub const Foo1 = enum_Foo.@"1";
     ,
         \\pub const Foo = enum_Foo;
-    );
+    });
 
     cases.add("enums",
         \\enum Foo {
@@ -364,7 +364,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    FooB = 5,
         \\    Foo1,
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const enum_Foo = extern enum {
         \\    A = 2,
         \\    B = 5,
@@ -378,27 +378,27 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub const Foo1 = enum_Foo.@"1";
     ,
         \\pub const Foo = enum_Foo;
-    );
+    });
 
     cases.add("restrict -> noalias",
         \\void foo(void *restrict bar, void *restrict);
-    ,
+    , &[_][]const u8{
         \\pub extern fn foo(noalias bar: ?*c_void, noalias arg1: ?*c_void) void;
-    );
+    });
 
     cases.add("simple struct",
         \\struct Foo {
         \\    int x;
         \\    char *y;
         \\};
-    ,
+    , &[_][]const u8{
         \\const struct_Foo = extern struct {
         \\    x: c_int,
         \\    y: [*c]u8,
         \\};
     ,
         \\pub const Foo = struct_Foo;
-    );
+    });
 
     cases.add("qualified struct and enum",
         \\struct Foo {
@@ -410,7 +410,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    BarB,
         \\};
         \\void func(struct Foo *a, enum Bar **b);
-    ,
+    , &[_][]const u8{
         \\pub const struct_Foo = extern struct {
         \\    x: c_int,
         \\    y: c_int,
@@ -430,66 +430,66 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub const Foo = struct_Foo;
     ,
         \\pub const Bar = enum_Bar;
-    );
+    });
 
     cases.add("constant size array",
         \\void func(int array[20]);
-    ,
+    , &[_][]const u8{
         \\pub extern fn func(array: [*c]c_int) void;
-    );
+    });
 
     cases.add("self referential struct with function pointer",
         \\struct Foo {
         \\    void (*derp)(struct Foo *foo);
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const struct_Foo = extern struct {
         \\    derp: ?extern fn ([*c]struct_Foo) void,
         \\};
     ,
         \\pub const Foo = struct_Foo;
-    );
+    });
 
     cases.add("struct prototype used in func",
         \\struct Foo;
         \\struct Foo *some_func(struct Foo *foo, int x);
-    ,
+    , &[_][]const u8{
         \\pub const struct_Foo = @OpaqueType();
     ,
         \\pub extern fn some_func(foo: ?*struct_Foo, x: c_int) ?*struct_Foo;
     ,
         \\pub const Foo = struct_Foo;
-    );
+    });
 
     cases.add("#define a char literal",
         \\#define A_CHAR  'a'
-    ,
+    , &[_][]const u8{
         \\pub const A_CHAR = 97;
-    );
+    });
 
     cases.add("#define an unsigned integer literal",
         \\#define CHANNEL_COUNT 24
-    ,
+    , &[_][]const u8{
         \\pub const CHANNEL_COUNT = 24;
-    );
+    });
 
     cases.add("#define referencing another #define",
         \\#define THING2 THING1
         \\#define THING1 1234
-    ,
+    , &[_][]const u8{
         \\pub const THING1 = 1234;
     ,
         \\pub const THING2 = THING1;
-    );
+    });
 
     cases.add("variables",
         \\extern int extern_var;
         \\static const int int_var = 13;
-    ,
+    , &[_][]const u8{
         \\pub extern var extern_var: c_int;
     ,
         \\pub const int_var: c_int = 13;
-    );
+    });
 
     cases.add("circular struct definitions",
         \\struct Bar;
@@ -501,7 +501,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\struct Bar {
         \\    struct Foo *next;
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const struct_Bar = extern struct {
         \\    next: [*c]struct_Foo,
         \\};
@@ -509,16 +509,16 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub const struct_Foo = extern struct {
         \\    next: [*c]struct_Bar,
         \\};
-    );
+    });
 
     cases.add("typedef void",
         \\typedef void Foo;
         \\Foo fun(Foo *a);
-    ,
+    , &[_][]const u8{
         \\pub const Foo = c_void;
     ,
         \\pub extern fn fun(a: ?*Foo) Foo;
-    );
+    });
 
     cases.add("generate inline func for #define global extern fn",
         \\extern void (*fn_ptr)(void);
@@ -526,7 +526,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\
         \\extern char (*fn_ptr2)(int, float);
         \\#define bar fn_ptr2
-    ,
+    , &[_][]const u8{
         \\pub extern var fn_ptr: ?extern fn () void;
     ,
         \\pub inline fn foo() void {
@@ -538,109 +538,109 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub inline fn bar(arg0: c_int, arg1: f32) u8 {
         \\    return fn_ptr2.?(arg0, arg1);
         \\}
-    );
+    });
 
     cases.add("#define string",
         \\#define  foo  "a string"
-    ,
+    , &[_][]const u8{
         \\pub const foo = "a string";
-    );
+    });
 
     cases.add("__cdecl doesn't mess up function pointers",
         \\void foo(void (__cdecl *fn_ptr)(void));
-    ,
+    , &[_][]const u8{
         \\pub extern fn foo(fn_ptr: ?extern fn () void) void;
-    );
+    });
 
     cases.add("comment after integer literal",
         \\#define SDL_INIT_VIDEO 0x00000020  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = 32;
-    );
+    });
 
     cases.add("u integer suffix after hex literal",
         \\#define SDL_INIT_VIDEO 0x00000020u  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = @as(c_uint, 32);
-    );
+    });
 
     cases.add("l integer suffix after hex literal",
         \\#define SDL_INIT_VIDEO 0x00000020l  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = @as(c_long, 32);
-    );
+    });
 
     cases.add("ul integer suffix after hex literal",
         \\#define SDL_INIT_VIDEO 0x00000020ul  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = @as(c_ulong, 32);
-    );
+    });
 
     cases.add("lu integer suffix after hex literal",
         \\#define SDL_INIT_VIDEO 0x00000020lu  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = @as(c_ulong, 32);
-    );
+    });
 
     cases.add("ll integer suffix after hex literal",
         \\#define SDL_INIT_VIDEO 0x00000020ll  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = @as(c_longlong, 32);
-    );
+    });
 
     cases.add("ull integer suffix after hex literal",
         \\#define SDL_INIT_VIDEO 0x00000020ull  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = @as(c_ulonglong, 32);
-    );
+    });
 
     cases.add("llu integer suffix after hex literal",
         \\#define SDL_INIT_VIDEO 0x00000020llu  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-    ,
+    , &[_][]const u8{
         \\pub const SDL_INIT_VIDEO = @as(c_ulonglong, 32);
-    );
+    });
 
     cases.add("zig keywords in C code",
         \\struct comptime {
         \\    int defer;
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const struct_comptime = extern struct {
         \\    @"defer": c_int,
         \\};
     ,
         \\pub const @"comptime" = struct_comptime;
-    );
+    });
 
     cases.add("macro defines string literal with hex",
         \\#define FOO "aoeu\xab derp"
         \\#define FOO2 "aoeu\x0007a derp"
         \\#define FOO_CHAR '\xfF'
-    ,
+    , &[_][]const u8{
         \\pub const FOO = "aoeu\xab derp";
     ,
         \\pub const FOO2 = "aoeuz derp";
     ,
         \\pub const FOO_CHAR = 255;
-    );
+    });
 
     cases.add("macro defines string literal with octal",
         \\#define FOO "aoeu\023 derp"
         \\#define FOO2 "aoeu\0234 derp"
         \\#define FOO_CHAR '\077'
-    ,
+    , &[_][]const u8{
         \\pub const FOO = "aoeu\x13 derp";
     ,
         \\pub const FOO2 = "aoeu\x134 derp";
     ,
         \\pub const FOO_CHAR = 63;
-    );
+    });
 
     cases.add("macro with parens around negative number",
         \\#define LUA_GLOBALSINDEX        (-10002)
-    ,
+    , &[_][]const u8{
         \\pub const LUA_GLOBALSINDEX = -10002;
-    );
+    });
 
     cases.addC("post increment",
         \\unsigned foo1(unsigned a) {
@@ -651,7 +651,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    a++;
         \\    return a;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo1(_arg_a: c_uint) c_uint {
         \\    var a = _arg_a;
         \\    a +%= 1;
@@ -662,7 +662,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    a += 1;
         \\    return a;
         \\}
-    );
+    });
 
     cases.addC("shift right assign",
         \\int log2(unsigned a) {
@@ -672,7 +672,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    }
         \\    return i;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn log2(_arg_a: c_uint) c_int {
         \\    var a = _arg_a;
         \\    var i: c_int = 0;
@@ -681,7 +681,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    }
         \\    return i;
         \\}
-    );
+    });
 
     cases.addC("if statement",
         \\int max(int a, int b) {
@@ -695,13 +695,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\
         \\    if (a < b) ; else ;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn max(a: c_int, b: c_int) c_int {
         \\    if (a < b) return b;
         \\    if (a < b) return b else return a;
         \\    if (a < b) {} else {}
         \\}
-    );
+    });
 
     cases.addC("==, !=",
         \\int max(int a, int b) {
@@ -711,13 +711,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        return b;
         \\    return a;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn max(a: c_int, b: c_int) c_int {
         \\    if (a == b) return a;
         \\    if (a != b) return b;
         \\    return a;
         \\}
-    );
+    });
 
     cases.addC("add, sub, mul, div, rem",
         \\int s(int a, int b) {
@@ -736,7 +736,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    c = a / b;
         \\    c = a % b;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn s(a: c_int, b: c_int) c_int {
         \\    var c: c_int = undefined;
         \\    c = (a + b);
@@ -753,17 +753,17 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    c = (a / b);
         \\    c = (a % b);
         \\}
-    );
+    });
 
     cases.addC("bitwise binary operators",
         \\int max(int a, int b) {
         \\    return (a & b) ^ (a | b);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn max(a: c_int, b: c_int) c_int {
         \\    return (a & b) ^ (a | b);
         \\}
-    );
+    });
 
     cases.addC("logical and, logical or",
         \\int max(int a, int b) {
@@ -773,13 +773,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        return a;
         \\    return a;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn max(a: c_int, b: c_int) c_int {
         \\    if ((a < b) or (a == b)) return b;
         \\    if ((a >= b) and (a == b)) return a;
         \\    return a;
         \\}
-    );
+    });
 
     cases.addC("logical and, logical or on none bool values",
         \\int and_or_none_bool(int a, float b, void *c) {
@@ -791,7 +791,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    if (a || c) return 5;
         \\    return 6;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn and_or_none_bool(a: c_int, b: f32, c: ?*c_void) c_int {
         \\    if ((a != 0) and (b != 0)) return 0;
         \\    if ((b != 0) and (c != null)) return 1;
@@ -801,7 +801,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    if ((a != 0) or (c != null)) return 5;
         \\    return 6;
         \\}
-    );
+    });
 
     cases.addC("assign",
         \\int max(int a) {
@@ -809,21 +809,21 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    tmp = a;
         \\    a = tmp;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn max(_arg_a: c_int) c_int {
         \\    var a = _arg_a;
         \\    var tmp: c_int = undefined;
         \\    tmp = a;
         \\    a = tmp;
         \\}
-    );
+    });
 
     cases.addC("chaining assign",
         \\void max(int a) {
         \\    int b, c;
         \\    c = b = a;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn max(a: c_int) void {
         \\    var b: c_int = undefined;
         \\    var c: c_int = undefined;
@@ -833,7 +833,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        break :x _tmp;
         \\    });
         \\}
-    );
+    });
 
     cases.addC("shift right assign with a fixed size type",
         \\#include <stdint.h>
@@ -844,7 +844,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    }
         \\    return i;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn log2(_arg_a: u32) c_int {
         \\    var a = _arg_a;
         \\    var i: c_int = 0;
@@ -853,17 +853,17 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    }
         \\    return i;
         \\}
-    );
+    });
 
     cases.add("anonymous enum",
         \\enum {
         \\    One,
         \\    Two,
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const One = 0;
         \\pub const Two = 1;
-    );
+    });
 
     cases.addC("function call",
         \\static void bar(void) { }
@@ -872,7 +872,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    bar();
         \\    baz();
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn bar() void {}
         \\pub fn baz() c_int {
         \\    return 0;
@@ -881,7 +881,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    bar();
         \\    _ = baz();
         \\}
-    );
+    });
 
     cases.addC("field access expression",
         \\struct Foo {
@@ -890,20 +890,20 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\int read_field(struct Foo *foo) {
         \\    return foo->field;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub const struct_Foo = extern struct {
         \\    field: c_int,
         \\};
         \\pub export fn read_field(foo: [*c]struct_Foo) c_int {
         \\    return foo.*.field;
         \\}
-    );
+    });
 
     cases.addC("null statements",
         \\void foo(void) {
         \\    ;;;;;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {
         \\    {}
         \\    {}
@@ -911,89 +911,89 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    {}
         \\    {}
         \\}
-    );
+    });
 
     cases.add("undefined array global",
         \\int array[100];
-    ,
+    , &[_][]const u8{
         \\pub var array: [100]c_int = undefined;
-    );
+    });
 
     cases.addC("array access",
         \\int array[100];
         \\int foo(int index) {
         \\    return array[index];
         \\}
-    ,
+    , &[_][]const u8{
         \\pub var array: [100]c_int = undefined;
         \\pub export fn foo(index: c_int) c_int {
         \\    return array[index];
         \\}
-    );
+    });
 
     cases.addC("c style cast",
         \\int float_to_int(float a) {
         \\    return (int)a;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn float_to_int(a: f32) c_int {
         \\    return @as(c_int, a);
         \\}
-    );
+    });
 
     cases.addC("void cast",
         \\void foo(int a) {
         \\    (void) a;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo(a: c_int) void {
         \\    _ = a;
         \\}
-    );
+    });
 
     cases.addC("implicit cast to void *",
         \\void *foo(unsigned short *x) {
         \\    return x;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo(x: [*c]c_ushort) ?*c_void {
         \\    return @ptrCast(?*c_void, x);
         \\}
-    );
+    });
 
     cases.addC("sizeof",
         \\#include <stddef.h>
         \\size_t size_of(void) {
         \\        return sizeof(int);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn size_of() usize {
         \\    return @sizeOf(c_int);
         \\}
-    );
+    });
 
     cases.addC("null pointer implicit cast",
         \\int* foo(void) {
         \\    return 0;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() [*c]c_int {
         \\    return null;
         \\}
-    );
+    });
 
     cases.addC("comma operator",
         \\int foo(void) {
         \\    return 1, 2;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() c_int {
         \\    return x: {
         \\        _ = 1;
         \\        break :x 2;
         \\    };
         \\}
-    );
+    });
 
     cases.addC("statement expression",
         \\int foo(void) {
@@ -1002,34 +1002,34 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        a;
         \\    });
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() c_int {
         \\    return x: {
         \\        var a: c_int = 1;
         \\        break :x a;
         \\    };
         \\}
-    );
+    });
 
     cases.addC("__extension__ cast",
         \\int foo(void) {
         \\    return __extension__ 1;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() c_int {
         \\    return 1;
         \\}
-    );
+    });
 
     cases.addC("bitshift",
         \\int foo(void) {
         \\    return (1 << 2) >> 1;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() c_int {
         \\    return (1 << @as(@import("std").math.Log2Int(c_int), 2)) >> @as(@import("std").math.Log2Int(c_int), 1);
         \\}
-    );
+    });
 
     cases.addC("compound assignment operators",
         \\void foo(void) {
@@ -1043,7 +1043,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    a >>= (a >>= 1);
         \\    a <<= (a <<= 1);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {
         \\    var a: c_int = 0;
         \\    a += (x: {
@@ -1087,7 +1087,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        break :x _ref.*;
         \\    }));
         \\}
-    );
+    });
 
     cases.addC("compound assignment operators unsigned",
         \\void foo(void) {
@@ -1101,7 +1101,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    a >>= (a >>= 1);
         \\    a <<= (a <<= 1);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {
         \\    var a: c_uint = @as(c_uint, 0);
         \\    a +%= (x: {
@@ -1145,18 +1145,18 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        break :x _ref.*;
         \\    }));
         \\}
-    );
+    });
 
     cases.addC("duplicate typedef",
         \\typedef long foo;
         \\typedef int bar;
         \\typedef long foo;
         \\typedef int baz;
-    ,
+    , &[_][]const u8{
         \\pub const foo = c_long;
         \\pub const bar = c_int;
         \\pub const baz = c_int;
-    );
+    });
 
     cases.addC("post increment/decrement",
         \\void foo(void) {
@@ -1171,7 +1171,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    u = u++;
         \\    u = u--;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {
         \\    var i: c_int = 0;
         \\    var u: c_uint = @as(c_uint, 0);
@@ -1204,7 +1204,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        break :x _tmp;
         \\    });
         \\}
-    );
+    });
 
     cases.addC("pre increment/decrement",
         \\void foo(void) {
@@ -1219,7 +1219,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    u = ++u;
         \\    u = --u;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {
         \\    var i: c_int = 0;
         \\    var u: c_uint = @as(c_uint, 0);
@@ -1248,7 +1248,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        break :x _ref.*;
         \\    });
         \\}
-    );
+    });
 
     cases.addC("do loop",
         \\void foo(void) {
@@ -1262,7 +1262,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        b--;
         \\    while (b != 0);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {
         \\    var a: c_int = 2;
         \\    while (true) {
@@ -1275,7 +1275,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        if (!(b != 0)) break;
         \\    }
         \\}
-    );
+    });
 
     cases.addC("deref function pointer",
         \\void foo(void) {}
@@ -1290,7 +1290,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    (*(b))();
         \\    baz();
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {}
         \\pub export fn baz() c_int {
         \\    return 0;
@@ -1305,31 +1305,31 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    _ = b.?();
         \\    _ = baz();
         \\}
-    );
+    });
 
     cases.addC("normal deref",
         \\void foo(int *x) {
         \\    *x = 1;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo(x: [*c]c_int) void {
         \\    x.?.* = 1;
         \\}
-    );
+    });
 
     cases.add("simple union",
         \\union Foo {
         \\    int x;
         \\    double y;
         \\};
-    ,
+    , &[_][]const u8{
         \\pub const union_Foo = extern union {
         \\    x: c_int,
         \\    y: f64,
         \\};
     ,
         \\pub const Foo = union_Foo;
-    );
+    });
 
     cases.add("address of operator",
         \\int foo(void) {
@@ -1337,56 +1337,56 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    int *ptr = &x;
         \\    return *ptr;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() c_int {
         \\    var x: c_int = 1234;
         \\    var ptr: [*c]c_int = &x;
         \\    return ptr.?.*;
         \\}
-    );
+    });
 
     cases.add("string literal",
         \\const char *foo(void) {
         \\    return "bar";
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() [*c]const u8 {
         \\    return "bar";
         \\}
-    );
+    });
 
     cases.add("return void",
         \\void foo(void) {
         \\    return;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    return;
         \\}
-    );
+    });
 
     cases.add("for loop",
         \\void foo(void) {
         \\    for (int i = 0; i < 10; i += 1) { }
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    {
         \\        var i: c_int = 0;
         \\        while (i < 10) : (i += 1) {}
         \\    }
         \\}
-    );
+    });
 
     cases.add("empty for loop",
         \\void foo(void) {
         \\    for (;;) { }
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    while (true) {}
         \\}
-    );
+    });
 
     cases.add("break statement",
         \\void foo(void) {
@@ -1394,13 +1394,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        break;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    while (true) {
         \\        break;
         \\    }
         \\}
-    );
+    });
 
     cases.add("continue statement",
         \\void foo(void) {
@@ -1408,13 +1408,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        continue;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    while (true) {
         \\        continue;
         \\    }
         \\}
-    );
+    });
 
     cases.add("macros with field targets",
         \\typedef unsigned int GLbitfield;
@@ -1429,7 +1429,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\extern union OpenGLProcs glProcs;
         \\#define glClearUnion glProcs.gl.Clear
         \\#define glClearPFN PFNGLCLEARPROC
-    ,
+    , &[_][]const u8{
         \\pub const GLbitfield = c_uint;
     ,
         \\pub const PFNGLCLEARPROC = ?extern fn (GLbitfield) void;
@@ -1452,7 +1452,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\}
     ,
         \\pub const OpenGLProcs = union_OpenGLProcs;
-    );
+    });
 
     cases.add("variable name shadowing",
         \\int foo(void) {
@@ -1463,7 +1463,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    }
         \\    return x;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() c_int {
         \\    var x: c_int = 1;
         \\    {
@@ -1472,27 +1472,27 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    }
         \\    return x;
         \\}
-    );
+    });
 
     cases.add("pointer casting",
         \\float *ptrcast(int *a) {
         \\    return (float *)a;
         \\}
-    ,
+    , &[_][]const u8{
         \\fn ptrcast(a: [*c]c_int) [*c]f32 {
         \\    return @ptrCast([*c]f32, @alignCast(@alignOf(f32), a));
         \\}
-    );
+    });
 
     cases.add("bin not",
         \\int foo(int x) {
         \\    return ~x;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo(x: c_int) c_int {
         \\    return ~x;
         \\}
-    );
+    });
 
     cases.add("bool not",
         \\int foo(int a, float b, void *c) {
@@ -1501,46 +1501,46 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    return !b;
         \\    return !c;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo(a: c_int, b: f32, c: ?*c_void) c_int {
         \\    return !(a == 0);
         \\    return !(a != 0);
         \\    return !(b != 0);
         \\    return !(c != null);
         \\}
-    );
+    });
 
     cases.add("primitive types included in defined symbols",
         \\int foo(int u32) {
         \\    return u32;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo(u32_0: c_int) c_int {
         \\    return u32_0;
         \\}
-    );
+    });
 
     cases.add("const ptr initializer",
         \\static const char *v0 = "0.0.0";
-    ,
+    , &[_][]const u8{
         \\pub var v0: [*c]const u8 = "0.0.0";
-    );
+    });
 
     cases.add("static incomplete array inside function",
         \\void foo(void) {
         \\    static const char v2[] = "2.2.2";
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn foo() void {
         \\    const v2: [*c]const u8 = "2.2.2";
         \\}
-    );
+    });
 
     cases.add("macro pointer cast",
         \\#define NRF_GPIO ((NRF_GPIO_Type *) NRF_GPIO_BASE)
-    ,
+    , &[_][]const u8{
         \\pub const NRF_GPIO = if (@typeId(@typeOf(NRF_GPIO_BASE)) == @import("builtin").TypeId.Pointer) @ptrCast([*c]NRF_GPIO_Type, NRF_GPIO_BASE) else if (@typeId(@typeOf(NRF_GPIO_BASE)) == @import("builtin").TypeId.Int) @intToPtr([*c]NRF_GPIO_Type, NRF_GPIO_BASE) else @as([*c]NRF_GPIO_Type, NRF_GPIO_BASE);
-    );
+    });
 
     cases.add("if on non-bool",
         \\enum SomeEnum { A, B, C };
@@ -1551,7 +1551,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    if (d) return 3;
         \\    return 4;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub const A = enum_SomeEnum.A;
         \\pub const B = enum_SomeEnum.B;
         \\pub const C = enum_SomeEnum.C;
@@ -1567,7 +1567,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    if (d != @bitCast(enum_SomeEnum, @as(@TagType(enum_SomeEnum), 0))) return 3;
         \\    return 4;
         \\}
-    );
+    });
 
     cases.add("while on non-bool",
         \\int while_none_bool(int a, float b, void *c) {
@@ -1576,14 +1576,14 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    while (c) return 2;
         \\    return 3;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn while_none_bool(a: c_int, b: f32, c: ?*c_void) c_int {
         \\    while (a != 0) return 0;
         \\    while (b != 0) return 1;
         \\    while (c != null) return 2;
         \\    return 3;
         \\}
-    );
+    });
 
     cases.add("for on non-bool",
         \\int for_none_bool(int a, float b, void *c) {
@@ -1592,14 +1592,14 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    for (;c;) return 2;
         \\    return 3;
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn for_none_bool(a: c_int, b: f32, c: ?*c_void) c_int {
         \\    while (a != 0) return 0;
         \\    while (b != 0) return 1;
         \\    while (c != null) return 2;
         \\    return 3;
         \\}
-    );
+    });
 
     cases.add("switch on int",
         \\int switch_fn(int i) {
@@ -1616,7 +1616,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\            res = 5;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         \\pub fn switch_fn(i: c_int) c_int {
         \\    var res: c_int = 0;
         \\    __switch: {
@@ -1641,54 +1641,70 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        res = 5;
         \\    }
         \\}
-    );
+    });
 
     cases.addC(
         "u integer suffix after 0 (zero) in macro definition",
         "#define ZERO 0U",
-        "pub const ZERO = @as(c_uint, 0);",
+        &[_][]const u8{
+            "pub const ZERO = @as(c_uint, 0);",
+        },
     );
 
     cases.addC(
         "l integer suffix after 0 (zero) in macro definition",
         "#define ZERO 0L",
-        "pub const ZERO = @as(c_long, 0);",
+        &[_][]const u8{
+            "pub const ZERO = @as(c_long, 0);",
+        },
     );
 
     cases.addC(
         "ul integer suffix after 0 (zero) in macro definition",
         "#define ZERO 0UL",
-        "pub const ZERO = @as(c_ulong, 0);",
+        &[_][]const u8{
+            "pub const ZERO = @as(c_ulong, 0);",
+        },
     );
 
     cases.addC(
         "lu integer suffix after 0 (zero) in macro definition",
         "#define ZERO 0LU",
-        "pub const ZERO = @as(c_ulong, 0);",
+        &[_][]const u8{
+            "pub const ZERO = @as(c_ulong, 0);",
+        },
     );
 
     cases.addC(
         "ll integer suffix after 0 (zero) in macro definition",
         "#define ZERO 0LL",
-        "pub const ZERO = @as(c_longlong, 0);",
+        &[_][]const u8{
+            "pub const ZERO = @as(c_longlong, 0);",
+        },
     );
 
     cases.addC(
         "ull integer suffix after 0 (zero) in macro definition",
         "#define ZERO 0ULL",
-        "pub const ZERO = @as(c_ulonglong, 0);",
+        &[_][]const u8{
+            "pub const ZERO = @as(c_ulonglong, 0);",
+        },
     );
 
     cases.addC(
         "llu integer suffix after 0 (zero) in macro definition",
         "#define ZERO 0LLU",
-        "pub const ZERO = @as(c_ulonglong, 0);",
+        &[_][]const u8{
+            "pub const ZERO = @as(c_ulonglong, 0);",
+        },
     );
 
     cases.addC(
         "bitwise not on u-suffixed 0 (zero) in macro definition",
         "#define NOT_ZERO (~0U)",
-        "pub const NOT_ZERO = ~@as(c_uint, 0);",
+        &[_][]const u8{
+            "pub const NOT_ZERO = ~@as(c_uint, 0);",
+        },
     );
 
     cases.addC("implicit casts",
@@ -1719,7 +1735,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    fn_int(&fn_int);
         \\    fn_ptr(42);
         \\}
-    ,
+    , &[_][]const u8{
         \\pub extern fn fn_int(x: c_int) void;
         \\pub extern fn fn_f32(x: f32) void;
         \\pub extern fn fn_f64(x: f64) void;
@@ -1744,7 +1760,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    fn_int(@intCast(c_int, @ptrToInt(&fn_int)));
         \\    fn_ptr(@intToPtr(?*c_void, 42));
         \\}
-    );
+    });
 
     cases.addC("pointer conversion with different alignment",
         \\void test_ptr_cast() {
@@ -1762,7 +1778,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        long long *to_longlong = p;
         \\    }
         \\}
-    ,
+    , &[_][]const u8{
         \\pub export fn test_ptr_cast() void {
         \\    var p: ?*c_void = undefined;
         \\    {
@@ -1778,7 +1794,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        var to_longlong: [*c]c_longlong = @ptrCast([*c]c_longlong, @alignCast(@alignOf(c_longlong), p));
         \\    }
         \\}
-    );
+    });
 
     cases.addC("escape sequences",
         \\const char *escapes() {
@@ -1796,7 +1812,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    return "\'\\\a\b\f\n\r\t\v\0\"";
         \\}
         \\
-    ,
+    , &[_][]const u8{
         \\pub export fn escapes() [*c]const u8 {
         \\    var a: u8 = @as(u8, '\'');
         \\    var b: u8 = @as(u8, '\\');
@@ -1812,23 +1828,23 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    return "\'\\\x07\x08\x0c\n\r\t\x0b\x00\"";
         \\}
         \\
-    );
+    });
 
     if (builtin.os != builtin.Os.windows) {
         // sysv_abi not currently supported on windows
         cases.add("Macro qualified functions",
             \\void __attribute__((sysv_abi)) foo(void);
-        ,
+        , &[_][]const u8{
             \\pub extern fn foo() void;
-        );
+        });
     }
 
     /////////////// Cases for only stage1 because stage2 behavior is better ////////////////
     cases.addC("Parameterless function prototypes",
         \\void foo() {}
         \\void bar(void) {}
-    ,
+    , &[_][]const u8{
         \\pub export fn foo() void {}
         \\pub export fn bar() void {}
-    );
+    });
 }
-- 
cgit v1.2.3


From c759a77aa063f75b29a2278409b9c6d92496ae5d Mon Sep 17 00:00:00 2001
From: Vexu <git@vexu.eu>
Date: Thu, 12 Dec 2019 18:26:12 +0200
Subject: fix dot init parsing

---
 src/parser.cpp          |  6 +++++-
 test/compile_errors.zig | 12 ++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

(limited to 'src/parser.cpp')

diff --git a/src/parser.cpp b/src/parser.cpp
index 96162632b9..4b5e0e3ebb 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -1923,7 +1923,11 @@ static AstNode *ast_parse_anon_lit(ParseContext *pc) {
     }
 
     // anon container literal
-    return ast_parse_init_list(pc);
+    AstNode *res = ast_parse_init_list(pc);
+    if (res != nullptr)
+        return res;
+    put_back_token(pc);
+    return nullptr;
 }
 
 // AsmOutput <- COLON AsmOutputList AsmInput?
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 12e9184c57..d2f5082d74 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -2,6 +2,18 @@ const tests = @import("tests.zig");
 const builtin = @import("builtin");
 
 pub fn addCases(cases: *tests.CompileErrorContext) void {
+    cases.add("invalid float literal",
+        \\const std = @import("std");
+        \\
+        \\pub fn main() void {
+        \\    var bad_float :f32 = 0.0;
+        \\    bad_float = bad_float + .20;
+        \\    std.debug.assert(bad_float < 1.0);
+        \\})
+    , &[_][]const u8{
+        "tmp.zig:5:29: error: invalid token: '.'",
+    });
+
     cases.add("var args without c calling conv",
         \\fn foo(args: ...) void {}
         \\comptime {
-- 
cgit v1.2.3


From 26f3c2d0614f4fb37752b1931cb0b43aed2696d2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 18 Dec 2019 16:43:56 -0500
Subject: fix std.mem.addNullByte and implement sentinel slicing

see #3770
---
 lib/std/buffer.zig      |  4 +--
 lib/std/cstr.zig        | 12 ++++++--
 lib/std/fs.zig          |  9 +++---
 lib/std/mem.zig         |  5 +--
 lib/std/os.zig          | 25 ++++++---------
 src/all_types.hpp       |  2 ++
 src/ir.cpp              | 82 ++++++++++++++++++++++++++++++++++++++++++-------
 src/parser.cpp          |  8 ++++-
 test/compile_errors.zig | 11 +++++++
 9 files changed, 119 insertions(+), 39 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/buffer.zig b/lib/std/buffer.zig
index 55a5a890d6..6313d693b7 100644
--- a/lib/std/buffer.zig
+++ b/lib/std/buffer.zig
@@ -82,11 +82,11 @@ pub const Buffer = struct {
     }
 
     pub fn toSlice(self: Buffer) [:0]u8 {
-        return self.list.toSlice()[0..self.len()];
+        return self.list.toSlice()[0..self.len() :0];
     }
 
     pub fn toSliceConst(self: Buffer) [:0]const u8 {
-        return self.list.toSliceConst()[0..self.len()];
+        return self.list.toSliceConst()[0..self.len() :0];
     }
 
     pub fn shrink(self: *Buffer, new_len: usize) void {
diff --git a/lib/std/cstr.zig b/lib/std/cstr.zig
index 6dbae8342e..5194dc1a13 100644
--- a/lib/std/cstr.zig
+++ b/lib/std/cstr.zig
@@ -31,13 +31,21 @@ fn testCStrFnsImpl() void {
     testing.expect(mem.len(u8, "123456789") == 9);
 }
 
-/// Returns a mutable slice with 1 more byte of length which is a null byte.
+/// Returns a mutable, null-terminated slice with the same length as `slice`.
 /// Caller owns the returned memory.
 pub fn addNullByte(allocator: *mem.Allocator, slice: []const u8) ![:0]u8 {
     const result = try allocator.alloc(u8, slice.len + 1);
     mem.copy(u8, result, slice);
     result[slice.len] = 0;
-    return result;
+    return result[0..slice.len :0];
+}
+
+test "addNullByte" {
+    var buf: [30]u8 = undefined;
+    const allocator = &std.heap.FixedBufferAllocator.init(&buf).allocator;
+    const slice = try addNullByte(allocator, "hello"[0..4]);
+    testing.expect(slice.len == 4);
+    testing.expect(slice[4] == 0);
 }
 
 pub const NullTerminated2DArray = struct {
diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index 9e7daf0a9a..ea62086f59 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -221,16 +221,16 @@ pub const AtomicFile = struct {
         }
 
         tmp_path_buf[tmp_path_len] = 0;
+        const tmp_path_slice = tmp_path_buf[0..tmp_path_len :0];
 
         const my_cwd = cwd();
 
         while (true) {
             try crypto.randomBytes(rand_buf[0..]);
-            b64_fs_encoder.encode(tmp_path_buf[dirname_component_len..tmp_path_len], &rand_buf);
+            b64_fs_encoder.encode(tmp_path_slice[dirname_component_len..tmp_path_len], &rand_buf);
 
-            // TODO https://github.com/ziglang/zig/issues/3770 to clean up this @ptrCast
             const file = my_cwd.createFileC(
-                @ptrCast([*:0]u8, &tmp_path_buf),
+                tmp_path_slice, 
                 .{ .mode = mode, .exclusive = true },
             ) catch |err| switch (err) {
                 error.PathAlreadyExists => continue,
@@ -1488,8 +1488,7 @@ pub fn openSelfExe() OpenSelfExeError!File {
     var buf: [MAX_PATH_BYTES]u8 = undefined;
     const self_exe_path = try selfExePath(&buf);
     buf[self_exe_path.len] = 0;
-    // TODO avoid @ptrCast here using slice syntax with https://github.com/ziglang/zig/issues/3770
-    return openFileAbsoluteC(@ptrCast([*:0]u8, self_exe_path.ptr), .{});
+    return openFileAbsoluteC(self_exe_path[0..self_exe_path.len :0].ptr, .{});
 }
 
 test "openSelfExe" {
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 8082d31063..824ab2f556 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -231,9 +231,10 @@ pub const Allocator = struct {
     pub fn free(self: *Allocator, memory: var) void {
         const Slice = @typeInfo(@TypeOf(memory)).Pointer;
         const bytes = @sliceToBytes(memory);
-        if (bytes.len == 0) return;
+        const bytes_len = bytes.len + @boolToInt(Slice.sentinel != null);
+        if (bytes_len == 0) return;
         const non_const_ptr = @intToPtr([*]u8, @ptrToInt(bytes.ptr));
-        const shrink_result = self.shrinkFn(self, non_const_ptr[0..bytes.len], Slice.alignment, 0, 1);
+        const shrink_result = self.shrinkFn(self, non_const_ptr[0..bytes_len], Slice.alignment, 0, 1);
         assert(shrink_result.len == 0);
     }
 };
diff --git a/lib/std/os.zig b/lib/std/os.zig
index 6d49bcd38e..3cc43357bd 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -805,9 +805,9 @@ pub fn execvpeC(file: [*:0]const u8, child_argv: [*:null]const ?[*:0]const u8, e
         mem.copy(u8, &path_buf, search_path);
         path_buf[search_path.len] = '/';
         mem.copy(u8, path_buf[search_path.len + 1 ..], file_slice);
-        path_buf[search_path.len + file_slice.len + 1] = 0;
-        // TODO avoid @ptrCast here using slice syntax with https://github.com/ziglang/zig/issues/3770
-        err = execveC(@ptrCast([*:0]u8, &path_buf), child_argv, envp);
+        const path_len = search_path.len + file_slice.len + 1;
+        path_buf[path_len] = 0;
+        err = execveC(path_buf[0..path_len :0].ptr, child_argv, envp);
         switch (err) {
             error.AccessDenied => seen_eacces = true,
             error.FileNotFound, error.NotDir => {},
@@ -841,18 +841,14 @@ pub fn execvpe(
         const arg_buf = try allocator.alloc(u8, arg.len + 1);
         @memcpy(arg_buf.ptr, arg.ptr, arg.len);
         arg_buf[arg.len] = 0;
-
-        // TODO avoid @ptrCast using slice syntax with https://github.com/ziglang/zig/issues/3770
-        argv_buf[i] = @ptrCast([*:0]u8, arg_buf.ptr);
+        argv_buf[i] = arg_buf[0..arg.len :0].ptr;
     }
     argv_buf[argv_slice.len] = null;
+    const argv_ptr = argv_buf[0..argv_slice.len :null].ptr;
 
     const envp_buf = try createNullDelimitedEnvMap(allocator, env_map);
     defer freeNullDelimitedEnvMap(allocator, envp_buf);
 
-    // TODO avoid @ptrCast here using slice syntax with https://github.com/ziglang/zig/issues/3770
-    const argv_ptr = @ptrCast([*:null]?[*:0]u8, argv_buf.ptr);
-
     return execvpeC(argv_buf.ptr[0].?, argv_ptr, envp_buf.ptr);
 }
 
@@ -869,16 +865,13 @@ pub fn createNullDelimitedEnvMap(allocator: *mem.Allocator, env_map: *const std.
             @memcpy(env_buf.ptr, pair.key.ptr, pair.key.len);
             env_buf[pair.key.len] = '=';
             @memcpy(env_buf.ptr + pair.key.len + 1, pair.value.ptr, pair.value.len);
-            env_buf[env_buf.len - 1] = 0;
-
-            // TODO avoid @ptrCast here using slice syntax with https://github.com/ziglang/zig/issues/3770
-            envp_buf[i] = @ptrCast([*:0]u8, env_buf.ptr);
+            const len = env_buf.len - 1;
+            env_buf[len] = 0;
+            envp_buf[i] = env_buf[0..len :0].ptr;
         }
         assert(i == envp_count);
     }
-    // TODO avoid @ptrCast here using slice syntax with https://github.com/ziglang/zig/issues/3770
-    assert(envp_buf[envp_count] == null);
-    return @ptrCast([*:null]?[*:0]u8, envp_buf.ptr)[0..envp_count];
+    return envp_buf[0..envp_count :null];
 }
 
 pub fn freeNullDelimitedEnvMap(allocator: *mem.Allocator, envp_buf: []?[*:0]u8) void {
diff --git a/src/all_types.hpp b/src/all_types.hpp
index bcef45f718..144cdd4fc5 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -810,6 +810,7 @@ struct AstNodeSliceExpr {
     AstNode *array_ref_expr;
     AstNode *start;
     AstNode *end;
+    AstNode *sentinel; // can be null
 };
 
 struct AstNodeFieldAccessExpr {
@@ -3388,6 +3389,7 @@ struct IrInstructionSliceSrc {
     IrInstruction *ptr;
     IrInstruction *start;
     IrInstruction *end;
+    IrInstruction *sentinel;
     ResultLoc *result_loc;
 };
 
diff --git a/src/ir.cpp b/src/ir.cpp
index 3000269ad3..e172b69c96 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -2967,18 +2967,21 @@ static IrInstruction *ir_build_memcpy(IrBuilder *irb, Scope *scope, AstNode *sou
 }
 
 static IrInstruction *ir_build_slice_src(IrBuilder *irb, Scope *scope, AstNode *source_node,
-    IrInstruction *ptr, IrInstruction *start, IrInstruction *end, bool safety_check_on, ResultLoc *result_loc)
+    IrInstruction *ptr, IrInstruction *start, IrInstruction *end, IrInstruction *sentinel,
+    bool safety_check_on, ResultLoc *result_loc)
 {
     IrInstructionSliceSrc *instruction = ir_build_instruction<IrInstructionSliceSrc>(irb, scope, source_node);
     instruction->ptr = ptr;
     instruction->start = start;
     instruction->end = end;
+    instruction->sentinel = sentinel;
     instruction->safety_check_on = safety_check_on;
     instruction->result_loc = result_loc;
 
     ir_ref_instruction(ptr, irb->current_basic_block);
     ir_ref_instruction(start, irb->current_basic_block);
     if (end) ir_ref_instruction(end, irb->current_basic_block);
+    if (sentinel) ir_ref_instruction(sentinel, irb->current_basic_block);
 
     return &instruction->base;
 }
@@ -8483,6 +8486,7 @@ static IrInstruction *ir_gen_slice(IrBuilder *irb, Scope *scope, AstNode *node,
     AstNode *array_node = slice_expr->array_ref_expr;
     AstNode *start_node = slice_expr->start;
     AstNode *end_node = slice_expr->end;
+    AstNode *sentinel_node = slice_expr->sentinel;
 
     IrInstruction *ptr_value = ir_gen_node_extra(irb, array_node, scope, LValPtr, nullptr);
     if (ptr_value == irb->codegen->invalid_instruction)
@@ -8501,7 +8505,17 @@ static IrInstruction *ir_gen_slice(IrBuilder *irb, Scope *scope, AstNode *node,
         end_value = nullptr;
     }
 
-    IrInstruction *slice = ir_build_slice_src(irb, scope, node, ptr_value, start_value, end_value, true, result_loc);
+    IrInstruction *sentinel_value;
+    if (sentinel_node) {
+        sentinel_value = ir_gen_node(irb, sentinel_node, scope);
+        if (sentinel_value == irb->codegen->invalid_instruction)
+            return irb->codegen->invalid_instruction;
+    } else {
+        sentinel_value = nullptr;
+    }
+
+    IrInstruction *slice = ir_build_slice_src(irb, scope, node, ptr_value, start_value, end_value,
+            sentinel_value, true, result_loc);
     return ir_lval_wrap(irb, scope, slice, lval, result_loc);
 }
 
@@ -10533,6 +10547,18 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             result.id = ConstCastResultIdInvalid;
             return result;
         }
+        bool ok_sentinels =
+            wanted_ptr_type->data.pointer.sentinel == nullptr ||
+            (actual_ptr_type->data.pointer.sentinel != nullptr &&
+             const_values_equal(ira->codegen, wanted_ptr_type->data.pointer.sentinel,
+                 actual_ptr_type->data.pointer.sentinel));
+        if (!ok_sentinels) {
+            result.id = ConstCastResultIdPtrSentinel;
+            result.data.bad_ptr_sentinel = allocate_nonzero<ConstCastPtrSentinel>(1);
+            result.data.bad_ptr_sentinel->wanted_type = wanted_ptr_type;
+            result.data.bad_ptr_sentinel->actual_type = actual_ptr_type;
+            return result;
+        }
         if ((!actual_ptr_type->data.pointer.is_const || wanted_ptr_type->data.pointer.is_const) &&
             (!actual_ptr_type->data.pointer.is_volatile || wanted_ptr_type->data.pointer.is_volatile) &&
             actual_ptr_type->data.pointer.bit_offset_in_host == wanted_ptr_type->data.pointer.bit_offset_in_host &&
@@ -19313,6 +19339,20 @@ static ZigType *adjust_ptr_align(CodeGen *g, ZigType *ptr_type, uint32_t new_ali
             ptr_type->data.pointer.sentinel);
 }
 
+static ZigType *adjust_ptr_sentinel(CodeGen *g, ZigType *ptr_type, ZigValue *new_sentinel) {
+    assert(ptr_type->id == ZigTypeIdPointer);
+    return get_pointer_to_type_extra2(g,
+            ptr_type->data.pointer.child_type,
+            ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
+            ptr_type->data.pointer.ptr_len,
+            ptr_type->data.pointer.explicit_alignment,
+            ptr_type->data.pointer.bit_offset_in_host, ptr_type->data.pointer.host_int_bytes,
+            ptr_type->data.pointer.allow_zero,
+            ptr_type->data.pointer.vector_index,
+            ptr_type->data.pointer.inferred_struct_field,
+            new_sentinel);
+}
+
 static ZigType *adjust_slice_align(CodeGen *g, ZigType *slice_type, uint32_t new_align) {
     assert(is_slice(slice_type));
     ZigType *ptr_type = adjust_ptr_align(g, slice_type->data.structure.fields[slice_ptr_index]->type_entry,
@@ -25051,50 +25091,70 @@ static IrInstruction *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstruction
         end = nullptr;
     }
 
-    ZigType *return_type;
+    ZigType *non_sentinel_slice_ptr_type;
+    ZigType *elem_type;
 
     if (array_type->id == ZigTypeIdArray) {
+        elem_type = array_type->data.array.child_type;
         bool is_comptime_const = ptr_ptr->value->special == ConstValSpecialStatic &&
             ptr_ptr->value->data.x_ptr.mut == ConstPtrMutComptimeConst;
-        ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, array_type->data.array.child_type,
+        non_sentinel_slice_ptr_type = get_pointer_to_type_extra(ira->codegen, elem_type,
             ptr_ptr_type->data.pointer.is_const || is_comptime_const,
             ptr_ptr_type->data.pointer.is_volatile,
             PtrLenUnknown,
             ptr_ptr_type->data.pointer.explicit_alignment, 0, 0, false);
-        return_type = get_slice_type(ira->codegen, slice_ptr_type);
     } else if (array_type->id == ZigTypeIdPointer) {
         if (array_type->data.pointer.ptr_len == PtrLenSingle) {
             ZigType *main_type = array_type->data.pointer.child_type;
             if (main_type->id == ZigTypeIdArray) {
-                ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen,
-                        main_type->data.pointer.child_type,
+                elem_type = main_type->data.pointer.child_type;
+                non_sentinel_slice_ptr_type = get_pointer_to_type_extra(ira->codegen,
+                        elem_type,
                         array_type->data.pointer.is_const, array_type->data.pointer.is_volatile,
                         PtrLenUnknown,
                         array_type->data.pointer.explicit_alignment, 0, 0, false);
-                return_type = get_slice_type(ira->codegen, slice_ptr_type);
             } else {
                 ir_add_error(ira, &instruction->base, buf_sprintf("slice of single-item pointer"));
                 return ira->codegen->invalid_instruction;
             }
         } else {
+            elem_type = array_type->data.pointer.child_type;
             if (array_type->data.pointer.ptr_len == PtrLenC) {
                 array_type = adjust_ptr_len(ira->codegen, array_type, PtrLenUnknown);
             }
-            return_type = get_slice_type(ira->codegen, array_type);
+            non_sentinel_slice_ptr_type = array_type;
             if (!end) {
                 ir_add_error(ira, &instruction->base, buf_sprintf("slice of pointer must include end value"));
                 return ira->codegen->invalid_instruction;
             }
         }
     } else if (is_slice(array_type)) {
-        ZigType *ptr_type = array_type->data.structure.fields[slice_ptr_index]->type_entry;
-        return_type = get_slice_type(ira->codegen, ptr_type);
+        non_sentinel_slice_ptr_type = array_type->data.structure.fields[slice_ptr_index]->type_entry;
+        elem_type = non_sentinel_slice_ptr_type->data.pointer.child_type;
     } else {
         ir_add_error(ira, &instruction->base,
             buf_sprintf("slice of non-array type '%s'", buf_ptr(&array_type->name)));
         return ira->codegen->invalid_instruction;
     }
 
+    ZigType *return_type;
+    ZigValue *sentinel_val = nullptr;
+    if (instruction->sentinel) {
+        IrInstruction *uncasted_sentinel = instruction->sentinel->child;
+        if (type_is_invalid(uncasted_sentinel->value->type))
+            return ira->codegen->invalid_instruction;
+        IrInstruction *sentinel = ir_implicit_cast(ira, uncasted_sentinel, elem_type);
+        if (type_is_invalid(sentinel->value->type))
+            return ira->codegen->invalid_instruction;
+        sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
+        if (sentinel_val == nullptr)
+            return ira->codegen->invalid_instruction;
+        ZigType *slice_ptr_type = adjust_ptr_sentinel(ira->codegen, non_sentinel_slice_ptr_type, sentinel_val);
+        return_type = get_slice_type(ira->codegen, slice_ptr_type);
+    } else {
+        return_type = get_slice_type(ira->codegen, non_sentinel_slice_ptr_type);
+    }
+
     if (instr_is_comptime(ptr_ptr) &&
         value_is_comptime(casted_start->value) &&
         (!end || value_is_comptime(end->value)))
diff --git a/src/parser.cpp b/src/parser.cpp
index 4b5e0e3ebb..a0c5cf794b 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -2723,7 +2723,7 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
 }
 
 // SuffixOp
-//     <- LBRACKET Expr (DOT2 Expr?)? RBRACKET
+//     <- LBRACKET Expr (DOT2 (Expr (COLON Expr)?)?)? RBRACKET
 //      / DOT IDENTIFIER
 //      / DOTASTERISK
 //      / DOTQUESTIONMARK
@@ -2733,12 +2733,17 @@ static AstNode *ast_parse_suffix_op(ParseContext *pc) {
         AstNode *start = ast_expect(pc, ast_parse_expr);
         AstNode *end = nullptr;
         if (eat_token_if(pc, TokenIdEllipsis2) != nullptr) {
+            AstNode *sentinel = nullptr;
             end = ast_parse_expr(pc);
+            if (eat_token_if(pc, TokenIdColon) != nullptr) {
+                sentinel = ast_parse_expr(pc);
+            }
             expect_token(pc, TokenIdRBracket);
 
             AstNode *res = ast_create_node(pc, NodeTypeSliceExpr, lbracket);
             res->data.slice_expr.start = start;
             res->data.slice_expr.end = end;
+            res->data.slice_expr.sentinel = sentinel;
             return res;
         }
 
@@ -3041,6 +3046,7 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
             visit_field(&node->data.slice_expr.array_ref_expr, visit, context);
             visit_field(&node->data.slice_expr.start, visit, context);
             visit_field(&node->data.slice_expr.end, visit, context);
+            visit_field(&node->data.slice_expr.sentinel, visit, context);
             break;
         case NodeTypeFieldAccessExpr:
             visit_field(&node->data.field_access_expr.struct_expr, visit, context);
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index c826d45cea..450f91b9be 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -2,6 +2,17 @@ const tests = @import("tests.zig");
 const builtin = @import("builtin");
 
 pub fn addCases(cases: *tests.CompileErrorContext) void {
+    cases.add("slice sentinel mismatch",
+        \\fn foo() [:0]u8 {
+        \\    var x: []u8 = undefined;
+        \\    return x;
+        \\}
+        \\comptime { _ = foo; }
+    , &[_][]const u8{
+        "tmp.zig:3:12: error: expected type '[:0]u8', found '[]u8'",
+        "tmp.zig:3:12: note: destination pointer requires a terminating '0' sentinel",
+    });
+
     cases.add("intToPtr with misaligned address",
         \\pub fn main() void {
         \\    var y = @intToPtr([*]align(4) u8, 5);
-- 
cgit v1.2.3


From 563d9ebfe597b313b265a5a30296c081fe35d87a Mon Sep 17 00:00:00 2001
From: LemonBoy <thatlemon@gmail.com>
Date: Mon, 23 Dec 2019 21:52:06 +0100
Subject: Implement the callconv() annotation

---
 doc/docgen.zig                                     |   1 +
 doc/langref.html.in                                |   2 +-
 lib/std/builtin.zig                                |  31 ++--
 lib/std/debug.zig                                  |   2 +-
 lib/std/fs.zig                                     |   2 +-
 lib/std/mutex.zig                                  |  27 +--
 lib/std/net.zig                                    |   6 +-
 lib/std/os/linux/arm-eabi.zig                      |   4 +-
 lib/std/os/linux/arm64.zig                         |   2 +-
 lib/std/os/linux/i386.zig                          |   4 +-
 lib/std/os/linux/mipsel.zig                        |   4 +-
 lib/std/os/linux/riscv64.zig                       |   2 +-
 lib/std/os/linux/x86_64.zig                        |   2 +-
 lib/std/os/test.zig                                |   2 +-
 .../uefi/protocols/simple_text_input_protocol.zig  |   1 -
 lib/std/os/windows/advapi32.zig                    |  10 +-
 lib/std/os/windows/bits.zig                        |   2 +-
 lib/std/os/windows/kernel32.zig                    | 200 ++++++++++-----------
 lib/std/os/windows/ntdll.zig                       |  38 ++--
 lib/std/os/windows/ole32.zig                       |   8 +-
 lib/std/os/windows/shell32.zig                     |   2 +-
 lib/std/os/windows/ws2_32.zig                      |  46 ++---
 lib/std/reset_event.zig                            |  26 ++-
 lib/std/special/c.zig                              |   2 +-
 lib/std/special/compiler_rt.zig                    |  10 +-
 lib/std/special/compiler_rt/arm/aeabi_dcmp.zig     |  10 +-
 lib/std/special/compiler_rt/arm/aeabi_fcmp.zig     |  10 +-
 lib/std/special/compiler_rt/aulldiv.zig            |   4 +-
 lib/std/special/compiler_rt/aullrem.zig            |   4 +-
 lib/std/special/compiler_rt/stack_probe.zig        |  12 +-
 lib/std/spinlock.zig                               |  12 +-
 lib/std/start.zig                                  |   8 +-
 lib/std/zig/ast.zig                                |   1 +
 lib/std/zig/parse.zig                              |  13 ++
 lib/std/zig/parser_test.zig                        |   4 +-
 lib/std/zig/render.zig                             |  25 ++-
 lib/std/zig/tokenizer.zig                          |   3 +
 src-self-hosted/translate_c.zig                    |   5 +-
 src-self-hosted/type.zig                           |   3 +-
 src/all_types.hpp                                  |  34 ++--
 src/analyze.cpp                                    | 154 ++++++++++------
 src/analyze.hpp                                    |   3 +-
 src/ast_render.cpp                                 |   5 +
 src/codegen.cpp                                    |  57 +++++-
 src/ir.cpp                                         |  57 ++++--
 src/parser.cpp                                     |  33 +++-
 src/tokenizer.cpp                                  |   2 +
 src/tokenizer.hpp                                  |   1 +
 test/compile_errors.zig                            |  30 ++--
 test/stage1/behavior/type_info.zig                 |   4 +-
 50 files changed, 572 insertions(+), 358 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/doc/docgen.zig b/doc/docgen.zig
index 83855b3b50..0218f50419 100644
--- a/doc/docgen.zig
+++ b/doc/docgen.zig
@@ -818,6 +818,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
             .Keyword_resume,
             .Keyword_return,
             .Keyword_linksection,
+            .Keyword_callconv,
             .Keyword_stdcallcc,
             .Keyword_struct,
             .Keyword_suspend,
diff --git a/doc/langref.html.in b/doc/langref.html.in
index 3be3131843..dd77bcaa63 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -2829,7 +2829,7 @@ test "@tagName" {
       <p>
       By default, enums are not guaranteed to be compatible with the C ABI:
       </p>
-      {#code_begin|obj_err|parameter of type 'Foo' not allowed in function with calling convention 'ccc'#}
+      {#code_begin|obj_err|parameter of type 'Foo' not allowed in function with calling convention 'C'#}
 const Foo = enum { A, B, C };
 export fn entry(foo: Foo) void { }
       {#code_end#}
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 687e169bbe..87b95786ec 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -91,6 +91,24 @@ pub const Mode = enum {
     ReleaseSmall,
 };
 
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const CallingConvention = enum {
+    Unspecified,
+    C,
+    Cold,
+    Naked,
+    Async,
+    Interrupt,
+    Signal,
+    Stdcall,
+    Fastcall,
+    Vectorcall,
+    APCS,
+    AAPCS,
+    AAPCSVFP,
+};
+
 pub const TypeId = @TagType(TypeInfo);
 
 /// This data structure is used by the Zig language code generation and
@@ -253,17 +271,6 @@ pub const TypeInfo = union(enum) {
         decls: []Declaration,
     };
 
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const CallingConvention = enum {
-        Unspecified,
-        C,
-        Cold,
-        Naked,
-        Stdcall,
-        Async,
-    };
-
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
     pub const FnArg = struct {
@@ -416,7 +423,7 @@ pub const CallOptions = struct {
 /// therefore must be kept in sync with the compiler implementation.
 pub const TestFn = struct {
     name: []const u8,
-    func: fn()anyerror!void,
+    func: fn () anyerror!void,
 };
 
 /// This function type is used by the Zig language code generation and
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 76685666ad..5ef25ec9fc 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -2475,7 +2475,7 @@ extern fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: *con
     os.abort();
 }
 
-stdcallcc fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) c_long {
+fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(.Stdcall) c_long {
     const exception_address = @ptrToInt(info.ExceptionRecord.ExceptionAddress);
     switch (info.ExceptionRecord.ExceptionCode) {
         windows.EXCEPTION_DATATYPE_MISALIGNMENT => panicExtra(null, exception_address, "Unaligned Memory Access", .{}),
diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index ea62086f59..deb671f0a1 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -230,7 +230,7 @@ pub const AtomicFile = struct {
             b64_fs_encoder.encode(tmp_path_slice[dirname_component_len..tmp_path_len], &rand_buf);
 
             const file = my_cwd.createFileC(
-                tmp_path_slice, 
+                tmp_path_slice,
                 .{ .mode = mode, .exclusive = true },
             ) catch |err| switch (err) {
                 error.PathAlreadyExists => continue,
diff --git a/lib/std/mutex.zig b/lib/std/mutex.zig
index a96402a31c..c13d5a2aa4 100644
--- a/lib/std/mutex.zig
+++ b/lib/std/mutex.zig
@@ -48,8 +48,8 @@ pub const Mutex = if (builtin.single_threaded)
             return self.tryAcquire() orelse @panic("deadlock detected");
         }
     }
-else if (builtin.os == .windows) 
-    // https://locklessinc.com/articles/keyed_events/
+else if (builtin.os == .windows)
+// https://locklessinc.com/articles/keyed_events/
     extern union {
         locked: u8,
         waiters: u32,
@@ -97,8 +97,8 @@ else if (builtin.os == .windows)
                         return Held{ .mutex = self };
                     }
 
-                // otherwise, try and update the waiting count.
-                // then unset the WAKE bit so that another unlocker can wake up a thread.
+                    // otherwise, try and update the waiting count.
+                    // then unset the WAKE bit so that another unlocker can wake up a thread.
                 } else if (@cmpxchgWeak(u32, &self.waiters, waiters, (waiters + WAIT) | 1, .Monotonic, .Monotonic) == null) {
                     const rc = windows.ntdll.NtWaitForKeyedEvent(handle, key, windows.FALSE, null);
                     assert(rc == 0);
@@ -118,7 +118,7 @@ else if (builtin.os == .windows)
 
                 while (true) : (SpinLock.loopHint(1)) {
                     const waiters = @atomicLoad(u32, &self.mutex.waiters, .Monotonic);
-                
+
                     // no one is waiting
                     if (waiters < WAIT) return;
                     // someone grabbed the lock and will do the wake instead
@@ -130,14 +130,14 @@ else if (builtin.os == .windows)
                     if (@cmpxchgWeak(u32, &self.mutex.waiters, waiters, waiters - WAIT + WAKE, .Release, .Monotonic) == null) {
                         const rc = windows.ntdll.NtReleaseKeyedEvent(handle, key, windows.FALSE, null);
                         assert(rc == 0);
-                        return;   
+                        return;
                     }
                 }
             }
         };
     }
 else if (builtin.link_libc or builtin.os == .linux)
-    // stack-based version of https://github.com/Amanieu/parking_lot/blob/master/core/src/word_lock.rs
+// stack-based version of https://github.com/Amanieu/parking_lot/blob/master/core/src/word_lock.rs
     struct {
         state: usize,
 
@@ -170,8 +170,8 @@ else if (builtin.link_libc or builtin.os == .linux)
 
         pub fn acquire(self: *Mutex) Held {
             return self.tryAcquire() orelse {
-               self.acquireSlow();
-               return Held{ .mutex = self };
+                self.acquireSlow();
+                return Held{ .mutex = self };
             };
         }
 
@@ -237,7 +237,7 @@ else if (builtin.link_libc or builtin.os == .linux)
 
         fn releaseSlow(self: *Mutex) void {
             @setCold(true);
-            
+
             // try and lock the LFIO queue to pop a node off,
             // stopping altogether if its already locked or the queue is empty
             var state = @atomicLoad(usize, &self.state, .Monotonic);
@@ -265,9 +265,10 @@ else if (builtin.link_libc or builtin.os == .linux)
         }
     }
 
-// for platforms without a known OS blocking
-// primitive, default to SpinLock for correctness
-else SpinLock;
+    // for platforms without a known OS blocking
+    // primitive, default to SpinLock for correctness
+else
+    SpinLock;
 
 const TestContext = struct {
     mutex: *Mutex,
diff --git a/lib/std/net.zig b/lib/std/net.zig
index d4e68b2e17..47ce95c99f 100644
--- a/lib/std/net.zig
+++ b/lib/std/net.zig
@@ -451,11 +451,7 @@ pub fn getAddressList(allocator: *mem.Allocator, name: []const u8, port: u16) !*
             .next = null,
         };
         var res: *os.addrinfo = undefined;
-        switch (os.system.getaddrinfo(
-                name_c.ptr,
-                @ptrCast([*:0]const u8, port_c.ptr),
-                &hints,
-                &res)) {
+        switch (os.system.getaddrinfo(name_c.ptr, @ptrCast([*:0]const u8, port_c.ptr), &hints, &res)) {
             0 => {},
             c.EAI_ADDRFAMILY => return error.HostLacksNetworkAddresses,
             c.EAI_AGAIN => return error.TemporaryNameServerFailure,
diff --git a/lib/std/os/linux/arm-eabi.zig b/lib/std/os/linux/arm-eabi.zig
index c457e10beb..879805696c 100644
--- a/lib/std/os/linux/arm-eabi.zig
+++ b/lib/std/os/linux/arm-eabi.zig
@@ -97,7 +97,7 @@ pub extern fn getThreadPointer() usize {
     );
 }
 
-pub nakedcc fn restore() void {
+pub fn restore() callconv(.Naked) void {
     return asm volatile ("svc #0"
         :
         : [number] "{r7}" (@as(usize, SYS_sigreturn))
@@ -105,7 +105,7 @@ pub nakedcc fn restore() void {
     );
 }
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("svc #0"
         :
         : [number] "{r7}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/arm64.zig b/lib/std/os/linux/arm64.zig
index ac2bb3bfdf..f565bea489 100644
--- a/lib/std/os/linux/arm64.zig
+++ b/lib/std/os/linux/arm64.zig
@@ -90,7 +90,7 @@ pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, a
 
 pub const restore = restore_rt;
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("svc #0"
         :
         : [number] "{x8}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/i386.zig b/lib/std/os/linux/i386.zig
index 3345f9904d..7652ece43e 100644
--- a/lib/std/os/linux/i386.zig
+++ b/lib/std/os/linux/i386.zig
@@ -102,7 +102,7 @@ pub fn socketcall(call: usize, args: [*]usize) usize {
 /// This matches the libc clone function.
 pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, arg: usize, ptid: *i32, tls: usize, ctid: *i32) usize;
 
-pub nakedcc fn restore() void {
+pub fn restore() callconv(.Naked) void {
     return asm volatile ("int $0x80"
         :
         : [number] "{eax}" (@as(usize, SYS_sigreturn))
@@ -110,7 +110,7 @@ pub nakedcc fn restore() void {
     );
 }
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("int $0x80"
         :
         : [number] "{eax}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/mipsel.zig b/lib/std/os/linux/mipsel.zig
index 60408c1e84..5193133f6c 100644
--- a/lib/std/os/linux/mipsel.zig
+++ b/lib/std/os/linux/mipsel.zig
@@ -144,7 +144,7 @@ pub fn syscall6(
 /// This matches the libc clone function.
 pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, arg: usize, ptid: *i32, tls: usize, ctid: *i32) usize;
 
-pub nakedcc fn restore() void {
+pub fn restore() callconv(.Naked) void {
     return asm volatile ("syscall"
         :
         : [number] "{$2}" (@as(usize, SYS_sigreturn))
@@ -152,7 +152,7 @@ pub nakedcc fn restore() void {
     );
 }
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("syscall"
         :
         : [number] "{$2}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig
index b7c59a9039..2259dad78e 100644
--- a/lib/std/os/linux/riscv64.zig
+++ b/lib/std/os/linux/riscv64.zig
@@ -89,7 +89,7 @@ pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, a
 
 pub const restore = restore_rt;
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("ecall"
         :
         : [number] "{x17}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig
index d037b3c6ae..d6067f9b18 100644
--- a/lib/std/os/linux/x86_64.zig
+++ b/lib/std/os/linux/x86_64.zig
@@ -90,7 +90,7 @@ pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: usize,
 
 pub const restore = restore_rt;
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("syscall"
         :
         : [number] "{rax}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/test.zig b/lib/std/os/test.zig
index 09e8c24899..877b95af1f 100644
--- a/lib/std/os/test.zig
+++ b/lib/std/os/test.zig
@@ -166,7 +166,7 @@ test "sigaltstack" {
 // analyzed
 const dl_phdr_info = if (@hasDecl(os, "dl_phdr_info")) os.dl_phdr_info else c_void;
 
-export fn iter_fn(info: *dl_phdr_info, size: usize, data: ?*usize) i32 {
+extern fn iter_fn(info: *dl_phdr_info, size: usize, data: ?*usize) i32 {
     if (builtin.os == .windows or builtin.os == .wasi or builtin.os == .macosx)
         return 0;
 
diff --git a/lib/std/os/uefi/protocols/simple_text_input_protocol.zig b/lib/std/os/uefi/protocols/simple_text_input_protocol.zig
index e1c5f6446f..b56ff728ef 100644
--- a/lib/std/os/uefi/protocols/simple_text_input_protocol.zig
+++ b/lib/std/os/uefi/protocols/simple_text_input_protocol.zig
@@ -27,4 +27,3 @@ pub const SimpleTextInputProtocol = extern struct {
         .node = [_]u8{ 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b },
     };
 };
-
diff --git a/lib/std/os/windows/advapi32.zig b/lib/std/os/windows/advapi32.zig
index 940f10994c..6364c5bddb 100644
--- a/lib/std/os/windows/advapi32.zig
+++ b/lib/std/os/windows/advapi32.zig
@@ -1,23 +1,23 @@
 usingnamespace @import("bits.zig");
 
-pub extern "advapi32" stdcallcc fn RegOpenKeyExW(
+pub extern "advapi32" fn RegOpenKeyExW(
     hKey: HKEY,
     lpSubKey: LPCWSTR,
     ulOptions: DWORD,
     samDesired: REGSAM,
     phkResult: *HKEY,
-) LSTATUS;
+) callconv(.Stdcall) LSTATUS;
 
-pub extern "advapi32" stdcallcc fn RegQueryValueExW(
+pub extern "advapi32" fn RegQueryValueExW(
     hKey: HKEY,
     lpValueName: LPCWSTR,
     lpReserved: LPDWORD,
     lpType: LPDWORD,
     lpData: LPBYTE,
     lpcbData: LPDWORD,
-) LSTATUS;
+) callconv(.Stdcall) LSTATUS;
 
 // RtlGenRandom is known as SystemFunction036 under advapi32
 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx */
-pub extern "advapi32" stdcallcc fn SystemFunction036(output: [*]u8, length: ULONG) BOOL;
+pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(.Stdcall) BOOL;
 pub const RtlGenRandom = SystemFunction036;
diff --git a/lib/std/os/windows/bits.zig b/lib/std/os/windows/bits.zig
index def987bd23..7d87ae075a 100644
--- a/lib/std/os/windows/bits.zig
+++ b/lib/std/os/windows/bits.zig
@@ -892,7 +892,7 @@ pub const EXCEPTION_POINTERS = extern struct {
     ContextRecord: *c_void,
 };
 
-pub const VECTORED_EXCEPTION_HANDLER = stdcallcc fn (ExceptionInfo: *EXCEPTION_POINTERS) c_long;
+pub const VECTORED_EXCEPTION_HANDLER = fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(.Stdcall) c_long;
 
 pub const OBJECT_ATTRIBUTES = extern struct {
     Length: ULONG,
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index 33e56abce1..1af68f4abd 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -1,22 +1,22 @@
 usingnamespace @import("bits.zig");
 
-pub extern "kernel32" stdcallcc fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) ?*c_void;
-pub extern "kernel32" stdcallcc fn RemoveVectoredExceptionHandler(Handle: HANDLE) c_ulong;
+pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(.Stdcall) ?*c_void;
+pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(.Stdcall) c_ulong;
 
-pub extern "kernel32" stdcallcc fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) BOOL;
+pub extern "kernel32" fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CloseHandle(hObject: HANDLE) BOOL;
+pub extern "kernel32" fn CloseHandle(hObject: HANDLE) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateDirectoryW(lpPathName: [*]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) BOOL;
+pub extern "kernel32" fn CreateDirectoryW(lpPathName: [*]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateEventExW(
+pub extern "kernel32" fn CreateEventExW(
     lpEventAttributes: ?*SECURITY_ATTRIBUTES,
     lpName: [*:0]const u16,
     dwFlags: DWORD,
     dwDesiredAccess: DWORD,
-) ?HANDLE;
+) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn CreateFileW(
+pub extern "kernel32" fn CreateFileW(
     lpFileName: [*]const u16, // TODO null terminated pointer type
     dwDesiredAccess: DWORD,
     dwShareMode: DWORD,
@@ -24,16 +24,16 @@ pub extern "kernel32" stdcallcc fn CreateFileW(
     dwCreationDisposition: DWORD,
     dwFlagsAndAttributes: DWORD,
     hTemplateFile: ?HANDLE,
-) HANDLE;
+) callconv(.Stdcall) HANDLE;
 
-pub extern "kernel32" stdcallcc fn CreatePipe(
+pub extern "kernel32" fn CreatePipe(
     hReadPipe: *HANDLE,
     hWritePipe: *HANDLE,
     lpPipeAttributes: *const SECURITY_ATTRIBUTES,
     nSize: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateProcessW(
+pub extern "kernel32" fn CreateProcessW(
     lpApplicationName: ?LPWSTR,
     lpCommandLine: LPWSTR,
     lpProcessAttributes: ?*SECURITY_ATTRIBUTES,
@@ -44,15 +44,15 @@ pub extern "kernel32" stdcallcc fn CreateProcessW(
     lpCurrentDirectory: ?LPWSTR,
     lpStartupInfo: *STARTUPINFOW,
     lpProcessInformation: *PROCESS_INFORMATION,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateSymbolicLinkW(lpSymlinkFileName: [*]const u16, lpTargetFileName: [*]const u16, dwFlags: DWORD) BOOLEAN;
+pub extern "kernel32" fn CreateSymbolicLinkW(lpSymlinkFileName: [*]const u16, lpTargetFileName: [*]const u16, dwFlags: DWORD) callconv(.Stdcall) BOOLEAN;
 
-pub extern "kernel32" stdcallcc fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) ?HANDLE;
+pub extern "kernel32" fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) ?HANDLE;
+pub extern "kernel32" fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn DeviceIoControl(
+pub extern "kernel32" fn DeviceIoControl(
     h: HANDLE,
     dwIoControlCode: DWORD,
     lpInBuffer: ?*const c_void,
@@ -61,107 +61,107 @@ pub extern "kernel32" stdcallcc fn DeviceIoControl(
     nOutBufferSize: DWORD,
     lpBytesReturned: ?*DWORD,
     lpOverlapped: ?*OVERLAPPED,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn DeleteFileW(lpFileName: [*]const u16) BOOL;
+pub extern "kernel32" fn DeleteFileW(lpFileName: [*]const u16) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) BOOL;
+pub extern "kernel32" fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn ExitProcess(exit_code: UINT) noreturn;
+pub extern "kernel32" fn ExitProcess(exit_code: UINT) callconv(.Stdcall) noreturn;
 
-pub extern "kernel32" stdcallcc fn FindFirstFileW(lpFileName: [*]const u16, lpFindFileData: *WIN32_FIND_DATAW) HANDLE;
-pub extern "kernel32" stdcallcc fn FindClose(hFindFile: HANDLE) BOOL;
-pub extern "kernel32" stdcallcc fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) BOOL;
+pub extern "kernel32" fn FindFirstFileW(lpFileName: [*]const u16, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) HANDLE;
+pub extern "kernel32" fn FindClose(hFindFile: HANDLE) callconv(.Stdcall) BOOL;
+pub extern "kernel32" fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: ?*va_list) DWORD;
+pub extern "kernel32" fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: ?*va_list) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn FreeEnvironmentStringsW(penv: [*]u16) BOOL;
+pub extern "kernel32" fn FreeEnvironmentStringsW(penv: [*]u16) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetCommandLineA() LPSTR;
+pub extern "kernel32" fn GetCommandLineA() callconv(.Stdcall) LPSTR;
 
-pub extern "kernel32" stdcallcc fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) BOOL;
+pub extern "kernel32" fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) BOOL;
+pub extern "kernel32" fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) DWORD;
+pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetCurrentThread() HANDLE;
-pub extern "kernel32" stdcallcc fn GetCurrentThreadId() DWORD;
+pub extern "kernel32" fn GetCurrentThread() callconv(.Stdcall) HANDLE;
+pub extern "kernel32" fn GetCurrentThreadId() callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetEnvironmentStringsW() ?[*]u16;
+pub extern "kernel32" fn GetEnvironmentStringsW() callconv(.Stdcall) ?[*]u16;
 
-pub extern "kernel32" stdcallcc fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: LPWSTR, nSize: DWORD) DWORD;
+pub extern "kernel32" fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) BOOL;
+pub extern "kernel32" fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) BOOL;
+pub extern "kernel32" fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFileAttributesW(lpFileName: [*]const WCHAR) DWORD;
+pub extern "kernel32" fn GetFileAttributesW(lpFileName: [*]const WCHAR) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) DWORD;
+pub extern "kernel32" fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetModuleHandleW(lpModuleName: ?[*]const WCHAR) HMODULE;
+pub extern "kernel32" fn GetModuleHandleW(lpModuleName: ?[*]const WCHAR) callconv(.Stdcall) HMODULE;
 
-pub extern "kernel32" stdcallcc fn GetLastError() DWORD;
+pub extern "kernel32" fn GetLastError() callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetFileInformationByHandle(
+pub extern "kernel32" fn GetFileInformationByHandle(
     hFile: HANDLE,
     lpFileInformation: *BY_HANDLE_FILE_INFORMATION,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFileInformationByHandleEx(
+pub extern "kernel32" fn GetFileInformationByHandleEx(
     in_hFile: HANDLE,
     in_FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
     out_lpFileInformation: *c_void,
     in_dwBufferSize: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFinalPathNameByHandleW(
+pub extern "kernel32" fn GetFinalPathNameByHandleW(
     hFile: HANDLE,
     lpszFilePath: [*]u16,
     cchFilePath: DWORD,
     dwFlags: DWORD,
-) DWORD;
+) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) BOOL;
+pub extern "kernel32" fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetProcessHeap() ?HANDLE;
-pub extern "kernel32" stdcallcc fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) BOOL;
+pub extern "kernel32" fn GetProcessHeap() callconv(.Stdcall) ?HANDLE;
+pub extern "kernel32" fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) void;
-pub extern "kernel32" stdcallcc fn GetSystemTimeAsFileTime(*FILETIME) void;
+pub extern "kernel32" fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) callconv(.Stdcall) void;
+pub extern "kernel32" fn GetSystemTimeAsFileTime(*FILETIME) callconv(.Stdcall) void;
 
-pub extern "kernel32" stdcallcc fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) ?HANDLE;
-pub extern "kernel32" stdcallcc fn HeapDestroy(hHeap: HANDLE) BOOL;
-pub extern "kernel32" stdcallcc fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) ?*c_void;
-pub extern "kernel32" stdcallcc fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) SIZE_T;
-pub extern "kernel32" stdcallcc fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) SIZE_T;
-pub extern "kernel32" stdcallcc fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) BOOL;
+pub extern "kernel32" fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) callconv(.Stdcall) ?HANDLE;
+pub extern "kernel32" fn HeapDestroy(hHeap: HANDLE) callconv(.Stdcall) BOOL;
+pub extern "kernel32" fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;
+pub extern "kernel32" fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) callconv(.Stdcall) SIZE_T;
+pub extern "kernel32" fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) callconv(.Stdcall) SIZE_T;
+pub extern "kernel32" fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetStdHandle(in_nStdHandle: DWORD) ?HANDLE;
+pub extern "kernel32" fn GetStdHandle(in_nStdHandle: DWORD) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) ?*c_void;
+pub extern "kernel32" fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;
 
-pub extern "kernel32" stdcallcc fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) BOOL;
+pub extern "kernel32" fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) BOOL;
+pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) ?LPVOID;
-pub extern "kernel32" stdcallcc fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) BOOL;
+pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(.Stdcall) ?LPVOID;
+pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn MoveFileExW(
+pub extern "kernel32" fn MoveFileExW(
     lpExistingFileName: [*]const u16,
     lpNewFileName: [*]const u16,
     dwFlags: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) BOOL;
+pub extern "kernel32" fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) BOOL;
+pub extern "kernel32" fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) BOOL;
+pub extern "kernel32" fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn ReadDirectoryChangesW(
+pub extern "kernel32" fn ReadDirectoryChangesW(
     hDirectory: HANDLE,
     lpBuffer: [*]align(@alignOf(FILE_NOTIFY_INFORMATION)) u8,
     nBufferLength: DWORD,
@@ -170,79 +170,79 @@ pub extern "kernel32" stdcallcc fn ReadDirectoryChangesW(
     lpBytesReturned: ?*DWORD,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn ReadFile(
+pub extern "kernel32" fn ReadFile(
     in_hFile: HANDLE,
     out_lpBuffer: [*]u8,
     in_nNumberOfBytesToRead: DWORD,
     out_lpNumberOfBytesRead: ?*DWORD,
     in_out_lpOverlapped: ?*OVERLAPPED,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn RemoveDirectoryW(lpPathName: [*]const u16) BOOL;
+pub extern "kernel32" fn RemoveDirectoryW(lpPathName: [*]const u16) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) BOOL;
+pub extern "kernel32" fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetFilePointerEx(
+pub extern "kernel32" fn SetFilePointerEx(
     in_fFile: HANDLE,
     in_liDistanceToMove: LARGE_INTEGER,
     out_opt_ldNewFilePointer: ?*LARGE_INTEGER,
     in_dwMoveMethod: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetFileTime(
+pub extern "kernel32" fn SetFileTime(
     hFile: HANDLE,
     lpCreationTime: ?*const FILETIME,
     lpLastAccessTime: ?*const FILETIME,
     lpLastWriteTime: ?*const FILETIME,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) BOOL;
+pub extern "kernel32" fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn Sleep(dwMilliseconds: DWORD) void;
+pub extern "kernel32" fn Sleep(dwMilliseconds: DWORD) callconv(.Stdcall) void;
 
-pub extern "kernel32" stdcallcc fn SwitchToThread() BOOL;
+pub extern "kernel32" fn SwitchToThread() callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) BOOL;
+pub extern "kernel32" fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn TlsAlloc() DWORD;
+pub extern "kernel32" fn TlsAlloc() callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn TlsFree(dwTlsIndex: DWORD) BOOL;
+pub extern "kernel32" fn TlsFree(dwTlsIndex: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) DWORD;
+pub extern "kernel32" fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) DWORD;
+pub extern "kernel32" fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) DWORD;
+pub extern "kernel32" fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WaitForMultipleObjectsEx(
+pub extern "kernel32" fn WaitForMultipleObjectsEx(
     nCount: DWORD,
     lpHandle: [*]const HANDLE,
     bWaitAll: BOOL,
     dwMilliseconds: DWORD,
     bAlertable: BOOL,
-) DWORD;
+) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WriteFile(
+pub extern "kernel32" fn WriteFile(
     in_hFile: HANDLE,
     in_lpBuffer: [*]const u8,
     in_nNumberOfBytesToWrite: DWORD,
     out_lpNumberOfBytesWritten: ?*DWORD,
     in_out_lpOverlapped: ?*OVERLAPPED,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) BOOL;
+pub extern "kernel32" fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn LoadLibraryW(lpLibFileName: [*]const u16) ?HMODULE;
+pub extern "kernel32" fn LoadLibraryW(lpLibFileName: [*]const u16) callconv(.Stdcall) ?HMODULE;
 
-pub extern "kernel32" stdcallcc fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) ?FARPROC;
+pub extern "kernel32" fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) callconv(.Stdcall) ?FARPROC;
 
-pub extern "kernel32" stdcallcc fn FreeLibrary(hModule: HMODULE) BOOL;
+pub extern "kernel32" fn FreeLibrary(hModule: HMODULE) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
-pub extern "kernel32" stdcallcc fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
-pub extern "kernel32" stdcallcc fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
-pub extern "kernel32" stdcallcc fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
+pub extern "kernel32" fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
+pub extern "kernel32" fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
+pub extern "kernel32" fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
+pub extern "kernel32" fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
 
-pub extern "kernel32" stdcallcc fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) BOOL;
+pub extern "kernel32" fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) callconv(.Stdcall) BOOL;
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 84de0ca946..695cd77274 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -1,14 +1,14 @@
 usingnamespace @import("bits.zig");
 
-pub extern "NtDll" stdcallcc fn RtlCaptureStackBackTrace(FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: **c_void, BackTraceHash: ?*DWORD) WORD;
-pub extern "NtDll" stdcallcc fn NtQueryInformationFile(
+pub extern "NtDll" fn RtlCaptureStackBackTrace(FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: **c_void, BackTraceHash: ?*DWORD) callconv(.Stdcall) WORD;
+pub extern "NtDll" fn NtQueryInformationFile(
     FileHandle: HANDLE,
     IoStatusBlock: *IO_STATUS_BLOCK,
     FileInformation: *c_void,
     Length: ULONG,
     FileInformationClass: FILE_INFORMATION_CLASS,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtCreateFile(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtCreateFile(
     FileHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
     ObjectAttributes: *OBJECT_ATTRIBUTES,
@@ -20,8 +20,8 @@ pub extern "NtDll" stdcallcc fn NtCreateFile(
     CreateOptions: ULONG,
     EaBuffer: ?*c_void,
     EaLength: ULONG,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtDeviceIoControlFile(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtDeviceIoControlFile(
     FileHandle: HANDLE,
     Event: ?HANDLE,
     ApcRoutine: ?IO_APC_ROUTINE,
@@ -32,17 +32,17 @@ pub extern "NtDll" stdcallcc fn NtDeviceIoControlFile(
     InputBufferLength: ULONG,
     OutputBuffer: ?PVOID,
     OutputBufferLength: ULONG,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtClose(Handle: HANDLE) NTSTATUS;
-pub extern "NtDll" stdcallcc fn RtlDosPathNameToNtPathName_U(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtClose(Handle: HANDLE) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn RtlDosPathNameToNtPathName_U(
     DosPathName: [*]const u16,
     NtPathName: *UNICODE_STRING,
     NtFileNamePart: ?*?[*]const u16,
     DirectoryInfo: ?*CURDIR,
-) BOOL;
-pub extern "NtDll" stdcallcc fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) void;
+) callconv(.Stdcall) BOOL;
+pub extern "NtDll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(.Stdcall) void;
 
-pub extern "NtDll" stdcallcc fn NtQueryDirectoryFile(
+pub extern "NtDll" fn NtQueryDirectoryFile(
     FileHandle: HANDLE,
     Event: ?HANDLE,
     ApcRoutine: ?IO_APC_ROUTINE,
@@ -54,22 +54,22 @@ pub extern "NtDll" stdcallcc fn NtQueryDirectoryFile(
     ReturnSingleEntry: BOOLEAN,
     FileName: ?*UNICODE_STRING,
     RestartScan: BOOLEAN,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtCreateKeyedEvent(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtCreateKeyedEvent(
     KeyedEventHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
     ObjectAttributes: ?PVOID,
     Flags: ULONG,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtReleaseKeyedEvent(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtReleaseKeyedEvent(
     EventHandle: HANDLE,
     Key: *const c_void,
     Alertable: BOOLEAN,
     Timeout: ?*LARGE_INTEGER,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtWaitForKeyedEvent(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtWaitForKeyedEvent(
     EventHandle: HANDLE,
     Key: *const c_void,
     Alertable: BOOLEAN,
     Timeout: ?*LARGE_INTEGER,
-) NTSTATUS;
+) callconv(.Stdcall) NTSTATUS;
diff --git a/lib/std/os/windows/ole32.zig b/lib/std/os/windows/ole32.zig
index 39c12d074c..a472089078 100644
--- a/lib/std/os/windows/ole32.zig
+++ b/lib/std/os/windows/ole32.zig
@@ -1,6 +1,6 @@
 usingnamespace @import("bits.zig");
 
-pub extern "ole32" stdcallcc fn CoTaskMemFree(pv: LPVOID) void;
-pub extern "ole32" stdcallcc fn CoUninitialize() void;
-pub extern "ole32" stdcallcc fn CoGetCurrentProcess() DWORD;
-pub extern "ole32" stdcallcc fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) HRESULT;
+pub extern "ole32" fn CoTaskMemFree(pv: LPVOID) callconv(.Stdcall) void;
+pub extern "ole32" fn CoUninitialize() callconv(.Stdcall) void;
+pub extern "ole32" fn CoGetCurrentProcess() callconv(.Stdcall) DWORD;
+pub extern "ole32" fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) callconv(.Stdcall) HRESULT;
diff --git a/lib/std/os/windows/shell32.zig b/lib/std/os/windows/shell32.zig
index c178997aad..aa1667d01d 100644
--- a/lib/std/os/windows/shell32.zig
+++ b/lib/std/os/windows/shell32.zig
@@ -1,3 +1,3 @@
 usingnamespace @import("bits.zig");
 
-pub extern "shell32" stdcallcc fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*]WCHAR) HRESULT;
+pub extern "shell32" fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*]WCHAR) callconv(.Stdcall) HRESULT;
diff --git a/lib/std/os/windows/ws2_32.zig b/lib/std/os/windows/ws2_32.zig
index c3dece2909..70cb62ac51 100644
--- a/lib/std/os/windows/ws2_32.zig
+++ b/lib/std/os/windows/ws2_32.zig
@@ -315,30 +315,30 @@ const IOC_WS2 = 0x08000000;
 
 pub const SIO_BASE_HANDLE = IOC_OUT | IOC_WS2 | 34;
 
-pub extern "ws2_32" stdcallcc fn WSAStartup(
+pub extern "ws2_32" fn WSAStartup(
     wVersionRequired: WORD,
     lpWSAData: *WSADATA,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSACleanup() c_int;
-pub extern "ws2_32" stdcallcc fn WSAGetLastError() c_int;
-pub extern "ws2_32" stdcallcc fn WSASocketA(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSACleanup() callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSAGetLastError() callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSASocketA(
     af: c_int,
     type: c_int,
     protocol: c_int,
     lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
     g: GROUP,
     dwFlags: DWORD,
-) SOCKET;
-pub extern "ws2_32" stdcallcc fn WSASocketW(
+) callconv(.Stdcall) SOCKET;
+pub extern "ws2_32" fn WSASocketW(
     af: c_int,
     type: c_int,
     protocol: c_int,
     lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
     g: GROUP,
     dwFlags: DWORD,
-) SOCKET;
-pub extern "ws2_32" stdcallcc fn closesocket(s: SOCKET) c_int;
-pub extern "ws2_32" stdcallcc fn WSAIoctl(
+) callconv(.Stdcall) SOCKET;
+pub extern "ws2_32" fn closesocket(s: SOCKET) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSAIoctl(
     s: SOCKET,
     dwIoControlCode: DWORD,
     lpvInBuffer: ?*const c_void,
@@ -348,18 +348,18 @@ pub extern "ws2_32" stdcallcc fn WSAIoctl(
     lpcbBytesReturned: LPDWORD,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn accept(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn accept(
     s: SOCKET,
     addr: ?*sockaddr,
     addrlen: socklen_t,
-) SOCKET;
-pub extern "ws2_32" stdcallcc fn connect(
+) callconv(.Stdcall) SOCKET;
+pub extern "ws2_32" fn connect(
     s: SOCKET,
     name: *const sockaddr,
     namelen: socklen_t,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSARecv(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSARecv(
     s: SOCKET,
     lpBuffers: [*]const WSABUF,
     dwBufferCount: DWORD,
@@ -367,8 +367,8 @@ pub extern "ws2_32" stdcallcc fn WSARecv(
     lpFlags: *DWORD,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSARecvFrom(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSARecvFrom(
     s: SOCKET,
     lpBuffers: [*]const WSABUF,
     dwBufferCount: DWORD,
@@ -378,8 +378,8 @@ pub extern "ws2_32" stdcallcc fn WSARecvFrom(
     lpFromlen: socklen_t,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSASend(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSASend(
     s: SOCKET,
     lpBuffers: [*]WSABUF,
     dwBufferCount: DWORD,
@@ -387,8 +387,8 @@ pub extern "ws2_32" stdcallcc fn WSASend(
     dwFlags: DWORD,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSASendTo(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSASendTo(
     s: SOCKET,
     lpBuffers: [*]WSABUF,
     dwBufferCount: DWORD,
@@ -398,4 +398,4 @@ pub extern "ws2_32" stdcallcc fn WSASendTo(
     iTolen: socklen_t,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
+) callconv(.Stdcall) c_int;
diff --git a/lib/std/reset_event.zig b/lib/std/reset_event.zig
index 86bc5ba5aa..b9d9517c6d 100644
--- a/lib/std/reset_event.zig
+++ b/lib/std/reset_event.zig
@@ -14,13 +14,12 @@ const windows = os.windows;
 pub const ResetEvent = struct {
     os_event: OsEvent,
 
-    pub const OsEvent = 
-        if (builtin.single_threaded)
-            DebugEvent
-        else if (builtin.link_libc and builtin.os != .windows and builtin.os != .linux)
-            PosixEvent
-        else
-            AtomicEvent;
+    pub const OsEvent = if (builtin.single_threaded)
+        DebugEvent
+    else if (builtin.link_libc and builtin.os != .windows and builtin.os != .linux)
+        PosixEvent
+    else
+        AtomicEvent;
 
     pub fn init() ResetEvent {
         return ResetEvent{ .os_event = OsEvent.init() };
@@ -105,7 +104,7 @@ const PosixEvent = struct {
     }
 
     fn deinit(self: *PosixEvent) void {
-        // on dragonfly, *destroy() functions can return EINVAL 
+        // on dragonfly, *destroy() functions can return EINVAL
         // for statically initialized pthread structures
         const err = if (builtin.os == .dragonfly) os.EINVAL else 0;
 
@@ -212,8 +211,7 @@ const AtomicEvent = struct {
     fn wait(self: *AtomicEvent, timeout: ?u64) !void {
         var waiters = @atomicLoad(u32, &self.waiters, .Acquire);
         while (waiters != WAKE) {
-            waiters = @cmpxchgWeak(u32, &self.waiters, waiters, waiters + WAIT, .Acquire, .Acquire)
-                orelse return Futex.wait(&self.waiters, timeout);
+            waiters = @cmpxchgWeak(u32, &self.waiters, waiters, waiters + WAIT, .Acquire, .Acquire) orelse return Futex.wait(&self.waiters, timeout);
         }
     }
 
@@ -281,7 +279,7 @@ const AtomicEvent = struct {
         pub fn wake(waiters: *u32, wake_count: u32) void {
             const handle = getEventHandle() orelse return SpinFutex.wake(waiters, wake_count);
             const key = @ptrCast(*const c_void, waiters);
-            
+
             var waiting = wake_count;
             while (waiting != 0) : (waiting -= 1) {
                 const rc = windows.ntdll.NtReleaseKeyedEvent(handle, key, windows.FALSE, null);
@@ -408,7 +406,7 @@ test "std.ResetEvent" {
             // wait for receiver to update value and signal output
             self.out.wait();
             testing.expect(self.value == 2);
-            
+
             // update value and signal final input
             self.value = 3;
             self.in.set();
@@ -418,12 +416,12 @@ test "std.ResetEvent" {
             // wait for sender to update value and signal input
             self.in.wait();
             assert(self.value == 1);
-            
+
             // update value and signal output
             self.in.reset();
             self.value = 2;
             self.out.set();
-            
+
             // wait for sender to update value and signal final input
             self.in.wait();
             assert(self.value == 3);
diff --git a/lib/std/special/c.zig b/lib/std/special/c.zig
index 0895b1e6f9..c0ee9a938e 100644
--- a/lib/std/special/c.zig
+++ b/lib/std/special/c.zig
@@ -195,7 +195,7 @@ extern fn __stack_chk_fail() noreturn {
 // TODO we should be able to put this directly in std/linux/x86_64.zig but
 // it causes a segfault in release mode. this is a workaround of calling it
 // across .o file boundaries. fix comptime @ptrCast of nakedcc functions.
-nakedcc fn clone() void {
+fn clone() callconv(.Naked) void {
     switch (builtin.arch) {
         .i386 => {
             // __clone(func, stack, flags, arg, ptid, tls, ctid)
diff --git a/lib/std/special/compiler_rt.zig b/lib/std/special/compiler_rt.zig
index 0426f72417..f821918ccc 100644
--- a/lib/std/special/compiler_rt.zig
+++ b/lib/std/special/compiler_rt.zig
@@ -528,7 +528,7 @@ fn usesThumb1PreArmv6(arch: builtin.Arch) bool {
     };
 }
 
-nakedcc fn __aeabi_memcpy() noreturn {
+fn __aeabi_memcpy() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     if (use_thumb_1) {
         asm volatile (
@@ -544,7 +544,7 @@ nakedcc fn __aeabi_memcpy() noreturn {
     unreachable;
 }
 
-nakedcc fn __aeabi_memmove() noreturn {
+fn __aeabi_memmove() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     if (use_thumb_1) {
         asm volatile (
@@ -560,7 +560,7 @@ nakedcc fn __aeabi_memmove() noreturn {
     unreachable;
 }
 
-nakedcc fn __aeabi_memset() noreturn {
+fn __aeabi_memset() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     if (use_thumb_1_pre_armv6) {
         asm volatile (
@@ -591,7 +591,7 @@ nakedcc fn __aeabi_memset() noreturn {
     unreachable;
 }
 
-nakedcc fn __aeabi_memclr() noreturn {
+fn __aeabi_memclr() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     if (use_thumb_1_pre_armv6) {
         asm volatile (
@@ -619,7 +619,7 @@ nakedcc fn __aeabi_memclr() noreturn {
     unreachable;
 }
 
-nakedcc fn __aeabi_memcmp() noreturn {
+fn __aeabi_memcmp() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     if (use_thumb_1) {
         asm volatile (
diff --git a/lib/std/special/compiler_rt/arm/aeabi_dcmp.zig b/lib/std/special/compiler_rt/arm/aeabi_dcmp.zig
index 7463c49931..d75c343fbb 100644
--- a/lib/std/special/compiler_rt/arm/aeabi_dcmp.zig
+++ b/lib/std/special/compiler_rt/arm/aeabi_dcmp.zig
@@ -12,31 +12,31 @@ const ConditionalOperator = enum {
     Gt,
 };
 
-pub nakedcc fn __aeabi_dcmpeq() noreturn {
+pub fn __aeabi_dcmpeq() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_dcmp, .{.Eq});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_dcmplt() noreturn {
+pub fn __aeabi_dcmplt() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_dcmp, .{.Lt});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_dcmple() noreturn {
+pub fn __aeabi_dcmple() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_dcmp, .{.Le});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_dcmpge() noreturn {
+pub fn __aeabi_dcmpge() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_dcmp, .{.Ge});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_dcmpgt() noreturn {
+pub fn __aeabi_dcmpgt() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_dcmp, .{.Gt});
     unreachable;
diff --git a/lib/std/special/compiler_rt/arm/aeabi_fcmp.zig b/lib/std/special/compiler_rt/arm/aeabi_fcmp.zig
index 9a24641d9a..bf36e78ad2 100644
--- a/lib/std/special/compiler_rt/arm/aeabi_fcmp.zig
+++ b/lib/std/special/compiler_rt/arm/aeabi_fcmp.zig
@@ -12,31 +12,31 @@ const ConditionalOperator = enum {
     Gt,
 };
 
-pub nakedcc fn __aeabi_fcmpeq() noreturn {
+pub fn __aeabi_fcmpeq() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_fcmp, .{.Eq});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_fcmplt() noreturn {
+pub fn __aeabi_fcmplt() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_fcmp, .{.Lt});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_fcmple() noreturn {
+pub fn __aeabi_fcmple() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_fcmp, .{.Le});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_fcmpge() noreturn {
+pub fn __aeabi_fcmpge() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_fcmp, .{.Ge});
     unreachable;
 }
 
-pub nakedcc fn __aeabi_fcmpgt() noreturn {
+pub fn __aeabi_fcmpgt() callconv(.Naked) noreturn {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, aeabi_fcmp, .{.Gt});
     unreachable;
diff --git a/lib/std/special/compiler_rt/aulldiv.zig b/lib/std/special/compiler_rt/aulldiv.zig
index dfca4f4c43..afc96492c1 100644
--- a/lib/std/special/compiler_rt/aulldiv.zig
+++ b/lib/std/special/compiler_rt/aulldiv.zig
@@ -1,6 +1,6 @@
 const builtin = @import("builtin");
 
-pub extern stdcallcc fn _alldiv(a: i64, b: i64) i64 {
+pub extern fn _alldiv(a: i64, b: i64) callconv(.Stdcall) i64 {
     @setRuntimeSafety(builtin.is_test);
     const s_a = a >> (i64.bit_count - 1);
     const s_b = b >> (i64.bit_count - 1);
@@ -13,7 +13,7 @@ pub extern stdcallcc fn _alldiv(a: i64, b: i64) i64 {
     return (@bitCast(i64, r) ^ s) -% s;
 }
 
-pub nakedcc fn _aulldiv() void {
+pub fn _aulldiv() callconv(.Naked) void {
     @setRuntimeSafety(false);
 
     // The stack layout is:
diff --git a/lib/std/special/compiler_rt/aullrem.zig b/lib/std/special/compiler_rt/aullrem.zig
index c1fee72032..748aaa0f89 100644
--- a/lib/std/special/compiler_rt/aullrem.zig
+++ b/lib/std/special/compiler_rt/aullrem.zig
@@ -1,6 +1,6 @@
 const builtin = @import("builtin");
 
-pub extern stdcallcc fn _allrem(a: i64, b: i64) i64 {
+pub extern fn _allrem(a: i64, b: i64) callconv(.Stdcall) i64 {
     @setRuntimeSafety(builtin.is_test);
     const s_a = a >> (i64.bit_count - 1);
     const s_b = b >> (i64.bit_count - 1);
@@ -13,7 +13,7 @@ pub extern stdcallcc fn _allrem(a: i64, b: i64) i64 {
     return (@bitCast(i64, r) ^ s) -% s;
 }
 
-pub nakedcc fn _aullrem() void {
+pub fn _aullrem() callconv(.Naked) void {
     @setRuntimeSafety(false);
 
     // The stack layout is:
diff --git a/lib/std/special/compiler_rt/stack_probe.zig b/lib/std/special/compiler_rt/stack_probe.zig
index 6406f3977a..dd441b2f32 100644
--- a/lib/std/special/compiler_rt/stack_probe.zig
+++ b/lib/std/special/compiler_rt/stack_probe.zig
@@ -1,7 +1,7 @@
 const builtin = @import("builtin");
 
 // Zig's own stack-probe routine (available only on x86 and x86_64)
-pub nakedcc fn zig_probe_stack() void {
+pub fn zig_probe_stack() callconv(.Naked) void {
     @setRuntimeSafety(false);
 
     // Versions of the Linux kernel before 5.1 treat any access below SP as
@@ -180,11 +180,11 @@ fn win_probe_stack_adjust_sp() void {
 // ___chkstk (__alloca) | yes    | yes    |
 // ___chkstk_ms         | no     | no     |
 
-pub nakedcc fn _chkstk() void {
+pub fn _chkstk() callconv(.Naked) void {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{});
 }
-pub nakedcc fn __chkstk() void {
+pub fn __chkstk() callconv(.Naked) void {
     @setRuntimeSafety(false);
     switch (builtin.arch) {
         .i386 => @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{}),
@@ -192,15 +192,15 @@ pub nakedcc fn __chkstk() void {
         else => unreachable,
     }
 }
-pub nakedcc fn ___chkstk() void {
+pub fn ___chkstk() callconv(.Naked) void {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{});
 }
-pub nakedcc fn __chkstk_ms() void {
+pub fn __chkstk_ms() callconv(.Naked) void {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{});
 }
-pub nakedcc fn ___chkstk_ms() void {
+pub fn ___chkstk_ms() callconv(.Naked) void {
     @setRuntimeSafety(false);
     @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{});
 }
diff --git a/lib/std/spinlock.zig b/lib/std/spinlock.zig
index 4efd244367..1a3239a95c 100644
--- a/lib/std/spinlock.zig
+++ b/lib/std/spinlock.zig
@@ -60,8 +60,16 @@ pub const SpinLock = struct {
             switch (builtin.arch) {
                 // these instructions use a memory clobber as they
                 // flush the pipeline of any speculated reads/writes.
-                .i386, .x86_64 => asm volatile ("pause" ::: "memory"),
-                .arm, .aarch64 => asm volatile ("yield" ::: "memory"),
+                .i386, .x86_64 => asm volatile ("pause"
+                    :
+                    :
+                    : "memory"
+                ),
+                .arm, .aarch64 => asm volatile ("yield"
+                    :
+                    :
+                    : "memory"
+                ),
                 else => std.os.sched_yield() catch {},
             }
         }
diff --git a/lib/std/start.zig b/lib/std/start.zig
index 3c46449949..a919107266 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -43,11 +43,11 @@ comptime {
     }
 }
 
-stdcallcc fn _DllMainCRTStartup(
+fn _DllMainCRTStartup(
     hinstDLL: std.os.windows.HINSTANCE,
     fdwReason: std.os.windows.DWORD,
     lpReserved: std.os.windows.LPVOID,
-) std.os.windows.BOOL {
+) callconv(.Stdcall) std.os.windows.BOOL {
     if (@hasDecl(root, "DllMain")) {
         return root.DllMain(hinstDLL, fdwReason, lpReserved);
     }
@@ -84,7 +84,7 @@ extern fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) u
     }
 }
 
-nakedcc fn _start() noreturn {
+fn _start() callconv(.Naked) noreturn {
     if (builtin.os == builtin.Os.wasi) {
         // This is marked inline because for some reason LLVM in release mode fails to inline it,
         // and we want fewer call frames in stack traces.
@@ -127,7 +127,7 @@ nakedcc fn _start() noreturn {
     @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
 }
 
-stdcallcc fn WinMainCRTStartup() noreturn {
+fn WinMainCRTStartup() callconv(.Stdcall) noreturn {
     @setAlignStack(16);
     if (!builtin.single_threaded) {
         _ = @import("start_windows_tls.zig");
diff --git a/lib/std/zig/ast.zig b/lib/std/zig/ast.zig
index adbcef165e..b921213f0c 100644
--- a/lib/std/zig/ast.zig
+++ b/lib/std/zig/ast.zig
@@ -860,6 +860,7 @@ pub const Node = struct {
         lib_name: ?*Node, // populated if this is an extern declaration
         align_expr: ?*Node, // populated if align(A) is present
         section_expr: ?*Node, // populated if linksection(A) is present
+        callconv_expr: ?*Node, // populated if callconv(A) is present
 
         pub const ParamList = SegmentedList(*Node, 2);
 
diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 14d5a0a400..c9c9956159 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -311,6 +311,7 @@ fn parseFnProto(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     const rparen = try expectToken(it, tree, .RParen);
     const align_expr = try parseByteAlign(arena, it, tree);
     const section_expr = try parseLinkSection(arena, it, tree);
+    const callconv_expr = try parseCallconv(arena, it, tree);
     const exclamation_token = eatToken(it, .Bang);
 
     const return_type_expr = (try parseVarType(arena, it, tree)) orelse
@@ -347,6 +348,7 @@ fn parseFnProto(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
         .lib_name = null,
         .align_expr = align_expr,
         .section_expr = section_expr,
+        .callconv_expr = callconv_expr,
     };
 
     if (cc) |kind| {
@@ -1678,6 +1680,17 @@ fn parseLinkSection(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
     return expr_node;
 }
 
+/// CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
+fn parseCallconv(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
+    _ = eatToken(it, .Keyword_callconv) orelse return null;
+    _ = try expectToken(it, tree, .LParen);
+    const expr_node = try expectNode(arena, it, tree, parseExpr, AstError{
+        .ExpectedExpr = AstError.ExpectedExpr{ .token = it.index },
+    });
+    _ = try expectToken(it, tree, .RParen);
+    return expr_node;
+}
+
 /// FnCC
 ///     <- KEYWORD_nakedcc
 ///      / KEYWORD_stdcallcc
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index f193e1b6ef..4ab7dd4ce1 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -219,7 +219,7 @@ test "zig fmt: threadlocal" {
 test "zig fmt: linksection" {
     try testCanonical(
         \\export var aoeu: u64 linksection(".text.derp") = 1234;
-        \\export nakedcc fn _start() linksection(".text.boot") noreturn {}
+        \\export fn _start() linksection(".text.boot") callconv(.Naked) noreturn {}
         \\
     );
 }
@@ -2311,7 +2311,7 @@ test "zig fmt: fn type" {
         \\
         \\const a: fn (u8) u8 = undefined;
         \\const b: extern fn (u8) u8 = undefined;
-        \\const c: nakedcc fn (u8) u8 = undefined;
+        \\const c: fn (u8) callconv(.Naked) u8 = undefined;
         \\const ap: fn (u8) u8 = a;
         \\
     );
diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig
index 6e1ee4a601..2c89ba35e9 100644
--- a/lib/std/zig/render.zig
+++ b/lib/std/zig/render.zig
@@ -1295,8 +1295,16 @@ fn renderExpression(
                 try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space);
             }
 
+            // Some extra machinery is needed to rewrite the old-style cc
+            // notation to the new callconv one
+            var cc_rewrite_str: ?[*:0]const u8 = null;
             if (fn_proto.cc_token) |cc_token| {
-                try renderToken(tree, stream, cc_token, indent, start_col, Space.Space); // stdcallcc
+                var str = tree.tokenSlicePtr(tree.tokens.at(cc_token));
+                if (mem.eql(u8, str, "stdcallcc")) {
+                    cc_rewrite_str = ".Stdcall";
+                } else if (mem.eql(u8, str, "nakedcc")) {
+                    cc_rewrite_str = ".Naked";
+                } else try renderToken(tree, stream, cc_token, indent, start_col, Space.Space); // stdcallcc
             }
 
             const lparen = if (fn_proto.name_token) |name_token| blk: {
@@ -1368,6 +1376,21 @@ fn renderExpression(
                 try renderToken(tree, stream, section_rparen, indent, start_col, Space.Space); // )
             }
 
+            if (fn_proto.callconv_expr) |callconv_expr| {
+                const section_rparen = tree.nextToken(callconv_expr.lastToken());
+                const section_lparen = tree.prevToken(callconv_expr.firstToken());
+                const section_kw = tree.prevToken(section_lparen);
+
+                try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // section
+                try renderToken(tree, stream, section_lparen, indent, start_col, Space.None); // (
+                try renderExpression(allocator, stream, tree, indent, start_col, callconv_expr, Space.None);
+                try renderToken(tree, stream, section_rparen, indent, start_col, Space.Space); // )
+            } else if (cc_rewrite_str) |str| {
+                try stream.write("callconv(");
+                try stream.write(mem.toSliceConst(u8, str));
+                try stream.write(") ");
+            }
+
             switch (fn_proto.return_type) {
                 ast.Node.FnProto.ReturnType.Explicit => |node| {
                     return renderExpression(allocator, stream, tree, indent, start_col, node, space);
diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index d95fb47d41..327700f591 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -30,6 +30,7 @@ pub const Token = struct {
         Keyword.init("async", .Keyword_async),
         Keyword.init("await", .Keyword_await),
         Keyword.init("break", .Keyword_break),
+        Keyword.init("callconv", .Keyword_callconv),
         Keyword.init("catch", .Keyword_catch),
         Keyword.init("comptime", .Keyword_comptime),
         Keyword.init("const", .Keyword_const),
@@ -162,6 +163,7 @@ pub const Token = struct {
         Keyword_async,
         Keyword_await,
         Keyword_break,
+        Keyword_callconv,
         Keyword_catch,
         Keyword_comptime,
         Keyword_const,
@@ -286,6 +288,7 @@ pub const Token = struct {
                 .Keyword_async => "async",
                 .Keyword_await => "await",
                 .Keyword_break => "break",
+                .Keyword_callconv => "callconv",
                 .Keyword_catch => "catch",
                 .Keyword_comptime => "comptime",
                 .Keyword_const => "const",
diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig
index b49989732e..8bb28284a3 100644
--- a/src-self-hosted/translate_c.zig
+++ b/src-self-hosted/translate_c.zig
@@ -11,7 +11,7 @@ const CToken = ctok.CToken;
 const mem = std.mem;
 const math = std.math;
 
-const CallingConvention = std.builtin.TypeInfo.CallingConvention;
+const CallingConvention = std.builtin.CallingConvention;
 
 pub const ClangErrMsg = Stage2ErrorMsg;
 
@@ -3529,6 +3529,7 @@ fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_a
         .lib_name = null,
         .align_expr = null,
         .section_expr = null,
+        .callconv_expr = null,
     };
 
     const block = try transCreateNodeBlock(c, null);
@@ -4135,6 +4136,7 @@ fn finishTransFnProto(
         .lib_name = null,
         .align_expr = null,
         .section_expr = null,
+        .callconv_expr = null,
     };
     return fn_proto;
 }
@@ -4483,6 +4485,7 @@ fn transMacroFnDefine(c: *Context, it: *ctok.TokenList.Iterator, name: []const u
         .lib_name = null,
         .align_expr = null,
         .section_expr = null,
+        .callconv_expr = null,
     };
 
     const block = try transCreateNodeBlock(c, null);
diff --git a/src-self-hosted/type.zig b/src-self-hosted/type.zig
index d3f3ba746a..d4ffc355c0 100644
--- a/src-self-hosted/type.zig
+++ b/src-self-hosted/type.zig
@@ -337,7 +337,7 @@ pub const Type = struct {
             }
         };
 
-        const CallingConvention = builtin.TypeInfo.CallingConvention;
+        const CallingConvention = builtin.CallingConvention;
 
         pub const Param = struct {
             is_noalias: bool,
@@ -352,6 +352,7 @@ pub const Type = struct {
                 .Naked => "nakedcc ",
                 .Stdcall => "stdcallcc ",
                 .Async => "async ",
+                else => unreachable,
             };
         }
 
diff --git a/src/all_types.hpp b/src/all_types.hpp
index ea46ab81a6..b2c3712f50 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -57,6 +57,22 @@ enum PtrLen {
     PtrLenC,
 };
 
+enum CallingConvention {
+    CallingConventionUnspecified,
+    CallingConventionC,
+    CallingConventionCold,
+    CallingConventionNaked,
+    CallingConventionAsync,
+    CallingConventionInterrupt,
+    CallingConventionSignal,
+    CallingConventionStdcall,
+    CallingConventionFastcall,
+    CallingConventionVectorcall,
+    CallingConventionAPCS,
+    CallingConventionAAPCS,
+    CallingConventionAAPCSVFP,
+};
+
 // This one corresponds to the builtin.zig enum.
 enum BuiltinPtrSize {
     BuiltinPtrSizeOne,
@@ -398,6 +414,7 @@ struct LazyValueFnType {
     IrInstruction *align_inst; // can be null
     IrInstruction *return_type;
 
+    CallingConvention cc;
     bool is_generic;
 };
 
@@ -612,15 +629,6 @@ enum NodeType {
     NodeTypeVarFieldType,
 };
 
-enum CallingConvention {
-    CallingConventionUnspecified,
-    CallingConventionC,
-    CallingConventionCold,
-    CallingConventionNaked,
-    CallingConventionStdcall,
-    CallingConventionAsync,
-};
-
 enum FnInline {
     FnInlineAuto,
     FnInlineAlways,
@@ -639,10 +647,14 @@ struct AstNodeFnProto {
     AstNode *align_expr;
     // populated if the "section(S)" is present
     AstNode *section_expr;
+    // populated if the "callconv(S)" is present
+    AstNode *callconv_expr;
     Buf doc_comments;
 
     FnInline fn_inline;
-    CallingConvention cc;
+    bool is_nakedcc;
+    bool is_stdcallcc;
+    bool is_async;
 
     VisibMod visib_mod;
     bool auto_err_set;
@@ -1597,6 +1609,7 @@ struct ZigFn {
     Buf **param_names;
     IrInstruction *err_code_spill;
     AstNode *assumed_non_async;
+    CallingConvention cc;
 
     AstNode *fn_no_inline_set_node;
     AstNode *fn_static_eval_set_node;
@@ -3549,6 +3562,7 @@ struct IrInstructionFnProto {
 
     IrInstruction **param_types;
     IrInstruction *align_value;
+    IrInstruction *callconv_value;
     IrInstruction *return_type;
     bool is_var_args;
 };
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 8be25b7592..7e672e1936 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -919,24 +919,19 @@ ZigType *get_bound_fn_type(CodeGen *g, ZigFn *fn_entry) {
 
 const char *calling_convention_name(CallingConvention cc) {
     switch (cc) {
-        case CallingConventionUnspecified: return "undefined";
-        case CallingConventionC: return "ccc";
-        case CallingConventionCold: return "coldcc";
-        case CallingConventionNaked: return "nakedcc";
-        case CallingConventionStdcall: return "stdcallcc";
-        case CallingConventionAsync: return "async";
-    }
-    zig_unreachable();
-}
-
-static const char *calling_convention_fn_type_str(CallingConvention cc) {
-    switch (cc) {
-        case CallingConventionUnspecified: return "";
-        case CallingConventionC: return "extern ";
-        case CallingConventionCold: return "coldcc ";
-        case CallingConventionNaked: return "nakedcc ";
-        case CallingConventionStdcall: return "stdcallcc ";
-        case CallingConventionAsync: return "async ";
+        case CallingConventionUnspecified: return "Unspecified";
+        case CallingConventionC: return "C";
+        case CallingConventionCold: return "Cold";
+        case CallingConventionNaked: return "Naked";
+        case CallingConventionAsync: return "Async";
+        case CallingConventionInterrupt: return "Interrupt";
+        case CallingConventionSignal: return "Signal";
+        case CallingConventionStdcall: return "Stdcall";
+        case CallingConventionFastcall: return "Fastcall";
+        case CallingConventionVectorcall: return "Vectorcall";
+        case CallingConventionAPCS: return "Apcs";
+        case CallingConventionAAPCS: return "Aapcs";
+        case CallingConventionAAPCSVFP: return "Aapcsvfp";
     }
     zig_unreachable();
 }
@@ -949,7 +944,14 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {
         case CallingConventionC:
         case CallingConventionCold:
         case CallingConventionNaked:
+        case CallingConventionInterrupt:
+        case CallingConventionSignal:
         case CallingConventionStdcall:
+        case CallingConventionFastcall:
+        case CallingConventionVectorcall:
+        case CallingConventionAPCS:
+        case CallingConventionAAPCS:
+        case CallingConventionAAPCSVFP:
             return false;
     }
     zig_unreachable();
@@ -1006,8 +1008,8 @@ ZigType *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
 
     // populate the name of the type
     buf_resize(&fn_type->name, 0);
-    const char *cc_str = calling_convention_fn_type_str(fn_type->data.fn.fn_type_id.cc);
-    buf_appendf(&fn_type->name, "%s", cc_str);
+    if (fn_type->data.fn.fn_type_id.cc == CallingConventionC)
+        buf_append_str(&fn_type->name, "extern ");
     buf_appendf(&fn_type->name, "fn(");
     for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
         FnTypeParamInfo *param_info = &fn_type_id->param_info[i];
@@ -1026,6 +1028,9 @@ ZigType *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
     if (fn_type_id->alignment != 0) {
         buf_appendf(&fn_type->name, " align(%" PRIu32 ")", fn_type_id->alignment);
     }
+    if (fn_type_id->cc != CallingConventionUnspecified && fn_type_id->cc != CallingConventionC) {
+        buf_appendf(&fn_type->name, " callconv(%s)", calling_convention_name(fn_type_id->cc));
+    }
     buf_appendf(&fn_type->name, " %s", buf_ptr(&fn_type_id->return_type->name));
 
     // The fn_type is a pointer; not to be confused with the raw function type.
@@ -1442,8 +1447,8 @@ ZigType *analyze_type_expr(CodeGen *g, Scope *scope, AstNode *node) {
 ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
     ZigType *fn_type = new_type_table_entry(ZigTypeIdFn);
     buf_resize(&fn_type->name, 0);
-    const char *cc_str = calling_convention_fn_type_str(fn_type->data.fn.fn_type_id.cc);
-    buf_appendf(&fn_type->name, "%s", cc_str);
+    if (fn_type->data.fn.fn_type_id.cc == CallingConventionC)
+        buf_append_str(&fn_type->name, "extern ");
     buf_appendf(&fn_type->name, "fn(");
     size_t i = 0;
     for (; i < fn_type_id->next_param_index; i += 1) {
@@ -1455,7 +1460,11 @@ ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
         const char *comma_str = (i == 0) ? "" : ",";
         buf_appendf(&fn_type->name, "%svar", comma_str);
     }
-    buf_appendf(&fn_type->name, ")var");
+    buf_append_str(&fn_type->name, ")");
+    if (fn_type_id->cc != CallingConventionUnspecified && fn_type_id->cc != CallingConventionC) {
+        buf_appendf(&fn_type->name, " callconv(%s)", calling_convention_name(fn_type_id->cc));
+    }
+    buf_append_str(&fn_type->name, " var");
 
     fn_type->data.fn.fn_type_id = *fn_type_id;
     fn_type->data.fn.is_generic = true;
@@ -1465,17 +1474,25 @@ ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
     return fn_type;
 }
 
-void init_fn_type_id(FnTypeId *fn_type_id, AstNode *proto_node, size_t param_count_alloc) {
+CallingConvention cc_from_fn_proto(AstNodeFnProto *fn_proto) {
+    if (fn_proto->is_nakedcc)
+        return CallingConventionNaked;
+    if (fn_proto->is_stdcallcc)
+        return CallingConventionStdcall;
+    if (fn_proto->is_async)
+        return CallingConventionAsync;
+    // Compatible with the C ABI
+    if (fn_proto->is_extern || fn_proto->is_export)
+        return CallingConventionC;
+
+    return CallingConventionUnspecified;
+}
+
+void init_fn_type_id(FnTypeId *fn_type_id, AstNode *proto_node, CallingConvention cc, size_t param_count_alloc) {
     assert(proto_node->type == NodeTypeFnProto);
     AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
 
-    if (fn_proto->cc == CallingConventionUnspecified) {
-        bool extern_abi = fn_proto->is_extern || fn_proto->is_export;
-        fn_type_id->cc = extern_abi ? CallingConventionC : CallingConventionUnspecified;
-    } else {
-        fn_type_id->cc = fn_proto->cc;
-    }
-
+    fn_type_id->cc = cc;
     fn_type_id->param_count = fn_proto->params.length;
     fn_type_id->param_info = allocate<FnTypeParamInfo>(param_count_alloc);
     fn_type_id->next_param_index = 0;
@@ -1690,7 +1707,8 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
             return type_allowed_in_extern(g, type_entry->data.array.child_type, result);
         case ZigTypeIdFn:
             *result = type_entry->data.fn.fn_type_id.cc == CallingConventionC ||
-                 type_entry->data.fn.fn_type_id.cc == CallingConventionStdcall;
+                 type_entry->data.fn.fn_type_id.cc == CallingConventionStdcall ||
+                 type_entry->data.fn.fn_type_id.cc == CallingConventionAAPCS;
             return ErrorNone;
         case ZigTypeIdPointer:
             if ((err = type_resolve(g, type_entry, ResolveStatusZeroBitsKnown)))
@@ -1750,7 +1768,7 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
     Error err;
 
     FnTypeId fn_type_id = {0};
-    init_fn_type_id(&fn_type_id, proto_node, proto_node->data.fn_proto.params.length);
+    init_fn_type_id(&fn_type_id, proto_node, fn_entry->cc, proto_node->data.fn_proto.params.length);
 
     for (; fn_type_id.next_param_index < fn_type_id.param_count; fn_type_id.next_param_index += 1) {
         AstNode *param_node = fn_proto->params.at(fn_type_id.next_param_index);
@@ -3393,27 +3411,6 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
             get_fully_qualified_decl_name(g, &fn_table_entry->symbol_name, &tld_fn->base, false);
         }
 
-        if (fn_proto->is_export) {
-            switch (fn_proto->cc) {
-                case CallingConventionAsync: {
-                    add_node_error(g, fn_def_node,
-                        buf_sprintf("exported function cannot be async"));
-                } break;
-                case CallingConventionC:
-                case CallingConventionNaked:
-                case CallingConventionCold:
-                case CallingConventionStdcall:
-                case CallingConventionUnspecified:
-                    // An exported function without a specific calling
-                    // convention defaults to C
-                    CallingConvention cc = (fn_proto->cc != CallingConventionUnspecified) ?
-                        fn_proto->cc : CallingConventionC;
-                    add_fn_export(g, fn_table_entry, buf_ptr(&fn_table_entry->symbol_name),
-                                  GlobalLinkageIdStrong, cc);
-                    break;
-            }
-        }
-
         if (!is_extern) {
             fn_table_entry->fndef_scope = create_fndef_scope(g,
                 fn_table_entry->body_node, tld_fn->base.parent_scope, fn_table_entry);
@@ -3432,6 +3429,21 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
 
         Scope *child_scope = fn_table_entry->fndef_scope ? &fn_table_entry->fndef_scope->base : tld_fn->base.parent_scope;
 
+        fn_table_entry->cc = cc_from_fn_proto(fn_proto);
+        if (fn_proto->callconv_expr != nullptr) {
+            ZigType *cc_enum_value = get_builtin_type(g, "CallingConvention");
+
+            ZigValue *result_val = analyze_const_value(g, child_scope, fn_proto->callconv_expr,
+                cc_enum_value, nullptr, UndefBad);
+            if (type_is_invalid(result_val->type)) {
+                fn_table_entry->type_entry = g->builtin_types.entry_invalid;
+                tld_fn->base.resolution = TldResolutionInvalid;
+                return;
+            }
+
+            fn_table_entry->cc = (CallingConvention)bigint_as_u32(&result_val->data.x_enum_tag);
+        }
+
         fn_table_entry->type_entry = analyze_fn_type(g, source_node, child_scope, fn_table_entry);
 
         if (fn_proto->section_expr != nullptr) {
@@ -3450,10 +3462,42 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
                 g->fn_defs.append(fn_table_entry);
         }
 
+        const CallingConvention fn_cc = fn_table_entry->type_entry->data.fn.fn_type_id.cc;
+
+        if (fn_proto->is_export) {
+            switch (fn_cc) {
+                case CallingConventionAsync:
+                    add_node_error(g, fn_def_node,
+                        buf_sprintf("exported function cannot be async"));
+                    tld_fn->base.resolution = TldResolutionInvalid;
+                    return;
+                case CallingConventionC:
+                case CallingConventionCold:
+                case CallingConventionNaked:
+                case CallingConventionInterrupt:
+                case CallingConventionSignal:
+                case CallingConventionStdcall:
+                case CallingConventionFastcall:
+                case CallingConventionVectorcall:
+                case CallingConventionAPCS:
+                case CallingConventionAAPCS:
+                case CallingConventionAAPCSVFP:
+                    add_fn_export(g, fn_table_entry, buf_ptr(&fn_table_entry->symbol_name),
+                                  GlobalLinkageIdStrong, fn_cc);
+                    break;
+                case CallingConventionUnspecified:
+                    // An exported function without a specific calling
+                    // convention defaults to C
+                    add_fn_export(g, fn_table_entry, buf_ptr(&fn_table_entry->symbol_name),
+                                  GlobalLinkageIdStrong, CallingConventionC);
+                    break;
+            }
+        }
+
         // if the calling convention implies that it cannot be async, we save that for later
         // and leave the value to be nullptr to indicate that we have not emitted possible
         // compile errors for improperly calling async functions.
-        if (fn_table_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync) {
+        if (fn_cc == CallingConventionAsync) {
             fn_table_entry->inferred_async_node = fn_table_entry->proto_node;
         }
     } else if (source_node->type == NodeTypeTestDecl) {
diff --git a/src/analyze.hpp b/src/analyze.hpp
index c8699913af..bea36e83d7 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -100,7 +100,7 @@ ZigType *analyze_type_expr(CodeGen *g, Scope *scope, AstNode *node);
 void append_namespace_qualification(CodeGen *g, Buf *buf, ZigType *container_type);
 ZigFn *create_fn(CodeGen *g, AstNode *proto_node);
 ZigFn *create_fn_raw(CodeGen *g, FnInline inline_value);
-void init_fn_type_id(FnTypeId *fn_type_id, AstNode *proto_node, size_t param_count_alloc);
+void init_fn_type_id(FnTypeId *fn_type_id, AstNode *proto_node, CallingConvention cc, size_t param_count_alloc);
 AstNode *get_param_decl_node(ZigFn *fn_entry, size_t index);
 Error ATTRIBUTE_MUST_USE type_resolve(CodeGen *g, ZigType *type_entry, ResolveStatus status);
 void complete_enum(CodeGen *g, ZigType *enum_type);
@@ -259,6 +259,7 @@ ZigValue *analyze_const_value(CodeGen *g, Scope *scope, AstNode *node, ZigType *
 
 void resolve_llvm_types_fn(CodeGen *g, ZigFn *fn);
 bool fn_is_async(ZigFn *fn);
+CallingConvention cc_from_fn_proto(AstNodeFnProto *fn_proto);
 
 Error type_val_resolve_abi_align(CodeGen *g, ZigValue *type_val, uint32_t *abi_align);
 Error type_val_resolve_abi_size(CodeGen *g, AstNode *source_node, ZigValue *type_val,
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index 2be932ac8e..d8d0d6c0e2 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -488,6 +488,11 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
                     render_node_grouped(ar, node->data.fn_proto.section_expr);
                     fprintf(ar->f, ")");
                 }
+                if (node->data.fn_proto.callconv_expr) {
+                    fprintf(ar->f, " callconv(");
+                    render_node_grouped(ar, node->data.fn_proto.callconv_expr);
+                    fprintf(ar->f, ")");
+                }
 
                 if (node->data.fn_proto.return_var_token != nullptr) {
                     fprintf(ar->f, "var");
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 734fc3be2b..c5611f3e2c 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -284,14 +284,43 @@ static LLVMCallConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
         case CallingConventionNaked:
             zig_unreachable();
         case CallingConventionStdcall:
-            // stdcall calling convention only works on x86.
-            if (g->zig_target->arch == ZigLLVM_x86) {
+            if (g->zig_target->arch == ZigLLVM_x86)
                 return LLVMX86StdcallCallConv;
-            } else {
-                return LLVMCCallConv;
-            }
+            return LLVMCCallConv;
+        case CallingConventionFastcall:
+            if (g->zig_target->arch == ZigLLVM_x86)
+                return LLVMX86FastcallCallConv;
+            return LLVMFastCallConv;
+        case CallingConventionVectorcall:
+            if (g->zig_target->arch == ZigLLVM_x86)
+                return LLVMX86VectorCallCallConv;
+            return LLVMCCallConv;
         case CallingConventionAsync:
             return LLVMFastCallConv;
+        case CallingConventionAPCS:
+            if (target_is_arm(g->zig_target))
+                return LLVMARMAPCSCallConv;
+            return LLVMCCallConv;
+        case CallingConventionAAPCS:
+            if (target_is_arm(g->zig_target))
+                return LLVMARMAAPCSCallConv;
+            return LLVMCCallConv;
+        case CallingConventionAAPCSVFP:
+            if (target_is_arm(g->zig_target))
+                return LLVMARMAAPCSVFPCallConv;
+            return LLVMCCallConv;
+        case CallingConventionInterrupt:
+            if (g->zig_target->arch == ZigLLVM_x86 || g->zig_target->arch == ZigLLVM_x86_64)
+                return LLVMX86INTRCallConv;
+            if (g->zig_target->arch == ZigLLVM_avr)
+                return LLVMAVRINTRCallConv;
+            if (g->zig_target->arch == ZigLLVM_msp430)
+                return LLVMMSP430INTRCallConv;
+            return LLVMCCallConv;
+        case CallingConventionSignal:
+            if (g->zig_target->arch == ZigLLVM_avr)
+                return LLVMAVRSIGNALCallConv;
+            return LLVMCCallConv;
     }
     zig_unreachable();
 }
@@ -383,7 +412,14 @@ static bool cc_want_sret_attr(CallingConvention cc) {
             zig_unreachable();
         case CallingConventionC:
         case CallingConventionCold:
+        case CallingConventionInterrupt:
+        case CallingConventionSignal:
         case CallingConventionStdcall:
+        case CallingConventionFastcall:
+        case CallingConventionVectorcall:
+        case CallingConventionAPCS:
+        case CallingConventionAAPCS:
+        case CallingConventionAAPCSVFP:
             return true;
         case CallingConventionAsync:
         case CallingConventionUnspecified:
@@ -8463,8 +8499,15 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
     static_assert(CallingConventionC == 1, "");
     static_assert(CallingConventionCold == 2, "");
     static_assert(CallingConventionNaked == 3, "");
-    static_assert(CallingConventionStdcall == 4, "");
-    static_assert(CallingConventionAsync == 5, "");
+    static_assert(CallingConventionAsync == 4, "");
+    static_assert(CallingConventionInterrupt == 5, "");
+    static_assert(CallingConventionSignal == 6, "");
+    static_assert(CallingConventionStdcall == 7, "");
+    static_assert(CallingConventionFastcall == 8, "");
+    static_assert(CallingConventionVectorcall == 9, "");
+    static_assert(CallingConventionAPCS == 10, "");
+    static_assert(CallingConventionAAPCS == 11, "");
+    static_assert(CallingConventionAAPCSVFP == 12, "");
 
     static_assert(FnInlineAuto == 0, "");
     static_assert(FnInlineAlways == 1, "");
diff --git a/src/ir.cpp b/src/ir.cpp
index 08efdbd6e4..da402887c4 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -3250,12 +3250,13 @@ static IrInstruction *ir_build_unwrap_err_payload(IrBuilder *irb, Scope *scope,
 }
 
 static IrInstruction *ir_build_fn_proto(IrBuilder *irb, Scope *scope, AstNode *source_node,
-    IrInstruction **param_types, IrInstruction *align_value, IrInstruction *return_type,
-    bool is_var_args)
+    IrInstruction **param_types, IrInstruction *align_value, IrInstruction *callconv_value,
+    IrInstruction *return_type, bool is_var_args)
 {
     IrInstructionFnProto *instruction = ir_build_instruction<IrInstructionFnProto>(irb, scope, source_node);
     instruction->param_types = param_types;
     instruction->align_value = align_value;
+    instruction->callconv_value = callconv_value;
     instruction->return_type = return_type;
     instruction->is_var_args = is_var_args;
 
@@ -3266,6 +3267,7 @@ static IrInstruction *ir_build_fn_proto(IrBuilder *irb, Scope *scope, AstNode *s
         if (param_types[i] != nullptr) ir_ref_instruction(param_types[i], irb->current_basic_block);
     }
     if (align_value != nullptr) ir_ref_instruction(align_value, irb->current_basic_block);
+    if (callconv_value != nullptr) ir_ref_instruction(callconv_value, irb->current_basic_block);
     ir_ref_instruction(return_type, irb->current_basic_block);
 
     return &instruction->base;
@@ -8850,6 +8852,13 @@ static IrInstruction *ir_gen_fn_proto(IrBuilder *irb, Scope *parent_scope, AstNo
             return irb->codegen->invalid_instruction;
     }
 
+    IrInstruction *callconv_value = nullptr;
+    if (node->data.fn_proto.callconv_expr != nullptr) {
+        callconv_value = ir_gen_node(irb, node->data.fn_proto.callconv_expr, parent_scope);
+        if (callconv_value == irb->codegen->invalid_instruction)
+            return irb->codegen->invalid_instruction;
+    }
+
     IrInstruction *return_type;
     if (node->data.fn_proto.return_var_token == nullptr) {
         if (node->data.fn_proto.return_type == nullptr) {
@@ -8866,7 +8875,7 @@ static IrInstruction *ir_gen_fn_proto(IrBuilder *irb, Scope *parent_scope, AstNo
         //return_type = nullptr;
     }
 
-    return ir_build_fn_proto(irb, parent_scope, node, param_types, align_value, return_type, is_var_args);
+    return ir_build_fn_proto(irb, parent_scope, node, param_types, align_value, callconv_value, return_type, is_var_args);
 }
 
 static IrInstruction *ir_gen_resume(IrBuilder *irb, Scope *scope, AstNode *node) {
@@ -16736,9 +16745,16 @@ static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructio
                     add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));
                 } break;
                 case CallingConventionC:
-                case CallingConventionNaked:
                 case CallingConventionCold:
+                case CallingConventionNaked:
+                case CallingConventionInterrupt:
+                case CallingConventionSignal:
                 case CallingConventionStdcall:
+                case CallingConventionFastcall:
+                case CallingConventionVectorcall:
+                case CallingConventionAPCS:
+                case CallingConventionAAPCS:
+                case CallingConventionAAPCSVFP:
                     add_fn_export(ira->codegen, fn_entry, buf_ptr(symbol_name), global_linkage_id, cc);
                     break;
             }
@@ -18101,7 +18117,6 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
         return ira->codegen->invalid_instruction;
     }
 
-
     if (fn_type_id->is_var_args) {
         if (call_param_count < src_param_count) {
             ErrorMsg *msg = ir_add_error_node(ira, source_node,
@@ -18254,8 +18269,9 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
         buf_init_from_buf(&impl_fn->symbol_name, &fn_entry->symbol_name);
         impl_fn->fndef_scope = create_fndef_scope(ira->codegen, impl_fn->body_node, parent_scope, impl_fn);
         impl_fn->child_scope = &impl_fn->fndef_scope->base;
+        impl_fn->cc = fn_entry->cc;
         FnTypeId inst_fn_type_id = {0};
-        init_fn_type_id(&inst_fn_type_id, fn_proto_node, new_fn_arg_count);
+        init_fn_type_id(&inst_fn_type_id, fn_proto_node, fn_type_id->cc, new_fn_arg_count);
         inst_fn_type_id.param_count = 0;
         inst_fn_type_id.is_var_args = false;
 
@@ -22592,8 +22608,8 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
                     // calling_convention: TypeInfo.CallingConvention
                     ensure_field_index(fn_decl_val->type, "calling_convention", 2);
                     fn_decl_fields[2]->special = ConstValSpecialStatic;
-                    fn_decl_fields[2]->type = ir_type_info_get_type(ira, "CallingConvention", nullptr);
-                    bigint_init_unsigned(&fn_decl_fields[2]->data.x_enum_tag, fn_node->cc);
+                    fn_decl_fields[2]->type = get_builtin_type(ira->codegen, "CallingConvention");
+                    bigint_init_unsigned(&fn_decl_fields[2]->data.x_enum_tag, fn_entry->cc);
                     // is_var_args: bool
                     ensure_field_index(fn_decl_val->type, "is_var_args", 3);
                     bool is_varargs = fn_node->is_var_args;
@@ -23280,7 +23296,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
                 // calling_convention: TypeInfo.CallingConvention
                 ensure_field_index(result->type, "calling_convention", 0);
                 fields[0]->special = ConstValSpecialStatic;
-                fields[0]->type = ir_type_info_get_type(ira, "CallingConvention", nullptr);
+                fields[0]->type = get_builtin_type(ira->codegen, "CallingConvention");
                 bigint_init_unsigned(&fields[0]->data.x_enum_tag, type_entry->data.fn.fn_type_id.cc);
                 // is_generic: bool
                 ensure_field_index(result->type, "is_generic", 1);
@@ -26192,6 +26208,21 @@ static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruct
         return ira->codegen->invalid_instruction;
     }
 
+    lazy_fn_type->cc = cc_from_fn_proto(&proto_node->data.fn_proto);
+    if (instruction->callconv_value != nullptr) {
+        ZigType *cc_enum_type = get_builtin_type(ira->codegen, "CallingConvention");
+
+        IrInstruction *casted_value = ir_implicit_cast(ira, instruction->callconv_value, cc_enum_type);
+        if (type_is_invalid(casted_value->value->type))
+            return ira->codegen->invalid_instruction;
+
+        ZigValue *const_value = ir_resolve_const(ira, casted_value, UndefBad);
+        if (const_value == nullptr)
+            return ira->codegen->invalid_instruction;
+
+        lazy_fn_type->cc = (CallingConvention)bigint_as_u32(&const_value->data.x_enum_tag);
+    }
+
     size_t param_count = proto_node->data.fn_proto.params.length;
     lazy_fn_type->proto_node = proto_node;
     lazy_fn_type->param_types = allocate<IrInstruction *>(param_count);
@@ -26202,9 +26233,11 @@ static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruct
 
         bool param_is_var_args = param_node->data.param_decl.is_var_args;
         if (param_is_var_args) {
-            if (proto_node->data.fn_proto.cc == CallingConventionC) {
+            const CallingConvention cc = lazy_fn_type->cc;
+
+            if (cc == CallingConventionC) {
                 break;
-            } else if (proto_node->data.fn_proto.cc == CallingConventionUnspecified) {
+            } else if (cc == CallingConventionUnspecified) {
                 lazy_fn_type->is_generic = true;
                 return result;
             } else {
@@ -29062,7 +29095,7 @@ static ZigType *ir_resolve_lazy_fn_type(IrAnalyze *ira, AstNode *source_node, La
     AstNode *proto_node = lazy_fn_type->proto_node;
 
     FnTypeId fn_type_id = {0};
-    init_fn_type_id(&fn_type_id, proto_node, proto_node->data.fn_proto.params.length);
+    init_fn_type_id(&fn_type_id, proto_node, lazy_fn_type->cc, proto_node->data.fn_proto.params.length);
 
     for (; fn_type_id.next_param_index < fn_type_id.param_count; fn_type_id.next_param_index += 1) {
         AstNode *param_node = proto_node->data.fn_proto.params.at(fn_type_id.next_param_index);
diff --git a/src/parser.cpp b/src/parser.cpp
index a0c5cf794b..65ea9ac203 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -92,6 +92,7 @@ static Token *ast_parse_block_label(ParseContext *pc);
 static AstNode *ast_parse_field_init(ParseContext *pc);
 static AstNode *ast_parse_while_continue_expr(ParseContext *pc);
 static AstNode *ast_parse_link_section(ParseContext *pc);
+static AstNode *ast_parse_callconv(ParseContext *pc);
 static Optional<AstNodeFnProto> ast_parse_fn_cc(ParseContext *pc);
 static AstNode *ast_parse_param_decl(ParseContext *pc);
 static AstNode *ast_parse_param_type(ParseContext *pc);
@@ -676,7 +677,9 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, B
             fn_proto->column = first->start_column;
             fn_proto->data.fn_proto.visib_mod = visib_mod;
             fn_proto->data.fn_proto.doc_comments = *doc_comments;
-            fn_proto->data.fn_proto.is_extern = first->id == TokenIdKeywordExtern;
+            // ast_parse_fn_cc may set it
+            if (!fn_proto->data.fn_proto.is_extern)
+                fn_proto->data.fn_proto.is_extern = first->id == TokenIdKeywordExtern;
             fn_proto->data.fn_proto.is_export = first->id == TokenIdKeywordExport;
             switch (first->id) {
                 case TokenIdKeywordInline:
@@ -761,7 +764,7 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc) {
         // The extern keyword for fn CC is also used for container decls.
         // We therefore put it back, as allow container decl to consume it
         // later.
-        if (fn_cc.cc == CallingConventionC) {
+        if (fn_cc.is_extern) {
             fn = eat_token_if(pc, TokenIdKeywordFn);
             if (fn == nullptr) {
                 put_back_token(pc);
@@ -784,6 +787,7 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc) {
 
     AstNode *align_expr = ast_parse_byte_align(pc);
     AstNode *section_expr = ast_parse_link_section(pc);
+    AstNode *callconv_expr = ast_parse_callconv(pc);
     Token *var = eat_token_if(pc, TokenIdKeywordVar);
     Token *exmark = nullptr;
     AstNode *return_type = nullptr;
@@ -798,6 +802,7 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc) {
     res->data.fn_proto.params = params;
     res->data.fn_proto.align_expr = align_expr;
     res->data.fn_proto.section_expr = section_expr;
+    res->data.fn_proto.callconv_expr = callconv_expr;
     res->data.fn_proto.return_var_token = var;
     res->data.fn_proto.auto_err_set = exmark != nullptr;
     res->data.fn_proto.return_type = return_type;
@@ -2099,6 +2104,18 @@ static AstNode *ast_parse_link_section(ParseContext *pc) {
     return res;
 }
 
+// CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
+static AstNode *ast_parse_callconv(ParseContext *pc) {
+    Token *first = eat_token_if(pc, TokenIdKeywordCallconv);
+    if (first == nullptr)
+        return nullptr;
+
+    expect_token(pc, TokenIdLParen);
+    AstNode *res = ast_expect(pc, ast_parse_expr);
+    expect_token(pc, TokenIdRParen);
+    return res;
+}
+
 // FnCC
 //     <- KEYWORD_nakedcc
 //      / KEYWORD_stdcallcc
@@ -2107,19 +2124,19 @@ static AstNode *ast_parse_link_section(ParseContext *pc) {
 static Optional<AstNodeFnProto> ast_parse_fn_cc(ParseContext *pc) {
     AstNodeFnProto res = {};
     if (eat_token_if(pc, TokenIdKeywordNakedCC) != nullptr) {
-        res.cc = CallingConventionNaked;
+        res.is_nakedcc = true;
         return Optional<AstNodeFnProto>::some(res);
     }
     if (eat_token_if(pc, TokenIdKeywordStdcallCC) != nullptr) {
-        res.cc = CallingConventionStdcall;
+        res.is_stdcallcc = true;
         return Optional<AstNodeFnProto>::some(res);
     }
-    if (eat_token_if(pc, TokenIdKeywordExtern) != nullptr) {
-        res.cc = CallingConventionC;
+    if (eat_token_if(pc, TokenIdKeywordAsync) != nullptr) {
+        res.is_async = true;
         return Optional<AstNodeFnProto>::some(res);
     }
-    if (eat_token_if(pc, TokenIdKeywordAsync) != nullptr) {
-        res.cc = CallingConventionAsync;
+    if (eat_token_if(pc, TokenIdKeywordExtern) != nullptr) {
+        res.is_extern = true;
         return Optional<AstNodeFnProto>::some(res);
     }
 
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index f8b5059bf1..fb58bc19bb 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -110,6 +110,7 @@ static const struct ZigKeyword zig_keywords[] = {
     {"async", TokenIdKeywordAsync},
     {"await", TokenIdKeywordAwait},
     {"break", TokenIdKeywordBreak},
+    {"callconv", TokenIdKeywordCallconv},
     {"catch", TokenIdKeywordCatch},
     {"comptime", TokenIdKeywordCompTime},
     {"const", TokenIdKeywordConst},
@@ -1545,6 +1546,7 @@ const char * token_name(TokenId id) {
         case TokenIdKeywordAsm: return "asm";
         case TokenIdKeywordBreak: return "break";
         case TokenIdKeywordCatch: return "catch";
+        case TokenIdKeywordCallconv: return "callconv";
         case TokenIdKeywordCompTime: return "comptime";
         case TokenIdKeywordConst: return "const";
         case TokenIdKeywordContinue: return "continue";
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index 084512a576..eacdaad98d 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -59,6 +59,7 @@ enum TokenId {
     TokenIdKeywordAwait,
     TokenIdKeywordBreak,
     TokenIdKeywordCatch,
+    TokenIdKeywordCallconv,
     TokenIdKeywordCompTime,
     TokenIdKeywordConst,
     TokenIdKeywordContinue,
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 75e88ac918..f5798a5460 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -752,7 +752,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    _ = @frame();
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:1: error: function with calling convention 'ccc' cannot be async",
+        "tmp.zig:1:1: error: function with calling convention 'C' cannot be async",
         "tmp.zig:5:9: note: @frame() causes function to be async",
     });
 
@@ -765,7 +765,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    suspend;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:1: error: function with calling convention 'ccc' cannot be async",
+        "tmp.zig:1:1: error: function with calling convention 'C' cannot be async",
         "tmp.zig:3:18: note: await here is a suspend point",
     });
 
@@ -843,7 +843,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    suspend;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:1: error: function with calling convention 'ccc' cannot be async",
+        "tmp.zig:1:1: error: function with calling convention 'C' cannot be async",
         "tmp.zig:2:8: note: async function call here",
         "tmp.zig:5:8: note: async function call here",
         "tmp.zig:8:5: note: suspends here",
@@ -1140,7 +1140,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    while (true) {}
         \\}
     , &[_][]const u8{
-        "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,var)var'",
+        "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,var) var'",
         "note: only one of the functions is generic",
     });
 
@@ -1362,7 +1362,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    return 0;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:15: error: parameter of type 'var' not allowed in function with calling convention 'ccc'",
+        "tmp.zig:1:15: error: parameter of type 'var' not allowed in function with calling convention 'C'",
     });
 
     cases.add("C pointer to c_void",
@@ -2187,7 +2187,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    f(g);
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:9: error: parameter of type 'fn(var)var' must be declared comptime",
+        "tmp.zig:1:9: error: parameter of type 'fn(var) var' must be declared comptime",
     });
 
     cases.add("optional pointer to void in extern struct",
@@ -2859,7 +2859,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\const Foo = enum { A, B, C };
         \\export fn entry(foo: Foo) void { }
     , &[_][]const u8{
-        "tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'",
+        "tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
     });
 
     cases.add("function with non-extern non-packed struct parameter",
@@ -2870,7 +2870,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry(foo: Foo) void { }
     , &[_][]const u8{
-        "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'",
+        "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
     });
 
     cases.add("function with non-extern non-packed union parameter",
@@ -2881,7 +2881,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry(foo: Foo) void { }
     , &[_][]const u8{
-        "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'ccc'",
+        "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
     });
 
     cases.add("switch on enum with 1 field with no prongs",
@@ -2977,8 +2977,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    bar(&{});
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:30: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'ccc'",
-        "tmp.zig:7:18: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'ccc'",
+        "tmp.zig:1:30: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'",
+        "tmp.zig:7:18: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'",
     });
 
     cases.add("implicit semicolon - block statement",
@@ -4552,7 +4552,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    return x + y;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'ccc'",
+        "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'",
     });
 
     cases.add("extern function with comptime parameter",
@@ -4562,7 +4562,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
     , &[_][]const u8{
-        "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'ccc'",
+        "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'",
     });
 
     cases.add("convert fixed size array to slice with invalid size",
@@ -6303,7 +6303,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    _ = @TypeOf(generic).ReturnType;
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(var)var' is generic",
+        "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(var) var' is generic",
     });
 
     cases.add("getting @ArgType of generic function",
@@ -6312,7 +6312,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    _ = @ArgType(@TypeOf(generic), 0);
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic",
+        "tmp.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var) var' is generic",
     });
 
     cases.add("unsupported modifier at start of asm output constraint",
diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig
index a9d4a1c924..d35cc8831f 100644
--- a/test/stage1/behavior/type_info.zig
+++ b/test/stage1/behavior/type_info.zig
@@ -202,7 +202,7 @@ fn testUnion() void {
     expect(typeinfo_info.Union.fields[4].enum_field != null);
     expect(typeinfo_info.Union.fields[4].enum_field.?.value == 4);
     expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int));
-    expect(typeinfo_info.Union.decls.len == 21);
+    expect(typeinfo_info.Union.decls.len == 20);
 
     const TestNoTagUnion = union {
         Foo: void,
@@ -266,7 +266,7 @@ test "type info: function type info" {
 fn testFunction() void {
     const fn_info = @typeInfo(@TypeOf(foo));
     expect(@as(TypeId, fn_info) == TypeId.Fn);
-    expect(fn_info.Fn.calling_convention == TypeInfo.CallingConvention.Unspecified);
+    expect(fn_info.Fn.calling_convention == .Unspecified);
     expect(fn_info.Fn.is_generic);
     expect(fn_info.Fn.args.len == 2);
     expect(fn_info.Fn.is_var_args);
-- 
cgit v1.2.3


From 5951b79af40212754071157596b8aebbe2414ffb Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 6 Jan 2020 15:23:05 -0500
Subject: remove stdcallcc, extern, nakedcc from stage1; zig fmt rewrites

---
 lib/std/builtin.zig         |  1 -
 lib/std/zig/parser_test.zig |  4 +++-
 lib/std/zig/render.zig      | 15 ++++++++++-----
 src/all_types.hpp           |  3 ---
 src/analyze.cpp             | 22 ++++++++++------------
 src/codegen.cpp             |  2 +-
 src/ir.cpp                  | 18 ++++++------------
 src/parser.cpp              | 12 +-----------
 src/tokenizer.cpp           |  4 ----
 src/tokenizer.hpp           |  2 --
 10 files changed, 31 insertions(+), 52 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 9b3be8f424..288e8f8897 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -322,7 +322,6 @@ pub const TypeInfo = union(enum) {
             pub const FnDecl = struct {
                 fn_type: type,
                 inline_type: Inline,
-                calling_convention: CallingConvention,
                 is_var_args: bool,
                 is_extern: bool,
                 is_export: bool,
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 018ba9653f..97df2dff15 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -10,13 +10,15 @@ test "zig fmt: change @typeOf to @TypeOf" {
 }
 
 // TODO: Remove nakedcc/stdcallcc once zig 0.6.0 is released. See https://github.com/ziglang/zig/pull/3977
-test "zig fmt: convert nakedcc/stdcallcc into callconv(...)" {
+test "zig fmt: convert extern/nakedcc/stdcallcc into callconv(...)" {
     try testTransform(
         \\nakedcc fn foo1() void {}
         \\stdcallcc fn foo2() void {}
+        \\extern fn foo3() void {}
     ,
         \\fn foo1() callconv(.Naked) void {}
         \\fn foo2() callconv(.Stdcall) void {}
+        \\fn foo3() callconv(.C) void {}
         \\
     );
 }
diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig
index 626017dd66..2b1a739186 100644
--- a/lib/std/zig/render.zig
+++ b/lib/std/zig/render.zig
@@ -1311,17 +1311,22 @@ fn renderExpression(
                 try renderToken(tree, stream, visib_token_index, indent, start_col, Space.Space); // pub
             }
 
+            // Some extra machinery is needed to rewrite the old-style cc
+            // notation to the new callconv one
+            var cc_rewrite_str: ?[*:0]const u8 = null;
             if (fn_proto.extern_export_inline_token) |extern_export_inline_token| {
-                try renderToken(tree, stream, extern_export_inline_token, indent, start_col, Space.Space); // extern/export
+                const tok = tree.tokens.at(extern_export_inline_token);
+                if (tok.id != .Keyword_extern or fn_proto.body_node == null) {
+                    try renderToken(tree, stream, extern_export_inline_token, indent, start_col, Space.Space); // extern/export
+                } else {
+                    cc_rewrite_str = ".C";
+                }
             }
 
             if (fn_proto.lib_name) |lib_name| {
                 try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space);
             }
 
-            // Some extra machinery is needed to rewrite the old-style cc
-            // notation to the new callconv one
-            var cc_rewrite_str: ?[*:0]const u8 = null;
             if (fn_proto.cc_token) |cc_token| {
                 var str = tree.tokenSlicePtr(tree.tokens.at(cc_token));
                 if (mem.eql(u8, str, "stdcallcc")) {
@@ -1405,7 +1410,7 @@ fn renderExpression(
                 const callconv_lparen = tree.prevToken(callconv_expr.firstToken());
                 const callconv_kw = tree.prevToken(callconv_lparen);
 
-                try renderToken(tree, stream, callconv_kw, indent, start_col, Space.None); // section
+                try renderToken(tree, stream, callconv_kw, indent, start_col, Space.None); // callconv
                 try renderToken(tree, stream, callconv_lparen, indent, start_col, Space.None); // (
                 try renderExpression(allocator, stream, tree, indent, start_col, callconv_expr, Space.None);
                 try renderToken(tree, stream, callconv_rparen, indent, start_col, Space.Space); // )
diff --git a/src/all_types.hpp b/src/all_types.hpp
index 3e8516529a..fe77d3db3b 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -653,8 +653,6 @@ struct AstNodeFnProto {
     Buf doc_comments;
 
     FnInline fn_inline;
-    bool is_nakedcc;
-    bool is_stdcallcc;
     bool is_async;
 
     VisibMod visib_mod;
@@ -1610,7 +1608,6 @@ struct ZigFn {
     Buf **param_names;
     IrInstruction *err_code_spill;
     AstNode *assumed_non_async;
-    CallingConvention cc;
 
     AstNode *fn_no_inline_set_node;
     AstNode *fn_static_eval_set_node;
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 5fb99ef1f3..a7763fea61 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -1451,8 +1451,6 @@ ZigType *analyze_type_expr(CodeGen *g, Scope *scope, AstNode *node) {
 ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
     ZigType *fn_type = new_type_table_entry(ZigTypeIdFn);
     buf_resize(&fn_type->name, 0);
-    if (fn_type->data.fn.fn_type_id.cc == CallingConventionC)
-        buf_append_str(&fn_type->name, "extern ");
     buf_appendf(&fn_type->name, "fn(");
     size_t i = 0;
     for (; i < fn_type_id->next_param_index; i += 1) {
@@ -1465,7 +1463,7 @@ ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
         buf_appendf(&fn_type->name, "%svar", comma_str);
     }
     buf_append_str(&fn_type->name, ")");
-    if (fn_type_id->cc != CallingConventionUnspecified && fn_type_id->cc != CallingConventionC) {
+    if (fn_type_id->cc != CallingConventionUnspecified) {
         buf_appendf(&fn_type->name, " callconv(%s)", calling_convention_name(fn_type_id->cc));
     }
     buf_append_str(&fn_type->name, " var");
@@ -1479,10 +1477,6 @@ ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
 }
 
 CallingConvention cc_from_fn_proto(AstNodeFnProto *fn_proto) {
-    if (fn_proto->is_nakedcc)
-        return CallingConventionNaked;
-    if (fn_proto->is_stdcallcc)
-        return CallingConventionStdcall;
     if (fn_proto->is_async)
         return CallingConventionAsync;
     // Compatible with the C ABI
@@ -1764,13 +1758,15 @@ ZigType *get_auto_err_set_type(CodeGen *g, ZigFn *fn_entry) {
     return err_set_type;
 }
 
-static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_scope, ZigFn *fn_entry) {
+static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_scope, ZigFn *fn_entry,
+        CallingConvention cc)
+{
     assert(proto_node->type == NodeTypeFnProto);
     AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
     Error err;
 
     FnTypeId fn_type_id = {0};
-    init_fn_type_id(&fn_type_id, proto_node, fn_entry->cc, proto_node->data.fn_proto.params.length);
+    init_fn_type_id(&fn_type_id, proto_node, cc, proto_node->data.fn_proto.params.length);
 
     for (; fn_type_id.next_param_index < fn_type_id.param_count; fn_type_id.next_param_index += 1) {
         AstNode *param_node = fn_proto->params.at(fn_type_id.next_param_index);
@@ -3432,7 +3428,7 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
 
         Scope *child_scope = fn_table_entry->fndef_scope ? &fn_table_entry->fndef_scope->base : tld_fn->base.parent_scope;
 
-        fn_table_entry->cc = cc_from_fn_proto(fn_proto);
+        CallingConvention cc;
         if (fn_proto->callconv_expr != nullptr) {
             ZigType *cc_enum_value = get_builtin_type(g, "CallingConvention");
 
@@ -3444,7 +3440,9 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
                 return;
             }
 
-            fn_table_entry->cc = (CallingConvention)bigint_as_u32(&result_val->data.x_enum_tag);
+            cc = (CallingConvention)bigint_as_u32(&result_val->data.x_enum_tag);
+        } else {
+            cc = cc_from_fn_proto(fn_proto);
         }
 
         if (fn_proto->section_expr != nullptr) {
@@ -3455,7 +3453,7 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
             }
         }
 
-        fn_table_entry->type_entry = analyze_fn_type(g, source_node, child_scope, fn_table_entry);
+        fn_table_entry->type_entry = analyze_fn_type(g, source_node, child_scope, fn_table_entry, cc);
 
         if (type_is_invalid(fn_table_entry->type_entry)) {
             tld_fn->base.resolution = TldResolutionInvalid;
diff --git a/src/codegen.cpp b/src/codegen.cpp
index cbb5e35a57..59f69539bc 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -519,7 +519,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
     if (cc == CallingConventionNaked) {
         addLLVMFnAttr(llvm_fn, "naked");
     } else {
-        ZigLLVMFunctionSetCallingConv(llvm_fn, get_llvm_cc(g, fn_type->data.fn.fn_type_id.cc));
+        ZigLLVMFunctionSetCallingConv(llvm_fn, get_llvm_cc(g, cc));
     }
 
     bool want_cold = fn->is_cold || cc == CallingConventionCold;
diff --git a/src/ir.cpp b/src/ir.cpp
index 78be3256c0..4a91046b7c 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -18263,7 +18263,6 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
         buf_init_from_buf(&impl_fn->symbol_name, &fn_entry->symbol_name);
         impl_fn->fndef_scope = create_fndef_scope(ira->codegen, impl_fn->body_node, parent_scope, impl_fn);
         impl_fn->child_scope = &impl_fn->fndef_scope->base;
-        impl_fn->cc = fn_entry->cc;
         FnTypeId inst_fn_type_id = {0};
         init_fn_type_id(&inst_fn_type_id, fn_proto_node, fn_type_id->cc, new_fn_arg_count);
         inst_fn_type_id.param_count = 0;
@@ -22599,29 +22598,24 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
                     fn_decl_fields[1]->special = ConstValSpecialStatic;
                     fn_decl_fields[1]->type = type_info_fn_decl_inline_type;
                     bigint_init_unsigned(&fn_decl_fields[1]->data.x_enum_tag, fn_entry->fn_inline);
-                    // calling_convention: TypeInfo.CallingConvention
-                    ensure_field_index(fn_decl_val->type, "calling_convention", 2);
-                    fn_decl_fields[2]->special = ConstValSpecialStatic;
-                    fn_decl_fields[2]->type = get_builtin_type(ira->codegen, "CallingConvention");
-                    bigint_init_unsigned(&fn_decl_fields[2]->data.x_enum_tag, fn_entry->cc);
                     // is_var_args: bool
-                    ensure_field_index(fn_decl_val->type, "is_var_args", 3);
+                    ensure_field_index(fn_decl_val->type, "is_var_args", 2);
                     bool is_varargs = fn_node->is_var_args;
                     fn_decl_fields[3]->special = ConstValSpecialStatic;
                     fn_decl_fields[3]->type = ira->codegen->builtin_types.entry_bool;
                     fn_decl_fields[3]->data.x_bool = is_varargs;
                     // is_extern: bool
-                    ensure_field_index(fn_decl_val->type, "is_extern", 4);
+                    ensure_field_index(fn_decl_val->type, "is_extern", 3);
                     fn_decl_fields[4]->special = ConstValSpecialStatic;
                     fn_decl_fields[4]->type = ira->codegen->builtin_types.entry_bool;
                     fn_decl_fields[4]->data.x_bool = fn_node->is_extern;
                     // is_export: bool
-                    ensure_field_index(fn_decl_val->type, "is_export", 5);
+                    ensure_field_index(fn_decl_val->type, "is_export", 4);
                     fn_decl_fields[5]->special = ConstValSpecialStatic;
                     fn_decl_fields[5]->type = ira->codegen->builtin_types.entry_bool;
                     fn_decl_fields[5]->data.x_bool = fn_node->is_export;
                     // lib_name: ?[]const u8
-                    ensure_field_index(fn_decl_val->type, "lib_name", 6);
+                    ensure_field_index(fn_decl_val->type, "lib_name", 5);
                     fn_decl_fields[6]->special = ConstValSpecialStatic;
                     ZigType *u8_ptr = get_pointer_to_type_extra(
                         ira->codegen, ira->codegen->builtin_types.entry_u8,
@@ -22637,12 +22631,12 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
                         fn_decl_fields[6]->data.x_optional = nullptr;
                     }
                     // return_type: type
-                    ensure_field_index(fn_decl_val->type, "return_type", 7);
+                    ensure_field_index(fn_decl_val->type, "return_type", 6);
                     fn_decl_fields[7]->special = ConstValSpecialStatic;
                     fn_decl_fields[7]->type = ira->codegen->builtin_types.entry_type;
                     fn_decl_fields[7]->data.x_type = fn_entry->type_entry->data.fn.fn_type_id.return_type;
                     // arg_names: [][] const u8
-                    ensure_field_index(fn_decl_val->type, "arg_names", 8);
+                    ensure_field_index(fn_decl_val->type, "arg_names", 7);
                     size_t fn_arg_count = fn_entry->variable_list.length;
                     ZigValue *fn_arg_name_array = create_const_vals(1);
                     fn_arg_name_array->special = ConstValSpecialStatic;
diff --git a/src/parser.cpp b/src/parser.cpp
index 65ea9ac203..f6f5811e63 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -2117,20 +2117,10 @@ static AstNode *ast_parse_callconv(ParseContext *pc) {
 }
 
 // FnCC
-//     <- KEYWORD_nakedcc
-//      / KEYWORD_stdcallcc
-//      / KEYWORD_extern
+//     <- KEYWORD_extern
 //      / KEYWORD_async
 static Optional<AstNodeFnProto> ast_parse_fn_cc(ParseContext *pc) {
     AstNodeFnProto res = {};
-    if (eat_token_if(pc, TokenIdKeywordNakedCC) != nullptr) {
-        res.is_nakedcc = true;
-        return Optional<AstNodeFnProto>::some(res);
-    }
-    if (eat_token_if(pc, TokenIdKeywordStdcallCC) != nullptr) {
-        res.is_stdcallcc = true;
-        return Optional<AstNodeFnProto>::some(res);
-    }
     if (eat_token_if(pc, TokenIdKeywordAsync) != nullptr) {
         res.is_async = true;
         return Optional<AstNodeFnProto>::some(res);
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index fb58bc19bb..9182c5227a 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -127,7 +127,6 @@ static const struct ZigKeyword zig_keywords[] = {
     {"for", TokenIdKeywordFor},
     {"if", TokenIdKeywordIf},
     {"inline", TokenIdKeywordInline},
-    {"nakedcc", TokenIdKeywordNakedCC},
     {"noalias", TokenIdKeywordNoAlias},
     {"noasync", TokenIdKeywordNoAsync},
     {"noinline", TokenIdKeywordNoInline},
@@ -139,7 +138,6 @@ static const struct ZigKeyword zig_keywords[] = {
     {"resume", TokenIdKeywordResume},
     {"return", TokenIdKeywordReturn},
     {"linksection", TokenIdKeywordLinkSection},
-    {"stdcallcc", TokenIdKeywordStdcallCC},
     {"struct", TokenIdKeywordStruct},
     {"suspend", TokenIdKeywordSuspend},
     {"switch", TokenIdKeywordSwitch},
@@ -1562,7 +1560,6 @@ const char * token_name(TokenId id) {
         case TokenIdKeywordFor: return "for";
         case TokenIdKeywordIf: return "if";
         case TokenIdKeywordInline: return "inline";
-        case TokenIdKeywordNakedCC: return "nakedcc";
         case TokenIdKeywordNoAlias: return "noalias";
         case TokenIdKeywordNoAsync: return "noasync";
         case TokenIdKeywordNoInline: return "noinline";
@@ -1573,7 +1570,6 @@ const char * token_name(TokenId id) {
         case TokenIdKeywordPub: return "pub";
         case TokenIdKeywordReturn: return "return";
         case TokenIdKeywordLinkSection: return "linksection";
-        case TokenIdKeywordStdcallCC: return "stdcallcc";
         case TokenIdKeywordStruct: return "struct";
         case TokenIdKeywordSwitch: return "switch";
         case TokenIdKeywordTest: return "test";
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index eacdaad98d..a893cc2373 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -77,7 +77,6 @@ enum TokenId {
     TokenIdKeywordInline,
     TokenIdKeywordNoInline,
     TokenIdKeywordLinkSection,
-    TokenIdKeywordNakedCC,
     TokenIdKeywordNoAlias,
     TokenIdKeywordNoAsync,
     TokenIdKeywordNull,
@@ -87,7 +86,6 @@ enum TokenId {
     TokenIdKeywordPub,
     TokenIdKeywordResume,
     TokenIdKeywordReturn,
-    TokenIdKeywordStdcallCC,
     TokenIdKeywordStruct,
     TokenIdKeywordSuspend,
     TokenIdKeywordSwitch,
-- 
cgit v1.2.3


From 0ea96c11ef5eca9cfd19233b6d51b00ba33da716 Mon Sep 17 00:00:00 2001
From: Vexu <git@vexu.eu>
Date: Tue, 14 Jan 2020 21:24:39 +0200
Subject: disallow multiline strings in test and library names

---
 doc/langref.html.in         | 10 +++++-----
 lib/std/zig/parse.zig       | 26 +++++++++++++-------------
 lib/std/zig/parser_test.zig | 10 ----------
 src/parser.cpp              | 29 +++++++++++++++--------------
 src/tokenizer.cpp           | 19 +++----------------
 src/tokenizer.hpp           |  3 ++-
 6 files changed, 38 insertions(+), 59 deletions(-)

(limited to 'src/parser.cpp')

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 442e4ac52b..092e303013 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -10212,13 +10212,13 @@ ContainerMembers
      / ContainerField
      /
 
-TestDecl &lt;- KEYWORD_test STRINGLITERAL Block
+TestDecl &lt;- KEYWORD_test STRINGLITERALSINGLE Block
 
 TopLevelComptime &lt;- KEYWORD_comptime BlockExpr
 
 TopLevelDecl
-    &lt;- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / KEYWORD_inline)? FnProto (SEMICOLON / Block)
-     / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? KEYWORD_threadlocal? VarDecl
+    &lt;- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / KEYWORD_inline)? FnProto (SEMICOLON / Block)
+     / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
      / KEYWORD_usingnamespace Expr SEMICOLON
 
 FnProto &lt;- FnCC? KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr)
@@ -10561,10 +10561,10 @@ INTEGER
      / "0o" [0-7]+ skip
      / "0x" hex+   skip
      /      [0-9]+ skip
+STRINGLITERALSINGLE &lt;- "\"" string_char* "\"" skip
 STRINGLITERAL
-    &lt;- "\"" string_char* "\"" skip
+    &lt;- STRINGLITERALSINGLE
      / line_string                 skip
-     / line_cstring                skip
 IDENTIFIER
     &lt;- !keyword [A-Za-z_] [A-Za-z0-9_]* skip
      / "@\"" string_char* "\""                            skip
diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 604de516c4..1b6afc1c1a 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -183,10 +183,10 @@ fn parseContainerDocComments(arena: *Allocator, it: *TokenIterator, tree: *Tree)
     return &node.base;
 }
 
-/// TestDecl <- KEYWORD_test STRINGLITERAL Block
+/// TestDecl <- KEYWORD_test STRINGLITERALSINGLE Block
 fn parseTestDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     const test_token = eatToken(it, .Keyword_test) orelse return null;
-    const name_node = try expectNode(arena, it, tree, parseStringLiteral, AstError{
+    const name_node = try expectNode(arena, it, tree, parseStringLiteralSingle, AstError{
         .ExpectedStringLiteral = AstError.ExpectedStringLiteral{ .token = it.index },
     });
     const block_node = try expectNode(arena, it, tree, parseBlock, AstError{
@@ -225,15 +225,15 @@ fn parseTopLevelComptime(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*
 }
 
 /// TopLevelDecl
-///     <- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
-///      / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? KEYWORD_threadlocal? VarDecl
+///     <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
+///      / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
 ///      / KEYWORD_usingnamespace Expr SEMICOLON
 fn parseTopLevelDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     var lib_name: ?*Node = null;
     const extern_export_inline_token = blk: {
         if (eatToken(it, .Keyword_export)) |token| break :blk token;
         if (eatToken(it, .Keyword_extern)) |token| {
-            lib_name = try parseStringLiteral(arena, it, tree);
+            lib_name = try parseStringLiteralSingle(arena, it, tree);
             break :blk token;
         }
         if (eatToken(it, .Keyword_inline)) |token| break :blk token;
@@ -285,12 +285,7 @@ fn parseTopLevelDecl(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
 
     if (extern_export_inline_token) |token| {
         if (lib_name) |string_literal_node|
-            if (string_literal_node.cast(Node.StringLiteral)) |single| {
-                putBackToken(it, single.token);
-            } else if (string_literal_node.cast(Node.MultilineStringLiteral)) |multi| {
-                while (multi.lines.pop()) |line|
-                    putBackToken(it, line);
-            } else unreachable;
+            putBackToken(it, string_literal_node.cast(Node.StringLiteral).?.token);
         putBackToken(it, token);
         return null;
     }
@@ -2776,8 +2771,7 @@ fn createLiteral(arena: *Allocator, comptime T: type, token: TokenIndex) !*Node
     return &result.base;
 }
 
-// string literal or multiline string literal
-fn parseStringLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
+fn parseStringLiteralSingle(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
     if (eatToken(it, .StringLiteral)) |token| {
         const node = try arena.create(Node.StringLiteral);
         node.* = Node.StringLiteral{
@@ -2785,6 +2779,12 @@ fn parseStringLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Nod
         };
         return &node.base;
     }
+    return null;
+}
+
+// string literal or multiline string literal
+fn parseStringLiteral(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node {
+    if (try parseStringLiteralSingle(arena, it, tree)) |node| return node;
 
     if (eatToken(it, .MultilineStringLiteralLine)) |first_line| {
         const node = try arena.create(Node.MultilineStringLiteral);
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 1ebef6a114..c57540ade9 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -2721,16 +2721,6 @@ test "zig fmt: extern without container keyword returns error" {
     );
 }
 
-test "zig fmt: extern multiline lib name" {
-    try testError(
-        \\extern \\super
-        \\    \\long
-        \\    \\library
-        \\    \\name
-        \\
-    );
-}
-
 const std = @import("std");
 const mem = std.mem;
 const warn = std.debug.warn;
diff --git a/src/parser.cpp b/src/parser.cpp
index f6f5811e63..0054c0a0c6 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -141,16 +141,9 @@ static void ast_error(ParseContext *pc, Token *token, const char *format, ...) {
     exit(EXIT_FAILURE);
 }
 
-static Buf ast_token_str(Buf *input, Token *token) {
-    Buf str = BUF_INIT;
-    buf_init_from_mem(&str, buf_ptr(input) + token->start_pos, token->end_pos - token->start_pos);
-    return str;
-}
-
 ATTRIBUTE_NORETURN
 static void ast_invalid_token_error(ParseContext *pc, Token *token) {
-    Buf token_value = ast_token_str(pc->buf, token);
-    ast_error(pc, token, "invalid token: '%s'", buf_ptr(&token_value));
+    ast_error(pc, token, "invalid token: '%s'", token_name(token->id));
 }
 
 static AstNode *ast_create_node_no_line_info(ParseContext *pc, NodeType type) {
@@ -213,7 +206,7 @@ static void put_back_token(ParseContext *pc) {
 static Buf *token_buf(Token *token) {
     if (token == nullptr)
         return nullptr;
-    assert(token->id == TokenIdStringLiteral || token->id == TokenIdSymbol);
+    assert(token->id == TokenIdStringLiteral || token->id == TokenIdMultilineStringLiteral || token->id == TokenIdSymbol);
     return &token->data.str_lit.str;
 }
 
@@ -596,7 +589,7 @@ static AstNodeContainerDecl ast_parse_container_members(ParseContext *pc) {
     return res;
 }
 
-// TestDecl <- KEYWORD_test STRINGLITERAL Block
+// TestDecl <- KEYWORD_test STRINGLITERALSINGLE Block
 static AstNode *ast_parse_test_decl(ParseContext *pc) {
     Token *test = eat_token_if(pc, TokenIdKeywordTest);
     if (test == nullptr)
@@ -630,8 +623,8 @@ static AstNode *ast_parse_top_level_comptime(ParseContext *pc) {
 }
 
 // TopLevelDecl
-//     <- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
-//      / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? KEYWORD_threadlocal? VarDecl
+//     <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
+//      / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
 //      / KEYWORD_use Expr SEMICOLON
 static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, Buf *doc_comments) {
     Token *first = eat_token_if(pc, TokenIdKeywordExport);
@@ -1729,6 +1722,8 @@ static AstNode *ast_parse_primary_type_expr(ParseContext *pc) {
         return ast_create_node(pc, NodeTypeUnreachable, unreachable);
 
     Token *string_lit = eat_token_if(pc, TokenIdStringLiteral);
+    if (string_lit == nullptr)
+        string_lit = eat_token_if(pc, TokenIdMultilineStringLiteral);
     if (string_lit != nullptr) {
         AstNode *res = ast_create_node(pc, NodeTypeStringLiteral, string_lit);
         res->data.string_literal.buf = token_buf(string_lit);
@@ -1957,7 +1952,9 @@ static AsmOutput *ast_parse_asm_output_item(ParseContext *pc) {
     Token *sym_name = expect_token(pc, TokenIdSymbol);
     expect_token(pc, TokenIdRBracket);
 
-    Token *str = expect_token(pc, TokenIdStringLiteral);
+    Token *str = eat_token_if(pc, TokenIdMultilineStringLiteral);
+    if (str == nullptr)
+        str = expect_token(pc, TokenIdStringLiteral);
     expect_token(pc, TokenIdLParen);
 
     Token *var_name = eat_token_if(pc, TokenIdSymbol);
@@ -1999,7 +1996,9 @@ static AsmInput *ast_parse_asm_input_item(ParseContext *pc) {
     Token *sym_name = expect_token(pc, TokenIdSymbol);
     expect_token(pc, TokenIdRBracket);
 
-    Token *constraint = expect_token(pc, TokenIdStringLiteral);
+    Token *constraint = eat_token_if(pc, TokenIdMultilineStringLiteral);
+    if (constraint == nullptr)
+        constraint = expect_token(pc, TokenIdStringLiteral);
     expect_token(pc, TokenIdLParen);
     AstNode *expr = ast_expect(pc, ast_parse_expr);
     expect_token(pc, TokenIdRParen);
@@ -2018,6 +2017,8 @@ static AstNode *ast_parse_asm_clobbers(ParseContext *pc) {
 
     ZigList<Buf *> clobber_list = ast_parse_list<Buf>(pc, TokenIdComma, [](ParseContext *context) {
         Token *str = eat_token_if(context, TokenIdStringLiteral);
+        if (str == nullptr)
+            str = eat_token_if(context, TokenIdMultilineStringLiteral);
         if (str != nullptr)
             return token_buf(str);
         return (Buf*)nullptr;
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 9182c5227a..2aae048cdf 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -209,7 +209,6 @@ enum TokenizeState {
     TokenizeStateLineString,
     TokenizeStateLineStringEnd,
     TokenizeStateLineStringContinue,
-    TokenizeStateLineStringContinueC,
     TokenizeStateSawEq,
     TokenizeStateSawBang,
     TokenizeStateSawLessThan,
@@ -266,7 +265,7 @@ static void set_token_id(Tokenize *t, Token *token, TokenId id) {
     } else if (id == TokenIdFloatLiteral) {
         bigfloat_init_32(&token->data.float_lit.bigfloat, 0.0f);
         token->data.float_lit.overflow = false;
-    } else if (id == TokenIdStringLiteral || id == TokenIdSymbol) {
+    } else if (id == TokenIdStringLiteral || id == TokenIdMultilineStringLiteral || id == TokenIdSymbol) {
         memset(&token->data.str_lit.str, 0, sizeof(Buf));
         buf_resize(&token->data.str_lit.str, 0);
     }
@@ -503,7 +502,7 @@ void tokenize(Buf *buf, Tokenization *out) {
                         t.state = TokenizeStateSawSlash;
                         break;
                     case '\\':
-                        begin_token(&t, TokenIdStringLiteral);
+                        begin_token(&t, TokenIdMultilineStringLiteral);
                         t.state = TokenizeStateSawBackslash;
                         break;
                     case '%':
@@ -945,18 +944,6 @@ void tokenize(Buf *buf, Tokenization *out) {
                         continue;
                 }
                 break;
-            case TokenizeStateLineStringContinueC:
-                switch (c) {
-                    case '\\':
-                        t.state = TokenizeStateLineStringContinue;
-                        break;
-                    default:
-                        t.pos -= 1;
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        continue;
-                }
-                break;
             case TokenizeStateLineStringContinue:
                 switch (c) {
                     case '\\':
@@ -1471,7 +1458,6 @@ void tokenize(Buf *buf, Tokenization *out) {
         case TokenizeStateSawDotDot:
         case TokenizeStateSawBackslash:
         case TokenizeStateLineStringContinue:
-        case TokenizeStateLineStringContinueC:
             tokenize_error(&t, "unexpected EOF");
             break;
         case TokenizeStateLineComment:
@@ -1607,6 +1593,7 @@ const char * token_name(TokenId id) {
         case TokenIdStar: return "*";
         case TokenIdStarStar: return "**";
         case TokenIdStringLiteral: return "StringLiteral";
+        case TokenIdMultilineStringLiteral: return "MultilineStringLiteral";
         case TokenIdSymbol: return "Symbol";
         case TokenIdTilde: return "~";
         case TokenIdTimesEq: return "*=";
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index a893cc2373..3f025ca74a 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -124,6 +124,7 @@ enum TokenId {
     TokenIdStar,
     TokenIdStarStar,
     TokenIdStringLiteral,
+    TokenIdMultilineStringLiteral,
     TokenIdSymbol,
     TokenIdTilde,
     TokenIdTimesEq,
@@ -165,7 +166,7 @@ struct Token {
         // TokenIdFloatLiteral
         TokenFloatLit float_lit;
 
-        // TokenIdStringLiteral or TokenIdSymbol
+        // TokenIdStringLiteral, TokenIdMultilineStringLiteral or TokenIdSymbol
         TokenStrLit str_lit;
 
         // TokenIdCharLiteral
-- 
cgit v1.2.3