Commit 32dd98b19fe3cc384df32704dac0ff3e377dbe0c | zig

CMakeLists.txt+3

README.md+12-12

...	@@ -55,18 +55,18 @@ that counts as "freestanding" for the purposes of this table.	...	@@ -55,18 +55,18 @@ that counts as "freestanding" for the purposes of this table.
55	\|i386 \| OK \| planned \| OK \| planned \| planned \|	55	\|i386 \| OK \| planned \| OK \| planned \| planned \|
56	\|x86_64 \| OK \| OK \| OK \| OK \| planned \|	56	\|x86_64 \| OK \| OK \| OK \| OK \| planned \|
57	\|arm \| OK \| planned \| planned \| N/A \| planned \|	57	\|arm \| OK \| planned \| planned \| N/A \| planned \|
58	\|aarch64 \| OK \| planned \| planned \| planned \| planned \|	58	\|aarch64 \| OK \| planned \| N/A \| planned \| planned \|
59	\|bpf \| OK \| planned \| planned \| N/A \| planned \|	59	\|bpf \| OK \| planned \| N/A \| N/A \| planned \|
60	\|hexagon \| OK \| planned \| planned \| N/A \| planned \|	60	\|hexagon \| OK \| planned \| N/A \| N/A \| planned \|
61	\|mips \| OK \| planned \| planned \| N/A \| planned \|	61	\|mips \| OK \| planned \| N/A \| N/A \| planned \|
62	\|powerpc \| OK \| planned \| planned \| N/A \| planned \|	62	\|powerpc \| OK \| planned \| N/A \| N/A \| planned \|
63	\|r600 \| OK \| planned \| planned \| N/A \| planned \|	63	\|r600 \| OK \| planned \| N/A \| N/A \| planned \|
64	\|amdgcn \| OK \| planned \| planned \| N/A \| planned \|	64	\|amdgcn \| OK \| planned \| N/A \| N/A \| planned \|
65	\|sparc \| OK \| planned \| planned \| N/A \| planned \|	65	\|sparc \| OK \| planned \| N/A \| N/A \| planned \|
66	\|s390x \| OK \| planned \| planned \| N/A \| planned \|	66	\|s390x \| OK \| planned \| N/A \| N/A \| planned \|
67	\|thumb \| OK \| planned \| planned \| N/A \| planned \|	67	\|thumb \| OK \| planned \| N/A \| N/A \| planned \|
68	\|spir \| OK \| planned \| planned \| N/A \| planned \|	68	\|spir \| OK \| planned \| N/A \| N/A \| planned \|
69	\|lanai \| OK \| planned \| planned \| N/A \| planned \|	69	\|lanai \| OK \| planned \| N/A \| N/A \| planned \|
70		70
71	## Community	71	## Community
72		72

build.zig+5-4

doc/codegen.md+4-4

...	@@ -6,7 +6,7 @@ Every type has a "handle". If a type is a simple primitive type such as i32 or	...	@@ -6,7 +6,7 @@ Every type has a "handle". If a type is a simple primitive type such as i32 or
6	f64, the handle is "by value", meaning that we pass around the value itself when	6	f64, the handle is "by value", meaning that we pass around the value itself when
7	we refer to a value of that type.	7	we refer to a value of that type.
8		8
9	If a type is a container, error union, maybe type, slice, or array, then its	9	If a type is a container, error union, optional type, slice, or array, then its
10	handle is a pointer, and everywhere we refer to a value of this type we refer to	10	handle is a pointer, and everywhere we refer to a value of this type we refer to
11	a pointer.	11	a pointer.
12		12
...	@@ -19,7 +19,7 @@ Error union types are represented as:	...	@@ -19,7 +19,7 @@ Error union types are represented as:
19	payload: T,	19	payload: T,
20	}	20	}
21		21
22	Maybe types are represented as:	22	Optional types are represented as:
23		23
24	struct {	24	struct {
25	payload: T,	25	payload: T,
...	@@ -28,6 +28,6 @@ Maybe types are represented as:	...	@@ -28,6 +28,6 @@ Maybe types are represented as:
28		28
29	## Data Optimizations	29	## Data Optimizations
30		30
31	Maybe pointer types are special: the 0x0 pointer value is used to represent a	31	Optional pointer types are special: the 0x0 pointer value is used to represent a
32	null pointer. Thus, instead of the struct above, maybe pointer types are	32	null pointer. Thus, instead of the struct above, optional pointer types are
33	represented as a `usize` in codegen and the handle is by value.	33	represented as a `usize` in codegen and the handle is by value.

doc/docgen.zig+28-11

...	@@ -25,13 +25,13 @@ pub fn main() !void {	...	@@ -25,13 +25,13 @@ pub fn main() !void {
25		25
26	if (!args_it.skip()) @panic("expected self arg");	26	if (!args_it.skip()) @panic("expected self arg");
27		27
28	const zig_exe = try (args_it.next(allocator) ?? @panic("expected zig exe arg"));	28	const zig_exe = try (args_it.next(allocator) orelse @panic("expected zig exe arg"));
29	defer allocator.free(zig_exe);	29	defer allocator.free(zig_exe);
30		30
31	const in_file_name = try (args_it.next(allocator) ?? @panic("expected input arg"));	31	const in_file_name = try (args_it.next(allocator) orelse @panic("expected input arg"));
32	defer allocator.free(in_file_name);	32	defer allocator.free(in_file_name);
33		33
34	const out_file_name = try (args_it.next(allocator) ?? @panic("expected output arg"));	34	const out_file_name = try (args_it.next(allocator) orelse @panic("expected output arg"));
35	defer allocator.free(out_file_name);	35	defer allocator.free(out_file_name);
36		36
37	var in_file = try os.File.openRead(allocator, in_file_name);	37	var in_file = try os.File.openRead(allocator, in_file_name);
...	@@ -51,14 +51,8 @@ pub fn main() !void {	...	@@ -51,14 +51,8 @@ pub fn main() !void {
51	var toc = try genToc(allocator, &tokenizer);	51	var toc = try genToc(allocator, &tokenizer);
52		52
53	try os.makePath(allocator, tmp_dir_name);	53	try os.makePath(allocator, tmp_dir_name);
54	defer {	54	defer os.deleteTree(allocator, tmp_dir_name) catch {};
55	// TODO issue #709	55
56	// disabled to pass CI tests, but obviously we want to implement this
57	// and then remove this workaround
58	if (builtin.os != builtin.Os.windows) {
59	os.deleteTree(allocator, tmp_dir_name) catch {};
60	}
61	}
62	try genHtml(allocator, &tokenizer, &toc, &buffered_out_stream.stream, zig_exe);	56	try genHtml(allocator, &tokenizer, &toc, &buffered_out_stream.stream, zig_exe);
63	try buffered_out_stream.flush();	57	try buffered_out_stream.flush();
64	}	58	}
...	@@ -300,6 +294,7 @@ const Link = struct {	...	@@ -300,6 +294,7 @@ const Link = struct {
300	const Node = union(enum) {	294	const Node = union(enum) {
301	Content: []const u8,	295	Content: []const u8,
302	Nav,	296	Nav,
		297	Builtin,
303	HeaderOpen: HeaderOpen,	298	HeaderOpen: HeaderOpen,
304	SeeAlso: []const SeeAlsoItem,	299	SeeAlso: []const SeeAlsoItem,
305	Code: Code,	300	Code: Code,
...	@@ -356,6 +351,9 @@ fn genToc(allocator: mem.Allocator, tokenizer: Tokenizer) !Toc {	...	@@ -356,6 +351,9 @@ fn genToc(allocator: mem.Allocator, tokenizer: Tokenizer) !Toc {
356	_ = try eatToken(tokenizer, Token.Id.BracketClose);	351	_ = try eatToken(tokenizer, Token.Id.BracketClose);
357		352
358	try nodes.append(Node.Nav);	353	try nodes.append(Node.Nav);
		354	} else if (mem.eql(u8, tag_name, "builtin")) {
		355	_ = try eatToken(tokenizer, Token.Id.BracketClose);
		356	try nodes.append(Node.Builtin);
359	} else if (mem.eql(u8, tag_name, "header_open")) {	357	} else if (mem.eql(u8, tag_name, "header_open")) {
360	_ = try eatToken(tokenizer, Token.Id.Separator);	358	_ = try eatToken(tokenizer, Token.Id.Separator);
361	const content_token = try eatToken(tokenizer, Token.Id.TagContent);	359	const content_token = try eatToken(tokenizer, Token.Id.TagContent);
...	@@ -690,6 +688,9 @@ fn termColor(allocator: *mem.Allocator, input: []const u8) ![]u8 {	...	@@ -690,6 +688,9 @@ fn termColor(allocator: *mem.Allocator, input: []const u8) ![]u8 {
690		688
691	fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var, zig_exe: []const u8) !void {	689	fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var, zig_exe: []const u8) !void {
692	var code_progress_index: usize = 0;	690	var code_progress_index: usize = 0;
		691
		692	const builtin_code = try escapeHtml(allocator, try getBuiltinCode(allocator, zig_exe));
		693
693	for (toc.nodes) \|node\| {	694	for (toc.nodes) \|node\| {
694	switch (node) {	695	switch (node) {
695	Node.Content => \|data\| {	696	Node.Content => \|data\| {
...	@@ -704,6 +705,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -704,6 +705,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
704	Node.Nav => {	705	Node.Nav => {
705	try out.write(toc.toc);	706	try out.write(toc.toc);
706	},	707	},
		708	Node.Builtin => {
		709	try out.print("<pre><code class=\"zig\">{}</code></pre>", builtin_code);
		710	},
707	Node.HeaderOpen => \|info\| {	711	Node.HeaderOpen => \|info\| {
708	try out.print("<h{} id=\"{}\">{}</h{}>\n", info.n, info.url, info.name, info.n);	712	try out.print("<h{} id=\"{}\">{}</h{}>\n", info.n, info.url, info.name, info.n);
709	},	713	},
...	@@ -954,6 +958,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -954,6 +958,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
954	var build_args = std.ArrayList([]const u8).init(allocator);	958	var build_args = std.ArrayList([]const u8).init(allocator);
955	defer build_args.deinit();	959	defer build_args.deinit();
956		960
		961	const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", code.name);
		962	const output_h_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_h_ext);
		963
957	try build_args.appendSlice([][]const u8{	964	try build_args.appendSlice([][]const u8{
958	zig_exe,	965	zig_exe,
959	"build-obj",	966	"build-obj",
...	@@ -962,6 +969,8 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -962,6 +969,8 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
962	"on",	969	"on",
963	"--output",	970	"--output",
964	tmp_obj_file_name,	971	tmp_obj_file_name,
		972	"--output-h",
		973	output_h_file_name,
965	});	974	});
966		975
967	if (!code.is_inline) {	976	if (!code.is_inline) {
...	@@ -1060,3 +1069,11 @@ fn exec(allocator: *mem.Allocator, args: []const []const u8) !os.ChildProcess.Ex	...	@@ -1060,3 +1069,11 @@ fn exec(allocator: *mem.Allocator, args: []const []const u8) !os.ChildProcess.Ex
1060	}	1069	}
1061	return result;	1070	return result;
1062	}	1071	}
		1072
		1073	fn getBuiltinCode(allocator: *mem.Allocator, zig_exe: []const u8) ![]const u8 {
		1074	const result = try exec(allocator, []const []const u8{
		1075	zig_exe,
		1076	"builtin",
		1077	});
		1078	return result.stdout;
		1079	}

doc/langref.html.in+609-511

 @@ -156,18 +156,18 @@ pub fn main() void {
         true or false,
         !true);
-    // nullable
+    // optional
-    var nullable_value: ?[]const u8 = null;
+    var optional_value: ?[]const u8 = null;
-    assert(nullable_value == null);
+    assert(optional_value == null);
-    warn("\nnullable 1\ntype: {}\nvalue: {}\n",
+    warn("\noptional 1\ntype: {}\nvalue: {}\n",
-        @typeName(@typeOf(nullable_value)), nullable_value);
+        @typeName(@typeOf(optional_value)), optional_value);
-    nullable_value = "hi";
+    optional_value = "hi";
-    assert(nullable_value != null);
+    assert(optional_value != null);
-    warn("\nnullable 2\ntype: {}\nvalue: {}\n",
+    warn("\noptional 2\ntype: {}\nvalue: {}\n",
-        @typeName(@typeOf(nullable_value)), nullable_value);
+        @typeName(@typeOf(optional_value)), optional_value);
     // error union
     var number_or_error: error!i32 = error.ArgNotFound;
 @@ -428,7 +428,7 @@ pub fn main() void {
         </tr>
         <tr>
           <td><code>null</code></td>
-          <td>used to set a nullable type to <code>null</code></td>
+          <td>used to set an optional type to <code>null</code></td>
         </tr>
         <tr>
           <td><code>undefined</code></td>
 @@ -440,7 +440,7 @@ pub fn main() void {
         </tr>
       </table>
       </div>
-      {#see_also|Nullables|this#}
+      {#see_also|Optionals|this#}
       {#header_close#}
       {#header_open|String Literals#}
       {#code_begin|test#}
 @@ -590,6 +590,7 @@ test "initialization" {
     x = 1;
 }
       {#code_end#}
+      {#header_open|undefined#}
       <p>Use <code>undefined</code> to leave variables uninitialized:</p>
       {#code_begin|test#}
 const assert = @import("std").debug.assert;
 @@ -602,6 +603,7 @@ test "init with undefined" {
       {#code_end#}
       {#header_close#}
       {#header_close#}
+      {#header_close#}
       {#header_open|Integers#}
       {#header_open|Integer Literals#}
       {#code_begin|syntax#}
 @@ -985,10 +987,10 @@ a ^= b</code></pre></td>
           </td>
         </tr>
         <tr>
-          <td><pre><code class="zig">a ?? b</code></pre></td>
+          <td><pre><code class="zig">a orelse b</code></pre></td>
           <td>
             <ul>
-              <li>{#link|Nullables#}</li>
+              <li>{#link|Optionals#}</li>
             </ul>
           </td>
           <td>If <code>a</code> is <code>null</code>,
 @@ -998,24 +1000,24 @@ a ^= b</code></pre></td>
           </td>
           <td>
             <pre><code class="zig">const value: ?u32 = null;
-const unwrapped = value ?? 1234;
+const unwrapped = value orelse 1234;
 unwrapped == 1234</code></pre>
           </td>
         </tr>
         <tr>
-          <td><pre><code class="zig">??a</code></pre></td>
+          <td><pre><code class="zig">a.?</code></pre></td>
           <td>
             <ul>
-              <li>{#link|Nullables#}</li>
+              <li>{#link|Optionals#}</li>
             </ul>
           </td>
           <td>
             Equivalent to:
-            <pre><code class="zig">a ?? unreachable</code></pre>
+            <pre><code class="zig">a orelse unreachable</code></pre>
           </td>
           <td>
             <pre><code class="zig">const value: ?u32 = 5678;
-??value == 5678</code></pre>
+value.? == 5678</code></pre>
           </td>
         </tr>
         <tr>
 @@ -1103,7 +1105,7 @@ unwrapped == 1234</code></pre>
           <td><pre><code class="zig">a == null<code></pre></td>
           <td>
             <ul>
-              <li>{#link|Nullables#}</li>
+              <li>{#link|Optionals#}</li>
             </ul>
           </td>
           <td>
 @@ -1261,15 +1263,31 @@ const ptr = &amp;x;
 x.* == 1234</code></pre>
           </td>
         </tr>
+        <tr>
+          <td><pre><code class="zig">a || b<code></pre></td>
+          <td>
+            <ul>
+              <li>{#link|Error Set Type#}</li>
+            </ul>
+          </td>
+          <td>
+              {#link|Merging Error Sets#}
+          </td>
+          <td>
+            <pre><code class="zig">const A = error{One};
+const B = error{Two};
+(A || B) == error{One, Two}</code></pre>
+          </td>
+        </tr>
       </table>
       </div>
       {#header_close#}
       {#header_open|Precedence#}
       <pre><code>x() x[] x.y
 a!b
-!x -x -%x ~x &amp;x ?x ??x
+!x -x -%x ~x &amp;x ?x
-x{} x.*
+x{} x.* x.?
-! * / % ** *%
+! * / % ** *% ||
 + - ++ +% -%
 &lt;&lt; &gt;&gt;
 &amp;
 @@ -1278,7 +1296,7 @@ x{} x.*
 == != &lt; &gt; &lt;= &gt;=
 and
 or
-?? catch
+orelse catch
 = *= /= %= += -= &lt;&lt;= &gt;&gt;= &amp;= ^= |=</code></pre>
       {#header_close#}
       {#header_close#}
 @@ -1483,17 +1501,17 @@ test "volatile" {
     assert(@typeOf(mmio_ptr) == *volatile u8);
 }
-test "nullable pointers" {
+test "optional pointers" {
-    // Pointers cannot be null. If you want a null pointer, use the nullable
+    // Pointers cannot be null. If you want a null pointer, use the optional
-    // prefix `?` to make the pointer type nullable.
+    // prefix `?` to make the pointer type optional.
     var ptr: ?*i32 = null;
     var x: i32 = 1;
     ptr = &x;
-    assert((??ptr).* == 1);
+    assert(ptr.?.* == 1);
-    // Nullable pointers are the same size as normal pointers, because pointer
+    // Optional pointers are the same size as normal pointers, because pointer
     // value 0 is used as the null value.
     assert(@sizeOf(?*i32) == @sizeOf(*i32));
 }
 @@ -1832,7 +1850,7 @@ test "linked list" {
         .last = &node,
         .len = 1,
     };
-    assert((??list2.first).data == 1234);
+    assert(list2.first.?.data == 1234);
 }
       {#code_end#}
       {#see_also|comptime|@fieldParentPtr#}
 @@ -2270,7 +2288,7 @@ fn rangeHasNumber(begin: usize, end: usize, number: usize) bool {
 }
 test "while null capture" {
-    // Just like if expressions, while loops can take a nullable as the
+    // Just like if expressions, while loops can take an optional as the
     // condition and capture the payload. When null is encountered the loop
     // exits.
     var sum1: u32 = 0;
 @@ -2280,7 +2298,7 @@ test "while null capture" {
     }
     assert(sum1 == 3);
-    // The else branch is allowed on nullable iteration. In this case, it will
+    // The else branch is allowed on optional iteration. In this case, it will
     // be executed on the first null value encountered.
     var sum2: u32 = 0;
     numbers_left = 3;
 @@ -2340,7 +2358,7 @@ fn typeNameLength(comptime T: type) usize {
     return @typeName(T).len;
 }
       {#code_end#}
-      {#see_also|if|Nullables|Errors|comptime|unreachable#}
+      {#see_also|if|Optionals|Errors|comptime|unreachable#}
       {#header_close#}
       {#header_open|for#}
       {#code_begin|test|for#}
 @@ -2400,7 +2418,7 @@ test "for else" {
         if (value == null) {
             break 9;
         } else {
-            sum += ??value;
+            sum += value.?;
         }
     } else blk: {
         assert(sum == 7);
 @@ -2461,7 +2479,7 @@ test "if boolean" {
     assert(result == 47);
 }
-test "if nullable" {
+test "if optional" {
     // If expressions test for null.
     const a: ?u32 = 0;
 @@ -2544,7 +2562,7 @@ test "if error union" {
     }
 }
       {#code_end#}
-      {#see_also|Nullables|Errors#}
+      {#see_also|Optionals|Errors#}
       {#header_close#}
       {#header_open|defer#}
       {#code_begin|test|defer#}
 @@ -2983,6 +3001,7 @@ test "parse u64" {
         <li>You know with complete certainty it will not return an error, so want to unconditionally unwrap it.</li>
         <li>You want to take a different action for each possible error.</li>
       </ul>
+      {#header_open|catch#}
       <p>If you want to provide a default value, you can use the <code>catch</code> binary operator:</p>
       {#code_begin|syntax#}
 fn doAThing(str: []u8) void {
 @@ -2995,6 +3014,8 @@ fn doAThing(str: []u8) void {
       a default value of 13. The type of the right hand side of the binary <code>catch</code> operator must
       match the unwrapped error union type, or be of type <code>noreturn</code>.
       </p>
+      {#header_close#}
+      {#header_open|try#}
       <p>Let's say you wanted to return the error if you got one, otherwise continue with the
       function logic:</p>
       {#code_begin|syntax#}
 @@ -3017,6 +3038,7 @@ fn doAThing(str: []u8) !void {
       from the current function with the same error. Otherwise, the expression results in
       the unwrapped value.
       </p>
+      {#header_close#}
       <p>
         Maybe you know with complete certainty that an expression will never be an error.
         In this case you can do this:
 @@ -3031,7 +3053,7 @@ fn doAThing(str: []u8) !void {
       </p>
       <p>
       Finally, you may want to take a different action for every situation. For that, we combine
-      the <code>if</code> and <code>switch</code> expression:
+      the {#link|if#} and {#link|switch#} expression:
       </p>
       {#code_begin|syntax#}
 fn doAThing(str: []u8) void {
 @@ -3046,9 +3068,10 @@ fn doAThing(str: []u8) void {
     }
 }
       {#code_end#}
+      {#header_open|errdefer#}
       <p>
       The other component to error handling is defer statements.
-      In addition to an unconditional <code>defer</code>, Zig has <code>errdefer</code>,
+      In addition to an unconditional {#link|defer#}, Zig has <code>errdefer</code>,
       which evaluates the deferred expression on block exit path if and only if
       the function returned with an error from the block.
       </p>
 @@ -3062,7 +3085,7 @@ fn createFoo(param: i32) !Foo {
     // but we want to return it if the function succeeds.
     errdefer deallocateFoo(foo);
-    const tmp_buf = allocateTmpBuffer() ?? return error.OutOfMemory;
+    const tmp_buf = allocateTmpBuffer() orelse return error.OutOfMemory;
     // tmp_buf is truly a temporary resource, and we for sure want to clean it up
     // before this block leaves scope
     defer deallocateTmpBuffer(tmp_buf);
 @@ -3079,6 +3102,7 @@ fn createFoo(param: i32) !Foo {
       the verbosity and cognitive overhead of trying to make sure every exit path
       is covered. The deallocation code is always directly following the allocation code.
       </p>
+      {#header_close#}
       <p>
       A couple of other tidbits about error handling:
       </p>
 @@ -3117,7 +3141,50 @@ test "error union" {
     comptime assert(@typeOf(foo).ErrorSet == error);
 }
       {#code_end#}
-      <p>TODO the <code>||</code> operator for error sets</p>
+      {#header_open|Merging Error Sets#}
+      <p>
+      Use the <code>||</code> operator to merge two error sets together. The resulting
+      error set contains the errors of both error sets. Doc comments from the left-hand
+      side override doc comments from the right-hand side. In this example, the doc
+      comments for <code>C.PathNotFound</code> is <code>A doc comment</code>.
+      </p>
+      <p>
+      This is especially useful for functions which return different error sets depending
+      on {#link|comptime#} branches. For example, the Zig standard library uses
+      <code>LinuxFileOpenError || WindowsFileOpenError</code> for the error set of opening
+      files.
+      </p>
+      {#code_begin|test#}
+const A = error{
+    NotDir,
+    /// A doc comment
+    PathNotFound,
+};
+const B = error{
+    OutOfMemory,
+    /// B doc comment
+    PathNotFound,
+};
+const C = A || B;
+fn foo() C!void {
+    return error.NotDir;
+}
+test "merge error sets" {
+    if (foo()) {
+        @panic("unexpected");
+    } else |err| switch (err) {
+        error.OutOfMemory => @panic("unexpected"),
+        error.PathNotFound => @panic("unexpected"),
+        error.NotDir => {},
+    }
+}
+      {#code_end#}
+      {#header_close#}
       {#header_open|Inferred Error Sets#}
       <p>
       Because many functions in Zig return a possible error, Zig supports inferring the error set.
 @@ -3164,27 +3231,194 @@ test "inferred error set" {
       {#header_close#}
       {#header_close#}
       {#header_open|Error Return Traces#}
-      <p>TODO</p>
+      <p>
+      Error Return Traces show all the points in the code that an error was returned to the calling function. This makes it practical to use {#link|try#} everywhere and then still be able to know what happened if an error ends up bubbling all the way out of your application.
+      </p>
+      {#code_begin|exe_err#}
+pub fn main() !void {
+    try foo(12);
+}
+fn foo(x: i32) !void {
+    if (x >= 5) {
+        try bar();
+    } else {
+        try bang2();
+    }
+}
+fn bar() !void {
+    if (baz()) {
+        try quux();
+    } else |err| switch (err) {
+        error.FileNotFound => try hello(),
+        else => try another(),
+    }
+}
+fn baz() !void {
+    try bang1();
+}
+fn quux() !void {
+    try bang2();
+}
+fn hello() !void {
+    try bang2();
+}
+fn another() !void {
+    try bang1();
+}
+fn bang1() !void {
+    return error.FileNotFound;
+}
+fn bang2() !void {
+    return error.PermissionDenied;
+}
+      {#code_end#}
+      <p>
+      Look closely at this example. This is no stack trace.
+      </p>
+      <p>
+      You can see that the final error bubbled up was <code>PermissionDenied</code>,
+      but the original error that started this whole thing was <code>FileNotFound</code>. In the <code>bar</code> function, the code handles the original error code,
+      and then returns another one, from the switch statement. Error Return Traces make this clear, whereas a stack trace would look like this:
+      </p>
+      {#code_begin|exe_err#}
+pub fn main() void {
+    foo(12);
+}
+fn foo(x: i32) void {
+    if (x >= 5) {
+        bar();
+    } else {
+        bang2();
+    }
+}
+fn bar() void {
+    if (baz()) {
+        quux();
+    } else {
+        hello();
+    }
+}
+fn baz() bool {
+    return bang1();
+}
+fn quux() void {
+    bang2();
+}
+fn hello() void {
+    bang2();
+}
+fn bang1() bool {
+    return false;
+}
+fn bang2() void {
+    @panic("PermissionDenied");
+}
+      {#code_end#}
+      <p>
+      Here, the stack trace does not explain how the control
+      flow in <code>bar</code> got to the <code>hello()</code> call.
+      One would have to open a debugger or further instrument the application
+      in order to find out. The error return trace, on the other hand,
+      shows exactly how the error bubbled up.
+      </p>
+      <p>
+      This debugging feature makes it easier to iterate quickly on code that
+      robustly handles all error conditions. This means that Zig developers
+      will naturally find themselves writing correct, robust code in order
+      to increase their development pace.
+      </p>
+      <p>
+      Error Return Traces are enabled by default in {#link|Debug#} and {#link|ReleaseSafe#} builds and disabled by default in {#link|ReleaseFast#} and {#link|ReleaseSmall#} builds.
+      </p>
+      <p>
+      There are a few ways to activate this error return tracing feature:
+      </p>
+      <ul>
+        <li>Return an error from main</li>
+        <li>An error makes its way to <code>catch unreachable</code> and you have not overridden the default panic handler</li>
+        <li>Use {#link|errorReturnTrace#} to access the current return trace. You can use <code>std.debug.dumpStackTrace</code> to print it. This function returns comptime-known {#link|null#} when building without error return tracing support.</li>
+      </ul>
+      {#header_open|Implementation Details#}
+      <p>
+      To analyze performance cost, there are two cases:
+      </p>
+      <ul>
+        <li>when no errors are returned</li>
+        <li>when returning errors</li>
+      </ul>
+      <p>
+      For the case when no errors are returned, the cost is a single memory write operation, only in the first non-failable function in the call graph that calls a failable function, i.e. when a function returning <code>void</code> calls a function returning <code>error</code>.
+      This is to initialize this struct in the stack memory:
+      </p>
+      {#code_begin|syntax#}
+pub const StackTrace = struct {
+    index: usize,
+    instruction_addresses: [N]usize,
+};
+      {#code_end#}
+      <p>
+      Here, N is the maximum function call depth as determined by call graph analysis. Recursion is ignored and counts for 2.
+      </p>
+      <p>
+      A pointer to <code>StackTrace</code> is passed as a secret parameter to every function that can return an error, but it's always the first parameter, so it can likely sit in a register and stay there.
+      </p>
+      <p>
+      That's it for the path when no errors occur. It's practically free in terms of performance.
+      </p>
+      <p>
+      When generating the code for a function that returns an error, just before the <code>return</code> statement (only for the <code>return</code> statements that return errors), Zig generates a call to this function:
+      </p>
+      {#code_begin|syntax#}
+// marked as "no-inline" in LLVM IR
+fn __zig_return_error(stack_trace: *StackTrace) void {
+    stack_trace.instruction_addresses[stack_trace.index] = @returnAddress();
+    stack_trace.index = (stack_trace.index + 1) % N;
+}
+      {#code_end#}
+      <p>
+      The cost is 2 math operations plus some memory reads and writes. The memory accessed is constrained and should remain cached for the duration of the error return bubbling.
+      </p>
+      <p>
+      As for code size cost, 1 function call before a return statement is no big deal. Even so,
+      I have <a href="https://github.com/ziglang/zig/issues/690">a plan</a> to make the call to
+      <code>__zig_return_error</code> a tail call, which brings the code size cost down to actually zero. What is a return statement in code without error return tracing can become a jump instruction in code with error return tracing.
+      </p>
       {#header_close#}
       {#header_close#}
-      {#header_open|Nullables#}
+      {#header_close#}
+      {#header_open|Optionals#}
       <p>
       One area that Zig provides safety without compromising efficiency or
-      readability is with the nullable type.
+      readability is with the optional type.
       </p>
       <p>
-      The question mark symbolizes the nullable type. You can convert a type to a nullable
+      The question mark symbolizes the optional type. You can convert a type to an optional
       type by putting a question mark in front of it, like this:
       </p>
       {#code_begin|syntax#}
 // normal integer
 const normal_int: i32 = 1234;
-// nullable integer
+// optional integer
-const nullable_int: ?i32 = 5678;
+const optional_int: ?i32 = 5678;
       {#code_end#}
       <p>
-      Now the variable <code>nullable_int</code> could be an <code>i32</code>, or <code>null</code>.
+      Now the variable <code>optional_int</code> could be an <code>i32</code>, or <code>null</code>.
       </p>
       <p>
       Instead of integers, let's talk about pointers. Null references are the source of many runtime
 @@ -3193,8 +3427,8 @@ const nullable_int: ?i32 = 5678;
       </p>
       <p>Zig does not have them.</p>
       <p>
-      Instead, you can use a nullable pointer. This secretly compiles down to a normal pointer,
+      Instead, you can use an optional pointer. This secretly compiles down to a normal pointer,
-      since we know we can use 0 as the null value for the nullable type. But the compiler
+      since we know we can use 0 as the null value for the optional type. But the compiler
       can check your work and make sure you don't assign null to something that can't be null.
       </p>
       <p>
 @@ -3219,14 +3453,14 @@ struct Foo *do_a_thing(void) {
 extern fn malloc(size: size_t) ?*u8;
 fn doAThing() ?*Foo {
-    const ptr = malloc(1234) ?? return null;
+    const ptr = malloc(1234) orelse return null;
     // ...
 }
       {#code_end#}
       <p>
         Here, Zig is at least as convenient, if not more, than C. And, the type of "ptr"
-        is <code>*u8</code> <em>not</em> <code>?*u8</code>. The <code>??</code> operator
+        is <code>*u8</code> <em>not</em> <code>?*u8</code>. The <code>orelse</code> keyword
-        unwrapped the nullable type and therefore <code>ptr</code> is guaranteed to be non-null everywhere
+        unwrapped the optional type and therefore <code>ptr</code> is guaranteed to be non-null everywhere
         it is used in the function.
       </p>
       <p>
 @@ -3245,10 +3479,10 @@ fn doAThing() ?*Foo {
         In Zig you can accomplish the same thing:
       </p>
       {#code_begin|syntax#}
-fn doAThing(nullable_foo: ?*Foo) void {
+fn doAThing(optional_foo: ?*Foo) void {
     // do some stuff
-    if (nullable_foo) |foo| {
+    if (optional_foo) |foo| {
       doSomethingWithFoo(foo);
     }
 @@ -3257,7 +3491,7 @@ fn doAThing(nullable_foo: ?*Foo) void {
       {#code_end#}
       <p>
       Once again, the notable thing here is that inside the if block,
-      <code>foo</code> is no longer a nullable pointer, it is a pointer, which
+      <code>foo</code> is no longer an optional pointer, it is a pointer, which
       cannot be null.
       </p>
       <p>
 @@ -3267,22 +3501,31 @@ fn doAThing(nullable_foo: ?*Foo) void {
       The optimizer can sometimes make better decisions knowing that pointer arguments
       cannot be null.
       </p>
-      {#header_open|Nullable Type#}
+      {#header_open|Optional Type#}
-      <p>A nullable is created by putting <code>?</code> in front of a type. You can use compile-time
+      <p>An optional is created by putting <code>?</code> in front of a type. You can use compile-time
-      reflection to access the child type of a nullable:</p>
+      reflection to access the child type of an optional:</p>
       {#code_begin|test#}
 const assert = @import("std").debug.assert;
-test "nullable type" {
+test "optional type" {
-    // Declare a nullable and implicitly cast from null:
+    // Declare an optional and implicitly cast from null:
     var foo: ?i32 = null;
-    // Implicitly cast from child type of a nullable
+    // Implicitly cast from child type of an optional
     foo = 1234;
-    // Use compile-time reflection to access the child type of the nullable:
+    // Use compile-time reflection to access the child type of the optional:
     comptime assert(@typeOf(foo).Child == i32);
 }
+      {#code_end#}
+      {#header_close#}
+      {#header_open|null#}
+      <p>
+      Just like {#link|undefined#}, <code>null</code> has its own type, and the only way to use it is to
+      cast it to a different type:
+      </p>
+      {#code_begin|syntax#}
+const optional_value: ?i32 = null;
       {#code_end#}
       {#header_close#}
       {#header_close#}
 @@ -3845,9 +4088,6 @@ pub fn printValue(self: *OutStream, value: var) !void {
         return self.printInt(T, value);
     } else if (@isFloat(T)) {
         return self.printFloat(T, value);
-    } else if (@canImplicitCast([]const u8, value)) {
-        const casted_value = ([]const u8)(value);
-        return self.write(casted_value);
     } else {
         @compileError("Unable to print type '" ++ @typeName(T) ++ "'");
     }
 @@ -3911,6 +4151,277 @@ pub fn main() void {
       <p>TODO: @fence()</p>
       <p>TODO: @atomic rmw</p>
       <p>TODO: builtin atomic memory ordering enum</p>
+      {#header_close#}
+      {#header_open|Coroutines#}
+      <p>
+      A coroutine is a generalization of a function.
+      </p>
+      <p>
+      When you call a function, it creates a stack frame,
+      and then the function runs until it reaches a return
+      statement, and then the stack frame is destroyed.
+      At the callsite, the next line of code does not run
+      until the function returns.
+      </p>
+      <p>
+      A coroutine is like a function, but it can be suspended
+      and resumed any number of times, and then it must be
+      explicitly destroyed. When a coroutine suspends, it
+      returns to the resumer.
+      </p>
+      {#header_open|Minimal Coroutine Example#}
+      <p>
+      Declare a coroutine with the <code>async</code> keyword.
+      The expression in angle brackets must evaluate to a struct
+      which has these fields:
+      </p>
+      <ul>
+        <li><code>allocFn: fn (self: *Allocator, byte_count: usize, alignment: u29) Error![]u8</code> - where <code>Error</code> can be any error set.</li>
+        <li><code>freeFn: fn (self: *Allocator, old_mem: []u8) void</code></li>
+      </ul>
+      <p>
+      You may notice that this corresponds to the <code>std.mem.Allocator</code> interface.
+      This makes it convenient to integrate with existing allocators. Note, however,
+      that the language feature does not depend on the standard library, and any struct which
+      has these fields is allowed.
+      </p>
+      <p>
+      Omitting the angle bracket expression when defining an async function makes
+      the function generic. Zig will infer the allocator type when the async function is called.
+      </p>
+      <p>
+      Call a coroutine with the <code>async</code> keyword. Here, the expression in angle brackets
+      is a pointer to the allocator struct that the coroutine expects.
+      </p>
+      <p>
+      The result of an async function call is a <code>promise->T</code> type, where <code>T</code>
+      is the return type of the async function. Once a promise has been created, it must be
+      consumed, either with <code>cancel</code> or <code>await</code>:
+      </p>
+      <p>
+      Async functions start executing when created, so in the following example, the entire
+      async function completes before it is canceled:
+      </p>
+      {#code_begin|test#}
+const std = @import("std");
+const assert = std.debug.assert;
+var x: i32 = 1;
+test "create a coroutine and cancel it" {
+    const p = try async<std.debug.global_allocator> simpleAsyncFn();
+    comptime assert(@typeOf(p) == promise->void);
+    cancel p;
+    assert(x == 2);
+}
+async<*std.mem.Allocator> fn simpleAsyncFn() void {
+    x += 1;
+}
+      {#code_end#}
+      {#header_close#}
+      {#header_open|Suspend and Resume#}
+      <p>
+      At any point, an async function may suspend itself. This causes control flow to
+      return to the caller or resumer. The following code demonstrates where control flow
+      goes:
+      </p>
+      {#code_begin|test#}
+const std = @import("std");
+const assert = std.debug.assert;
+test "coroutine suspend, resume, cancel" {
+    seq('a');
+    const p = try async<std.debug.global_allocator> testAsyncSeq();
+    seq('c');
+    resume p;
+    seq('f');
+    cancel p;
+    seq('g');
+    assert(std.mem.eql(u8, points, "abcdefg"));
+}
+async fn testAsyncSeq() void {
+    defer seq('e');
+    seq('b');
+    suspend;
+    seq('d');
+}
+var points = []u8{0} ** "abcdefg".len;
+var index: usize = 0;
+fn seq(c: u8) void {
+    points[index] = c;
+    index += 1;
+}
+      {#code_end#}
+      <p>
+      When an async function suspends itself, it must be sure that it will be
+      resumed or canceled somehow, for example by registering its promise handle
+      in an event loop. Use a suspend capture block to gain access to the
+      promise:
+      </p>
+      {#code_begin|test#}
+const std = @import("std");
+const assert = std.debug.assert;
+test "coroutine suspend with block" {
+    const p = try async<std.debug.global_allocator> testSuspendBlock();
+    std.debug.assert(!result);
+    resume a_promise;
+    std.debug.assert(result);
+    cancel p;
+}
+var a_promise: promise = undefined;
+var result = false;
+async fn testSuspendBlock() void {
+    suspend |p| {
+        comptime assert(@typeOf(p) == promise->void);
+        a_promise = p;
+    }
+    result = true;
+}
+      {#code_end#}
+      <p>
+      Every suspend point in an async function represents a point at which the coroutine
+      could be destroyed. If that happens, <code>defer</code> expressions that are in
+      scope are run, as well as <code>errdefer</code> expressions.
+      </p>
+      <p>
+      {#link|Await#} counts as a suspend point.
+      </p>
+      {#header_open|Breaking from Suspend Blocks#}
+      <p>
+      Suspend blocks support labeled break, just like {#link|while#} and {#link|for#}.
+      </p>
+      <p>
+      Upon entering a <code>suspend</code> block, the coroutine is already considered
+      suspended, and can be resumed. For example, if you started another kernel thread,
+      and had that thread call <code>resume</code> on the promise handle provided by the
+      <code>suspend</code> block, the new thread would begin executing after the suspend
+      block, while the old thread continued executing the suspend block.
+      </p>
+      <p>
+      However, if you use labeled <code>break</code> on the suspend block, the coroutine
+      never returns to its resumer and continues executing.
+      </p>
+      {#code_begin|test#}
+const std = @import("std");
+const assert = std.debug.assert;
+test "break from suspend" {
+    var buf: [500]u8 = undefined;
+    var a = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator;
+    var my_result: i32 = 1;
+    const p = try async<a> testBreakFromSuspend(&my_result);
+    cancel p;
+    std.debug.assert(my_result == 2);
+}
+async fn testBreakFromSuspend(my_result: *i32) void {
+    s: suspend |p| {
+        break :s;
+    }
+    my_result.* += 1;
+    suspend;
+    my_result.* += 1;
+}
+      {#code_end#}
+      {#header_close#}
+      {#header_close#}
+      {#header_open|Await#}
+      <p>
+      The <code>await</code> keyword is used to coordinate with an async function's
+      <code>return</code> statement.
+      </p>
+      <p>
+      <code>await</code> is valid only in an <code>async</code> function, and it takes
+      as an operand a promise handle.
+      If the async function associated with the promise handle has already returned,
+      then <code>await</code> destroys the target async function, and gives the return value.
+      Otherwise, <code>await</code> suspends the current async function, registering its
+      promise handle with the target coroutine. It becomes the target coroutine's responsibility
+      to have ensured that it will be resumed or destroyed. When the target coroutine reaches
+      its return statement, it gives the return value to the awaiter, destroys itself, and then
+      resumes the awaiter.
+      </p>
+      <p>
+      A promise handle must be consumed exactly once after it is created, either by <code>cancel</code> or <code>await</code>.
+      </p>
+      <p>
+      <code>await</code> counts as a suspend point, and therefore at every <code>await</code>,
+      a coroutine can be potentially destroyed, which would run <code>defer</code> and <code>errdefer</code> expressions.
+      </p>
+      {#code_begin|test#}
+const std = @import("std");
+const assert = std.debug.assert;
+var a_promise: promise = undefined;
+var final_result: i32 = 0;
+test "coroutine await" {
+    seq('a');
+    const p = async<std.debug.global_allocator> amain() catch unreachable;
+    seq('f');
+    resume a_promise;
+    seq('i');
+    assert(final_result == 1234);
+    assert(std.mem.eql(u8, seq_points, "abcdefghi"));
+}
+async fn amain() void {
+    seq('b');
+    const p = async another() catch unreachable;
+    seq('e');
+    final_result = await p;
+    seq('h');
+}
+async fn another() i32 {
+    seq('c');
+    suspend |p| {
+        seq('d');
+        a_promise = p;
+    }
+    seq('g');
+    return 1234;
+}
+var seq_points = []u8{0} ** "abcdefghi".len;
+var seq_index: usize = 0;
+fn seq(c: u8) void {
+    seq_points[seq_index] = c;
+    seq_index += 1;
+}
+      {#code_end#}
+      <p>
+      In general, <code>suspend</code> is lower level than <code>await</code>. Most application
+      code will use only <code>async</code> and <code>await</code>, but event loop
+      implementations will make use of <code>suspend</code> internally.
+      </p>
+      {#header_close#}
+      {#header_open|Open Issues#}
+      <p>
+      There are a few issues with coroutines that are considered unresolved. Best be aware of them,
+      as the situation is likely to change before 1.0.0:
+      </p>
+      <ul>
+          <li>Async functions have optimizations disabled - even in release modes - due to an
+              <a href="https://github.com/ziglang/zig/issues/802">LLVM bug</a>.
+          </li>
+          <li>
+              There are some situations where we can know statically that there will not be
+              memory allocation failure, but Zig still forces us to handle it.
+              TODO file an issue for this and link it here.
+          </li>
+          <li>
+              Zig does not take advantage of LLVM's allocation elision optimization for
+              coroutines. It crashed LLVM when I tried to do it the first time. This is
+              related to the other 2 bullet points here. See
+              <a href="https://github.com/ziglang/zig/issues/802">#802</a>.
+          </li>
+      </ul>
+      {#header_close#}
       {#header_close#}
       {#header_open|Builtin Functions#}
       <p>
 @@ -4102,12 +4613,6 @@ comptime {
       </p>
       {#see_also|Import from C Header File|@cImport|@cDefine|@cInclude#}
       {#header_close#}
-      {#header_open|@canImplicitCast#}
-      <pre><code class="zig">@canImplicitCast(comptime T: type, value) bool</code></pre>
-      <p>
-      Returns whether a value can be implicitly casted to a given type.
-      </p>
-      {#header_close#}
       {#header_open|@clz#}
       <pre><code class="zig">@clz(x: T) U</code></pre>
       <p>
 @@ -4897,7 +5402,7 @@ pub const TypeId = enum {
     ComptimeInt,
     Undefined,
     Null,
-    Nullable,
+    Optional,
     ErrorUnion,
     Error,
     Enum,
 @@ -4931,7 +5436,7 @@ pub const TypeInfo = union(TypeId) {
     ComptimeInt: void,
     Undefined: void,
     Null: void,
-    Nullable: Nullable,
+    Optional: Optional,
     ErrorUnion: ErrorUnion,
     ErrorSet: ErrorSet,
     Enum: Enum,
 @@ -4984,7 +5489,7 @@ pub const TypeInfo = union(TypeId) {
         defs: []Definition,
     };
-    pub const Nullable = struct {
+    pub const Optional = struct {
         child: type,
     };
 @@ -5105,12 +5610,13 @@ pub const TypeInfo = union(TypeId) {
       {#header_close#}
       {#header_open|Build Mode#}
       <p>
-      Zig has three build modes:
+      Zig has four build modes:
       </p>
       <ul>
         <li>{#link|Debug#} (default)</li>
         <li>{#link|ReleaseFast#}</li>
         <li>{#link|ReleaseSafe#}</li>
+        <li>{#link|ReleaseSmall#}</li>
       </ul>
       <p>
       To add standard build options to a <code>build.zig</code> file:
 @@ -5127,14 +5633,16 @@ pub fn build(b: &Builder) void {
       <p>
       This causes these options to be available:
       </p>
-      <pre><code class="shell">  -Drelease-safe=(bool)  optimizations on and safety on
+      <pre><code class="shell">  -Drelease-safe=[bool] optimizations on and safety on
-  -Drelease-fast=(bool)  optimizations on and safety off</code></pre>
+  -Drelease-fast=[bool] optimizations on and safety off
+  -Drelease-small=[bool] size optimizations on and safety off</code></pre>
       {#header_open|Debug#}
       <pre><code class="shell">$ zig build-exe example.zig</code></pre>
       <ul>
         <li>Fast compilation speed</li>
         <li>Safety checks enabled</li>
         <li>Slow runtime performance</li>
+        <li>Large binary size</li>
       </ul>
       {#header_close#}
       {#header_open|ReleaseFast#}
 @@ -5143,6 +5651,7 @@ pub fn build(b: &Builder) void {
         <li>Fast runtime performance</li>
         <li>Safety checks disabled</li>
         <li>Slow compilation speed</li>
+        <li>Large binary size</li>
       </ul>
       {#header_close#}
       {#header_open|ReleaseSafe#}
 @@ -5151,9 +5660,19 @@ pub fn build(b: &Builder) void {
         <li>Medium runtime performance</li>
         <li>Safety checks enabled</li>
         <li>Slow compilation speed</li>
+        <li>Large binary size</li>
+      </ul>
+      {#header_close#}
+      {#header_open|ReleaseSmall#}
+      <pre><code class="shell">$ zig build-exe example.zig --release-small</code></pre>
+      <ul>
+        <li>Medium runtime performance</li>
+        <li>Safety checks disabled</li>
+        <li>Slow compilation speed</li>
+        <li>Small binary size</li>
       </ul>
-      {#see_also|Compile Variables|Zig Build System|Undefined Behavior#}
       {#header_close#}
+      {#see_also|Compile Variables|Zig Build System|Undefined Behavior#}
       {#header_close#}
       {#header_open|Undefined Behavior#}
       <p>
 @@ -5161,7 +5680,7 @@ pub fn build(b: &Builder) void {
       detected at compile-time, Zig emits an error. Most undefined behavior that
       cannot be detected at compile-time can be detected at runtime. In these cases,
       Zig has safety checks. Safety checks can be disabled on a per-block basis
-      with <code>@setRuntimeSafety</code>. The {#link|ReleaseFast#}
+      with {#link|setRuntimeSafety#}. The {#link|ReleaseFast#}
       build mode disables all safety checks in order to facilitate optimizations.
       </p>
       <p>
 @@ -5375,8 +5894,8 @@ comptime {
       <p>At compile-time:</p>
       {#code_begin|test_err|unable to unwrap null#}
 comptime {
-    const nullable_number: ?i32 = null;
+    const optional_number: ?i32 = null;
-    const number = ??nullable_number;
+    const number = optional_number.?;
 }
       {#code_end#}
       <p>At runtime crashes with the message <code>attempt to unwrap null</code> and a stack trace.</p>
 @@ -5385,9 +5904,9 @@ comptime {
       {#code_begin|exe|test#}
 const warn = @import("std").debug.warn;
 pub fn main() void {
-    const nullable_number: ?i32 = null;
+    const optional_number: ?i32 = null;
-    if (nullable_number) |number| {
+    if (optional_number) |number| {
         warn("got number: {}\n", number);
     } else {
         warn("it's null\n");
 @@ -5474,425 +5993,7 @@ const separator = if (builtin.os == builtin.Os.windows) '\\' else '/';
       <p>
       Example of what is imported with <code>@import("builtin")</code>:
       </p>
-      {#code_begin|syntax#}
+      {#builtin#}
-pub const StackTrace = struct {
-    index: usize,
-    instruction_addresses: []usize,
-};
-pub const Os = enum {
-    freestanding,
-    ananas,
-    cloudabi,
-    dragonfly,
-    freebsd,
-    fuchsia,
-    ios,
-    kfreebsd,
-    linux,
-    lv2,
-    macosx,
-    netbsd,
-    openbsd,
-    solaris,
-    windows,
-    haiku,
-    minix,
-    rtems,
-    nacl,
-    cnk,
-    aix,
-    cuda,
-    nvcl,
-    amdhsa,
-    ps4,
-    elfiamcu,
-    tvos,
-    watchos,
-    mesa3d,
-    contiki,
-    amdpal,
-    zen,
-};
-pub const Arch = enum {
-    armv8_3a,
-    armv8_2a,
-    armv8_1a,
-    armv8,
-    armv8r,
-    armv8m_baseline,
-    armv8m_mainline,
-    armv7,
-    armv7em,
-    armv7m,
-    armv7s,
-    armv7k,
-    armv7ve,
-    armv6,
-    armv6m,
-    armv6k,
-    armv6t2,
-    armv5,
-    armv5te,
-    armv4t,
-    armebv8_3a,
-    armebv8_2a,
-    armebv8_1a,
-    armebv8,
-    armebv8r,
-    armebv8m_baseline,
-    armebv8m_mainline,
-    armebv7,
-    armebv7em,
-    armebv7m,
-    armebv7s,
-    armebv7k,
-    armebv7ve,
-    armebv6,
-    armebv6m,
-    armebv6k,
-    armebv6t2,
-    armebv5,
-    armebv5te,
-    armebv4t,
-    aarch64,
-    aarch64_be,
-    arc,
-    avr,
-    bpfel,
-    bpfeb,
-    hexagon,
-    mips,
-    mipsel,
-    mips64,
-    mips64el,
-    msp430,
-    nios2,
-    powerpc,
-    powerpc64,
-    powerpc64le,
-    r600,
-    amdgcn,
-    riscv32,
-    riscv64,
-    sparc,
-    sparcv9,
-    sparcel,
-    s390x,
-    tce,
-    tcele,
-    thumb,
-    thumbeb,
-    i386,
-    x86_64,
-    xcore,
-    nvptx,
-    nvptx64,
-    le32,
-    le64,
-    amdil,
-    amdil64,
-    hsail,
-    hsail64,
-    spir,
-    spir64,
-    kalimbav3,
-    kalimbav4,
-    kalimbav5,
-    shave,
-    lanai,
-    wasm32,
-    wasm64,
-    renderscript32,
-    renderscript64,
-};
-pub const Environ = enum {
-    unknown,
-    gnu,
-    gnuabin32,
-    gnuabi64,
-    gnueabi,
-    gnueabihf,
-    gnux32,
-    code16,
-    eabi,
-    eabihf,
-    android,
-    musl,
-    musleabi,
-    musleabihf,
-    msvc,
-    itanium,
-    cygnus,
-    amdopencl,
-    coreclr,
-    opencl,
-    simulator,
-};
-pub const ObjectFormat = enum {
-    unknown,
-    coff,
-    elf,
-    macho,
-    wasm,
-};
-pub const GlobalLinkage = enum {
-    Internal,
-    Strong,
-    Weak,
-    LinkOnce,
-};
-pub const AtomicOrder = enum {
-    Unordered,
-    Monotonic,
-    Acquire,
-    Release,
-    AcqRel,
-    SeqCst,
-};
-pub const AtomicRmwOp = enum {
-    Xchg,
-    Add,
-    Sub,
-    And,
-    Nand,
-    Or,
-    Xor,
-    Max,
-    Min,
-};
-pub const Mode = enum {
-    Debug,
-    ReleaseSafe,
-    ReleaseFast,
-    ReleaseSmall,
-};
-pub const TypeId = enum {
-    Type,
-    Void,
-    Bool,
-    NoReturn,
-    Int,
-    Float,
-    Pointer,
-    Array,
-    Struct,
-    ComptimeFloat,
-    ComptimeInt,
-    Undefined,
-    Null,
-    Nullable,
-    ErrorUnion,
-    ErrorSet,
-    Enum,
-    Union,
-    Fn,
-    Namespace,
-    Block,
-    BoundFn,
-    ArgTuple,
-    Opaque,
-    Promise,
-};
-pub const TypeInfo = union(TypeId) {
-    Type: void,
-    Void: void,
-    Bool: void,
-    NoReturn: void,
-    Int: Int,
-    Float: Float,
-    Pointer: Pointer,
-    Array: Array,
-    Struct: Struct,
-    ComptimeFloat: void,
-    ComptimeInt: void,
-    Undefined: void,
-    Null: void,
-    Nullable: Nullable,
-    ErrorUnion: ErrorUnion,
-    ErrorSet: ErrorSet,
-    Enum: Enum,
-    Union: Union,
-    Fn: Fn,
-    Namespace: void,
-    Block: void,
-    BoundFn: Fn,
-    ArgTuple: void,
-    Opaque: void,
-    Promise: Promise,
-    pub const Int = struct {
-        is_signed: bool,
-        bits: u8,
-    };
-    pub const Float = struct {
-        bits: u8,
-    };
-    pub const Pointer = struct {
-        is_const: bool,
-        is_volatile: bool,
-        alignment: u32,
-        child: type,
-    };
-    pub const Array = struct {
-        len: usize,
-        child: type,
-    };
-    pub const ContainerLayout = enum {
-        Auto,
-        Extern,
-        Packed,
-    };
-    pub const StructField = struct {
-        name: []const u8,
-        offset: ?usize,
-        field_type: type,
-    };
-    pub const Struct = struct {
-        layout: ContainerLayout,
-        fields: []StructField,
-        defs: []Definition,
-    };
-    pub const Nullable = struct {
-        child: type,
-    };
-    pub const ErrorUnion = struct {
-        error_set: type,
-        payload: type,
-    };
-    pub const Error = struct {
-        name: []const u8,
-        value: usize,
-    };
-    pub const ErrorSet = struct {
-        errors: []Error,
-    };
-    pub const EnumField = struct {
-        name: []const u8,
-        value: usize,
-    };
-    pub const Enum = struct {
-        layout: ContainerLayout,
-        tag_type: type,
-        fields: []EnumField,
-        defs: []Definition,
-    };
-    pub const UnionField = struct {
-        name: []const u8,
-        enum_field: ?EnumField,
-        field_type: type,
-    };
-    pub const Union = struct {
-        layout: ContainerLayout,
-        tag_type: type,
-        fields: []UnionField,
-        defs: []Definition,
-    };
-    pub const CallingConvention = enum {
-        Unspecified,
-        C,
-        Cold,
-        Naked,
-        Stdcall,
-        Async,
-    };
-    pub const FnArg = struct {
-        is_generic: bool,
-        is_noalias: bool,
-        arg_type: type,
-    };
-    pub const Fn = struct {
-        calling_convention: CallingConvention,
-        is_generic: bool,
-        is_var_args: bool,
-        return_type: type,
-        async_allocator_type: type,
-        args: []FnArg,
-    };
-    pub const Promise = struct {
-        child: type,
-    };
-    pub const Definition = struct {
-        name: []const u8,
-        is_pub: bool,
-        data: Data,
-        pub const Data = union(enum) {
-            Type: type,
-            Var: type,
-            Fn: FnDef,
-            pub const FnDef = struct {
-                fn_type: type,
-                inline_type: Inline,
-                calling_convention: CallingConvention,
-                is_var_args: bool,
-                is_extern: bool,
-                is_export: bool,
-                lib_name: ?[]const u8,
-                return_type: type,
-                arg_names: [][] const u8,
-                pub const Inline = enum {
-                    Auto,
-                    Always,
-                    Never,
-                };
-            };
-        };
-    };
-};
-pub const FloatMode = enum {
-    Optimized,
-    Strict,
-};
-pub const Endian = enum {
-    Big,
-    Little,
-};
-pub const endian = Endian.Little;
-pub const is_test = true;
-pub const os = Os.linux;
-pub const arch = Arch.x86_64;
-pub const environ = Environ.gnu;
-pub const object_format = ObjectFormat.elf;
-pub const mode = Mode.Debug;
-pub const link_libc = false;
-pub const have_error_return_tracing = true;
-pub const __zig_test_fn_slice = {}; // overwritten later
-      {#code_end#}
       {#see_also|Build Mode#}
       {#header_close#}
       {#header_open|Root Source File#}
 @@ -6053,8 +6154,7 @@ pub fn build(b: *Builder) void {
     b.default_step.dependOn(&exe.step);
 }
       {#code_end#}
-      {#header_close#}
+      <p class="file">terminal</p>
-      {#header_open|Terminal#}
       <pre><code class="shell">$ zig build
 $ ./test
 all your base are belong to us</code></pre>
 @@ -6367,9 +6467,9 @@ AsmInputItem = "[" Symbol "]" String "(" Expression ")"
 AsmClobbers= ":" list(String, ",")
-UnwrapExpression = BoolOrExpression (UnwrapNullable | UnwrapError) | BoolOrExpression
+UnwrapExpression = BoolOrExpression (UnwrapOptional | UnwrapError) | BoolOrExpression
-UnwrapNullable = "??" Expression
+UnwrapOptional = "orelse" Expression
 UnwrapError = "catch" option("|" Symbol "|") Expression
 @@ -6443,12 +6543,10 @@ MultiplyOperator = "||" | "*" | "/" | "%" | "**" | "*%"
 PrefixOpExpression = PrefixOp TypeExpr | SuffixOpExpression
-SuffixOpExpression = ("async" option("&lt;" SuffixOpExpression "&gt;") SuffixOpExpression FnCallExpression) | PrimaryExpression option(FnCallExpression | ArrayAccessExpression | FieldAccessExpression | SliceExpression | PtrDerefExpression)
+SuffixOpExpression = ("async" option("&lt;" SuffixOpExpression "&gt;") SuffixOpExpression FnCallExpression) | PrimaryExpression option(FnCallExpression | ArrayAccessExpression | FieldAccessExpression | SliceExpression | ".*" | ".?")
 FieldAccessExpression = "." Symbol
-PtrDerefExpression = ".*"
 FnCallExpression = "(" list(Expression, ",") ")"
 ArrayAccessExpression = "[" Expression "]"
 @@ -6461,7 +6559,7 @@ ContainerInitBody = list(StructLiteralField, ",") | list(Expression, ",")
 StructLiteralField = "." Symbol "=" Expression
-PrefixOp = "!" | "-" | "~" | (("*" | "[*]") option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "??" | "-%" | "try" | "await"
+PrefixOp = "!" | "-" | "~" | (("*" | "[*]") option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "-%" | "try" | "await"
 PrimaryExpression = Integer | Float | String | CharLiteral | KeywordLiteral | GroupedExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | FnProto | AsmExpression | ContainerDecl | ("continue" option(":" Symbol)) | ErrorSetDecl | PromiseType
 @@ -6554,8 +6652,8 @@ hljs.registerLanguage("zig", function(t) {
         },
         a = t.IR + "\\s*\\(",
         c = {
-            keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong",
+            keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong resume cancel await async orelse",
-            built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt field typeInfo typeName newStackCall",
+            built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt field typeInfo typeName newStackCall",
             literal: "true false null undefined"
         },
         n = [e, t.CLCM, t.CBCM, s, r];

example/cat/main.zig+1-1

...	@@ -7,7 +7,7 @@ const allocator = std.debug.global_allocator;	...	@@ -7,7 +7,7 @@ const allocator = std.debug.global_allocator;
7		7
8	pub fn main() !void {	8	pub fn main() !void {
9	var args_it = os.args();	9	var args_it = os.args();
10	const exe = try unwrapArg(??args_it.next(allocator));	10	const exe = try unwrapArg(args_it.next(allocator).?);
11	var catted_anything = false;	11	var catted_anything = false;
12	var stdout_file = try io.getStdOut();	12	var stdout_file = try io.getStdOut();
13		13

src-self-hosted/arg.zig+5-5

src-self-hosted/introspect.zig+1-1

...	@@ -27,7 +27,7 @@ pub fn findZigLibDir(allocator: *mem.Allocator) ![]u8 {	...	@@ -27,7 +27,7 @@ pub fn findZigLibDir(allocator: *mem.Allocator) ![]u8 {
27		27
28	var cur_path: []const u8 = self_exe_path;	28	var cur_path: []const u8 = self_exe_path;
29	while (true) {	29	while (true) {
30	const test_dir = os.path.dirname(cur_path);	30	const test_dir = os.path.dirname(cur_path) orelse ".";
31		31
32	if (mem.eql(u8, test_dir, cur_path)) {	32	if (mem.eql(u8, test_dir, cur_path)) {
33	break;	33	break;

src-self-hosted/llvm.zig+1-1

...	@@ -8,6 +8,6 @@ pub const ContextRef = removeNullability(c.LLVMContextRef);	...	@@ -8,6 +8,6 @@ pub const ContextRef = removeNullability(c.LLVMContextRef);
8	pub const BuilderRef = removeNullability(c.LLVMBuilderRef);	8	pub const BuilderRef = removeNullability(c.LLVMBuilderRef);
9		9
10	fn removeNullability(comptime T: type) type {	10	fn removeNullability(comptime T: type) type {
11	comptime assert(@typeId(T) == builtin.TypeId.Nullable);	11	comptime assert(@typeId(T) == builtin.TypeId.Optional);
12	return T.Child;	12	return T.Child;
13	}	13	}

src-self-hosted/main.zig+13-13

src-self-hosted/module.zig+4-4

src/all_types.hpp+39-33

...	@@ -144,6 +144,9 @@ enum ConstPtrSpecial {	...	@@ -144,6 +144,9 @@ enum ConstPtrSpecial {
144	// understand the value of pointee at compile time. However, we will still	144	// understand the value of pointee at compile time. However, we will still
145	// emit a binary with a compile time known address.	145	// emit a binary with a compile time known address.
146	// In this case index is the numeric address value.	146	// In this case index is the numeric address value.
		147	// We also use this for null pointer. We need the data layout for ConstCastOnly == true
		148	// types to be the same, so all optionals of pointer types use x_ptr
		149	// instead of x_optional
147	ConstPtrSpecialHardCodedAddr,	150	ConstPtrSpecialHardCodedAddr,
148	// This means that the pointer represents memory of assigning to _.	151	// This means that the pointer represents memory of assigning to _.
149	// That is, storing discards the data, and loading is invalid.	152	// That is, storing discards the data, and loading is invalid.
...	@@ -219,10 +222,10 @@ enum RuntimeHintErrorUnion {	...	@@ -219,10 +222,10 @@ enum RuntimeHintErrorUnion {
219	RuntimeHintErrorUnionNonError,	222	RuntimeHintErrorUnionNonError,
220	};	223	};
221		224
222	enum RuntimeHintMaybe {	225	enum RuntimeHintOptional {
223	RuntimeHintMaybeUnknown,	226	RuntimeHintOptionalUnknown,
224	RuntimeHintMaybeNull, // TODO is this value even possible? if this is the case it might mean the const value is compile time known.	227	RuntimeHintOptionalNull, // TODO is this value even possible? if this is the case it might mean the const value is compile time known.
225	RuntimeHintMaybeNonNull,	228	RuntimeHintOptionalNonNull,
226	};	229	};
227		230
228	enum RuntimeHintPtr {	231	enum RuntimeHintPtr {
...	@@ -251,7 +254,7 @@ struct ConstExprValue {	...	@@ -251,7 +254,7 @@ struct ConstExprValue {
251	bool x_bool;	254	bool x_bool;
252	ConstBoundFnValue x_bound_fn;	255	ConstBoundFnValue x_bound_fn;
253	TypeTableEntry *x_type;	256	TypeTableEntry *x_type;
254	ConstExprValue *x_maybe;	257	ConstExprValue *x_optional;
255	ConstErrValue x_err_union;	258	ConstErrValue x_err_union;
256	ErrorTableEntry *x_err_set;	259	ErrorTableEntry *x_err_set;
257	BigInt x_enum_tag;	260	BigInt x_enum_tag;
...	@@ -265,7 +268,7 @@ struct ConstExprValue {	...	@@ -265,7 +268,7 @@ struct ConstExprValue {
265		268
266	// populated if special == ConstValSpecialRuntime	269	// populated if special == ConstValSpecialRuntime
267	RuntimeHintErrorUnion rh_error_union;	270	RuntimeHintErrorUnion rh_error_union;
268	RuntimeHintMaybe rh_maybe;	271	RuntimeHintOptional rh_maybe;
269	RuntimeHintPtr rh_ptr;	272	RuntimeHintPtr rh_ptr;
270	} data;	273	} data;
271	};	274	};
...	@@ -384,6 +387,7 @@ enum NodeType {	...	@@ -384,6 +387,7 @@ enum NodeType {
384	NodeTypeSliceExpr,	387	NodeTypeSliceExpr,
385	NodeTypeFieldAccessExpr,	388	NodeTypeFieldAccessExpr,
386	NodeTypePtrDeref,	389	NodeTypePtrDeref,
		390	NodeTypeUnwrapOptional,
387	NodeTypeUse,	391	NodeTypeUse,
388	NodeTypeBoolLiteral,	392	NodeTypeBoolLiteral,
389	NodeTypeNullLiteral,	393	NodeTypeNullLiteral,
...	@@ -553,7 +557,7 @@ enum BinOpType {	...	@@ -553,7 +557,7 @@ enum BinOpType {
553	BinOpTypeMultWrap,	557	BinOpTypeMultWrap,
554	BinOpTypeDiv,	558	BinOpTypeDiv,
555	BinOpTypeMod,	559	BinOpTypeMod,
556	BinOpTypeUnwrapMaybe,	560	BinOpTypeUnwrapOptional,
557	BinOpTypeArrayCat,	561	BinOpTypeArrayCat,
558	BinOpTypeArrayMult,	562	BinOpTypeArrayMult,
559	BinOpTypeErrorUnion,	563	BinOpTypeErrorUnion,
...	@@ -572,6 +576,10 @@ struct AstNodeCatchExpr {	...	@@ -572,6 +576,10 @@ struct AstNodeCatchExpr {
572	AstNode *op2;	576	AstNode *op2;
573	};	577	};
574		578
		579	struct AstNodeUnwrapOptional {
		580	AstNode *expr;
		581	};
		582
575	enum CastOp {	583	enum CastOp {
576	CastOpNoCast, // signifies the function call expression is not a cast	584	CastOpNoCast, // signifies the function call expression is not a cast
577	CastOpNoop, // fn call expr is a cast, but does nothing	585	CastOpNoop, // fn call expr is a cast, but does nothing
...	@@ -583,6 +591,7 @@ enum CastOp {	...	@@ -583,6 +591,7 @@ enum CastOp {
583	CastOpNumLitToConcrete,	591	CastOpNumLitToConcrete,
584	CastOpErrSet,	592	CastOpErrSet,
585	CastOpBitCast,	593	CastOpBitCast,
		594	CastOpPtrOfArrayToSlice,
586	};	595	};
587		596
588	struct AstNodeFnCallExpr {	597	struct AstNodeFnCallExpr {
...	@@ -619,8 +628,7 @@ enum PrefixOp {	...	@@ -619,8 +628,7 @@ enum PrefixOp {
619	PrefixOpBinNot,	628	PrefixOpBinNot,
620	PrefixOpNegation,	629	PrefixOpNegation,
621	PrefixOpNegationWrap,	630	PrefixOpNegationWrap,
622	PrefixOpMaybe,	631	PrefixOpOptional,
623	PrefixOpUnwrapMaybe,
624	PrefixOpAddrOf,	632	PrefixOpAddrOf,
625	};	633	};
626		634
...	@@ -905,6 +913,7 @@ struct AstNode {	...	@@ -905,6 +913,7 @@ struct AstNode {
905	AstNodeTestDecl test_decl;	913	AstNodeTestDecl test_decl;
906	AstNodeBinOpExpr bin_op_expr;	914	AstNodeBinOpExpr bin_op_expr;
907	AstNodeCatchExpr unwrap_err_expr;	915	AstNodeCatchExpr unwrap_err_expr;
		916	AstNodeUnwrapOptional unwrap_optional;
908	AstNodePrefixOpExpr prefix_op_expr;	917	AstNodePrefixOpExpr prefix_op_expr;
909	AstNodePointerType pointer_type;	918	AstNodePointerType pointer_type;
910	AstNodeFnCallExpr fn_call_expr;	919	AstNodeFnCallExpr fn_call_expr;
...	@@ -1037,6 +1046,10 @@ struct TypeTableEntryStruct {	...	@@ -1037,6 +1046,10 @@ struct TypeTableEntryStruct {
1037	// whether we've finished resolving it	1046	// whether we've finished resolving it
1038	bool complete;	1047	bool complete;
1039		1048
		1049	// whether any of the fields require comptime
		1050	// the value is not valid until zero_bits_known == true
		1051	bool requires_comptime;
		1052
1040	bool zero_bits_loop_flag;	1053	bool zero_bits_loop_flag;
1041	bool zero_bits_known;	1054	bool zero_bits_known;
1042	uint32_t abi_alignment; // also figured out with zero_bits pass	1055	uint32_t abi_alignment; // also figured out with zero_bits pass
...	@@ -1044,7 +1057,7 @@ struct TypeTableEntryStruct {	...	@@ -1044,7 +1057,7 @@ struct TypeTableEntryStruct {
1044	HashMap<Buf , TypeStructField , buf_hash, buf_eql_buf> fields_by_name;	1057	HashMap<Buf , TypeStructField , buf_hash, buf_eql_buf> fields_by_name;
1045	};	1058	};
1046		1059
1047	struct TypeTableEntryMaybe {	1060	struct TypeTableEntryOptional {
1048	TypeTableEntry *child_type;	1061	TypeTableEntry *child_type;
1049	};	1062	};
1050		1063
...	@@ -1078,8 +1091,7 @@ struct TypeTableEntryEnum {	...	@@ -1078,8 +1091,7 @@ struct TypeTableEntryEnum {
1078	bool zero_bits_loop_flag;	1091	bool zero_bits_loop_flag;
1079	bool zero_bits_known;	1092	bool zero_bits_known;
1080		1093
1081	bool generate_name_table;	1094	LLVMValueRef name_function;
1082	LLVMValueRef name_table;
1083		1095
1084	HashMap<Buf , TypeEnumField , buf_hash, buf_eql_buf> fields_by_name;	1096	HashMap<Buf , TypeEnumField , buf_hash, buf_eql_buf> fields_by_name;
1085	};	1097	};
...	@@ -1105,6 +1117,10 @@ struct TypeTableEntryUnion {	...	@@ -1105,6 +1117,10 @@ struct TypeTableEntryUnion {
1105	// whether we've finished resolving it	1117	// whether we've finished resolving it
1106	bool complete;	1118	bool complete;
1107		1119
		1120	// whether any of the fields require comptime
		1121	// the value is not valid until zero_bits_known == true
		1122	bool requires_comptime;
		1123
1108	bool zero_bits_loop_flag;	1124	bool zero_bits_loop_flag;
1109	bool zero_bits_known;	1125	bool zero_bits_known;
1110	uint32_t abi_alignment; // also figured out with zero_bits pass	1126	uint32_t abi_alignment; // also figured out with zero_bits pass
...	@@ -1163,7 +1179,7 @@ enum TypeTableEntryId {	...	@@ -1163,7 +1179,7 @@ enum TypeTableEntryId {
1163	TypeTableEntryIdComptimeInt,	1179	TypeTableEntryIdComptimeInt,
1164	TypeTableEntryIdUndefined,	1180	TypeTableEntryIdUndefined,
1165	TypeTableEntryIdNull,	1181	TypeTableEntryIdNull,
1166	TypeTableEntryIdMaybe,	1182	TypeTableEntryIdOptional,
1167	TypeTableEntryIdErrorUnion,	1183	TypeTableEntryIdErrorUnion,
1168	TypeTableEntryIdErrorSet,	1184	TypeTableEntryIdErrorSet,
1169	TypeTableEntryIdEnum,	1185	TypeTableEntryIdEnum,
...	@@ -1194,7 +1210,7 @@ struct TypeTableEntry {	...	@@ -1194,7 +1210,7 @@ struct TypeTableEntry {
1194	TypeTableEntryFloat floating;	1210	TypeTableEntryFloat floating;
1195	TypeTableEntryArray array;	1211	TypeTableEntryArray array;
1196	TypeTableEntryStruct structure;	1212	TypeTableEntryStruct structure;
1197	TypeTableEntryMaybe maybe;	1213	TypeTableEntryOptional maybe;
1198	TypeTableEntryErrorUnion error_union;	1214	TypeTableEntryErrorUnion error_union;
1199	TypeTableEntryErrorSet error_set;	1215	TypeTableEntryErrorSet error_set;
1200	TypeTableEntryEnum enumeration;	1216	TypeTableEntryEnum enumeration;
...	@@ -1346,7 +1362,6 @@ enum BuiltinFnId {	...	@@ -1346,7 +1362,6 @@ enum BuiltinFnId {
1346	BuiltinFnIdSetRuntimeSafety,	1362	BuiltinFnIdSetRuntimeSafety,
1347	BuiltinFnIdSetFloatMode,	1363	BuiltinFnIdSetFloatMode,
1348	BuiltinFnIdTypeName,	1364	BuiltinFnIdTypeName,
1349	BuiltinFnIdCanImplicitCast,
1350	BuiltinFnIdPanic,	1365	BuiltinFnIdPanic,
1351	BuiltinFnIdPtrCast,	1366	BuiltinFnIdPtrCast,
1352	BuiltinFnIdBitCast,	1367	BuiltinFnIdBitCast,
...	@@ -1391,10 +1406,11 @@ enum PanicMsgId {	...	@@ -1391,10 +1406,11 @@ enum PanicMsgId {
1391	PanicMsgIdRemainderDivisionByZero,	1406	PanicMsgIdRemainderDivisionByZero,
1392	PanicMsgIdExactDivisionRemainder,	1407	PanicMsgIdExactDivisionRemainder,
1393	PanicMsgIdSliceWidenRemainder,	1408	PanicMsgIdSliceWidenRemainder,
1394	PanicMsgIdUnwrapMaybeFail,	1409	PanicMsgIdUnwrapOptionalFail,
1395	PanicMsgIdInvalidErrorCode,	1410	PanicMsgIdInvalidErrorCode,
1396	PanicMsgIdIncorrectAlignment,	1411	PanicMsgIdIncorrectAlignment,
1397	PanicMsgIdBadUnionField,	1412	PanicMsgIdBadUnionField,
		1413	PanicMsgIdBadEnumValue,
1398		1414
1399	PanicMsgIdCount,	1415	PanicMsgIdCount,
1400	};	1416	};
...	@@ -1712,8 +1728,6 @@ struct CodeGen {	...	@@ -1712,8 +1728,6 @@ struct CodeGen {
1712	ZigList<Buf *> link_objects;	1728	ZigList<Buf *> link_objects;
1713	ZigList<Buf *> assembly_files;	1729	ZigList<Buf *> assembly_files;
1714		1730
1715	ZigList<TypeTableEntry *> name_table_enums;
1716
1717	Buf *test_filter;	1731	Buf *test_filter;
1718	Buf *test_name_prefix;	1732	Buf *test_name_prefix;
1719		1733
...	@@ -2003,8 +2017,8 @@ enum IrInstructionId {	...	@@ -2003,8 +2017,8 @@ enum IrInstructionId {
2003	IrInstructionIdAsm,	2017	IrInstructionIdAsm,
2004	IrInstructionIdSizeOf,	2018	IrInstructionIdSizeOf,
2005	IrInstructionIdTestNonNull,	2019	IrInstructionIdTestNonNull,
2006	IrInstructionIdUnwrapMaybe,	2020	IrInstructionIdUnwrapOptional,
2007	IrInstructionIdMaybeWrap,	2021	IrInstructionIdOptionalWrap,
2008	IrInstructionIdUnionTag,	2022	IrInstructionIdUnionTag,
2009	IrInstructionIdClz,	2023	IrInstructionIdClz,
2010	IrInstructionIdCtz,	2024	IrInstructionIdCtz,
...	@@ -2055,7 +2069,6 @@ enum IrInstructionId {	...	@@ -2055,7 +2069,6 @@ enum IrInstructionId {
2055	IrInstructionIdCheckSwitchProngs,	2069	IrInstructionIdCheckSwitchProngs,
2056	IrInstructionIdCheckStatementIsVoid,	2070	IrInstructionIdCheckStatementIsVoid,
2057	IrInstructionIdTypeName,	2071	IrInstructionIdTypeName,
2058	IrInstructionIdCanImplicitCast,
2059	IrInstructionIdDeclRef,	2072	IrInstructionIdDeclRef,
2060	IrInstructionIdPanic,	2073	IrInstructionIdPanic,
2061	IrInstructionIdTagName,	2074	IrInstructionIdTagName,
...	@@ -2172,7 +2185,7 @@ enum IrUnOp {	...	@@ -2172,7 +2185,7 @@ enum IrUnOp {
2172	IrUnOpNegation,	2185	IrUnOpNegation,
2173	IrUnOpNegationWrap,	2186	IrUnOpNegationWrap,
2174	IrUnOpDereference,	2187	IrUnOpDereference,
2175	IrUnOpMaybe,	2188	IrUnOpOptional,
2176	};	2189	};
2177		2190
2178	struct IrInstructionUnOp {	2191	struct IrInstructionUnOp {
...	@@ -2475,7 +2488,7 @@ struct IrInstructionTestNonNull {	...	@@ -2475,7 +2488,7 @@ struct IrInstructionTestNonNull {
2475	IrInstruction *value;	2488	IrInstruction *value;
2476	};	2489	};
2477		2490
2478	struct IrInstructionUnwrapMaybe {	2491	struct IrInstructionUnwrapOptional {
2479	IrInstruction base;	2492	IrInstruction base;
2480		2493
2481	IrInstruction *value;	2494	IrInstruction *value;
...	@@ -2733,7 +2746,7 @@ struct IrInstructionUnwrapErrPayload {	...	@@ -2733,7 +2746,7 @@ struct IrInstructionUnwrapErrPayload {
2733	bool safety_check_on;	2746	bool safety_check_on;
2734	};	2747	};
2735		2748
2736	struct IrInstructionMaybeWrap {	2749	struct IrInstructionOptionalWrap {
2737	IrInstruction base;	2750	IrInstruction base;
2738		2751
2739	IrInstruction *value;	2752	IrInstruction *value;
...	@@ -2848,13 +2861,6 @@ struct IrInstructionTypeName {	...	@@ -2848,13 +2861,6 @@ struct IrInstructionTypeName {
2848	IrInstruction *type_value;	2861	IrInstruction *type_value;
2849	};	2862	};
2850		2863
2851	struct IrInstructionCanImplicitCast {
2852	IrInstruction base;
2853
2854	IrInstruction *type_value;
2855	IrInstruction *target_value;
2856	};
2857
2858	struct IrInstructionDeclRef {	2864	struct IrInstructionDeclRef {
2859	IrInstruction base;	2865	IrInstruction base;
2860		2866
...	@@ -2949,10 +2955,10 @@ struct IrInstructionExport {	...	@@ -2949,10 +2955,10 @@ struct IrInstructionExport {
2949	struct IrInstructionErrorReturnTrace {	2955	struct IrInstructionErrorReturnTrace {
2950	IrInstruction base;	2956	IrInstruction base;
2951		2957
2952	enum Nullable {	2958	enum Optional {
2953	Null,	2959	Null,
2954	NonNull,	2960	NonNull,
2955	} nullable;	2961	} optional;
2956	};	2962	};
2957		2963
2958	struct IrInstructionErrorUnion {	2964	struct IrInstructionErrorUnion {

src/analyze.cpp+215-161

 @@ -236,7 +236,7 @@ bool type_is_complete(TypeTableEntry *type_entry) {
         case TypeTableEntryIdComptimeInt:
         case TypeTableEntryIdUndefined:
         case TypeTableEntryIdNull:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdErrorUnion:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdFn:
 @@ -272,7 +272,7 @@ bool type_has_zero_bits_known(TypeTableEntry *type_entry) {
         case TypeTableEntryIdComptimeInt:
         case TypeTableEntryIdUndefined:
         case TypeTableEntryIdNull:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdErrorUnion:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdFn:
 @@ -384,6 +384,7 @@ TypeTableEntry *get_pointer_to_type_extra(CodeGen *g, TypeTableEntry *child_type
         bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count)
 {
     assert(!type_is_invalid(child_type));
+    assert(ptr_len == PtrLenSingle || child_type->id != TypeTableEntryIdOpaque);
     TypeId type_id = {};
     TypeTableEntry **parent_pointer = nullptr;
 @@ -519,9 +520,8 @@ TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) {
     } else {
         ensure_complete_type(g, child_type);
-        TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdMaybe);
+        TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdOptional);
         assert(child_type->type_ref || child_type->zero_bits);
-        assert(child_type->di_type);
         entry->is_copyable = type_is_copyable(g, child_type);
         buf_resize(&entry->name, 0);
 @@ -531,12 +531,14 @@ TypeTableEntry *get_maybe_type(CodeGen *g, TypeTableEntry *child_type) {
             entry->type_ref = LLVMInt1Type();
             entry->di_type = g->builtin_types.entry_bool->di_type;
         } else if (type_is_codegen_pointer(child_type)) {
+            assert(child_type->di_type);
             // this is an optimization but also is necessary for calling C
             // functions where all pointers are maybe pointers
             // function types are technically pointers
             entry->type_ref = child_type->type_ref;
             entry->di_type = child_type->di_type;
         } else {
+            assert(child_type->di_type);
             // create a struct with a boolean whether this is the null value
             LLVMTypeRef elem_types[] = {
                 child_type->type_ref,
 @@ -1360,7 +1362,7 @@ static bool type_allowed_in_packed_struct(TypeTableEntry *type_entry) {
             return type_entry->data.structure.layout == ContainerLayoutPacked;
         case TypeTableEntryIdUnion:
             return type_entry->data.unionation.layout == ContainerLayoutPacked;
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             {
                 TypeTableEntry *child_type = type_entry->data.maybe.child_type;
                 return type_is_codegen_pointer(child_type);
 @@ -1414,7 +1416,7 @@ static bool type_allowed_in_extern(CodeGen *g, TypeTableEntry *type_entry) {
             return type_allowed_in_extern(g, type_entry->data.pointer.child_type);
         case TypeTableEntryIdStruct:
             return type_entry->data.structure.layout == ContainerLayoutExtern || type_entry->data.structure.layout == ContainerLayoutPacked;
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             {
                 TypeTableEntry *child_type = type_entry->data.maybe.child_type;
                 return child_type->id == TypeTableEntryIdPointer || child_type->id == TypeTableEntryIdFn;
 @@ -1537,7 +1539,7 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
             case TypeTableEntryIdPointer:
             case TypeTableEntryIdArray:
             case TypeTableEntryIdStruct:
-            case TypeTableEntryIdMaybe:
+            case TypeTableEntryIdOptional:
             case TypeTableEntryIdErrorUnion:
             case TypeTableEntryIdErrorSet:
             case TypeTableEntryIdEnum:
 @@ -1631,7 +1633,7 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
         case TypeTableEntryIdPointer:
         case TypeTableEntryIdArray:
         case TypeTableEntryIdStruct:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdErrorUnion:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdEnum:
 @@ -2532,6 +2534,10 @@ static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
             continue;
         }
+        if (type_requires_comptime(field_type)) {
+            struct_type->data.structure.requires_comptime = true;
+        }
         if (!type_has_bits(field_type))
             continue;
 @@ -2723,6 +2729,11 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
         }
         union_field->type_entry = field_type;
+        if (type_requires_comptime(field_type)) {
+            union_type->data.unionation.requires_comptime = true;
+        }
         if (field_node->data.struct_field.value != nullptr && !decl_node->data.container_decl.auto_enum) {
             ErrorMsg *msg = add_node_error(g, field_node->data.struct_field.value,
                     buf_sprintf("non-enum union field assignment"));
 @@ -2975,8 +2986,8 @@ static void typecheck_panic_fn(CodeGen *g, FnTableEntry *panic_fn) {
         return wrong_panic_prototype(g, proto_node, fn_type);
     }
-    TypeTableEntry *nullable_ptr_to_stack_trace_type = get_maybe_type(g, get_ptr_to_stack_trace_type(g));
+    TypeTableEntry *optional_ptr_to_stack_trace_type = get_maybe_type(g, get_ptr_to_stack_trace_type(g));
-    if (fn_type_id->param_info[1].type != nullable_ptr_to_stack_trace_type) {
+    if (fn_type_id->param_info[1].type != optional_ptr_to_stack_trace_type) {
         return wrong_panic_prototype(g, proto_node, fn_type);
     }
 @@ -3298,6 +3309,7 @@ void scan_decls(CodeGen *g, ScopeDecls *decls_scope, AstNode *node) {
         case NodeTypeAsmExpr:
         case NodeTypeFieldAccessExpr:
         case NodeTypePtrDeref:
+        case NodeTypeUnwrapOptional:
         case NodeTypeStructField:
         case NodeTypeContainerInitExpr:
         case NodeTypeStructValueField:
 @@ -3358,7 +3370,7 @@ TypeTableEntry *validate_var_type(CodeGen *g, AstNode *source_node, TypeTableEnt
         case TypeTableEntryIdPointer:
         case TypeTableEntryIdArray:
         case TypeTableEntryIdStruct:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdErrorUnion:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdEnum:
 @@ -3736,7 +3748,7 @@ static bool is_container(TypeTableEntry *type_entry) {
         case TypeTableEntryIdComptimeInt:
         case TypeTableEntryIdUndefined:
         case TypeTableEntryIdNull:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdErrorUnion:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdFn:
 @@ -3751,14 +3763,24 @@ static bool is_container(TypeTableEntry *type_entry) {
     zig_unreachable();
 }
+bool is_ref(TypeTableEntry *type_entry) {
+    return type_entry->id == TypeTableEntryIdPointer && type_entry->data.pointer.ptr_len == PtrLenSingle;
+}
+bool is_array_ref(TypeTableEntry *type_entry) {
+    TypeTableEntry *array = is_ref(type_entry) ?
+        type_entry->data.pointer.child_type : type_entry;
+    return array->id == TypeTableEntryIdArray;
+}
 bool is_container_ref(TypeTableEntry *type_entry) {
-    return (type_entry->id == TypeTableEntryIdPointer) ?
+    return is_ref(type_entry) ?
         is_container(type_entry->data.pointer.child_type) : is_container(type_entry);
 }
 TypeTableEntry *container_ref_type(TypeTableEntry *type_entry) {
     assert(is_container_ref(type_entry));
-    return (type_entry->id == TypeTableEntryIdPointer) ?
+    return is_ref(type_entry) ?
         type_entry->data.pointer.child_type : type_entry;
 }
 @@ -3785,7 +3807,7 @@ void resolve_container_type(CodeGen *g, TypeTableEntry *type_entry) {
         case TypeTableEntryIdComptimeInt:
         case TypeTableEntryIdUndefined:
         case TypeTableEntryIdNull:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdErrorUnion:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdFn:
 @@ -3804,7 +3826,7 @@ TypeTableEntry *get_codegen_ptr_type(TypeTableEntry *type) {
     if (type->id == TypeTableEntryIdPointer) return type;
     if (type->id == TypeTableEntryIdFn) return type;
     if (type->id == TypeTableEntryIdPromise) return type;
-    if (type->id == TypeTableEntryIdMaybe) {
+    if (type->id == TypeTableEntryIdOptional) {
         if (type->data.maybe.child_type->id == TypeTableEntryIdPointer) return type->data.maybe.child_type;
         if (type->data.maybe.child_type->id == TypeTableEntryIdFn) return type->data.maybe.child_type;
         if (type->data.maybe.child_type->id == TypeTableEntryIdPromise) return type->data.maybe.child_type;
 @@ -4311,7 +4333,7 @@ bool handle_is_ptr(TypeTableEntry *type_entry) {
              return type_has_bits(type_entry);
         case TypeTableEntryIdErrorUnion:
              return type_has_bits(type_entry->data.error_union.payload_type);
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
              return type_has_bits(type_entry->data.maybe.child_type) &&
                     !type_is_codegen_pointer(type_entry->data.maybe.child_type);
         case TypeTableEntryIdUnion:
 @@ -4558,6 +4580,52 @@ bool fn_type_id_eql(FnTypeId *a, FnTypeId *b) {
     return true;
 }
+static uint32_t hash_const_val_ptr(ConstExprValue *const_val) {
+    uint32_t hash_val = 0;
+    switch (const_val->data.x_ptr.mut) {
+        case ConstPtrMutRuntimeVar:
+            hash_val += (uint32_t)3500721036;
+            break;
+        case ConstPtrMutComptimeConst:
+            hash_val += (uint32_t)4214318515;
+            break;
+        case ConstPtrMutComptimeVar:
+            hash_val += (uint32_t)1103195694;
+            break;
+    }
+    switch (const_val->data.x_ptr.special) {
+        case ConstPtrSpecialInvalid:
+            zig_unreachable();
+        case ConstPtrSpecialRef:
+            hash_val += (uint32_t)2478261866;
+            hash_val += hash_ptr(const_val->data.x_ptr.data.ref.pointee);
+            return hash_val;
+        case ConstPtrSpecialBaseArray:
+            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;
+            hash_val += hash_ptr(const_val->data.x_ptr.data.base_struct.struct_val);
+            hash_val += hash_size(const_val->data.x_ptr.data.base_struct.field_index);
+            return hash_val;
+        case ConstPtrSpecialHardCodedAddr:
+            hash_val += (uint32_t)4048518294;
+            hash_val += hash_size(const_val->data.x_ptr.data.hard_coded_addr.addr);
+            return hash_val;
+        case ConstPtrSpecialDiscard:
+            hash_val += 2010123162;
+            return hash_val;
+        case ConstPtrSpecialFunction:
+            hash_val += (uint32_t)2590901619;
+            hash_val += hash_ptr(const_val->data.x_ptr.data.fn.fn_entry);
+            return hash_val;
+    }
+    zig_unreachable();
+}
 static uint32_t hash_const_val(ConstExprValue *const_val) {
     assert(const_val->special == ConstValSpecialStatic);
     switch (const_val->type->id) {
 @@ -4626,51 +4694,7 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
             assert(const_val->data.x_ptr.special == ConstPtrSpecialFunction);
             return 3677364617 ^ hash_ptr(const_val->data.x_ptr.data.fn.fn_entry);
         case TypeTableEntryIdPointer:
-            {
+            return hash_const_val_ptr(const_val);
-                uint32_t hash_val = 0;
-                switch (const_val->data.x_ptr.mut) {
-                    case ConstPtrMutRuntimeVar:
-                        hash_val += (uint32_t)3500721036;
-                        break;
-                    case ConstPtrMutComptimeConst:
-                        hash_val += (uint32_t)4214318515;
-                        break;
-                    case ConstPtrMutComptimeVar:
-                        hash_val += (uint32_t)1103195694;
-                        break;
-                }
-                switch (const_val->data.x_ptr.special) {
-                    case ConstPtrSpecialInvalid:
-                        zig_unreachable();
-                    case ConstPtrSpecialRef:
-                        hash_val += (uint32_t)2478261866;
-                        hash_val += hash_ptr(const_val->data.x_ptr.data.ref.pointee);
-                        return hash_val;
-                    case ConstPtrSpecialBaseArray:
-                        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;
-                        hash_val += hash_ptr(const_val->data.x_ptr.data.base_struct.struct_val);
-                        hash_val += hash_size(const_val->data.x_ptr.data.base_struct.field_index);
-                        return hash_val;
-                    case ConstPtrSpecialHardCodedAddr:
-                        hash_val += (uint32_t)4048518294;
-                        hash_val += hash_size(const_val->data.x_ptr.data.hard_coded_addr.addr);
-                        return hash_val;
-                    case ConstPtrSpecialDiscard:
-                        hash_val += 2010123162;
-                        return hash_val;
-                    case ConstPtrSpecialFunction:
-                        hash_val += (uint32_t)2590901619;
-                        hash_val += hash_ptr(const_val->data.x_ptr.data.fn.fn_entry);
-                        return hash_val;
-                }
-                zig_unreachable();
-            }
         case TypeTableEntryIdPromise:
             // TODO better hashing algorithm
             return 223048345;
 @@ -4687,11 +4711,15 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
         case TypeTableEntryIdUnion:
             // TODO better hashing algorithm
             return 2709806591;
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
-            if (const_val->data.x_maybe) {
+            if (get_codegen_ptr_type(const_val->type) != nullptr) {
-                return hash_const_val(const_val->data.x_maybe) * 1992916303;
+                return hash_const_val(const_val) * 1992916303;
             } else {
-                return 4016830364;
+                if (const_val->data.x_optional) {
+                    return hash_const_val(const_val->data.x_optional) * 1992916303;
+                } else {
+                    return 4016830364;
+                }
             }
         case TypeTableEntryIdErrorUnion:
             // TODO better hashing algorithm
 @@ -4791,10 +4819,12 @@ static bool can_mutate_comptime_var_state(ConstExprValue *value) {
             }
             return false;
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
-            if (value->data.x_maybe == nullptr)
+            if (get_codegen_ptr_type(value->type) != nullptr)
+                return value->data.x_ptr.mut == ConstPtrMutComptimeVar;
+            if (value->data.x_optional == nullptr)
                 return false;
-            return can_mutate_comptime_var_state(value->data.x_maybe);
+            return can_mutate_comptime_var_state(value->data.x_optional);
         case TypeTableEntryIdErrorUnion:
             if (value->data.x_err_union.err != nullptr)
 @@ -4841,7 +4871,7 @@ static bool return_type_is_cacheable(TypeTableEntry *return_type) {
         case TypeTableEntryIdUnion:
             return false;
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             return return_type_is_cacheable(return_type->data.maybe.child_type);
         case TypeTableEntryIdErrorUnion:
 @@ -4943,17 +4973,29 @@ bool type_requires_comptime(TypeTableEntry *type_entry) {
         case TypeTableEntryIdArgTuple:
             return true;
         case TypeTableEntryIdArray:
+            return type_requires_comptime(type_entry->data.array.child_type);
         case TypeTableEntryIdStruct:
+            assert(type_has_zero_bits_known(type_entry));
+            return type_entry->data.structure.requires_comptime;
         case TypeTableEntryIdUnion:
-        case TypeTableEntryIdMaybe:
+            assert(type_has_zero_bits_known(type_entry));
+            return type_entry->data.unionation.requires_comptime;
+        case TypeTableEntryIdOptional:
+            return type_requires_comptime(type_entry->data.maybe.child_type);
         case TypeTableEntryIdErrorUnion:
+            return type_requires_comptime(type_entry->data.error_union.payload_type);
+        case TypeTableEntryIdPointer:
+            if (type_entry->data.pointer.child_type->id == TypeTableEntryIdOpaque) {
+                return false;
+            } else {
+                return type_requires_comptime(type_entry->data.pointer.child_type);
+            }
         case TypeTableEntryIdEnum:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdFn:
         case TypeTableEntryIdBool:
         case TypeTableEntryIdInt:
         case TypeTableEntryIdFloat:
-        case TypeTableEntryIdPointer:
         case TypeTableEntryIdVoid:
         case TypeTableEntryIdUnreachable:
         case TypeTableEntryIdPromise:
 @@ -5308,6 +5350,52 @@ bool ir_get_var_is_comptime(VariableTableEntry *var) {
     return var->is_comptime->value.data.x_bool;
 }
+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();
+        case ConstPtrSpecialRef:
+            if (a->data.x_ptr.data.ref.pointee != b->data.x_ptr.data.ref.pointee)
+                return false;
+            return true;
+        case ConstPtrSpecialBaseArray:
+            if (a->data.x_ptr.data.base_array.array_val != b->data.x_ptr.data.base_array.array_val &&
+                a->data.x_ptr.data.base_array.array_val->global_refs !=
+                b->data.x_ptr.data.base_array.array_val->global_refs)
+            {
+                return false;
+            }
+            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 &&
+                a->data.x_ptr.data.base_struct.struct_val->global_refs !=
+                b->data.x_ptr.data.base_struct.struct_val->global_refs)
+            {
+                return false;
+            }
+            if (a->data.x_ptr.data.base_struct.field_index != b->data.x_ptr.data.base_struct.field_index)
+                return false;
+            return true;
+        case ConstPtrSpecialHardCodedAddr:
+            if (a->data.x_ptr.data.hard_coded_addr.addr != b->data.x_ptr.data.hard_coded_addr.addr)
+                return false;
+            return true;
+        case ConstPtrSpecialDiscard:
+            return true;
+        case ConstPtrSpecialFunction:
+            return a->data.x_ptr.data.fn.fn_entry == b->data.x_ptr.data.fn.fn_entry;
+    }
+    zig_unreachable();
+}
 bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
     assert(a->type->id == b->type->id);
     assert(a->special == ConstValSpecialStatic);
 @@ -5359,49 +5447,7 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
             return bigint_cmp(&a->data.x_bigint, &b->data.x_bigint) == CmpEQ;
         case TypeTableEntryIdPointer:
         case TypeTableEntryIdFn:
-            if (a->data.x_ptr.special != b->data.x_ptr.special)
+            return const_values_equal_ptr(a, b);
-                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();
-                case ConstPtrSpecialRef:
-                    if (a->data.x_ptr.data.ref.pointee != b->data.x_ptr.data.ref.pointee)
-                        return false;
-                    return true;
-                case ConstPtrSpecialBaseArray:
-                    if (a->data.x_ptr.data.base_array.array_val != b->data.x_ptr.data.base_array.array_val &&
-                        a->data.x_ptr.data.base_array.array_val->global_refs !=
-                        b->data.x_ptr.data.base_array.array_val->global_refs)
-                    {
-                        return false;
-                    }
-                    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 &&
-                        a->data.x_ptr.data.base_struct.struct_val->global_refs !=
-                        b->data.x_ptr.data.base_struct.struct_val->global_refs)
-                    {
-                        return false;
-                    }
-                    if (a->data.x_ptr.data.base_struct.field_index != b->data.x_ptr.data.base_struct.field_index)
-                        return false;
-                    return true;
-                case ConstPtrSpecialHardCodedAddr:
-                    if (a->data.x_ptr.data.hard_coded_addr.addr != b->data.x_ptr.data.hard_coded_addr.addr)
-                        return false;
-                    return true;
-                case ConstPtrSpecialDiscard:
-                    return true;
-                case ConstPtrSpecialFunction:
-                    return a->data.x_ptr.data.fn.fn_entry == b->data.x_ptr.data.fn.fn_entry;
-            }
-            zig_unreachable();
         case TypeTableEntryIdArray:
             zig_panic("TODO");
         case TypeTableEntryIdStruct:
 @@ -5416,11 +5462,13 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
             zig_panic("TODO");
         case TypeTableEntryIdNull:
             zig_panic("TODO");
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
-            if (a->data.x_maybe == nullptr || b->data.x_maybe == nullptr) {
+            if (get_codegen_ptr_type(a->type) != nullptr)
-                return (a->data.x_maybe == nullptr && b->data.x_maybe == nullptr);
+                return const_values_equal_ptr(a, b);
+            if (a->data.x_optional == nullptr || b->data.x_optional == nullptr) {
+                return (a->data.x_optional == nullptr && b->data.x_optional == nullptr);
             } else {
-                return const_values_equal(a->data.x_maybe, b->data.x_maybe);
+                return const_values_equal(a->data.x_optional, b->data.x_optional);
             }
         case TypeTableEntryIdErrorUnion:
             zig_panic("TODO");
 @@ -5493,6 +5541,41 @@ void eval_min_max_value(CodeGen *g, TypeTableEntry *type_entry, ConstExprValue *
     }
 }
+void render_const_val_ptr(CodeGen *g, Buf *buf, ConstExprValue *const_val, TypeTableEntry *type_entry) {
+    switch (const_val->data.x_ptr.special) {
+        case ConstPtrSpecialInvalid:
+            zig_unreachable();
+        case ConstPtrSpecialRef:
+        case ConstPtrSpecialBaseStruct:
+            buf_appendf(buf, "*");
+            render_const_value(g, buf, const_ptr_pointee(g, const_val));
+            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, "*");
+                render_const_value(g, buf, const_ptr_pointee(g, const_val));
+                return;
+            }
+        case ConstPtrSpecialHardCodedAddr:
+            buf_appendf(buf, "(*%s)(%" ZIG_PRI_x64 ")", buf_ptr(&type_entry->data.pointer.child_type->name),
+                    const_val->data.x_ptr.data.hard_coded_addr.addr);
+            return;
+        case ConstPtrSpecialDiscard:
+            buf_append_str(buf, "*_");
+            return;
+        case ConstPtrSpecialFunction:
+            {
+                FnTableEntry *fn_entry = const_val->data.x_ptr.data.fn.fn_entry;
+                buf_appendf(buf, "@ptrCast(%s, %s)", buf_ptr(&const_val->type->name), buf_ptr(&fn_entry->symbol_name));
+                return;
+            }
+    }
+    zig_unreachable();
+}
 void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val) {
     switch (const_val->special) {
         case ConstValSpecialRuntime:
 @@ -5569,38 +5652,7 @@ void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val) {
                 return;
             }
         case TypeTableEntryIdPointer:
-            switch (const_val->data.x_ptr.special) {
+            return render_const_val_ptr(g, buf, const_val, type_entry);
-                case ConstPtrSpecialInvalid:
-                    zig_unreachable();
-                case ConstPtrSpecialRef:
-                case ConstPtrSpecialBaseStruct:
-                    buf_appendf(buf, "&");
-                    render_const_value(g, buf, const_ptr_pointee(g, const_val));
-                    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, "&");
-                        render_const_value(g, buf, const_ptr_pointee(g, const_val));
-                        return;
-                    }
-                case ConstPtrSpecialHardCodedAddr:
-                    buf_appendf(buf, "(&%s)(%" ZIG_PRI_x64 ")", buf_ptr(&type_entry->data.pointer.child_type->name),
-                            const_val->data.x_ptr.data.hard_coded_addr.addr);
-                    return;
-                case ConstPtrSpecialDiscard:
-                    buf_append_str(buf, "&_");
-                    return;
-                case ConstPtrSpecialFunction:
-                    {
-                        FnTableEntry *fn_entry = const_val->data.x_ptr.data.fn.fn_entry;
-                        buf_appendf(buf, "@ptrCast(%s, %s)", buf_ptr(&const_val->type->name), buf_ptr(&fn_entry->symbol_name));
-                        return;
-                    }
-            }
-            zig_unreachable();
         case TypeTableEntryIdBlock:
             {
                 AstNode *node = const_val->data.x_block->source_node;
 @@ -5658,10 +5710,12 @@ void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val) {
                 buf_appendf(buf, "undefined");
                 return;
             }
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             {
-                if (const_val->data.x_maybe) {
+                if (get_codegen_ptr_type(const_val->type) != nullptr)
-                    render_const_value(g, buf, const_val->data.x_maybe);
+                    return render_const_val_ptr(g, buf, const_val, type_entry->data.maybe.child_type);
+                if (const_val->data.x_optional) {
+                    render_const_value(g, buf, const_val->data.x_optional);
                 } else {
                     buf_appendf(buf, "null");
                 }
 @@ -5767,7 +5821,7 @@ uint32_t type_id_hash(TypeId x) {
         case TypeTableEntryIdComptimeInt:
         case TypeTableEntryIdUndefined:
         case TypeTableEntryIdNull:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdEnum:
         case TypeTableEntryIdUnion:
 @@ -5813,7 +5867,7 @@ bool type_id_eql(TypeId a, TypeId b) {
         case TypeTableEntryIdComptimeInt:
         case TypeTableEntryIdUndefined:
         case TypeTableEntryIdNull:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdPromise:
         case TypeTableEntryIdErrorSet:
         case TypeTableEntryIdEnum:
 @@ -5935,7 +5989,7 @@ static const TypeTableEntryId all_type_ids[] = {
     TypeTableEntryIdComptimeInt,
     TypeTableEntryIdUndefined,
     TypeTableEntryIdNull,
-    TypeTableEntryIdMaybe,
+    TypeTableEntryIdOptional,
     TypeTableEntryIdErrorUnion,
     TypeTableEntryIdErrorSet,
     TypeTableEntryIdEnum,
 @@ -5980,7 +6034,7 @@ size_t type_id_index(TypeTableEntry *entry) {
             return 7;
         case TypeTableEntryIdStruct:
             if (entry->data.structure.is_slice)
-                return 25;
+                return 6;
             return 8;
         case TypeTableEntryIdComptimeFloat:
             return 9;
 @@ -5990,7 +6044,7 @@ size_t type_id_index(TypeTableEntry *entry) {
             return 11;
         case TypeTableEntryIdNull:
             return 12;
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             return 13;
         case TypeTableEntryIdErrorUnion:
             return 14;
 @@ -6048,8 +6102,8 @@ const char *type_id_name(TypeTableEntryId id) {
             return "Undefined";
         case TypeTableEntryIdNull:
             return "Null";
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
-            return "Nullable";
+            return "Optional";
         case TypeTableEntryIdErrorUnion:
             return "ErrorUnion";
         case TypeTableEntryIdErrorSet:

src/analyze.hpp+2

...	@@ -70,6 +70,8 @@ TypeUnionField find_union_type_field(TypeTableEntry type_entry, Buf *name);	...	@@ -70,6 +70,8 @@ TypeUnionField find_union_type_field(TypeTableEntry type_entry, Buf *name);
70	TypeEnumField find_enum_field_by_tag(TypeTableEntry enum_type, const BigInt *tag);	70	TypeEnumField find_enum_field_by_tag(TypeTableEntry enum_type, const BigInt *tag);
71	TypeUnionField find_union_field_by_tag(TypeTableEntry type_entry, const BigInt *tag);	71	TypeUnionField find_union_field_by_tag(TypeTableEntry type_entry, const BigInt *tag);
72		72
		73	bool is_ref(TypeTableEntry *type_entry);
		74	bool is_array_ref(TypeTableEntry *type_entry);
73	bool is_container_ref(TypeTableEntry *type_entry);	75	bool is_container_ref(TypeTableEntry *type_entry);
74	void scan_decls(CodeGen g, ScopeDecls decls_scope, AstNode *node);	76	void scan_decls(CodeGen g, ScopeDecls decls_scope, AstNode *node);
75	void scan_import(CodeGen g, ImportTableEntry import);	77	void scan_import(CodeGen g, ImportTableEntry import);

src/ast_render.cpp+11-3

 @@ -50,7 +50,7 @@ static const char *bin_op_str(BinOpType bin_op) {
         case BinOpTypeAssignBitXor:           return "^=";
         case BinOpTypeAssignBitOr:            return "|=";
         case BinOpTypeAssignMergeErrorSets:   return "||=";
-        case BinOpTypeUnwrapMaybe:            return "??";
+        case BinOpTypeUnwrapOptional:         return "orelse";
         case BinOpTypeArrayCat:               return "++";
         case BinOpTypeArrayMult:              return "**";
         case BinOpTypeErrorUnion:             return "!";
 @@ -66,8 +66,7 @@ static const char *prefix_op_str(PrefixOp prefix_op) {
         case PrefixOpNegationWrap: return "-%";
         case PrefixOpBoolNot: return "!";
         case PrefixOpBinNot: return "~";
-        case PrefixOpMaybe: return "?";
+        case PrefixOpOptional: return "?";
-        case PrefixOpUnwrapMaybe: return "??";
         case PrefixOpAddrOf: return "&";
     }
     zig_unreachable();
 @@ -222,6 +221,8 @@ static const char *node_type_str(NodeType node_type) {
             return "FieldAccessExpr";
         case NodeTypePtrDeref:
             return "PtrDerefExpr";
+        case NodeTypeUnwrapOptional:
+            return "UnwrapOptional";
         case NodeTypeContainerDecl:
             return "ContainerDecl";
         case NodeTypeStructField:
 @@ -711,6 +712,13 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
                 fprintf(ar->f, ".*");
                 break;
             }
+        case NodeTypeUnwrapOptional:
+            {
+                AstNode *lhs = node->data.unwrap_optional.expr;
+                render_node_ungrouped(ar, lhs);
+                fprintf(ar->f, ".?");
+                break;
+            }
         case NodeTypeUndefinedLiteral:
             fprintf(ar->f, "undefined");
             break;

src/codegen.cpp+251-193

 @@ -869,7 +869,7 @@ static Buf *panic_msg_buf(PanicMsgId msg_id) {
             return buf_create_from_str("exact division produced remainder");
         case PanicMsgIdSliceWidenRemainder:
             return buf_create_from_str("slice widening size mismatch");
-        case PanicMsgIdUnwrapMaybeFail:
+        case PanicMsgIdUnwrapOptionalFail:
             return buf_create_from_str("attempt to unwrap null");
         case PanicMsgIdUnreachable:
             return buf_create_from_str("reached unreachable code");
 @@ -879,6 +879,8 @@ static Buf *panic_msg_buf(PanicMsgId msg_id) {
             return buf_create_from_str("incorrect alignment");
         case PanicMsgIdBadUnionField:
             return buf_create_from_str("access of inactive union field");
+        case PanicMsgIdBadEnumValue:
+            return buf_create_from_str("invalid enum value");
     }
     zig_unreachable();
 }
 @@ -2497,7 +2499,7 @@ static LLVMValueRef ir_render_cast(CodeGen *g, IrExecutable *executable,
                 assert(wanted_type->data.structure.is_slice);
                 assert(actual_type->id == TypeTableEntryIdArray);
-                TypeTableEntry *wanted_pointer_type = wanted_type->data.structure.fields[0].type_entry;
+                TypeTableEntry *wanted_pointer_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
                 TypeTableEntry *wanted_child_type = wanted_pointer_type->data.pointer.child_type;
 @@ -2543,6 +2545,29 @@ static LLVMValueRef ir_render_cast(CodeGen *g, IrExecutable *executable,
             return expr_val;
         case CastOpBitCast:
             return LLVMBuildBitCast(g->builder, expr_val, wanted_type->type_ref, "");
+        case CastOpPtrOfArrayToSlice: {
+            assert(cast_instruction->tmp_ptr);
+            assert(actual_type->id == TypeTableEntryIdPointer);
+            TypeTableEntry *array_type = actual_type->data.pointer.child_type;
+            assert(array_type->id == TypeTableEntryIdArray);
+            LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, cast_instruction->tmp_ptr,
+                    slice_ptr_index, "");
+            LLVMValueRef indices[] = {
+                LLVMConstNull(g->builtin_types.entry_usize->type_ref),
+                LLVMConstInt(g->builtin_types.entry_usize->type_ref, 0, false),
+            };
+            LLVMValueRef slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, expr_val, indices, 2, "");
+            gen_store_untyped(g, slice_start_ptr, ptr_field_ptr, 0, false);
+            LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, cast_instruction->tmp_ptr,
+                    slice_len_index, "");
+            LLVMValueRef len_value = LLVMConstInt(g->builtin_types.entry_usize->type_ref,
+                    array_type->data.array.len, false);
+            gen_store_untyped(g, len_value, len_field_ptr, 0, false);
+            return cast_instruction->tmp_ptr;
+        }
     }
     zig_unreachable();
 }
 @@ -2678,7 +2703,7 @@ static LLVMValueRef ir_render_un_op(CodeGen *g, IrExecutable *executable, IrInst
     switch (op_id) {
         case IrUnOpInvalid:
-        case IrUnOpMaybe:
+        case IrUnOpOptional:
         case IrUnOpDereference:
             zig_unreachable();
         case IrUnOpNegation:
 @@ -3249,7 +3274,7 @@ static LLVMValueRef ir_render_asm(CodeGen *g, IrExecutable *executable, IrInstru
 }
 static LLVMValueRef gen_non_null_bit(CodeGen *g, TypeTableEntry *maybe_type, LLVMValueRef maybe_handle) {
-    assert(maybe_type->id == TypeTableEntryIdMaybe);
+    assert(maybe_type->id == TypeTableEntryIdOptional);
     TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
     if (child_type->zero_bits) {
         return maybe_handle;
 @@ -3271,23 +3296,23 @@ static LLVMValueRef ir_render_test_non_null(CodeGen *g, IrExecutable *executable
 }
 static LLVMValueRef ir_render_unwrap_maybe(CodeGen *g, IrExecutable *executable,
-        IrInstructionUnwrapMaybe *instruction)
+        IrInstructionUnwrapOptional *instruction)
 {
     TypeTableEntry *ptr_type = instruction->value->value.type;
     assert(ptr_type->id == TypeTableEntryIdPointer);
     TypeTableEntry *maybe_type = ptr_type->data.pointer.child_type;
-    assert(maybe_type->id == TypeTableEntryIdMaybe);
+    assert(maybe_type->id == TypeTableEntryIdOptional);
     TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
     LLVMValueRef maybe_ptr = ir_llvm_value(g, instruction->value);
     LLVMValueRef maybe_handle = get_handle_value(g, maybe_ptr, maybe_type, ptr_type);
     if (ir_want_runtime_safety(g, &instruction->base) && instruction->safety_check_on) {
         LLVMValueRef non_null_bit = gen_non_null_bit(g, maybe_type, maybe_handle);
-        LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapMaybeOk");
+        LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapOptionalOk");
-        LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapMaybeFail");
+        LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapOptionalFail");
         LLVMBuildCondBr(g->builder, non_null_bit, ok_block, fail_block);
         LLVMPositionBuilderAtEnd(g->builder, fail_block);
-        gen_safety_crash(g, PanicMsgIdUnwrapMaybeFail);
+        gen_safety_crash(g, PanicMsgIdUnwrapOptionalFail);
         LLVMPositionBuilderAtEnd(g->builder, ok_block);
     }
 @@ -3432,34 +3457,112 @@ static LLVMValueRef ir_render_err_name(CodeGen *g, IrExecutable *executable, IrI
     return LLVMBuildInBoundsGEP(g->builder, g->err_name_table, indices, 2, "");
 }
+static LLVMValueRef get_enum_tag_name_function(CodeGen *g, TypeTableEntry *enum_type) {
+    assert(enum_type->id == TypeTableEntryIdEnum);
+    if (enum_type->data.enumeration.name_function)
+        return enum_type->data.enumeration.name_function;
+    TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,
+            PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
+    TypeTableEntry *u8_slice_type = get_slice_type(g, u8_ptr_type);
+    TypeTableEntry *tag_int_type = enum_type->data.enumeration.tag_int_type;
+    LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMPointerType(u8_slice_type->type_ref, 0),
+            &tag_int_type->type_ref, 1, false);
+    Buf *fn_name = get_mangled_name(g, buf_sprintf("__zig_tag_name_%s", buf_ptr(&enum_type->name)), false);
+    LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
+    LLVMSetLinkage(fn_val, LLVMInternalLinkage);
+    LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
+    addLLVMFnAttr(fn_val, "nounwind");
+    add_uwtable_attr(g, fn_val);
+    if (g->build_mode == BuildModeDebug) {
+        ZigLLVMAddFunctionAttr(fn_val, "no-frame-pointer-elim", "true");
+        ZigLLVMAddFunctionAttr(fn_val, "no-frame-pointer-elim-non-leaf", nullptr);
+    }
+    LLVMBasicBlockRef prev_block = LLVMGetInsertBlock(g->builder);
+    LLVMValueRef prev_debug_location = LLVMGetCurrentDebugLocation(g->builder);
+    FnTableEntry *prev_cur_fn = g->cur_fn;
+    LLVMValueRef prev_cur_fn_val = g->cur_fn_val;
+    LLVMBasicBlockRef entry_block = LLVMAppendBasicBlock(fn_val, "Entry");
+    LLVMPositionBuilderAtEnd(g->builder, entry_block);
+    ZigLLVMClearCurrentDebugLocation(g->builder);
+    g->cur_fn = nullptr;
+    g->cur_fn_val = fn_val;
+    size_t field_count = enum_type->data.enumeration.src_field_count;
+    LLVMBasicBlockRef bad_value_block = LLVMAppendBasicBlock(g->cur_fn_val, "BadValue");
+    LLVMValueRef tag_int_value = LLVMGetParam(fn_val, 0);
+    LLVMValueRef switch_instr = LLVMBuildSwitch(g->builder, tag_int_value, bad_value_block, field_count);
+    TypeTableEntry *usize = g->builtin_types.entry_usize;
+    LLVMValueRef array_ptr_indices[] = {
+        LLVMConstNull(usize->type_ref),
+        LLVMConstNull(usize->type_ref),
+    };
+    for (size_t field_i = 0; field_i < field_count; field_i += 1) {
+        Buf *name = enum_type->data.enumeration.fields[field_i].name;
+        LLVMValueRef str_init = LLVMConstString(buf_ptr(name), (unsigned)buf_len(name), true);
+        LLVMValueRef str_global = LLVMAddGlobal(g->module, LLVMTypeOf(str_init), "");
+        LLVMSetInitializer(str_global, str_init);
+        LLVMSetLinkage(str_global, LLVMPrivateLinkage);
+        LLVMSetGlobalConstant(str_global, true);
+        LLVMSetUnnamedAddr(str_global, true);
+        LLVMSetAlignment(str_global, LLVMABIAlignmentOfType(g->target_data_ref, LLVMTypeOf(str_init)));
+        LLVMValueRef fields[] = {
+            LLVMConstGEP(str_global, array_ptr_indices, 2),
+            LLVMConstInt(g->builtin_types.entry_usize->type_ref, buf_len(name), false),
+        };
+        LLVMValueRef slice_init_value = LLVMConstNamedStruct(u8_slice_type->type_ref, fields, 2);
+        LLVMValueRef slice_global = LLVMAddGlobal(g->module, LLVMTypeOf(slice_init_value), "");
+        LLVMSetInitializer(slice_global, slice_init_value);
+        LLVMSetLinkage(slice_global, LLVMPrivateLinkage);
+        LLVMSetGlobalConstant(slice_global, true);
+        LLVMSetUnnamedAddr(slice_global, true);
+        LLVMSetAlignment(slice_global, LLVMABIAlignmentOfType(g->target_data_ref, LLVMTypeOf(slice_init_value)));
+        LLVMBasicBlockRef return_block = LLVMAppendBasicBlock(g->cur_fn_val, "Name");
+        LLVMValueRef this_tag_int_value = bigint_to_llvm_const(tag_int_type->type_ref,
+                &enum_type->data.enumeration.fields[field_i].value);
+        LLVMAddCase(switch_instr, this_tag_int_value, return_block);
+        LLVMPositionBuilderAtEnd(g->builder, return_block);
+        LLVMBuildRet(g->builder, slice_global);
+    }
+    LLVMPositionBuilderAtEnd(g->builder, bad_value_block);
+    if (g->build_mode == BuildModeDebug || g->build_mode == BuildModeSafeRelease) {
+        gen_safety_crash(g, PanicMsgIdBadEnumValue);
+    } else {
+        LLVMBuildUnreachable(g->builder);
+    }
+    g->cur_fn = prev_cur_fn;
+    g->cur_fn_val = prev_cur_fn_val;
+    LLVMPositionBuilderAtEnd(g->builder, prev_block);
+    LLVMSetCurrentDebugLocation(g->builder, prev_debug_location);
+    enum_type->data.enumeration.name_function = fn_val;
+    return fn_val;
+}
 static LLVMValueRef ir_render_enum_tag_name(CodeGen *g, IrExecutable *executable,
         IrInstructionTagName *instruction)
 {
     TypeTableEntry *enum_type = instruction->target->value.type;
     assert(enum_type->id == TypeTableEntryIdEnum);
-    assert(enum_type->data.enumeration.generate_name_table);
-    TypeTableEntry *tag_int_type = enum_type->data.enumeration.tag_int_type;
+    LLVMValueRef enum_name_function = get_enum_tag_name_function(g, enum_type);
-    LLVMValueRef enum_tag_value = ir_llvm_value(g, instruction->target);
-    if (ir_want_runtime_safety(g, &instruction->base)) {
-        size_t field_count = enum_type->data.enumeration.src_field_count;
-        // if the field_count can't fit in the bits of the enum_type, then it can't possibly
-        // be the wrong value
-        BigInt field_bi;
-        bigint_init_unsigned(&field_bi, field_count);
-        if (bigint_fits_in_bits(&field_bi, tag_int_type->data.integral.bit_count, false)) {
-            LLVMValueRef end_val = LLVMConstInt(LLVMTypeOf(enum_tag_value), field_count, false);
-            add_bounds_check(g, enum_tag_value, LLVMIntEQ, nullptr, LLVMIntULT, end_val);
-        }
-    }
-    LLVMValueRef indices[] = {
+    LLVMValueRef enum_tag_value = ir_llvm_value(g, instruction->target);
-        LLVMConstNull(g->builtin_types.entry_usize->type_ref),
+    return ZigLLVMBuildCall(g->builder, enum_name_function, &enum_tag_value, 1,
-        gen_widen_or_shorten(g, false, tag_int_type,
+            get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_FnInlineAuto, "");
-                g->builtin_types.entry_usize, enum_tag_value),
-    };
-    return LLVMBuildInBoundsGEP(g->builder, enum_type->data.enumeration.name_table, indices, 2, "");
 }
 static LLVMValueRef ir_render_field_parent_ptr(CodeGen *g, IrExecutable *executable,
 @@ -3509,17 +3612,17 @@ static LLVMValueRef ir_render_align_cast(CodeGen *g, IrExecutable *executable, I
     } else if (target_type->id == TypeTableEntryIdFn) {
         align_bytes = target_type->data.fn.fn_type_id.alignment;
         ptr_val = target_val;
-    } else if (target_type->id == TypeTableEntryIdMaybe &&
+    } else if (target_type->id == TypeTableEntryIdOptional &&
             target_type->data.maybe.child_type->id == TypeTableEntryIdPointer)
     {
         align_bytes = target_type->data.maybe.child_type->data.pointer.alignment;
         ptr_val = target_val;
-    } else if (target_type->id == TypeTableEntryIdMaybe &&
+    } else if (target_type->id == TypeTableEntryIdOptional &&
             target_type->data.maybe.child_type->id == TypeTableEntryIdFn)
     {
         align_bytes = target_type->data.maybe.child_type->data.fn.fn_type_id.alignment;
         ptr_val = target_val;
-    } else if (target_type->id == TypeTableEntryIdMaybe &&
+    } else if (target_type->id == TypeTableEntryIdOptional &&
             target_type->data.maybe.child_type->id == TypeTableEntryIdPromise)
     {
         zig_panic("TODO audit this function");
 @@ -3621,7 +3724,7 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen *g, IrExecutable *executable, IrIn
             success_order, failure_order, instruction->is_weak);
     TypeTableEntry *maybe_type = instruction->base.value.type;
-    assert(maybe_type->id == TypeTableEntryIdMaybe);
+    assert(maybe_type->id == TypeTableEntryIdOptional);
     TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
     if (type_is_codegen_pointer(child_type)) {
 @@ -3730,7 +3833,6 @@ static LLVMValueRef ir_render_slice(CodeGen *g, IrExecutable *executable, IrInst
         } else {
             end_val = LLVMConstInt(g->builtin_types.entry_usize->type_ref, array_type->data.array.len, false);
         }
         if (want_runtime_safety) {
             add_bounds_check(g, start_val, LLVMIntEQ, nullptr, LLVMIntULE, end_val);
             if (instruction->end) {
 @@ -4008,10 +4110,10 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen *g, IrExecutable *execu
     }
 }
-static LLVMValueRef ir_render_maybe_wrap(CodeGen *g, IrExecutable *executable, IrInstructionMaybeWrap *instruction) {
+static LLVMValueRef ir_render_maybe_wrap(CodeGen *g, IrExecutable *executable, IrInstructionOptionalWrap *instruction) {
     TypeTableEntry *wanted_type = instruction->base.value.type;
-    assert(wanted_type->id == TypeTableEntryIdMaybe);
+    assert(wanted_type->id == TypeTableEntryIdOptional);
     TypeTableEntry *child_type = wanted_type->data.maybe.child_type;
 @@ -4540,7 +4642,6 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
         case IrInstructionIdCheckSwitchProngs:
         case IrInstructionIdCheckStatementIsVoid:
         case IrInstructionIdTypeName:
-        case IrInstructionIdCanImplicitCast:
         case IrInstructionIdDeclRef:
         case IrInstructionIdSwitchVar:
         case IrInstructionIdOffsetOf:
 @@ -4593,8 +4694,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_asm(g, executable, (IrInstructionAsm *)instruction);
         case IrInstructionIdTestNonNull:
             return ir_render_test_non_null(g, executable, (IrInstructionTestNonNull *)instruction);
-        case IrInstructionIdUnwrapMaybe:
+        case IrInstructionIdUnwrapOptional:
-            return ir_render_unwrap_maybe(g, executable, (IrInstructionUnwrapMaybe *)instruction);
+            return ir_render_unwrap_maybe(g, executable, (IrInstructionUnwrapOptional *)instruction);
         case IrInstructionIdClz:
             return ir_render_clz(g, executable, (IrInstructionClz *)instruction);
         case IrInstructionIdCtz:
 @@ -4635,8 +4736,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_unwrap_err_code(g, executable, (IrInstructionUnwrapErrCode *)instruction);
         case IrInstructionIdUnwrapErrPayload:
             return ir_render_unwrap_err_payload(g, executable, (IrInstructionUnwrapErrPayload *)instruction);
-        case IrInstructionIdMaybeWrap:
+        case IrInstructionIdOptionalWrap:
-            return ir_render_maybe_wrap(g, executable, (IrInstructionMaybeWrap *)instruction);
+            return ir_render_maybe_wrap(g, executable, (IrInstructionOptionalWrap *)instruction);
         case IrInstructionIdErrWrapCode:
             return ir_render_err_wrap_code(g, executable, (IrInstructionErrWrapCode *)instruction);
         case IrInstructionIdErrWrapPayload:
 @@ -4866,7 +4967,7 @@ static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, Con
             }
         case TypeTableEntryIdPointer:
         case TypeTableEntryIdFn:
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
         case TypeTableEntryIdPromise:
             {
                 LLVMValueRef ptr_val = gen_const_val(g, const_val, "");
 @@ -4914,6 +5015,79 @@ static bool is_llvm_value_unnamed_type(TypeTableEntry *type_entry, LLVMValueRef
     return LLVMTypeOf(val) != type_entry->type_ref;
 }
+static LLVMValueRef gen_const_val_ptr(CodeGen *g, ConstExprValue *const_val, const char *name) {
+    render_const_val_global(g, const_val, name);
+    switch (const_val->data.x_ptr.special) {
+        case ConstPtrSpecialInvalid:
+        case ConstPtrSpecialDiscard:
+            zig_unreachable();
+        case ConstPtrSpecialRef:
+            {
+                ConstExprValue *pointee = const_val->data.x_ptr.data.ref.pointee;
+                render_const_val(g, pointee, "");
+                render_const_val_global(g, pointee, "");
+                ConstExprValue *other_val = pointee;
+                const_val->global_refs->llvm_value = LLVMConstBitCast(other_val->global_refs->llvm_global, const_val->type->type_ref);
+                render_const_val_global(g, const_val, "");
+                return const_val->global_refs->llvm_value;
+            }
+        case ConstPtrSpecialBaseArray:
+            {
+                ConstExprValue *array_const_val = const_val->data.x_ptr.data.base_array.array_val;
+                size_t elem_index = const_val->data.x_ptr.data.base_array.elem_index;
+                assert(array_const_val->type->id == TypeTableEntryIdArray);
+                if (array_const_val->type->zero_bits) {
+                    // make this a null pointer
+                    TypeTableEntry *usize = g->builtin_types.entry_usize;
+                    const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->type_ref),
+                            const_val->type->type_ref);
+                    render_const_val_global(g, const_val, "");
+                    return const_val->global_refs->llvm_value;
+                }
+                LLVMValueRef uncasted_ptr_val = gen_const_ptr_array_recursive(g, array_const_val,
+                        elem_index);
+                LLVMValueRef ptr_val = LLVMConstBitCast(uncasted_ptr_val, const_val->type->type_ref);
+                const_val->global_refs->llvm_value = ptr_val;
+                render_const_val_global(g, const_val, "");
+                return ptr_val;
+            }
+        case ConstPtrSpecialBaseStruct:
+            {
+                ConstExprValue *struct_const_val = const_val->data.x_ptr.data.base_struct.struct_val;
+                assert(struct_const_val->type->id == TypeTableEntryIdStruct);
+                if (struct_const_val->type->zero_bits) {
+                    // make this a null pointer
+                    TypeTableEntry *usize = g->builtin_types.entry_usize;
+                    const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->type_ref),
+                            const_val->type->type_ref);
+                    render_const_val_global(g, const_val, "");
+                    return const_val->global_refs->llvm_value;
+                }
+                size_t src_field_index = const_val->data.x_ptr.data.base_struct.field_index;
+                size_t gen_field_index =
+                    struct_const_val->type->data.structure.fields[src_field_index].gen_index;
+                LLVMValueRef uncasted_ptr_val = gen_const_ptr_struct_recursive(g, struct_const_val,
+                        gen_field_index);
+                LLVMValueRef ptr_val = LLVMConstBitCast(uncasted_ptr_val, const_val->type->type_ref);
+                const_val->global_refs->llvm_value = ptr_val;
+                render_const_val_global(g, const_val, "");
+                return ptr_val;
+            }
+        case ConstPtrSpecialHardCodedAddr:
+            {
+                uint64_t addr_value = const_val->data.x_ptr.data.hard_coded_addr.addr;
+                TypeTableEntry *usize = g->builtin_types.entry_usize;
+                const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstInt(usize->type_ref, addr_value, false),
+                        const_val->type->type_ref);
+                render_const_val_global(g, const_val, "");
+                return const_val->global_refs->llvm_value;
+            }
+        case ConstPtrSpecialFunction:
+            return LLVMConstBitCast(fn_llvm_value(g, const_val->data.x_ptr.data.fn.fn_entry), const_val->type->type_ref);
+    }
+    zig_unreachable();
+}
 static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val, const char *name) {
     TypeTableEntry *type_entry = const_val->type;
     assert(!type_entry->zero_bits);
 @@ -4958,23 +5132,19 @@ static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val, const c
             } else {
                 return LLVMConstNull(LLVMInt1Type());
             }
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             {
                 TypeTableEntry *child_type = type_entry->data.maybe.child_type;
                 if (child_type->zero_bits) {
-                    return LLVMConstInt(LLVMInt1Type(), const_val->data.x_maybe ? 1 : 0, false);
+                    return LLVMConstInt(LLVMInt1Type(), const_val->data.x_optional ? 1 : 0, false);
                 } else if (type_is_codegen_pointer(child_type)) {
-                    if (const_val->data.x_maybe) {
+                    return gen_const_val_ptr(g, const_val, name);
-                        return gen_const_val(g, const_val->data.x_maybe, "");
-                    } else {
-                        return LLVMConstNull(child_type->type_ref);
-                    }
                 } else {
                     LLVMValueRef child_val;
                     LLVMValueRef maybe_val;
                     bool make_unnamed_struct;
-                    if (const_val->data.x_maybe) {
+                    if (const_val->data.x_optional) {
-                        child_val = gen_const_val(g, const_val->data.x_maybe, "");
+                        child_val = gen_const_val(g, const_val->data.x_optional, "");
                         maybe_val = LLVMConstAllOnes(LLVMInt1Type());
                         make_unnamed_struct = is_llvm_value_unnamed_type(const_val->type, child_val);
 @@ -5164,78 +5334,7 @@ static LLVMValueRef gen_const_val(CodeGen *g, ConstExprValue *const_val, const c
             assert(const_val->data.x_ptr.mut == ConstPtrMutComptimeConst);
             return fn_llvm_value(g, const_val->data.x_ptr.data.fn.fn_entry);
         case TypeTableEntryIdPointer:
-            {
+            return gen_const_val_ptr(g, const_val, name);
-                render_const_val_global(g, const_val, name);
-                switch (const_val->data.x_ptr.special) {
-                    case ConstPtrSpecialInvalid:
-                    case ConstPtrSpecialDiscard:
-                        zig_unreachable();
-                    case ConstPtrSpecialRef:
-                        {
-                            ConstExprValue *pointee = const_val->data.x_ptr.data.ref.pointee;
-                            render_const_val(g, pointee, "");
-                            render_const_val_global(g, pointee, "");
-                            ConstExprValue *other_val = pointee;
-                            const_val->global_refs->llvm_value = LLVMConstBitCast(other_val->global_refs->llvm_global, const_val->type->type_ref);
-                            render_const_val_global(g, const_val, "");
-                            return const_val->global_refs->llvm_value;
-                        }
-                    case ConstPtrSpecialBaseArray:
-                        {
-                            ConstExprValue *array_const_val = const_val->data.x_ptr.data.base_array.array_val;
-                            size_t elem_index = const_val->data.x_ptr.data.base_array.elem_index;
-                            assert(array_const_val->type->id == TypeTableEntryIdArray);
-                            if (array_const_val->type->zero_bits) {
-                                // make this a null pointer
-                                TypeTableEntry *usize = g->builtin_types.entry_usize;
-                                const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->type_ref),
-                                        const_val->type->type_ref);
-                                render_const_val_global(g, const_val, "");
-                                return const_val->global_refs->llvm_value;
-                            }
-                            LLVMValueRef uncasted_ptr_val = gen_const_ptr_array_recursive(g, array_const_val,
-                                    elem_index);
-                            LLVMValueRef ptr_val = LLVMConstBitCast(uncasted_ptr_val, const_val->type->type_ref);
-                            const_val->global_refs->llvm_value = ptr_val;
-                            render_const_val_global(g, const_val, "");
-                            return ptr_val;
-                        }
-                    case ConstPtrSpecialBaseStruct:
-                        {
-                            ConstExprValue *struct_const_val = const_val->data.x_ptr.data.base_struct.struct_val;
-                            assert(struct_const_val->type->id == TypeTableEntryIdStruct);
-                            if (struct_const_val->type->zero_bits) {
-                                // make this a null pointer
-                                TypeTableEntry *usize = g->builtin_types.entry_usize;
-                                const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstNull(usize->type_ref),
-                                        const_val->type->type_ref);
-                                render_const_val_global(g, const_val, "");
-                                return const_val->global_refs->llvm_value;
-                            }
-                            size_t src_field_index = const_val->data.x_ptr.data.base_struct.field_index;
-                            size_t gen_field_index =
-                                struct_const_val->type->data.structure.fields[src_field_index].gen_index;
-                            LLVMValueRef uncasted_ptr_val = gen_const_ptr_struct_recursive(g, struct_const_val,
-                                    gen_field_index);
-                            LLVMValueRef ptr_val = LLVMConstBitCast(uncasted_ptr_val, const_val->type->type_ref);
-                            const_val->global_refs->llvm_value = ptr_val;
-                            render_const_val_global(g, const_val, "");
-                            return ptr_val;
-                        }
-                    case ConstPtrSpecialHardCodedAddr:
-                        {
-                            uint64_t addr_value = const_val->data.x_ptr.data.hard_coded_addr.addr;
-                            TypeTableEntry *usize = g->builtin_types.entry_usize;
-                            const_val->global_refs->llvm_value = LLVMConstIntToPtr(LLVMConstInt(usize->type_ref, addr_value, false),
-                                    const_val->type->type_ref);
-                            render_const_val_global(g, const_val, "");
-                            return const_val->global_refs->llvm_value;
-                        }
-                    case ConstPtrSpecialFunction:
-                        return LLVMConstBitCast(fn_llvm_value(g, const_val->data.x_ptr.data.fn.fn_entry), const_val->type->type_ref);
-                }
-            }
-            zig_unreachable();
         case TypeTableEntryIdErrorUnion:
             {
                 TypeTableEntry *payload_type = type_entry->data.error_union.payload_type;
 @@ -5367,55 +5466,6 @@ static void generate_error_name_table(CodeGen *g) {
     LLVMSetAlignment(g->err_name_table, LLVMABIAlignmentOfType(g->target_data_ref, LLVMTypeOf(err_name_table_init)));
 }
-static void generate_enum_name_tables(CodeGen *g) {
-    TypeTableEntry *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
-            PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);
-    TypeTableEntry *str_type = get_slice_type(g, u8_ptr_type);
-    TypeTableEntry *usize = g->builtin_types.entry_usize;
-    LLVMValueRef array_ptr_indices[] = {
-        LLVMConstNull(usize->type_ref),
-        LLVMConstNull(usize->type_ref),
-    };
-    for (size_t enum_i = 0; enum_i < g->name_table_enums.length; enum_i += 1) {
-        TypeTableEntry *enum_type = g->name_table_enums.at(enum_i);
-        assert(enum_type->id == TypeTableEntryIdEnum);
-        size_t field_count = enum_type->data.enumeration.src_field_count;
-        LLVMValueRef *values = allocate<LLVMValueRef>(field_count);
-        for (size_t field_i = 0; field_i < field_count; field_i += 1) {
-            Buf *name = enum_type->data.enumeration.fields[field_i].name;
-            LLVMValueRef str_init = LLVMConstString(buf_ptr(name), (unsigned)buf_len(name), true);
-            LLVMValueRef str_global = LLVMAddGlobal(g->module, LLVMTypeOf(str_init), "");
-            LLVMSetInitializer(str_global, str_init);
-            LLVMSetLinkage(str_global, LLVMPrivateLinkage);
-            LLVMSetGlobalConstant(str_global, true);
-            LLVMSetUnnamedAddr(str_global, true);
-            LLVMSetAlignment(str_global, LLVMABIAlignmentOfType(g->target_data_ref, LLVMTypeOf(str_init)));
-            LLVMValueRef fields[] = {
-                LLVMConstGEP(str_global, array_ptr_indices, 2),
-                LLVMConstInt(g->builtin_types.entry_usize->type_ref, buf_len(name), false),
-            };
-            values[field_i] = LLVMConstNamedStruct(str_type->type_ref, fields, 2);
-        }
-        LLVMValueRef name_table_init = LLVMConstArray(str_type->type_ref, values, (unsigned)field_count);
-        Buf *table_name = get_mangled_name(g, buf_sprintf("%s_name_table", buf_ptr(&enum_type->name)), false);
-        LLVMValueRef name_table = LLVMAddGlobal(g->module, LLVMTypeOf(name_table_init), buf_ptr(table_name));
-        LLVMSetInitializer(name_table, name_table_init);
-        LLVMSetLinkage(name_table, LLVMPrivateLinkage);
-        LLVMSetGlobalConstant(name_table, true);
-        LLVMSetUnnamedAddr(name_table, true);
-        LLVMSetAlignment(name_table, LLVMABIAlignmentOfType(g->target_data_ref, LLVMTypeOf(name_table_init)));
-        enum_type->data.enumeration.name_table = name_table;
-    }
-}
 static void build_all_basic_blocks(CodeGen *g, FnTableEntry *fn) {
     IrExecutable *executable = &fn->analyzed_executable;
     assert(executable->basic_block_list.length > 0);
 @@ -5512,7 +5562,6 @@ static void do_code_gen(CodeGen *g) {
     }
     generate_error_name_table(g);
-    generate_enum_name_tables(g);
     // Generate module level variables
     for (size_t i = 0; i < g->global_vars.length; i += 1) {
 @@ -5651,8 +5700,8 @@ static void do_code_gen(CodeGen *g) {
             } else if (instruction->id == IrInstructionIdSlice) {
                 IrInstructionSlice *slice_instruction = (IrInstructionSlice *)instruction;
                 slot = &slice_instruction->tmp_ptr;
-            } else if (instruction->id == IrInstructionIdMaybeWrap) {
+            } else if (instruction->id == IrInstructionIdOptionalWrap) {
-                IrInstructionMaybeWrap *maybe_wrap_instruction = (IrInstructionMaybeWrap *)instruction;
+                IrInstructionOptionalWrap *maybe_wrap_instruction = (IrInstructionOptionalWrap *)instruction;
                 slot = &maybe_wrap_instruction->tmp_ptr;
             } else if (instruction->id == IrInstructionIdErrWrapPayload) {
                 IrInstructionErrWrapPayload *err_wrap_payload_instruction = (IrInstructionErrWrapPayload *)instruction;
 @@ -6192,7 +6241,6 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn(g, BuiltinFnIdCImport, "cImport", 1);
     create_builtin_fn(g, BuiltinFnIdErrName, "errorName", 1);
     create_builtin_fn(g, BuiltinFnIdTypeName, "typeName", 1);
-    create_builtin_fn(g, BuiltinFnIdCanImplicitCast, "canImplicitCast", 2);
     create_builtin_fn(g, BuiltinFnIdEmbedFile, "embedFile", 1);
     create_builtin_fn(g, BuiltinFnIdCmpxchgWeak, "cmpxchgWeak", 6);
     create_builtin_fn(g, BuiltinFnIdCmpxchgStrong, "cmpxchgStrong", 6);
 @@ -6250,13 +6298,7 @@ static const char *build_mode_to_str(BuildMode build_mode) {
     zig_unreachable();
 }
-static void define_builtin_compile_vars(CodeGen *g) {
+Buf *codegen_generate_builtin_source(CodeGen *g) {
-    if (g->std_package == nullptr)
-        return;
-    const char *builtin_zig_basename = "builtin.zig";
-    Buf *builtin_zig_path = buf_alloc();
-    os_path_join(g->cache_dir, buf_create_from_str(builtin_zig_basename), builtin_zig_path);
     Buf *contents = buf_alloc();
     // Modifications to this struct must be coordinated with code that does anything with
 @@ -6396,7 +6438,6 @@ static void define_builtin_compile_vars(CodeGen *g) {
             const TypeTableEntryId id = type_id_at_index(i);
             buf_appendf(contents, "    %s,\n", type_id_name(id));
         }
-        buf_appendf(contents, "    Slice,\n");
         buf_appendf(contents, "};\n\n");
     }
     {
 @@ -6409,14 +6450,13 @@ static void define_builtin_compile_vars(CodeGen *g) {
             "    Int: Int,\n"
             "    Float: Float,\n"
             "    Pointer: Pointer,\n"
-            "    Slice: Slice,\n"
             "    Array: Array,\n"
             "    Struct: Struct,\n"
             "    ComptimeFloat: void,\n"
             "    ComptimeInt: void,\n"
             "    Undefined: void,\n"
             "    Null: void,\n"
-            "    Nullable: Nullable,\n"
+            "    Optional: Optional,\n"
             "    ErrorUnion: ErrorUnion,\n"
             "    ErrorSet: ErrorSet,\n"
             "    Enum: Enum,\n"
 @@ -6439,13 +6479,18 @@ static void define_builtin_compile_vars(CodeGen *g) {
             "    };\n"
             "\n"
             "    pub const Pointer = struct {\n"
+            "        size: Size,\n"
             "        is_const: bool,\n"
             "        is_volatile: bool,\n"
             "        alignment: u32,\n"
             "        child: type,\n"
-            "    };\n"
             "\n"
-            "    pub const Slice = Pointer;\n"
+            "        pub const Size = enum {\n"
+            "            One,\n"
+            "            Many,\n"
+            "            Slice,\n"
+            "        };\n"
+            "    };\n"
             "\n"
             "    pub const Array = struct {\n"
             "        len: usize,\n"
 @@ -6470,7 +6515,7 @@ static void define_builtin_compile_vars(CodeGen *g) {
             "        defs: []Definition,\n"
             "    };\n"
             "\n"
-            "    pub const Nullable = struct {\n"
+            "    pub const Optional = struct {\n"
             "        child: type,\n"
             "    };\n"
             "\n"
 @@ -6619,6 +6664,19 @@ static void define_builtin_compile_vars(CodeGen *g) {
     buf_appendf(contents, "pub const __zig_test_fn_slice = {}; // overwritten later\n");
+    return contents;
+}
+static void define_builtin_compile_vars(CodeGen *g) {
+    if (g->std_package == nullptr)
+        return;
+    const char *builtin_zig_basename = "builtin.zig";
+    Buf *builtin_zig_path = buf_alloc();
+    os_path_join(g->cache_dir, buf_create_from_str(builtin_zig_basename), builtin_zig_path);
+    Buf *contents = codegen_generate_builtin_source(g);
     ensure_cache_dir(g);
     os_write_file(builtin_zig_path, contents);
 @@ -7032,7 +7090,7 @@ static void prepend_c_type_to_decl_list(CodeGen *g, GenH *gen_h, TypeTableEntry
         case TypeTableEntryIdArray:
             prepend_c_type_to_decl_list(g, gen_h, type_entry->data.array.child_type);
             return;
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             prepend_c_type_to_decl_list(g, gen_h, type_entry->data.maybe.child_type);
             return;
         case TypeTableEntryIdFn:
 @@ -7121,7 +7179,7 @@ static void get_c_type(CodeGen *g, GenH *gen_h, TypeTableEntry *type_entry, Buf
                 buf_appendf(out_buf, "%s%s *", const_str, buf_ptr(&child_buf));
                 break;
             }
-        case TypeTableEntryIdMaybe:
+        case TypeTableEntryIdOptional:
             {
                 TypeTableEntry *child_type = type_entry->data.maybe.child_type;
                 if (child_type->zero_bits) {
 @@ -7335,7 +7393,7 @@ static void gen_h_file(CodeGen *g) {
             case TypeTableEntryIdBlock:
             case TypeTableEntryIdBoundFn:
             case TypeTableEntryIdArgTuple:
-            case TypeTableEntryIdMaybe:
+            case TypeTableEntryIdOptional:
             case TypeTableEntryIdFn:
             case TypeTableEntryIdPromise:
                 zig_unreachable();

src/codegen.hpp+2

...	@@ -59,5 +59,7 @@ void codegen_add_object(CodeGen g, Buf object_path);	...	@@ -59,5 +59,7 @@ void codegen_add_object(CodeGen g, Buf object_path);
59		59
60	void codegen_translate_c(CodeGen g, Buf path);	60	void codegen_translate_c(CodeGen g, Buf path);
61		61
		62	Buf codegen_generate_builtin_source(CodeGen g);
		63
62		64
63	#endif	65	#endif

src/ir.cpp+603-453

...	@@ -47,7 +47,7 @@ enum ConstCastResultId {	...	@@ -47,7 +47,7 @@ enum ConstCastResultId {
47	ConstCastResultIdErrSetGlobal,	47	ConstCastResultIdErrSetGlobal,
48	ConstCastResultIdPointerChild,	48	ConstCastResultIdPointerChild,
49	ConstCastResultIdSliceChild,	49	ConstCastResultIdSliceChild,
50	ConstCastResultIdNullableChild,	50	ConstCastResultIdOptionalChild,
51	ConstCastResultIdErrorUnionPayload,	51	ConstCastResultIdErrorUnionPayload,
52	ConstCastResultIdErrorUnionErrorSet,	52	ConstCastResultIdErrorUnionErrorSet,
53	ConstCastResultIdFnAlign,	53	ConstCastResultIdFnAlign,
...	@@ -62,6 +62,7 @@ enum ConstCastResultId {	...	@@ -62,6 +62,7 @@ enum ConstCastResultId {
62	ConstCastResultIdType,	62	ConstCastResultIdType,
63	ConstCastResultIdUnresolvedInferredErrSet,	63	ConstCastResultIdUnresolvedInferredErrSet,
64	ConstCastResultIdAsyncAllocatorType,	64	ConstCastResultIdAsyncAllocatorType,
		65	ConstCastResultIdNullWrapPtr,
65	};	66	};
66		67
67	struct ConstCastErrSetMismatch {	68	struct ConstCastErrSetMismatch {
...	@@ -85,11 +86,12 @@ struct ConstCastOnly {	...	@@ -85,11 +86,12 @@ struct ConstCastOnly {
85	ConstCastErrSetMismatch error_set;	86	ConstCastErrSetMismatch error_set;
86	ConstCastOnly *pointer_child;	87	ConstCastOnly *pointer_child;
87	ConstCastOnly *slice_child;	88	ConstCastOnly *slice_child;
88	ConstCastOnly *nullable_child;	89	ConstCastOnly *optional_child;
89	ConstCastOnly *error_union_payload;	90	ConstCastOnly *error_union_payload;
90	ConstCastOnly *error_union_error_set;	91	ConstCastOnly *error_union_error_set;
91	ConstCastOnly *return_type;	92	ConstCastOnly *return_type;
92	ConstCastOnly *async_allocator_type;	93	ConstCastOnly *async_allocator_type;
		94	ConstCastOnly *null_wrap_ptr_child;
93	ConstCastArg fn_arg;	95	ConstCastArg fn_arg;
94	ConstCastArgNoAlias arg_no_alias;	96	ConstCastArgNoAlias arg_no_alias;
95	} data;	97	} data;
...	@@ -108,9 +110,10 @@ static IrInstruction ir_get_var_ptr(IrAnalyze ira, IrInstruction *instruction,	...	@@ -108,9 +110,10 @@ static IrInstruction ir_get_var_ptr(IrAnalyze ira, IrInstruction *instruction,
108	static TypeTableEntry ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op);	110	static TypeTableEntry ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op);
109	static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction value, LVal lval);	111	static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction value, LVal lval);
110	static TypeTableEntry adjust_ptr_align(CodeGen g, TypeTableEntry *ptr_type, uint32_t new_align);	112	static TypeTableEntry adjust_ptr_align(CodeGen g, TypeTableEntry *ptr_type, uint32_t new_align);
		113	static TypeTableEntry adjust_slice_align(CodeGen g, TypeTableEntry *slice_type, uint32_t new_align);
111		114
112	ConstExprValue const_ptr_pointee(CodeGen g, ConstExprValue *const_val) {	115	ConstExprValue const_ptr_pointee(CodeGen g, ConstExprValue *const_val) {
113	assert(const_val->type->id == TypeTableEntryIdPointer);	116	assert(get_codegen_ptr_type(const_val->type) != nullptr);
114	assert(const_val->special == ConstValSpecialStatic);	117	assert(const_val->special == ConstValSpecialStatic);
115	switch (const_val->data.x_ptr.special) {	118	switch (const_val->data.x_ptr.special) {
116	case ConstPtrSpecialInvalid:	119	case ConstPtrSpecialInvalid:
...	@@ -369,8 +372,8 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionTestNonNull *) {	...	@@ -369,8 +372,8 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionTestNonNull *) {
369	return IrInstructionIdTestNonNull;	372	return IrInstructionIdTestNonNull;
370	}	373	}
371		374
372	static constexpr IrInstructionId ir_instruction_id(IrInstructionUnwrapMaybe *) {	375	static constexpr IrInstructionId ir_instruction_id(IrInstructionUnwrapOptional *) {
373	return IrInstructionIdUnwrapMaybe;	376	return IrInstructionIdUnwrapOptional;
374	}	377	}
375		378
376	static constexpr IrInstructionId ir_instruction_id(IrInstructionClz *) {	379	static constexpr IrInstructionId ir_instruction_id(IrInstructionClz *) {
...	@@ -521,8 +524,8 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionUnwrapErrPayload	...	@@ -521,8 +524,8 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionUnwrapErrPayload
521	return IrInstructionIdUnwrapErrPayload;	524	return IrInstructionIdUnwrapErrPayload;
522	}	525	}
523		526
524	static constexpr IrInstructionId ir_instruction_id(IrInstructionMaybeWrap *) {	527	static constexpr IrInstructionId ir_instruction_id(IrInstructionOptionalWrap *) {
525	return IrInstructionIdMaybeWrap;	528	return IrInstructionIdOptionalWrap;
526	}	529	}
527		530
528	static constexpr IrInstructionId ir_instruction_id(IrInstructionErrWrapPayload *) {	531	static constexpr IrInstructionId ir_instruction_id(IrInstructionErrWrapPayload *) {
...	@@ -585,10 +588,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeName *) {	...	@@ -585,10 +588,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeName *) {
585	return IrInstructionIdTypeName;	588	return IrInstructionIdTypeName;
586	}	589	}
587		590
588	static constexpr IrInstructionId ir_instruction_id(IrInstructionCanImplicitCast *) {
589	return IrInstructionIdCanImplicitCast;
590	}
591
592	static constexpr IrInstructionId ir_instruction_id(IrInstructionDeclRef *) {	591	static constexpr IrInstructionId ir_instruction_id(IrInstructionDeclRef *) {
593	return IrInstructionIdDeclRef;	592	return IrInstructionIdDeclRef;
594	}	593	}
...	@@ -1572,7 +1571,7 @@ static IrInstruction ir_build_test_nonnull_from(IrBuilder irb, IrInstruction *	...	@@ -1572,7 +1571,7 @@ static IrInstruction ir_build_test_nonnull_from(IrBuilder irb, IrInstruction *
1572	static IrInstruction ir_build_unwrap_maybe(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value,	1571	static IrInstruction ir_build_unwrap_maybe(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value,
1573	bool safety_check_on)	1572	bool safety_check_on)
1574	{	1573	{
1575	IrInstructionUnwrapMaybe *instruction = ir_build_instruction<IrInstructionUnwrapMaybe>(irb, scope, source_node);	1574	IrInstructionUnwrapOptional *instruction = ir_build_instruction<IrInstructionUnwrapOptional>(irb, scope, source_node);
1576	instruction->value = value;	1575	instruction->value = value;
1577	instruction->safety_check_on = safety_check_on;	1576	instruction->safety_check_on = safety_check_on;
1578		1577
...	@@ -1591,7 +1590,7 @@ static IrInstruction ir_build_unwrap_maybe_from(IrBuilder irb, IrInstruction *	...	@@ -1591,7 +1590,7 @@ static IrInstruction ir_build_unwrap_maybe_from(IrBuilder irb, IrInstruction *
1591	}	1590	}
1592		1591
1593	static IrInstruction ir_build_maybe_wrap(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {	1592	static IrInstruction ir_build_maybe_wrap(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
1594	IrInstructionMaybeWrap *instruction = ir_build_instruction<IrInstructionMaybeWrap>(irb, scope, source_node);	1593	IrInstructionOptionalWrap *instruction = ir_build_instruction<IrInstructionOptionalWrap>(irb, scope, source_node);
1595	instruction->value = value;	1594	instruction->value = value;
1596		1595
1597	ir_ref_instruction(value, irb->current_basic_block);	1596	ir_ref_instruction(value, irb->current_basic_block);
...	@@ -2348,20 +2347,6 @@ static IrInstruction ir_build_type_name(IrBuilder irb, Scope scope, AstNode	...	@@ -2348,20 +2347,6 @@ static IrInstruction ir_build_type_name(IrBuilder irb, Scope scope, AstNode
2348	return &instruction->base;	2347	return &instruction->base;
2349	}	2348	}
2350		2349
2351	static IrInstruction ir_build_can_implicit_cast(IrBuilder irb, Scope scope, AstNode source_node,
2352	IrInstruction type_value, IrInstruction target_value)
2353	{
2354	IrInstructionCanImplicitCast *instruction = ir_build_instruction<IrInstructionCanImplicitCast>(
2355	irb, scope, source_node);
2356	instruction->type_value = type_value;
2357	instruction->target_value = target_value;
2358
2359	ir_ref_instruction(type_value, irb->current_basic_block);
2360	ir_ref_instruction(target_value, irb->current_basic_block);
2361
2362	return &instruction->base;
2363	}
2364
2365	static IrInstruction ir_build_decl_ref(IrBuilder irb, Scope scope, AstNode source_node,	2350	static IrInstruction ir_build_decl_ref(IrBuilder irb, Scope scope, AstNode source_node,
2366	Tld *tld, LVal lval)	2351	Tld *tld, LVal lval)
2367	{	2352	{
...	@@ -2511,9 +2496,9 @@ static IrInstruction ir_build_arg_type(IrBuilder irb, Scope scope, AstNode s	...	@@ -2511,9 +2496,9 @@ static IrInstruction ir_build_arg_type(IrBuilder irb, Scope scope, AstNode s
2511	return &instruction->base;	2496	return &instruction->base;
2512	}	2497	}
2513		2498
2514	static IrInstruction ir_build_error_return_trace(IrBuilder irb, Scope scope, AstNode source_node, IrInstructionErrorReturnTrace::Nullable nullable) {	2499	static IrInstruction ir_build_error_return_trace(IrBuilder irb, Scope scope, AstNode source_node, IrInstructionErrorReturnTrace::Optional optional) {
2515	IrInstructionErrorReturnTrace *instruction = ir_build_instruction<IrInstructionErrorReturnTrace>(irb, scope, source_node);	2500	IrInstructionErrorReturnTrace *instruction = ir_build_instruction<IrInstructionErrorReturnTrace>(irb, scope, source_node);
2516	instruction->nullable = nullable;	2501	instruction->optional = optional;
2517		2502
2518	return &instruction->base;	2503	return &instruction->base;
2519	}	2504	}
...	@@ -3310,9 +3295,9 @@ static IrInstruction ir_gen_maybe_ok_or(IrBuilder irb, Scope *parent_scope, As	...	@@ -3310,9 +3295,9 @@ static IrInstruction ir_gen_maybe_ok_or(IrBuilder irb, Scope *parent_scope, As
3310	is_comptime = ir_build_test_comptime(irb, parent_scope, node, is_non_null);	3295	is_comptime = ir_build_test_comptime(irb, parent_scope, node, is_non_null);
3311	}	3296	}
3312		3297
3313	IrBasicBlock *ok_block = ir_create_basic_block(irb, parent_scope, "MaybeNonNull");	3298	IrBasicBlock *ok_block = ir_create_basic_block(irb, parent_scope, "OptionalNonNull");
3314	IrBasicBlock *null_block = ir_create_basic_block(irb, parent_scope, "MaybeNull");	3299	IrBasicBlock *null_block = ir_create_basic_block(irb, parent_scope, "OptionalNull");
3315	IrBasicBlock *end_block = ir_create_basic_block(irb, parent_scope, "MaybeEnd");	3300	IrBasicBlock *end_block = ir_create_basic_block(irb, parent_scope, "OptionalEnd");
3316	ir_build_cond_br(irb, parent_scope, node, is_non_null, ok_block, null_block, is_comptime);	3301	ir_build_cond_br(irb, parent_scope, node, is_non_null, ok_block, null_block, is_comptime);
3317		3302
3318	ir_set_cursor_at_end_and_append_block(irb, null_block);	3303	ir_set_cursor_at_end_and_append_block(irb, null_block);
...	@@ -3441,7 +3426,7 @@ static IrInstruction ir_gen_bin_op(IrBuilder irb, Scope scope, AstNode node)	...	@@ -3441,7 +3426,7 @@ static IrInstruction ir_gen_bin_op(IrBuilder irb, Scope scope, AstNode node)
3441	return ir_gen_bin_op_id(irb, scope, node, IrBinOpArrayMult);	3426	return ir_gen_bin_op_id(irb, scope, node, IrBinOpArrayMult);
3442	case BinOpTypeMergeErrorSets:	3427	case BinOpTypeMergeErrorSets:
3443	return ir_gen_bin_op_id(irb, scope, node, IrBinOpMergeErrorSets);	3428	return ir_gen_bin_op_id(irb, scope, node, IrBinOpMergeErrorSets);
3444	case BinOpTypeUnwrapMaybe:	3429	case BinOpTypeUnwrapOptional:
3445	return ir_gen_maybe_ok_or(irb, scope, node);	3430	return ir_gen_maybe_ok_or(irb, scope, node);
3446	case BinOpTypeErrorUnion:	3431	case BinOpTypeErrorUnion:
3447	return ir_gen_error_union(irb, scope, node);	3432	return ir_gen_error_union(irb, scope, node);
...	@@ -4132,21 +4117,6 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo	...	@@ -4132,21 +4117,6 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4132	IrInstruction *type_name = ir_build_type_name(irb, scope, node, arg0_value);	4117	IrInstruction *type_name = ir_build_type_name(irb, scope, node, arg0_value);
4133	return ir_lval_wrap(irb, scope, type_name, lval);	4118	return ir_lval_wrap(irb, scope, type_name, lval);
4134	}	4119	}
4135	case BuiltinFnIdCanImplicitCast:
4136	{
4137	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
4138	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
4139	if (arg0_value == irb->codegen->invalid_instruction)
4140	return arg0_value;
4141
4142	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
4143	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
4144	if (arg1_value == irb->codegen->invalid_instruction)
4145	return arg1_value;
4146
4147	IrInstruction *can_implicit_cast = ir_build_can_implicit_cast(irb, scope, node, arg0_value, arg1_value);
4148	return ir_lval_wrap(irb, scope, can_implicit_cast, lval);
4149	}
4150	case BuiltinFnIdPanic:	4120	case BuiltinFnIdPanic:
4151	{	4121	{
4152	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);	4122	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
...	@@ -4620,11 +4590,8 @@ static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction	...	@@ -4620,11 +4590,8 @@ static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction
4620		4590
4621	static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope scope, AstNode node) {	4591	static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope scope, AstNode node) {
4622	assert(node->type == NodeTypePointerType);	4592	assert(node->type == NodeTypePointerType);
4623	// The null check here is for C imports which don't set a token on the AST node. We could potentially	4593	PtrLen ptr_len = (node->data.pointer_type.star_token->id == TokenIdStar \|\|
4624	// update that code to create a fake token and then remove this check.	4594	node->data.pointer_type.star_token->id == TokenIdStarStar) ? PtrLenSingle : PtrLenUnknown;
4625	PtrLen ptr_len = (node->data.pointer_type.star_token != nullptr &&
4626	(node->data.pointer_type.star_token->id == TokenIdStar \|\|
4627	node->data.pointer_type.star_token->id == TokenIdStarStar)) ? PtrLenSingle : PtrLenUnknown;
4628	bool is_const = node->data.pointer_type.is_const;	4595	bool is_const = node->data.pointer_type.is_const;
4629	bool is_volatile = node->data.pointer_type.is_volatile;	4596	bool is_volatile = node->data.pointer_type.is_volatile;
4630	AstNode *expr_node = node->data.pointer_type.op_expr;	4597	AstNode *expr_node = node->data.pointer_type.op_expr;
...	@@ -4694,21 +4661,6 @@ static IrInstruction ir_gen_err_assert_ok(IrBuilder irb, Scope *scope, AstNode	...	@@ -4694,21 +4661,6 @@ static IrInstruction ir_gen_err_assert_ok(IrBuilder irb, Scope *scope, AstNode
4694	return ir_build_load_ptr(irb, scope, source_node, payload_ptr);	4661	return ir_build_load_ptr(irb, scope, source_node, payload_ptr);
4695	}	4662	}
4696		4663
4697	static IrInstruction ir_gen_maybe_assert_ok(IrBuilder irb, Scope scope, AstNode node, LVal lval) {
4698	assert(node->type == NodeTypePrefixOpExpr);
4699	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
4700
4701	IrInstruction *maybe_ptr = ir_gen_node_extra(irb, expr_node, scope, LVAL_PTR);
4702	if (maybe_ptr == irb->codegen->invalid_instruction)
4703	return irb->codegen->invalid_instruction;
4704
4705	IrInstruction *unwrapped_ptr = ir_build_unwrap_maybe(irb, scope, node, maybe_ptr, true);
4706	if (lval.is_ptr)
4707	return unwrapped_ptr;
4708
4709	return ir_build_load_ptr(irb, scope, node, unwrapped_ptr);
4710	}
4711
4712	static IrInstruction ir_gen_bool_not(IrBuilder irb, Scope scope, AstNode node) {	4664	static IrInstruction ir_gen_bool_not(IrBuilder irb, Scope scope, AstNode node) {
4713	assert(node->type == NodeTypePrefixOpExpr);	4665	assert(node->type == NodeTypePrefixOpExpr);
4714	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;	4666	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
...	@@ -4736,10 +4688,8 @@ static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, Scope *scope, AstNod	...	@@ -4736,10 +4688,8 @@ static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, Scope *scope, AstNod
4736	return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpNegation), lval);	4688	return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpNegation), lval);
4737	case PrefixOpNegationWrap:	4689	case PrefixOpNegationWrap:
4738	return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpNegationWrap), lval);	4690	return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpNegationWrap), lval);
4739	case PrefixOpMaybe:	4691	case PrefixOpOptional:
4740	return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpMaybe), lval);	4692	return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpOptional), lval);
4741	case PrefixOpUnwrapMaybe:
4742	return ir_gen_maybe_assert_ok(irb, scope, node, lval);
4743	case PrefixOpAddrOf: {	4693	case PrefixOpAddrOf: {
4744	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;	4694	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
4745	return ir_lval_wrap(irb, scope, ir_gen_node_extra(irb, expr_node, scope, LVAL_PTR), lval);	4695	return ir_lval_wrap(irb, scope, ir_gen_node_extra(irb, expr_node, scope, LVAL_PTR), lval);
...	@@ -5403,9 +5353,9 @@ static IrInstruction ir_gen_test_expr(IrBuilder irb, Scope scope, AstNode no	...	@@ -5403,9 +5353,9 @@ static IrInstruction ir_gen_test_expr(IrBuilder irb, Scope scope, AstNode no
5403	IrInstruction *maybe_val = ir_build_load_ptr(irb, scope, node, maybe_val_ptr);	5353	IrInstruction *maybe_val = ir_build_load_ptr(irb, scope, node, maybe_val_ptr);
5404	IrInstruction *is_non_null = ir_build_test_nonnull(irb, scope, node, maybe_val);	5354	IrInstruction *is_non_null = ir_build_test_nonnull(irb, scope, node, maybe_val);
5405		5355
5406	IrBasicBlock *then_block = ir_create_basic_block(irb, scope, "MaybeThen");	5356	IrBasicBlock *then_block = ir_create_basic_block(irb, scope, "OptionalThen");
5407	IrBasicBlock *else_block = ir_create_basic_block(irb, scope, "MaybeElse");	5357	IrBasicBlock *else_block = ir_create_basic_block(irb, scope, "OptionalElse");
5408	IrBasicBlock *endif_block = ir_create_basic_block(irb, scope, "MaybeEndIf");	5358	IrBasicBlock *endif_block = ir_create_basic_block(irb, scope, "OptionalEndIf");
5409		5359
5410	IrInstruction *is_comptime;	5360	IrInstruction *is_comptime;
5411	if (ir_should_inline(irb->exec, scope)) {	5361	if (ir_should_inline(irb->exec, scope)) {
...	@@ -6574,7 +6524,6 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop	...	@@ -6574,7 +6524,6 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
6574	return ir_build_load_ptr(irb, scope, node, ptr_instruction);	6524	return ir_build_load_ptr(irb, scope, node, ptr_instruction);
6575	}	6525	}
6576	case NodeTypePtrDeref: {	6526	case NodeTypePtrDeref: {
6577	assert(node->type == NodeTypePtrDeref);
6578	AstNode *expr_node = node->data.ptr_deref_expr.target;	6527	AstNode *expr_node = node->data.ptr_deref_expr.target;
6579	IrInstruction *value = ir_gen_node_extra(irb, expr_node, scope, lval);	6528	IrInstruction *value = ir_gen_node_extra(irb, expr_node, scope, lval);
6580	if (value == irb->codegen->invalid_instruction)	6529	if (value == irb->codegen->invalid_instruction)
...	@@ -6582,6 +6531,19 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop	...	@@ -6582,6 +6531,19 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
6582		6531
6583	return ir_build_un_op(irb, scope, node, IrUnOpDereference, value);	6532	return ir_build_un_op(irb, scope, node, IrUnOpDereference, value);
6584	}	6533	}
		6534	case NodeTypeUnwrapOptional: {
		6535	AstNode *expr_node = node->data.unwrap_optional.expr;
		6536
		6537	IrInstruction *maybe_ptr = ir_gen_node_extra(irb, expr_node, scope, LVAL_PTR);
		6538	if (maybe_ptr == irb->codegen->invalid_instruction)
		6539	return irb->codegen->invalid_instruction;
		6540
		6541	IrInstruction *unwrapped_ptr = ir_build_unwrap_maybe(irb, scope, node, maybe_ptr, true);
		6542	if (lval.is_ptr)
		6543	return unwrapped_ptr;
		6544
		6545	return ir_build_load_ptr(irb, scope, node, unwrapped_ptr);
		6546	}
6585	case NodeTypeThisLiteral:	6547	case NodeTypeThisLiteral:
6586	return ir_lval_wrap(irb, scope, ir_gen_this_literal(irb, scope, node), lval);	6548	return ir_lval_wrap(irb, scope, ir_gen_this_literal(irb, scope, node), lval);
6587	case NodeTypeBoolLiteral:	6549	case NodeTypeBoolLiteral:
...	@@ -7552,7 +7514,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc	...	@@ -7552,7 +7514,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
7552	}	7514	}
7553	} else if (const_val_fits_in_num_lit(const_val, other_type)) {	7515	} else if (const_val_fits_in_num_lit(const_val, other_type)) {
7554	return true;	7516	return true;
7555	} else if (other_type->id == TypeTableEntryIdMaybe) {	7517	} else if (other_type->id == TypeTableEntryIdOptional) {
7556	TypeTableEntry *child_type = other_type->data.maybe.child_type;	7518	TypeTableEntry *child_type = other_type->data.maybe.child_type;
7557	if (const_val_fits_in_num_lit(const_val, child_type)) {	7519	if (const_val_fits_in_num_lit(const_val, child_type)) {
7558	return true;	7520	return true;
...	@@ -7685,27 +7647,44 @@ static TypeTableEntry get_error_set_intersection(IrAnalyze ira, TypeTableEntry	...	@@ -7685,27 +7647,44 @@ static TypeTableEntry get_error_set_intersection(IrAnalyze ira, TypeTableEntry
7685	}	7647	}
7686		7648
7687		7649
7688	static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, TypeTableEntry expected_type,	7650	static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, TypeTableEntry wanted_type,
7689	TypeTableEntry actual_type, AstNode source_node)	7651	TypeTableEntry actual_type, AstNode source_node, bool wanted_is_mutable)
7690	{	7652	{
7691	CodeGen *g = ira->codegen;	7653	CodeGen *g = ira->codegen;
7692	ConstCastOnly result = {};	7654	ConstCastOnly result = {};
7693	result.id = ConstCastResultIdOk;	7655	result.id = ConstCastResultIdOk;
7694		7656
7695	if (expected_type == actual_type)	7657	if (wanted_type == actual_type)
		7658	return result;
		7659
		7660	// * and [] can do a const-cast-only to ? and ?[*], respectively
		7661	// but not if there is a mutable parent pointer
		7662	if (!wanted_is_mutable && wanted_type->id == TypeTableEntryIdOptional &&
		7663	wanted_type->data.maybe.child_type->id == TypeTableEntryIdPointer &&
		7664	actual_type->id == TypeTableEntryIdPointer)
		7665	{
		7666	ConstCastOnly child = types_match_const_cast_only(ira,
		7667	wanted_type->data.maybe.child_type, actual_type, source_node, wanted_is_mutable);
		7668	if (child.id != ConstCastResultIdOk) {
		7669	result.id = ConstCastResultIdNullWrapPtr;
		7670	result.data.null_wrap_ptr_child = allocate_nonzero<ConstCastOnly>(1);
		7671	*result.data.null_wrap_ptr_child = child;
		7672	}
7696	return result;	7673	return result;
		7674	}
7697		7675
7698	// pointer const	7676	// pointer const
7699	if (expected_type->id == TypeTableEntryIdPointer &&	7677	if (wanted_type->id == TypeTableEntryIdPointer &&
7700	actual_type->id == TypeTableEntryIdPointer &&	7678	actual_type->id == TypeTableEntryIdPointer &&
7701	(actual_type->data.pointer.ptr_len == expected_type->data.pointer.ptr_len) &&	7679	(actual_type->data.pointer.ptr_len == wanted_type->data.pointer.ptr_len) &&
7702	(!actual_type->data.pointer.is_const \|\| expected_type->data.pointer.is_const) &&	7680	(!actual_type->data.pointer.is_const \|\| wanted_type->data.pointer.is_const) &&
7703	(!actual_type->data.pointer.is_volatile \|\| expected_type->data.pointer.is_volatile) &&	7681	(!actual_type->data.pointer.is_volatile \|\| wanted_type->data.pointer.is_volatile) &&
7704	actual_type->data.pointer.bit_offset == expected_type->data.pointer.bit_offset &&	7682	actual_type->data.pointer.bit_offset == wanted_type->data.pointer.bit_offset &&
7705	actual_type->data.pointer.unaligned_bit_count == expected_type->data.pointer.unaligned_bit_count &&	7683	actual_type->data.pointer.unaligned_bit_count == wanted_type->data.pointer.unaligned_bit_count &&
7706	actual_type->data.pointer.alignment >= expected_type->data.pointer.alignment)	7684	actual_type->data.pointer.alignment >= wanted_type->data.pointer.alignment)
7707	{	7685	{
7708	ConstCastOnly child = types_match_const_cast_only(ira, expected_type->data.pointer.child_type, actual_type->data.pointer.child_type, source_node);	7686	ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
		7687	actual_type->data.pointer.child_type, source_node, !wanted_type->data.pointer.is_const);
7709	if (child.id != ConstCastResultIdOk) {	7688	if (child.id != ConstCastResultIdOk) {
7710	result.id = ConstCastResultIdPointerChild;	7689	result.id = ConstCastResultIdPointerChild;
7711	result.data.pointer_child = allocate_nonzero<ConstCastOnly>(1);	7690	result.data.pointer_child = allocate_nonzero<ConstCastOnly>(1);
...	@@ -7715,17 +7694,17 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry	...	@@ -7715,17 +7694,17 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
7715	}	7694	}
7716		7695
7717	// slice const	7696	// slice const
7718	if (is_slice(expected_type) && is_slice(actual_type)) {	7697	if (is_slice(wanted_type) && is_slice(actual_type)) {
7719	TypeTableEntry *actual_ptr_type = actual_type->data.structure.fields[slice_ptr_index].type_entry;	7698	TypeTableEntry *actual_ptr_type = actual_type->data.structure.fields[slice_ptr_index].type_entry;
7720	TypeTableEntry *expected_ptr_type = expected_type->data.structure.fields[slice_ptr_index].type_entry;	7699	TypeTableEntry *wanted_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
7721	if ((!actual_ptr_type->data.pointer.is_const \|\| expected_ptr_type->data.pointer.is_const) &&	7700	if ((!actual_ptr_type->data.pointer.is_const \|\| wanted_ptr_type->data.pointer.is_const) &&
7722	(!actual_ptr_type->data.pointer.is_volatile \|\| expected_ptr_type->data.pointer.is_volatile) &&	7701	(!actual_ptr_type->data.pointer.is_volatile \|\| wanted_ptr_type->data.pointer.is_volatile) &&
7723	actual_ptr_type->data.pointer.bit_offset == expected_ptr_type->data.pointer.bit_offset &&	7702	actual_ptr_type->data.pointer.bit_offset == wanted_ptr_type->data.pointer.bit_offset &&
7724	actual_ptr_type->data.pointer.unaligned_bit_count == expected_ptr_type->data.pointer.unaligned_bit_count &&	7703	actual_ptr_type->data.pointer.unaligned_bit_count == wanted_ptr_type->data.pointer.unaligned_bit_count &&
7725	actual_ptr_type->data.pointer.alignment >= expected_ptr_type->data.pointer.alignment)	7704	actual_ptr_type->data.pointer.alignment >= wanted_ptr_type->data.pointer.alignment)
7726	{	7705	{
7727	ConstCastOnly child = types_match_const_cast_only(ira, expected_ptr_type->data.pointer.child_type,	7706	ConstCastOnly child = types_match_const_cast_only(ira, wanted_ptr_type->data.pointer.child_type,
7728	actual_ptr_type->data.pointer.child_type, source_node);	7707	actual_ptr_type->data.pointer.child_type, source_node, !wanted_ptr_type->data.pointer.is_const);
7729	if (child.id != ConstCastResultIdOk) {	7708	if (child.id != ConstCastResultIdOk) {
7730	result.id = ConstCastResultIdSliceChild;	7709	result.id = ConstCastResultIdSliceChild;
7731	result.data.slice_child = allocate_nonzero<ConstCastOnly>(1);	7710	result.data.slice_child = allocate_nonzero<ConstCastOnly>(1);
...	@@ -7736,26 +7715,29 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry	...	@@ -7736,26 +7715,29 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
7736	}	7715	}
7737		7716
7738	// maybe	7717	// maybe
7739	if (expected_type->id == TypeTableEntryIdMaybe && actual_type->id == TypeTableEntryIdMaybe) {	7718	if (wanted_type->id == TypeTableEntryIdOptional && actual_type->id == TypeTableEntryIdOptional) {
7740	ConstCastOnly child = types_match_const_cast_only(ira, expected_type->data.maybe.child_type, actual_type->data.maybe.child_type, source_node);	7719	ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.maybe.child_type,
		7720	actual_type->data.maybe.child_type, source_node, wanted_is_mutable);
7741	if (child.id != ConstCastResultIdOk) {	7721	if (child.id != ConstCastResultIdOk) {
7742	result.id = ConstCastResultIdNullableChild;	7722	result.id = ConstCastResultIdOptionalChild;
7743	result.data.nullable_child = allocate_nonzero<ConstCastOnly>(1);	7723	result.data.optional_child = allocate_nonzero<ConstCastOnly>(1);
7744	*result.data.nullable_child = child;	7724	*result.data.optional_child = child;
7745	}	7725	}
7746	return result;	7726	return result;
7747	}	7727	}
7748		7728
7749	// error union	7729	// error union
7750	if (expected_type->id == TypeTableEntryIdErrorUnion && actual_type->id == TypeTableEntryIdErrorUnion) {	7730	if (wanted_type->id == TypeTableEntryIdErrorUnion && actual_type->id == TypeTableEntryIdErrorUnion) {
7751	ConstCastOnly payload_child = types_match_const_cast_only(ira, expected_type->data.error_union.payload_type, actual_type->data.error_union.payload_type, source_node);	7731	ConstCastOnly payload_child = types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type,
		7732	actual_type->data.error_union.payload_type, source_node, wanted_is_mutable);
7752	if (payload_child.id != ConstCastResultIdOk) {	7733	if (payload_child.id != ConstCastResultIdOk) {
7753	result.id = ConstCastResultIdErrorUnionPayload;	7734	result.id = ConstCastResultIdErrorUnionPayload;
7754	result.data.error_union_payload = allocate_nonzero<ConstCastOnly>(1);	7735	result.data.error_union_payload = allocate_nonzero<ConstCastOnly>(1);
7755	*result.data.error_union_payload = payload_child;	7736	*result.data.error_union_payload = payload_child;
7756	return result;	7737	return result;
7757	}	7738	}
7758	ConstCastOnly error_set_child = types_match_const_cast_only(ira, expected_type->data.error_union.err_set_type, actual_type->data.error_union.err_set_type, source_node);	7739	ConstCastOnly error_set_child = types_match_const_cast_only(ira, wanted_type->data.error_union.err_set_type,
		7740	actual_type->data.error_union.err_set_type, source_node, wanted_is_mutable);
7759	if (error_set_child.id != ConstCastResultIdOk) {	7741	if (error_set_child.id != ConstCastResultIdOk) {
7760	result.id = ConstCastResultIdErrorUnionErrorSet;	7742	result.id = ConstCastResultIdErrorUnionErrorSet;
7761	result.data.error_union_error_set = allocate_nonzero<ConstCastOnly>(1);	7743	result.data.error_union_error_set = allocate_nonzero<ConstCastOnly>(1);
...	@@ -7766,9 +7748,9 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry	...	@@ -7766,9 +7748,9 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
7766	}	7748	}
7767		7749
7768	// error set	7750	// error set
7769	if (expected_type->id == TypeTableEntryIdErrorSet && actual_type->id == TypeTableEntryIdErrorSet) {	7751	if (wanted_type->id == TypeTableEntryIdErrorSet && actual_type->id == TypeTableEntryIdErrorSet) {
7770	TypeTableEntry *contained_set = actual_type;	7752	TypeTableEntry *contained_set = actual_type;
7771	TypeTableEntry *container_set = expected_type;	7753	TypeTableEntry *container_set = wanted_type;
7772		7754
7773	// if the container set is inferred, then this will always work.	7755	// if the container set is inferred, then this will always work.
7774	if (container_set->data.error_set.infer_fn != nullptr) {	7756	if (container_set->data.error_set.infer_fn != nullptr) {
...	@@ -7809,36 +7791,37 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry	...	@@ -7809,36 +7791,37 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
7809	return result;	7791	return result;
7810	}	7792	}
7811		7793
7812	if (expected_type == ira->codegen->builtin_types.entry_promise &&	7794	if (wanted_type == ira->codegen->builtin_types.entry_promise &&
7813	actual_type->id == TypeTableEntryIdPromise)	7795	actual_type->id == TypeTableEntryIdPromise)
7814	{	7796	{
7815	return result;	7797	return result;
7816	}	7798	}
7817		7799
7818	// fn	7800	// fn
7819	if (expected_type->id == TypeTableEntryIdFn &&	7801	if (wanted_type->id == TypeTableEntryIdFn &&
7820	actual_type->id == TypeTableEntryIdFn)	7802	actual_type->id == TypeTableEntryIdFn)
7821	{	7803	{
7822	if (expected_type->data.fn.fn_type_id.alignment > actual_type->data.fn.fn_type_id.alignment) {	7804	if (wanted_type->data.fn.fn_type_id.alignment > actual_type->data.fn.fn_type_id.alignment) {
7823	result.id = ConstCastResultIdFnAlign;	7805	result.id = ConstCastResultIdFnAlign;
7824	return result;	7806	return result;
7825	}	7807	}
7826	if (expected_type->data.fn.fn_type_id.cc != actual_type->data.fn.fn_type_id.cc) {	7808	if (wanted_type->data.fn.fn_type_id.cc != actual_type->data.fn.fn_type_id.cc) {
7827	result.id = ConstCastResultIdFnCC;	7809	result.id = ConstCastResultIdFnCC;
7828	return result;	7810	return result;
7829	}	7811	}
7830	if (expected_type->data.fn.fn_type_id.is_var_args != actual_type->data.fn.fn_type_id.is_var_args) {	7812	if (wanted_type->data.fn.fn_type_id.is_var_args != actual_type->data.fn.fn_type_id.is_var_args) {
7831	result.id = ConstCastResultIdFnVarArgs;	7813	result.id = ConstCastResultIdFnVarArgs;
7832	return result;	7814	return result;
7833	}	7815	}
7834	if (expected_type->data.fn.is_generic != actual_type->data.fn.is_generic) {	7816	if (wanted_type->data.fn.is_generic != actual_type->data.fn.is_generic) {
7835	result.id = ConstCastResultIdFnIsGeneric;	7817	result.id = ConstCastResultIdFnIsGeneric;
7836	return result;	7818	return result;
7837	}	7819	}
7838	if (!expected_type->data.fn.is_generic &&	7820	if (!wanted_type->data.fn.is_generic &&
7839	actual_type->data.fn.fn_type_id.return_type->id != TypeTableEntryIdUnreachable)	7821	actual_type->data.fn.fn_type_id.return_type->id != TypeTableEntryIdUnreachable)
7840	{	7822	{
7841	ConstCastOnly child = types_match_const_cast_only(ira, expected_type->data.fn.fn_type_id.return_type, actual_type->data.fn.fn_type_id.return_type, source_node);	7823	ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.fn.fn_type_id.return_type,
		7824	actual_type->data.fn.fn_type_id.return_type, source_node, false);
7842	if (child.id != ConstCastResultIdOk) {	7825	if (child.id != ConstCastResultIdOk) {
7843	result.id = ConstCastResultIdFnReturnType;	7826	result.id = ConstCastResultIdFnReturnType;
7844	result.data.return_type = allocate_nonzero<ConstCastOnly>(1);	7827	result.data.return_type = allocate_nonzero<ConstCastOnly>(1);
...	@@ -7846,9 +7829,11 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry	...	@@ -7846,9 +7829,11 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
7846	return result;	7829	return result;
7847	}	7830	}
7848	}	7831	}
7849	if (!expected_type->data.fn.is_generic && expected_type->data.fn.fn_type_id.cc == CallingConventionAsync) {	7832	if (!wanted_type->data.fn.is_generic && wanted_type->data.fn.fn_type_id.cc == CallingConventionAsync) {
7850	ConstCastOnly child = types_match_const_cast_only(ira, actual_type->data.fn.fn_type_id.async_allocator_type,	7833	ConstCastOnly child = types_match_const_cast_only(ira,
7851	expected_type->data.fn.fn_type_id.async_allocator_type, source_node);	7834	actual_type->data.fn.fn_type_id.async_allocator_type,
		7835	wanted_type->data.fn.fn_type_id.async_allocator_type,
		7836	source_node, false);
7852	if (child.id != ConstCastResultIdOk) {	7837	if (child.id != ConstCastResultIdOk) {
7853	result.id = ConstCastResultIdAsyncAllocatorType;	7838	result.id = ConstCastResultIdAsyncAllocatorType;
7854	result.data.async_allocator_type = allocate_nonzero<ConstCastOnly>(1);	7839	result.data.async_allocator_type = allocate_nonzero<ConstCastOnly>(1);
...	@@ -7856,22 +7841,23 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry	...	@@ -7856,22 +7841,23 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, TypeTableEntry
7856	return result;	7841	return result;
7857	}	7842	}
7858	}	7843	}
7859	if (expected_type->data.fn.fn_type_id.param_count != actual_type->data.fn.fn_type_id.param_count) {	7844	if (wanted_type->data.fn.fn_type_id.param_count != actual_type->data.fn.fn_type_id.param_count) {
7860	result.id = ConstCastResultIdFnArgCount;	7845	result.id = ConstCastResultIdFnArgCount;
7861	return result;	7846	return result;
7862	}	7847	}
7863	if (expected_type->data.fn.fn_type_id.next_param_index != actual_type->data.fn.fn_type_id.next_param_index) {	7848	if (wanted_type->data.fn.fn_type_id.next_param_index != actual_type->data.fn.fn_type_id.next_param_index) {
7864	result.id = ConstCastResultIdFnGenericArgCount;	7849	result.id = ConstCastResultIdFnGenericArgCount;
7865	return result;	7850	return result;
7866	}	7851	}
7867	assert(expected_type->data.fn.is_generic \|\|	7852	assert(wanted_type->data.fn.is_generic \|\|
7868	expected_type->data.fn.fn_type_id.next_param_index == expected_type->data.fn.fn_type_id.param_count);	7853	wanted_type->data.fn.fn_type_id.next_param_index == wanted_type->data.fn.fn_type_id.param_count);
7869	for (size_t i = 0; i < expected_type->data.fn.fn_type_id.next_param_index; i += 1) {	7854	for (size_t i = 0; i < wanted_type->data.fn.fn_type_id.next_param_index; i += 1) {
7870	// note it's reversed for parameters	7855	// note it's reversed for parameters
7871	FnTypeParamInfo *actual_param_info = &actual_type->data.fn.fn_type_id.param_info[i];	7856	FnTypeParamInfo *actual_param_info = &actual_type->data.fn.fn_type_id.param_info[i];
7872	FnTypeParamInfo *expected_param_info = &expected_type->data.fn.fn_type_id.param_info[i];	7857	FnTypeParamInfo *expected_param_info = &wanted_type->data.fn.fn_type_id.param_info[i];
7873		7858
7874	ConstCastOnly arg_child = types_match_const_cast_only(ira, actual_param_info->type, expected_param_info->type, source_node);	7859	ConstCastOnly arg_child = types_match_const_cast_only(ira, actual_param_info->type,
		7860	expected_param_info->type, source_node, false);
7875	if (arg_child.id != ConstCastResultIdOk) {	7861	if (arg_child.id != ConstCastResultIdOk) {
7876	result.id = ConstCastResultIdFnArg;	7862	result.id = ConstCastResultIdFnArg;
7877	result.data.fn_arg.arg_index = i;	7863	result.data.fn_arg.arg_index = i;
...	@@ -7899,11 +7885,12 @@ enum ImplicitCastMatchResult {	...	@@ -7899,11 +7885,12 @@ enum ImplicitCastMatchResult {
7899	ImplicitCastMatchResultReportedError,	7885	ImplicitCastMatchResultReportedError,
7900	};	7886	};
7901		7887
7902	static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze ira, TypeTableEntry expected_type,	7888	static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze ira, TypeTableEntry wanted_type,
7903	TypeTableEntry actual_type, IrInstruction value)	7889	TypeTableEntry actual_type, IrInstruction value)
7904	{	7890	{
7905	AstNode *source_node = value->source_node;	7891	AstNode *source_node = value->source_node;
7906	ConstCastOnly const_cast_result = types_match_const_cast_only(ira, expected_type, actual_type, source_node);	7892	ConstCastOnly const_cast_result = types_match_const_cast_only(ira, wanted_type, actual_type,
		7893	source_node, false);
7907	if (const_cast_result.id == ConstCastResultIdOk) {	7894	if (const_cast_result.id == ConstCastResultIdOk) {
7908	return ImplicitCastMatchResultYes;	7895	return ImplicitCastMatchResultYes;
7909	}	7896	}
...	@@ -7918,21 +7905,21 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,	...	@@ -7918,21 +7905,21 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
7918	missing_errors = &const_cast_result.data.error_union_error_set->data.error_set.missing_errors;	7905	missing_errors = &const_cast_result.data.error_union_error_set->data.error_set.missing_errors;
7919	} else if (const_cast_result.data.error_union_error_set->id == ConstCastResultIdErrSetGlobal) {	7906	} else if (const_cast_result.data.error_union_error_set->id == ConstCastResultIdErrSetGlobal) {
7920	ErrorMsg *msg = ir_add_error(ira, value,	7907	ErrorMsg *msg = ir_add_error(ira, value,
7921	buf_sprintf("expected '%s', found '%s'", buf_ptr(&expected_type->name), buf_ptr(&actual_type->name)));	7908	buf_sprintf("expected '%s', found '%s'", buf_ptr(&wanted_type->name), buf_ptr(&actual_type->name)));
7922	add_error_note(ira->codegen, msg, value->source_node,	7909	add_error_note(ira->codegen, msg, value->source_node,
7923	buf_sprintf("unable to cast global error set into smaller set"));	7910	buf_sprintf("unable to cast global error set into smaller set"));
7924	return ImplicitCastMatchResultReportedError;	7911	return ImplicitCastMatchResultReportedError;
7925	}	7912	}
7926	} else if (const_cast_result.id == ConstCastResultIdErrSetGlobal) {	7913	} else if (const_cast_result.id == ConstCastResultIdErrSetGlobal) {
7927	ErrorMsg *msg = ir_add_error(ira, value,	7914	ErrorMsg *msg = ir_add_error(ira, value,
7928	buf_sprintf("expected '%s', found '%s'", buf_ptr(&expected_type->name), buf_ptr(&actual_type->name)));	7915	buf_sprintf("expected '%s', found '%s'", buf_ptr(&wanted_type->name), buf_ptr(&actual_type->name)));
7929	add_error_note(ira->codegen, msg, value->source_node,	7916	add_error_note(ira->codegen, msg, value->source_node,
7930	buf_sprintf("unable to cast global error set into smaller set"));	7917	buf_sprintf("unable to cast global error set into smaller set"));
7931	return ImplicitCastMatchResultReportedError;	7918	return ImplicitCastMatchResultReportedError;
7932	}	7919	}
7933	if (missing_errors != nullptr) {	7920	if (missing_errors != nullptr) {
7934	ErrorMsg *msg = ir_add_error(ira, value,	7921	ErrorMsg *msg = ir_add_error(ira, value,
7935	buf_sprintf("expected '%s', found '%s'", buf_ptr(&expected_type->name), buf_ptr(&actual_type->name)));	7922	buf_sprintf("expected '%s', found '%s'", buf_ptr(&wanted_type->name), buf_ptr(&actual_type->name)));
7936	for (size_t i = 0; i < missing_errors->length; i += 1) {	7923	for (size_t i = 0; i < missing_errors->length; i += 1) {
7937	ErrorTableEntry *error_entry = missing_errors->at(i);	7924	ErrorTableEntry *error_entry = missing_errors->at(i);
7938	add_error_note(ira->codegen, msg, error_entry->decl_node,	7925	add_error_note(ira->codegen, msg, error_entry->decl_node,
...	@@ -7943,133 +7930,168 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,	...	@@ -7943,133 +7930,168 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
7943	}	7930	}
7944		7931
7945	// implicit conversion from ?T to ?U	7932	// implicit conversion from ?T to ?U
7946	if (expected_type->id == TypeTableEntryIdMaybe && actual_type->id == TypeTableEntryIdMaybe) {	7933	if (wanted_type->id == TypeTableEntryIdOptional && actual_type->id == TypeTableEntryIdOptional) {
7947	ImplicitCastMatchResult res = ir_types_match_with_implicit_cast(ira, expected_type->data.maybe.child_type,	7934	ImplicitCastMatchResult res = ir_types_match_with_implicit_cast(ira, wanted_type->data.maybe.child_type,
7948	actual_type->data.maybe.child_type, value);	7935	actual_type->data.maybe.child_type, value);
7949	if (res != ImplicitCastMatchResultNo)	7936	if (res != ImplicitCastMatchResultNo)
7950	return res;	7937	return res;
7951	}	7938	}
7952		7939
7953	// implicit conversion from non maybe type to maybe type	7940	// implicit conversion from non maybe type to maybe type
7954	if (expected_type->id == TypeTableEntryIdMaybe) {	7941	if (wanted_type->id == TypeTableEntryIdOptional) {
7955	ImplicitCastMatchResult res = ir_types_match_with_implicit_cast(ira, expected_type->data.maybe.child_type,	7942	ImplicitCastMatchResult res = ir_types_match_with_implicit_cast(ira, wanted_type->data.maybe.child_type,
7956	actual_type, value);	7943	actual_type, value);
7957	if (res != ImplicitCastMatchResultNo)	7944	if (res != ImplicitCastMatchResultNo)
7958	return res;	7945	return res;
7959	}	7946	}
7960		7947
7961	// implicit conversion from null literal to maybe type	7948	// implicit conversion from null literal to maybe type
7962	if (expected_type->id == TypeTableEntryIdMaybe &&	7949	if (wanted_type->id == TypeTableEntryIdOptional &&
7963	actual_type->id == TypeTableEntryIdNull)	7950	actual_type->id == TypeTableEntryIdNull)
7964	{	7951	{
7965	return ImplicitCastMatchResultYes;	7952	return ImplicitCastMatchResultYes;
7966	}	7953	}
7967		7954
7968	// implicit T to U!T	7955	// implicit T to U!T
7969	if (expected_type->id == TypeTableEntryIdErrorUnion &&	7956	if (wanted_type->id == TypeTableEntryIdErrorUnion &&
7970	ir_types_match_with_implicit_cast(ira, expected_type->data.error_union.payload_type, actual_type, value))	7957	ir_types_match_with_implicit_cast(ira, wanted_type->data.error_union.payload_type, actual_type, value))
7971	{	7958	{
7972	return ImplicitCastMatchResultYes;	7959	return ImplicitCastMatchResultYes;
7973	}	7960	}
7974		7961
7975	// implicit conversion from error set to error union type	7962	// implicit conversion from error set to error union type
7976	if (expected_type->id == TypeTableEntryIdErrorUnion &&	7963	if (wanted_type->id == TypeTableEntryIdErrorUnion &&
7977	actual_type->id == TypeTableEntryIdErrorSet)	7964	actual_type->id == TypeTableEntryIdErrorSet)
7978	{	7965	{
7979	return ImplicitCastMatchResultYes;	7966	return ImplicitCastMatchResultYes;
7980	}	7967	}
7981		7968
7982	// implicit conversion from T to U!?T	7969	// implicit conversion from T to U!?T
7983	if (expected_type->id == TypeTableEntryIdErrorUnion &&	7970	if (wanted_type->id == TypeTableEntryIdErrorUnion &&
7984	expected_type->data.error_union.payload_type->id == TypeTableEntryIdMaybe &&	7971	wanted_type->data.error_union.payload_type->id == TypeTableEntryIdOptional &&
7985	ir_types_match_with_implicit_cast(ira,	7972	ir_types_match_with_implicit_cast(ira,
7986	expected_type->data.error_union.payload_type->data.maybe.child_type,	7973	wanted_type->data.error_union.payload_type->data.maybe.child_type,
7987	actual_type, value))	7974	actual_type, value))
7988	{	7975	{
7989	return ImplicitCastMatchResultYes;	7976	return ImplicitCastMatchResultYes;
7990	}	7977	}
7991		7978
7992	// implicit widening conversion	7979	// implicit widening conversion
7993	if (expected_type->id == TypeTableEntryIdInt &&	7980	if (wanted_type->id == TypeTableEntryIdInt &&
7994	actual_type->id == TypeTableEntryIdInt &&	7981	actual_type->id == TypeTableEntryIdInt &&
7995	expected_type->data.integral.is_signed == actual_type->data.integral.is_signed &&	7982	wanted_type->data.integral.is_signed == actual_type->data.integral.is_signed &&
7996	expected_type->data.integral.bit_count >= actual_type->data.integral.bit_count)	7983	wanted_type->data.integral.bit_count >= actual_type->data.integral.bit_count)
7997	{	7984	{
7998	return ImplicitCastMatchResultYes;	7985	return ImplicitCastMatchResultYes;
7999	}	7986	}
8000		7987
8001	// small enough unsigned ints can get casted to large enough signed ints	7988	// small enough unsigned ints can get casted to large enough signed ints
8002	if (expected_type->id == TypeTableEntryIdInt && expected_type->data.integral.is_signed &&	7989	if (wanted_type->id == TypeTableEntryIdInt && wanted_type->data.integral.is_signed &&
8003	actual_type->id == TypeTableEntryIdInt && !actual_type->data.integral.is_signed &&	7990	actual_type->id == TypeTableEntryIdInt && !actual_type->data.integral.is_signed &&
8004	expected_type->data.integral.bit_count > actual_type->data.integral.bit_count)	7991	wanted_type->data.integral.bit_count > actual_type->data.integral.bit_count)
8005	{	7992	{
8006	return ImplicitCastMatchResultYes;	7993	return ImplicitCastMatchResultYes;
8007	}	7994	}
8008		7995
8009	// implicit float widening conversion	7996	// implicit float widening conversion
8010	if (expected_type->id == TypeTableEntryIdFloat &&	7997	if (wanted_type->id == TypeTableEntryIdFloat &&
8011	actual_type->id == TypeTableEntryIdFloat &&	7998	actual_type->id == TypeTableEntryIdFloat &&
8012	expected_type->data.floating.bit_count >= actual_type->data.floating.bit_count)	7999	wanted_type->data.floating.bit_count >= actual_type->data.floating.bit_count)
8013	{	8000	{
8014	return ImplicitCastMatchResultYes;	8001	return ImplicitCastMatchResultYes;
8015	}	8002	}
8016		8003
8017	// implicit [N]T to []const T	8004	// implicit [N]T to []const T
8018	if (is_slice(expected_type) && actual_type->id == TypeTableEntryIdArray) {	8005	if (is_slice(wanted_type) && actual_type->id == TypeTableEntryIdArray) {
8019	TypeTableEntry *ptr_type = expected_type->data.structure.fields[slice_ptr_index].type_entry;	8006	TypeTableEntry *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
8020	assert(ptr_type->id == TypeTableEntryIdPointer);	8007	assert(ptr_type->id == TypeTableEntryIdPointer);
8021		8008
8022	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&	8009	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
8023	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8010	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
		8011	source_node, false).id == ConstCastResultIdOk)
8024	{	8012	{
8025	return ImplicitCastMatchResultYes;	8013	return ImplicitCastMatchResultYes;
8026	}	8014	}
8027	}	8015	}
8028		8016
8029	// implicit &const [N]T to []const T	8017	// implicit &const [N]T to []const T
8030	if (is_slice(expected_type) &&	8018	if (is_slice(wanted_type) &&
8031	actual_type->id == TypeTableEntryIdPointer &&	8019	actual_type->id == TypeTableEntryIdPointer &&
		8020	actual_type->data.pointer.ptr_len == PtrLenSingle &&
8032	actual_type->data.pointer.is_const &&	8021	actual_type->data.pointer.is_const &&
8033	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)	8022	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)
8034	{	8023	{
8035	TypeTableEntry *ptr_type = expected_type->data.structure.fields[slice_ptr_index].type_entry;	8024	TypeTableEntry *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
8036	assert(ptr_type->id == TypeTableEntryIdPointer);	8025	assert(ptr_type->id == TypeTableEntryIdPointer);
8037		8026
8038	TypeTableEntry *array_type = actual_type->data.pointer.child_type;	8027	TypeTableEntry *array_type = actual_type->data.pointer.child_type;
8039		8028
8040	if ((ptr_type->data.pointer.is_const \|\| array_type->data.array.len == 0) &&	8029	if ((ptr_type->data.pointer.is_const \|\| array_type->data.array.len == 0) &&
8041	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, array_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8030	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, array_type->data.array.child_type,
		8031	source_node, false).id == ConstCastResultIdOk)
8042	{	8032	{
8043	return ImplicitCastMatchResultYes;	8033	return ImplicitCastMatchResultYes;
8044	}	8034	}
8045	}	8035	}
8046		8036
8047	// implicit [N]T to &const []const T	8037	// implicit [N]T to &const []const T
8048	if (expected_type->id == TypeTableEntryIdPointer &&	8038	if (wanted_type->id == TypeTableEntryIdPointer &&
8049	expected_type->data.pointer.is_const &&	8039	wanted_type->data.pointer.is_const &&
8050	is_slice(expected_type->data.pointer.child_type) &&	8040	wanted_type->data.pointer.ptr_len == PtrLenSingle &&
		8041	is_slice(wanted_type->data.pointer.child_type) &&
8051	actual_type->id == TypeTableEntryIdArray)	8042	actual_type->id == TypeTableEntryIdArray)
8052	{	8043	{
8053	TypeTableEntry *ptr_type =	8044	TypeTableEntry *ptr_type =
8054	expected_type->data.pointer.child_type->data.structure.fields[slice_ptr_index].type_entry;	8045	wanted_type->data.pointer.child_type->data.structure.fields[slice_ptr_index].type_entry;
8055	assert(ptr_type->id == TypeTableEntryIdPointer);	8046	assert(ptr_type->id == TypeTableEntryIdPointer);
8056	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&	8047	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
8057	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8048	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type,
		8049	actual_type->data.array.child_type, source_node, false).id == ConstCastResultIdOk)
		8050	{
		8051	return ImplicitCastMatchResultYes;
		8052	}
		8053	}
		8054
		8055	// implicit [N]T to []T
		8056	if (wanted_type->id == TypeTableEntryIdPointer &&
		8057	wanted_type->data.pointer.ptr_len == PtrLenUnknown &&
		8058	actual_type->id == TypeTableEntryIdPointer &&
		8059	actual_type->data.pointer.ptr_len == PtrLenSingle &&
		8060	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray &&
		8061	types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
		8062	actual_type->data.pointer.child_type->data.array.child_type, source_node,
		8063	!wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
		8064	{
		8065	return ImplicitCastMatchResultYes;
		8066	}
		8067
		8068	// implicit *[N]T to []T
		8069	if (is_slice(wanted_type) &&
		8070	actual_type->id == TypeTableEntryIdPointer &&
		8071	actual_type->data.pointer.ptr_len == PtrLenSingle &&
		8072	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)
		8073	{
		8074	TypeTableEntry *slice_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
		8075	assert(slice_ptr_type->id == TypeTableEntryIdPointer);
		8076	if (types_match_const_cast_only(ira, slice_ptr_type->data.pointer.child_type,
		8077	actual_type->data.pointer.child_type->data.array.child_type, source_node,
		8078	!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
8058	{	8079	{
8059	return ImplicitCastMatchResultYes;	8080	return ImplicitCastMatchResultYes;
8060	}	8081	}
8061	}	8082	}
8062		8083
8063	// implicit [N]T to ?[]const T	8084	// implicit [N]T to ?[]const T
8064	if (expected_type->id == TypeTableEntryIdMaybe &&	8085	if (wanted_type->id == TypeTableEntryIdOptional &&
8065	is_slice(expected_type->data.maybe.child_type) &&	8086	is_slice(wanted_type->data.maybe.child_type) &&
8066	actual_type->id == TypeTableEntryIdArray)	8087	actual_type->id == TypeTableEntryIdArray)
8067	{	8088	{
8068	TypeTableEntry *ptr_type =	8089	TypeTableEntry *ptr_type =
8069	expected_type->data.maybe.child_type->data.structure.fields[slice_ptr_index].type_entry;	8090	wanted_type->data.maybe.child_type->data.structure.fields[slice_ptr_index].type_entry;
8070	assert(ptr_type->id == TypeTableEntryIdPointer);	8091	assert(ptr_type->id == TypeTableEntryIdPointer);
8071	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&	8092	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
8072	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8093	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type,
		8094	actual_type->data.array.child_type, source_node, false).id == ConstCastResultIdOk)
8073	{	8095	{
8074	return ImplicitCastMatchResultYes;	8096	return ImplicitCastMatchResultYes;
8075	}	8097	}
...	@@ -8081,15 +8103,16 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,	...	@@ -8081,15 +8103,16 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
8081	if (actual_type->id == TypeTableEntryIdComptimeFloat \|\|	8103	if (actual_type->id == TypeTableEntryIdComptimeFloat \|\|
8082	actual_type->id == TypeTableEntryIdComptimeInt)	8104	actual_type->id == TypeTableEntryIdComptimeInt)
8083	{	8105	{
8084	if (expected_type->id == TypeTableEntryIdPointer &&	8106	if (wanted_type->id == TypeTableEntryIdPointer &&
8085	expected_type->data.pointer.is_const)	8107	wanted_type->data.pointer.ptr_len == PtrLenSingle &&
		8108	wanted_type->data.pointer.is_const)
8086	{	8109	{
8087	if (ir_num_lit_fits_in_other_type(ira, value, expected_type->data.pointer.child_type, false)) {	8110	if (ir_num_lit_fits_in_other_type(ira, value, wanted_type->data.pointer.child_type, false)) {
8088	return ImplicitCastMatchResultYes;	8111	return ImplicitCastMatchResultYes;
8089	} else {	8112	} else {
8090	return ImplicitCastMatchResultReportedError;	8113	return ImplicitCastMatchResultReportedError;
8091	}	8114	}
8092	} else if (ir_num_lit_fits_in_other_type(ira, value, expected_type, false)) {	8115	} else if (ir_num_lit_fits_in_other_type(ira, value, wanted_type, false)) {
8093	return ImplicitCastMatchResultYes;	8116	return ImplicitCastMatchResultYes;
8094	} else {	8117	} else {
8095	return ImplicitCastMatchResultReportedError;	8118	return ImplicitCastMatchResultReportedError;
...	@@ -8099,38 +8122,41 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,	...	@@ -8099,38 +8122,41 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
8099	// implicit typed number to integer or float literal.	8122	// implicit typed number to integer or float literal.
8100	// works when the number is known	8123	// works when the number is known
8101	if (value->value.special == ConstValSpecialStatic) {	8124	if (value->value.special == ConstValSpecialStatic) {
8102	if (actual_type->id == TypeTableEntryIdInt && expected_type->id == TypeTableEntryIdComptimeInt) {	8125	if (actual_type->id == TypeTableEntryIdInt && wanted_type->id == TypeTableEntryIdComptimeInt) {
8103	return ImplicitCastMatchResultYes;	8126	return ImplicitCastMatchResultYes;
8104	} else if (actual_type->id == TypeTableEntryIdFloat && expected_type->id == TypeTableEntryIdComptimeFloat) {	8127	} else if (actual_type->id == TypeTableEntryIdFloat && wanted_type->id == TypeTableEntryIdComptimeFloat) {
8105	return ImplicitCastMatchResultYes;	8128	return ImplicitCastMatchResultYes;
8106	}	8129	}
8107	}	8130	}
8108		8131
8109	// implicit union to its enum tag type	8132	// implicit union to its enum tag type
8110	if (expected_type->id == TypeTableEntryIdEnum && actual_type->id == TypeTableEntryIdUnion &&	8133	if (wanted_type->id == TypeTableEntryIdEnum && actual_type->id == TypeTableEntryIdUnion &&
8111	(actual_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|	8134	(actual_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|
8112	actual_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))	8135	actual_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
8113	{	8136	{
8114	type_ensure_zero_bits_known(ira->codegen, actual_type);	8137	type_ensure_zero_bits_known(ira->codegen, actual_type);
8115	if (actual_type->data.unionation.tag_type == expected_type) {	8138	if (actual_type->data.unionation.tag_type == wanted_type) {
8116	return ImplicitCastMatchResultYes;	8139	return ImplicitCastMatchResultYes;
8117	}	8140	}
8118	}	8141	}
8119		8142
8120	// implicit enum to union which has the enum as the tag type	8143	// implicit enum to union which has the enum as the tag type
8121	if (expected_type->id == TypeTableEntryIdUnion && actual_type->id == TypeTableEntryIdEnum &&	8144	if (wanted_type->id == TypeTableEntryIdUnion && actual_type->id == TypeTableEntryIdEnum &&
8122	(expected_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|	8145	(wanted_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|
8123	expected_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))	8146	wanted_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
8124	{	8147	{
8125	type_ensure_zero_bits_known(ira->codegen, expected_type);	8148	type_ensure_zero_bits_known(ira->codegen, wanted_type);
8126	if (expected_type->data.unionation.tag_type == actual_type) {	8149	if (wanted_type->data.unionation.tag_type == actual_type) {
8127	return ImplicitCastMatchResultYes;	8150	return ImplicitCastMatchResultYes;
8128	}	8151	}
8129	}	8152	}
8130		8153
8131	// implicit enum to &const union which has the enum as the tag type	8154	// implicit enum to &const union which has the enum as the tag type
8132	if (actual_type->id == TypeTableEntryIdEnum && expected_type->id == TypeTableEntryIdPointer) {	8155	if (actual_type->id == TypeTableEntryIdEnum &&
8133	TypeTableEntry *union_type = expected_type->data.pointer.child_type;	8156	wanted_type->id == TypeTableEntryIdPointer &&
		8157	wanted_type->data.pointer.ptr_len == PtrLenSingle)
		8158	{
		8159	TypeTableEntry *union_type = wanted_type->data.pointer.child_type;
8134	if (union_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|	8160	if (union_type->data.unionation.decl_node->data.container_decl.auto_enum \|\|
8135	union_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr)	8161	union_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr)
8136	{	8162	{
...	@@ -8141,6 +8167,17 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,	...	@@ -8141,6 +8167,17 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
8141	}	8167	}
8142	}	8168	}
8143		8169
		8170	// implicit T to *T where T is zero bits
		8171	if (wanted_type->id == TypeTableEntryIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
		8172	types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
		8173	actual_type, source_node, false).id == ConstCastResultIdOk)
		8174	{
		8175	type_ensure_zero_bits_known(ira->codegen, actual_type);
		8176	if (!type_has_bits(actual_type)) {
		8177	return ImplicitCastMatchResultYes;
		8178	}
		8179	}
		8180
8144	// implicit undefined literal to anything	8181	// implicit undefined literal to anything
8145	if (actual_type->id == TypeTableEntryIdUndefined) {	8182	if (actual_type->id == TypeTableEntryIdUndefined) {
8146	return ImplicitCastMatchResultYes;	8183	return ImplicitCastMatchResultYes;
...	@@ -8149,7 +8186,11 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,	...	@@ -8149,7 +8186,11 @@ static ImplicitCastMatchResult ir_types_match_with_implicit_cast(IrAnalyze *ira,
8149	// implicitly take a const pointer to something	8186	// implicitly take a const pointer to something
8150	if (!type_requires_comptime(actual_type)) {	8187	if (!type_requires_comptime(actual_type)) {
8151	TypeTableEntry *const_ptr_actual = get_pointer_to_type(ira->codegen, actual_type, true);	8188	TypeTableEntry *const_ptr_actual = get_pointer_to_type(ira->codegen, actual_type, true);
8152	if (types_match_const_cast_only(ira, expected_type, const_ptr_actual, source_node).id == ConstCastResultIdOk) {	8189	if (wanted_type->id == TypeTableEntryIdPointer &&
		8190	wanted_type->data.pointer.ptr_len == PtrLenSingle &&
		8191	types_match_const_cast_only(ira, wanted_type, const_ptr_actual,
		8192	source_node, false).id == ConstCastResultIdOk)
		8193	{
8153	return ImplicitCastMatchResultYes;	8194	return ImplicitCastMatchResultYes;
8154	}	8195	}
8155	}	8196	}
...	@@ -8390,9 +8431,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8390,9 +8431,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8390	TypeTableEntry *cur_payload_type = cur_type->data.error_union.payload_type;	8431	TypeTableEntry *cur_payload_type = cur_type->data.error_union.payload_type;
8391		8432
8392	bool const_cast_prev = types_match_const_cast_only(ira, prev_payload_type, cur_payload_type,	8433	bool const_cast_prev = types_match_const_cast_only(ira, prev_payload_type, cur_payload_type,
8393	source_node).id == ConstCastResultIdOk;	8434	source_node, false).id == ConstCastResultIdOk;
8394	bool const_cast_cur = types_match_const_cast_only(ira, cur_payload_type, prev_payload_type,	8435	bool const_cast_cur = types_match_const_cast_only(ira, cur_payload_type, prev_payload_type,
8395	source_node).id == ConstCastResultIdOk;	8436	source_node, false).id == ConstCastResultIdOk;
8396		8437
8397	if (const_cast_prev \|\| const_cast_cur) {	8438	if (const_cast_prev \|\| const_cast_cur) {
8398	if (const_cast_cur) {	8439	if (const_cast_cur) {
...	@@ -8479,11 +8520,11 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8479,11 +8520,11 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8479	continue;	8520	continue;
8480	}	8521	}
8481		8522
8482	if (types_match_const_cast_only(ira, prev_type, cur_type, source_node).id == ConstCastResultIdOk) {	8523	if (types_match_const_cast_only(ira, prev_type, cur_type, source_node, false).id == ConstCastResultIdOk) {
8483	continue;	8524	continue;
8484	}	8525	}
8485		8526
8486	if (types_match_const_cast_only(ira, cur_type, prev_type, source_node).id == ConstCastResultIdOk) {	8527	if (types_match_const_cast_only(ira, cur_type, prev_type, source_node, false).id == ConstCastResultIdOk) {
8487	prev_inst = cur_inst;	8528	prev_inst = cur_inst;
8488	continue;	8529	continue;
8489	}	8530	}
...	@@ -8506,13 +8547,15 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8506,13 +8547,15 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8506	}	8547	}
8507		8548
8508	if (prev_type->id == TypeTableEntryIdErrorUnion &&	8549	if (prev_type->id == TypeTableEntryIdErrorUnion &&
8509	types_match_const_cast_only(ira, prev_type->data.error_union.payload_type, cur_type, source_node).id == ConstCastResultIdOk)	8550	types_match_const_cast_only(ira, prev_type->data.error_union.payload_type, cur_type,
		8551	source_node, false).id == ConstCastResultIdOk)
8510	{	8552	{
8511	continue;	8553	continue;
8512	}	8554	}
8513		8555
8514	if (cur_type->id == TypeTableEntryIdErrorUnion &&	8556	if (cur_type->id == TypeTableEntryIdErrorUnion &&
8515	types_match_const_cast_only(ira, cur_type->data.error_union.payload_type, prev_type, source_node).id == ConstCastResultIdOk)	8557	types_match_const_cast_only(ira, cur_type->data.error_union.payload_type, prev_type,
		8558	source_node, false).id == ConstCastResultIdOk)
8516	{	8559	{
8517	if (err_set_type != nullptr) {	8560	if (err_set_type != nullptr) {
8518	TypeTableEntry *cur_err_set_type = cur_type->data.error_union.err_set_type;	8561	TypeTableEntry *cur_err_set_type = cur_type->data.error_union.err_set_type;
...	@@ -8533,14 +8576,16 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8533,14 +8576,16 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8533	continue;	8576	continue;
8534	}	8577	}
8535		8578
8536	if (prev_type->id == TypeTableEntryIdMaybe &&	8579	if (prev_type->id == TypeTableEntryIdOptional &&
8537	types_match_const_cast_only(ira, prev_type->data.maybe.child_type, cur_type, source_node).id == ConstCastResultIdOk)	8580	types_match_const_cast_only(ira, prev_type->data.maybe.child_type, cur_type,
		8581	source_node, false).id == ConstCastResultIdOk)
8538	{	8582	{
8539	continue;	8583	continue;
8540	}	8584	}
8541		8585
8542	if (cur_type->id == TypeTableEntryIdMaybe &&	8586	if (cur_type->id == TypeTableEntryIdOptional &&
8543	types_match_const_cast_only(ira, cur_type->data.maybe.child_type, prev_type, source_node).id == ConstCastResultIdOk)	8587	types_match_const_cast_only(ira, cur_type->data.maybe.child_type, prev_type,
		8588	source_node, false).id == ConstCastResultIdOk)
8544	{	8589	{
8545	prev_inst = cur_inst;	8590	prev_inst = cur_inst;
8546	continue;	8591	continue;
...	@@ -8577,8 +8622,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8577,8 +8622,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8577	}	8622	}
8578		8623
8579	if (cur_type->id == TypeTableEntryIdArray && prev_type->id == TypeTableEntryIdArray &&	8624	if (cur_type->id == TypeTableEntryIdArray && prev_type->id == TypeTableEntryIdArray &&
8580	cur_type->data.array.len != prev_type->data.array.len &&	8625	cur_type->data.array.len != prev_type->data.array.len &&
8581	types_match_const_cast_only(ira, cur_type->data.array.child_type, prev_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8626	types_match_const_cast_only(ira, cur_type->data.array.child_type, prev_type->data.array.child_type,
		8627	source_node, false).id == ConstCastResultIdOk)
8582	{	8628	{
8583	convert_to_const_slice = true;	8629	convert_to_const_slice = true;
8584	prev_inst = cur_inst;	8630	prev_inst = cur_inst;
...	@@ -8586,8 +8632,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8586,8 +8632,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8586	}	8632	}
8587		8633
8588	if (cur_type->id == TypeTableEntryIdArray && prev_type->id == TypeTableEntryIdArray &&	8634	if (cur_type->id == TypeTableEntryIdArray && prev_type->id == TypeTableEntryIdArray &&
8589	cur_type->data.array.len != prev_type->data.array.len &&	8635	cur_type->data.array.len != prev_type->data.array.len &&
8590	types_match_const_cast_only(ira, prev_type->data.array.child_type, cur_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8636	types_match_const_cast_only(ira, prev_type->data.array.child_type, cur_type->data.array.child_type,
		8637	source_node, false).id == ConstCastResultIdOk)
8591	{	8638	{
8592	convert_to_const_slice = true;	8639	convert_to_const_slice = true;
8593	continue;	8640	continue;
...	@@ -8596,8 +8643,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8596,8 +8643,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8596	if (cur_type->id == TypeTableEntryIdArray && is_slice(prev_type) &&	8643	if (cur_type->id == TypeTableEntryIdArray && is_slice(prev_type) &&
8597	(prev_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const \|\|	8644	(prev_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const \|\|
8598	cur_type->data.array.len == 0) &&	8645	cur_type->data.array.len == 0) &&
8599	types_match_const_cast_only(ira, prev_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.child_type,	8646	types_match_const_cast_only(ira,
8600	cur_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8647	prev_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.child_type,
		8648	cur_type->data.array.child_type, source_node, false).id == ConstCastResultIdOk)
8601	{	8649	{
8602	convert_to_const_slice = false;	8650	convert_to_const_slice = false;
8603	continue;	8651	continue;
...	@@ -8606,8 +8654,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8606,8 +8654,9 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8606	if (prev_type->id == TypeTableEntryIdArray && is_slice(cur_type) &&	8654	if (prev_type->id == TypeTableEntryIdArray && is_slice(cur_type) &&
8607	(cur_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const \|\|	8655	(cur_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const \|\|
8608	prev_type->data.array.len == 0) &&	8656	prev_type->data.array.len == 0) &&
8609	types_match_const_cast_only(ira, cur_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.child_type,	8657	types_match_const_cast_only(ira,
8610	prev_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	8658	cur_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.child_type,
		8659	prev_type->data.array.child_type, source_node, false).id == ConstCastResultIdOk)
8611	{	8660	{
8612	prev_inst = cur_inst;	8661	prev_inst = cur_inst;
8613	convert_to_const_slice = false;	8662	convert_to_const_slice = false;
...	@@ -8692,7 +8741,7 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod	...	@@ -8692,7 +8741,7 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8692	ir_add_error_node(ira, source_node,	8741	ir_add_error_node(ira, source_node,
8693	buf_sprintf("unable to make maybe out of number literal"));	8742	buf_sprintf("unable to make maybe out of number literal"));
8694	return ira->codegen->builtin_types.entry_invalid;	8743	return ira->codegen->builtin_types.entry_invalid;
8695	} else if (prev_inst->value.type->id == TypeTableEntryIdMaybe) {	8744	} else if (prev_inst->value.type->id == TypeTableEntryIdOptional) {
8696	return prev_inst->value.type;	8745	return prev_inst->value.type;
8697	} else {	8746	} else {
8698	return get_maybe_type(ira->codegen, prev_inst->value.type);	8747	return get_maybe_type(ira->codegen, prev_inst->value.type);
...	@@ -8735,10 +8784,12 @@ static void eval_const_expr_implicit_cast(CastOp cast_op,	...	@@ -8735,10 +8784,12 @@ static void eval_const_expr_implicit_cast(CastOp cast_op,
8735	zig_unreachable();	8784	zig_unreachable();
8736	case CastOpErrSet:	8785	case CastOpErrSet:
8737	case CastOpBitCast:	8786	case CastOpBitCast:
		8787	case CastOpPtrOfArrayToSlice:
8738	zig_panic("TODO");	8788	zig_panic("TODO");
8739	case CastOpNoop:	8789	case CastOpNoop:
8740	{	8790	{
8741	copy_const_val(const_val, other_val, other_val->special == ConstValSpecialStatic);	8791	bool same_global_refs = other_val->special == ConstValSpecialStatic;
		8792	copy_const_val(const_val, other_val, same_global_refs);
8742	const_val->type = new_type;	8793	const_val->type = new_type;
8743	break;	8794	break;
8744	}	8795	}
...	@@ -8804,7 +8855,7 @@ static void eval_const_expr_implicit_cast(CastOp cast_op,	...	@@ -8804,7 +8855,7 @@ static void eval_const_expr_implicit_cast(CastOp cast_op,
8804	static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,	8855	static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
8805	TypeTableEntry *wanted_type, CastOp cast_op, bool need_alloca)	8856	TypeTableEntry *wanted_type, CastOp cast_op, bool need_alloca)
8806	{	8857	{
8807	if (value->value.special != ConstValSpecialRuntime &&	8858	if ((instr_is_comptime(value) \|\| !type_has_bits(wanted_type)) &&
8808	cast_op != CastOpResizeSlice && cast_op != CastOpBytesToSlice)	8859	cast_op != CastOpResizeSlice && cast_op != CastOpBytesToSlice)
8809	{	8860	{
8810	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,	8861	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
...	@@ -8822,6 +8873,63 @@ static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -8822,6 +8873,63 @@ static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction *source_inst
8822	}	8873	}
8823	}	8874	}
8824		8875
		8876	static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira, IrInstruction *source_instr,
		8877	IrInstruction value, TypeTableEntry wanted_type)
		8878	{
		8879	assert(value->value.type->id == TypeTableEntryIdPointer);
		8880	wanted_type = adjust_ptr_align(ira->codegen, wanted_type, value->value.type->data.pointer.alignment);
		8881
		8882	if (instr_is_comptime(value)) {
		8883	ConstExprValue *pointee = const_ptr_pointee(ira->codegen, &value->value);
		8884	if (pointee->special != ConstValSpecialRuntime) {
		8885	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
		8886	source_instr->source_node, wanted_type);
		8887	result->value.type = wanted_type;
		8888	result->value.data.x_ptr.special = ConstPtrSpecialBaseArray;
		8889	result->value.data.x_ptr.mut = value->value.data.x_ptr.mut;
		8890	result->value.data.x_ptr.data.base_array.array_val = pointee;
		8891	result->value.data.x_ptr.data.base_array.elem_index = 0;
		8892	result->value.data.x_ptr.data.base_array.is_cstr = false;
		8893	return result;
		8894	}
		8895	}
		8896
		8897	IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node,
		8898	wanted_type, value, CastOpBitCast);
		8899	result->value.type = wanted_type;
		8900	return result;
		8901	}
		8902
		8903	static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruction *source_instr,
		8904	IrInstruction value, TypeTableEntry wanted_type)
		8905	{
		8906	wanted_type = adjust_slice_align(ira->codegen, wanted_type, value->value.type->data.pointer.alignment);
		8907
		8908	if (instr_is_comptime(value)) {
		8909	ConstExprValue *pointee = const_ptr_pointee(ira->codegen, &value->value);
		8910	if (pointee->special != ConstValSpecialRuntime) {
		8911	assert(value->value.type->id == TypeTableEntryIdPointer);
		8912	TypeTableEntry *array_type = value->value.type->data.pointer.child_type;
		8913	assert(is_slice(wanted_type));
		8914	bool is_const = wanted_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const;
		8915
		8916	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope,
		8917	source_instr->source_node, wanted_type);
		8918	init_const_slice(ira->codegen, &result->value, pointee, 0, array_type->data.array.len, is_const);
		8919	result->value.data.x_struct.fields[slice_ptr_index].data.x_ptr.mut =
		8920	value->value.data.x_ptr.mut;
		8921	result->value.type = wanted_type;
		8922	return result;
		8923	}
		8924	}
		8925
		8926	IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node,
		8927	wanted_type, value, CastOpPtrOfArrayToSlice);
		8928	result->value.type = wanted_type;
		8929	ir_add_alloca(ira, result, wanted_type);
		8930	return result;
		8931	}
		8932
8825	static bool is_container(TypeTableEntry *type) {	8933	static bool is_container(TypeTableEntry *type) {
8826	return type->id == TypeTableEntryIdStruct \|\|	8934	return type->id == TypeTableEntryIdStruct \|\|
8827	type->id == TypeTableEntryIdEnum \|\|	8935	type->id == TypeTableEntryIdEnum \|\|
...	@@ -9115,7 +9223,7 @@ static FnTableEntry ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {	...	@@ -9115,7 +9223,7 @@ static FnTableEntry ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {
9115	}	9223	}
9116		9224
9117	static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, TypeTableEntry *wanted_type) {	9225	static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, TypeTableEntry *wanted_type) {
9118	assert(wanted_type->id == TypeTableEntryIdMaybe);	9226	assert(wanted_type->id == TypeTableEntryIdOptional);
9119		9227
9120	if (instr_is_comptime(value)) {	9228	if (instr_is_comptime(value)) {
9121	TypeTableEntry *payload_type = wanted_type->data.maybe.child_type;	9229	TypeTableEntry *payload_type = wanted_type->data.maybe.child_type;
...	@@ -9129,15 +9237,19 @@ static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction *sourc	...	@@ -9129,15 +9237,19 @@ static IrInstruction ir_analyze_maybe_wrap(IrAnalyze ira, IrInstruction *sourc
9129		9237
9130	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,	9238	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
9131	source_instr->scope, source_instr->source_node);	9239	source_instr->scope, source_instr->source_node);
9132	const_instruction->base.value.type = wanted_type;
9133	const_instruction->base.value.special = ConstValSpecialStatic;	9240	const_instruction->base.value.special = ConstValSpecialStatic;
9134	const_instruction->base.value.data.x_maybe = val;	9241	if (get_codegen_ptr_type(wanted_type) != nullptr) {
		9242	copy_const_val(&const_instruction->base.value, val, val->data.x_ptr.mut == ConstPtrMutComptimeConst);
		9243	} else {
		9244	const_instruction->base.value.data.x_optional = val;
		9245	}
		9246	const_instruction->base.value.type = wanted_type;
9135	return &const_instruction->base;	9247	return &const_instruction->base;
9136	}	9248	}
9137		9249
9138	IrInstruction *result = ir_build_maybe_wrap(&ira->new_irb, source_instr->scope, source_instr->source_node, value);	9250	IrInstruction *result = ir_build_maybe_wrap(&ira->new_irb, source_instr->scope, source_instr->source_node, value);
9139	result->value.type = wanted_type;	9251	result->value.type = wanted_type;
9140	result->value.data.rh_maybe = RuntimeHintMaybeNonNull;	9252	result->value.data.rh_maybe = RuntimeHintOptionalNonNull;
9141	ir_add_alloca(ira, result, wanted_type);	9253	ir_add_alloca(ira, result, wanted_type);
9142	return result;	9254	return result;
9143	}	9255	}
...	@@ -9279,16 +9391,21 @@ static IrInstruction ir_analyze_cast_ref(IrAnalyze ira, IrInstruction *source_	...	@@ -9279,16 +9391,21 @@ static IrInstruction ir_analyze_cast_ref(IrAnalyze ira, IrInstruction *source_
9279	}	9391	}
9280		9392
9281	static IrInstruction ir_analyze_null_to_maybe(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, TypeTableEntry *wanted_type) {	9393	static IrInstruction ir_analyze_null_to_maybe(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, TypeTableEntry *wanted_type) {
9282	assert(wanted_type->id == TypeTableEntryIdMaybe);	9394	assert(wanted_type->id == TypeTableEntryIdOptional);
9283	assert(instr_is_comptime(value));	9395	assert(instr_is_comptime(value));
9284		9396
9285	ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);	9397	ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
9286	assert(val);	9398	assert(val);
9287		9399
9288	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb, source_instr->scope, source_instr->source_node);	9400	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb, source_instr->scope, source_instr->source_node);
9289	const_instruction->base.value.type = wanted_type;
9290	const_instruction->base.value.special = ConstValSpecialStatic;	9401	const_instruction->base.value.special = ConstValSpecialStatic;
9291	const_instruction->base.value.data.x_maybe = nullptr;	9402	if (get_codegen_ptr_type(wanted_type) != nullptr) {
		9403	const_instruction->base.value.data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
		9404	const_instruction->base.value.data.x_ptr.data.hard_coded_addr.addr = 0;
		9405	} else {
		9406	const_instruction->base.value.data.x_optional = nullptr;
		9407	}
		9408	const_instruction->base.value.type = wanted_type;
9292	return &const_instruction->base;	9409	return &const_instruction->base;
9293	}	9410	}
9294		9411
...	@@ -9300,9 +9417,19 @@ static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction *source_instructi	...	@@ -9300,9 +9417,19 @@ static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction *source_instructi
9300		9417
9301	if (value->id == IrInstructionIdLoadPtr) {	9418	if (value->id == IrInstructionIdLoadPtr) {
9302	IrInstructionLoadPtr load_ptr_inst = (IrInstructionLoadPtr ) value;	9419	IrInstructionLoadPtr load_ptr_inst = (IrInstructionLoadPtr ) value;
		9420
9303	if (load_ptr_inst->ptr->value.type->data.pointer.is_const) {	9421	if (load_ptr_inst->ptr->value.type->data.pointer.is_const) {
9304	return load_ptr_inst->ptr;	9422	return load_ptr_inst->ptr;
9305	}	9423	}
		9424
		9425	type_ensure_zero_bits_known(ira->codegen, value->value.type);
		9426	if (type_is_invalid(value->value.type)) {
		9427	return ira->codegen->invalid_instruction;
		9428	}
		9429
		9430	if (!type_has_bits(value->value.type)) {
		9431	return load_ptr_inst->ptr;
		9432	}
9306	}	9433	}
9307		9434
9308	if (instr_is_comptime(value)) {	9435	if (instr_is_comptime(value)) {
...	@@ -9810,7 +9937,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -9810,7 +9937,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9810	}	9937	}
9811		9938
9812	// explicit match or non-const to const	9939	// explicit match or non-const to const
9813	if (types_match_const_cast_only(ira, wanted_type, actual_type, source_node).id == ConstCastResultIdOk) {	9940	if (types_match_const_cast_only(ira, wanted_type, actual_type, source_node, false).id == ConstCastResultIdOk) {
9814	return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop, false);	9941	return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop, false);
9815	}	9942	}
9816		9943
...	@@ -9856,7 +9983,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -9856,7 +9983,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9856	TypeTableEntry *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;	9983	TypeTableEntry *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
9857	assert(ptr_type->id == TypeTableEntryIdPointer);	9984	assert(ptr_type->id == TypeTableEntryIdPointer);
9858	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&	9985	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
9859	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	9986	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
		9987	source_node, false).id == ConstCastResultIdOk)
9860	{	9988	{
9861	return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type);	9989	return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type);
9862	}	9990	}
...	@@ -9874,7 +10002,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -9874,7 +10002,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9874	TypeTableEntry *array_type = actual_type->data.pointer.child_type;	10002	TypeTableEntry *array_type = actual_type->data.pointer.child_type;
9875		10003
9876	if ((ptr_type->data.pointer.is_const \|\| array_type->data.array.len == 0) &&	10004	if ((ptr_type->data.pointer.is_const \|\| array_type->data.array.len == 0) &&
9877	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, array_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	10005	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, array_type->data.array.child_type,
		10006	source_node, false).id == ConstCastResultIdOk)
9878	{	10007	{
9879	return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type);	10008	return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type);
9880	}	10009	}
...	@@ -9890,7 +10019,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -9890,7 +10019,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9890	wanted_type->data.pointer.child_type->data.structure.fields[slice_ptr_index].type_entry;	10019	wanted_type->data.pointer.child_type->data.structure.fields[slice_ptr_index].type_entry;
9891	assert(ptr_type->id == TypeTableEntryIdPointer);	10020	assert(ptr_type->id == TypeTableEntryIdPointer);
9892	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&	10021	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
9893	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	10022	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
		10023	source_node, false).id == ConstCastResultIdOk)
9894	{	10024	{
9895	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.pointer.child_type, value);	10025	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.pointer.child_type, value);
9896	if (type_is_invalid(cast1->value.type))	10026	if (type_is_invalid(cast1->value.type))
...	@@ -9905,7 +10035,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -9905,7 +10035,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9905	}	10035	}
9906		10036
9907	// explicit cast from [N]T to ?[]const N	10037	// explicit cast from [N]T to ?[]const N
9908	if (wanted_type->id == TypeTableEntryIdMaybe &&	10038	if (wanted_type->id == TypeTableEntryIdOptional &&
9909	is_slice(wanted_type->data.maybe.child_type) &&	10039	is_slice(wanted_type->data.maybe.child_type) &&
9910	actual_type->id == TypeTableEntryIdArray)	10040	actual_type->id == TypeTableEntryIdArray)
9911	{	10041	{
...	@@ -9913,7 +10043,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -9913,7 +10043,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9913	wanted_type->data.maybe.child_type->data.structure.fields[slice_ptr_index].type_entry;	10043	wanted_type->data.maybe.child_type->data.structure.fields[slice_ptr_index].type_entry;
9914	assert(ptr_type->id == TypeTableEntryIdPointer);	10044	assert(ptr_type->id == TypeTableEntryIdPointer);
9915	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&	10045	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
9916	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	10046	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
		10047	source_node, false).id == ConstCastResultIdOk)
9917	{	10048	{
9918	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value);	10049	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value);
9919	if (type_is_invalid(cast1->value.type))	10050	if (type_is_invalid(cast1->value.type))
...	@@ -9973,10 +10104,44 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -9973,10 +10104,44 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
9973	}	10104	}
9974	}	10105	}
9975		10106
9976	// explicit cast from child type of maybe type to maybe type	10107	// explicit [N]T to []T
9977	if (wanted_type->id == TypeTableEntryIdMaybe) {	10108	if (wanted_type->id == TypeTableEntryIdPointer &&
		10109	wanted_type->data.pointer.ptr_len == PtrLenUnknown &&
		10110	actual_type->id == TypeTableEntryIdPointer &&
		10111	actual_type->data.pointer.ptr_len == PtrLenSingle &&
		10112	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray &&
		10113	actual_type->data.pointer.alignment >= wanted_type->data.pointer.alignment &&
		10114	types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
		10115	actual_type->data.pointer.child_type->data.array.child_type, source_node,
		10116	!wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
		10117	{
		10118	return ir_resolve_ptr_of_array_to_unknown_len_ptr(ira, source_instr, value, wanted_type);
		10119	}
		10120
		10121	// explicit *[N]T to []T
		10122	if (is_slice(wanted_type) &&
		10123	actual_type->id == TypeTableEntryIdPointer &&
		10124	actual_type->data.pointer.ptr_len == PtrLenSingle &&
		10125	actual_type->data.pointer.child_type->id == TypeTableEntryIdArray)
		10126	{
		10127	TypeTableEntry *slice_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
		10128	assert(slice_ptr_type->id == TypeTableEntryIdPointer);
		10129	if (types_match_const_cast_only(ira, slice_ptr_type->data.pointer.child_type,
		10130	actual_type->data.pointer.child_type->data.array.child_type, source_node,
		10131	!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
		10132	{
		10133	return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, wanted_type);
		10134	}
		10135	}
		10136
		10137
		10138	// explicit cast from T to ?T
		10139	// note that the T to ?T case is handled via the "ConstCastOnly" mechanism
		10140	if (wanted_type->id == TypeTableEntryIdOptional) {
9978	TypeTableEntry *wanted_child_type = wanted_type->data.maybe.child_type;	10141	TypeTableEntry *wanted_child_type = wanted_type->data.maybe.child_type;
9979	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node).id == ConstCastResultIdOk) {	10142	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node,
		10143	false).id == ConstCastResultIdOk)
		10144	{
9980	return ir_analyze_maybe_wrap(ira, source_instr, value, wanted_type);	10145	return ir_analyze_maybe_wrap(ira, source_instr, value, wanted_type);
9981	} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|	10146	} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|
9982	actual_type->id == TypeTableEntryIdComptimeFloat)	10147	actual_type->id == TypeTableEntryIdComptimeFloat)
...	@@ -10003,7 +10168,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10003,7 +10168,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10003	}	10168	}
10004		10169
10005	// explicit cast from null literal to maybe type	10170	// explicit cast from null literal to maybe type
10006	if (wanted_type->id == TypeTableEntryIdMaybe &&	10171	if (wanted_type->id == TypeTableEntryIdOptional &&
10007	actual_type->id == TypeTableEntryIdNull)	10172	actual_type->id == TypeTableEntryIdNull)
10008	{	10173	{
10009	return ir_analyze_null_to_maybe(ira, source_instr, value, wanted_type);	10174	return ir_analyze_null_to_maybe(ira, source_instr, value, wanted_type);
...	@@ -10011,7 +10176,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10011,7 +10176,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10011		10176
10012	// explicit cast from child type of error type to error type	10177	// explicit cast from child type of error type to error type
10013	if (wanted_type->id == TypeTableEntryIdErrorUnion) {	10178	if (wanted_type->id == TypeTableEntryIdErrorUnion) {
10014	if (types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type, actual_type, source_node).id == ConstCastResultIdOk) {	10179	if (types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type, actual_type,
		10180	source_node, false).id == ConstCastResultIdOk)
		10181	{
10015	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type);	10182	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type);
10016	} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|	10183	} else if (actual_type->id == TypeTableEntryIdComptimeInt \|\|
10017	actual_type->id == TypeTableEntryIdComptimeFloat)	10184	actual_type->id == TypeTableEntryIdComptimeFloat)
...	@@ -10024,7 +10191,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10024,7 +10191,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10024	}	10191	}
10025	}	10192	}
10026		10193
10027	// explicit cast from [N]T to %[]const T	10194	// explicit cast from [N]T to E![]const T
10028	if (wanted_type->id == TypeTableEntryIdErrorUnion &&	10195	if (wanted_type->id == TypeTableEntryIdErrorUnion &&
10029	is_slice(wanted_type->data.error_union.payload_type) &&	10196	is_slice(wanted_type->data.error_union.payload_type) &&
10030	actual_type->id == TypeTableEntryIdArray)	10197	actual_type->id == TypeTableEntryIdArray)
...	@@ -10033,7 +10200,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10033,7 +10200,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10033	wanted_type->data.error_union.payload_type->data.structure.fields[slice_ptr_index].type_entry;	10200	wanted_type->data.error_union.payload_type->data.structure.fields[slice_ptr_index].type_entry;
10034	assert(ptr_type->id == TypeTableEntryIdPointer);	10201	assert(ptr_type->id == TypeTableEntryIdPointer);
10035	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&	10202	if ((ptr_type->data.pointer.is_const \|\| actual_type->data.array.len == 0) &&
10036	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type, source_node).id == ConstCastResultIdOk)	10203	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
		10204	source_node, false).id == ConstCastResultIdOk)
10037	{	10205	{
10038	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);	10206	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
10039	if (type_is_invalid(cast1->value.type))	10207	if (type_is_invalid(cast1->value.type))
...	@@ -10054,13 +10222,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10054,13 +10222,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10054	return ir_analyze_err_wrap_code(ira, source_instr, value, wanted_type);	10222	return ir_analyze_err_wrap_code(ira, source_instr, value, wanted_type);
10055	}	10223	}
10056		10224
10057	// explicit cast from T to %?T	10225	// explicit cast from T to E!?T
10058	if (wanted_type->id == TypeTableEntryIdErrorUnion &&	10226	if (wanted_type->id == TypeTableEntryIdErrorUnion &&
10059	wanted_type->data.error_union.payload_type->id == TypeTableEntryIdMaybe &&	10227	wanted_type->data.error_union.payload_type->id == TypeTableEntryIdOptional &&
10060	actual_type->id != TypeTableEntryIdMaybe)	10228	actual_type->id != TypeTableEntryIdOptional)
10061	{	10229	{
10062	TypeTableEntry *wanted_child_type = wanted_type->data.error_union.payload_type->data.maybe.child_type;	10230	TypeTableEntry *wanted_child_type = wanted_type->data.error_union.payload_type->data.maybe.child_type;
10063	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node).id == ConstCastResultIdOk \|\|	10231	if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node, false).id == ConstCastResultIdOk \|\|
10064	actual_type->id == TypeTableEntryIdNull \|\|	10232	actual_type->id == TypeTableEntryIdNull \|\|
10065	actual_type->id == TypeTableEntryIdComptimeInt \|\|	10233	actual_type->id == TypeTableEntryIdComptimeInt \|\|
10066	actual_type->id == TypeTableEntryIdComptimeFloat)	10234	actual_type->id == TypeTableEntryIdComptimeFloat)
...	@@ -10078,7 +10246,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10078,7 +10246,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10078	}	10246	}
10079		10247
10080	// explicit cast from number literal to another type	10248	// explicit cast from number literal to another type
10081	// explicit cast from number literal to &const integer	10249	// explicit cast from number literal to *const integer
10082	if (actual_type->id == TypeTableEntryIdComptimeFloat \|\|	10250	if (actual_type->id == TypeTableEntryIdComptimeFloat \|\|
10083	actual_type->id == TypeTableEntryIdComptimeInt)	10251	actual_type->id == TypeTableEntryIdComptimeInt)
10084	{	10252	{
...	@@ -10212,7 +10380,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10212,7 +10380,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10212	TypeTableEntry *array_type = wanted_type->data.pointer.child_type;	10380	TypeTableEntry *array_type = wanted_type->data.pointer.child_type;
10213	if (array_type->id == TypeTableEntryIdArray && array_type->data.array.len == 1 &&	10381	if (array_type->id == TypeTableEntryIdArray && array_type->data.array.len == 1 &&
10214	types_match_const_cast_only(ira, array_type->data.array.child_type,	10382	types_match_const_cast_only(ira, array_type->data.array.child_type,
10215	actual_type->data.pointer.child_type, source_node).id == ConstCastResultIdOk)	10383	actual_type->data.pointer.child_type, source_node,
		10384	!wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
10216	{	10385	{
10217	if (wanted_type->data.pointer.alignment > actual_type->data.pointer.alignment) {	10386	if (wanted_type->data.pointer.alignment > actual_type->data.pointer.alignment) {
10218	ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));	10387	ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));
...	@@ -10228,6 +10397,20 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10228,6 +10397,20 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10228	}	10397	}
10229	}	10398	}
10230		10399
		10400	// explicit cast from T to *T where T is zero bits
		10401	if (wanted_type->id == TypeTableEntryIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
		10402	types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
		10403	actual_type, source_node, !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
		10404	{
		10405	type_ensure_zero_bits_known(ira->codegen, actual_type);
		10406	if (type_is_invalid(actual_type)) {
		10407	return ira->codegen->invalid_instruction;
		10408	}
		10409	if (!type_has_bits(actual_type)) {
		10410	return ir_get_ref(ira, source_instr, value, false, false);
		10411	}
		10412	}
		10413
10231		10414
10232	// explicit cast from undefined to anything	10415	// explicit cast from undefined to anything
10233	if (actual_type->id == TypeTableEntryIdUndefined) {	10416	if (actual_type->id == TypeTableEntryIdUndefined) {
...	@@ -10237,7 +10420,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -10237,7 +10420,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
10237	// explicit cast from something to const pointer of it	10420	// explicit cast from something to const pointer of it
10238	if (!type_requires_comptime(actual_type)) {	10421	if (!type_requires_comptime(actual_type)) {
10239	TypeTableEntry *const_ptr_actual = get_pointer_to_type(ira->codegen, actual_type, true);	10422	TypeTableEntry *const_ptr_actual = get_pointer_to_type(ira->codegen, actual_type, true);
10240	if (types_match_const_cast_only(ira, wanted_type, const_ptr_actual, source_node).id == ConstCastResultIdOk) {	10423	if (types_match_const_cast_only(ira, wanted_type, const_ptr_actual, source_node, false).id == ConstCastResultIdOk) {
10241	return ir_analyze_cast_ref(ira, source_instr, value, wanted_type);	10424	return ir_analyze_cast_ref(ira, source_instr, value, wanted_type);
10242	}	10425	}
10243	}	10426	}
...	@@ -10302,6 +10485,7 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc	...	@@ -10302,6 +10485,7 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
10302	IrInstruction *result = ir_create_const(&ira->new_irb, source_instruction->scope,	10485	IrInstruction *result = ir_create_const(&ira->new_irb, source_instruction->scope,
10303	source_instruction->source_node, child_type);	10486	source_instruction->source_node, child_type);
10304	copy_const_val(&result->value, pointee, ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst);	10487	copy_const_val(&result->value, pointee, ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst);
		10488	result->value.type = child_type;
10305	return result;	10489	return result;
10306	}	10490	}
10307	}	10491	}
...	@@ -10619,6 +10803,16 @@ static bool resolve_cmp_op_id(IrBinOp op_id, Cmp cmp) {	...	@@ -10619,6 +10803,16 @@ static bool resolve_cmp_op_id(IrBinOp op_id, Cmp cmp) {
10619	}	10803	}
10620	}	10804	}
10621		10805
		10806	static bool optional_value_is_null(ConstExprValue *val) {
		10807	assert(val->special == ConstValSpecialStatic);
		10808	if (get_codegen_ptr_type(val->type) != nullptr) {
		10809	return val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr &&
		10810	val->data.x_ptr.data.hard_coded_addr.addr == 0;
		10811	} else {
		10812	return val->data.x_optional == nullptr;
		10813	}
		10814	}
		10815
10622	static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {	10816	static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
10623	IrInstruction *op1 = bin_op_instruction->op1->other;	10817	IrInstruction *op1 = bin_op_instruction->op1->other;
10624	IrInstruction *op2 = bin_op_instruction->op2->other;	10818	IrInstruction *op2 = bin_op_instruction->op2->other;
...	@@ -10627,8 +10821,8 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp	...	@@ -10627,8 +10821,8 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
10627	IrBinOp op_id = bin_op_instruction->op_id;	10821	IrBinOp op_id = bin_op_instruction->op_id;
10628	bool is_equality_cmp = (op_id == IrBinOpCmpEq \|\| op_id == IrBinOpCmpNotEq);	10822	bool is_equality_cmp = (op_id == IrBinOpCmpEq \|\| op_id == IrBinOpCmpNotEq);
10629	if (is_equality_cmp &&	10823	if (is_equality_cmp &&
10630	((op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdMaybe) \|\|	10824	((op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdOptional) \|\|
10631	(op2->value.type->id == TypeTableEntryIdNull && op1->value.type->id == TypeTableEntryIdMaybe) \|\|	10825	(op2->value.type->id == TypeTableEntryIdNull && op1->value.type->id == TypeTableEntryIdOptional) \|\|
10632	(op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdNull)))	10826	(op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdNull)))
10633	{	10827	{
10634	if (op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdNull) {	10828	if (op1->value.type->id == TypeTableEntryIdNull && op2->value.type->id == TypeTableEntryIdNull) {
...	@@ -10648,7 +10842,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp	...	@@ -10648,7 +10842,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
10648	ConstExprValue *maybe_val = ir_resolve_const(ira, maybe_op, UndefBad);	10842	ConstExprValue *maybe_val = ir_resolve_const(ira, maybe_op, UndefBad);
10649	if (!maybe_val)	10843	if (!maybe_val)
10650	return ira->codegen->builtin_types.entry_invalid;	10844	return ira->codegen->builtin_types.entry_invalid;
10651	bool is_null = (maybe_val->data.x_maybe == nullptr);	10845	bool is_null = optional_value_is_null(maybe_val);
10652	ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);	10846	ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
10653	out_val->data.x_bool = (op_id == IrBinOpCmpEq) ? is_null : !is_null;	10847	out_val->data.x_bool = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
10654	return ira->codegen->builtin_types.entry_bool;	10848	return ira->codegen->builtin_types.entry_bool;
...	@@ -10797,7 +10991,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp	...	@@ -10797,7 +10991,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
10797	case TypeTableEntryIdStruct:	10991	case TypeTableEntryIdStruct:
10798	case TypeTableEntryIdUndefined:	10992	case TypeTableEntryIdUndefined:
10799	case TypeTableEntryIdNull:	10993	case TypeTableEntryIdNull:
10800	case TypeTableEntryIdMaybe:	10994	case TypeTableEntryIdOptional:
10801	case TypeTableEntryIdErrorUnion:	10995	case TypeTableEntryIdErrorUnion:
10802	case TypeTableEntryIdUnion:	10996	case TypeTableEntryIdUnion:
10803	ir_add_error_node(ira, source_node,	10997	ir_add_error_node(ira, source_node,
...	@@ -11135,7 +11329,13 @@ static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *	...	@@ -11135,7 +11329,13 @@ static TypeTableEntry ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *
11135		11329
11136	static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {	11330	static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
11137	IrInstruction *op1 = bin_op_instruction->op1->other;	11331	IrInstruction *op1 = bin_op_instruction->op1->other;
		11332	if (type_is_invalid(op1->value.type))
		11333	return ira->codegen->builtin_types.entry_invalid;
		11334
11138	IrInstruction *op2 = bin_op_instruction->op2->other;	11335	IrInstruction *op2 = bin_op_instruction->op2->other;
		11336	if (type_is_invalid(op2->value.type))
		11337	return ira->codegen->builtin_types.entry_invalid;
		11338
11139	IrBinOp op_id = bin_op_instruction->op_id;	11339	IrBinOp op_id = bin_op_instruction->op_id;
11140		11340
11141	// look for pointer math	11341	// look for pointer math
...	@@ -11621,61 +11821,6 @@ static TypeTableEntry ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstructi	...	@@ -11621,61 +11821,6 @@ static TypeTableEntry ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstructi
11621	zig_unreachable();	11821	zig_unreachable();
11622	}	11822	}
11623		11823
11624	enum VarClassRequired {
11625	VarClassRequiredAny,
11626	VarClassRequiredConst,
11627	VarClassRequiredIllegal,
11628	};
11629
11630	static VarClassRequired get_var_class_required(TypeTableEntry *type_entry) {
11631	switch (type_entry->id) {
11632	case TypeTableEntryIdInvalid:
11633	zig_unreachable();
11634	case TypeTableEntryIdUnreachable:
11635	return VarClassRequiredIllegal;
11636	case TypeTableEntryIdBool:
11637	case TypeTableEntryIdInt:
11638	case TypeTableEntryIdFloat:
11639	case TypeTableEntryIdVoid:
11640	case TypeTableEntryIdErrorSet:
11641	case TypeTableEntryIdFn:
11642	case TypeTableEntryIdPromise:
11643	return VarClassRequiredAny;
11644	case TypeTableEntryIdComptimeFloat:
11645	case TypeTableEntryIdComptimeInt:
11646	case TypeTableEntryIdUndefined:
11647	case TypeTableEntryIdBlock:
11648	case TypeTableEntryIdNull:
11649	case TypeTableEntryIdOpaque:
11650	case TypeTableEntryIdMetaType:
11651	case TypeTableEntryIdNamespace:
11652	case TypeTableEntryIdBoundFn:
11653	case TypeTableEntryIdArgTuple:
11654	return VarClassRequiredConst;
11655
11656	case TypeTableEntryIdPointer:
11657	if (type_entry->data.pointer.child_type->id == TypeTableEntryIdOpaque) {
11658	return VarClassRequiredAny;
11659	} else {
11660	return get_var_class_required(type_entry->data.pointer.child_type);
11661	}
11662	case TypeTableEntryIdArray:
11663	return get_var_class_required(type_entry->data.array.child_type);
11664	case TypeTableEntryIdMaybe:
11665	return get_var_class_required(type_entry->data.maybe.child_type);
11666	case TypeTableEntryIdErrorUnion:
11667	return get_var_class_required(type_entry->data.error_union.payload_type);
11668
11669	case TypeTableEntryIdStruct:
11670	case TypeTableEntryIdEnum:
11671	case TypeTableEntryIdUnion:
11672	// TODO check the fields of these things and make sure that they don't recursively
11673	// contain any of the other variable classes
11674	return VarClassRequiredAny;
11675	}
11676	zig_unreachable();
11677	}
11678
11679	static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstructionDeclVar *decl_var_instruction) {	11824	static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstructionDeclVar *decl_var_instruction) {
11680	VariableTableEntry *var = decl_var_instruction->var;	11825	VariableTableEntry *var = decl_var_instruction->var;
11681		11826
...	@@ -11710,36 +11855,41 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc	...	@@ -11710,36 +11855,41 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
11710	if (type_is_invalid(result_type)) {	11855	if (type_is_invalid(result_type)) {
11711	result_type = ira->codegen->builtin_types.entry_invalid;	11856	result_type = ira->codegen->builtin_types.entry_invalid;
11712	} else {	11857	} else {
11713	switch (get_var_class_required(result_type)) {	11858	type_ensure_zero_bits_known(ira->codegen, result_type);
11714	case VarClassRequiredIllegal:	11859	if (type_is_invalid(result_type)) {
		11860	result_type = ira->codegen->builtin_types.entry_invalid;
		11861	}
		11862	}
		11863
		11864	if (!type_is_invalid(result_type)) {
		11865	if (result_type->id == TypeTableEntryIdUnreachable \|\|
		11866	result_type->id == TypeTableEntryIdOpaque)
		11867	{
		11868	ir_add_error_node(ira, source_node,
		11869	buf_sprintf("variable of type '%s' not allowed", buf_ptr(&result_type->name)));
		11870	result_type = ira->codegen->builtin_types.entry_invalid;
		11871	} else if (type_requires_comptime(result_type)) {
		11872	var_class_requires_const = true;
		11873	if (!var->src_is_const && !is_comptime_var) {
11715	ir_add_error_node(ira, source_node,	11874	ir_add_error_node(ira, source_node,
11716	buf_sprintf("variable of type '%s' not allowed", buf_ptr(&result_type->name)));	11875	buf_sprintf("variable of type '%s' must be const or comptime",
		11876	buf_ptr(&result_type->name)));
11717	result_type = ira->codegen->builtin_types.entry_invalid;	11877	result_type = ira->codegen->builtin_types.entry_invalid;
11718	break;	11878	}
11719	case VarClassRequiredConst:	11879	} else {
		11880	if (casted_init_value->value.special == ConstValSpecialStatic &&
		11881	casted_init_value->value.type->id == TypeTableEntryIdFn &&
		11882	casted_init_value->value.data.x_ptr.data.fn.fn_entry->fn_inline == FnInlineAlways)
		11883	{
11720	var_class_requires_const = true;	11884	var_class_requires_const = true;
11721	if (!var->src_is_const && !is_comptime_var) {	11885	if (!var->src_is_const && !is_comptime_var) {
11722	ir_add_error_node(ira, source_node,	11886	ErrorMsg *msg = ir_add_error_node(ira, source_node,
11723	buf_sprintf("variable of type '%s' must be const or comptime",	11887	buf_sprintf("functions marked inline must be stored in const or comptime var"));
11724	buf_ptr(&result_type->name)));	11888	AstNode *proto_node = casted_init_value->value.data.x_ptr.data.fn.fn_entry->proto_node;
		11889	add_error_note(ira->codegen, msg, proto_node, buf_sprintf("declared here"));
11725	result_type = ira->codegen->builtin_types.entry_invalid;	11890	result_type = ira->codegen->builtin_types.entry_invalid;
11726	}	11891	}
11727	break;	11892	}
11728	case VarClassRequiredAny:
11729	if (casted_init_value->value.special == ConstValSpecialStatic &&
11730	casted_init_value->value.type->id == TypeTableEntryIdFn &&
11731	casted_init_value->value.data.x_ptr.data.fn.fn_entry->fn_inline == FnInlineAlways)
11732	{
11733	var_class_requires_const = true;
11734	if (!var->src_is_const && !is_comptime_var) {
11735	ErrorMsg *msg = ir_add_error_node(ira, source_node,
11736	buf_sprintf("functions marked inline must be stored in const or comptime var"));
11737	AstNode *proto_node = casted_init_value->value.data.x_ptr.data.fn.fn_entry->proto_node;
11738	add_error_note(ira->codegen, msg, proto_node, buf_sprintf("declared here"));
11739	result_type = ira->codegen->builtin_types.entry_invalid;
11740	}
11741	}
11742	break;
11743	}	11893	}
11744	}	11894	}
11745		11895
...	@@ -11914,7 +12064,7 @@ static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructi	...	@@ -11914,7 +12064,7 @@ static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructi
11914	case TypeTableEntryIdComptimeInt:	12064	case TypeTableEntryIdComptimeInt:
11915	case TypeTableEntryIdUndefined:	12065	case TypeTableEntryIdUndefined:
11916	case TypeTableEntryIdNull:	12066	case TypeTableEntryIdNull:
11917	case TypeTableEntryIdMaybe:	12067	case TypeTableEntryIdOptional:
11918	case TypeTableEntryIdErrorUnion:	12068	case TypeTableEntryIdErrorUnion:
11919	case TypeTableEntryIdErrorSet:	12069	case TypeTableEntryIdErrorSet:
11920	case TypeTableEntryIdNamespace:	12070	case TypeTableEntryIdNamespace:
...	@@ -11938,7 +12088,7 @@ static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructi	...	@@ -11938,7 +12088,7 @@ static TypeTableEntry ir_analyze_instruction_export(IrAnalyze ira, IrInstructi
11938	case TypeTableEntryIdComptimeInt:	12088	case TypeTableEntryIdComptimeInt:
11939	case TypeTableEntryIdUndefined:	12089	case TypeTableEntryIdUndefined:
11940	case TypeTableEntryIdNull:	12090	case TypeTableEntryIdNull:
11941	case TypeTableEntryIdMaybe:	12091	case TypeTableEntryIdOptional:
11942	case TypeTableEntryIdErrorUnion:	12092	case TypeTableEntryIdErrorUnion:
11943	case TypeTableEntryIdErrorSet:	12093	case TypeTableEntryIdErrorSet:
11944	zig_panic("TODO export const value of type %s", buf_ptr(&target->value.type->name));	12094	zig_panic("TODO export const value of type %s", buf_ptr(&target->value.type->name));
...	@@ -11965,22 +12115,24 @@ static bool exec_has_err_ret_trace(CodeGen g, IrExecutable exec) {	...	@@ -11965,22 +12115,24 @@ static bool exec_has_err_ret_trace(CodeGen g, IrExecutable exec) {
11965	static TypeTableEntry ir_analyze_instruction_error_return_trace(IrAnalyze ira,	12115	static TypeTableEntry ir_analyze_instruction_error_return_trace(IrAnalyze ira,
11966	IrInstructionErrorReturnTrace *instruction)	12116	IrInstructionErrorReturnTrace *instruction)
11967	{	12117	{
11968	if (instruction->nullable == IrInstructionErrorReturnTrace::Null) {	12118	if (instruction->optional == IrInstructionErrorReturnTrace::Null) {
11969	TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);	12119	TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);
11970	TypeTableEntry *nullable_type = get_maybe_type(ira->codegen, ptr_to_stack_trace_type);	12120	TypeTableEntry *optional_type = get_maybe_type(ira->codegen, ptr_to_stack_trace_type);
11971	if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {	12121	if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {
11972	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);	12122	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
11973	out_val->data.x_maybe = nullptr;	12123	assert(get_codegen_ptr_type(optional_type) != nullptr);
11974	return nullable_type;	12124	out_val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
		12125	out_val->data.x_ptr.data.hard_coded_addr.addr = 0;
		12126	return optional_type;
11975	}	12127	}
11976	IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,	12128	IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
11977	instruction->base.source_node, instruction->nullable);	12129	instruction->base.source_node, instruction->optional);
11978	ir_link_new_instruction(new_instruction, &instruction->base);	12130	ir_link_new_instruction(new_instruction, &instruction->base);
11979	return nullable_type;	12131	return optional_type;
11980	} else {	12132	} else {
11981	assert(ira->codegen->have_err_ret_tracing);	12133	assert(ira->codegen->have_err_ret_tracing);
11982	IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,	12134	IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
11983	instruction->base.source_node, instruction->nullable);	12135	instruction->base.source_node, instruction->optional);
11984	ir_link_new_instruction(new_instruction, &instruction->base);	12136	ir_link_new_instruction(new_instruction, &instruction->base);
11985	return get_ptr_to_stack_trace_type(ira->codegen);	12137	return get_ptr_to_stack_trace_type(ira->codegen);
11986	}	12138	}
...	@@ -12620,6 +12772,10 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal	...	@@ -12620,6 +12772,10 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
12620	inst_fn_type_id.return_type = specified_return_type;	12772	inst_fn_type_id.return_type = specified_return_type;
12621	}	12773	}
12622		12774
		12775	type_ensure_zero_bits_known(ira->codegen, specified_return_type);
		12776	if (type_is_invalid(specified_return_type))
		12777	return ira->codegen->builtin_types.entry_invalid;
		12778
12623	if (type_requires_comptime(specified_return_type)) {	12779	if (type_requires_comptime(specified_return_type)) {
12624	// Throw out our work and call the function as if it were comptime.	12780	// Throw out our work and call the function as if it were comptime.
12625	return ir_analyze_fn_call(ira, call_instruction, fn_entry, fn_type, fn_ref, first_arg_ptr, true, FnInlineAuto);	12781	return ir_analyze_fn_call(ira, call_instruction, fn_entry, fn_type, fn_ref, first_arg_ptr, true, FnInlineAuto);
...	@@ -12854,6 +13010,12 @@ static TypeTableEntry ir_analyze_dereference(IrAnalyze ira, IrInstructionUnOp	...	@@ -12854,6 +13010,12 @@ static TypeTableEntry ir_analyze_dereference(IrAnalyze ira, IrInstructionUnOp
12854	if (type_is_invalid(ptr_type)) {	13010	if (type_is_invalid(ptr_type)) {
12855	return ira->codegen->builtin_types.entry_invalid;	13011	return ira->codegen->builtin_types.entry_invalid;
12856	} else if (ptr_type->id == TypeTableEntryIdPointer) {	13012	} else if (ptr_type->id == TypeTableEntryIdPointer) {
		13013	if (ptr_type->data.pointer.ptr_len == PtrLenUnknown) {
		13014	ir_add_error_node(ira, un_op_instruction->base.source_node,
		13015	buf_sprintf("index syntax required for unknown-length pointer type '%s'",
		13016	buf_ptr(&ptr_type->name)));
		13017	return ira->codegen->builtin_types.entry_invalid;
		13018	}
12857	child_type = ptr_type->data.pointer.child_type;	13019	child_type = ptr_type->data.pointer.child_type;
12858	} else {	13020	} else {
12859	ir_add_error_node(ira, un_op_instruction->base.source_node,	13021	ir_add_error_node(ira, un_op_instruction->base.source_node,
...	@@ -12902,7 +13064,7 @@ static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op	...	@@ -12902,7 +13064,7 @@ static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op
12902	case TypeTableEntryIdComptimeInt:	13064	case TypeTableEntryIdComptimeInt:
12903	case TypeTableEntryIdUndefined:	13065	case TypeTableEntryIdUndefined:
12904	case TypeTableEntryIdNull:	13066	case TypeTableEntryIdNull:
12905	case TypeTableEntryIdMaybe:	13067	case TypeTableEntryIdOptional:
12906	case TypeTableEntryIdErrorUnion:	13068	case TypeTableEntryIdErrorUnion:
12907	case TypeTableEntryIdErrorSet:	13069	case TypeTableEntryIdErrorSet:
12908	case TypeTableEntryIdEnum:	13070	case TypeTableEntryIdEnum:
...	@@ -12921,7 +13083,7 @@ static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op	...	@@ -12921,7 +13083,7 @@ static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op
12921	case TypeTableEntryIdUnreachable:	13083	case TypeTableEntryIdUnreachable:
12922	case TypeTableEntryIdOpaque:	13084	case TypeTableEntryIdOpaque:
12923	ir_add_error_node(ira, un_op_instruction->base.source_node,	13085	ir_add_error_node(ira, un_op_instruction->base.source_node,
12924	buf_sprintf("type '%s' not nullable", buf_ptr(&type_entry->name)));	13086	buf_sprintf("type '%s' not optional", buf_ptr(&type_entry->name)));
12925	return ira->codegen->builtin_types.entry_invalid;	13087	return ira->codegen->builtin_types.entry_invalid;
12926	}	13088	}
12927	zig_unreachable();	13089	zig_unreachable();
...	@@ -13013,7 +13175,7 @@ static TypeTableEntry ir_analyze_instruction_un_op(IrAnalyze ira, IrInstructio	...	@@ -13013,7 +13175,7 @@ static TypeTableEntry ir_analyze_instruction_un_op(IrAnalyze ira, IrInstructio
13013	return ir_analyze_negation(ira, un_op_instruction);	13175	return ir_analyze_negation(ira, un_op_instruction);
13014	case IrUnOpDereference:	13176	case IrUnOpDereference:
13015	return ir_analyze_dereference(ira, un_op_instruction);	13177	return ir_analyze_dereference(ira, un_op_instruction);
13016	case IrUnOpMaybe:	13178	case IrUnOpOptional:
13017	return ir_analyze_maybe(ira, un_op_instruction);	13179	return ir_analyze_maybe(ira, un_op_instruction);
13018	}	13180	}
13019	zig_unreachable();	13181	zig_unreachable();
...	@@ -13220,6 +13382,13 @@ static TypeTableEntry adjust_ptr_align(CodeGen g, TypeTableEntry *ptr_type, ui	...	@@ -13220,6 +13382,13 @@ static TypeTableEntry adjust_ptr_align(CodeGen g, TypeTableEntry *ptr_type, ui
13220	ptr_type->data.pointer.bit_offset, ptr_type->data.pointer.unaligned_bit_count);	13382	ptr_type->data.pointer.bit_offset, ptr_type->data.pointer.unaligned_bit_count);
13221	}	13383	}
13222		13384
		13385	static TypeTableEntry adjust_slice_align(CodeGen g, TypeTableEntry *slice_type, uint32_t new_align) {
		13386	assert(is_slice(slice_type));
		13387	TypeTableEntry *ptr_type = adjust_ptr_align(g, slice_type->data.structure.fields[slice_ptr_index].type_entry,
		13388	new_align);
		13389	return get_slice_type(g, ptr_type);
		13390	}
		13391
13223	static TypeTableEntry adjust_ptr_len(CodeGen g, TypeTableEntry *ptr_type, PtrLen ptr_len) {	13392	static TypeTableEntry adjust_ptr_len(CodeGen g, TypeTableEntry *ptr_type, PtrLen ptr_len) {
13224	assert(ptr_type->id == TypeTableEntryIdPointer);	13393	assert(ptr_type->id == TypeTableEntryIdPointer);
13225	return get_pointer_to_type_extra(g,	13394	return get_pointer_to_type_extra(g,
...	@@ -13794,10 +13963,14 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru	...	@@ -13794,10 +13963,14 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
13794	ir_link_new_instruction(result, &field_ptr_instruction->base);	13963	ir_link_new_instruction(result, &field_ptr_instruction->base);
13795	return result->value.type;	13964	return result->value.type;
13796	}	13965	}
13797	} else if (container_type->id == TypeTableEntryIdArray) {	13966	} else if (is_array_ref(container_type)) {
13798	if (buf_eql_str(field_name, "len")) {	13967	if (buf_eql_str(field_name, "len")) {
13799	ConstExprValue *len_val = create_const_vals(1);	13968	ConstExprValue *len_val = create_const_vals(1);
13800	init_const_usize(ira->codegen, len_val, container_type->data.array.len);	13969	if (container_type->id == TypeTableEntryIdPointer) {
		13970	init_const_usize(ira->codegen, len_val, container_type->data.pointer.child_type->data.array.len);
		13971	} else {
		13972	init_const_usize(ira->codegen, len_val, container_type->data.array.len);
		13973	}
13801		13974
13802	TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;	13975	TypeTableEntry *usize = ira->codegen->builtin_types.entry_usize;
13803	bool ptr_is_const = true;	13976	bool ptr_is_const = true;
...	@@ -14048,7 +14221,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru	...	@@ -14048,7 +14221,7 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14048	buf_ptr(&child_type->name), buf_ptr(field_name)));	14221	buf_ptr(&child_type->name), buf_ptr(field_name)));
14049	return ira->codegen->builtin_types.entry_invalid;	14222	return ira->codegen->builtin_types.entry_invalid;
14050	}	14223	}
14051	} else if (child_type->id == TypeTableEntryIdMaybe) {	14224	} else if (child_type->id == TypeTableEntryIdOptional) {
14052	if (buf_eql_str(field_name, "Child")) {	14225	if (buf_eql_str(field_name, "Child")) {
14053	bool ptr_is_const = true;	14226	bool ptr_is_const = true;
14054	bool ptr_is_volatile = false;	14227	bool ptr_is_volatile = false;
...	@@ -14141,6 +14314,9 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru	...	@@ -14141,6 +14314,9 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
14141		14314
14142	static TypeTableEntry ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstructionLoadPtr *load_ptr_instruction) {	14315	static TypeTableEntry ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstructionLoadPtr *load_ptr_instruction) {
14143	IrInstruction *ptr = load_ptr_instruction->ptr->other;	14316	IrInstruction *ptr = load_ptr_instruction->ptr->other;
		14317	if (type_is_invalid(ptr->value.type))
		14318	return ira->codegen->builtin_types.entry_invalid;
		14319
14144	IrInstruction *result = ir_get_deref(ira, &load_ptr_instruction->base, ptr);	14320	IrInstruction *result = ir_get_deref(ira, &load_ptr_instruction->base, ptr);
14145	ir_link_new_instruction(result, &load_ptr_instruction->base);	14321	ir_link_new_instruction(result, &load_ptr_instruction->base);
14146	assert(result->value.type);	14322	assert(result->value.type);
...	@@ -14229,7 +14405,7 @@ static TypeTableEntry ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructi	...	@@ -14229,7 +14405,7 @@ static TypeTableEntry ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructi
14229	case TypeTableEntryIdPointer:	14405	case TypeTableEntryIdPointer:
14230	case TypeTableEntryIdArray:	14406	case TypeTableEntryIdArray:
14231	case TypeTableEntryIdStruct:	14407	case TypeTableEntryIdStruct:
14232	case TypeTableEntryIdMaybe:	14408	case TypeTableEntryIdOptional:
14233	case TypeTableEntryIdErrorUnion:	14409	case TypeTableEntryIdErrorUnion:
14234	case TypeTableEntryIdErrorSet:	14410	case TypeTableEntryIdErrorSet:
14235	case TypeTableEntryIdEnum:	14411	case TypeTableEntryIdEnum:
...	@@ -14497,7 +14673,7 @@ static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,	...	@@ -14497,7 +14673,7 @@ static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,
14497	case TypeTableEntryIdStruct:	14673	case TypeTableEntryIdStruct:
14498	case TypeTableEntryIdComptimeFloat:	14674	case TypeTableEntryIdComptimeFloat:
14499	case TypeTableEntryIdComptimeInt:	14675	case TypeTableEntryIdComptimeInt:
14500	case TypeTableEntryIdMaybe:	14676	case TypeTableEntryIdOptional:
14501	case TypeTableEntryIdErrorUnion:	14677	case TypeTableEntryIdErrorUnion:
14502	case TypeTableEntryIdErrorSet:	14678	case TypeTableEntryIdErrorSet:
14503	case TypeTableEntryIdEnum:	14679	case TypeTableEntryIdEnum:
...	@@ -14605,7 +14781,7 @@ static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,	...	@@ -14605,7 +14781,7 @@ static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,
14605	case TypeTableEntryIdStruct:	14781	case TypeTableEntryIdStruct:
14606	case TypeTableEntryIdComptimeFloat:	14782	case TypeTableEntryIdComptimeFloat:
14607	case TypeTableEntryIdComptimeInt:	14783	case TypeTableEntryIdComptimeInt:
14608	case TypeTableEntryIdMaybe:	14784	case TypeTableEntryIdOptional:
14609	case TypeTableEntryIdErrorUnion:	14785	case TypeTableEntryIdErrorUnion:
14610	case TypeTableEntryIdErrorSet:	14786	case TypeTableEntryIdErrorSet:
14611	case TypeTableEntryIdEnum:	14787	case TypeTableEntryIdEnum:
...	@@ -14676,7 +14852,7 @@ static TypeTableEntry ir_analyze_instruction_size_of(IrAnalyze ira,	...	@@ -14676,7 +14852,7 @@ static TypeTableEntry ir_analyze_instruction_size_of(IrAnalyze ira,
14676	case TypeTableEntryIdPointer:	14852	case TypeTableEntryIdPointer:
14677	case TypeTableEntryIdArray:	14853	case TypeTableEntryIdArray:
14678	case TypeTableEntryIdStruct:	14854	case TypeTableEntryIdStruct:
14679	case TypeTableEntryIdMaybe:	14855	case TypeTableEntryIdOptional:
14680	case TypeTableEntryIdErrorUnion:	14856	case TypeTableEntryIdErrorUnion:
14681	case TypeTableEntryIdErrorSet:	14857	case TypeTableEntryIdErrorSet:
14682	case TypeTableEntryIdEnum:	14858	case TypeTableEntryIdEnum:
...	@@ -14700,14 +14876,14 @@ static TypeTableEntry ir_analyze_instruction_test_non_null(IrAnalyze ira, IrIn	...	@@ -14700,14 +14876,14 @@ static TypeTableEntry ir_analyze_instruction_test_non_null(IrAnalyze ira, IrIn
14700		14876
14701	TypeTableEntry *type_entry = value->value.type;	14877	TypeTableEntry *type_entry = value->value.type;
14702		14878
14703	if (type_entry->id == TypeTableEntryIdMaybe) {	14879	if (type_entry->id == TypeTableEntryIdOptional) {
14704	if (instr_is_comptime(value)) {	14880	if (instr_is_comptime(value)) {
14705	ConstExprValue *maybe_val = ir_resolve_const(ira, value, UndefBad);	14881	ConstExprValue *maybe_val = ir_resolve_const(ira, value, UndefBad);
14706	if (!maybe_val)	14882	if (!maybe_val)
14707	return ira->codegen->builtin_types.entry_invalid;	14883	return ira->codegen->builtin_types.entry_invalid;
14708		14884
14709	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);	14885	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
14710	out_val->data.x_bool = (maybe_val->data.x_maybe != nullptr);	14886	out_val->data.x_bool = !optional_value_is_null(maybe_val);
14711	return ira->codegen->builtin_types.entry_bool;	14887	return ira->codegen->builtin_types.entry_bool;
14712	}	14888	}
14713		14889
...	@@ -14725,7 +14901,7 @@ static TypeTableEntry ir_analyze_instruction_test_non_null(IrAnalyze ira, IrIn	...	@@ -14725,7 +14901,7 @@ static TypeTableEntry ir_analyze_instruction_test_non_null(IrAnalyze ira, IrIn
14725	}	14901	}
14726		14902
14727	static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,	14903	static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
14728	IrInstructionUnwrapMaybe *unwrap_maybe_instruction)	14904	IrInstructionUnwrapOptional *unwrap_maybe_instruction)
14729	{	14905	{
14730	IrInstruction *value = unwrap_maybe_instruction->value->other;	14906	IrInstruction *value = unwrap_maybe_instruction->value->other;
14731	if (type_is_invalid(value->value.type))	14907	if (type_is_invalid(value->value.type))
...	@@ -14737,25 +14913,9 @@ static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,	...	@@ -14737,25 +14913,9 @@ static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
14737	TypeTableEntry *type_entry = ptr_type->data.pointer.child_type;	14913	TypeTableEntry *type_entry = ptr_type->data.pointer.child_type;
14738	if (type_is_invalid(type_entry)) {	14914	if (type_is_invalid(type_entry)) {
14739	return ira->codegen->builtin_types.entry_invalid;	14915	return ira->codegen->builtin_types.entry_invalid;
14740	} else if (type_entry->id == TypeTableEntryIdMetaType) {	14916	} else if (type_entry->id != TypeTableEntryIdOptional) {
14741	// surprise! actually this is just ??T not an unwrap maybe instruction
14742	ConstExprValue *ptr_val = const_ptr_pointee(ira->codegen, &value->value);
14743	assert(ptr_val->type->id == TypeTableEntryIdMetaType);
14744	TypeTableEntry *child_type = ptr_val->data.x_type;
14745
14746	type_ensure_zero_bits_known(ira->codegen, child_type);
14747	TypeTableEntry *layer1 = get_maybe_type(ira->codegen, child_type);
14748	TypeTableEntry *layer2 = get_maybe_type(ira->codegen, layer1);
14749
14750	IrInstruction *const_instr = ir_build_const_type(&ira->new_irb, unwrap_maybe_instruction->base.scope,
14751	unwrap_maybe_instruction->base.source_node, layer2);
14752	IrInstruction *result_instr = ir_get_ref(ira, &unwrap_maybe_instruction->base, const_instr,
14753	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile);
14754	ir_link_new_instruction(result_instr, &unwrap_maybe_instruction->base);
14755	return result_instr->value.type;
14756	} else if (type_entry->id != TypeTableEntryIdMaybe) {
14757	ir_add_error_node(ira, unwrap_maybe_instruction->value->source_node,	14917	ir_add_error_node(ira, unwrap_maybe_instruction->value->source_node,
14758	buf_sprintf("expected nullable type, found '%s'", buf_ptr(&type_entry->name)));	14918	buf_sprintf("expected optional type, found '%s'", buf_ptr(&type_entry->name)));
14759	return ira->codegen->builtin_types.entry_invalid;	14919	return ira->codegen->builtin_types.entry_invalid;
14760	}	14920	}
14761	TypeTableEntry *child_type = type_entry->data.maybe.child_type;	14921	TypeTableEntry *child_type = type_entry->data.maybe.child_type;
...	@@ -14771,13 +14931,18 @@ static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,	...	@@ -14771,13 +14931,18 @@ static TypeTableEntry ir_analyze_instruction_unwrap_maybe(IrAnalyze ira,
14771	ConstExprValue *maybe_val = const_ptr_pointee(ira->codegen, val);	14931	ConstExprValue *maybe_val = const_ptr_pointee(ira->codegen, val);
14772		14932
14773	if (val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {	14933	if (val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
14774	if (!maybe_val->data.x_maybe) {	14934	if (optional_value_is_null(maybe_val)) {
14775	ir_add_error(ira, &unwrap_maybe_instruction->base, buf_sprintf("unable to unwrap null"));	14935	ir_add_error(ira, &unwrap_maybe_instruction->base, buf_sprintf("unable to unwrap null"));
14776	return ira->codegen->builtin_types.entry_invalid;	14936	return ira->codegen->builtin_types.entry_invalid;
14777	}	14937	}
14778	ConstExprValue *out_val = ir_build_const_from(ira, &unwrap_maybe_instruction->base);	14938	ConstExprValue *out_val = ir_build_const_from(ira, &unwrap_maybe_instruction->base);
14779	out_val->data.x_ptr.special = ConstPtrSpecialRef;	14939	out_val->data.x_ptr.special = ConstPtrSpecialRef;
14780	out_val->data.x_ptr.data.ref.pointee = maybe_val->data.x_maybe;	14940	out_val->data.x_ptr.mut = val->data.x_ptr.mut;
		14941	if (type_is_codegen_pointer(child_type)) {
		14942	out_val->data.x_ptr.data.ref.pointee = maybe_val;
		14943	} else {
		14944	out_val->data.x_ptr.data.ref.pointee = maybe_val->data.x_optional;
		14945	}
14781	return result_type;	14946	return result_type;
14782	}	14947	}
14783	}	14948	}
...	@@ -15101,7 +15266,7 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,	...	@@ -15101,7 +15266,7 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
15101	case TypeTableEntryIdStruct:	15266	case TypeTableEntryIdStruct:
15102	case TypeTableEntryIdUndefined:	15267	case TypeTableEntryIdUndefined:
15103	case TypeTableEntryIdNull:	15268	case TypeTableEntryIdNull:
15104	case TypeTableEntryIdMaybe:	15269	case TypeTableEntryIdOptional:
15105	case TypeTableEntryIdBlock:	15270	case TypeTableEntryIdBlock:
15106	case TypeTableEntryIdBoundFn:	15271	case TypeTableEntryIdBoundFn:
15107	case TypeTableEntryIdArgTuple:	15272	case TypeTableEntryIdArgTuple:
...	@@ -15622,7 +15787,7 @@ static TypeTableEntry ir_analyze_min_max(IrAnalyze ira, IrInstruction *source_	...	@@ -15622,7 +15787,7 @@ static TypeTableEntry ir_analyze_min_max(IrAnalyze ira, IrInstruction *source_
15622	case TypeTableEntryIdComptimeInt:	15787	case TypeTableEntryIdComptimeInt:
15623	case TypeTableEntryIdUndefined:	15788	case TypeTableEntryIdUndefined:
15624	case TypeTableEntryIdNull:	15789	case TypeTableEntryIdNull:
15625	case TypeTableEntryIdMaybe:	15790	case TypeTableEntryIdOptional:
15626	case TypeTableEntryIdErrorUnion:	15791	case TypeTableEntryIdErrorUnion:
15627	case TypeTableEntryIdErrorSet:	15792	case TypeTableEntryIdErrorSet:
15628	case TypeTableEntryIdUnion:	15793	case TypeTableEntryIdUnion:
...	@@ -15743,11 +15908,6 @@ static TypeTableEntry ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrIn	...	@@ -15743,11 +15908,6 @@ static TypeTableEntry ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrIn
15743	return out_val->type;	15908	return out_val->type;
15744	}	15909	}
15745		15910
15746	if (!target->value.type->data.enumeration.generate_name_table) {
15747	target->value.type->data.enumeration.generate_name_table = true;
15748	ira->codegen->name_table_enums.append(target->value.type);
15749	}
15750
15751	IrInstruction *result = ir_build_tag_name(&ira->new_irb, instruction->base.scope,	15911	IrInstruction *result = ir_build_tag_name(&ira->new_irb, instruction->base.scope,
15752	instruction->base.source_node, target);	15912	instruction->base.source_node, target);
15753	ir_link_new_instruction(result, &instruction->base);	15913	ir_link_new_instruction(result, &instruction->base);
...	@@ -16140,12 +16300,12 @@ static bool ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Scop	...	@@ -16140,12 +16300,12 @@ static bool ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Scop
16140	0, 0);	16300	0, 0);
16141	fn_def_fields[6].type = get_maybe_type(ira->codegen, get_slice_type(ira->codegen, u8_ptr));	16301	fn_def_fields[6].type = get_maybe_type(ira->codegen, get_slice_type(ira->codegen, u8_ptr));
16142	if (fn_node->is_extern && buf_len(fn_node->lib_name) > 0) {	16302	if (fn_node->is_extern && buf_len(fn_node->lib_name) > 0) {
16143	fn_def_fields[6].data.x_maybe = create_const_vals(1);	16303	fn_def_fields[6].data.x_optional = create_const_vals(1);
16144	ConstExprValue *lib_name = create_const_str_lit(ira->codegen, fn_node->lib_name);	16304	ConstExprValue *lib_name = create_const_str_lit(ira->codegen, fn_node->lib_name);
16145	init_const_slice(ira->codegen, fn_def_fields[6].data.x_maybe, lib_name, 0, buf_len(fn_node->lib_name), true);	16305	init_const_slice(ira->codegen, fn_def_fields[6].data.x_optional, lib_name, 0, buf_len(fn_node->lib_name), true);
		16306	} else {
		16307	fn_def_fields[6].data.x_optional = nullptr;
16146	}	16308	}
16147	else
16148	fn_def_fields[6].data.x_maybe = nullptr;
16149	// return_type: type	16309	// return_type: type
16150	ensure_field_index(fn_def_val->type, "return_type", 7);	16310	ensure_field_index(fn_def_val->type, "return_type", 7);
16151	fn_def_fields[7].special = ConstValSpecialStatic;	16311	fn_def_fields[7].special = ConstValSpecialStatic;
...	@@ -16213,8 +16373,7 @@ static bool ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Scop	...	@@ -16213,8 +16373,7 @@ static bool ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, Scop
16213	return true;	16373	return true;
16214	}	16374	}
16215		16375
16216	static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *type_entry)	16376	static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *type_entry) {
16217	{
16218	assert(type_entry != nullptr);	16377	assert(type_entry != nullptr);
16219	assert(!type_is_invalid(type_entry));	16378	assert(!type_is_invalid(type_entry));
16220		16379
...	@@ -16239,38 +16398,67 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16239,38 +16398,67 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16239	enum_field_val->data.x_struct.fields = inner_fields;	16398	enum_field_val->data.x_struct.fields = inner_fields;
16240	};	16399	};
16241		16400
16242	const auto create_ptr_like_type_info = [ira](const char name, TypeTableEntry ptr_type_entry) {	16401	const auto create_ptr_like_type_info = [ira](TypeTableEntry *ptr_type_entry) {
		16402	TypeTableEntry *attrs_type;
		16403	uint32_t size_enum_index;
		16404	if (is_slice(ptr_type_entry)) {
		16405	attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
		16406	size_enum_index = 2;
		16407	} else if (ptr_type_entry->id == TypeTableEntryIdPointer) {
		16408	attrs_type = ptr_type_entry;
		16409	size_enum_index = (ptr_type_entry->data.pointer.ptr_len == PtrLenSingle) ? 0 : 1;
		16410	} else {
		16411	zig_unreachable();
		16412	}
		16413
		16414	TypeTableEntry *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer");
		16415	ensure_complete_type(ira->codegen, type_info_pointer_type);
		16416	assert(!type_is_invalid(type_info_pointer_type));
		16417
16243	ConstExprValue *result = create_const_vals(1);	16418	ConstExprValue *result = create_const_vals(1);
16244	result->special = ConstValSpecialStatic;	16419	result->special = ConstValSpecialStatic;
16245	result->type = ir_type_info_get_type(ira, name);	16420	result->type = type_info_pointer_type;
16246		16421
16247	ConstExprValue *fields = create_const_vals(4);	16422	ConstExprValue *fields = create_const_vals(5);
16248	result->data.x_struct.fields = fields;	16423	result->data.x_struct.fields = fields;
16249		16424
16250	// is_const: bool	16425	// size: Size
16251	ensure_field_index(result->type, "is_const", 0);	16426	ensure_field_index(result->type, "size", 0);
		16427	TypeTableEntry *type_info_pointer_size_type = ir_type_info_get_type(ira, "Size", type_info_pointer_type);
		16428	ensure_complete_type(ira->codegen, type_info_pointer_size_type);
		16429	assert(!type_is_invalid(type_info_pointer_size_type));
16252	fields[0].special = ConstValSpecialStatic;	16430	fields[0].special = ConstValSpecialStatic;
16253	fields[0].type = ira->codegen->builtin_types.entry_bool;	16431	fields[0].type = type_info_pointer_size_type;
16254	fields[0].data.x_bool = ptr_type_entry->data.pointer.is_const;	16432	bigint_init_unsigned(&fields[0].data.x_enum_tag, size_enum_index);
16255	// is_volatile: bool	16433
16256	ensure_field_index(result->type, "is_volatile", 1);	16434	// is_const: bool
		16435	ensure_field_index(result->type, "is_const", 1);
16257	fields[1].special = ConstValSpecialStatic;	16436	fields[1].special = ConstValSpecialStatic;
16258	fields[1].type = ira->codegen->builtin_types.entry_bool;	16437	fields[1].type = ira->codegen->builtin_types.entry_bool;
16259	fields[1].data.x_bool = ptr_type_entry->data.pointer.is_volatile;	16438	fields[1].data.x_bool = attrs_type->data.pointer.is_const;
16260	// alignment: u32	16439	// is_volatile: bool
16261	ensure_field_index(result->type, "alignment", 2);	16440	ensure_field_index(result->type, "is_volatile", 2);
16262	fields[2].special = ConstValSpecialStatic;	16441	fields[2].special = ConstValSpecialStatic;
16263	fields[2].type = ira->codegen->builtin_types.entry_u32;	16442	fields[2].type = ira->codegen->builtin_types.entry_bool;
16264	bigint_init_unsigned(&fields[2].data.x_bigint, ptr_type_entry->data.pointer.alignment);	16443	fields[2].data.x_bool = attrs_type->data.pointer.is_volatile;
16265	// child: type	16444	// alignment: u32
16266	ensure_field_index(result->type, "child", 3);	16445	ensure_field_index(result->type, "alignment", 3);
16267	fields[3].special = ConstValSpecialStatic;	16446	fields[3].special = ConstValSpecialStatic;
16268	fields[3].type = ira->codegen->builtin_types.entry_type;	16447	fields[3].type = ira->codegen->builtin_types.entry_u32;
16269	fields[3].data.x_type = ptr_type_entry->data.pointer.child_type;	16448	bigint_init_unsigned(&fields[3].data.x_bigint, attrs_type->data.pointer.alignment);
		16449	// child: type
		16450	ensure_field_index(result->type, "child", 4);
		16451	fields[4].special = ConstValSpecialStatic;
		16452	fields[4].type = ira->codegen->builtin_types.entry_type;
		16453	fields[4].data.x_type = attrs_type->data.pointer.child_type;
16270		16454
16271	return result;	16455	return result;
16272	};	16456	};
16273		16457
		16458	if (type_entry == ira->codegen->builtin_types.entry_global_error_set) {
		16459	zig_panic("TODO implement @typeInfo for global error set");
		16460	}
		16461
16274	ConstExprValue *result = nullptr;	16462	ConstExprValue *result = nullptr;
16275	switch (type_entry->id)	16463	switch (type_entry->id)
16276	{	16464	{
...	@@ -16339,7 +16527,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16339,7 +16527,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16339	}	16527	}
16340	case TypeTableEntryIdPointer:	16528	case TypeTableEntryIdPointer:
16341	{	16529	{
16342	result = create_ptr_like_type_info("Pointer", type_entry);	16530	result = create_ptr_like_type_info(type_entry);
16343	break;	16531	break;
16344	}	16532	}
16345	case TypeTableEntryIdArray:	16533	case TypeTableEntryIdArray:
...	@@ -16364,11 +16552,11 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16364,11 +16552,11 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16364		16552
16365	break;	16553	break;
16366	}	16554	}
16367	case TypeTableEntryIdMaybe:	16555	case TypeTableEntryIdOptional:
16368	{	16556	{
16369	result = create_const_vals(1);	16557	result = create_const_vals(1);
16370	result->special = ConstValSpecialStatic;	16558	result->special = ConstValSpecialStatic;
16371	result->type = ir_type_info_get_type(ira, "Nullable");	16559	result->type = ir_type_info_get_type(ira, "Optional");
16372		16560
16373	ConstExprValue *fields = create_const_vals(1);	16561	ConstExprValue *fields = create_const_vals(1);
16374	result->data.x_struct.fields = fields;	16562	result->data.x_struct.fields = fields;
...	@@ -16570,8 +16758,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16570,8 +16758,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16570		16758
16571	TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");	16759	TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
16572		16760
16573	for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++)	16761	for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++) {
16574	{
16575	TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];	16762	TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
16576	ConstExprValue *union_field_val = &union_field_array->data.x_array.s_none.elements[union_field_index];	16763	ConstExprValue *union_field_val = &union_field_array->data.x_array.s_none.elements[union_field_index];
16577		16764
...	@@ -16582,12 +16769,11 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16582,12 +16769,11 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16582	inner_fields[1].special = ConstValSpecialStatic;	16769	inner_fields[1].special = ConstValSpecialStatic;
16583	inner_fields[1].type = get_maybe_type(ira->codegen, type_info_enum_field_type);	16770	inner_fields[1].type = get_maybe_type(ira->codegen, type_info_enum_field_type);
16584		16771
16585	if (fields[1].data.x_type == ira->codegen->builtin_types.entry_undef)	16772	if (fields[1].data.x_type == ira->codegen->builtin_types.entry_undef) {
16586	inner_fields[1].data.x_maybe = nullptr;	16773	inner_fields[1].data.x_optional = nullptr;
16587	else	16774	} else {
16588	{	16775	inner_fields[1].data.x_optional = create_const_vals(1);
16589	inner_fields[1].data.x_maybe = create_const_vals(1);	16776	make_enum_field_val(inner_fields[1].data.x_optional, union_field->enum_field, type_info_enum_field_type);
16590	make_enum_field_val(inner_fields[1].data.x_maybe, union_field->enum_field, type_info_enum_field_type);
16591	}	16777	}
16592		16778
16593	inner_fields[2].special = ConstValSpecialStatic;	16779	inner_fields[2].special = ConstValSpecialStatic;
...	@@ -16612,15 +16798,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16612,15 +16798,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16612	case TypeTableEntryIdStruct:	16798	case TypeTableEntryIdStruct:
16613	{	16799	{
16614	if (type_entry->data.structure.is_slice) {	16800	if (type_entry->data.structure.is_slice) {
16615	Buf ptr_field_name = BUF_INIT;	16801	result = create_ptr_like_type_info(type_entry);
16616	buf_init_from_str(&ptr_field_name, "ptr");
16617	TypeTableEntry *ptr_type = type_entry->data.structure.fields_by_name.get(&ptr_field_name)->type_entry;
16618	ensure_complete_type(ira->codegen, ptr_type);
16619	if (type_is_invalid(ptr_type))
16620	return nullptr;
16621	buf_deinit(&ptr_field_name);
16622
16623	result = create_ptr_like_type_info("Slice", ptr_type);
16624	break;	16802	break;
16625	}	16803	}
16626		16804
...	@@ -16651,8 +16829,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16651,8 +16829,7 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16651		16829
16652	init_const_slice(ira->codegen, &fields[1], struct_field_array, 0, struct_field_count, false);	16830	init_const_slice(ira->codegen, &fields[1], struct_field_array, 0, struct_field_count, false);
16653		16831
16654	for (uint32_t struct_field_index = 0; struct_field_index < struct_field_count; struct_field_index++)	16832	for (uint32_t struct_field_index = 0; struct_field_index < struct_field_count; struct_field_index++) {
16655	{
16656	TypeStructField *struct_field = &type_entry->data.structure.fields[struct_field_index];	16833	TypeStructField *struct_field = &type_entry->data.structure.fields[struct_field_index];
16657	ConstExprValue *struct_field_val = &struct_field_array->data.x_array.s_none.elements[struct_field_index];	16834	ConstExprValue *struct_field_val = &struct_field_array->data.x_array.s_none.elements[struct_field_index];
16658		16835
...	@@ -16663,15 +16840,14 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t	...	@@ -16663,15 +16840,14 @@ static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *t
16663	inner_fields[1].special = ConstValSpecialStatic;	16840	inner_fields[1].special = ConstValSpecialStatic;
16664	inner_fields[1].type = get_maybe_type(ira->codegen, ira->codegen->builtin_types.entry_usize);	16841	inner_fields[1].type = get_maybe_type(ira->codegen, ira->codegen->builtin_types.entry_usize);
16665		16842
16666	if (!type_has_bits(struct_field->type_entry))	16843	if (!type_has_bits(struct_field->type_entry)) {
16667	inner_fields[1].data.x_maybe = nullptr;	16844	inner_fields[1].data.x_optional = nullptr;
16668	else	16845	} else {
16669	{
16670	size_t byte_offset = LLVMOffsetOfElement(ira->codegen->target_data_ref, type_entry->type_ref, struct_field->gen_index);	16846	size_t byte_offset = LLVMOffsetOfElement(ira->codegen->target_data_ref, type_entry->type_ref, struct_field->gen_index);
16671	inner_fields[1].data.x_maybe = create_const_vals(1);	16847	inner_fields[1].data.x_optional = create_const_vals(1);
16672	inner_fields[1].data.x_maybe->special = ConstValSpecialStatic;	16848	inner_fields[1].data.x_optional->special = ConstValSpecialStatic;
16673	inner_fields[1].data.x_maybe->type = ira->codegen->builtin_types.entry_usize;	16849	inner_fields[1].data.x_optional->type = ira->codegen->builtin_types.entry_usize;
16674	bigint_init_unsigned(&inner_fields[1].data.x_maybe->data.x_bigint, byte_offset);	16850	bigint_init_unsigned(&inner_fields[1].data.x_optional->data.x_bigint, byte_offset);
16675	}	16851	}
16676		16852
16677	inner_fields[2].special = ConstValSpecialStatic;	16853	inner_fields[2].special = ConstValSpecialStatic;
...	@@ -17896,7 +18072,7 @@ static TypeTableEntry ir_analyze_instruction_align_of(IrAnalyze ira, IrInstruc	...	@@ -17896,7 +18072,7 @@ static TypeTableEntry ir_analyze_instruction_align_of(IrAnalyze ira, IrInstruc
17896	case TypeTableEntryIdPromise:	18072	case TypeTableEntryIdPromise:
17897	case TypeTableEntryIdArray:	18073	case TypeTableEntryIdArray:
17898	case TypeTableEntryIdStruct:	18074	case TypeTableEntryIdStruct:
17899	case TypeTableEntryIdMaybe:	18075	case TypeTableEntryIdOptional:
17900	case TypeTableEntryIdErrorUnion:	18076	case TypeTableEntryIdErrorUnion:
17901	case TypeTableEntryIdErrorSet:	18077	case TypeTableEntryIdErrorSet:
17902	case TypeTableEntryIdEnum:	18078	case TypeTableEntryIdEnum:
...	@@ -18422,30 +18598,6 @@ static TypeTableEntry *ir_analyze_instruction_check_statement_is_void(IrAnalyze	...	@@ -18422,30 +18598,6 @@ static TypeTableEntry *ir_analyze_instruction_check_statement_is_void(IrAnalyze
18422	return ira->codegen->builtin_types.entry_void;	18598	return ira->codegen->builtin_types.entry_void;
18423	}	18599	}
18424		18600
18425	static TypeTableEntry ir_analyze_instruction_can_implicit_cast(IrAnalyze ira,
18426	IrInstructionCanImplicitCast *instruction)
18427	{
18428	IrInstruction *type_value = instruction->type_value->other;
18429	TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
18430	if (type_is_invalid(type_entry))
18431	return ira->codegen->builtin_types.entry_invalid;
18432
18433	IrInstruction *target_value = instruction->target_value->other;
18434	if (type_is_invalid(target_value->value.type))
18435	return ira->codegen->builtin_types.entry_invalid;
18436
18437	ImplicitCastMatchResult result = ir_types_match_with_implicit_cast(ira, type_entry, target_value->value.type,
18438	target_value);
18439
18440	if (result == ImplicitCastMatchResultReportedError) {
18441	zig_panic("TODO refactor implicit cast tester to return bool without reporting errors");
18442	}
18443
18444	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18445	out_val->data.x_bool = (result == ImplicitCastMatchResultYes);
18446	return ira->codegen->builtin_types.entry_bool;
18447	}
18448
18449	static TypeTableEntry ir_analyze_instruction_panic(IrAnalyze ira, IrInstructionPanic *instruction) {	18601	static TypeTableEntry ir_analyze_instruction_panic(IrAnalyze ira, IrInstructionPanic *instruction) {
18450	IrInstruction *msg = instruction->msg->other;	18602	IrInstruction *msg = instruction->msg->other;
18451	if (type_is_invalid(msg->value.type))	18603	if (type_is_invalid(msg->value.type))
...	@@ -18484,7 +18636,7 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3	...	@@ -18484,7 +18636,7 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
18484	old_align_bytes = fn_type_id.alignment;	18636	old_align_bytes = fn_type_id.alignment;
18485	fn_type_id.alignment = align_bytes;	18637	fn_type_id.alignment = align_bytes;
18486	result_type = get_fn_type(ira->codegen, &fn_type_id);	18638	result_type = get_fn_type(ira->codegen, &fn_type_id);
18487	} else if (target_type->id == TypeTableEntryIdMaybe &&	18639	} else if (target_type->id == TypeTableEntryIdOptional &&
18488	target_type->data.maybe.child_type->id == TypeTableEntryIdPointer)	18640	target_type->data.maybe.child_type->id == TypeTableEntryIdPointer)
18489	{	18641	{
18490	TypeTableEntry *ptr_type = target_type->data.maybe.child_type;	18642	TypeTableEntry *ptr_type = target_type->data.maybe.child_type;
...	@@ -18492,7 +18644,7 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3	...	@@ -18492,7 +18644,7 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
18492	TypeTableEntry *better_ptr_type = adjust_ptr_align(ira->codegen, ptr_type, align_bytes);	18644	TypeTableEntry *better_ptr_type = adjust_ptr_align(ira->codegen, ptr_type, align_bytes);
18493		18645
18494	result_type = get_maybe_type(ira->codegen, better_ptr_type);	18646	result_type = get_maybe_type(ira->codegen, better_ptr_type);
18495	} else if (target_type->id == TypeTableEntryIdMaybe &&	18647	} else if (target_type->id == TypeTableEntryIdOptional &&
18496	target_type->data.maybe.child_type->id == TypeTableEntryIdFn)	18648	target_type->data.maybe.child_type->id == TypeTableEntryIdFn)
18497	{	18649	{
18498	FnTypeId fn_type_id = target_type->data.maybe.child_type->data.fn.fn_type_id;	18650	FnTypeId fn_type_id = target_type->data.maybe.child_type->data.fn.fn_type_id;
...	@@ -18650,7 +18802,7 @@ static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue	...	@@ -18650,7 +18802,7 @@ static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
18650	return;	18802	return;
18651	case TypeTableEntryIdStruct:	18803	case TypeTableEntryIdStruct:
18652	zig_panic("TODO buf_write_value_bytes struct type");	18804	zig_panic("TODO buf_write_value_bytes struct type");
18653	case TypeTableEntryIdMaybe:	18805	case TypeTableEntryIdOptional:
18654	zig_panic("TODO buf_write_value_bytes maybe type");	18806	zig_panic("TODO buf_write_value_bytes maybe type");
18655	case TypeTableEntryIdErrorUnion:	18807	case TypeTableEntryIdErrorUnion:
18656	zig_panic("TODO buf_write_value_bytes error union");	18808	zig_panic("TODO buf_write_value_bytes error union");
...	@@ -18708,7 +18860,7 @@ static void buf_read_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue	...	@@ -18708,7 +18860,7 @@ static void buf_read_value_bytes(CodeGen codegen, uint8_t buf, ConstExprValue
18708	zig_panic("TODO buf_read_value_bytes array type");	18860	zig_panic("TODO buf_read_value_bytes array type");
18709	case TypeTableEntryIdStruct:	18861	case TypeTableEntryIdStruct:
18710	zig_panic("TODO buf_read_value_bytes struct type");	18862	zig_panic("TODO buf_read_value_bytes struct type");
18711	case TypeTableEntryIdMaybe:	18863	case TypeTableEntryIdOptional:
18712	zig_panic("TODO buf_read_value_bytes maybe type");	18864	zig_panic("TODO buf_read_value_bytes maybe type");
18713	case TypeTableEntryIdErrorUnion:	18865	case TypeTableEntryIdErrorUnion:
18714	zig_panic("TODO buf_read_value_bytes error union");	18866	zig_panic("TODO buf_read_value_bytes error union");
...	@@ -18946,9 +19098,6 @@ static TypeTableEntry ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstr	...	@@ -18946,9 +19098,6 @@ static TypeTableEntry ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstr
18946	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);	19098	ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
18947	if (!val)	19099	if (!val)
18948	return ira->codegen->builtin_types.entry_invalid;	19100	return ira->codegen->builtin_types.entry_invalid;
18949	if (target->value.type->id == TypeTableEntryIdMaybe) {
18950	val = val->data.x_maybe;
18951	}
18952	if (val->type->id == TypeTableEntryIdPointer && val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {	19101	if (val->type->id == TypeTableEntryIdPointer && val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
18953	IrInstruction *result = ir_create_const(&ira->new_irb, instruction->base.scope,	19102	IrInstruction *result = ir_create_const(&ira->new_irb, instruction->base.scope,
18954	instruction->base.source_node, usize);	19103	instruction->base.source_node, usize);
...	@@ -18973,6 +19122,9 @@ static TypeTableEntry ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstruc	...	@@ -18973,6 +19122,9 @@ static TypeTableEntry ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstruc
18973	if (child_type->id == TypeTableEntryIdUnreachable) {	19122	if (child_type->id == TypeTableEntryIdUnreachable) {
18974	ir_add_error(ira, &instruction->base, buf_sprintf("pointer to noreturn not allowed"));	19123	ir_add_error(ira, &instruction->base, buf_sprintf("pointer to noreturn not allowed"));
18975	return ira->codegen->builtin_types.entry_invalid;	19124	return ira->codegen->builtin_types.entry_invalid;
		19125	} else if (child_type->id == TypeTableEntryIdOpaque && instruction->ptr_len == PtrLenUnknown) {
		19126	ir_add_error(ira, &instruction->base, buf_sprintf("unknown-length pointer to opaque"));
		19127	return ira->codegen->builtin_types.entry_invalid;
18976	}	19128	}
18977		19129
18978	uint32_t align_bytes;	19130	uint32_t align_bytes;
...	@@ -19624,7 +19776,7 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi	...	@@ -19624,7 +19776,7 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
19624	case IrInstructionIdUnionInit:	19776	case IrInstructionIdUnionInit:
19625	case IrInstructionIdStructFieldPtr:	19777	case IrInstructionIdStructFieldPtr:
19626	case IrInstructionIdUnionFieldPtr:	19778	case IrInstructionIdUnionFieldPtr:
19627	case IrInstructionIdMaybeWrap:	19779	case IrInstructionIdOptionalWrap:
19628	case IrInstructionIdErrWrapCode:	19780	case IrInstructionIdErrWrapCode:
19629	case IrInstructionIdErrWrapPayload:	19781	case IrInstructionIdErrWrapPayload:
19630	case IrInstructionIdCast:	19782	case IrInstructionIdCast:
...	@@ -19684,8 +19836,8 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi	...	@@ -19684,8 +19836,8 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
19684	return ir_analyze_instruction_size_of(ira, (IrInstructionSizeOf *)instruction);	19836	return ir_analyze_instruction_size_of(ira, (IrInstructionSizeOf *)instruction);
19685	case IrInstructionIdTestNonNull:	19837	case IrInstructionIdTestNonNull:
19686	return ir_analyze_instruction_test_non_null(ira, (IrInstructionTestNonNull *)instruction);	19838	return ir_analyze_instruction_test_non_null(ira, (IrInstructionTestNonNull *)instruction);
19687	case IrInstructionIdUnwrapMaybe:	19839	case IrInstructionIdUnwrapOptional:
19688	return ir_analyze_instruction_unwrap_maybe(ira, (IrInstructionUnwrapMaybe *)instruction);	19840	return ir_analyze_instruction_unwrap_maybe(ira, (IrInstructionUnwrapOptional *)instruction);
19689	case IrInstructionIdClz:	19841	case IrInstructionIdClz:
19690	return ir_analyze_instruction_clz(ira, (IrInstructionClz *)instruction);	19842	return ir_analyze_instruction_clz(ira, (IrInstructionClz *)instruction);
19691	case IrInstructionIdCtz:	19843	case IrInstructionIdCtz:
...	@@ -19776,8 +19928,6 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi	...	@@ -19776,8 +19928,6 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
19776	return ir_analyze_instruction_check_switch_prongs(ira, (IrInstructionCheckSwitchProngs *)instruction);	19928	return ir_analyze_instruction_check_switch_prongs(ira, (IrInstructionCheckSwitchProngs *)instruction);
19777	case IrInstructionIdCheckStatementIsVoid:	19929	case IrInstructionIdCheckStatementIsVoid:
19778	return ir_analyze_instruction_check_statement_is_void(ira, (IrInstructionCheckStatementIsVoid *)instruction);	19930	return ir_analyze_instruction_check_statement_is_void(ira, (IrInstructionCheckStatementIsVoid *)instruction);
19779	case IrInstructionIdCanImplicitCast:
19780	return ir_analyze_instruction_can_implicit_cast(ira, (IrInstructionCanImplicitCast *)instruction);
19781	case IrInstructionIdDeclRef:	19931	case IrInstructionIdDeclRef:
19782	return ir_analyze_instruction_decl_ref(ira, (IrInstructionDeclRef *)instruction);	19932	return ir_analyze_instruction_decl_ref(ira, (IrInstructionDeclRef *)instruction);
19783	case IrInstructionIdPanic:	19933	case IrInstructionIdPanic:
...	@@ -19873,6 +20023,7 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi	...	@@ -19873,6 +20023,7 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
19873	static TypeTableEntry ir_analyze_instruction(IrAnalyze ira, IrInstruction *instruction) {	20023	static TypeTableEntry ir_analyze_instruction(IrAnalyze ira, IrInstruction *instruction) {
19874	TypeTableEntry *instruction_type = ir_analyze_instruction_nocast(ira, instruction);	20024	TypeTableEntry *instruction_type = ir_analyze_instruction_nocast(ira, instruction);
19875	instruction->value.type = instruction_type;	20025	instruction->value.type = instruction_type;
		20026
19876	if (instruction->other) {	20027	if (instruction->other) {
19877	instruction->other->value.type = instruction_type;	20028	instruction->other->value.type = instruction_type;
19878	} else {	20029	} else {
...	@@ -20022,7 +20173,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {	...	@@ -20022,7 +20173,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
20022	case IrInstructionIdSliceType:	20173	case IrInstructionIdSliceType:
20023	case IrInstructionIdSizeOf:	20174	case IrInstructionIdSizeOf:
20024	case IrInstructionIdTestNonNull:	20175	case IrInstructionIdTestNonNull:
20025	case IrInstructionIdUnwrapMaybe:	20176	case IrInstructionIdUnwrapOptional:
20026	case IrInstructionIdClz:	20177	case IrInstructionIdClz:
20027	case IrInstructionIdCtz:	20178	case IrInstructionIdCtz:
20028	case IrInstructionIdSwitchVar:	20179	case IrInstructionIdSwitchVar:
...	@@ -20044,7 +20195,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {	...	@@ -20044,7 +20195,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
20044	case IrInstructionIdFrameAddress:	20195	case IrInstructionIdFrameAddress:
20045	case IrInstructionIdTestErr:	20196	case IrInstructionIdTestErr:
20046	case IrInstructionIdUnwrapErrCode:	20197	case IrInstructionIdUnwrapErrCode:
20047	case IrInstructionIdMaybeWrap:	20198	case IrInstructionIdOptionalWrap:
20048	case IrInstructionIdErrWrapCode:	20199	case IrInstructionIdErrWrapCode:
20049	case IrInstructionIdErrWrapPayload:	20200	case IrInstructionIdErrWrapPayload:
20050	case IrInstructionIdFnProto:	20201	case IrInstructionIdFnProto:
...	@@ -20057,7 +20208,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {	...	@@ -20057,7 +20208,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {
20057	case IrInstructionIdIntToEnum:	20208	case IrInstructionIdIntToEnum:
20058	case IrInstructionIdIntToErr:	20209	case IrInstructionIdIntToErr:
20059	case IrInstructionIdErrToInt:	20210	case IrInstructionIdErrToInt:
20060	case IrInstructionIdCanImplicitCast:
20061	case IrInstructionIdDeclRef:	20211	case IrInstructionIdDeclRef:
20062	case IrInstructionIdErrName:	20212	case IrInstructionIdErrName:
20063	case IrInstructionIdTypeName:	20213	case IrInstructionIdTypeName:

src/ir_print.cpp+8-19

...	@@ -148,7 +148,7 @@ static const char *ir_un_op_id_str(IrUnOp op_id) {	...	@@ -148,7 +148,7 @@ static const char *ir_un_op_id_str(IrUnOp op_id) {
148	return "-%";	148	return "-%";
149	case IrUnOpDereference:	149	case IrUnOpDereference:
150	return "*";	150	return "*";
151	case IrUnOpMaybe:	151	case IrUnOpOptional:
152	return "?";	152	return "?";
153	}	153	}
154	zig_unreachable();	154	zig_unreachable();
...	@@ -481,7 +481,7 @@ static void ir_print_test_null(IrPrint irp, IrInstructionTestNonNull instructi	...	@@ -481,7 +481,7 @@ static void ir_print_test_null(IrPrint irp, IrInstructionTestNonNull instructi
481	fprintf(irp->f, " != null");	481	fprintf(irp->f, " != null");
482	}	482	}
483		483
484	static void ir_print_unwrap_maybe(IrPrint irp, IrInstructionUnwrapMaybe instruction) {	484	static void ir_print_unwrap_maybe(IrPrint irp, IrInstructionUnwrapOptional instruction) {
485	fprintf(irp->f, "&??*");	485	fprintf(irp->f, "&??*");
486	ir_print_other_instruction(irp, instruction->value);	486	ir_print_other_instruction(irp, instruction->value);
487	if (!instruction->safety_check_on) {	487	if (!instruction->safety_check_on) {
...	@@ -777,7 +777,7 @@ static void ir_print_unwrap_err_payload(IrPrint *irp, IrInstructionUnwrapErrPayl	...	@@ -777,7 +777,7 @@ static void ir_print_unwrap_err_payload(IrPrint *irp, IrInstructionUnwrapErrPayl
777	}	777	}
778	}	778	}
779		779
780	static void ir_print_maybe_wrap(IrPrint irp, IrInstructionMaybeWrap instruction) {	780	static void ir_print_maybe_wrap(IrPrint irp, IrInstructionOptionalWrap instruction) {
781	fprintf(irp->f, "@maybeWrap(");	781	fprintf(irp->f, "@maybeWrap(");
782	ir_print_other_instruction(irp, instruction->value);	782	ir_print_other_instruction(irp, instruction->value);
783	fprintf(irp->f, ")");	783	fprintf(irp->f, ")");
...	@@ -913,14 +913,6 @@ static void ir_print_tag_name(IrPrint irp, IrInstructionTagName instruction) {	...	@@ -913,14 +913,6 @@ static void ir_print_tag_name(IrPrint irp, IrInstructionTagName instruction) {
913	ir_print_other_instruction(irp, instruction->target);	913	ir_print_other_instruction(irp, instruction->target);
914	}	914	}
915		915
916	static void ir_print_can_implicit_cast(IrPrint irp, IrInstructionCanImplicitCast instruction) {
917	fprintf(irp->f, "@canImplicitCast(");
918	ir_print_other_instruction(irp, instruction->type_value);
919	fprintf(irp->f, ",");
920	ir_print_other_instruction(irp, instruction->target_value);
921	fprintf(irp->f, ")");
922	}
923
924	static void ir_print_ptr_type(IrPrint irp, IrInstructionPtrType instruction) {	916	static void ir_print_ptr_type(IrPrint irp, IrInstructionPtrType instruction) {
925	fprintf(irp->f, "&");	917	fprintf(irp->f, "&");
926	if (instruction->align_value != nullptr) {	918	if (instruction->align_value != nullptr) {
...	@@ -1040,7 +1032,7 @@ static void ir_print_export(IrPrint irp, IrInstructionExport instruction) {	...	@@ -1040,7 +1032,7 @@ static void ir_print_export(IrPrint irp, IrInstructionExport instruction) {
1040		1032
1041	static void ir_print_error_return_trace(IrPrint irp, IrInstructionErrorReturnTrace instruction) {	1033	static void ir_print_error_return_trace(IrPrint irp, IrInstructionErrorReturnTrace instruction) {
1042	fprintf(irp->f, "@errorReturnTrace(");	1034	fprintf(irp->f, "@errorReturnTrace(");
1043	switch (instruction->nullable) {	1035	switch (instruction->optional) {
1044	case IrInstructionErrorReturnTrace::Null:	1036	case IrInstructionErrorReturnTrace::Null:
1045	fprintf(irp->f, "Null");	1037	fprintf(irp->f, "Null");
1046	break;	1038	break;
...	@@ -1356,8 +1348,8 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {	...	@@ -1356,8 +1348,8 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1356	case IrInstructionIdTestNonNull:	1348	case IrInstructionIdTestNonNull:
1357	ir_print_test_null(irp, (IrInstructionTestNonNull *)instruction);	1349	ir_print_test_null(irp, (IrInstructionTestNonNull *)instruction);
1358	break;	1350	break;
1359	case IrInstructionIdUnwrapMaybe:	1351	case IrInstructionIdUnwrapOptional:
1360	ir_print_unwrap_maybe(irp, (IrInstructionUnwrapMaybe *)instruction);	1352	ir_print_unwrap_maybe(irp, (IrInstructionUnwrapOptional *)instruction);
1361	break;	1353	break;
1362	case IrInstructionIdCtz:	1354	case IrInstructionIdCtz:
1363	ir_print_ctz(irp, (IrInstructionCtz *)instruction);	1355	ir_print_ctz(irp, (IrInstructionCtz *)instruction);
...	@@ -1473,8 +1465,8 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {	...	@@ -1473,8 +1465,8 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1473	case IrInstructionIdUnwrapErrPayload:	1465	case IrInstructionIdUnwrapErrPayload:
1474	ir_print_unwrap_err_payload(irp, (IrInstructionUnwrapErrPayload *)instruction);	1466	ir_print_unwrap_err_payload(irp, (IrInstructionUnwrapErrPayload *)instruction);
1475	break;	1467	break;
1476	case IrInstructionIdMaybeWrap:	1468	case IrInstructionIdOptionalWrap:
1477	ir_print_maybe_wrap(irp, (IrInstructionMaybeWrap *)instruction);	1469	ir_print_maybe_wrap(irp, (IrInstructionOptionalWrap *)instruction);
1478	break;	1470	break;
1479	case IrInstructionIdErrWrapCode:	1471	case IrInstructionIdErrWrapCode:
1480	ir_print_err_wrap_code(irp, (IrInstructionErrWrapCode *)instruction);	1472	ir_print_err_wrap_code(irp, (IrInstructionErrWrapCode *)instruction);
...	@@ -1524,9 +1516,6 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {	...	@@ -1524,9 +1516,6 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1524	case IrInstructionIdTagName:	1516	case IrInstructionIdTagName:
1525	ir_print_tag_name(irp, (IrInstructionTagName *)instruction);	1517	ir_print_tag_name(irp, (IrInstructionTagName *)instruction);
1526	break;	1518	break;
1527	case IrInstructionIdCanImplicitCast:
1528	ir_print_can_implicit_cast(irp, (IrInstructionCanImplicitCast *)instruction);
1529	break;
1530	case IrInstructionIdPtrType:	1519	case IrInstructionIdPtrType:
1531	ir_print_ptr_type(irp, (IrInstructionPtrType *)instruction);	1520	ir_print_ptr_type(irp, (IrInstructionPtrType *)instruction);
1532	break;	1521	break;

src/link.cpp+14-1

...	@@ -391,6 +391,19 @@ static void construct_linker_job_elf(LinkJob *lj) {	...	@@ -391,6 +391,19 @@ static void construct_linker_job_elf(LinkJob *lj) {
391	}	391	}
392	}	392	}
393		393
		394	static void construct_linker_job_wasm(LinkJob *lj) {
		395	CodeGen *g = lj->codegen;
		396
		397	lj->args.append("--relocatable"); // So lld doesn't look for _start.
		398	lj->args.append("-o");
		399	lj->args.append(buf_ptr(&lj->out_file));
		400
		401	// .o files
		402	for (size_t i = 0; i < g->link_objects.length; i += 1) {
		403	lj->args.append((const char *)buf_ptr(g->link_objects.at(i)));
		404	}
		405	}
		406
394	//static bool is_target_cyg_mingw(const ZigTarget *target) {	407	//static bool is_target_cyg_mingw(const ZigTarget *target) {
395	// return (target->os == ZigLLVM_Win32 && target->env_type == ZigLLVM_Cygnus) \|\|	408	// return (target->os == ZigLLVM_Win32 && target->env_type == ZigLLVM_Cygnus) \|\|
396	// (target->os == ZigLLVM_Win32 && target->env_type == ZigLLVM_GNU);	409	// (target->os == ZigLLVM_Win32 && target->env_type == ZigLLVM_GNU);
...	@@ -924,7 +937,7 @@ static void construct_linker_job(LinkJob *lj) {	...	@@ -924,7 +937,7 @@ static void construct_linker_job(LinkJob *lj) {
924	case ZigLLVM_MachO:	937	case ZigLLVM_MachO:
925	return construct_linker_job_macho(lj);	938	return construct_linker_job_macho(lj);
926	case ZigLLVM_Wasm:	939	case ZigLLVM_Wasm:
927	zig_panic("TODO link wasm");	940	return construct_linker_job_wasm(lj);
928	}	941	}
929	}	942	}
930		943

src/main.cpp+15

 @@ -23,6 +23,7 @@ static int usage(const char *arg0) {
         "  build-exe [source]           create executable from source or object files\n"
         "  build-lib [source]           create library from source or object files\n"
         "  build-obj [source]           create object from source or assembly\n"
+        "  builtin                      show the source code of that @import(\"builtin\")\n"
         "  run [source]                 create executable and run immediately\n"
         "  translate-c [source]         convert c code to zig code\n"
         "  targets                      list available compilation targets\n"
 @@ -214,6 +215,7 @@ static Buf *resolve_zig_lib_dir(void) {
 enum Cmd {
     CmdInvalid,
     CmdBuild,
+    CmdBuiltin,
     CmdRun,
     CmdTest,
     CmdVersion,
 @@ -664,6 +666,8 @@ int main(int argc, char **argv) {
                 out_type = OutTypeExe;
             } else if (strcmp(arg, "targets") == 0) {
                 cmd = CmdTargets;
+            } else if (strcmp(arg, "builtin") == 0) {
+                cmd = CmdBuiltin;
             } else {
                 fprintf(stderr, "Unrecognized command: %s\n", arg);
                 return usage(arg0);
 @@ -681,6 +685,7 @@ int main(int argc, char **argv) {
                         return usage(arg0);
                     }
                     break;
+                case CmdBuiltin:
                 case CmdVersion:
                 case CmdZen:
                 case CmdTargets:
 @@ -727,6 +732,16 @@ int main(int argc, char **argv) {
     }
     switch (cmd) {
+    case CmdBuiltin: {
+        Buf *zig_lib_dir_buf = resolve_zig_lib_dir();
+        CodeGen *g = codegen_create(nullptr, target, out_type, build_mode, zig_lib_dir_buf);
+        Buf *builtin_source = codegen_generate_builtin_source(g);
+        if (fwrite(buf_ptr(builtin_source), 1, buf_len(builtin_source), stdout) != buf_len(builtin_source)) {
+            fprintf(stderr, "unable to write to stdout: %s\n", strerror(ferror(stdout)));
+            return EXIT_FAILURE;
+        }
+        return EXIT_SUCCESS;
+    }
     case CmdRun:
     case CmdBuild:
     case CmdTranslateC:

src/parser.cpp+16-8

 @@ -1046,12 +1046,11 @@ static AstNode *ast_parse_fn_proto_partial(ParseContext *pc, size_t *token_index
 }
 /*
-SuffixOpExpression = ("async" option("<" SuffixOpExpression ">") SuffixOpExpression FnCallExpression) | PrimaryExpression option(FnCallExpression | ArrayAccessExpression | FieldAccessExpression | PtrDerefExpression | SliceExpression)
+SuffixOpExpression = ("async" option("&lt;" SuffixOpExpression "&gt;") SuffixOpExpression FnCallExpression) | PrimaryExpression option(FnCallExpression | ArrayAccessExpression | FieldAccessExpression | SliceExpression | ".*" | ".?")
 FnCallExpression : token(LParen) list(Expression, token(Comma)) token(RParen)
 ArrayAccessExpression : token(LBracket) Expression token(RBracket)
 SliceExpression = "[" Expression ".." option(Expression) "]"
 FieldAccessExpression : token(Dot) token(Symbol)
-PtrDerefExpression = ".*"
 StructLiteralField : token(Dot) token(Symbol) token(Eq) Expression
 */
 static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
 @@ -1148,6 +1147,13 @@ static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, size_t *token_index,
                 AstNode *node = ast_create_node(pc, NodeTypePtrDeref, first_token);
                 node->data.ptr_deref_expr.target = primary_expr;
+                primary_expr = node;
+            } else if (token->id == TokenIdQuestion) {
+                *token_index += 1;
+                AstNode *node = ast_create_node(pc, NodeTypeUnwrapOptional, first_token);
+                node->data.unwrap_optional.expr = primary_expr;
                 primary_expr = node;
             } else {
                 ast_invalid_token_error(pc, token);
 @@ -1165,8 +1171,7 @@ static PrefixOp tok_to_prefix_op(Token *token) {
         case TokenIdDash: return PrefixOpNegation;
         case TokenIdMinusPercent: return PrefixOpNegationWrap;
         case TokenIdTilde: return PrefixOpBinNot;
-        case TokenIdMaybe: return PrefixOpMaybe;
+        case TokenIdQuestion: return PrefixOpOptional;
-        case TokenIdDoubleQuestion: return PrefixOpUnwrapMaybe;
         case TokenIdAmpersand: return PrefixOpAddrOf;
         default: return PrefixOpInvalid;
     }
 @@ -2304,8 +2309,8 @@ static BinOpType ast_parse_ass_op(ParseContext *pc, size_t *token_index, bool ma
 }
 /*
-UnwrapExpression : BoolOrExpression (UnwrapMaybe | UnwrapError) | BoolOrExpression
+UnwrapExpression : BoolOrExpression (UnwrapOptional | UnwrapError) | BoolOrExpression
-UnwrapMaybe : "??" BoolOrExpression
+UnwrapOptional = "orelse" Expression
 UnwrapError = "catch" option("|" Symbol "|") Expression
 */
 static AstNode *ast_parse_unwrap_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
 @@ -2315,14 +2320,14 @@ static AstNode *ast_parse_unwrap_expr(ParseContext *pc, size_t *token_index, boo
     Token *token = &pc->tokens->at(*token_index);
-    if (token->id == TokenIdDoubleQuestion) {
+    if (token->id == TokenIdKeywordOrElse) {
         *token_index += 1;
         AstNode *rhs = ast_parse_expression(pc, token_index, true);
         AstNode *node = ast_create_node(pc, NodeTypeBinOpExpr, token);
         node->data.bin_op_expr.op1 = lhs;
-        node->data.bin_op_expr.bin_op = BinOpTypeUnwrapMaybe;
+        node->data.bin_op_expr.bin_op = BinOpTypeUnwrapOptional;
         node->data.bin_op_expr.op2 = rhs;
         return node;
 @@ -3028,6 +3033,9 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
         case NodeTypePtrDeref:
             visit_field(&node->data.ptr_deref_expr.target, visit, context);
             break;
+        case NodeTypeUnwrapOptional:
+            visit_field(&node->data.unwrap_optional.expr, visit, context);
+            break;
         case NodeTypeUse:
             visit_field(&node->data.use.expr, visit, context);
             break;

src/target.cpp+5-2

 @@ -596,12 +596,15 @@ void resolve_target_object_format(ZigTarget *target) {
         case ZigLLVM_tce:
         case ZigLLVM_tcele:
         case ZigLLVM_thumbeb:
-        case ZigLLVM_wasm32:
-        case ZigLLVM_wasm64:
         case ZigLLVM_xcore:
             target->oformat= ZigLLVM_ELF;
             return;
+        case ZigLLVM_wasm32:
+        case ZigLLVM_wasm64:
+            target->oformat = ZigLLVM_Wasm;
+            return;
         case ZigLLVM_ppc:
         case ZigLLVM_ppc64:
             if (is_os_darwin(target)) {

src/tokenizer.cpp+7-28

 @@ -134,6 +134,7 @@ static const struct ZigKeyword zig_keywords[] = {
     {"noalias", TokenIdKeywordNoAlias},
     {"null", TokenIdKeywordNull},
     {"or", TokenIdKeywordOr},
+    {"orelse", TokenIdKeywordOrElse},
     {"packed", TokenIdKeywordPacked},
     {"promise", TokenIdKeywordPromise},
     {"pub", TokenIdKeywordPub},
 @@ -215,7 +216,6 @@ enum TokenizeState {
     TokenizeStateSawGreaterThanGreaterThan,
     TokenizeStateSawDot,
     TokenizeStateSawDotDot,
-    TokenizeStateSawQuestionMark,
     TokenizeStateSawAtSign,
     TokenizeStateCharCode,
     TokenizeStateError,
 @@ -532,6 +532,10 @@ void tokenize(Buf *buf, Tokenization *out) {
                         begin_token(&t, TokenIdComma);
                         end_token(&t);
                         break;
+                    case '?':
+                        begin_token(&t, TokenIdQuestion);
+                        end_token(&t);
+                        break;
                     case '{':
                         begin_token(&t, TokenIdLBrace);
                         end_token(&t);
 @@ -624,33 +628,10 @@ void tokenize(Buf *buf, Tokenization *out) {
                         begin_token(&t, TokenIdDot);
                         t.state = TokenizeStateSawDot;
                         break;
-                    case '?':
-                        begin_token(&t, TokenIdMaybe);
-                        t.state = TokenizeStateSawQuestionMark;
-                        break;
                     default:
                         invalid_char_error(&t, c);
                 }
                 break;
-            case TokenizeStateSawQuestionMark:
-                switch (c) {
-                    case '?':
-                        set_token_id(&t, t.cur_tok, TokenIdDoubleQuestion);
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        break;
-                    case '=':
-                        set_token_id(&t, t.cur_tok, TokenIdMaybeAssign);
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        break;
-                    default:
-                        t.pos -= 1;
-                        end_token(&t);
-                        t.state = TokenizeStateStart;
-                        continue;
-                }
-                break;
             case TokenizeStateSawDot:
                 switch (c) {
                     case '.':
 @@ -1485,7 +1466,6 @@ void tokenize(Buf *buf, Tokenization *out) {
         case TokenizeStateSawGreaterThan:
         case TokenizeStateSawGreaterThanGreaterThan:
         case TokenizeStateSawDot:
-        case TokenizeStateSawQuestionMark:
         case TokenizeStateSawAtSign:
         case TokenizeStateSawStarPercent:
         case TokenizeStateSawPlusPercent:
 @@ -1550,7 +1530,6 @@ const char * token_name(TokenId id) {
         case TokenIdDash: return "-";
         case TokenIdDivEq: return "/=";
         case TokenIdDot: return ".";
-        case TokenIdDoubleQuestion: return "??";
         case TokenIdEllipsis2: return "..";
         case TokenIdEllipsis3: return "...";
         case TokenIdEof: return "EOF";
 @@ -1587,6 +1566,7 @@ const char * token_name(TokenId id) {
         case TokenIdKeywordNoAlias: return "noalias";
         case TokenIdKeywordNull: return "null";
         case TokenIdKeywordOr: return "or";
+        case TokenIdKeywordOrElse: return "orelse";
         case TokenIdKeywordPacked: return "packed";
         case TokenIdKeywordPromise: return "promise";
         case TokenIdKeywordPub: return "pub";
 @@ -1609,8 +1589,7 @@ const char * token_name(TokenId id) {
         case TokenIdLBrace: return "{";
         case TokenIdLBracket: return "[";
         case TokenIdLParen: return "(";
-        case TokenIdMaybe: return "?";
+        case TokenIdQuestion: return "?";
-        case TokenIdMaybeAssign: return "?=";
         case TokenIdMinusEq: return "-=";
         case TokenIdMinusPercent: return "-%";
         case TokenIdMinusPercentEq: return "-%=";

src/tokenizer.hpp+4-3

...	@@ -41,7 +41,6 @@ enum TokenId {	...	@@ -41,7 +41,6 @@ enum TokenId {
41	TokenIdDash,	41	TokenIdDash,
42	TokenIdDivEq,	42	TokenIdDivEq,
43	TokenIdDot,	43	TokenIdDot,
44	TokenIdDoubleQuestion,
45	TokenIdEllipsis2,	44	TokenIdEllipsis2,
46	TokenIdEllipsis3,	45	TokenIdEllipsis3,
47	TokenIdEof,	46	TokenIdEof,
...	@@ -76,6 +75,7 @@ enum TokenId {	...	@@ -76,6 +75,7 @@ enum TokenId {
76	TokenIdKeywordNoAlias,	75	TokenIdKeywordNoAlias,
77	TokenIdKeywordNull,	76	TokenIdKeywordNull,
78	TokenIdKeywordOr,	77	TokenIdKeywordOr,
		78	TokenIdKeywordOrElse,
79	TokenIdKeywordPacked,	79	TokenIdKeywordPacked,
80	TokenIdKeywordPromise,	80	TokenIdKeywordPromise,
81	TokenIdKeywordPub,	81	TokenIdKeywordPub,
...	@@ -100,8 +100,7 @@ enum TokenId {	...	@@ -100,8 +100,7 @@ enum TokenId {
100	TokenIdLBrace,	100	TokenIdLBrace,
101	TokenIdLBracket,	101	TokenIdLBracket,
102	TokenIdLParen,	102	TokenIdLParen,
103	TokenIdMaybe,	103	TokenIdQuestion,
104	TokenIdMaybeAssign,
105	TokenIdMinusEq,	104	TokenIdMinusEq,
106	TokenIdMinusPercent,	105	TokenIdMinusPercent,
107	TokenIdMinusPercentEq,	106	TokenIdMinusPercentEq,
...	@@ -170,6 +169,8 @@ struct Token {	...	@@ -170,6 +169,8 @@ struct Token {
170	TokenCharLit char_lit;	169	TokenCharLit char_lit;
171	} data;	170	} data;
172	};	171	};
		172	// work around conflicting name Token which is also found in libclang
		173	typedef Token ZigToken;
173		174
174	struct Tokenization {	175	struct Tokenization {
175	ZigList<Token> *tokens;	176	ZigList<Token> *tokens;

src/translate_c.cpp+45-14

 @@ -260,6 +260,12 @@ static AstNode *trans_create_node_prefix_op(Context *c, PrefixOp op, AstNode *ch
     return node;
 }
+static AstNode *trans_create_node_unwrap_null(Context *c, AstNode *child_node) {
+    AstNode *node = trans_create_node(c, NodeTypeUnwrapOptional);
+    node->data.unwrap_optional.expr = child_node;
+    return node;
+}
 static AstNode *trans_create_node_bin_op(Context *c, AstNode *lhs_node, BinOpType op, AstNode *rhs_node) {
     AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
     node->data.bin_op_expr.op1 = lhs_node;
 @@ -276,8 +282,11 @@ static AstNode *maybe_suppress_result(Context *c, ResultUsed result_used, AstNod
         node);
 }
-static AstNode *trans_create_node_ptr_type(Context *c, bool is_const, bool is_volatile, AstNode *child_node) {
+static AstNode *trans_create_node_ptr_type(Context *c, bool is_const, bool is_volatile, AstNode *child_node, PtrLen ptr_len) {
     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 == PtrLenSingle) ? TokenIdStar: TokenIdBracketStarBracket;
+    node->data.pointer_type.is_const = is_const;
     node->data.pointer_type.is_const = is_const;
     node->data.pointer_type.is_volatile = is_volatile;
     node->data.pointer_type.op_expr = child_node;
 @@ -379,7 +388,7 @@ static AstNode *trans_create_node_inline_fn(Context *c, Buf *fn_name, AstNode *r
     fn_def->data.fn_def.fn_proto = fn_proto;
     fn_proto->data.fn_proto.fn_def_node = fn_def;
-    AstNode *unwrap_node = trans_create_node_prefix_op(c, PrefixOpUnwrapMaybe, ref_node);
+    AstNode *unwrap_node = trans_create_node_unwrap_null(c, ref_node);
     AstNode *fn_call_node = trans_create_node(c, NodeTypeFnCallExpr);
     fn_call_node->data.fn_call_expr.fn_ref_expr = unwrap_node;
 @@ -406,10 +415,6 @@ static AstNode *trans_create_node_inline_fn(Context *c, Buf *fn_name, AstNode *r
     return fn_def;
 }
-static AstNode *trans_create_node_unwrap_null(Context *c, AstNode *child) {
-    return trans_create_node_prefix_op(c, PrefixOpUnwrapMaybe, child);
-}
 static AstNode *get_global(Context *c, Buf *name) {
     {
         auto entry = c->global_table.maybe_get(name);
 @@ -731,6 +736,30 @@ static bool qual_type_has_wrapping_overflow(Context *c, QualType qt) {
     }
 }
+static bool type_is_opaque(Context *c, const Type *ty, const SourceLocation &source_loc) {
+    switch (ty->getTypeClass()) {
+        case Type::Builtin: {
+            const BuiltinType *builtin_ty = static_cast<const BuiltinType*>(ty);
+            return builtin_ty->getKind() == BuiltinType::Void;
+        }
+        case Type::Record: {
+            const RecordType *record_ty = static_cast<const RecordType*>(ty);
+            return record_ty->getDecl()->getDefinition() == nullptr;
+        }
+        case Type::Elaborated: {
+            const ElaboratedType *elaborated_ty = static_cast<const ElaboratedType*>(ty);
+            return type_is_opaque(c, elaborated_ty->getNamedType().getTypePtr(), source_loc);
+        }
+        case Type::Typedef: {
+            const TypedefType *typedef_ty = static_cast<const TypedefType*>(ty);
+            const TypedefNameDecl *typedef_decl = typedef_ty->getDecl();
+            return type_is_opaque(c, typedef_decl->getUnderlyingType().getTypePtr(), source_loc);
+        }
+        default:
+            return false;
+    }
+}
 static AstNode *trans_type(Context *c, const Type *ty, const SourceLocation &source_loc) {
     switch (ty->getTypeClass()) {
         case Type::Builtin:
 @@ -859,12 +888,14 @@ static AstNode *trans_type(Context *c, const Type *ty, const SourceLocation &sou
                 }
                 if (qual_type_child_is_fn_proto(child_qt)) {
-                    return trans_create_node_prefix_op(c, PrefixOpMaybe, child_node);
+                    return trans_create_node_prefix_op(c, PrefixOpOptional, child_node);
                 }
+                PtrLen ptr_len = type_is_opaque(c, child_qt.getTypePtr(), source_loc) ? PtrLenSingle : PtrLenUnknown;
                 AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(),
-                        child_qt.isVolatileQualified(), child_node);
+                        child_qt.isVolatileQualified(), child_node, ptr_len);
-                return trans_create_node_prefix_op(c, PrefixOpMaybe, pointer_node);
+                return trans_create_node_prefix_op(c, PrefixOpOptional, pointer_node);
             }
         case Type::Typedef:
             {
 @@ -1048,7 +1079,7 @@ static AstNode *trans_type(Context *c, const Type *ty, const SourceLocation &sou
                     return nullptr;
                 }
                 AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(),
-                        child_qt.isVolatileQualified(), child_type_node);
+                        child_qt.isVolatileQualified(), child_type_node, PtrLenUnknown);
                 return pointer_node;
             }
         case Type::BlockPointer:
 @@ -1941,7 +1972,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
                 bool is_fn_ptr = qual_type_is_fn_ptr(stmt->getSubExpr()->getType());
                 if (is_fn_ptr)
                     return value_node;
-                AstNode *unwrapped = trans_create_node_prefix_op(c, PrefixOpUnwrapMaybe, value_node);
+                AstNode *unwrapped = trans_create_node_unwrap_null(c, value_node);
                 return trans_create_node_ptr_deref(c, unwrapped);
             }
         case UO_Plus:
 @@ -2572,7 +2603,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
             }
         }
         if (callee_node == nullptr) {
-            callee_node = trans_create_node_prefix_op(c, PrefixOpUnwrapMaybe, callee_raw_node);
+            callee_node = trans_create_node_unwrap_null(c, callee_raw_node);
         }
     } else {
         callee_node = callee_raw_node;
 @@ -4286,7 +4317,7 @@ static AstNode *trans_lookup_ast_maybe_fn(Context *c, AstNode *ref_node) {
         return nullptr;
     if (prefix_node->type != NodeTypePrefixOpExpr)
         return nullptr;
-    if (prefix_node->data.prefix_op_expr.prefix_op != PrefixOpMaybe)
+    if (prefix_node->data.prefix_op_expr.prefix_op != PrefixOpOptional)
         return nullptr;
     AstNode *fn_proto_node = prefix_node->data.prefix_op_expr.primary_expr;
 @@ -4462,7 +4493,7 @@ static AstNode *parse_ctok_suffix_op_expr(Context *c, CTokenize *ctok, size_t *t
         } else if (first_tok->id == CTokIdAsterisk) {
             *tok_i += 1;
-            node = trans_create_node_ptr_type(c, false, false, node);
+            node = trans_create_node_ptr_type(c, false, false, node, PtrLenUnknown);
         } else {
             return node;
         }

src/zig_llvm.cpp+1-1

...	@@ -853,7 +853,7 @@ bool ZigLLDLink(ZigLLVM_ObjectFormatType oformat, const char **args, size_t arg_	...	@@ -853,7 +853,7 @@ bool ZigLLDLink(ZigLLVM_ObjectFormatType oformat, const char **args, size_t arg_
853	return lld::mach_o::link(array_ref_args, diag);	853	return lld::mach_o::link(array_ref_args, diag);
854		854
855	case ZigLLVM_Wasm:	855	case ZigLLVM_Wasm:
856	assert(false); // TODO ZigLLDLink for Wasm	856	return lld::wasm::link(array_ref_args, false, diag);
857	}	857	}
858	assert(false); // unreachable	858	assert(false); // unreachable
859	abort();	859	abort();

std/array_list.zig+70-40

 @@ -1,6 +1,7 @@
 const std = @import("index.zig");
 const debug = std.debug;
 const assert = debug.assert;
+const assertError = debug.assertError;
 const mem = std.mem;
 const Allocator = mem.Allocator;
 @@ -28,20 +29,33 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
             };
         }
-        pub fn deinit(l: *const Self) void {
+        pub fn deinit(self: *const Self) void {
-            l.allocator.free(l.items);
+            self.allocator.free(self.items);
         }
-        pub fn toSlice(l: *const Self) []align(A) T {
+        pub fn toSlice(self: *const Self) []align(A) T {
-            return l.items[0..l.len];
+            return self.items[0..self.len];
         }
-        pub fn toSliceConst(l: *const Self) []align(A) const T {
+        pub fn toSliceConst(self: *const Self) []align(A) const T {
-            return l.items[0..l.len];
+            return self.items[0..self.len];
         }
-        pub fn at(l: *const Self, n: usize) T {
+        pub fn at(self: *const Self, n: usize) T {
-            return l.toSliceConst()[n];
+            return self.toSliceConst()[n];
+        }
+        /// Sets the value at index `i`, or returns `error.OutOfBounds` if
+        /// the index is not in range.
+        pub fn setOrError(self: *const Self, i: usize, item: *const T) !void {
+            if (i >= self.len) return error.OutOfBounds;
+            self.items[i] = item.*;
+        }
+        /// Sets the value at index `i`, asserting that the value is in range.
+        pub fn set(self: *const Self, i: usize, item: *const T) void {
+            assert(i < self.len);
+            self.items[i] = item.*;
         }
         pub fn count(self: *const Self) usize {
 @@ -67,58 +81,58 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
             return result;
         }
-        pub fn insert(l: *Self, n: usize, item: *const T) !void {
+        pub fn insert(self: *Self, n: usize, item: *const T) !void {
-            try l.ensureCapacity(l.len + 1);
+            try self.ensureCapacity(self.len + 1);
-            l.len += 1;
+            self.len += 1;
-            mem.copy(T, l.items[n + 1 .. l.len], l.items[n .. l.len - 1]);
+            mem.copy(T, self.items[n + 1 .. self.len], self.items[n .. self.len - 1]);
-            l.items[n] = item.*;
+            self.items[n] = item.*;
         }
-        pub fn insertSlice(l: *Self, n: usize, items: []align(A) const T) !void {
+        pub fn insertSlice(self: *Self, n: usize, items: []align(A) const T) !void {
-            try l.ensureCapacity(l.len + items.len);
+            try self.ensureCapacity(self.len + items.len);
-            l.len += items.len;
+            self.len += items.len;
-            mem.copy(T, l.items[n + items.len .. l.len], l.items[n .. l.len - items.len]);
+            mem.copy(T, self.items[n + items.len .. self.len], self.items[n .. self.len - items.len]);
-            mem.copy(T, l.items[n .. n + items.len], items);
+            mem.copy(T, self.items[n .. n + items.len], items);
         }
-        pub fn append(l: *Self, item: *const T) !void {
+        pub fn append(self: *Self, item: *const T) !void {
-            const new_item_ptr = try l.addOne();
+            const new_item_ptr = try self.addOne();
             new_item_ptr.* = item.*;
         }
-        pub fn appendSlice(l: *Self, items: []align(A) const T) !void {
+        pub fn appendSlice(self: *Self, items: []align(A) const T) !void {
-            try l.ensureCapacity(l.len + items.len);
+            try self.ensureCapacity(self.len + items.len);
-            mem.copy(T, l.items[l.len..], items);
+            mem.copy(T, self.items[self.len..], items);
-            l.len += items.len;
+            self.len += items.len;
         }
-        pub fn resize(l: *Self, new_len: usize) !void {
+        pub fn resize(self: *Self, new_len: usize) !void {
-            try l.ensureCapacity(new_len);
+            try self.ensureCapacity(new_len);
-            l.len = new_len;
+            self.len = new_len;
         }
-        pub fn shrink(l: *Self, new_len: usize) void {
+        pub fn shrink(self: *Self, new_len: usize) void {
-            assert(new_len <= l.len);
+            assert(new_len <= self.len);
-            l.len = new_len;
+            self.len = new_len;
         }
-        pub fn ensureCapacity(l: *Self, new_capacity: usize) !void {
+        pub fn ensureCapacity(self: *Self, new_capacity: usize) !void {
-            var better_capacity = l.items.len;
+            var better_capacity = self.items.len;
             if (better_capacity >= new_capacity) return;
             while (true) {
                 better_capacity += better_capacity / 2 + 8;
                 if (better_capacity >= new_capacity) break;
             }
-            l.items = try l.allocator.alignedRealloc(T, A, l.items, better_capacity);
+            self.items = try self.allocator.alignedRealloc(T, A, self.items, better_capacity);
         }
-        pub fn addOne(l: *Self) !*T {
+        pub fn addOne(self: *Self) !*T {
-            const new_length = l.len + 1;
+            const new_length = self.len + 1;
-            try l.ensureCapacity(new_length);
+            try self.ensureCapacity(new_length);
-            const result = &l.items[l.len];
+            const result = &self.items[self.len];
-            l.len = new_length;
+            self.len = new_length;
             return result;
         }
 @@ -159,9 +173,15 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
 }
 test "basic ArrayList test" {
-    var list = ArrayList(i32).init(debug.global_allocator);
+    var bytes: [1024]u8 = undefined;
+    const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
+    var list = ArrayList(i32).init(allocator);
     defer list.deinit();
+    // setting on empty list is out of bounds
+    assertError(list.setOrError(0, 1), error.OutOfBounds);
     {
         var i: usize = 0;
         while (i < 10) : (i += 1) {
 @@ -200,6 +220,16 @@ test "basic ArrayList test" {
     list.appendSlice([]const i32{}) catch unreachable;
     assert(list.len == 9);
+    // can only set on indices < self.len
+    list.set(7, 33);
+    list.set(8, 42);
+    assertError(list.setOrError(9, 99), error.OutOfBounds);
+    assertError(list.setOrError(10, 123), error.OutOfBounds);
+    assert(list.pop() == 42);
+    assert(list.pop() == 33);
 }
 test "iterator ArrayList test" {
 @@ -228,7 +258,7 @@ test "iterator ArrayList test" {
     }
     it.reset();
-    assert(??it.next() == 1);
+    assert(it.next().? == 1);
 }
 test "insert ArrayList test" {

std/atomic/queue.zig+17-8

 @@ -33,8 +33,8 @@ pub fn Queue(comptime T: type) type {
         pub fn get(self: *Self) ?*Node {
             var head = @atomicLoad(*Node, &self.head, AtomicOrder.SeqCst);
             while (true) {
-                const node = head.next ?? return null;
+                const node = head.next orelse return null;
-                head = @cmpxchgWeak(*Node, &self.head, head, node, AtomicOrder.SeqCst, AtomicOrder.SeqCst) ?? return node;
+                head = @cmpxchgWeak(*Node, &self.head, head, node, AtomicOrder.SeqCst, AtomicOrder.SeqCst) orelse return node;
             }
         }
     };
 @@ -94,8 +94,18 @@ test "std.atomic.queue" {
     for (getters) |t|
         t.wait();
-    std.debug.assert(context.put_sum == context.get_sum);
+    if (context.put_sum != context.get_sum) {
-    std.debug.assert(context.get_count == puts_per_thread * put_thread_count);
+        std.debug.panic("failure\nput_sum:{} != get_sum:{}", context.put_sum, context.get_sum);
+    }
+    if (context.get_count != puts_per_thread * put_thread_count) {
+        std.debug.panic(
+            "failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}",
+            context.get_count,
+            u32(puts_per_thread),
+            u32(put_thread_count),
+        );
+    }
 }
 fn startPuts(ctx: *Context) u8 {
 @@ -114,15 +124,14 @@ fn startPuts(ctx: *Context) u8 {
 fn startGets(ctx: *Context) u8 {
     while (true) {
+        const last = @atomicLoad(u8, &ctx.puts_done, builtin.AtomicOrder.SeqCst) == 1;
         while (ctx.queue.get()) |node| {
             std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
             _ = @atomicRmw(isize, &ctx.get_sum, builtin.AtomicRmwOp.Add, node.data, builtin.AtomicOrder.SeqCst);
             _ = @atomicRmw(usize, &ctx.get_count, builtin.AtomicRmwOp.Add, 1, builtin.AtomicOrder.SeqCst);
         }
-        if (@atomicLoad(u8, &ctx.puts_done, builtin.AtomicOrder.SeqCst) == 1) {
+        if (last) return 0;
-            break;
-        }
     }
-    return 0;
 }

std/atomic/stack.zig+17-8

 @@ -28,14 +28,14 @@ pub fn Stack(comptime T: type) type {
             var root = @atomicLoad(?*Node, &self.root, AtomicOrder.SeqCst);
             while (true) {
                 node.next = root;
-                root = @cmpxchgWeak(?*Node, &self.root, root, node, AtomicOrder.SeqCst, AtomicOrder.SeqCst) ?? break;
+                root = @cmpxchgWeak(?*Node, &self.root, root, node, AtomicOrder.SeqCst, AtomicOrder.SeqCst) orelse break;
             }
         }
         pub fn pop(self: *Self) ?*Node {
             var root = @atomicLoad(?*Node, &self.root, AtomicOrder.SeqCst);
             while (true) {
-                root = @cmpxchgWeak(?*Node, &self.root, root, (root ?? return null).next, AtomicOrder.SeqCst, AtomicOrder.SeqCst) ?? return root;
+                root = @cmpxchgWeak(?*Node, &self.root, root, (root orelse return null).next, AtomicOrder.SeqCst, AtomicOrder.SeqCst) orelse return root;
             }
         }
 @@ -97,8 +97,18 @@ test "std.atomic.stack" {
     for (getters) |t|
         t.wait();
-    std.debug.assert(context.put_sum == context.get_sum);
+    if (context.put_sum != context.get_sum) {
-    std.debug.assert(context.get_count == puts_per_thread * put_thread_count);
+        std.debug.panic("failure\nput_sum:{} != get_sum:{}", context.put_sum, context.get_sum);
+    }
+    if (context.get_count != puts_per_thread * put_thread_count) {
+        std.debug.panic(
+            "failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}",
+            context.get_count,
+            u32(puts_per_thread),
+            u32(put_thread_count),
+        );
+    }
 }
 fn startPuts(ctx: *Context) u8 {
 @@ -117,15 +127,14 @@ fn startPuts(ctx: *Context) u8 {
 fn startGets(ctx: *Context) u8 {
     while (true) {
+        const last = @atomicLoad(u8, &ctx.puts_done, builtin.AtomicOrder.SeqCst) == 1;
         while (ctx.stack.pop()) |node| {
             std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
             _ = @atomicRmw(isize, &ctx.get_sum, builtin.AtomicRmwOp.Add, node.data, builtin.AtomicOrder.SeqCst);
             _ = @atomicRmw(usize, &ctx.get_count, builtin.AtomicRmwOp.Add, 1, builtin.AtomicOrder.SeqCst);
         }
-        if (@atomicLoad(u8, &ctx.puts_done, builtin.AtomicOrder.SeqCst) == 1) {
+        if (last) return 0;
-            break;
-        }
     }
-    return 0;
 }

std/buf_map.zig+6-6

...	@@ -19,7 +19,7 @@ pub const BufMap = struct {	...	@@ -19,7 +19,7 @@ pub const BufMap = struct {
19	pub fn deinit(self: *const BufMap) void {	19	pub fn deinit(self: *const BufMap) void {
20	var it = self.hash_map.iterator();	20	var it = self.hash_map.iterator();
21	while (true) {	21	while (true) {
22	const entry = it.next() ?? break;	22	const entry = it.next() orelse break;
23	self.free(entry.key);	23	self.free(entry.key);
24	self.free(entry.value);	24	self.free(entry.value);
25	}	25	}
...	@@ -37,12 +37,12 @@ pub const BufMap = struct {	...	@@ -37,12 +37,12 @@ pub const BufMap = struct {
37	}	37	}
38		38
39	pub fn get(self: *const BufMap, key: []const u8) ?[]const u8 {	39	pub fn get(self: *const BufMap, key: []const u8) ?[]const u8 {
40	const entry = self.hash_map.get(key) ?? return null;	40	const entry = self.hash_map.get(key) orelse return null;
41	return entry.value;	41	return entry.value;
42	}	42	}
43		43
44	pub fn delete(self: *BufMap, key: []const u8) void {	44	pub fn delete(self: *BufMap, key: []const u8) void {
45	const entry = self.hash_map.remove(key) ?? return;	45	const entry = self.hash_map.remove(key) orelse return;
46	self.free(entry.key);	46	self.free(entry.key);
47	self.free(entry.value);	47	self.free(entry.value);
48	}	48	}
...	@@ -72,15 +72,15 @@ test "BufMap" {	...	@@ -72,15 +72,15 @@ test "BufMap" {
72	defer bufmap.deinit();	72	defer bufmap.deinit();
73		73
74	try bufmap.set("x", "1");	74	try bufmap.set("x", "1");
75	assert(mem.eql(u8, ??bufmap.get("x"), "1"));	75	assert(mem.eql(u8, bufmap.get("x").?, "1"));
76	assert(1 == bufmap.count());	76	assert(1 == bufmap.count());
77		77
78	try bufmap.set("x", "2");	78	try bufmap.set("x", "2");
79	assert(mem.eql(u8, ??bufmap.get("x"), "2"));	79	assert(mem.eql(u8, bufmap.get("x").?, "2"));
80	assert(1 == bufmap.count());	80	assert(1 == bufmap.count());
81		81
82	try bufmap.set("x", "3");	82	try bufmap.set("x", "3");
83	assert(mem.eql(u8, ??bufmap.get("x"), "3"));	83	assert(mem.eql(u8, bufmap.get("x").?, "3"));
84	assert(1 == bufmap.count());	84	assert(1 == bufmap.count());
85		85
86	bufmap.delete("x");	86	bufmap.delete("x");

std/buf_set.zig+2-2

...	@@ -17,7 +17,7 @@ pub const BufSet = struct {	...	@@ -17,7 +17,7 @@ pub const BufSet = struct {
17	pub fn deinit(self: *const BufSet) void {	17	pub fn deinit(self: *const BufSet) void {
18	var it = self.hash_map.iterator();	18	var it = self.hash_map.iterator();
19	while (true) {	19	while (true) {
20	const entry = it.next() ?? break;	20	const entry = it.next() orelse break;
21	self.free(entry.key);	21	self.free(entry.key);
22	}	22	}
23		23
...	@@ -33,7 +33,7 @@ pub const BufSet = struct {	...	@@ -33,7 +33,7 @@ pub const BufSet = struct {
33	}	33	}
34		34
35	pub fn delete(self: *BufSet, key: []const u8) void {	35	pub fn delete(self: *BufSet, key: []const u8) void {
36	const entry = self.hash_map.remove(key) ?? return;	36	const entry = self.hash_map.remove(key) orelse return;
37	self.free(entry.key);	37	self.free(entry.key);
38	}	38	}
39		39

std/buffer.zig+3-4

std/build.zig+21-19

std/c/index.zig+10-10

std/debug/index.zig+20-10

std/event.zig+2-2

...	@@ -40,9 +40,9 @@ pub const TcpServer = struct {	...	@@ -40,9 +40,9 @@ pub const TcpServer = struct {
40	self.listen_address = std.net.Address.initPosix(try std.os.posixGetSockName(self.sockfd));	40	self.listen_address = std.net.Address.initPosix(try std.os.posixGetSockName(self.sockfd));
41		41
42	self.accept_coro = try async<self.loop.allocator> TcpServer.handler(self);	42	self.accept_coro = try async<self.loop.allocator> TcpServer.handler(self);
43	errdefer cancel ??self.accept_coro;	43	errdefer cancel self.accept_coro.?;
44		44
45	try self.loop.addFd(self.sockfd, ??self.accept_coro);	45	try self.loop.addFd(self.sockfd, self.accept_coro.?);
46	errdefer self.loop.removeFd(self.sockfd);	46	errdefer self.loop.removeFd(self.sockfd);
47	}	47	}
48		48

std/fmt/index.zig+44-20

 @@ -97,7 +97,11 @@ pub fn formatType(
     output: fn (@typeOf(context), []const u8) Errors!void,
 ) Errors!void {
     const T = @typeOf(value);
-    switch (@typeId(T)) {
+    if (T == error) {
+        try output(context, "error.");
+        return output(context, @errorName(value));
+    }
+    switch (@typeInfo(T)) {
         builtin.TypeId.Int, builtin.TypeId.Float => {
             return formatValue(value, fmt, context, Errors, output);
         },
 @@ -107,7 +111,7 @@ pub fn formatType(
         builtin.TypeId.Bool => {
             return output(context, if (value) "true" else "false");
         },
-        builtin.TypeId.Nullable => {
+        builtin.TypeId.Optional => {
             if (value) |payload| {
                 return formatType(payload, fmt, context, Errors, output);
             } else {
 @@ -125,12 +129,13 @@ pub fn formatType(
             try output(context, "error.");
             return output(context, @errorName(value));
         },
-        builtin.TypeId.Pointer => {
+        builtin.TypeId.Pointer => |ptr_info| switch (ptr_info.size) {
-            switch (@typeId(T.Child)) {
+            builtin.TypeInfo.Pointer.Size.One => switch (@typeInfo(ptr_info.child)) {
-                builtin.TypeId.Array => {
+                builtin.TypeId.Array => |info| {
-                    if (T.Child.Child == u8) {
+                    if (info.child == u8) {
                         return formatText(value, fmt, context, Errors, output);
                     }
+                    return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value));
                 },
                 builtin.TypeId.Enum, builtin.TypeId.Union, builtin.TypeId.Struct => {
                     const has_cust_fmt = comptime cf: {
 @@ -154,14 +159,24 @@ pub fn formatType(
                     return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value));
                 },
                 else => return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value)),
-            }
+            },
-        },
+            builtin.TypeInfo.Pointer.Size.Many => {
-        else => if (@canImplicitCast([]const u8, value)) {
+                if (ptr_info.child == u8) {
-            const casted_value = ([]const u8)(value);
+                    //This is a bit of a hack, but it made more sense to
-            return output(context, casted_value);
+                    // do this check here than have formatText do it
-        } else {
+                    if (fmt[0] == 's') {
-            @compileError("Unable to format type '" ++ @typeName(T) ++ "'");
+                        const len = std.cstr.len(value);
+                        return formatText(value[0..len], fmt, context, Errors, output);
+                    }
+                }
+                return format(context, Errors, output, "{}@{x}", @typeName(T.Child), @ptrToInt(value));
+            },
+            builtin.TypeInfo.Pointer.Size.Slice => {
+                const casted_value = ([]const u8)(value);
+                return output(context, casted_value);
+            },
         },
+        else => @compileError("Unable to format type '" ++ @typeName(T) ++ "'"),
     }
 }
 @@ -293,7 +308,7 @@ pub fn formatBuf(
     var leftover_padding = if (width > buf.len) (width - buf.len) else return;
     const pad_byte: u8 = ' ';
     while (leftover_padding > 0) : (leftover_padding -= 1) {
-        try output(context, (&pad_byte)[0..1]);
+        try output(context, (*[1]u8)(&pad_byte)[0..1]);
     }
 }
 @@ -552,14 +567,19 @@ pub fn formatBytes(
         return output(context, "0B");
     }
-    const mags = " KMGTPEZY";
+    const mags_si = " kMGTPEZY";
+    const mags_iec = " KMGTPEZY";
     const magnitude = switch (radix) {
-        1000 => math.min(math.log2(value) / comptime math.log2(1000), mags.len - 1),
+        1000 => math.min(math.log2(value) / comptime math.log2(1000), mags_si.len - 1),
-        1024 => math.min(math.log2(value) / 10, mags.len - 1),
+        1024 => math.min(math.log2(value) / 10, mags_iec.len - 1),
         else => unreachable,
     };
     const new_value = f64(value) / math.pow(f64, f64(radix), f64(magnitude));
-    const suffix = mags[magnitude];
+    const suffix = switch (radix) {
+        1000 => mags_si[magnitude],
+        1024 => mags_iec[magnitude],
+        else => unreachable,
+    };
     try formatFloatDecimal(new_value, width, context, Errors, output);
 @@ -807,11 +827,11 @@ test "parse unsigned comptime" {
 test "fmt.format" {
     {
         const value: ?i32 = 1234;
-        try testFmt("nullable: 1234\n", "nullable: {}\n", value);
+        try testFmt("optional: 1234\n", "optional: {}\n", value);
     }
     {
         const value: ?i32 = null;
-        try testFmt("nullable: null\n", "nullable: {}\n", value);
+        try testFmt("optional: null\n", "optional: {}\n", value);
     }
     {
         const value: error!i32 = 1234;
 @@ -829,6 +849,10 @@ test "fmt.format" {
         const value: u8 = 'a';
         try testFmt("u8: a\n", "u8: {c}\n", value);
     }
+    try testFmt("buf: Test \n", "buf: {s5}\n", "Test");
+    try testFmt("buf: Test\n Other text", "buf: {s}\n Other text", "Test");
+    try testFmt("cstr: Test C\n", "cstr: {s}\n", c"Test C");
+    try testFmt("cstr: Test C    \n", "cstr: {s10}\n", c"Test C");
     try testFmt("file size: 63MiB\n", "file size: {Bi}\n", usize(63 * 1024 * 1024));
     try testFmt("file size: 66.06MB\n", "file size: {B2}\n", usize(63 * 1024 * 1024));
     {

std/hash_map.zig+4-4

...	@@ -265,11 +265,11 @@ test "basic hash map usage" {	...	@@ -265,11 +265,11 @@ test "basic hash map usage" {
265	assert((map.put(4, 44) catch unreachable) == null);	265	assert((map.put(4, 44) catch unreachable) == null);
266	assert((map.put(5, 55) catch unreachable) == null);	266	assert((map.put(5, 55) catch unreachable) == null);
267		267
268	assert(??(map.put(5, 66) catch unreachable) == 55);	268	assert((map.put(5, 66) catch unreachable).? == 55);
269	assert(??(map.put(5, 55) catch unreachable) == 66);	269	assert((map.put(5, 55) catch unreachable).? == 66);
270		270
271	assert(map.contains(2));	271	assert(map.contains(2));
272	assert((??map.get(2)).value == 22);	272	assert(map.get(2).?.value == 22);
273	_ = map.remove(2);	273	_ = map.remove(2);
274	assert(map.remove(2) == null);	274	assert(map.remove(2) == null);
275	assert(map.get(2) == null);	275	assert(map.get(2) == null);
...	@@ -317,7 +317,7 @@ test "iterator hash map" {	...	@@ -317,7 +317,7 @@ test "iterator hash map" {
317	}	317	}
318		318
319	it.reset();	319	it.reset();
320	var entry = ??it.next();	320	var entry = it.next().?;
321	assert(entry.key == keys[0]);	321	assert(entry.key == keys[0]);
322	assert(entry.value == values[0]);	322	assert(entry.value == values[0]);
323	}	323	}

std/heap.zig+10-10

std/json.zig+177-88

 @@ -3,6 +3,7 @@
 // https://tools.ietf.org/html/rfc8259
 const std = @import("index.zig");
+const debug = std.debug;
 const mem = std.mem;
 const u1 = @IntType(false, 1);
 @@ -86,7 +87,9 @@ pub const Token = struct {
 // parsing state requires ~40-50 bytes of stack space.
 //
 // Conforms strictly to RFC8529.
-pub const StreamingJsonParser = struct {
+//
+// For a non-byte based wrapper, consider using TokenStream instead.
+pub const StreamingParser = struct {
     // Current state
     state: State,
     // How many bytes we have counted for the current token
 @@ -109,13 +112,13 @@ pub const StreamingJsonParser = struct {
     const array_bit = 1;
     const max_stack_size = @maxValue(u8);
-    pub fn init() StreamingJsonParser {
+    pub fn init() StreamingParser {
-        var p: StreamingJsonParser = undefined;
+        var p: StreamingParser = undefined;
         p.reset();
         return p;
     }
-    pub fn reset(p: *StreamingJsonParser) void {
+    pub fn reset(p: *StreamingParser) void {
         p.state = State.TopLevelBegin;
         p.count = 0;
         // Set before ever read in main transition function
 @@ -175,7 +178,7 @@ pub const StreamingJsonParser = struct {
         // Only call this function to generate array/object final state.
         pub fn fromInt(x: var) State {
-            std.debug.assert(x == 0 or x == 1);
+            debug.assert(x == 0 or x == 1);
             const T = @TagType(State);
             return State(T(x));
         }
 @@ -205,7 +208,7 @@ pub const StreamingJsonParser = struct {
     // tokens. token2 is always null if token1 is null.
     //
     // There is currently no error recovery on a bad stream.
-    pub fn feed(p: *StreamingJsonParser, c: u8, token1: *?Token, token2: *?Token) Error!void {
+    pub fn feed(p: *StreamingParser, c: u8, token1: *?Token, token2: *?Token) Error!void {
         token1.* = null;
         token2.* = null;
         p.count += 1;
 @@ -217,7 +220,7 @@ pub const StreamingJsonParser = struct {
     }
     // Perform a single transition on the state machine and return any possible token.
-    fn transition(p: *StreamingJsonParser, c: u8, token: *?Token) Error!bool {
+    fn transition(p: *StreamingParser, c: u8, token: *?Token) Error!bool {
         switch (p.state) {
             State.TopLevelBegin => switch (c) {
                 '{' => {
 @@ -321,7 +324,9 @@ pub const StreamingJsonParser = struct {
                             p.complete = true;
                             p.state = State.TopLevelEnd;
                         },
-                        else => {},
+                        else => {
+                            p.state = State.ValueEnd;
+                        },
                     }
                     token.* = Token.initMarker(Token.Id.ObjectEnd);
 @@ -345,7 +350,9 @@ pub const StreamingJsonParser = struct {
                             p.complete = true;
                             p.state = State.TopLevelEnd;
                         },
-                        else => {},
+                        else => {
+                            p.state = State.ValueEnd;
+                        },
                     }
                     token.* = Token.initMarker(Token.Id.ArrayEnd);
 @@ -852,16 +859,122 @@ pub const StreamingJsonParser = struct {
     }
 };
+// A small wrapper over a StreamingParser for full slices. Returns a stream of json Tokens.
+pub const TokenStream = struct {
+    i: usize,
+    slice: []const u8,
+    parser: StreamingParser,
+    token: ?Token,
+    pub fn init(slice: []const u8) TokenStream {
+        return TokenStream{
+            .i = 0,
+            .slice = slice,
+            .parser = StreamingParser.init(),
+            .token = null,
+        };
+    }
+    pub fn next(self: *TokenStream) !?Token {
+        if (self.token) |token| {
+            self.token = null;
+            return token;
+        }
+        var t1: ?Token = undefined;
+        var t2: ?Token = undefined;
+        while (self.i < self.slice.len) {
+            try self.parser.feed(self.slice[self.i], &t1, &t2);
+            self.i += 1;
+            if (t1) |token| {
+                self.token = t2;
+                return token;
+            }
+        }
+        if (self.i > self.slice.len) {
+            try self.parser.feed(' ', &t1, &t2);
+            self.i += 1;
+            if (t1) |token| {
+                return token;
+            }
+        }
+        return null;
+    }
+};
+fn checkNext(p: *TokenStream, id: Token.Id) void {
+    const token = (p.next() catch unreachable).?;
+    debug.assert(token.id == id);
+}
+test "token" {
+    const s =
+        \\{
+        \\  "Image": {
+        \\      "Width":  800,
+        \\      "Height": 600,
+        \\      "Title":  "View from 15th Floor",
+        \\      "Thumbnail": {
+        \\          "Url":    "http://www.example.com/image/481989943",
+        \\          "Height": 125,
+        \\          "Width":  100
+        \\      },
+        \\      "Animated" : false,
+        \\      "IDs": [116, 943, 234, 38793]
+        \\    }
+        \\}
+    ;
+    var p = TokenStream.init(s);
+    checkNext(&p, Token.Id.ObjectBegin);
+    checkNext(&p, Token.Id.String); // Image
+    checkNext(&p, Token.Id.ObjectBegin);
+    checkNext(&p, Token.Id.String); // Width
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.String); // Height
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.String); // Title
+    checkNext(&p, Token.Id.String);
+    checkNext(&p, Token.Id.String); // Thumbnail
+    checkNext(&p, Token.Id.ObjectBegin);
+    checkNext(&p, Token.Id.String); // Url
+    checkNext(&p, Token.Id.String);
+    checkNext(&p, Token.Id.String); // Height
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.String); // Width
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.ObjectEnd);
+    checkNext(&p, Token.Id.String); // Animated
+    checkNext(&p, Token.Id.False);
+    checkNext(&p, Token.Id.String); // IDs
+    checkNext(&p, Token.Id.ArrayBegin);
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.Number);
+    checkNext(&p, Token.Id.ArrayEnd);
+    checkNext(&p, Token.Id.ObjectEnd);
+    checkNext(&p, Token.Id.ObjectEnd);
+    debug.assert((try p.next()) == null);
+}
 // Validate a JSON string. This does not limit number precision so a decoder may not necessarily
 // be able to decode the string even if this returns true.
 pub fn validate(s: []const u8) bool {
-    var p = StreamingJsonParser.init();
+    var p = StreamingParser.init();
     for (s) |c, i| {
         var token1: ?Token = undefined;
         var token2: ?Token = undefined;
-        p.feed(c, *token1, *token2) catch |err| {
+        p.feed(c, &token1, &token2) catch |err| {
             return false;
         };
     }
 @@ -869,6 +982,10 @@ pub fn validate(s: []const u8) bool {
     return p.complete;
 }
+test "json validate" {
+    debug.assert(validate("{}"));
+}
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
 const ArrayList = std.ArrayList;
 @@ -897,46 +1014,46 @@ pub const Value = union(enum) {
     pub fn dump(self: *const Value) void {
         switch (self.*) {
             Value.Null => {
-                std.debug.warn("null");
+                debug.warn("null");
             },
             Value.Bool => |inner| {
-                std.debug.warn("{}", inner);
+                debug.warn("{}", inner);
             },
             Value.Integer => |inner| {
-                std.debug.warn("{}", inner);
+                debug.warn("{}", inner);
             },
             Value.Float => |inner| {
-                std.debug.warn("{.5}", inner);
+                debug.warn("{.5}", inner);
             },
             Value.String => |inner| {
-                std.debug.warn("\"{}\"", inner);
+                debug.warn("\"{}\"", inner);
             },
             Value.Array => |inner| {
                 var not_first = false;
-                std.debug.warn("[");
+                debug.warn("[");
                 for (inner.toSliceConst()) |value| {
                     if (not_first) {
-                        std.debug.warn(",");
+                        debug.warn(",");
                     }
                     not_first = true;
                     value.dump();
                 }
-                std.debug.warn("]");
+                debug.warn("]");
             },
             Value.Object => |inner| {
                 var not_first = false;
-                std.debug.warn("{{");
+                debug.warn("{{");
                 var it = inner.iterator();
                 while (it.next()) |entry| {
                     if (not_first) {
-                        std.debug.warn(",");
+                        debug.warn(",");
                     }
                     not_first = true;
-                    std.debug.warn("\"{}\":", entry.key);
+                    debug.warn("\"{}\":", entry.key);
                     entry.value.dump();
                 }
-                std.debug.warn("}}");
+                debug.warn("}}");
             },
         }
     }
 @@ -952,53 +1069,53 @@ pub const Value = union(enum) {
     fn dumpIndentLevel(self: *const Value, indent: usize, level: usize) void {
         switch (self.*) {
             Value.Null => {
-                std.debug.warn("null");
+                debug.warn("null");
             },
             Value.Bool => |inner| {
-                std.debug.warn("{}", inner);
+                debug.warn("{}", inner);
             },
             Value.Integer => |inner| {
-                std.debug.warn("{}", inner);
+                debug.warn("{}", inner);
             },
             Value.Float => |inner| {
-                std.debug.warn("{.5}", inner);
+                debug.warn("{.5}", inner);
             },
             Value.String => |inner| {
-                std.debug.warn("\"{}\"", inner);
+                debug.warn("\"{}\"", inner);
             },
             Value.Array => |inner| {
                 var not_first = false;
-                std.debug.warn("[\n");
+                debug.warn("[\n");
                 for (inner.toSliceConst()) |value| {
                     if (not_first) {
-                        std.debug.warn(",\n");
+                        debug.warn(",\n");
                     }
                     not_first = true;
                     padSpace(level + indent);
                     value.dumpIndentLevel(indent, level + indent);
                 }
-                std.debug.warn("\n");
+                debug.warn("\n");
                 padSpace(level);
-                std.debug.warn("]");
+                debug.warn("]");
             },
             Value.Object => |inner| {
                 var not_first = false;
-                std.debug.warn("{{\n");
+                debug.warn("{{\n");
                 var it = inner.iterator();
                 while (it.next()) |entry| {
                     if (not_first) {
-                        std.debug.warn(",\n");
+                        debug.warn(",\n");
                     }
                     not_first = true;
                     padSpace(level + indent);
-                    std.debug.warn("\"{}\": ", entry.key);
+                    debug.warn("\"{}\": ", entry.key);
                     entry.value.dumpIndentLevel(indent, level + indent);
                 }
-                std.debug.warn("\n");
+                debug.warn("\n");
                 padSpace(level);
-                std.debug.warn("}}");
+                debug.warn("}}");
             },
         }
     }
 @@ -1006,13 +1123,13 @@ pub const Value = union(enum) {
     fn padSpace(indent: usize) void {
         var i: usize = 0;
         while (i < indent) : (i += 1) {
-            std.debug.warn(" ");
+            debug.warn(" ");
         }
     }
 };
 // A non-stream JSON parser which constructs a tree of Value's.
-pub const JsonParser = struct {
+pub const Parser = struct {
     allocator: *Allocator,
     state: State,
     copy_strings: bool,
 @@ -1026,8 +1143,8 @@ pub const JsonParser = struct {
         Simple,
     };
-    pub fn init(allocator: *Allocator, copy_strings: bool) JsonParser {
+    pub fn init(allocator: *Allocator, copy_strings: bool) Parser {
-        return JsonParser{
+        return Parser{
             .allocator = allocator,
             .state = State.Simple,
             .copy_strings = copy_strings,
 @@ -1035,52 +1152,26 @@ pub const JsonParser = struct {
         };
     }
-    pub fn deinit(p: *JsonParser) void {
+    pub fn deinit(p: *Parser) void {
         p.stack.deinit();
     }
-    pub fn reset(p: *JsonParser) void {
+    pub fn reset(p: *Parser) void {
         p.state = State.Simple;
         p.stack.shrink(0);
     }
-    pub fn parse(p: *JsonParser, input: []const u8) !ValueTree {
+    pub fn parse(p: *Parser, input: []const u8) !ValueTree {
-        var mp = StreamingJsonParser.init();
+        var s = TokenStream.init(input);
         var arena = ArenaAllocator.init(p.allocator);
         errdefer arena.deinit();
-        for (input) |c, i| {
+        while (try s.next()) |token| {
-            var mt1: ?Token = undefined;
+            try p.transition(&arena.allocator, input, s.i - 1, token);
-            var mt2: ?Token = undefined;
-            try mp.feed(c, &mt1, &mt2);
-            if (mt1) |t1| {
-                try p.transition(&arena.allocator, input, i, t1);
-                if (mt2) |t2| {
-                    try p.transition(&arena.allocator, input, i, t2);
-                }
-            }
-        }
-        // Handle top-level lonely number values.
-        {
-            const i = input.len;
-            var mt1: ?Token = undefined;
-            var mt2: ?Token = undefined;
-            try mp.feed(' ', &mt1, &mt2);
-            if (mt1) |t1| {
-                try p.transition(&arena.allocator, input, i, t1);
-            }
-        }
-        if (!mp.complete) {
-            return error.IncompleteJsonInput;
         }
-        std.debug.assert(p.stack.len == 1);
+        debug.assert(p.stack.len == 1);
         return ValueTree{
             .arena = arena,
 @@ -1090,7 +1181,7 @@ pub const JsonParser = struct {
     // Even though p.allocator exists, we take an explicit allocator so that allocation state
     // can be cleaned up on error correctly during a `parse` on call.
-    fn transition(p: *JsonParser, allocator: *Allocator, input: []const u8, i: usize, token: *const Token) !void {
+    fn transition(p: *Parser, allocator: *Allocator, input: []const u8, i: usize, token: *const Token) !void {
         switch (p.state) {
             State.ObjectKey => switch (token.id) {
                 Token.Id.ObjectEnd => {
 @@ -1147,7 +1238,7 @@ pub const JsonParser = struct {
                         _ = p.stack.pop();
                         p.state = State.ObjectKey;
                     },
-                    else => {
+                    Token.Id.ObjectEnd, Token.Id.ArrayEnd => {
                         unreachable;
                     },
                 }
 @@ -1187,7 +1278,7 @@ pub const JsonParser = struct {
                     Token.Id.Null => {
                         try array.append(Value.Null);
                     },
-                    else => {
+                    Token.Id.ObjectEnd => {
                         unreachable;
                     },
                 }
 @@ -1223,7 +1314,7 @@ pub const JsonParser = struct {
         }
     }
-    fn pushToParent(p: *JsonParser, value: *const Value) !void {
+    fn pushToParent(p: *Parser, value: *const Value) !void {
         switch (p.stack.at(p.stack.len - 1)) {
             // Object Parent -> [ ..., object, <key>, value ]
             Value.String => |key| {
 @@ -1244,14 +1335,14 @@ pub const JsonParser = struct {
         }
     }
-    fn parseString(p: *JsonParser, allocator: *Allocator, token: *const Token, input: []const u8, i: usize) !Value {
+    fn parseString(p: *Parser, allocator: *Allocator, token: *const Token, input: []const u8, i: usize) !Value {
         // TODO: We don't strictly have to copy values which do not contain any escape
         // characters if flagged with the option.
         const slice = token.slice(input, i);
         return Value{ .String = try mem.dupe(p.allocator, u8, slice) };
     }
-    fn parseNumber(p: *JsonParser, token: *const Token, input: []const u8, i: usize) !Value {
+    fn parseNumber(p: *Parser, token: *const Token, input: []const u8, i: usize) !Value {
         return if (token.number_is_integer)
             Value{ .Integer = try std.fmt.parseInt(i64, token.slice(input, i), 10) }
         else
 @@ -1259,10 +1350,8 @@ pub const JsonParser = struct {
     }
 };
-const debug = std.debug;
 test "json parser dynamic" {
-    var p = JsonParser.init(std.debug.global_allocator, false);
+    var p = Parser.init(debug.global_allocator, false);
     defer p.deinit();
     const s =
 @@ -1287,17 +1376,17 @@ test "json parser dynamic" {
     var root = tree.root;
-    var image = (??root.Object.get("Image")).value;
+    var image = root.Object.get("Image").?.value;
-    const width = (??image.Object.get("Width")).value;
+    const width = image.Object.get("Width").?.value;
     debug.assert(width.Integer == 800);
-    const height = (??image.Object.get("Height")).value;
+    const height = image.Object.get("Height").?.value;
     debug.assert(height.Integer == 600);
-    const title = (??image.Object.get("Title")).value;
+    const title = image.Object.get("Title").?.value;
     debug.assert(mem.eql(u8, title.String, "View from 15th Floor"));
-    const animated = (??image.Object.get("Animated")).value;
+    const animated = image.Object.get("Animated").?.value;
     debug.assert(animated.Bool == false);
 }

std/json_test.zig+10

...	@@ -17,6 +17,16 @@ fn any(comptime s: []const u8) void {	...	@@ -17,6 +17,16 @@ fn any(comptime s: []const u8) void {
17	std.debug.assert(true);	17	std.debug.assert(true);
18	}	18	}
19		19
		20	////////////////////////////////////////////////////////////////////////////////////////////////////
		21	//
		22	// Additional tests not part of test JSONTestSuite.
		23
		24	test "y_trailing_comma_after_empty" {
		25	ok(
		26	\\{"1":[],"2":{},"3":"4"}
		27	);
		28	}
		29
20	////////////////////////////////////////////////////////////////////////////////////////////////////	30	////////////////////////////////////////////////////////////////////////////////////////////////////
21		31
22	test "y_array_arraysWithSpaces" {	32	test "y_array_arraysWithSpaces" {

std/linked_list.zig+6-6

...	@@ -169,7 +169,7 @@ fn BaseLinkedList(comptime T: type, comptime ParentType: type, comptime field_na	...	@@ -169,7 +169,7 @@ fn BaseLinkedList(comptime T: type, comptime ParentType: type, comptime field_na
169	/// Returns:	169	/// Returns:
170	/// A pointer to the last node in the list.	170	/// A pointer to the last node in the list.
171	pub fn pop(list: Self) ?Node {	171	pub fn pop(list: Self) ?Node {
172	const last = list.last ?? return null;	172	const last = list.last orelse return null;
173	list.remove(last);	173	list.remove(last);
174	return last;	174	return last;
175	}	175	}
...	@@ -179,7 +179,7 @@ fn BaseLinkedList(comptime T: type, comptime ParentType: type, comptime field_na	...	@@ -179,7 +179,7 @@ fn BaseLinkedList(comptime T: type, comptime ParentType: type, comptime field_na
179	/// Returns:	179	/// Returns:
180	/// A pointer to the first node in the list.	180	/// A pointer to the first node in the list.
181	pub fn popFirst(list: Self) ?Node {	181	pub fn popFirst(list: Self) ?Node {
182	const first = list.first ?? return null;	182	const first = list.first orelse return null;
183	list.remove(first);	183	list.remove(first);
184	return first;	184	return first;
185	}	185	}
...	@@ -270,8 +270,8 @@ test "basic linked list test" {	...	@@ -270,8 +270,8 @@ test "basic linked list test" {
270	var last = list.pop(); // {2, 3, 4}	270	var last = list.pop(); // {2, 3, 4}
271	list.remove(three); // {2, 4}	271	list.remove(three); // {2, 4}
272		272
273	assert((??list.first).data == 2);	273	assert(list.first.?.data == 2);
274	assert((??list.last).data == 4);	274	assert(list.last.?.data == 4);
275	assert(list.len == 2);	275	assert(list.len == 2);
276	}	276	}
277		277
...	@@ -336,7 +336,7 @@ test "basic intrusive linked list test" {	...	@@ -336,7 +336,7 @@ test "basic intrusive linked list test" {
336	var last = list.pop(); // {2, 3, 4}	336	var last = list.pop(); // {2, 3, 4}
337	list.remove(&three.link); // {2, 4}	337	list.remove(&three.link); // {2, 4}
338		338
339	assert((??list.first).toData().value == 2);	339	assert(list.first.?.toData().value == 2);
340	assert((??list.last).toData().value == 4);	340	assert(list.last.?.toData().value == 4);
341	assert(list.len == 2);	341	assert(list.len == 2);
342	}	342	}

std/macho.zig+1-1

...	@@ -130,7 +130,7 @@ pub fn loadSymbols(allocator: mem.Allocator, in: io.FileInStream) !SymbolTable	...	@@ -130,7 +130,7 @@ pub fn loadSymbols(allocator: mem.Allocator, in: io.FileInStream) !SymbolTable
130	for (syms) \|sym\| {	130	for (syms) \|sym\| {
131	if (!isSymbol(sym)) continue;	131	if (!isSymbol(sym)) continue;
132	const start = sym.n_strx;	132	const start = sym.n_strx;
133	const end = ??mem.indexOfScalarPos(u8, strings, start, 0);	133	const end = mem.indexOfScalarPos(u8, strings, start, 0).?;
134	const name = strings[start..end];	134	const name = strings[start..end];
135	const address = sym.n_value;	135	const address = sym.n_value;
136	symbols[nsym] = Symbol{ .name = name, .address = address };	136	symbols[nsym] = Symbol{ .name = name, .address = address };

std/math/big/index.zig created+5

...	@@ -0,0 +1,5 @@
1	pub use @import("int.zig");
2
3	test "math.big" {
4	_ = @import("int.zig");
5	}

std/math/big/int.zig created+2023

...	@@ -0,0 +1,2023 @@
1	const std = @import("../../index.zig");
2	const builtin = @import("builtin");
3	const debug = std.debug;
4	const math = std.math;
5	const mem = std.mem;
6	const Allocator = mem.Allocator;
7	const ArrayList = std.ArrayList;
8
9	const TypeId = builtin.TypeId;
10
11	pub const Limb = usize;
12	pub const DoubleLimb = @IntType(false, 2 * Limb.bit_count);
13	pub const Log2Limb = math.Log2Int(Limb);
14
15	comptime {
16	debug.assert(math.floorPowerOfTwo(usize, Limb.bit_count) == Limb.bit_count);
17	debug.assert(Limb.bit_count <= 64); // u128 set is unsupported
18	debug.assert(Limb.is_signed == false);
19	}
20
21	const wrapped_buffer_size = 512;
22
23	// Converts primitive integer values onto a stack-based big integer, or passes through existing
24	// Int types with no modifications. This can fail at runtime if using a very large dynamic
25	// integer but it is very unlikely and is considered a user error.
26	fn wrapInt(allocator: Allocator, bn: var) const Int {
27	const T = @typeOf(bn);
28	switch (@typeInfo(T)) {
29	TypeId.Pointer => \|info\| {
30	if (info.child == Int) {
31	return bn;
32	} else {
33	@compileError("cannot set Int using type " ++ @typeName(T));
34	}
35	},
36	else => {
37	var s = allocator.create(Int) catch unreachable;
38	s.* = Int{
39	.allocator = allocator,
40	.positive = false,
41	.limbs = block: {
42	var limbs = allocator.alloc(Limb, Int.default_capacity) catch unreachable;
43	limbs[0] = 0;
44	break :block limbs;
45	},
46	.len = 1,
47	};
48	s.set(bn) catch unreachable;
49	return s;
50	},
51	}
52	}
53
54	pub const Int = struct {
55	allocator: *Allocator,
56	positive: bool,
57	// - little-endian ordered
58	// - len >= 1 always
59	// - zero value -> len == 1 with limbs[0] == 0
60	limbs: []Limb,
61	len: usize,
62
63	const default_capacity = 4;
64
65	pub fn init(allocator: *Allocator) !Int {
66	return try Int.initCapacity(allocator, default_capacity);
67	}
68
69	pub fn initSet(allocator: *Allocator, value: var) !Int {
70	var s = try Int.init(allocator);
71	try s.set(value);
72	return s;
73	}
74
75	pub fn initCapacity(allocator: *Allocator, capacity: usize) !Int {
76	return Int{
77	.allocator = allocator,
78	.positive = true,
79	.limbs = block: {
80	var limbs = try allocator.alloc(Limb, math.max(default_capacity, capacity));
81	limbs[0] = 0;
82	break :block limbs;
83	},
84	.len = 1,
85	};
86	}
87
88	pub fn ensureCapacity(self: *Int, capacity: usize) !void {
89	if (capacity <= self.limbs.len) {
90	return;
91	}
92
93	self.limbs = try self.allocator.realloc(Limb, self.limbs, capacity);
94	}
95
96	pub fn deinit(self: *const Int) void {
97	self.allocator.free(self.limbs);
98	}
99
100	pub fn clone(other: *const Int) !Int {
101	return Int{
102	.allocator = other.allocator,
103	.positive = other.positive,
104	.limbs = block: {
105	var limbs = try other.allocator.alloc(Limb, other.len);
106	mem.copy(Limb, limbs[0..], other.limbs[0..other.len]);
107	break :block limbs;
108	},
109	.len = other.len,
110	};
111	}
112
113	pub fn copy(self: Int, other: const Int) !void {
114	if (self == other) {
115	return;
116	}
117
118	self.positive = other.positive;
119	try self.ensureCapacity(other.len);
120	mem.copy(Limb, self.limbs[0..], other.limbs[0..other.len]);
121	self.len = other.len;
122	}
123
124	pub fn swap(self: Int, other: Int) void {
125	mem.swap(Int, self, other);
126	}
127
128	pub fn dump(self: *const Int) void {
129	for (self.limbs) \|limb\| {
130	debug.warn("{x} ", limb);
131	}
132	debug.warn("\n");
133	}
134
135	pub fn negate(r: *Int) void {
136	r.positive = !r.positive;
137	}
138
139	pub fn abs(r: *Int) void {
140	r.positive = true;
141	}
142
143	pub fn isOdd(r: *const Int) bool {
144	return r.limbs[0] & 1 != 0;
145	}
146
147	pub fn isEven(r: *const Int) bool {
148	return !r.isOdd();
149	}
150
151	fn bitcount(self: *const Int) usize {
152	const u_bit_count = (self.len - 1) * Limb.bit_count + (Limb.bit_count - @clz(self.limbs[self.len - 1]));
153	return usize(!self.positive) + u_bit_count;
154	}
155
156	pub fn sizeInBase(self: *const Int, base: usize) usize {
157	return (self.bitcount() / math.log2(base)) + 1;
158	}
159
160	pub fn set(self: *Int, value: var) Allocator.Error!void {
161	const T = @typeOf(value);
162
163	switch (@typeInfo(T)) {
164	TypeId.Int => \|info\| {
165	const UT = if (T.is_signed) @IntType(false, T.bit_count - 1) else T;
166
167	try self.ensureCapacity(@sizeOf(UT) / @sizeOf(Limb));
168	self.positive = value >= 0;
169	self.len = 0;
170
171	var w_value: UT = if (value < 0) UT(-value) else UT(value);
172
173	if (info.bits <= Limb.bit_count) {
174	self.limbs[0] = Limb(w_value);
175	self.len = 1;
176	} else {
177	var i: usize = 0;
178	while (w_value != 0) : (i += 1) {
179	self.limbs[i] = @truncate(Limb, w_value);
180	self.len += 1;
181
182	// TODO: shift == 64 at compile-time fails. Fails on u128 limbs.
183	w_value >>= Limb.bit_count / 2;
184	w_value >>= Limb.bit_count / 2;
185	}
186	}
187	},
188	TypeId.ComptimeInt => {
189	comptime var w_value = if (value < 0) -value else value;
190
191	const req_limbs = @divFloor(math.log2(w_value), Limb.bit_count) + 1;
192	try self.ensureCapacity(req_limbs);
193
194	self.positive = value >= 0;
195	self.len = req_limbs;
196
197	if (w_value <= @maxValue(Limb)) {
198	self.limbs[0] = w_value;
199	} else {
200	const mask = (1 << Limb.bit_count) - 1;
201
202	comptime var i = 0;
203	inline while (w_value != 0) : (i += 1) {
204	self.limbs[i] = w_value & mask;
205
206	w_value >>= Limb.bit_count / 2;
207	w_value >>= Limb.bit_count / 2;
208	}
209	}
210	},
211	else => {
212	@compileError("cannot set Int using type " ++ @typeName(T));
213	},
214	}
215	}
216
217	pub const ConvertError = error{
218	NegativeIntoUnsigned,
219	TargetTooSmall,
220	};
221
222	pub fn to(self: *const Int, comptime T: type) ConvertError!T {
223	switch (@typeId(T)) {
224	TypeId.Int => {
225	const UT = if (T.is_signed) @IntType(false, T.bit_count - 1) else T;
226
227	if (self.bitcount() > 8 * @sizeOf(UT)) {
228	return error.TargetTooSmall;
229	}
230
231	var r: UT = 0;
232
233	if (@sizeOf(UT) <= @sizeOf(Limb)) {
234	r = UT(self.limbs[0]);
235	} else {
236	for (self.limbs[0..self.len]) \|_, ri\| {
237	const limb = self.limbs[self.len - ri - 1];
238	r <<= Limb.bit_count;
239	r \|= limb;
240	}
241	}
242
243	if (!T.is_signed) {
244	return if (self.positive) r else error.NegativeIntoUnsigned;
245	} else {
246	return if (self.positive) T(r) else -T(r);
247	}
248	},
249	else => {
250	@compileError("cannot convert Int to type " ++ @typeName(T));
251	},
252	}
253	}
254
255	fn charToDigit(ch: u8, base: u8) !u8 {
256	const d = switch (ch) {
257	'0'...'9' => ch - '0',
258	'a'...'f' => (ch - 'a') + 0xa,
259	else => return error.InvalidCharForDigit,
260	};
261
262	return if (d < base) d else return error.DigitTooLargeForBase;
263	}
264
265	fn digitToChar(d: u8, base: u8) !u8 {
266	if (d >= base) {
267	return error.DigitTooLargeForBase;
268	}
269
270	return switch (d) {
271	0...9 => '0' + d,
272	0xa...0xf => ('a' - 0xa) + d,
273	else => unreachable,
274	};
275	}
276
277	pub fn setString(self: *Int, base: u8, value: []const u8) !void {
278	if (base < 2 or base > 16) {
279	return error.InvalidBase;
280	}
281
282	var i: usize = 0;
283	var positive = true;
284	if (value.len > 0 and value[0] == '-') {
285	positive = false;
286	i += 1;
287	}
288
289	try self.set(0);
290	for (value[i..]) \|ch\| {
291	const d = try charToDigit(ch, base);
292	try self.mul(self, base);
293	try self.add(self, d);
294	}
295	self.positive = positive;
296	}
297
298	pub fn toString(self: const Int, allocator: Allocator, base: u8) ![]const u8 {
299	if (base < 2 or base > 16) {
300	return error.InvalidBase;
301	}
302
303	var digits = ArrayList(u8).init(allocator);
304	try digits.ensureCapacity(self.sizeInBase(base) + 1);
305	defer digits.deinit();
306
307	if (self.eqZero()) {
308	try digits.append('0');
309	return digits.toOwnedSlice();
310	}
311
312	// Power of two: can do a single pass and use masks to extract digits.
313	if (base & (base - 1) == 0) {
314	const base_shift = math.log2_int(Limb, base);
315
316	for (self.limbs[0..self.len]) \|limb\| {
317	var shift: usize = 0;
318	while (shift < Limb.bit_count) : (shift += base_shift) {
319	const r = u8((limb >> Log2Limb(shift)) & Limb(base - 1));
320	const ch = try digitToChar(r, base);
321	try digits.append(ch);
322	}
323	}
324
325	while (true) {
326	// always will have a non-zero digit somewhere
327	const c = digits.pop();
328	if (c != '0') {
329	digits.append(c) catch unreachable;
330	break;
331	}
332	}
333	} // Non power-of-two: batch divisions per word size.
334	else {
335	const digits_per_limb = math.log(Limb, base, @maxValue(Limb));
336	var limb_base: Limb = 1;
337	var j: usize = 0;
338	while (j < digits_per_limb) : (j += 1) {
339	limb_base *= base;
340	}
341
342	var q = try self.clone();
343	q.positive = true;
344	var r = try Int.init(allocator);
345	var b = try Int.initSet(allocator, limb_base);
346
347	while (q.len >= 2) {
348	try Int.divTrunc(&q, &r, &q, &b);
349
350	var r_word = r.limbs[0];
351	var i: usize = 0;
352	while (i < digits_per_limb) : (i += 1) {
353	const ch = try digitToChar(u8(r_word % base), base);
354	r_word /= base;
355	try digits.append(ch);
356	}
357	}
358
359	{
360	debug.assert(q.len == 1);
361
362	var r_word = q.limbs[0];
363	while (r_word != 0) {
364	const ch = try digitToChar(u8(r_word % base), base);
365	r_word /= base;
366	try digits.append(ch);
367	}
368	}
369	}
370
371	if (!self.positive) {
372	try digits.append('-');
373	}
374
375	var s = digits.toOwnedSlice();
376	mem.reverse(u8, s);
377	return s;
378	}
379
380	// returns -1, 0, 1 if \|a\| < \|b\|, \|a\| == \|b\| or \|a\| > \|b\| respectively.
381	pub fn cmpAbs(a: *const Int, bv: var) i8 {
382	// TODO: Thread-local buffer.
383	var buffer: [wrapped_buffer_size]u8 = undefined;
384	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
385	var b = wrapInt(&stack.allocator, bv);
386
387	if (a.len < b.len) {
388	return -1;
389	}
390	if (a.len > b.len) {
391	return 1;
392	}
393
394	var i: usize = a.len - 1;
395	while (i != 0) : (i -= 1) {
396	if (a.limbs[i] != b.limbs[i]) {
397	break;
398	}
399	}
400
401	if (a.limbs[i] < b.limbs[i]) {
402	return -1;
403	} else if (a.limbs[i] > b.limbs[i]) {
404	return 1;
405	} else {
406	return 0;
407	}
408	}
409
410	// returns -1, 0, 1 if a < b, a == b or a > b respectively.
411	pub fn cmp(a: *const Int, bv: var) i8 {
412	var buffer: [wrapped_buffer_size]u8 = undefined;
413	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
414	var b = wrapInt(&stack.allocator, bv);
415
416	if (a.positive != b.positive) {
417	return if (a.positive) i8(1) else -1;
418	} else {
419	const r = cmpAbs(a, b);
420	return if (a.positive) r else -r;
421	}
422	}
423
424	// if a == 0
425	pub fn eqZero(a: *const Int) bool {
426	return a.len == 1 and a.limbs[0] == 0;
427	}
428
429	// if \|a\| == \|b\|
430	pub fn eqAbs(a: *const Int, b: var) bool {
431	return cmpAbs(a, b) == 0;
432	}
433
434	// if a == b
435	pub fn eq(a: *const Int, b: var) bool {
436	return cmp(a, b) == 0;
437	}
438
439	// Normalize for a possible single carry digit.
440	//
441	// [1, 2, 3, 4, 0] -> [1, 2, 3, 4]
442	// [1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
443	// [0] -> [0]
444	fn norm1(r: *Int, length: usize) void {
445	debug.assert(length > 0);
446	debug.assert(length <= r.limbs.len);
447
448	if (r.limbs[length - 1] == 0) {
449	r.len = if (length > 1) length - 1 else 1;
450	} else {
451	r.len = length;
452	}
453	}
454
455	// Normalize a possible sequence of leading zeros.
456	//
457	// [1, 2, 3, 4, 0] -> [1, 2, 3, 4]
458	// [1, 2, 0, 0, 0] -> [1, 2]
459	// [0, 0, 0, 0, 0] -> [0]
460	fn normN(r: *Int, length: usize) void {
461	debug.assert(length > 0);
462	debug.assert(length <= r.limbs.len);
463
464	var j = length;
465	while (j > 0) : (j -= 1) {
466	if (r.limbs[j - 1] != 0) {
467	break;
468	}
469	}
470
471	// Handle zero
472	r.len = if (j != 0) j else 1;
473	}
474
475	// r = a + b
476	pub fn add(r: *Int, av: var, bv: var) Allocator.Error!void {
477	var buffer: [2 * wrapped_buffer_size]u8 = undefined;
478	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
479	var a = wrapInt(&stack.allocator, av);
480	var b = wrapInt(&stack.allocator, bv);
481
482	if (a.eqZero()) {
483	try r.copy(b);
484	return;
485	} else if (b.eqZero()) {
486	try r.copy(a);
487	return;
488	}
489
490	if (a.positive != b.positive) {
491	if (a.positive) {
492	// (a) + (-b) => a - b
493	const bp = Int{
494	.allocator = undefined,
495	.positive = true,
496	.limbs = b.limbs,
497	.len = b.len,
498	};
499	try r.sub(a, bp);
500	} else {
501	// (-a) + (b) => b - a
502	const ap = Int{
503	.allocator = undefined,
504	.positive = true,
505	.limbs = a.limbs,
506	.len = a.len,
507	};
508	try r.sub(b, ap);
509	}
510	} else {
511	if (a.len >= b.len) {
512	try r.ensureCapacity(a.len + 1);
513	lladd(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
514	r.norm1(a.len + 1);
515	} else {
516	try r.ensureCapacity(b.len + 1);
517	lladd(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
518	r.norm1(b.len + 1);
519	}
520
521	r.positive = a.positive;
522	}
523	}
524
525	// Knuth 4.3.1, Algorithm A.
526	fn lladd(r: []Limb, a: []const Limb, b: []const Limb) void {
527	@setRuntimeSafety(false);
528	debug.assert(a.len != 0 and b.len != 0);
529	debug.assert(a.len >= b.len);
530	debug.assert(r.len >= a.len + 1);
531
532	var i: usize = 0;
533	var carry: Limb = 0;
534
535	while (i < b.len) : (i += 1) {
536	var c: Limb = 0;
537	c += Limb(@addWithOverflow(Limb, a[i], b[i], &r[i]));
538	c += Limb(@addWithOverflow(Limb, r[i], carry, &r[i]));
539	carry = c;
540	}
541
542	while (i < a.len) : (i += 1) {
543	carry = Limb(@addWithOverflow(Limb, a[i], carry, &r[i]));
544	}
545
546	r[i] = carry;
547	}
548
549	// r = a - b
550	pub fn sub(r: *Int, av: var, bv: var) !void {
551	var buffer: [wrapped_buffer_size]u8 = undefined;
552	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
553	var a = wrapInt(&stack.allocator, av);
554	var b = wrapInt(&stack.allocator, bv);
555
556	if (a.positive != b.positive) {
557	if (a.positive) {
558	// (a) - (-b) => a + b
559	const bp = Int{
560	.allocator = undefined,
561	.positive = true,
562	.limbs = b.limbs,
563	.len = b.len,
564	};
565	try r.add(a, bp);
566	} else {
567	// (-a) - (b) => -(a + b)
568	const ap = Int{
569	.allocator = undefined,
570	.positive = true,
571	.limbs = a.limbs,
572	.len = a.len,
573	};
574	try r.add(ap, b);
575	r.positive = false;
576	}
577	} else {
578	if (a.positive) {
579	// (a) - (b) => a - b
580	if (a.cmp(b) >= 0) {
581	try r.ensureCapacity(a.len + 1);
582	llsub(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
583	r.normN(a.len);
584	r.positive = true;
585	} else {
586	try r.ensureCapacity(b.len + 1);
587	llsub(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
588	r.normN(b.len);
589	r.positive = false;
590	}
591	} else {
592	// (-a) - (-b) => -(a - b)
593	if (a.cmp(b) < 0) {
594	try r.ensureCapacity(a.len + 1);
595	llsub(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
596	r.normN(a.len);
597	r.positive = false;
598	} else {
599	try r.ensureCapacity(b.len + 1);
600	llsub(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
601	r.normN(b.len);
602	r.positive = true;
603	}
604	}
605	}
606	}
607
608	// Knuth 4.3.1, Algorithm S.
609	fn llsub(r: []Limb, a: []const Limb, b: []const Limb) void {
610	@setRuntimeSafety(false);
611	debug.assert(a.len != 0 and b.len != 0);
612	debug.assert(a.len > b.len or (a.len == b.len and a[a.len - 1] >= b[b.len - 1]));
613	debug.assert(r.len >= a.len);
614
615	var i: usize = 0;
616	var borrow: Limb = 0;
617
618	while (i < b.len) : (i += 1) {
619	var c: Limb = 0;
620	c += Limb(@subWithOverflow(Limb, a[i], b[i], &r[i]));
621	c += Limb(@subWithOverflow(Limb, r[i], borrow, &r[i]));
622	borrow = c;
623	}
624
625	while (i < a.len) : (i += 1) {
626	borrow = Limb(@subWithOverflow(Limb, a[i], borrow, &r[i]));
627	}
628
629	debug.assert(borrow == 0);
630	}
631
632	// rma = a * b
633	//
634	// For greatest efficiency, ensure rma does not alias a or b.
635	pub fn mul(rma: *Int, av: var, bv: var) !void {
636	var buffer: [2 * wrapped_buffer_size]u8 = undefined;
637	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
638	var a = wrapInt(&stack.allocator, av);
639	var b = wrapInt(&stack.allocator, bv);
640
641	var r = rma;
642	var aliased = rma == a or rma == b;
643
644	var sr: Int = undefined;
645	if (aliased) {
646	sr = try Int.initCapacity(rma.allocator, a.len + b.len);
647	r = &sr;
648	aliased = true;
649	}
650	defer if (aliased) {
651	rma.swap(r);
652	r.deinit();
653	};
654
655	try r.ensureCapacity(a.len + b.len);
656
657	if (a.len >= b.len) {
658	llmul(r.limbs, a.limbs[0..a.len], b.limbs[0..b.len]);
659	} else {
660	llmul(r.limbs, b.limbs[0..b.len], a.limbs[0..a.len]);
661	}
662
663	r.positive = a.positive == b.positive;
664	r.normN(a.len + b.len);
665	}
666
667	// a + b * c + *carry, sets carry to the overflow bits
668	pub fn addMulLimbWithCarry(a: Limb, b: Limb, c: Limb, carry: *Limb) Limb {
669	var r1: Limb = undefined;
670
671	// r1 = a + *carry
672	const c1 = Limb(@addWithOverflow(Limb, a, carry.*, &r1));
673
674	// r2 = b * c
675	//
676	// We still use a DoubleLimb here since the @mulWithOverflow builtin does not
677	// return the carry and lower bits separately so we would need to perform this
678	// anyway to get the carry bits. The branch on the overflow case costs more than
679	// just computing them unconditionally and splitting.
680	//
681	// This could be a single x86 mul instruction, which stores the carry/lower in rdx:rax.
682	const bc = DoubleLimb(b) * DoubleLimb(c);
683	const r2 = @truncate(Limb, bc);
684	const c2 = @truncate(Limb, bc >> Limb.bit_count);
685
686	// r1 = r1 + r2
687	const c3 = Limb(@addWithOverflow(Limb, r1, r2, &r1));
688
689	// This never overflows, c1, c3 are either 0 or 1 and if both are 1 then
690	// c2 is at least <= @maxValue(Limb) - 2.
691	carry.* = c1 + c2 + c3;
692
693	return r1;
694	}
695
696	// Knuth 4.3.1, Algorithm M.
697	//
698	// r MUST NOT alias any of a or b.
699	fn llmul(r: []Limb, a: []const Limb, b: []const Limb) void {
700	@setRuntimeSafety(false);
701	debug.assert(a.len >= b.len);
702	debug.assert(r.len >= a.len + b.len);
703
704	mem.set(Limb, r[0 .. a.len + b.len], 0);
705
706	var i: usize = 0;
707	while (i < a.len) : (i += 1) {
708	var carry: Limb = 0;
709	var j: usize = 0;
710	while (j < b.len) : (j += 1) {
711	r[i + j] = @inlineCall(addMulLimbWithCarry, r[i + j], a[i], b[j], &carry);
712	}
713	r[i + j] = carry;
714	}
715	}
716
717	pub fn divFloor(q: Int, r: Int, a: var, b: var) !void {
718	try div(q, r, a, b);
719
720	// Trunc -> Floor.
721	if (!q.positive) {
722	try q.sub(q, 1);
723	try r.add(q, 1);
724	}
725	r.positive = b.positive;
726	}
727
728	pub fn divTrunc(q: Int, r: Int, a: var, b: var) !void {
729	try div(q, r, a, b);
730	r.positive = a.positive;
731	}
732
733	// Truncates by default.
734	fn div(quo: Int, rem: Int, av: var, bv: var) !void {
735	var buffer: [2 * wrapped_buffer_size]u8 = undefined;
736	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
737	var a = wrapInt(&stack.allocator, av);
738	var b = wrapInt(&stack.allocator, bv);
739
740	if (b.eqZero()) {
741	@panic("division by zero");
742	}
743	if (quo == rem) {
744	@panic("quo and rem cannot be same variable");
745	}
746
747	if (a.cmpAbs(b) < 0) {
748	// quo may alias a so handle rem first
749	try rem.copy(a);
750	rem.positive = a.positive == b.positive;
751
752	quo.positive = true;
753	quo.len = 1;
754	quo.limbs[0] = 0;
755	return;
756	}
757
758	if (b.len == 1) {
759	try quo.ensureCapacity(a.len);
760
761	lldiv1(quo.limbs[0..], &rem.limbs[0], a.limbs[0..a.len], b.limbs[0]);
762	quo.norm1(a.len);
763	quo.positive = a.positive == b.positive;
764
765	rem.len = 1;
766	rem.positive = true;
767	} else {
768	// x and y are modified during division
769	var x = try a.clone();
770	defer x.deinit();
771
772	var y = try b.clone();
773	defer y.deinit();
774
775	// x may grow one limb during normalization
776	try quo.ensureCapacity(a.len + y.len);
777	try divN(quo.allocator, quo, rem, &x, &y);
778
779	quo.positive = a.positive == b.positive;
780	}
781	}
782
783	// Knuth 4.3.1, Exercise 16.
784	fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
785	@setRuntimeSafety(false);
786	debug.assert(a.len > 1 or a[0] >= b);
787	debug.assert(quo.len >= a.len);
788
789	rem.* = 0;
790	for (a) \|_, ri\| {
791	const i = a.len - ri - 1;
792	const pdiv = ((DoubleLimb(rem.*) << Limb.bit_count) \| a[i]);
793
794	if (pdiv == 0) {
795	quo[i] = 0;
796	rem.* = 0;
797	} else if (pdiv < b) {
798	quo[i] = 0;
799	rem.* = @truncate(Limb, pdiv);
800	} else if (pdiv == b) {
801	quo[i] = 1;
802	rem.* = 0;
803	} else {
804	quo[i] = @truncate(Limb, @divTrunc(pdiv, b));
805	rem.* = @truncate(Limb, pdiv - (quo[i] *% b));
806	}
807	}
808	}
809
810	// Handbook of Applied Cryptography, 14.20
811	//
812	// x = qy + r where 0 <= r < y
813	fn divN(allocator: Allocator, q: Int, r: Int, x: Int, y: *Int) !void {
814	debug.assert(y.len >= 2);
815	debug.assert(x.len >= y.len);
816	debug.assert(q.limbs.len >= x.len + y.len - 1);
817	debug.assert(default_capacity >= 3); // see 3.2
818
819	var tmp = try Int.init(allocator);
820	defer tmp.deinit();
821
822	// Normalize so y > Limb.bit_count / 2 (i.e. leading bit is set)
823	const norm_shift = @clz(y.limbs[y.len - 1]);
824	try x.shiftLeft(x, norm_shift);
825	try y.shiftLeft(y, norm_shift);
826
827	const n = x.len - 1;
828	const t = y.len - 1;
829
830	// 1.
831	q.len = n - t + 1;
832	mem.set(Limb, q.limbs[0..q.len], 0);
833
834	// 2.
835	try tmp.shiftLeft(y, Limb.bit_count * (n - t));
836	while (x.cmp(&tmp) >= 0) {
837	q.limbs[n - t] += 1;
838	try x.sub(x, tmp);
839	}
840
841	// 3.
842	var i = n;
843	while (i > t) : (i -= 1) {
844	// 3.1
845	if (x.limbs[i] == y.limbs[t]) {
846	q.limbs[i - t - 1] = @maxValue(Limb);
847	} else {
848	const num = (DoubleLimb(x.limbs[i]) << Limb.bit_count) \| DoubleLimb(x.limbs[i - 1]);
849	const z = Limb(num / DoubleLimb(y.limbs[t]));
850	q.limbs[i - t - 1] = if (z > @maxValue(Limb)) @maxValue(Limb) else Limb(z);
851	}
852
853	// 3.2
854	tmp.limbs[0] = if (i >= 2) x.limbs[i - 2] else 0;
855	tmp.limbs[1] = if (i >= 1) x.limbs[i - 1] else 0;
856	tmp.limbs[2] = x.limbs[i];
857	tmp.normN(3);
858
859	while (true) {
860	// 2x1 limb multiplication unrolled against single-limb q[i-t-1]
861	var carry: Limb = 0;
862	r.limbs[0] = addMulLimbWithCarry(0, if (t >= 1) y.limbs[t - 1] else 0, q.limbs[i - t - 1], &carry);
863	r.limbs[1] = addMulLimbWithCarry(0, y.limbs[t], q.limbs[i - t - 1], &carry);
864	r.limbs[2] = carry;
865	r.normN(3);
866
867	if (r.cmpAbs(&tmp) <= 0) {
868	break;
869	}
870
871	q.limbs[i - t - 1] -= 1;
872	}
873
874	// 3.3
875	try tmp.set(q.limbs[i - t - 1]);
876	try tmp.mul(&tmp, y);
877	try tmp.shiftLeft(&tmp, Limb.bit_count * (i - t - 1));
878	try x.sub(x, &tmp);
879
880	if (!x.positive) {
881	try tmp.shiftLeft(y, Limb.bit_count * (i - t - 1));
882	try x.add(x, &tmp);
883	q.limbs[i - t - 1] -= 1;
884	}
885	}
886
887	// Denormalize
888	q.normN(q.len);
889
890	try r.shiftRight(x, norm_shift);
891	r.normN(r.len);
892	}
893
894	// r = a << shift, in other words, r = a * 2^shift
895	pub fn shiftLeft(r: *Int, av: var, shift: usize) !void {
896	var buffer: [wrapped_buffer_size]u8 = undefined;
897	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
898	var a = wrapInt(&stack.allocator, av);
899
900	try r.ensureCapacity(a.len + (shift / Limb.bit_count) + 1);
901	llshl(r.limbs[0..], a.limbs[0..a.len], shift);
902	r.norm1(a.len + (shift / Limb.bit_count) + 1);
903	r.positive = a.positive;
904	}
905
906	fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
907	@setRuntimeSafety(false);
908	debug.assert(a.len >= 1);
909	debug.assert(r.len >= a.len + (shift / Limb.bit_count) + 1);
910
911	const limb_shift = shift / Limb.bit_count + 1;
912	const interior_limb_shift = Log2Limb(shift % Limb.bit_count);
913
914	var carry: Limb = 0;
915	var i: usize = 0;
916	while (i < a.len) : (i += 1) {
917	const src_i = a.len - i - 1;
918	const dst_i = src_i + limb_shift;
919
920	const src_digit = a[src_i];
921	r[dst_i] = carry \| @inlineCall(math.shr, Limb, src_digit, Limb.bit_count - Limb(interior_limb_shift));
922	carry = (src_digit << interior_limb_shift);
923	}
924
925	r[limb_shift - 1] = carry;
926	mem.set(Limb, r[0 .. limb_shift - 1], 0);
927	}
928
929	// r = a >> shift
930	pub fn shiftRight(r: *Int, av: var, shift: usize) !void {
931	var buffer: [wrapped_buffer_size]u8 = undefined;
932	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
933	var a = wrapInt(&stack.allocator, av);
934
935	if (a.len <= shift / Limb.bit_count) {
936	r.len = 1;
937	r.limbs[0] = 0;
938	r.positive = true;
939	return;
940	}
941
942	try r.ensureCapacity(a.len - (shift / Limb.bit_count));
943	const r_len = llshr(r.limbs[0..], a.limbs[0..a.len], shift);
944	r.len = a.len - (shift / Limb.bit_count);
945	r.positive = a.positive;
946	}
947
948	fn llshr(r: []Limb, a: []const Limb, shift: usize) void {
949	@setRuntimeSafety(false);
950	debug.assert(a.len >= 1);
951	debug.assert(r.len >= a.len - (shift / Limb.bit_count));
952
953	const limb_shift = shift / Limb.bit_count;
954	const interior_limb_shift = Log2Limb(shift % Limb.bit_count);
955
956	var carry: Limb = 0;
957	var i: usize = 0;
958	while (i < a.len - limb_shift) : (i += 1) {
959	const src_i = a.len - i - 1;
960	const dst_i = src_i - limb_shift;
961
962	const src_digit = a[src_i];
963	r[dst_i] = carry \| (src_digit >> interior_limb_shift);
964	carry = @inlineCall(math.shl, Limb, src_digit, Limb.bit_count - Limb(interior_limb_shift));
965	}
966	}
967
968	// r = a \| b
969	pub fn bitOr(r: *Int, av: var, bv: var) !void {
970	var buffer: [2 * wrapped_buffer_size]u8 = undefined;
971	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
972	var a = wrapInt(&stack.allocator, av);
973	var b = wrapInt(&stack.allocator, bv);
974
975	if (a.len > b.len) {
976	try r.ensureCapacity(a.len);
977	llor(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
978	r.len = a.len;
979	} else {
980	try r.ensureCapacity(b.len);
981	llor(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
982	r.len = b.len;
983	}
984	}
985
986	fn llor(r: []Limb, a: []const Limb, b: []const Limb) void {
987	@setRuntimeSafety(false);
988	debug.assert(r.len >= a.len);
989	debug.assert(a.len >= b.len);
990
991	var i: usize = 0;
992	while (i < b.len) : (i += 1) {
993	r[i] = a[i] \| b[i];
994	}
995	while (i < a.len) : (i += 1) {
996	r[i] = a[i];
997	}
998	}
999
1000	// r = a & b
1001	pub fn bitAnd(r: *Int, av: var, bv: var) !void {
1002	var buffer: [2 * wrapped_buffer_size]u8 = undefined;
1003	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
1004	var a = wrapInt(&stack.allocator, av);
1005	var b = wrapInt(&stack.allocator, bv);
1006
1007	if (a.len > b.len) {
1008	try r.ensureCapacity(b.len);
1009	lland(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
1010	r.normN(b.len);
1011	} else {
1012	try r.ensureCapacity(a.len);
1013	lland(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
1014	r.normN(a.len);
1015	}
1016	}
1017
1018	fn lland(r: []Limb, a: []const Limb, b: []const Limb) void {
1019	@setRuntimeSafety(false);
1020	debug.assert(r.len >= b.len);
1021	debug.assert(a.len >= b.len);
1022
1023	var i: usize = 0;
1024	while (i < b.len) : (i += 1) {
1025	r[i] = a[i] & b[i];
1026	}
1027	}
1028
1029	// r = a ^ b
1030	pub fn bitXor(r: *Int, av: var, bv: var) !void {
1031	var buffer: [2 * wrapped_buffer_size]u8 = undefined;
1032	var stack = std.heap.FixedBufferAllocator.init(buffer[0..]);
1033	var a = wrapInt(&stack.allocator, av);
1034	var b = wrapInt(&stack.allocator, bv);
1035
1036	if (a.len > b.len) {
1037	try r.ensureCapacity(a.len);
1038	llxor(r.limbs[0..], a.limbs[0..a.len], b.limbs[0..b.len]);
1039	r.normN(a.len);
1040	} else {
1041	try r.ensureCapacity(b.len);
1042	llxor(r.limbs[0..], b.limbs[0..b.len], a.limbs[0..a.len]);
1043	r.normN(b.len);
1044	}
1045	}
1046
1047	fn llxor(r: []Limb, a: []const Limb, b: []const Limb) void {
1048	@setRuntimeSafety(false);
1049	debug.assert(r.len >= a.len);
1050	debug.assert(a.len >= b.len);
1051
1052	var i: usize = 0;
1053	while (i < b.len) : (i += 1) {
1054	r[i] = a[i] ^ b[i];
1055	}
1056	while (i < a.len) : (i += 1) {
1057	r[i] = a[i];
1058	}
1059	}
1060	};
1061
1062	// NOTE: All the following tests assume the max machine-word will be 64-bit.
1063	//
1064	// They will still run on larger than this and should pass, but the multi-limb code-paths
1065	// may be untested in some cases.
1066
1067	const u256 = @IntType(false, 256);
1068	var al = debug.global_allocator;
1069
1070	test "big.int comptime_int set" {
1071	comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab;
1072	var a = try Int.initSet(al, s);
1073
1074	const s_limb_count = 128 / Limb.bit_count;
1075
1076	comptime var i: usize = 0;
1077	inline while (i < s_limb_count) : (i += 1) {
1078	const result = Limb(s & @maxValue(Limb));
1079	s >>= Limb.bit_count / 2;
1080	s >>= Limb.bit_count / 2;
1081	debug.assert(a.limbs[i] == result);
1082	}
1083	}
1084
1085	test "big.int comptime_int set negative" {
1086	var a = try Int.initSet(al, -10);
1087
1088	debug.assert(a.limbs[0] == 10);
1089	debug.assert(a.positive == false);
1090	}
1091
1092	test "big.int int set unaligned small" {
1093	var a = try Int.initSet(al, u7(45));
1094
1095	debug.assert(a.limbs[0] == 45);
1096	debug.assert(a.positive == true);
1097	}
1098
1099	test "big.int comptime_int to" {
1100	const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
1101
1102	debug.assert((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);
1103	}
1104
1105	test "big.int sub-limb to" {
1106	const a = try Int.initSet(al, 10);
1107
1108	debug.assert((try a.to(u8)) == 10);
1109	}
1110
1111	test "big.int to target too small error" {
1112	const a = try Int.initSet(al, 0xffffffff);
1113
1114	if (a.to(u8)) \|_\| {
1115	unreachable;
1116	} else \|err\| {
1117	debug.assert(err == error.TargetTooSmall);
1118	}
1119	}
1120
1121	test "big.int norm1" {
1122	var a = try Int.init(al);
1123	try a.ensureCapacity(8);
1124
1125	a.limbs[0] = 1;
1126	a.limbs[1] = 2;
1127	a.limbs[2] = 3;
1128	a.limbs[3] = 0;
1129	a.norm1(4);
1130	debug.assert(a.len == 3);
1131
1132	a.limbs[0] = 1;
1133	a.limbs[1] = 2;
1134	a.limbs[2] = 3;
1135	a.norm1(3);
1136	debug.assert(a.len == 3);
1137
1138	a.limbs[0] = 0;
1139	a.limbs[1] = 0;
1140	a.norm1(2);
1141	debug.assert(a.len == 1);
1142
1143	a.limbs[0] = 0;
1144	a.norm1(1);
1145	debug.assert(a.len == 1);
1146	}
1147
1148	test "big.int normN" {
1149	var a = try Int.init(al);
1150	try a.ensureCapacity(8);
1151
1152	a.limbs[0] = 1;
1153	a.limbs[1] = 2;
1154	a.limbs[2] = 0;
1155	a.limbs[3] = 0;
1156	a.normN(4);
1157	debug.assert(a.len == 2);
1158
1159	a.limbs[0] = 1;
1160	a.limbs[1] = 2;
1161	a.limbs[2] = 3;
1162	a.normN(3);
1163	debug.assert(a.len == 3);
1164
1165	a.limbs[0] = 0;
1166	a.limbs[1] = 0;
1167	a.limbs[2] = 0;
1168	a.limbs[3] = 0;
1169	a.normN(4);
1170	debug.assert(a.len == 1);
1171
1172	a.limbs[0] = 0;
1173	a.normN(1);
1174	debug.assert(a.len == 1);
1175	}
1176
1177	test "big.int parity" {
1178	var a = try Int.init(al);
1179	try a.set(0);
1180	debug.assert(a.isEven());
1181	debug.assert(!a.isOdd());
1182
1183	try a.set(7);
1184	debug.assert(!a.isEven());
1185	debug.assert(a.isOdd());
1186	}
1187
1188	test "big.int bitcount + sizeInBase" {
1189	var a = try Int.init(al);
1190
1191	try a.set(0b100);
1192	debug.assert(a.bitcount() == 3);
1193	debug.assert(a.sizeInBase(2) >= 3);
1194	debug.assert(a.sizeInBase(10) >= 1);
1195
1196	try a.set(0xffffffff);
1197	debug.assert(a.bitcount() == 32);
1198	debug.assert(a.sizeInBase(2) >= 32);
1199	debug.assert(a.sizeInBase(10) >= 10);
1200
1201	try a.shiftLeft(&a, 5000);
1202	debug.assert(a.bitcount() == 5032);
1203	debug.assert(a.sizeInBase(2) >= 5032);
1204	a.positive = false;
1205
1206	debug.assert(a.bitcount() == 5033);
1207	debug.assert(a.sizeInBase(2) >= 5033);
1208	}
1209
1210	test "big.int string set" {
1211	var a = try Int.init(al);
1212	try a.setString(10, "120317241209124781241290847124");
1213
1214	debug.assert((try a.to(u128)) == 120317241209124781241290847124);
1215	}
1216
1217	test "big.int string negative" {
1218	var a = try Int.init(al);
1219	try a.setString(10, "-1023");
1220	debug.assert((try a.to(i32)) == -1023);
1221	}
1222
1223	test "big.int string set bad char error" {
1224	var a = try Int.init(al);
1225	a.setString(10, "x") catch \|err\| debug.assert(err == error.InvalidCharForDigit);
1226	}
1227
1228	test "big.int string set bad base error" {
1229	var a = try Int.init(al);
1230	a.setString(45, "10") catch \|err\| debug.assert(err == error.InvalidBase);
1231	}
1232
1233	test "big.int string to" {
1234	const a = try Int.initSet(al, 120317241209124781241290847124);
1235
1236	const as = try a.toString(al, 10);
1237	const es = "120317241209124781241290847124";
1238
1239	debug.assert(mem.eql(u8, as, es));
1240	}
1241
1242	test "big.int string to base base error" {
1243	const a = try Int.initSet(al, 0xffffffff);
1244
1245	if (a.toString(al, 45)) \|_\| {
1246	unreachable;
1247	} else \|err\| {
1248	debug.assert(err == error.InvalidBase);
1249	}
1250	}
1251
1252	test "big.int string to base 2" {
1253	const a = try Int.initSet(al, -0b1011);
1254
1255	const as = try a.toString(al, 2);
1256	const es = "-1011";
1257
1258	debug.assert(mem.eql(u8, as, es));
1259	}
1260
1261	test "big.int string to base 16" {
1262	const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
1263
1264	const as = try a.toString(al, 16);
1265	const es = "efffffff00000001eeeeeeefaaaaaaab";
1266
1267	debug.assert(mem.eql(u8, as, es));
1268	}
1269
1270	test "big.int neg string to" {
1271	const a = try Int.initSet(al, -123907434);
1272
1273	const as = try a.toString(al, 10);
1274	const es = "-123907434";
1275
1276	debug.assert(mem.eql(u8, as, es));
1277	}
1278
1279	test "big.int zero string to" {
1280	const a = try Int.initSet(al, 0);
1281
1282	const as = try a.toString(al, 10);
1283	const es = "0";
1284
1285	debug.assert(mem.eql(u8, as, es));
1286	}
1287
1288	test "big.int clone" {
1289	var a = try Int.initSet(al, 1234);
1290	const b = try a.clone();
1291
1292	debug.assert((try a.to(u32)) == 1234);
1293	debug.assert((try b.to(u32)) == 1234);
1294
1295	try a.set(77);
1296	debug.assert((try a.to(u32)) == 77);
1297	debug.assert((try b.to(u32)) == 1234);
1298	}
1299
1300	test "big.int swap" {
1301	var a = try Int.initSet(al, 1234);
1302	var b = try Int.initSet(al, 5678);
1303
1304	debug.assert((try a.to(u32)) == 1234);
1305	debug.assert((try b.to(u32)) == 5678);
1306
1307	a.swap(&b);
1308
1309	debug.assert((try a.to(u32)) == 5678);
1310	debug.assert((try b.to(u32)) == 1234);
1311	}
1312
1313	test "big.int to negative" {
1314	var a = try Int.initSet(al, -10);
1315
1316	debug.assert((try a.to(i32)) == -10);
1317	}
1318
1319	test "big.int compare" {
1320	var a = try Int.initSet(al, -11);
1321	var b = try Int.initSet(al, 10);
1322
1323	debug.assert(a.cmpAbs(&b) == 1);
1324	debug.assert(a.cmp(&b) == -1);
1325	}
1326
1327	test "big.int compare similar" {
1328	var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee);
1329	var b = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeef);
1330
1331	debug.assert(a.cmpAbs(&b) == -1);
1332	debug.assert(b.cmpAbs(&a) == 1);
1333	}
1334
1335	test "big.int compare different limb size" {
1336	var a = try Int.initSet(al, @maxValue(Limb) + 1);
1337	var b = try Int.initSet(al, 1);
1338
1339	debug.assert(a.cmpAbs(&b) == 1);
1340	debug.assert(b.cmpAbs(&a) == -1);
1341	}
1342
1343	test "big.int compare multi-limb" {
1344	var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
1345	var b = try Int.initSet(al, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);
1346
1347	debug.assert(a.cmpAbs(&b) == 1);
1348	debug.assert(a.cmp(&b) == -1);
1349	}
1350
1351	test "big.int equality" {
1352	var a = try Int.initSet(al, 0xffffffff1);
1353	var b = try Int.initSet(al, -0xffffffff1);
1354
1355	debug.assert(a.eqAbs(&b));
1356	debug.assert(!a.eq(&b));
1357	}
1358
1359	test "big.int abs" {
1360	var a = try Int.initSet(al, -5);
1361
1362	a.abs();
1363	debug.assert((try a.to(u32)) == 5);
1364
1365	a.abs();
1366	debug.assert((try a.to(u32)) == 5);
1367	}
1368
1369	test "big.int negate" {
1370	var a = try Int.initSet(al, 5);
1371
1372	a.negate();
1373	debug.assert((try a.to(i32)) == -5);
1374
1375	a.negate();
1376	debug.assert((try a.to(i32)) == 5);
1377	}
1378
1379	test "big.int add single-single" {
1380	var a = try Int.initSet(al, 50);
1381	var b = try Int.initSet(al, 5);
1382
1383	var c = try Int.init(al);
1384	try c.add(&a, &b);
1385
1386	debug.assert((try c.to(u32)) == 55);
1387	}
1388
1389	test "big.int add multi-single" {
1390	var a = try Int.initSet(al, @maxValue(Limb) + 1);
1391	var b = try Int.initSet(al, 1);
1392
1393	var c = try Int.init(al);
1394
1395	try c.add(&a, &b);
1396	debug.assert((try c.to(DoubleLimb)) == @maxValue(Limb) + 2);
1397
1398	try c.add(&b, &a);
1399	debug.assert((try c.to(DoubleLimb)) == @maxValue(Limb) + 2);
1400	}
1401
1402	test "big.int add multi-multi" {
1403	const op1 = 0xefefefef7f7f7f7f;
1404	const op2 = 0xfefefefe9f9f9f9f;
1405	var a = try Int.initSet(al, op1);
1406	var b = try Int.initSet(al, op2);
1407
1408	var c = try Int.init(al);
1409	try c.add(&a, &b);
1410
1411	debug.assert((try c.to(u128)) == op1 + op2);
1412	}
1413
1414	test "big.int add zero-zero" {
1415	var a = try Int.initSet(al, 0);
1416	var b = try Int.initSet(al, 0);
1417
1418	var c = try Int.init(al);
1419	try c.add(&a, &b);
1420
1421	debug.assert((try c.to(u32)) == 0);
1422	}
1423
1424	test "big.int add alias multi-limb nonzero-zero" {
1425	const op1 = 0xffffffff777777771;
1426	var a = try Int.initSet(al, op1);
1427	var b = try Int.initSet(al, 0);
1428
1429	try a.add(&a, &b);
1430
1431	debug.assert((try a.to(u128)) == op1);
1432	}
1433
1434	test "big.int add sign" {
1435	var a = try Int.init(al);
1436
1437	try a.add(1, 2);
1438	debug.assert((try a.to(i32)) == 3);
1439
1440	try a.add(-1, 2);
1441	debug.assert((try a.to(i32)) == 1);
1442
1443	try a.add(1, -2);
1444	debug.assert((try a.to(i32)) == -1);
1445
1446	try a.add(-1, -2);
1447	debug.assert((try a.to(i32)) == -3);
1448	}
1449
1450	test "big.int sub single-single" {
1451	var a = try Int.initSet(al, 50);
1452	var b = try Int.initSet(al, 5);
1453
1454	var c = try Int.init(al);
1455	try c.sub(&a, &b);
1456
1457	debug.assert((try c.to(u32)) == 45);
1458	}
1459
1460	test "big.int sub multi-single" {
1461	var a = try Int.initSet(al, @maxValue(Limb) + 1);
1462	var b = try Int.initSet(al, 1);
1463
1464	var c = try Int.init(al);
1465	try c.sub(&a, &b);
1466
1467	debug.assert((try c.to(Limb)) == @maxValue(Limb));
1468	}
1469
1470	test "big.int sub multi-multi" {
1471	const op1 = 0xefefefefefefefefefefefef;
1472	const op2 = 0xabababababababababababab;
1473
1474	var a = try Int.initSet(al, op1);
1475	var b = try Int.initSet(al, op2);
1476
1477	var c = try Int.init(al);
1478	try c.sub(&a, &b);
1479
1480	debug.assert((try c.to(u128)) == op1 - op2);
1481	}
1482
1483	test "big.int sub equal" {
1484	var a = try Int.initSet(al, 0x11efefefefefefefefefefefef);
1485	var b = try Int.initSet(al, 0x11efefefefefefefefefefefef);
1486
1487	var c = try Int.init(al);
1488	try c.sub(&a, &b);
1489
1490	debug.assert((try c.to(u32)) == 0);
1491	}
1492
1493	test "big.int sub sign" {
1494	var a = try Int.init(al);
1495
1496	try a.sub(1, 2);
1497	debug.assert((try a.to(i32)) == -1);
1498
1499	try a.sub(-1, 2);
1500	debug.assert((try a.to(i32)) == -3);
1501
1502	try a.sub(1, -2);
1503	debug.assert((try a.to(i32)) == 3);
1504
1505	try a.sub(-1, -2);
1506	debug.assert((try a.to(i32)) == 1);
1507
1508	try a.sub(-2, -1);
1509	debug.assert((try a.to(i32)) == -1);
1510	}
1511
1512	test "big.int mul single-single" {
1513	var a = try Int.initSet(al, 50);
1514	var b = try Int.initSet(al, 5);
1515
1516	var c = try Int.init(al);
1517	try c.mul(&a, &b);
1518
1519	debug.assert((try c.to(u64)) == 250);
1520	}
1521
1522	test "big.int mul multi-single" {
1523	var a = try Int.initSet(al, @maxValue(Limb));
1524	var b = try Int.initSet(al, 2);
1525
1526	var c = try Int.init(al);
1527	try c.mul(&a, &b);
1528
1529	debug.assert((try c.to(DoubleLimb)) == 2 * @maxValue(Limb));
1530	}
1531
1532	test "big.int mul multi-multi" {
1533	const op1 = 0x998888efefefefefefefef;
1534	const op2 = 0x333000abababababababab;
1535	var a = try Int.initSet(al, op1);
1536	var b = try Int.initSet(al, op2);
1537
1538	var c = try Int.init(al);
1539	try c.mul(&a, &b);
1540
1541	debug.assert((try c.to(u256)) == op1 * op2);
1542	}
1543
1544	test "big.int mul alias r with a" {
1545	var a = try Int.initSet(al, @maxValue(Limb));
1546	var b = try Int.initSet(al, 2);
1547
1548	try a.mul(&a, &b);
1549
1550	debug.assert((try a.to(DoubleLimb)) == 2 * @maxValue(Limb));
1551	}
1552
1553	test "big.int mul alias r with b" {
1554	var a = try Int.initSet(al, @maxValue(Limb));
1555	var b = try Int.initSet(al, 2);
1556
1557	try a.mul(&b, &a);
1558
1559	debug.assert((try a.to(DoubleLimb)) == 2 * @maxValue(Limb));
1560	}
1561
1562	test "big.int mul alias r with a and b" {
1563	var a = try Int.initSet(al, @maxValue(Limb));
1564
1565	try a.mul(&a, &a);
1566
1567	debug.assert((try a.to(DoubleLimb)) == @maxValue(Limb) * @maxValue(Limb));
1568	}
1569
1570	test "big.int mul a*0" {
1571	var a = try Int.initSet(al, 0xefefefefefefefef);
1572	var b = try Int.initSet(al, 0);
1573
1574	var c = try Int.init(al);
1575	try c.mul(&a, &b);
1576
1577	debug.assert((try c.to(u32)) == 0);
1578	}
1579
1580	test "big.int mul 0*0" {
1581	var a = try Int.initSet(al, 0);
1582	var b = try Int.initSet(al, 0);
1583
1584	var c = try Int.init(al);
1585	try c.mul(&a, &b);
1586
1587	debug.assert((try c.to(u32)) == 0);
1588	}
1589
1590	test "big.int div single-single no rem" {
1591	var a = try Int.initSet(al, 50);
1592	var b = try Int.initSet(al, 5);
1593
1594	var q = try Int.init(al);
1595	var r = try Int.init(al);
1596	try Int.divTrunc(&q, &r, &a, &b);
1597
1598	debug.assert((try q.to(u32)) == 10);
1599	debug.assert((try r.to(u32)) == 0);
1600	}
1601
1602	test "big.int div single-single with rem" {
1603	var a = try Int.initSet(al, 49);
1604	var b = try Int.initSet(al, 5);
1605
1606	var q = try Int.init(al);
1607	var r = try Int.init(al);
1608	try Int.divTrunc(&q, &r, &a, &b);
1609
1610	debug.assert((try q.to(u32)) == 9);
1611	debug.assert((try r.to(u32)) == 4);
1612	}
1613
1614	test "big.int div multi-single no rem" {
1615	const op1 = 0xffffeeeeddddcccc;
1616	const op2 = 34;
1617
1618	var a = try Int.initSet(al, op1);
1619	var b = try Int.initSet(al, op2);
1620
1621	var q = try Int.init(al);
1622	var r = try Int.init(al);
1623	try Int.divTrunc(&q, &r, &a, &b);
1624
1625	debug.assert((try q.to(u64)) == op1 / op2);
1626	debug.assert((try r.to(u64)) == 0);
1627	}
1628
1629	test "big.int div multi-single with rem" {
1630	const op1 = 0xffffeeeeddddcccf;
1631	const op2 = 34;
1632
1633	var a = try Int.initSet(al, op1);
1634	var b = try Int.initSet(al, op2);
1635
1636	var q = try Int.init(al);
1637	var r = try Int.init(al);
1638	try Int.divTrunc(&q, &r, &a, &b);
1639
1640	debug.assert((try q.to(u64)) == op1 / op2);
1641	debug.assert((try r.to(u64)) == 3);
1642	}
1643
1644	test "big.int div multi>2-single" {
1645	const op1 = 0xfefefefefefefefefefefefefefefefe;
1646	const op2 = 0xefab8;
1647
1648	var a = try Int.initSet(al, op1);
1649	var b = try Int.initSet(al, op2);
1650
1651	var q = try Int.init(al);
1652	var r = try Int.init(al);
1653	try Int.divTrunc(&q, &r, &a, &b);
1654
1655	debug.assert((try q.to(u128)) == op1 / op2);
1656	debug.assert((try r.to(u32)) == 0x3e4e);
1657	}
1658
1659	test "big.int div single-single q < r" {
1660	var a = try Int.initSet(al, 0x0078f432);
1661	var b = try Int.initSet(al, 0x01000000);
1662
1663	var q = try Int.init(al);
1664	var r = try Int.init(al);
1665	try Int.divTrunc(&q, &r, &a, &b);
1666
1667	debug.assert((try q.to(u64)) == 0);
1668	debug.assert((try r.to(u64)) == 0x0078f432);
1669	}
1670
1671	test "big.int div single-single q == r" {
1672	var a = try Int.initSet(al, 10);
1673	var b = try Int.initSet(al, 10);
1674
1675	var q = try Int.init(al);
1676	var r = try Int.init(al);
1677	try Int.divTrunc(&q, &r, &a, &b);
1678
1679	debug.assert((try q.to(u64)) == 1);
1680	debug.assert((try r.to(u64)) == 0);
1681	}
1682
1683	test "big.int div q=0 alias" {
1684	var a = try Int.initSet(al, 3);
1685	var b = try Int.initSet(al, 10);
1686
1687	try Int.divTrunc(&a, &b, &a, &b);
1688
1689	debug.assert((try a.to(u64)) == 0);
1690	debug.assert((try b.to(u64)) == 3);
1691	}
1692
1693	test "big.int div multi-multi q < r" {
1694	const op1 = 0x1ffffffff0078f432;
1695	const op2 = 0x1ffffffff01000000;
1696	var a = try Int.initSet(al, op1);
1697	var b = try Int.initSet(al, op2);
1698
1699	var q = try Int.init(al);
1700	var r = try Int.init(al);
1701	try Int.divTrunc(&q, &r, &a, &b);
1702
1703	debug.assert((try q.to(u128)) == 0);
1704	debug.assert((try r.to(u128)) == op1);
1705	}
1706
1707	test "big.int div trunc single-single +/+" {
1708	const u: i32 = 5;
1709	const v: i32 = 3;
1710
1711	var a = try Int.initSet(al, u);
1712	var b = try Int.initSet(al, v);
1713
1714	var q = try Int.init(al);
1715	var r = try Int.init(al);
1716	try Int.divTrunc(&q, &r, &a, &b);
1717
1718	// n = q * d + r
1719	// 5 = 1 * 3 + 2
1720	const eq = @divTrunc(u, v);
1721	const er = @mod(u, v);
1722
1723	debug.assert((try q.to(i32)) == eq);
1724	debug.assert((try r.to(i32)) == er);
1725	}
1726
1727	test "big.int div trunc single-single -/+" {
1728	const u: i32 = -5;
1729	const v: i32 = 3;
1730
1731	var a = try Int.initSet(al, u);
1732	var b = try Int.initSet(al, v);
1733
1734	var q = try Int.init(al);
1735	var r = try Int.init(al);
1736	try Int.divTrunc(&q, &r, &a, &b);
1737
1738	// n = q * d + r
1739	// -5 = 1 * -3 - 2
1740	const eq = -1;
1741	const er = -2;
1742
1743	debug.assert((try q.to(i32)) == eq);
1744	debug.assert((try r.to(i32)) == er);
1745	}
1746
1747	test "big.int div trunc single-single +/-" {
1748	const u: i32 = 5;
1749	const v: i32 = -3;
1750
1751	var a = try Int.initSet(al, u);
1752	var b = try Int.initSet(al, v);
1753
1754	var q = try Int.init(al);
1755	var r = try Int.init(al);
1756	try Int.divTrunc(&q, &r, &a, &b);
1757
1758	// n = q * d + r
1759	// 5 = -1 * -3 + 2
1760	const eq = -1;
1761	const er = 2;
1762
1763	debug.assert((try q.to(i32)) == eq);
1764	debug.assert((try r.to(i32)) == er);
1765	}
1766
1767	test "big.int div trunc single-single -/-" {
1768	const u: i32 = -5;
1769	const v: i32 = -3;
1770
1771	var a = try Int.initSet(al, u);
1772	var b = try Int.initSet(al, v);
1773
1774	var q = try Int.init(al);
1775	var r = try Int.init(al);
1776	try Int.divTrunc(&q, &r, &a, &b);
1777
1778	// n = q * d + r
1779	// -5 = 1 * -3 - 2
1780	const eq = 1;
1781	const er = -2;
1782
1783	debug.assert((try q.to(i32)) == eq);
1784	debug.assert((try r.to(i32)) == er);
1785	}
1786
1787	test "big.int div floor single-single +/+" {
1788	const u: i32 = 5;
1789	const v: i32 = 3;
1790
1791	var a = try Int.initSet(al, u);
1792	var b = try Int.initSet(al, v);
1793
1794	var q = try Int.init(al);
1795	var r = try Int.init(al);
1796	try Int.divFloor(&q, &r, &a, &b);
1797
1798	// n = q * d + r
1799	// 5 = 1 * 3 + 2
1800	const eq = 1;
1801	const er = 2;
1802
1803	debug.assert((try q.to(i32)) == eq);
1804	debug.assert((try r.to(i32)) == er);
1805	}
1806
1807	test "big.int div floor single-single -/+" {
1808	const u: i32 = -5;
1809	const v: i32 = 3;
1810
1811	var a = try Int.initSet(al, u);
1812	var b = try Int.initSet(al, v);
1813
1814	var q = try Int.init(al);
1815	var r = try Int.init(al);
1816	try Int.divFloor(&q, &r, &a, &b);
1817
1818	// n = q * d + r
1819	// -5 = -2 * 3 + 1
1820	const eq = -2;
1821	const er = 1;
1822
1823	debug.assert((try q.to(i32)) == eq);
1824	debug.assert((try r.to(i32)) == er);
1825	}
1826
1827	test "big.int div floor single-single +/-" {
1828	const u: i32 = 5;
1829	const v: i32 = -3;
1830
1831	var a = try Int.initSet(al, u);
1832	var b = try Int.initSet(al, v);
1833
1834	var q = try Int.init(al);
1835	var r = try Int.init(al);
1836	try Int.divFloor(&q, &r, &a, &b);
1837
1838	// n = q * d + r
1839	// 5 = -2 * -3 - 1
1840	const eq = -2;
1841	const er = -1;
1842
1843	debug.assert((try q.to(i32)) == eq);
1844	debug.assert((try r.to(i32)) == er);
1845	}
1846
1847	test "big.int div floor single-single -/-" {
1848	const u: i32 = -5;
1849	const v: i32 = -3;
1850
1851	var a = try Int.initSet(al, u);
1852	var b = try Int.initSet(al, v);
1853
1854	var q = try Int.init(al);
1855	var r = try Int.init(al);
1856	try Int.divFloor(&q, &r, &a, &b);
1857
1858	// n = q * d + r
1859	// -5 = 2 * -3 + 1
1860	const eq = 1;
1861	const er = -2;
1862
1863	debug.assert((try q.to(i32)) == eq);
1864	debug.assert((try r.to(i32)) == er);
1865	}
1866
1867	test "big.int div multi-multi with rem" {
1868	var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
1869	var b = try Int.initSet(al, 0x99990000111122223333);
1870
1871	var q = try Int.init(al);
1872	var r = try Int.init(al);
1873	try Int.divTrunc(&q, &r, &a, &b);
1874
1875	debug.assert((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
1876	debug.assert((try r.to(u128)) == 0x28de0acacd806823638);
1877	}
1878
1879	test "big.int div multi-multi no rem" {
1880	var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
1881	var b = try Int.initSet(al, 0x99990000111122223333);
1882
1883	var q = try Int.init(al);
1884	var r = try Int.init(al);
1885	try Int.divTrunc(&q, &r, &a, &b);
1886
1887	debug.assert((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
1888	debug.assert((try r.to(u128)) == 0);
1889	}
1890
1891	test "big.int div multi-multi (2 branch)" {
1892	var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111);
1893	var b = try Int.initSet(al, 0x86666666555555554444444433333333);
1894
1895	var q = try Int.init(al);
1896	var r = try Int.init(al);
1897	try Int.divTrunc(&q, &r, &a, &b);
1898
1899	debug.assert((try q.to(u128)) == 0x10000000000000000);
1900	debug.assert((try r.to(u128)) == 0x44444443444444431111111111111111);
1901	}
1902
1903	test "big.int div multi-multi (3.1/3.3 branch)" {
1904	var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111);
1905	var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171);
1906
1907	var q = try Int.init(al);
1908	var r = try Int.init(al);
1909	try Int.divTrunc(&q, &r, &a, &b);
1910
1911	debug.assert((try q.to(u128)) == 0xfffffffffffffffffff);
1912	debug.assert((try r.to(u256)) == 0x1111111111111111111110b12222222222222222282);
1913	}
1914
1915	test "big.int shift-right single" {
1916	var a = try Int.initSet(al, 0xffff0000);
1917	try a.shiftRight(a, 16);
1918
1919	debug.assert((try a.to(u32)) == 0xffff);
1920	}
1921
1922	test "big.int shift-right multi" {
1923	var a = try Int.initSet(al, 0xffff0000eeee1111dddd2222cccc3333);
1924	try a.shiftRight(a, 67);
1925
1926	debug.assert((try a.to(u64)) == 0x1fffe0001dddc222);
1927	}
1928
1929	test "big.int shift-left single" {
1930	var a = try Int.initSet(al, 0xffff);
1931	try a.shiftLeft(a, 16);
1932
1933	debug.assert((try a.to(u64)) == 0xffff0000);
1934	}
1935
1936	test "big.int shift-left multi" {
1937	var a = try Int.initSet(al, 0x1fffe0001dddc222);
1938	try a.shiftLeft(a, 67);
1939
1940	debug.assert((try a.to(u128)) == 0xffff0000eeee11100000000000000000);
1941	}
1942
1943	test "big.int shift-right negative" {
1944	var a = try Int.init(al);
1945
1946	try a.shiftRight(-20, 2);
1947	debug.assert((try a.to(i32)) == -20 >> 2);
1948
1949	try a.shiftRight(-5, 10);
1950	debug.assert((try a.to(i32)) == -5 >> 10);
1951	}
1952
1953	test "big.int shift-left negative" {
1954	var a = try Int.init(al);
1955
1956	try a.shiftRight(-10, 1232);
1957	debug.assert((try a.to(i32)) == -10 >> 1232);
1958	}
1959
1960	test "big.int bitwise and simple" {
1961	var a = try Int.initSet(al, 0xffffffff11111111);
1962	var b = try Int.initSet(al, 0xeeeeeeee22222222);
1963
1964	try a.bitAnd(&a, &b);
1965
1966	debug.assert((try a.to(u64)) == 0xeeeeeeee00000000);
1967	}
1968
1969	test "big.int bitwise and multi-limb" {
1970	var a = try Int.initSet(al, @maxValue(Limb) + 1);
1971	var b = try Int.initSet(al, @maxValue(Limb));
1972
1973	try a.bitAnd(&a, &b);
1974
1975	debug.assert((try a.to(u128)) == 0);
1976	}
1977
1978	test "big.int bitwise xor simple" {
1979	var a = try Int.initSet(al, 0xffffffff11111111);
1980	var b = try Int.initSet(al, 0xeeeeeeee22222222);
1981
1982	try a.bitXor(&a, &b);
1983
1984	debug.assert((try a.to(u64)) == 0x1111111133333333);
1985	}
1986
1987	test "big.int bitwise xor multi-limb" {
1988	var a = try Int.initSet(al, @maxValue(Limb) + 1);
1989	var b = try Int.initSet(al, @maxValue(Limb));
1990
1991	try a.bitXor(&a, &b);
1992
1993	debug.assert((try a.to(DoubleLimb)) == (@maxValue(Limb) + 1) ^ @maxValue(Limb));
1994	}
1995
1996	test "big.int bitwise or simple" {
1997	var a = try Int.initSet(al, 0xffffffff11111111);
1998	var b = try Int.initSet(al, 0xeeeeeeee22222222);
1999
2000	try a.bitOr(&a, &b);
2001
2002	debug.assert((try a.to(u64)) == 0xffffffff33333333);
2003	}
2004
2005	test "big.int bitwise or multi-limb" {
2006	var a = try Int.initSet(al, @maxValue(Limb) + 1);
2007	var b = try Int.initSet(al, @maxValue(Limb));
2008
2009	try a.bitOr(&a, &b);
2010
2011	// TODO: big.int.cpp or is wrong on multi-limb.
2012	debug.assert((try a.to(DoubleLimb)) == (@maxValue(Limb) + 1) + @maxValue(Limb));
2013	}
2014
2015	test "big.int var args" {
2016	var a = try Int.initSet(al, 5);
2017
2018	try a.add(&a, 6);
2019	debug.assert((try a.to(u64)) == 11);
2020
2021	debug.assert(a.cmp(11) == 0);
2022	debug.assert(a.cmp(14) <= 0);
2023	}

std/math/index.zig+12-1

 @@ -132,6 +132,8 @@ pub const tan = @import("tan.zig").tan;
 pub const complex = @import("complex/index.zig");
 pub const Complex = complex.Complex;
+pub const big = @import("big/index.zig");
 test "math" {
     _ = @import("nan.zig");
     _ = @import("isnan.zig");
 @@ -177,6 +179,8 @@ test "math" {
     _ = @import("tan.zig");
     _ = @import("complex/index.zig");
+    _ = @import("big/index.zig");
 }
 pub fn min(x: var, y: var) @typeOf(x + y) {
 @@ -306,7 +310,14 @@ test "math.rotl" {
 }
 pub fn Log2Int(comptime T: type) type {
-    return @IntType(false, log2(T.bit_count));
+    // comptime ceil log2
+    comptime var count: usize = 0;
+    comptime var s = T.bit_count - 1;
+    inline while (s != 0) : (s >>= 1) {
+        count += 1;
+    }
+    return @IntType(false, count);
 }
 test "math overflow functions" {

std/mem.zig+11-11

...	@@ -304,20 +304,20 @@ pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, nee	...	@@ -304,20 +304,20 @@ pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, nee
304	}	304	}
305		305
306	test "mem.indexOf" {	306	test "mem.indexOf" {
307	assert(??indexOf(u8, "one two three four", "four") == 14);	307	assert(indexOf(u8, "one two three four", "four").? == 14);
308	assert(??lastIndexOf(u8, "one two three two four", "two") == 14);	308	assert(lastIndexOf(u8, "one two three two four", "two").? == 14);
309	assert(indexOf(u8, "one two three four", "gour") == null);	309	assert(indexOf(u8, "one two three four", "gour") == null);
310	assert(lastIndexOf(u8, "one two three four", "gour") == null);	310	assert(lastIndexOf(u8, "one two three four", "gour") == null);
311	assert(??indexOf(u8, "foo", "foo") == 0);	311	assert(indexOf(u8, "foo", "foo").? == 0);
312	assert(??lastIndexOf(u8, "foo", "foo") == 0);	312	assert(lastIndexOf(u8, "foo", "foo").? == 0);
313	assert(indexOf(u8, "foo", "fool") == null);	313	assert(indexOf(u8, "foo", "fool") == null);
314	assert(lastIndexOf(u8, "foo", "lfoo") == null);	314	assert(lastIndexOf(u8, "foo", "lfoo") == null);
315	assert(lastIndexOf(u8, "foo", "fool") == null);	315	assert(lastIndexOf(u8, "foo", "fool") == null);
316		316
317	assert(??indexOf(u8, "foo foo", "foo") == 0);	317	assert(indexOf(u8, "foo foo", "foo").? == 0);
318	assert(??lastIndexOf(u8, "foo foo", "foo") == 4);	318	assert(lastIndexOf(u8, "foo foo", "foo").? == 4);
319	assert(??lastIndexOfAny(u8, "boo, cat", "abo") == 6);	319	assert(lastIndexOfAny(u8, "boo, cat", "abo").? == 6);
320	assert(??lastIndexOfScalar(u8, "boo", 'o') == 2);	320	assert(lastIndexOfScalar(u8, "boo", 'o').? == 2);
321	}	321	}
322		322
323	/// Reads an integer from memory with size equal to bytes.len.	323	/// Reads an integer from memory with size equal to bytes.len.
...	@@ -432,9 +432,9 @@ pub fn split(buffer: []const u8, split_bytes: []const u8) SplitIterator {	...	@@ -432,9 +432,9 @@ pub fn split(buffer: []const u8, split_bytes: []const u8) SplitIterator {
432		432
433	test "mem.split" {	433	test "mem.split" {
434	var it = split(" abc def ghi ", " ");	434	var it = split(" abc def ghi ", " ");
435	assert(eql(u8, ??it.next(), "abc"));	435	assert(eql(u8, it.next().?, "abc"));
436	assert(eql(u8, ??it.next(), "def"));	436	assert(eql(u8, it.next().?, "def"));
437	assert(eql(u8, ??it.next(), "ghi"));	437	assert(eql(u8, it.next().?, "ghi"));
438	assert(it.next() == null);	438	assert(it.next() == null);
439	}	439	}
440		440

std/os/child_process.zig+9-9

std/os/darwin.zig+4-4

...	@@ -327,7 +327,7 @@ pub fn raise(sig: i32) usize {	...	@@ -327,7 +327,7 @@ pub fn raise(sig: i32) usize {
327	}	327	}
328		328
329	pub fn read(fd: i32, buf: [*]u8, nbyte: usize) usize {	329	pub fn read(fd: i32, buf: [*]u8, nbyte: usize) usize {
330	return errnoWrap(c.read(fd, @ptrCast([*]c_void, buf), nbyte));	330	return errnoWrap(c.read(fd, @ptrCast(*c_void, buf), nbyte));
331	}	331	}
332		332
333	pub fn stat(noalias path: []const u8, noalias buf: stat) usize {	333	pub fn stat(noalias path: []const u8, noalias buf: stat) usize {
...	@@ -335,17 +335,17 @@ pub fn stat(noalias path: []const u8, noalias buf: stat) usize {	...	@@ -335,17 +335,17 @@ pub fn stat(noalias path: []const u8, noalias buf: stat) usize {
335	}	335	}
336		336
337	pub fn write(fd: i32, buf: [*]const u8, nbyte: usize) usize {	337	pub fn write(fd: i32, buf: [*]const u8, nbyte: usize) usize {
338	return errnoWrap(c.write(fd, @ptrCast([*]const c_void, buf), nbyte));	338	return errnoWrap(c.write(fd, @ptrCast(*const c_void, buf), nbyte));
339	}	339	}
340		340
341	pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: u32, fd: i32, offset: isize) usize {	341	pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: u32, fd: i32, offset: isize) usize {
342	const ptr_result = c.mmap(@ptrCast([*]c_void, address), length, @bitCast(c_int, c_uint(prot)), @bitCast(c_int, c_uint(flags)), fd, offset);	342	const ptr_result = c.mmap(@ptrCast(*c_void, address), length, @bitCast(c_int, c_uint(prot)), @bitCast(c_int, c_uint(flags)), fd, offset);
343	const isize_result = @bitCast(isize, @ptrToInt(ptr_result));	343	const isize_result = @bitCast(isize, @ptrToInt(ptr_result));
344	return errnoWrap(isize_result);	344	return errnoWrap(isize_result);
345	}	345	}
346		346
347	pub fn munmap(address: usize, length: usize) usize {	347	pub fn munmap(address: usize, length: usize) usize {
348	return errnoWrap(c.munmap(@intToPtr([*]c_void, address), length));	348	return errnoWrap(c.munmap(@intToPtr(*c_void, address), length));
349	}	349	}
350		350
351	pub fn unlink(path: [*]const u8) usize {	351	pub fn unlink(path: [*]const u8) usize {

std/os/file.zig+16-3

 @@ -96,7 +96,20 @@ pub const File = struct {
         return File{ .handle = handle };
     }
-    pub fn access(allocator: *mem.Allocator, path: []const u8, file_mode: os.FileMode) !bool {
+    pub const AccessError = error{
+        PermissionDenied,
+        NotFound,
+        NameTooLong,
+        BadMode,
+        BadPathName,
+        Io,
+        SystemResources,
+        OutOfMemory,
+        Unexpected,
+    };
+    pub fn access(allocator: *mem.Allocator, path: []const u8, file_mode: os.FileMode) AccessError!bool {
         const path_with_null = try std.cstr.addNullByte(allocator, path);
         defer allocator.free(path_with_null);
 @@ -123,7 +136,7 @@ pub const File = struct {
             }
             return true;
         } else if (is_windows) {
-            if (os.windows.PathFileExists(path_with_null.ptr) == os.windows.TRUE) {
+            if (os.windows.GetFileAttributesA(path_with_null.ptr) != os.windows.INVALID_FILE_ATTRIBUTES) {
                 return true;
             }
 @@ -334,7 +347,7 @@ pub const File = struct {
             while (index < buffer.len) {
                 const want_read_count = windows.DWORD(math.min(windows.DWORD(@maxValue(windows.DWORD)), buffer.len - index));
                 var amt_read: windows.DWORD = undefined;
-                if (windows.ReadFile(self.handle, @ptrCast([*]c_void, buffer.ptr + index), want_read_count, &amt_read, null) == 0) {
+                if (windows.ReadFile(self.handle, @ptrCast(*c_void, buffer.ptr + index), want_read_count, &amt_read, null) == 0) {
                     const err = windows.GetLastError();
                     return switch (err) {
                         windows.ERROR.OPERATION_ABORTED => continue,

std/os/index.zig+213-93

...	@@ -422,10 +422,10 @@ pub fn posixExecve(argv: []const []const u8, env_map: *const BufMap, allocator:	...	@@ -422,10 +422,10 @@ pub fn posixExecve(argv: []const []const u8, env_map: *const BufMap, allocator:
422		422
423	const exe_path = argv[0];	423	const exe_path = argv[0];
424	if (mem.indexOfScalar(u8, exe_path, '/') != null) {	424	if (mem.indexOfScalar(u8, exe_path, '/') != null) {
425	return posixExecveErrnoToErr(posix.getErrno(posix.execve(??argv_buf[0], argv_buf.ptr, envp_buf.ptr)));	425	return posixExecveErrnoToErr(posix.getErrno(posix.execve(argv_buf[0].?, argv_buf.ptr, envp_buf.ptr)));
426	}	426	}
427		427
428	const PATH = getEnvPosix("PATH") ?? "/usr/local/bin:/bin/:/usr/bin";	428	const PATH = getEnvPosix("PATH") orelse "/usr/local/bin:/bin/:/usr/bin";
429	// PATH.len because it is >= the largest search_path	429	// PATH.len because it is >= the largest search_path
430	// +1 for the / to join the search path and exe_path	430	// +1 for the / to join the search path and exe_path
431	// +1 for the null terminating byte	431	// +1 for the null terminating byte
...	@@ -490,7 +490,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {	...	@@ -490,7 +490,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
490	errdefer result.deinit();	490	errdefer result.deinit();
491		491
492	if (is_windows) {	492	if (is_windows) {
493	const ptr = windows.GetEnvironmentStringsA() ?? return error.OutOfMemory;	493	const ptr = windows.GetEnvironmentStringsA() orelse return error.OutOfMemory;
494	defer assert(windows.FreeEnvironmentStringsA(ptr) != 0);	494	defer assert(windows.FreeEnvironmentStringsA(ptr) != 0);
495		495
496	var i: usize = 0;	496	var i: usize = 0;
...	@@ -573,7 +573,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) ![]u8 {	...	@@ -573,7 +573,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) ![]u8 {
573	return allocator.shrink(u8, buf, result);	573	return allocator.shrink(u8, buf, result);
574	}	574	}
575	} else {	575	} else {
576	const result = getEnvPosix(key) ?? return error.EnvironmentVariableNotFound;	576	const result = getEnvPosix(key) orelse return error.EnvironmentVariableNotFound;
577	return mem.dupe(allocator, u8, result);	577	return mem.dupe(allocator, u8, result);
578	}	578	}
579	}	579	}
...	@@ -714,7 +714,7 @@ pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path:	...	@@ -714,7 +714,7 @@ pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path:
714	else => return err, // TODO zig should know this set does not include PathAlreadyExists	714	else => return err, // TODO zig should know this set does not include PathAlreadyExists
715	}	715	}
716		716
717	const dirname = os.path.dirname(new_path);	717	const dirname = os.path.dirname(new_path) orelse ".";
718		718
719	var rand_buf: [12]u8 = undefined;	719	var rand_buf: [12]u8 = undefined;
720	const tmp_path = try allocator.alloc(u8, dirname.len + 1 + base64.Base64Encoder.calcSize(rand_buf.len));	720	const tmp_path = try allocator.alloc(u8, dirname.len + 1 + base64.Base64Encoder.calcSize(rand_buf.len));
...	@@ -734,7 +734,23 @@ pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path:	...	@@ -734,7 +734,23 @@ pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path:
734	}	734	}
735	}	735	}
736		736
737	pub fn deleteFile(allocator: *Allocator, file_path: []const u8) !void {	737	pub const DeleteFileError = error{
		738	FileNotFound,
		739	AccessDenied,
		740	FileBusy,
		741	FileSystem,
		742	IsDir,
		743	SymLinkLoop,
		744	NameTooLong,
		745	NotDir,
		746	SystemResources,
		747	ReadOnlyFileSystem,
		748	OutOfMemory,
		749
		750	Unexpected,
		751	};
		752
		753	pub fn deleteFile(allocator: *Allocator, file_path: []const u8) DeleteFileError!void {
738	if (builtin.os == Os.windows) {	754	if (builtin.os == Os.windows) {
739	return deleteFileWindows(allocator, file_path);	755	return deleteFileWindows(allocator, file_path);
740	} else {	756	} else {
...	@@ -844,14 +860,14 @@ pub const AtomicFile = struct {	...	@@ -844,14 +860,14 @@ pub const AtomicFile = struct {
844		860
845	var rand_buf: [12]u8 = undefined;	861	var rand_buf: [12]u8 = undefined;
846		862
847	const dirname_component_len = if (dirname.len == 0) 0 else dirname.len + 1;	863	const dirname_component_len = if (dirname) \|d\| d.len + 1 else 0;
848	const tmp_path = try allocator.alloc(u8, dirname_component_len +	864	const tmp_path = try allocator.alloc(u8, dirname_component_len +
849	base64.Base64Encoder.calcSize(rand_buf.len));	865	base64.Base64Encoder.calcSize(rand_buf.len));
850	errdefer allocator.free(tmp_path);	866	errdefer allocator.free(tmp_path);
851		867
852	if (dirname.len != 0) {	868	if (dirname) \|dir\| {
853	mem.copy(u8, tmp_path[0..], dirname);	869	mem.copy(u8, tmp_path[0..], dir);
854	tmp_path[dirname.len] = os.path.sep;	870	tmp_path[dir.len] = os.path.sep;
855	}	871	}
856		872
857	while (true) {	873	while (true) {
...	@@ -1019,37 +1035,66 @@ pub fn makePath(allocator: *Allocator, full_path: []const u8) !void {	...	@@ -1019,37 +1035,66 @@ pub fn makePath(allocator: *Allocator, full_path: []const u8) !void {
1019	}	1035	}
1020	}	1036	}
1021		1037
		1038	pub const DeleteDirError = error{
		1039	AccessDenied,
		1040	FileBusy,
		1041	SymLinkLoop,
		1042	NameTooLong,
		1043	FileNotFound,
		1044	SystemResources,
		1045	NotDir,
		1046	DirNotEmpty,
		1047	ReadOnlyFileSystem,
		1048	OutOfMemory,
		1049
		1050	Unexpected,
		1051	};
		1052
1022	/// Returns ::error.DirNotEmpty if the directory is not empty.	1053	/// Returns ::error.DirNotEmpty if the directory is not empty.
1023	/// To delete a directory recursively, see ::deleteTree	1054	/// To delete a directory recursively, see ::deleteTree
1024	pub fn deleteDir(allocator: *Allocator, dir_path: []const u8) !void {	1055	pub fn deleteDir(allocator: *Allocator, dir_path: []const u8) DeleteDirError!void {
1025	const path_buf = try allocator.alloc(u8, dir_path.len + 1);	1056	const path_buf = try allocator.alloc(u8, dir_path.len + 1);
1026	defer allocator.free(path_buf);	1057	defer allocator.free(path_buf);
1027		1058
1028	mem.copy(u8, path_buf, dir_path);	1059	mem.copy(u8, path_buf, dir_path);
1029	path_buf[dir_path.len] = 0;	1060	path_buf[dir_path.len] = 0;
1030		1061
1031	const err = posix.getErrno(posix.rmdir(path_buf.ptr));	1062	switch (builtin.os) {
1032	if (err > 0) {	1063	Os.windows => {
1033	return switch (err) {	1064	if (windows.RemoveDirectoryA(path_buf.ptr) == 0) {
1034	posix.EACCES, posix.EPERM => error.AccessDenied,	1065	const err = windows.GetLastError();
1035	posix.EBUSY => error.FileBusy,	1066	return switch (err) {
1036	posix.EFAULT, posix.EINVAL => unreachable,	1067	windows.ERROR.PATH_NOT_FOUND => error.FileNotFound,
1037	posix.ELOOP => error.SymLinkLoop,	1068	windows.ERROR.DIR_NOT_EMPTY => error.DirNotEmpty,
1038	posix.ENAMETOOLONG => error.NameTooLong,	1069	else => unexpectedErrorWindows(err),
1039	posix.ENOENT => error.FileNotFound,	1070	};
1040	posix.ENOMEM => error.SystemResources,	1071	}
1041	posix.ENOTDIR => error.NotDir,	1072	},
1042	posix.EEXIST, posix.ENOTEMPTY => error.DirNotEmpty,	1073	Os.linux, Os.macosx, Os.ios => {
1043	posix.EROFS => error.ReadOnlyFileSystem,	1074	const err = posix.getErrno(posix.rmdir(path_buf.ptr));
1044	else => unexpectedErrorPosix(err),	1075	if (err > 0) {
1045	};	1076	return switch (err) {
		1077	posix.EACCES, posix.EPERM => error.AccessDenied,
		1078	posix.EBUSY => error.FileBusy,
		1079	posix.EFAULT, posix.EINVAL => unreachable,
		1080	posix.ELOOP => error.SymLinkLoop,
		1081	posix.ENAMETOOLONG => error.NameTooLong,
		1082	posix.ENOENT => error.FileNotFound,
		1083	posix.ENOMEM => error.SystemResources,
		1084	posix.ENOTDIR => error.NotDir,
		1085	posix.EEXIST, posix.ENOTEMPTY => error.DirNotEmpty,
		1086	posix.EROFS => error.ReadOnlyFileSystem,
		1087	else => unexpectedErrorPosix(err),
		1088	};
		1089	}
		1090	},
		1091	else => @compileError("unimplemented"),
1046	}	1092	}
1047	}	1093	}
1048		1094
1049	/// Whether ::full_path describes a symlink, file, or directory, this function	1095	/// Whether ::full_path describes a symlink, file, or directory, this function
1050	/// removes it. If it cannot be removed because it is a non-empty directory,	1096	/// removes it. If it cannot be removed because it is a non-empty directory,
1051	/// this function recursively removes its entries and then tries again.	1097	/// this function recursively removes its entries and then tries again.
1052	/// TODO non-recursive implementation
1053	const DeleteTreeError = error{	1098	const DeleteTreeError = error{
1054	OutOfMemory,	1099	OutOfMemory,
1055	AccessDenied,	1100	AccessDenied,
...	@@ -1128,7 +1173,7 @@ pub fn deleteTree(allocator: *Allocator, full_path: []const u8) DeleteTreeError!	...	@@ -1128,7 +1173,7 @@ pub fn deleteTree(allocator: *Allocator, full_path: []const u8) DeleteTreeError!
1128	try full_entry_buf.resize(full_path.len + entry.name.len + 1);	1173	try full_entry_buf.resize(full_path.len + entry.name.len + 1);
1129	const full_entry_path = full_entry_buf.toSlice();	1174	const full_entry_path = full_entry_buf.toSlice();
1130	mem.copy(u8, full_entry_path, full_path);	1175	mem.copy(u8, full_entry_path, full_path);
1131	full_entry_path[full_path.len] = '/';	1176	full_entry_path[full_path.len] = path.sep;
1132	mem.copy(u8, full_entry_path[full_path.len + 1 ..], entry.name);	1177	mem.copy(u8, full_entry_path[full_path.len + 1 ..], entry.name);
1133		1178
1134	try deleteTree(allocator, full_entry_path);	1179	try deleteTree(allocator, full_entry_path);
...	@@ -1139,16 +1184,29 @@ pub fn deleteTree(allocator: *Allocator, full_path: []const u8) DeleteTreeError!	...	@@ -1139,16 +1184,29 @@ pub fn deleteTree(allocator: *Allocator, full_path: []const u8) DeleteTreeError!
1139	}	1184	}
1140		1185
1141	pub const Dir = struct {	1186	pub const Dir = struct {
1142	fd: i32,	1187	handle: Handle,
1143	darwin_seek: darwin_seek_t,
1144	allocator: *Allocator,	1188	allocator: *Allocator,
1145	buf: []u8,
1146	index: usize,
1147	end_index: usize,
1148		1189
1149	const darwin_seek_t = switch (builtin.os) {	1190	pub const Handle = switch (builtin.os) {
1150	Os.macosx, Os.ios => i64,	1191	Os.macosx, Os.ios => struct {
1151	else => void,	1192	fd: i32,
		1193	seek: i64,
		1194	buf: []u8,
		1195	index: usize,
		1196	end_index: usize,
		1197	},
		1198	Os.linux => struct {
		1199	fd: i32,
		1200	buf: []u8,
		1201	index: usize,
		1202	end_index: usize,
		1203	},
		1204	Os.windows => struct {
		1205	handle: windows.HANDLE,
		1206	find_file_data: windows.WIN32_FIND_DATAA,
		1207	first: bool,
		1208	},
		1209	else => @compileError("unimplemented"),
1152	};	1210	};
1153		1211
1154	pub const Entry = struct {	1212	pub const Entry = struct {
...	@@ -1168,81 +1226,122 @@ pub const Dir = struct {	...	@@ -1168,81 +1226,122 @@ pub const Dir = struct {
1168	};	1226	};
1169	};	1227	};
1170		1228
1171	pub fn open(allocator: *Allocator, dir_path: []const u8) !Dir {	1229	pub const OpenError = error{
1172	const fd = switch (builtin.os) {	1230	PathNotFound,
1173	Os.windows => @compileError("TODO support Dir.open for windows"),	1231	NotDir,
1174	Os.linux => try posixOpen(allocator, dir_path, posix.O_RDONLY \| posix.O_DIRECTORY \| posix.O_CLOEXEC, 0),	1232	AccessDenied,
1175	Os.macosx, Os.ios => try posixOpen(	1233	FileTooBig,
1176	allocator,	1234	IsDir,
1177	dir_path,	1235	SymLinkLoop,
1178	posix.O_RDONLY \| posix.O_NONBLOCK \| posix.O_DIRECTORY \| posix.O_CLOEXEC,	1236	ProcessFdQuotaExceeded,
1179	0,	1237	NameTooLong,
1180	),	1238	SystemFdQuotaExceeded,
1181	else => @compileError("Dir.open is not supported for this platform"),	1239	NoDevice,
1182	};	1240	SystemResources,
1183	const darwin_seek_init = switch (builtin.os) {	1241	NoSpaceLeft,
1184	Os.macosx, Os.ios => 0,	1242	PathAlreadyExists,
1185	else => {},	1243	OutOfMemory,
1186	};	1244
		1245	Unexpected,
		1246	};
		1247
		1248	pub fn open(allocator: *Allocator, dir_path: []const u8) OpenError!Dir {
1187	return Dir{	1249	return Dir{
1188	.allocator = allocator,	1250	.allocator = allocator,
1189	.fd = fd,	1251	.handle = switch (builtin.os) {
1190	.darwin_seek = darwin_seek_init,	1252	Os.windows => blk: {
1191	.index = 0,	1253	var find_file_data: windows.WIN32_FIND_DATAA = undefined;
1192	.end_index = 0,	1254	const handle = try windows_util.windowsFindFirstFile(allocator, dir_path, &find_file_data);
1193	.buf = []u8{},	1255	break :blk Handle{
		1256	.handle = handle,
		1257	.find_file_data = find_file_data, // TODO guaranteed copy elision
		1258	.first = true,
		1259	};
		1260	},
		1261	Os.macosx, Os.ios => Handle{
		1262	.fd = try posixOpen(
		1263	allocator,
		1264	dir_path,
		1265	posix.O_RDONLY \| posix.O_NONBLOCK \| posix.O_DIRECTORY \| posix.O_CLOEXEC,
		1266	0,
		1267	),
		1268	.seek = 0,
		1269	.index = 0,
		1270	.end_index = 0,
		1271	.buf = []u8{},
		1272	},
		1273	Os.linux => Handle{
		1274	.fd = try posixOpen(
		1275	allocator,
		1276	dir_path,
		1277	posix.O_RDONLY \| posix.O_DIRECTORY \| posix.O_CLOEXEC,
		1278	0,
		1279	),
		1280	.index = 0,
		1281	.end_index = 0,
		1282	.buf = []u8{},
		1283	},
		1284	else => @compileError("unimplemented"),
		1285	},
1194	};	1286	};
1195	}	1287	}
1196		1288
1197	pub fn close(self: *Dir) void {	1289	pub fn close(self: *Dir) void {
1198	self.allocator.free(self.buf);	1290	switch (builtin.os) {
1199	os.close(self.fd);	1291	Os.windows => {
		1292	_ = windows.FindClose(self.handle.handle);
		1293	},
		1294	Os.macosx, Os.ios, Os.linux => {
		1295	self.allocator.free(self.handle.buf);
		1296	os.close(self.handle.fd);
		1297	},
		1298	else => @compileError("unimplemented"),
		1299	}
1200	}	1300	}
1201		1301
1202	/// Memory such as file names referenced in this returned entry becomes invalid	1302	/// Memory such as file names referenced in this returned entry becomes invalid
1203	/// with subsequent calls to next, as well as when this ::Dir is deinitialized.	1303	/// with subsequent calls to next, as well as when this `Dir` is deinitialized.
1204	pub fn next(self: *Dir) !?Entry {	1304	pub fn next(self: *Dir) !?Entry {
1205	switch (builtin.os) {	1305	switch (builtin.os) {
1206	Os.linux => return self.nextLinux(),	1306	Os.linux => return self.nextLinux(),
1207	Os.macosx, Os.ios => return self.nextDarwin(),	1307	Os.macosx, Os.ios => return self.nextDarwin(),
1208	Os.windows => return self.nextWindows(),	1308	Os.windows => return self.nextWindows(),
1209	else => @compileError("Dir.next not supported on " ++ @tagName(builtin.os)),	1309	else => @compileError("unimplemented"),
1210	}	1310	}
1211	}	1311	}
1212		1312
1213	fn nextDarwin(self: *Dir) !?Entry {	1313	fn nextDarwin(self: *Dir) !?Entry {
1214	start_over: while (true) {	1314	start_over: while (true) {
1215	if (self.index >= self.end_index) {	1315	if (self.handle.index >= self.handle.end_index) {
1216	if (self.buf.len == 0) {	1316	if (self.handle.buf.len == 0) {
1217	self.buf = try self.allocator.alloc(u8, page_size);	1317	self.handle.buf = try self.allocator.alloc(u8, page_size);
1218	}	1318	}
1219		1319
1220	while (true) {	1320	while (true) {
1221	const result = posix.getdirentries64(self.fd, self.buf.ptr, self.buf.len, &self.darwin_seek);	1321	const result = posix.getdirentries64(self.handle.fd, self.handle.buf.ptr, self.handle.buf.len, &self.handle.seek);
1222	const err = posix.getErrno(result);	1322	const err = posix.getErrno(result);
1223	if (err > 0) {	1323	if (err > 0) {
1224	switch (err) {	1324	switch (err) {
1225	posix.EBADF, posix.EFAULT, posix.ENOTDIR => unreachable,	1325	posix.EBADF, posix.EFAULT, posix.ENOTDIR => unreachable,
1226	posix.EINVAL => {	1326	posix.EINVAL => {
1227	self.buf = try self.allocator.realloc(u8, self.buf, self.buf.len * 2);	1327	self.handle.buf = try self.allocator.realloc(u8, self.handle.buf, self.handle.buf.len * 2);
1228	continue;	1328	continue;
1229	},	1329	},
1230	else => return unexpectedErrorPosix(err),	1330	else => return unexpectedErrorPosix(err),
1231	}	1331	}
1232	}	1332	}
1233	if (result == 0) return null;	1333	if (result == 0) return null;
1234	self.index = 0;	1334	self.handle.index = 0;
1235	self.end_index = result;	1335	self.handle.end_index = result;
1236	break;	1336	break;
1237	}	1337	}
1238	}	1338	}
1239	const darwin_entry = @ptrCast(*align(1) posix.dirent, &self.buf[self.index]);	1339	const darwin_entry = @ptrCast(*align(1) posix.dirent, &self.handle.buf[self.handle.index]);
1240	const next_index = self.index + darwin_entry.d_reclen;	1340	const next_index = self.handle.index + darwin_entry.d_reclen;
1241	self.index = next_index;	1341	self.handle.index = next_index;
1242		1342
1243	const name = @ptrCast([*]u8, &darwin_entry.d_name)[0..darwin_entry.d_namlen];	1343	const name = @ptrCast([*]u8, &darwin_entry.d_name)[0..darwin_entry.d_namlen];
1244		1344
1245	// skip . and .. entries
1246	if (mem.eql(u8, name, ".") or mem.eql(u8, name, "..")) {	1345	if (mem.eql(u8, name, ".") or mem.eql(u8, name, "..")) {
1247	continue :start_over;	1346	continue :start_over;
1248	}	1347	}
...	@@ -1266,38 +1365,59 @@ pub const Dir = struct {	...	@@ -1266,38 +1365,59 @@ pub const Dir = struct {
1266	}	1365	}
1267		1366
1268	fn nextWindows(self: *Dir) !?Entry {	1367	fn nextWindows(self: *Dir) !?Entry {
1269	@compileError("TODO support Dir.next for windows");	1368	while (true) {
		1369	if (self.handle.first) {
		1370	self.handle.first = false;
		1371	} else {
		1372	if (!try windows_util.windowsFindNextFile(self.handle.handle, &self.handle.find_file_data))
		1373	return null;
		1374	}
		1375	const name = std.cstr.toSlice(self.handle.find_file_data.cFileName[0..].ptr);
		1376	if (mem.eql(u8, name, ".") or mem.eql(u8, name, ".."))
		1377	continue;
		1378	const kind = blk: {
		1379	const attrs = self.handle.find_file_data.dwFileAttributes;
		1380	if (attrs & windows.FILE_ATTRIBUTE_DIRECTORY != 0) break :blk Entry.Kind.Directory;
		1381	if (attrs & windows.FILE_ATTRIBUTE_REPARSE_POINT != 0) break :blk Entry.Kind.SymLink;
		1382	if (attrs & windows.FILE_ATTRIBUTE_NORMAL != 0) break :blk Entry.Kind.File;
		1383	break :blk Entry.Kind.Unknown;
		1384	};
		1385	return Entry{
		1386	.name = name,
		1387	.kind = kind,
		1388	};
		1389	}
1270	}	1390	}
1271		1391
1272	fn nextLinux(self: *Dir) !?Entry {	1392	fn nextLinux(self: *Dir) !?Entry {
1273	start_over: while (true) {	1393	start_over: while (true) {
1274	if (self.index >= self.end_index) {	1394	if (self.handle.index >= self.handle.end_index) {
1275	if (self.buf.len == 0) {	1395	if (self.handle.buf.len == 0) {
1276	self.buf = try self.allocator.alloc(u8, page_size);	1396	self.handle.buf = try self.allocator.alloc(u8, page_size);
1277	}	1397	}
1278		1398
1279	while (true) {	1399	while (true) {
1280	const result = posix.getdents(self.fd, self.buf.ptr, self.buf.len);	1400	const result = posix.getdents(self.handle.fd, self.handle.buf.ptr, self.handle.buf.len);
1281	const err = posix.getErrno(result);	1401	const err = posix.getErrno(result);
1282	if (err > 0) {	1402	if (err > 0) {
1283	switch (err) {	1403	switch (err) {
1284	posix.EBADF, posix.EFAULT, posix.ENOTDIR => unreachable,	1404	posix.EBADF, posix.EFAULT, posix.ENOTDIR => unreachable,
1285	posix.EINVAL => {	1405	posix.EINVAL => {
1286	self.buf = try self.allocator.realloc(u8, self.buf, self.buf.len * 2);	1406	self.handle.buf = try self.allocator.realloc(u8, self.handle.buf, self.handle.buf.len * 2);
1287	continue;	1407	continue;
1288	},	1408	},
1289	else => return unexpectedErrorPosix(err),	1409	else => return unexpectedErrorPosix(err),
1290	}	1410	}
1291	}	1411	}
1292	if (result == 0) return null;	1412	if (result == 0) return null;
1293	self.index = 0;	1413	self.handle.index = 0;
1294	self.end_index = result;	1414	self.handle.end_index = result;
1295	break;	1415	break;
1296	}	1416	}
1297	}	1417	}
1298	const linux_entry = @ptrCast(*align(1) posix.dirent, &self.buf[self.index]);	1418	const linux_entry = @ptrCast(*align(1) posix.dirent, &self.handle.buf[self.handle.index]);
1299	const next_index = self.index + linux_entry.d_reclen;	1419	const next_index = self.handle.index + linux_entry.d_reclen;
1300	self.index = next_index;	1420	self.handle.index = next_index;
1301		1421
1302	const name = cstr.toSlice(@ptrCast([*]u8, &linux_entry.d_name));	1422	const name = cstr.toSlice(@ptrCast([*]u8, &linux_entry.d_name));
1303		1423
...	@@ -1306,7 +1426,7 @@ pub const Dir = struct {	...	@@ -1306,7 +1426,7 @@ pub const Dir = struct {
1306	continue :start_over;	1426	continue :start_over;
1307	}	1427	}
1308		1428
1309	const type_char = self.buf[next_index - 1];	1429	const type_char = self.handle.buf[next_index - 1];
1310	const entry_kind = switch (type_char) {	1430	const entry_kind = switch (type_char) {
1311	posix.DT_BLK => Entry.Kind.BlockDevice,	1431	posix.DT_BLK => Entry.Kind.BlockDevice,
1312	posix.DT_CHR => Entry.Kind.CharacterDevice,	1432	posix.DT_CHR => Entry.Kind.CharacterDevice,
...	@@ -1641,7 +1761,7 @@ pub const ArgIterator = struct {	...	@@ -1641,7 +1761,7 @@ pub const ArgIterator = struct {
1641	if (builtin.os == Os.windows) {	1761	if (builtin.os == Os.windows) {
1642	return self.inner.next(allocator);	1762	return self.inner.next(allocator);
1643	} else {	1763	} else {
1644	return mem.dupe(allocator, u8, self.inner.next() ?? return null);	1764	return mem.dupe(allocator, u8, self.inner.next() orelse return null);
1645	}	1765	}
1646	}	1766	}
1647		1767
...	@@ -1729,7 +1849,7 @@ test "windows arg parsing" {	...	@@ -1729,7 +1849,7 @@ test "windows arg parsing" {
1729	fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []const u8) void {	1849	fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []const u8) void {
1730	var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);	1850	var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);
1731	for (expected_args) \|expected_arg\| {	1851	for (expected_args) \|expected_arg\| {
1732	const arg = ??it.next(debug.global_allocator) catch unreachable;	1852	const arg = it.next(debug.global_allocator).? catch unreachable;
1733	assert(mem.eql(u8, arg, expected_arg));	1853	assert(mem.eql(u8, arg, expected_arg));
1734	}	1854	}
1735	assert(it.next(debug.global_allocator) == null);	1855	assert(it.next(debug.global_allocator) == null);
...	@@ -1845,13 +1965,13 @@ pub fn selfExeDirPath(allocator: *mem.Allocator) ![]u8 {	...	@@ -1845,13 +1965,13 @@ pub fn selfExeDirPath(allocator: *mem.Allocator) ![]u8 {
1845	// the executable was in when it was run.	1965	// the executable was in when it was run.
1846	const full_exe_path = try readLink(allocator, "/proc/self/exe");	1966	const full_exe_path = try readLink(allocator, "/proc/self/exe");
1847	errdefer allocator.free(full_exe_path);	1967	errdefer allocator.free(full_exe_path);
1848	const dir = path.dirname(full_exe_path);	1968	const dir = path.dirname(full_exe_path) orelse ".";
1849	return allocator.shrink(u8, full_exe_path, dir.len);	1969	return allocator.shrink(u8, full_exe_path, dir.len);
1850	},	1970	},
1851	Os.windows, Os.macosx, Os.ios => {	1971	Os.windows, Os.macosx, Os.ios => {
1852	const self_exe_path = try selfExePath(allocator);	1972	const self_exe_path = try selfExePath(allocator);
1853	errdefer allocator.free(self_exe_path);	1973	errdefer allocator.free(self_exe_path);
1854	const dirname = os.path.dirname(self_exe_path);	1974	const dirname = os.path.dirname(self_exe_path) orelse ".";
1855	return allocator.shrink(u8, self_exe_path, dirname.len);	1975	return allocator.shrink(u8, self_exe_path, dirname.len);
1856	},	1976	},
1857	else => @compileError("unimplemented: std.os.selfExeDirPath for " ++ @tagName(builtin.os)),	1977	else => @compileError("unimplemented: std.os.selfExeDirPath for " ++ @tagName(builtin.os)),
...	@@ -2362,7 +2482,7 @@ pub const Thread = struct {	...	@@ -2362,7 +2482,7 @@ pub const Thread = struct {
2362	},	2482	},
2363	builtin.Os.windows => struct {	2483	builtin.Os.windows => struct {
2364	handle: windows.HANDLE,	2484	handle: windows.HANDLE,
2365	alloc_start: [*]c_void,	2485	alloc_start: *c_void,
2366	heap_handle: windows.HANDLE,	2486	heap_handle: windows.HANDLE,
2367	},	2487	},
2368	else => @compileError("Unsupported OS"),	2488	else => @compileError("Unsupported OS"),
...	@@ -2457,9 +2577,9 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread	...	@@ -2457,9 +2577,9 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread
2457	}	2577	}
2458	};	2578	};
2459		2579
2460	const heap_handle = windows.GetProcessHeap() ?? return SpawnThreadError.OutOfMemory;	2580	const heap_handle = windows.GetProcessHeap() orelse return SpawnThreadError.OutOfMemory;
2461	const byte_count = @alignOf(WinThread.OuterContext) + @sizeOf(WinThread.OuterContext);	2581	const byte_count = @alignOf(WinThread.OuterContext) + @sizeOf(WinThread.OuterContext);
2462	const bytes_ptr = windows.HeapAlloc(heap_handle, 0, byte_count) ?? return SpawnThreadError.OutOfMemory;	2582	const bytes_ptr = windows.HeapAlloc(heap_handle, 0, byte_count) orelse return SpawnThreadError.OutOfMemory;
2463	errdefer assert(windows.HeapFree(heap_handle, 0, bytes_ptr) != 0);	2583	errdefer assert(windows.HeapFree(heap_handle, 0, bytes_ptr) != 0);
2464	const bytes = @ptrCast([*]u8, bytes_ptr)[0..byte_count];	2584	const bytes = @ptrCast([*]u8, bytes_ptr)[0..byte_count];
2465	const outer_context = std.heap.FixedBufferAllocator.init(bytes).allocator.create(WinThread.OuterContext) catch unreachable;	2585	const outer_context = std.heap.FixedBufferAllocator.init(bytes).allocator.create(WinThread.OuterContext) catch unreachable;
...	@@ -2468,7 +2588,7 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread	...	@@ -2468,7 +2588,7 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread
2468	outer_context.thread.data.alloc_start = bytes_ptr;	2588	outer_context.thread.data.alloc_start = bytes_ptr;
2469		2589
2470	const parameter = if (@sizeOf(Context) == 0) null else @ptrCast(*c_void, &outer_context.inner);	2590	const parameter = if (@sizeOf(Context) == 0) null else @ptrCast(*c_void, &outer_context.inner);
2471	outer_context.thread.data.handle = windows.CreateThread(null, default_stack_size, WinThread.threadMain, parameter, 0, null) ?? {	2591	outer_context.thread.data.handle = windows.CreateThread(null, default_stack_size, WinThread.threadMain, parameter, 0, null) orelse {
2472	const err = windows.GetLastError();	2592	const err = windows.GetLastError();
2473	return switch (err) {	2593	return switch (err) {
2474	else => os.unexpectedErrorWindows(err),	2594	else => os.unexpectedErrorWindows(err),
...	@@ -2533,7 +2653,7 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread	...	@@ -2533,7 +2653,7 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread
2533		2653
2534	// align to page	2654	// align to page
2535	stack_end -= stack_end % os.page_size;	2655	stack_end -= stack_end % os.page_size;
2536	assert(c.pthread_attr_setstack(&attr, @intToPtr([*]c_void, stack_addr), stack_end - stack_addr) == 0);	2656	assert(c.pthread_attr_setstack(&attr, @intToPtr(*c_void, stack_addr), stack_end - stack_addr) == 0);
2537		2657
2538	const err = c.pthread_create(&thread_ptr.data.handle, &attr, MainFuncs.posixThreadMain, @intToPtr(*c_void, arg));	2658	const err = c.pthread_create(&thread_ptr.data.handle, &attr, MainFuncs.posixThreadMain, @intToPtr(*c_void, arg));
2539	switch (err) {	2659	switch (err) {

std/os/linux/vdso.zig+5-5

...	@@ -28,7 +28,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {	...	@@ -28,7 +28,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
28	}	28	}
29	}	29	}
30	}	30	}
31	const dynv = maybe_dynv ?? return 0;	31	const dynv = maybe_dynv orelse return 0;
32	if (base == @maxValue(usize)) return 0;	32	if (base == @maxValue(usize)) return 0;
33		33
34	var maybe_strings: ?[*]u8 = null;	34	var maybe_strings: ?[*]u8 = null;
...	@@ -52,9 +52,9 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {	...	@@ -52,9 +52,9 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
52	}	52	}
53	}	53	}
54		54
55	const strings = maybe_strings ?? return 0;	55	const strings = maybe_strings orelse return 0;
56	const syms = maybe_syms ?? return 0;	56	const syms = maybe_syms orelse return 0;
57	const hashtab = maybe_hashtab ?? return 0;	57	const hashtab = maybe_hashtab orelse return 0;
58	if (maybe_verdef == null) maybe_versym = null;	58	if (maybe_verdef == null) maybe_versym = null;
59		59
60	const OK_TYPES = (1 << elf.STT_NOTYPE \| 1 << elf.STT_OBJECT \| 1 << elf.STT_FUNC \| 1 << elf.STT_COMMON);	60	const OK_TYPES = (1 << elf.STT_NOTYPE \| 1 << elf.STT_OBJECT \| 1 << elf.STT_FUNC \| 1 << elf.STT_COMMON);
...	@@ -67,7 +67,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {	...	@@ -67,7 +67,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
67	if (0 == syms[i].st_shndx) continue;	67	if (0 == syms[i].st_shndx) continue;
68	if (!mem.eql(u8, name, cstr.toSliceConst(strings + syms[i].st_name))) continue;	68	if (!mem.eql(u8, name, cstr.toSliceConst(strings + syms[i].st_name))) continue;
69	if (maybe_versym) \|versym\| {	69	if (maybe_versym) \|versym\| {
70	if (!checkver(??maybe_verdef, versym[i], vername, strings))	70	if (!checkver(maybe_verdef.?, versym[i], vername, strings))
71	continue;	71	continue;
72	}	72	}
73	return base + syms[i].st_value;	73	return base + syms[i].st_value;

std/os/path.zig+44-30

 @@ -182,8 +182,8 @@ pub fn windowsParsePath(path: []const u8) WindowsPath {
             }
             var it = mem.split(path, []u8{this_sep});
-            _ = (it.next() ?? return relative_path);
+            _ = (it.next() orelse return relative_path);
-            _ = (it.next() ?? return relative_path);
+            _ = (it.next() orelse return relative_path);
             return WindowsPath{
                 .is_abs = isAbsoluteWindows(path),
                 .kind = WindowsPath.Kind.NetworkShare,
 @@ -200,8 +200,8 @@ pub fn windowsParsePath(path: []const u8) WindowsPath {
             }
             var it = mem.split(path, []u8{this_sep});
-            _ = (it.next() ?? return relative_path);
+            _ = (it.next() orelse return relative_path);
-            _ = (it.next() ?? return relative_path);
+            _ = (it.next() orelse return relative_path);
             return WindowsPath{
                 .is_abs = isAbsoluteWindows(path),
                 .kind = WindowsPath.Kind.NetworkShare,
 @@ -265,7 +265,7 @@ fn networkShareServersEql(ns1: []const u8, ns2: []const u8) bool {
     var it2 = mem.split(ns2, []u8{sep2});
     // TODO ASCII is wrong, we actually need full unicode support to compare paths.
-    return asciiEqlIgnoreCase(??it1.next(), ??it2.next());
+    return asciiEqlIgnoreCase(it1.next().?, it2.next().?);
 }
 fn compareDiskDesignators(kind: WindowsPath.Kind, p1: []const u8, p2: []const u8) bool {
 @@ -286,7 +286,7 @@ fn compareDiskDesignators(kind: WindowsPath.Kind, p1: []const u8, p2: []const u8
             var it2 = mem.split(p2, []u8{sep2});
             // TODO ASCII is wrong, we actually need full unicode support to compare paths.
-            return asciiEqlIgnoreCase(??it1.next(), ??it2.next()) and asciiEqlIgnoreCase(??it1.next(), ??it2.next());
+            return asciiEqlIgnoreCase(it1.next().?, it2.next().?) and asciiEqlIgnoreCase(it1.next().?, it2.next().?);
         },
     }
 }
 @@ -414,8 +414,8 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
             WindowsPath.Kind.NetworkShare => {
                 result = try allocator.alloc(u8, max_size);
                 var it = mem.split(paths[first_index], "/\\");
-                const server_name = ??it.next();
+                const server_name = it.next().?;
-                const other_name = ??it.next();
+                const other_name = it.next().?;
                 result[result_index] = '\\';
                 result_index += 1;
 @@ -648,8 +648,8 @@ fn testResolvePosix(paths: []const []const u8) []u8 {
 }
 /// If the path is a file in the current directory (no directory component)
-/// then the returned slice has .len = 0.
+/// then returns null
-pub fn dirname(path: []const u8) []const u8 {
+pub fn dirname(path: []const u8) ?[]const u8 {
     if (is_windows) {
         return dirnameWindows(path);
     } else {
 @@ -657,9 +657,9 @@ pub fn dirname(path: []const u8) []const u8 {
     }
 }
-pub fn dirnameWindows(path: []const u8) []const u8 {
+pub fn dirnameWindows(path: []const u8) ?[]const u8 {
     if (path.len == 0)
-        return path[0..0];
+        return null;
     const root_slice = diskDesignatorWindows(path);
     if (path.len == root_slice.len)
 @@ -671,13 +671,13 @@ pub fn dirnameWindows(path: []const u8) []const u8 {
     while ((path[end_index] == '/' or path[end_index] == '\\') and end_index > root_slice.len) {
         if (end_index == 0)
-            return path[0..0];
+            return null;
         end_index -= 1;
     }
     while (path[end_index] != '/' and path[end_index] != '\\' and end_index > root_slice.len) {
         if (end_index == 0)
-            return path[0..0];
+            return null;
         end_index -= 1;
     }
 @@ -685,12 +685,15 @@ pub fn dirnameWindows(path: []const u8) []const u8 {
         end_index += 1;
     }
+    if (end_index == 0)
+        return null;
     return path[0..end_index];
 }
-pub fn dirnamePosix(path: []const u8) []const u8 {
+pub fn dirnamePosix(path: []const u8) ?[]const u8 {
     if (path.len == 0)
-        return path[0..0];
+        return null;
     var end_index: usize = path.len - 1;
     while (path[end_index] == '/') {
 @@ -701,13 +704,16 @@ pub fn dirnamePosix(path: []const u8) []const u8 {
     while (path[end_index] != '/') {
         if (end_index == 0)
-            return path[0..0];
+            return null;
         end_index -= 1;
     }
     if (end_index == 0 and path[end_index] == '/')
         return path[0..1];
+    if (end_index == 0)
+        return null;
     return path[0..end_index];
 }
 @@ -717,10 +723,10 @@ test "os.path.dirnamePosix" {
     testDirnamePosix("/a", "/");
     testDirnamePosix("/", "/");
     testDirnamePosix("////", "/");
-    testDirnamePosix("", "");
+    testDirnamePosix("", null);
-    testDirnamePosix("a", "");
+    testDirnamePosix("a", null);
-    testDirnamePosix("a/", "");
+    testDirnamePosix("a/", null);
-    testDirnamePosix("a//", "");
+    testDirnamePosix("a//", null);
 }
 test "os.path.dirnameWindows" {
 @@ -742,7 +748,7 @@ test "os.path.dirnameWindows" {
     testDirnameWindows("c:foo\\bar", "c:foo");
     testDirnameWindows("c:foo\\bar\\", "c:foo");
     testDirnameWindows("c:foo\\bar\\baz", "c:foo\\bar");
-    testDirnameWindows("file:stream", "");
+    testDirnameWindows("file:stream", null);
     testDirnameWindows("dir\\file:stream", "dir");
     testDirnameWindows("\\\\unc\\share", "\\\\unc\\share");
     testDirnameWindows("\\\\unc\\share\\foo", "\\\\unc\\share\\");
 @@ -753,18 +759,26 @@ test "os.path.dirnameWindows" {
     testDirnameWindows("/a/b/", "/a");
     testDirnameWindows("/a/b", "/a");
     testDirnameWindows("/a", "/");
-    testDirnameWindows("", "");
+    testDirnameWindows("", null);
     testDirnameWindows("/", "/");
     testDirnameWindows("////", "/");
-    testDirnameWindows("foo", "");
+    testDirnameWindows("foo", null);
 }
-fn testDirnamePosix(input: []const u8, expected_output: []const u8) void {
+fn testDirnamePosix(input: []const u8, expected_output: ?[]const u8) void {
-    assert(mem.eql(u8, dirnamePosix(input), expected_output));
+    if (dirnamePosix(input)) |output| {
+        assert(mem.eql(u8, output, expected_output.?));
+    } else {
+        assert(expected_output == null);
+    }
 }
-fn testDirnameWindows(input: []const u8, expected_output: []const u8) void {
+fn testDirnameWindows(input: []const u8, expected_output: ?[]const u8) void {
-    assert(mem.eql(u8, dirnameWindows(input), expected_output));
+    if (dirnameWindows(input)) |output| {
+        assert(mem.eql(u8, output, expected_output.?));
+    } else {
+        assert(expected_output == null);
+    }
 }
 pub fn basename(path: []const u8) []const u8 {
 @@ -923,7 +937,7 @@ pub fn relativeWindows(allocator: *Allocator, from: []const u8, to: []const u8)
     var from_it = mem.split(resolved_from, "/\\");
     var to_it = mem.split(resolved_to, "/\\");
     while (true) {
-        const from_component = from_it.next() ?? return mem.dupe(allocator, u8, to_it.rest());
+        const from_component = from_it.next() orelse return mem.dupe(allocator, u8, to_it.rest());
         const to_rest = to_it.rest();
         if (to_it.next()) |to_component| {
             // TODO ASCII is wrong, we actually need full unicode support to compare paths.
 @@ -974,7 +988,7 @@ pub fn relativePosix(allocator: *Allocator, from: []const u8, to: []const u8) ![
     var from_it = mem.split(resolved_from, "/");
     var to_it = mem.split(resolved_to, "/");
     while (true) {
-        const from_component = from_it.next() ?? return mem.dupe(allocator, u8, to_it.rest());
+        const from_component = from_it.next() orelse return mem.dupe(allocator, u8, to_it.rest());
         const to_rest = to_it.rest();
         if (to_it.next()) |to_component| {
             if (mem.eql(u8, from_component, to_component))

std/os/test.zig-9

 @@ -10,11 +10,6 @@ const AtomicRmwOp = builtin.AtomicRmwOp;
 const AtomicOrder = builtin.AtomicOrder;
 test "makePath, put some files in it, deleteTree" {
-    if (builtin.os == builtin.Os.windows) {
-        // TODO implement os.Dir for windows
-        // https://github.com/ziglang/zig/issues/709
-        return;
-    }
     try os.makePath(a, "os_test_tmp/b/c");
     try io.writeFile(a, "os_test_tmp/b/c/file.txt", "nonsense");
     try io.writeFile(a, "os_test_tmp/b/file2.txt", "blah");
 @@ -27,10 +22,6 @@ test "makePath, put some files in it, deleteTree" {
 }
 test "access file" {
-    if (builtin.os == builtin.Os.windows) {
-        return;
-    }
     try os.makePath(a, "os_test_tmp");
     if (os.File.access(a, "os_test_tmp/file.txt", os.default_file_mode)) |ok| {
         unreachable;

std/os/time.zig+4-2

...	@@ -68,11 +68,13 @@ pub const milliTimestamp = switch (builtin.os) {	...	@@ -68,11 +68,13 @@ pub const milliTimestamp = switch (builtin.os) {
68	fn milliTimestampWindows() u64 {	68	fn milliTimestampWindows() u64 {
69	//FileTime has a granularity of 100 nanoseconds	69	//FileTime has a granularity of 100 nanoseconds
70	// and uses the NTFS/Windows epoch	70	// and uses the NTFS/Windows epoch
71	var ft: i64 = undefined;	71	var ft: windows.FILETIME = undefined;
72	windows.GetSystemTimeAsFileTime(&ft);	72	windows.GetSystemTimeAsFileTime(&ft);
73	const hns_per_ms = (ns_per_s / 100) / ms_per_s;	73	const hns_per_ms = (ns_per_s / 100) / ms_per_s;
74	const epoch_adj = epoch.windows * ms_per_s;	74	const epoch_adj = epoch.windows * ms_per_s;
75	return u64(@divFloor(ft, hns_per_ms) + epoch_adj);	75
		76	const ft64 = (u64(ft.dwHighDateTime) << 32) \| ft.dwLowDateTime;
		77	return @divFloor(ft64, hns_per_ms) - -epoch_adj;
76	}	78	}
77		79
78	fn milliTimestampDarwin() u64 {	80	fn milliTimestampDarwin() u64 {

std/os/windows/index.zig+52-14

 @@ -1,3 +1,7 @@
+test "import" {
+    _ = @import("util.zig");
+}
 pub const ERROR = @import("error.zig");
 pub extern "advapi32" stdcallcc fn CryptAcquireContextA(
 @@ -61,6 +65,10 @@ pub extern "kernel32" stdcallcc fn DeleteFileA(lpFileName: LPCSTR) BOOL;
 pub extern "kernel32" stdcallcc fn ExitProcess(exit_code: UINT) noreturn;
+pub extern "kernel32" stdcallcc fn FindFirstFileA(lpFileName: LPCSTR, lpFindFileData: *WIN32_FIND_DATAA) HANDLE;
+pub extern "kernel32" stdcallcc fn FindClose(hFindFile: HANDLE) BOOL;
+pub extern "kernel32" stdcallcc fn FindNextFileA(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAA) BOOL;
 pub extern "kernel32" stdcallcc fn FreeEnvironmentStringsA(penv: [*]u8) BOOL;
 pub extern "kernel32" stdcallcc fn GetCommandLineA() LPSTR;
 @@ -77,6 +85,8 @@ pub extern "kernel32" stdcallcc fn GetExitCodeProcess(hProcess: HANDLE, lpExitCo
 pub extern "kernel32" stdcallcc fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) BOOL;
+pub extern "kernel32" stdcallcc fn GetFileAttributesA(lpFileName: LPCSTR) DWORD;
 pub extern "kernel32" stdcallcc fn GetModuleFileNameA(hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) DWORD;
 pub extern "kernel32" stdcallcc fn GetLastError() DWORD;
 @@ -97,21 +107,21 @@ pub extern "kernel32" stdcallcc fn GetFinalPathNameByHandleA(
 pub extern "kernel32" stdcallcc fn GetProcessHeap() ?HANDLE;
-pub extern "kernel32" stdcallcc fn GetSystemTimeAsFileTime(?*FILETIME) void;
+pub extern "kernel32" stdcallcc fn GetSystemTimeAsFileTime(*FILETIME) 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 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 HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) SIZE_T;
-pub extern "kernel32" stdcallcc fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: [*]const c_void) BOOL;
+pub extern "kernel32" stdcallcc fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) BOOL;
 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" stdcallcc fn GetStdHandle(in_nStdHandle: DWORD) ?HANDLE;
-pub extern "kernel32" stdcallcc fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) ?[*]c_void;
+pub extern "kernel32" stdcallcc fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) ?*c_void;
-pub extern "kernel32" stdcallcc fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: [*]c_void) BOOL;
+pub extern "kernel32" stdcallcc fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) BOOL;
 pub extern "kernel32" stdcallcc fn MoveFileExA(
     lpExistingFileName: LPCSTR,
 @@ -123,16 +133,16 @@ pub extern "kernel32" stdcallcc fn QueryPerformanceCounter(lpPerformanceCount: *
 pub extern "kernel32" stdcallcc fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) BOOL;
-pub extern "kernel32" stdcallcc fn PathFileExists(pszPath: ?LPCTSTR) BOOL;
 pub extern "kernel32" stdcallcc fn ReadFile(
     in_hFile: HANDLE,
-    out_lpBuffer: [*]c_void,
+    out_lpBuffer: *c_void,
     in_nNumberOfBytesToRead: DWORD,
     out_lpNumberOfBytesRead: *DWORD,
     in_out_lpOverlapped: ?*OVERLAPPED,
 ) BOOL;
+pub extern "kernel32" stdcallcc fn RemoveDirectoryA(lpPathName: LPCSTR) BOOL;
 pub extern "kernel32" stdcallcc fn SetFilePointerEx(
     in_fFile: HANDLE,
     in_liDistanceToMove: LARGE_INTEGER,
 @@ -150,7 +160,7 @@ pub extern "kernel32" stdcallcc fn WaitForSingleObject(hHandle: HANDLE, dwMillis
 pub extern "kernel32" stdcallcc fn WriteFile(
     in_hFile: HANDLE,
-    in_lpBuffer: [*]const c_void,
+    in_lpBuffer: *const c_void,
     in_nNumberOfBytesToWrite: DWORD,
     out_lpNumberOfBytesWritten: ?*DWORD,
     in_out_lpOverlapped: ?*OVERLAPPED,
 @@ -163,6 +173,8 @@ pub extern "kernel32" stdcallcc fn FreeLibrary(hModule: HMODULE) BOOL;
 pub extern "user32" stdcallcc fn MessageBoxA(hWnd: ?HANDLE, lpText: ?LPCTSTR, lpCaption: ?LPCTSTR, uType: UINT) c_int;
+pub extern "shlwapi" stdcallcc fn PathFileExistsA(pszPath: ?LPCTSTR) BOOL;
 pub const PROV_RSA_FULL = 1;
 pub const BOOL = c_int;
 @@ -196,7 +208,6 @@ pub const UNICODE = false;
 pub const WCHAR = u16;
 pub const WORD = u16;
 pub const LARGE_INTEGER = i64;
-pub const FILETIME = i64;
 pub const TRUE = 1;
 pub const FALSE = 0;
 @@ -212,6 +223,8 @@ pub const STD_ERROR_HANDLE = @maxValue(DWORD) - 12 + 1;
 pub const INVALID_HANDLE_VALUE = @intToPtr(HANDLE, @maxValue(usize));
+pub const INVALID_FILE_ATTRIBUTES = DWORD(@maxValue(DWORD));
 pub const OVERLAPPED = extern struct {
     Internal: ULONG_PTR,
     InternalHigh: ULONG_PTR,
 @@ -293,13 +306,24 @@ pub const OPEN_EXISTING = 3;
 pub const TRUNCATE_EXISTING = 5;
 pub const FILE_ATTRIBUTE_ARCHIVE = 0x20;
+pub const FILE_ATTRIBUTE_COMPRESSED = 0x800;
+pub const FILE_ATTRIBUTE_DEVICE = 0x40;
+pub const FILE_ATTRIBUTE_DIRECTORY = 0x10;
 pub const FILE_ATTRIBUTE_ENCRYPTED = 0x4000;
 pub const FILE_ATTRIBUTE_HIDDEN = 0x2;
+pub const FILE_ATTRIBUTE_INTEGRITY_STREAM = 0x8000;
 pub const FILE_ATTRIBUTE_NORMAL = 0x80;
+pub const FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x2000;
+pub const FILE_ATTRIBUTE_NO_SCRUB_DATA = 0x20000;
 pub const FILE_ATTRIBUTE_OFFLINE = 0x1000;
 pub const FILE_ATTRIBUTE_READONLY = 0x1;
+pub const FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS = 0x400000;
+pub const FILE_ATTRIBUTE_RECALL_ON_OPEN = 0x40000;
+pub const FILE_ATTRIBUTE_REPARSE_POINT = 0x400;
+pub const FILE_ATTRIBUTE_SPARSE_FILE = 0x200;
 pub const FILE_ATTRIBUTE_SYSTEM = 0x4;
 pub const FILE_ATTRIBUTE_TEMPORARY = 0x100;
+pub const FILE_ATTRIBUTE_VIRTUAL = 0x10000;
 pub const PROCESS_INFORMATION = extern struct {
     hProcess: HANDLE,
 @@ -372,6 +396,20 @@ pub const HEAP_NO_SERIALIZE = 0x00000001;
 pub const PTHREAD_START_ROUTINE = extern fn (LPVOID) DWORD;
 pub const LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
-test "import" {
+pub const WIN32_FIND_DATAA = extern struct {
-    _ = @import("util.zig");
+    dwFileAttributes: DWORD,
-}
+    ftCreationTime: FILETIME,
+    ftLastAccessTime: FILETIME,
+    ftLastWriteTime: FILETIME,
+    nFileSizeHigh: DWORD,
+    nFileSizeLow: DWORD,
+    dwReserved0: DWORD,
+    dwReserved1: DWORD,
+    cFileName: [260]CHAR,
+    cAlternateFileName: [14]CHAR,
+};
+pub const FILETIME = extern struct {
+    dwLowDateTime: DWORD,
+    dwHighDateTime: DWORD,
+};

std/os/windows/util.zig+41-2

...	@@ -42,7 +42,7 @@ pub const WriteError = error{	...	@@ -42,7 +42,7 @@ pub const WriteError = error{
42	};	42	};
43		43
44	pub fn windowsWrite(handle: windows.HANDLE, bytes: []const u8) WriteError!void {	44	pub fn windowsWrite(handle: windows.HANDLE, bytes: []const u8) WriteError!void {
45	if (windows.WriteFile(handle, @ptrCast([*]const c_void, bytes.ptr), u32(bytes.len), null, null) == 0) {	45	if (windows.WriteFile(handle, @ptrCast(*const c_void, bytes.ptr), u32(bytes.len), null, null) == 0) {
46	const err = windows.GetLastError();	46	const err = windows.GetLastError();
47	return switch (err) {	47	return switch (err) {
48	windows.ERROR.INVALID_USER_BUFFER => WriteError.SystemResources,	48	windows.ERROR.INVALID_USER_BUFFER => WriteError.SystemResources,
...	@@ -153,7 +153,7 @@ pub fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: const BufMap)	...	@@ -153,7 +153,7 @@ pub fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: const BufMap)
153	pub fn windowsLoadDll(allocator: *mem.Allocator, dll_path: []const u8) !windows.HMODULE {	153	pub fn windowsLoadDll(allocator: *mem.Allocator, dll_path: []const u8) !windows.HMODULE {
154	const padded_buff = try cstr.addNullByte(allocator, dll_path);	154	const padded_buff = try cstr.addNullByte(allocator, dll_path);
155	defer allocator.free(padded_buff);	155	defer allocator.free(padded_buff);
156	return windows.LoadLibraryA(padded_buff.ptr) ?? error.DllNotFound;	156	return windows.LoadLibraryA(padded_buff.ptr) orelse error.DllNotFound;
157	}	157	}
158		158
159	pub fn windowsUnloadDll(hModule: windows.HMODULE) void {	159	pub fn windowsUnloadDll(hModule: windows.HMODULE) void {
...	@@ -170,3 +170,42 @@ test "InvalidDll" {	...	@@ -170,3 +170,42 @@ test "InvalidDll" {
170	return;	170	return;
171	};	171	};
172	}	172	}
		173
		174	pub fn windowsFindFirstFile(
		175	allocator: *mem.Allocator,
		176	dir_path: []const u8,
		177	find_file_data: *windows.WIN32_FIND_DATAA,
		178	) !windows.HANDLE {
		179	const wild_and_null = []u8{ '\\', '*', 0 };
		180	const path_with_wild_and_null = try allocator.alloc(u8, dir_path.len + wild_and_null.len);
		181	defer allocator.free(path_with_wild_and_null);
		182
		183	mem.copy(u8, path_with_wild_and_null, dir_path);
		184	mem.copy(u8, path_with_wild_and_null[dir_path.len..], wild_and_null);
		185
		186	const handle = windows.FindFirstFileA(path_with_wild_and_null.ptr, find_file_data);
		187
		188	if (handle == windows.INVALID_HANDLE_VALUE) {
		189	const err = windows.GetLastError();
		190	switch (err) {
		191	windows.ERROR.FILE_NOT_FOUND,
		192	windows.ERROR.PATH_NOT_FOUND,
		193	=> return error.PathNotFound,
		194	else => return os.unexpectedErrorWindows(err),
		195	}
		196	}
		197
		198	return handle;
		199	}
		200
		201	/// Returns `true` if there was another file, `false` otherwise.
		202	pub fn windowsFindNextFile(handle: windows.HANDLE, find_file_data: *windows.WIN32_FIND_DATAA) !bool {
		203	if (windows.FindNextFileA(handle, find_file_data) == 0) {
		204	const err = windows.GetLastError();
		205	return switch (err) {
		206	windows.ERROR.NO_MORE_FILES => false,
		207	else => os.unexpectedErrorWindows(err),
		208	};
		209	}
		210	return true;
		211	}

std/segmented_list.zig+4-4

...	@@ -364,7 +364,7 @@ fn testSegmentedList(comptime prealloc: usize, allocator: *Allocator) !void {	...	@@ -364,7 +364,7 @@ fn testSegmentedList(comptime prealloc: usize, allocator: *Allocator) !void {
364	assert(x == 0);	364	assert(x == 0);
365	}	365	}
366		366
367	assert(??list.pop() == 100);	367	assert(list.pop().? == 100);
368	assert(list.len == 99);	368	assert(list.len == 99);
369		369
370	try list.pushMany([]i32{	370	try list.pushMany([]i32{
...	@@ -373,9 +373,9 @@ fn testSegmentedList(comptime prealloc: usize, allocator: *Allocator) !void {	...	@@ -373,9 +373,9 @@ fn testSegmentedList(comptime prealloc: usize, allocator: *Allocator) !void {
373	3,	373	3,
374	});	374	});
375	assert(list.len == 102);	375	assert(list.len == 102);
376	assert(??list.pop() == 3);	376	assert(list.pop().? == 3);
377	assert(??list.pop() == 2);	377	assert(list.pop().? == 2);
378	assert(??list.pop() == 1);	378	assert(list.pop().? == 1);
379	assert(list.len == 99);	379	assert(list.len == 99);
380		380
381	try list.pushMany([]const i32{});	381	try list.pushMany([]const i32{});

std/special/bootstrap.zig+4-4

...	@@ -51,13 +51,13 @@ extern fn WinMainCRTStartup() noreturn {	...	@@ -51,13 +51,13 @@ extern fn WinMainCRTStartup() noreturn {
51		51
52	// TODO https://github.com/ziglang/zig/issues/265	52	// TODO https://github.com/ziglang/zig/issues/265
53	fn posixCallMainAndExit() noreturn {	53	fn posixCallMainAndExit() noreturn {
54	const argc = argc_ptr.*;	54	const argc = argc_ptr[0];
55	const argv = @ptrCast([][]u8, argc_ptr + 1);	55	const argv = @ptrCast([][]u8, argc_ptr + 1);
56		56
57	const envp_nullable = @ptrCast([]?[]u8, argv + argc + 1);	57	const envp_optional = @ptrCast([]?[]u8, argv + argc + 1);
58	var envp_count: usize = 0;	58	var envp_count: usize = 0;
59	while (envp_nullable[envp_count]) \|_\| : (envp_count += 1) {}	59	while (envp_optional[envp_count]) \|_\| : (envp_count += 1) {}
60	const envp = @ptrCast([][]u8, envp_nullable)[0..envp_count];	60	const envp = @ptrCast([][]u8, envp_optional)[0..envp_count];
61	if (builtin.os == builtin.Os.linux) {	61	if (builtin.os == builtin.Os.linux) {
62	const auxv = @ptrCast([*]usize, envp.ptr + envp_count + 1);	62	const auxv = @ptrCast([*]usize, envp.ptr + envp_count + 1);
63	var i: usize = 0;	63	var i: usize = 0;

std/special/build_runner.zig+5-5

std/special/builtin.zig+4-4

...	@@ -19,7 +19,7 @@ export fn memset(dest: ?[]u8, c: u8, n: usize) ?[]u8 {	...	@@ -19,7 +19,7 @@ export fn memset(dest: ?[]u8, c: u8, n: usize) ?[]u8 {
19		19
20	var index: usize = 0;	20	var index: usize = 0;
21	while (index != n) : (index += 1)	21	while (index != n) : (index += 1)
22	(??dest)[index] = c;	22	dest.?[index] = c;
23		23
24	return dest;	24	return dest;
25	}	25	}
...	@@ -29,7 +29,7 @@ export fn memcpy(noalias dest: ?[]u8, noalias src: ?[]const u8, n: usize) ?[*]	...	@@ -29,7 +29,7 @@ export fn memcpy(noalias dest: ?[]u8, noalias src: ?[]const u8, n: usize) ?[*]
29		29
30	var index: usize = 0;	30	var index: usize = 0;
31	while (index != n) : (index += 1)	31	while (index != n) : (index += 1)
32	(??dest)[index] = (??src)[index];	32	dest.?[index] = src.?[index];
33		33
34	return dest;	34	return dest;
35	}	35	}
...	@@ -40,13 +40,13 @@ export fn memmove(dest: ?[]u8, src: ?[]const u8, n: usize) ?[*]u8 {	...	@@ -40,13 +40,13 @@ export fn memmove(dest: ?[]u8, src: ?[]const u8, n: usize) ?[*]u8 {
40	if (@ptrToInt(dest) < @ptrToInt(src)) {	40	if (@ptrToInt(dest) < @ptrToInt(src)) {
41	var index: usize = 0;	41	var index: usize = 0;
42	while (index != n) : (index += 1) {	42	while (index != n) : (index += 1) {
43	(??dest)[index] = (??src)[index];	43	dest.?[index] = src.?[index];
44	}	44	}
45	} else {	45	} else {
46	var index = n;	46	var index = n;
47	while (index != 0) {	47	while (index != 0) {
48	index -= 1;	48	index -= 1;
49	(??dest)[index] = (??src)[index];	49	dest.?[index] = src.?[index];
50	}	50	}
51	}	51	}
52		52

std/special/compiler_rt/divti3.zig created+26

...	@@ -0,0 +1,26 @@
1	const udivmod = @import("udivmod.zig").udivmod;
2	const builtin = @import("builtin");
3	const compiler_rt = @import("index.zig");
4
5	pub extern fn __divti3(a: i128, b: i128) i128 {
6	@setRuntimeSafety(builtin.is_test);
7
8	const s_a = a >> (i128.bit_count - 1);
9	const s_b = b >> (i128.bit_count - 1);
10
11	const an = (a ^ s_a) -% s_a;
12	const bn = (b ^ s_b) -% s_b;
13
14	const r = udivmod(u128, @bitCast(u128, an), @bitCast(u128, bn), null);
15	const s = s_a ^ s_b;
16	return (i128(r) ^ s) -% s;
17	}
18
19	pub extern fn __divti3_windows_x86_64(a: const i128, b: const i128) void {
20	@setRuntimeSafety(builtin.is_test);
21	compiler_rt.setXmm0(i128, __divti3(a., b.));
22	}
23
24	test "import divti3" {
25	_ = @import("divti3_test.zig");
26	}

std/special/compiler_rt/divti3_test.zig created+21

...	@@ -0,0 +1,21 @@
1	const __divti3 = @import("divti3.zig").__divti3;
2	const assert = @import("std").debug.assert;
3
4	fn test__divti3(a: i128, b: i128, expected: i128) void {
5	const x = __divti3(a, b);
6	assert(x == expected);
7	}
8
9	test "divti3" {
10	test__divti3(0, 1, 0);
11	test__divti3(0, -1, 0);
12	test__divti3(2, 1, 2);
13	test__divti3(2, -1, -2);
14	test__divti3(-2, 1, -2);
15	test__divti3(-2, -1, 2);
16
17	test__divti3(@bitCast(i128, u128(0x8 << 124)), 1, @bitCast(i128, u128(0x8 << 124)));
18	test__divti3(@bitCast(i128, u128(0x8 << 124)), -1, @bitCast(i128, u128(0x8 << 124)));
19	test__divti3(@bitCast(i128, u128(0x8 << 124)), -2, @bitCast(i128, u128(0x4 << 124)));
20	test__divti3(@bitCast(i128, u128(0x8 << 124)), 2, @bitCast(i128, u128(0xc << 124)));
21	}

std/special/compiler_rt/index.zig+4

...	@@ -58,6 +58,8 @@ comptime {	...	@@ -58,6 +58,8 @@ comptime {
58	@export("__chkstk", __chkstk, strong_linkage);	58	@export("__chkstk", __chkstk, strong_linkage);
59	@export("___chkstk_ms", ___chkstk_ms, linkage);	59	@export("___chkstk_ms", ___chkstk_ms, linkage);
60	}	60	}
		61	@export("__divti3", @import("divti3.zig").__divti3_windows_x86_64, linkage);
		62	@export("__muloti4", @import("muloti4.zig").__muloti4_windows_x86_64, linkage);
61	@export("__udivti3", @import("udivti3.zig").__udivti3_windows_x86_64, linkage);	63	@export("__udivti3", @import("udivti3.zig").__udivti3_windows_x86_64, linkage);
62	@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4_windows_x86_64, linkage);	64	@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4_windows_x86_64, linkage);
63	@export("__umodti3", @import("umodti3.zig").__umodti3_windows_x86_64, linkage);	65	@export("__umodti3", @import("umodti3.zig").__umodti3_windows_x86_64, linkage);
...	@@ -65,6 +67,8 @@ comptime {	...	@@ -65,6 +67,8 @@ comptime {
65	else => {},	67	else => {},
66	}	68	}
67	} else {	69	} else {
		70	@export("__divti3", @import("divti3.zig").__divti3, linkage);
		71	@export("__muloti4", @import("muloti4.zig").__muloti4, linkage);
68	@export("__udivti3", @import("udivti3.zig").__udivti3, linkage);	72	@export("__udivti3", @import("udivti3.zig").__udivti3, linkage);
69	@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4, linkage);	73	@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4, linkage);
70	@export("__umodti3", @import("umodti3.zig").__umodti3, linkage);	74	@export("__umodti3", @import("umodti3.zig").__umodti3, linkage);

std/special/compiler_rt/muloti4.zig created+55

...	@@ -0,0 +1,55 @@
1	const udivmod = @import("udivmod.zig").udivmod;
2	const builtin = @import("builtin");
3	const compiler_rt = @import("index.zig");
4
5	pub extern fn __muloti4(a: i128, b: i128, overflow: *c_int) i128 {
6	@setRuntimeSafety(builtin.is_test);
7
8	const min = @bitCast(i128, u128(1 << (i128.bit_count - 1)));
9	const max = ~min;
10	overflow.* = 0;
11
12	const r = a *% b;
13	if (a == min) {
14	if (b != 0 and b != 1) {
15	overflow.* = 1;
16	}
17	return r;
18	}
19	if (b == min) {
20	if (a != 0 and a != 1) {
21	overflow.* = 1;
22	}
23	return r;
24	}
25
26	const sa = a >> (i128.bit_count - 1);
27	const abs_a = (a ^ sa) -% sa;
28	const sb = b >> (i128.bit_count - 1);
29	const abs_b = (b ^ sb) -% sb;
30
31	if (abs_a < 2 or abs_b < 2) {
32	return r;
33	}
34
35	if (sa == sb) {
36	if (abs_a > @divFloor(max, abs_b)) {
37	overflow.* = 1;
38	}
39	} else {
40	if (abs_a > @divFloor(min, -abs_b)) {
41	overflow.* = 1;
42	}
43	}
44
45	return r;
46	}
47
48	pub extern fn __muloti4_windows_x86_64(a: const i128, b: const i128, overflow: *c_int) void {
49	@setRuntimeSafety(builtin.is_test);
50	compiler_rt.setXmm0(i128, __muloti4(a., b., overflow));
51	}
52
53	test "import muloti4" {
54	_ = @import("muloti4_test.zig");
55	}

std/special/compiler_rt/muloti4_test.zig created+76

...	@@ -0,0 +1,76 @@
1	const __muloti4 = @import("muloti4.zig").__muloti4;
2	const assert = @import("std").debug.assert;
3
4	fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) void {
5	var overflow: c_int = undefined;
6	const x = __muloti4(a, b, &overflow);
7	assert(overflow == expected_overflow and (expected_overflow != 0 or x == expected));
8	}
9
10	test "muloti4" {
11	test__muloti4(0, 0, 0, 0);
12	test__muloti4(0, 1, 0, 0);
13	test__muloti4(1, 0, 0, 0);
14	test__muloti4(0, 10, 0, 0);
15	test__muloti4(10, 0, 0, 0);
16
17	test__muloti4(0, 81985529216486895, 0, 0);
18	test__muloti4(81985529216486895, 0, 0, 0);
19
20	test__muloti4(0, -1, 0, 0);
21	test__muloti4(-1, 0, 0, 0);
22	test__muloti4(0, -10, 0, 0);
23	test__muloti4(-10, 0, 0, 0);
24	test__muloti4(0, -81985529216486895, 0, 0);
25	test__muloti4(-81985529216486895, 0, 0, 0);
26
27	test__muloti4(3037000499, 3037000499, 9223372030926249001, 0);
28	test__muloti4(-3037000499, 3037000499, -9223372030926249001, 0);
29	test__muloti4(3037000499, -3037000499, -9223372030926249001, 0);
30	test__muloti4(-3037000499, -3037000499, 9223372030926249001, 0);
31
32	test__muloti4(4398046511103, 2097152, 9223372036852678656, 0);
33	test__muloti4(-4398046511103, 2097152, -9223372036852678656, 0);
34	test__muloti4(4398046511103, -2097152, -9223372036852678656, 0);
35	test__muloti4(-4398046511103, -2097152, 9223372036852678656, 0);
36
37	test__muloti4(2097152, 4398046511103, 9223372036852678656, 0);
38	test__muloti4(-2097152, 4398046511103, -9223372036852678656, 0);
39	test__muloti4(2097152, -4398046511103, -9223372036852678656, 0);
40	test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0);
41
42	test__muloti4(@bitCast(i128, u128(0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, u128(0x000000000000000000B504F333F9DE5B)), @bitCast(i128, u128(0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0);
43	test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
44	test__muloti4(-2, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
45
46	test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
47	test__muloti4(-1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
48	test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0);
49	test__muloti4(0, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0);
50	test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
51	test__muloti4(1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
52	test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
53	test__muloti4(2, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
54
55	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), -2, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
56	test__muloti4(-2, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
57	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), -1, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
58	test__muloti4(-1, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
59	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), 0, 0, 0);
60	test__muloti4(0, @bitCast(i128, u128(0x80000000000000000000000000000000)), 0, 0);
61	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), 1, @bitCast(i128, u128(0x80000000000000000000000000000000)), 0);
62	test__muloti4(1, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 0);
63	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), 2, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
64	test__muloti4(2, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
65
66	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), -2, @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
67	test__muloti4(-2, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
68	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), -1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
69	test__muloti4(-1, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
70	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), 0, 0, 0);
71	test__muloti4(0, @bitCast(i128, u128(0x80000000000000000000000000000001)), 0, 0);
72	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), 1, @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
73	test__muloti4(1, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
74	test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), 2, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
75	test__muloti4(2, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
76	}

std/unicode.zig+13-13

...	@@ -220,7 +220,7 @@ const Utf8Iterator = struct {	...	@@ -220,7 +220,7 @@ const Utf8Iterator = struct {
220	}	220	}
221		221
222	pub fn nextCodepoint(it: *Utf8Iterator) ?u32 {	222	pub fn nextCodepoint(it: *Utf8Iterator) ?u32 {
223	const slice = it.nextCodepointSlice() ?? return null;	223	const slice = it.nextCodepointSlice() orelse return null;
224		224
225	switch (slice.len) {	225	switch (slice.len) {
226	1 => return u32(slice[0]),	226	1 => return u32(slice[0]),
...	@@ -286,15 +286,15 @@ fn testUtf8IteratorOnAscii() void {	...	@@ -286,15 +286,15 @@ fn testUtf8IteratorOnAscii() void {
286	const s = Utf8View.initComptime("abc");	286	const s = Utf8View.initComptime("abc");
287		287
288	var it1 = s.iterator();	288	var it1 = s.iterator();
289	debug.assert(std.mem.eql(u8, "a", ??it1.nextCodepointSlice()));	289	debug.assert(std.mem.eql(u8, "a", it1.nextCodepointSlice().?));
290	debug.assert(std.mem.eql(u8, "b", ??it1.nextCodepointSlice()));	290	debug.assert(std.mem.eql(u8, "b", it1.nextCodepointSlice().?));
291	debug.assert(std.mem.eql(u8, "c", ??it1.nextCodepointSlice()));	291	debug.assert(std.mem.eql(u8, "c", it1.nextCodepointSlice().?));
292	debug.assert(it1.nextCodepointSlice() == null);	292	debug.assert(it1.nextCodepointSlice() == null);
293		293
294	var it2 = s.iterator();	294	var it2 = s.iterator();
295	debug.assert(??it2.nextCodepoint() == 'a');	295	debug.assert(it2.nextCodepoint().? == 'a');
296	debug.assert(??it2.nextCodepoint() == 'b');	296	debug.assert(it2.nextCodepoint().? == 'b');
297	debug.assert(??it2.nextCodepoint() == 'c');	297	debug.assert(it2.nextCodepoint().? == 'c');
298	debug.assert(it2.nextCodepoint() == null);	298	debug.assert(it2.nextCodepoint() == null);
299	}	299	}
300		300
...	@@ -321,15 +321,15 @@ fn testUtf8ViewOk() void {	...	@@ -321,15 +321,15 @@ fn testUtf8ViewOk() void {
321	const s = Utf8View.initComptime("東京市");	321	const s = Utf8View.initComptime("東京市");
322		322
323	var it1 = s.iterator();	323	var it1 = s.iterator();
324	debug.assert(std.mem.eql(u8, "東", ??it1.nextCodepointSlice()));	324	debug.assert(std.mem.eql(u8, "東", it1.nextCodepointSlice().?));
325	debug.assert(std.mem.eql(u8, "京", ??it1.nextCodepointSlice()));	325	debug.assert(std.mem.eql(u8, "京", it1.nextCodepointSlice().?));
326	debug.assert(std.mem.eql(u8, "市", ??it1.nextCodepointSlice()));	326	debug.assert(std.mem.eql(u8, "市", it1.nextCodepointSlice().?));
327	debug.assert(it1.nextCodepointSlice() == null);	327	debug.assert(it1.nextCodepointSlice() == null);
328		328
329	var it2 = s.iterator();	329	var it2 = s.iterator();
330	debug.assert(??it2.nextCodepoint() == 0x6771);	330	debug.assert(it2.nextCodepoint().? == 0x6771);
331	debug.assert(??it2.nextCodepoint() == 0x4eac);	331	debug.assert(it2.nextCodepoint().? == 0x4eac);
332	debug.assert(??it2.nextCodepoint() == 0x5e02);	332	debug.assert(it2.nextCodepoint().? == 0x5e02);
333	debug.assert(it2.nextCodepoint() == null);	333	debug.assert(it2.nextCodepoint() == null);
334	}	334	}
335		335

std/zig/ast.zig+32-16

...	@@ -734,7 +734,7 @@ pub const Node = struct {	...	@@ -734,7 +734,7 @@ pub const Node = struct {
734	var i = index;	734	var i = index;
735		735
736	if (self.doc_comments) \|comments\| {	736	if (self.doc_comments) \|comments\| {
737	if (i < 1) return *comments.base;	737	if (i < 1) return &comments.base;
738	i -= 1;	738	i -= 1;
739	}	739	}
740		740
...	@@ -1243,7 +1243,7 @@ pub const Node = struct {	...	@@ -1243,7 +1243,7 @@ pub const Node = struct {
1243	i -= 1;	1243	i -= 1;
1244		1244
1245	if (self.@"else") \|@"else"\| {	1245	if (self.@"else") \|@"else"\| {
1246	if (i < 1) return *@"else".base;	1246	if (i < 1) return &@"else".base;
1247	i -= 1;	1247	i -= 1;
1248	}	1248	}
1249		1249
...	@@ -1296,7 +1296,7 @@ pub const Node = struct {	...	@@ -1296,7 +1296,7 @@ pub const Node = struct {
1296	i -= 1;	1296	i -= 1;
1297		1297
1298	if (self.@"else") \|@"else"\| {	1298	if (self.@"else") \|@"else"\| {
1299	if (i < 1) return *@"else".base;	1299	if (i < 1) return &@"else".base;
1300	i -= 1;	1300	i -= 1;
1301	}	1301	}
1302		1302
...	@@ -1347,7 +1347,7 @@ pub const Node = struct {	...	@@ -1347,7 +1347,7 @@ pub const Node = struct {
1347	i -= 1;	1347	i -= 1;
1348		1348
1349	if (self.@"else") \|@"else"\| {	1349	if (self.@"else") \|@"else"\| {
1350	if (i < 1) return *@"else".base;	1350	if (i < 1) return &@"else".base;
1351	i -= 1;	1351	i -= 1;
1352	}	1352	}
1353		1353
...	@@ -1417,7 +1417,7 @@ pub const Node = struct {	...	@@ -1417,7 +1417,7 @@ pub const Node = struct {
1417	Range,	1417	Range,
1418	Sub,	1418	Sub,
1419	SubWrap,	1419	SubWrap,
1420	UnwrapMaybe,	1420	UnwrapOptional,
1421	};	1421	};
1422		1422
1423	pub fn iterate(self: InfixOp, index: usize) ?Node {	1423	pub fn iterate(self: InfixOp, index: usize) ?Node {
...	@@ -1475,7 +1475,7 @@ pub const Node = struct {	...	@@ -1475,7 +1475,7 @@ pub const Node = struct {
1475	Op.Range,	1475	Op.Range,
1476	Op.Sub,	1476	Op.Sub,
1477	Op.SubWrap,	1477	Op.SubWrap,
1478	Op.UnwrapMaybe,	1478	Op.UnwrapOptional,
1479	=> {},	1479	=> {},
1480	}	1480	}
1481		1481
...	@@ -1507,14 +1507,13 @@ pub const Node = struct {	...	@@ -1507,14 +1507,13 @@ pub const Node = struct {
1507	BitNot,	1507	BitNot,
1508	BoolNot,	1508	BoolNot,
1509	Cancel,	1509	Cancel,
1510	MaybeType,	1510	OptionalType,
1511	Negation,	1511	Negation,
1512	NegationWrap,	1512	NegationWrap,
1513	Resume,	1513	Resume,
1514	PtrType: PtrInfo,	1514	PtrType: PtrInfo,
1515	SliceType: PtrInfo,	1515	SliceType: PtrInfo,
1516	Try,	1516	Try,
1517	UnwrapMaybe,
1518	};	1517	};
1519		1518
1520	pub const PtrInfo = struct {	1519	pub const PtrInfo = struct {
...	@@ -1537,33 +1536,36 @@ pub const Node = struct {	...	@@ -1537,33 +1536,36 @@ pub const Node = struct {
1537	var i = index;	1536	var i = index;
1538		1537
1539	switch (self.op) {	1538	switch (self.op) {
		1539	// TODO https://github.com/ziglang/zig/issues/1107
1540	Op.SliceType => \|addr_of_info\| {	1540	Op.SliceType => \|addr_of_info\| {
1541	if (addr_of_info.align_info) \|align_info\| {	1541	if (addr_of_info.align_info) \|align_info\| {
1542	if (i < 1) return align_info.node;	1542	if (i < 1) return align_info.node;
1543	i -= 1;	1543	i -= 1;
1544	}	1544	}
1545	},	1545	},
1546	Op.AddrOf => \|addr_of_info\| {	1546
		1547	Op.PtrType => \|addr_of_info\| {
1547	if (addr_of_info.align_info) \|align_info\| {	1548	if (addr_of_info.align_info) \|align_info\| {
1548	if (i < 1) return align_info.node;	1549	if (i < 1) return align_info.node;
1549	i -= 1;	1550	i -= 1;
1550	}	1551	}
1551	},	1552	},
		1553
1552	Op.ArrayType => \|size_expr\| {	1554	Op.ArrayType => \|size_expr\| {
1553	if (i < 1) return size_expr;	1555	if (i < 1) return size_expr;
1554	i -= 1;	1556	i -= 1;
1555	},	1557	},
		1558
		1559	Op.AddressOf,
1556	Op.Await,	1560	Op.Await,
1557	Op.BitNot,	1561	Op.BitNot,
1558	Op.BoolNot,	1562	Op.BoolNot,
1559	Op.Cancel,	1563	Op.Cancel,
1560	Op.MaybeType,	1564	Op.OptionalType,
1561	Op.Negation,	1565	Op.Negation,
1562	Op.NegationWrap,	1566	Op.NegationWrap,
1563	Op.Try,	1567	Op.Try,
1564	Op.Resume,	1568	Op.Resume,
1565	Op.UnwrapMaybe,
1566	Op.PointerType,
1567	=> {},	1569	=> {},
1568	}	1570	}
1569		1571
...	@@ -1619,6 +1621,7 @@ pub const Node = struct {	...	@@ -1619,6 +1621,7 @@ pub const Node = struct {
1619	ArrayInitializer: InitList,	1621	ArrayInitializer: InitList,
1620	StructInitializer: InitList,	1622	StructInitializer: InitList,
1621	Deref,	1623	Deref,
		1624	UnwrapOptional,
1622		1625
1623	pub const InitList = SegmentedList(*Node, 2);	1626	pub const InitList = SegmentedList(*Node, 2);
1624		1627
...	@@ -1667,7 +1670,9 @@ pub const Node = struct {	...	@@ -1667,7 +1670,9 @@ pub const Node = struct {
1667	if (i < fields.len) return fields.at(i).*;	1670	if (i < fields.len) return fields.at(i).*;
1668	i -= fields.len;	1671	i -= fields.len;
1669	},	1672	},
1670	Op.Deref => {},	1673	Op.UnwrapOptional,
		1674	Op.Deref,
		1675	=> {},
1671	}	1676	}
1672		1677
1673	return null;	1678	return null;
...	@@ -2022,7 +2027,7 @@ pub const Node = struct {	...	@@ -2022,7 +2027,7 @@ pub const Node = struct {
2022		2027
2023	switch (self.kind) {	2028	switch (self.kind) {
2024	Kind.Variable => \|variable_name\| {	2029	Kind.Variable => \|variable_name\| {
2025	if (i < 1) return *variable_name.base;	2030	if (i < 1) return &variable_name.base;
2026	i -= 1;	2031	i -= 1;
2027	},	2032	},
2028	Kind.Return => \|return_type\| {	2033	Kind.Return => \|return_type\| {
...	@@ -2092,10 +2097,10 @@ pub const Node = struct {	...	@@ -2092,10 +2097,10 @@ pub const Node = struct {
2092	pub fn iterate(self: Asm, index: usize) ?Node {	2097	pub fn iterate(self: Asm, index: usize) ?Node {
2093	var i = index;	2098	var i = index;
2094		2099
2095	if (i < self.outputs.len) return (self.outputs.at(index).).base;	2100	if (i < self.outputs.len) return &self.outputs.at(index).*.base;
2096	i -= self.outputs.len;	2101	i -= self.outputs.len;
2097		2102
2098	if (i < self.inputs.len) return (self.inputs.at(index).).base;	2103	if (i < self.inputs.len) return &self.inputs.at(index).*.base;
2099	i -= self.inputs.len;	2104	i -= self.inputs.len;
2100		2105
2101	return null;	2106	return null;
...	@@ -2205,3 +2210,14 @@ pub const Node = struct {	...	@@ -2205,3 +2210,14 @@ pub const Node = struct {
2205	}	2210	}
2206	};	2211	};
2207	};	2212	};
		2213
		2214	test "iterate" {
		2215	var root = Node.Root{
		2216	.base = Node{ .id = Node.Id.Root },
		2217	.doc_comments = null,
		2218	.decls = Node.Root.DeclList.init(std.debug.global_allocator),
		2219	.eof_token = 0,
		2220	};
		2221	var base = &root.base;
		2222	assert(base.iterate(0) == null);
		2223	}

std/zig/parse.zig+44-34

std/zig/parser_test.zig+4-3

...	@@ -650,9 +650,10 @@ test "zig fmt: statements with empty line between" {	...	@@ -650,9 +650,10 @@ test "zig fmt: statements with empty line between" {
650	);	650	);
651	}	651	}
652		652
653	test "zig fmt: ptr deref operator" {	653	test "zig fmt: ptr deref operator and unwrap optional operator" {
654	try testCanonical(	654	try testCanonical(
655	\\const a = b.*;	655	\\const a = b.*;
		656	\\const a = b.?;
656	\\	657	\\
657	);	658	);
658	}	659	}
...	@@ -1150,7 +1151,7 @@ test "zig fmt: infix operators" {	...	@@ -1150,7 +1151,7 @@ test "zig fmt: infix operators" {
1150	\\ _ = i!i;	1151	\\ _ = i!i;
1151	\\ _ = i ** i;	1152	\\ _ = i ** i;
1152	\\ _ = i ++ i;	1153	\\ _ = i ++ i;
1153	\\ _ = i ?? i;	1154	\\ _ = i orelse i;
1154	\\ _ = i % i;	1155	\\ _ = i % i;
1155	\\ _ = i / i;	1156	\\ _ = i / i;
1156	\\ _ = i *% i;	1157	\\ _ = i *% i;
...	@@ -1209,7 +1210,7 @@ test "zig fmt: precedence" {	...	@@ -1209,7 +1210,7 @@ test "zig fmt: precedence" {
1209	test "zig fmt: prefix operators" {	1210	test "zig fmt: prefix operators" {
1210	try testCanonical(	1211	try testCanonical(
1211	\\test "prefix operators" {	1212	\\test "prefix operators" {
1212	\\ try return --%~??!*&0;	1213	\\ try return --%~!*&0;
1213	\\}	1214	\\}
1214	\\	1215	\\
1215	);	1216	);

std/zig/render.zig+16-17

std/zig/tokenizer.zig+7-20

 @@ -39,6 +39,7 @@ pub const Token = struct {
         Keyword{ .bytes = "noalias", .id = Id.Keyword_noalias },
         Keyword{ .bytes = "null", .id = Id.Keyword_null },
         Keyword{ .bytes = "or", .id = Id.Keyword_or },
+        Keyword{ .bytes = "orelse", .id = Id.Keyword_orelse },
         Keyword{ .bytes = "packed", .id = Id.Keyword_packed },
         Keyword{ .bytes = "promise", .id = Id.Keyword_promise },
         Keyword{ .bytes = "pub", .id = Id.Keyword_pub },
 @@ -129,7 +130,6 @@ pub const Token = struct {
         Ampersand,
         AmpersandEqual,
         QuestionMark,
-        QuestionMarkQuestionMark,
         AngleBracketLeft,
         AngleBracketLeftEqual,
         AngleBracketAngleBracketLeft,
 @@ -171,6 +171,7 @@ pub const Token = struct {
         Keyword_noalias,
         Keyword_null,
         Keyword_or,
+        Keyword_orelse,
         Keyword_packed,
         Keyword_promise,
         Keyword_pub,
 @@ -254,7 +255,6 @@ pub const Tokenizer = struct {
         Ampersand,
         Caret,
         Percent,
-        QuestionMark,
         Plus,
         PlusPercent,
         AngleBracketLeft,
 @@ -345,6 +345,11 @@ pub const Tokenizer = struct {
                         self.index += 1;
                         break;
                     },
+                    '?' => {
+                        result.id = Token.Id.QuestionMark;
+                        self.index += 1;
+                        break;
+                    },
                     ':' => {
                         result.id = Token.Id.Colon;
                         self.index += 1;
 @@ -359,9 +364,6 @@ pub const Tokenizer = struct {
                     '+' => {
                         state = State.Plus;
                     },
-                    '?' => {
-                        state = State.QuestionMark;
-                    },
                     '<' => {
                         state = State.AngleBracketLeft;
                     },
 @@ -496,18 +498,6 @@ pub const Tokenizer = struct {
                     },
                 },
-                State.QuestionMark => switch (c) {
-                    '?' => {
-                        result.id = Token.Id.QuestionMarkQuestionMark;
-                        self.index += 1;
-                        break;
-                    },
-                    else => {
-                        result.id = Token.Id.QuestionMark;
-                        break;
-                    },
-                },
                 State.Percent => switch (c) {
                     '=' => {
                         result.id = Token.Id.PercentEqual;
 @@ -1084,9 +1074,6 @@ pub const Tokenizer = struct {
                 State.Plus => {
                     result.id = Token.Id.Plus;
                 },
-                State.QuestionMark => {
-                    result.id = Token.Id.QuestionMark;
-                },
                 State.Percent => {
                     result.id = Token.Id.Percent;
                 },

test/behavior.zig+1

...	@@ -31,6 +31,7 @@ comptime {	...	@@ -31,6 +31,7 @@ comptime {
31	_ = @import("cases/incomplete_struct_param_tld.zig");	31	_ = @import("cases/incomplete_struct_param_tld.zig");
32	_ = @import("cases/ir_block_deps.zig");	32	_ = @import("cases/ir_block_deps.zig");
33	_ = @import("cases/math.zig");	33	_ = @import("cases/math.zig");
		34	_ = @import("cases/merge_error_sets.zig");
34	_ = @import("cases/misc.zig");	35	_ = @import("cases/misc.zig");
35	_ = @import("cases/namespace_depends_on_compile_var/index.zig");	36	_ = @import("cases/namespace_depends_on_compile_var/index.zig");
36	_ = @import("cases/new_stack_call.zig");	37	_ = @import("cases/new_stack_call.zig");

test/cases/array.zig+9-1

...	@@ -116,6 +116,15 @@ test "array len property" {	...	@@ -116,6 +116,15 @@ test "array len property" {
116	assert(@typeOf(x).len == 5);	116	assert(@typeOf(x).len == 5);
117	}	117	}
118		118
		119	test "array len field" {
		120	var arr = [4]u8{ 0, 0, 0, 0 };
		121	var ptr = &arr;
		122	assert(arr.len == 4);
		123	comptime assert(arr.len == 4);
		124	assert(ptr.len == 4);
		125	comptime assert(ptr.len == 4);
		126	}
		127
119	test "single-item pointer to array indexing and slicing" {	128	test "single-item pointer to array indexing and slicing" {
120	testSingleItemPtrArrayIndexSlice();	129	testSingleItemPtrArrayIndexSlice();
121	comptime testSingleItemPtrArrayIndexSlice();	130	comptime testSingleItemPtrArrayIndexSlice();
...	@@ -143,4 +152,3 @@ fn testImplicitCastSingleItemPtr() void {	...	@@ -143,4 +152,3 @@ fn testImplicitCastSingleItemPtr() void {
143	slice[0] += 1;	152	slice[0] += 1;
144	assert(byte == 101);	153	assert(byte == 101);
145	}	154	}
146

test/cases/bugs/656.zig+1-1

...	@@ -9,7 +9,7 @@ const Value = struct {	...	@@ -9,7 +9,7 @@ const Value = struct {
9	align_expr: ?u32,	9	align_expr: ?u32,
10	};	10	};
11		11
12	test "nullable if after an if in a switch prong of a switch with 2 prongs in an else" {	12	test "optional if after an if in a switch prong of a switch with 2 prongs in an else" {
13	foo(false, true);	13	foo(false, true);
14	}	14	}
15		15

test/cases/cast.zig+51-29

 @@ -1,5 +1,6 @@
-const assert = @import("std").debug.assert;
+const std = @import("std");
-const mem = @import("std").mem;
+const assert = std.debug.assert;
+const mem = std.mem;
 test "int to ptr cast" {
     const x = usize(13);
 @@ -72,7 +73,7 @@ fn Struct(comptime T: type) type {
         fn maybePointer(self: ?*const Self) Self {
             const none = Self{ .x = if (T == void) void{} else 0 };
-            return (self ?? &none).*;
+            return (self orelse &none).*;
         }
     };
 }
 @@ -86,7 +87,7 @@ const Union = union {
     fn maybePointer(self: ?*const Union) Union {
         const none = Union{ .x = 0 };
-        return (self ?? &none).*;
+        return (self orelse &none).*;
     }
 };
 @@ -99,7 +100,7 @@ const Enum = enum {
     }
     fn maybePointer(self: ?*const Enum) Enum {
-        return (self ?? &Enum.None).*;
+        return (self orelse &Enum.None).*;
     }
 };
 @@ -108,16 +109,16 @@ test "implicitly cast indirect pointer to maybe-indirect pointer" {
         const Self = this;
         x: u8,
         fn constConst(p: *const *const Self) u8 {
-            return (p.*).x;
+            return p.*.x;
         }
         fn maybeConstConst(p: ?*const *const Self) u8 {
-            return ((??p).*).x;
+            return p.?.*.x;
         }
         fn constConstConst(p: *const *const *const Self) u8 {
-            return (p.*.*).x;
+            return p.*.*.x;
         }
         fn maybeConstConstConst(p: ?*const *const *const Self) u8 {
-            return ((??p).*.*).x;
+            return p.?.*.*.x;
         }
     };
     const s = S{ .x = 42 };
 @@ -176,56 +177,56 @@ test "string literal to &const []const u8" {
 }
 test "implicitly cast from T to error!?T" {
-    castToMaybeTypeError(1);
+    castToOptionalTypeError(1);
-    comptime castToMaybeTypeError(1);
+    comptime castToOptionalTypeError(1);
 }
 const A = struct {
     a: i32,
 };
-fn castToMaybeTypeError(z: i32) void {
+fn castToOptionalTypeError(z: i32) void {
     const x = i32(1);
     const y: error!?i32 = x;
-    assert(??(try y) == 1);
+    assert((try y).? == 1);
     const f = z;
     const g: error!?i32 = f;
     const a = A{ .a = z };
     const b: error!?A = a;
-    assert((??(b catch unreachable)).a == 1);
+    assert((b catch unreachable).?.a == 1);
 }
 test "implicitly cast from int to error!?T" {
-    implicitIntLitToMaybe();
+    implicitIntLitToOptional();
-    comptime implicitIntLitToMaybe();
+    comptime implicitIntLitToOptional();
 }
-fn implicitIntLitToMaybe() void {
+fn implicitIntLitToOptional() void {
     const f: ?i32 = 1;
     const g: error!?i32 = 1;
 }
 test "return null from fn() error!?&T" {
-    const a = returnNullFromMaybeTypeErrorRef();
+    const a = returnNullFromOptionalTypeErrorRef();
-    const b = returnNullLitFromMaybeTypeErrorRef();
+    const b = returnNullLitFromOptionalTypeErrorRef();
     assert((try a) == null and (try b) == null);
 }
-fn returnNullFromMaybeTypeErrorRef() error!?*A {
+fn returnNullFromOptionalTypeErrorRef() error!?*A {
     const a: ?*A = null;
     return a;
 }
-fn returnNullLitFromMaybeTypeErrorRef() error!?*A {
+fn returnNullLitFromOptionalTypeErrorRef() error!?*A {
     return null;
 }
 test "peer type resolution: ?T and T" {
-    assert(??peerTypeTAndMaybeT(true, false) == 0);
+    assert(peerTypeTAndOptionalT(true, false).? == 0);
-    assert(??peerTypeTAndMaybeT(false, false) == 3);
+    assert(peerTypeTAndOptionalT(false, false).? == 3);
     comptime {
-        assert(??peerTypeTAndMaybeT(true, false) == 0);
+        assert(peerTypeTAndOptionalT(true, false).? == 0);
-        assert(??peerTypeTAndMaybeT(false, false) == 3);
+        assert(peerTypeTAndOptionalT(false, false).? == 3);
     }
 }
-fn peerTypeTAndMaybeT(c: bool, b: bool) ?usize {
+fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
     if (c) {
         return if (b) null else usize(0);
     }
 @@ -250,11 +251,11 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
 }
 test "implicitly cast from [N]T to ?[]const T" {
-    assert(mem.eql(u8, ??castToMaybeSlice(), "hi"));
+    assert(mem.eql(u8, castToOptionalSlice().?, "hi"));
-    comptime assert(mem.eql(u8, ??castToMaybeSlice(), "hi"));
+    comptime assert(mem.eql(u8, castToOptionalSlice().?, "hi"));
 }
-fn castToMaybeSlice() ?[]const u8 {
+fn castToOptionalSlice() ?[]const u8 {
     return "hi";
 }
 @@ -384,3 +385,24 @@ test "const slice widen cast" {
     assert(@bitCast(u32, bytes) == 0x12121212);
 }
+test "single-item pointer of array to slice and to unknown length pointer" {
+    testCastPtrOfArrayToSliceAndPtr();
+    comptime testCastPtrOfArrayToSliceAndPtr();
+}
+fn testCastPtrOfArrayToSliceAndPtr() void {
+    var array = "ao" ++ "eu"; // TODO https://github.com/ziglang/zig/issues/1076
+    const x: [*]u8 = &array;
+    x[0] += 1;
+    assert(mem.eql(u8, array[0..], "boeu"));
+    const y: []u8 = &array;
+    y[0] += 1;
+    assert(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 x: [*]const ?[*]const u8 = &window_name;
+    assert(mem.eql(u8, std.cstr.toSliceConst(x[0].?), "window name"));
+}

test/cases/enum.zig+9

...	@@ -883,3 +883,12 @@ test "empty extern enum with members" {	...	@@ -883,3 +883,12 @@ test "empty extern enum with members" {
883	};	883	};
884	assert(@sizeOf(E) == @sizeOf(c_int));	884	assert(@sizeOf(E) == @sizeOf(c_int));
885	}	885	}
		886
		887	test "aoeu" {
		888	const LocalFoo = enum {
		889	A = 1,
		890	B = 0,
		891	};
		892	var b = LocalFoo.B;
		893	assert(mem.eql(u8, @tagName(b), "B"));
		894	}

test/cases/error.zig+1-1

...	@@ -140,7 +140,7 @@ fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) void {	...	@@ -140,7 +140,7 @@ fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) void {
140	if (x) \|v\| assert(v == 1234) else \|err\| @compileError("bad");	140	if (x) \|v\| assert(v == 1234) else \|err\| @compileError("bad");
141	}	141	}
142		142
143	test "syntax: nullable operator in front of error union operator" {	143	test "syntax: optional operator in front of error union operator" {
144	comptime {	144	comptime {
145	assert(?error!i32 == ?(error!i32));	145	assert(?error!i32 == ?(error!i32));
146	}	146	}

test/cases/eval.zig+14-1

...	@@ -12,7 +12,7 @@ fn fibonacci(x: i32) i32 {	...	@@ -12,7 +12,7 @@ fn fibonacci(x: i32) i32 {
12	}	12	}
13		13
14	fn unwrapAndAddOne(blah: ?i32) i32 {	14	fn unwrapAndAddOne(blah: ?i32) i32 {
15	return ??blah + 1;	15	return blah.? + 1;
16	}	16	}
17	const should_be_1235 = unwrapAndAddOne(1234);	17	const should_be_1235 = unwrapAndAddOne(1234);
18	test "static add one" {	18	test "static add one" {
...	@@ -610,3 +610,16 @@ test "slice of type" {	...	@@ -610,3 +610,16 @@ test "slice of type" {
610	}	610	}
611	}	611	}
612	}	612	}
		613
		614	const Wrapper = struct {
		615	T: type,
		616	};
		617
		618	fn wrap(comptime T: type) Wrapper {
		619	return Wrapper{ .T = T };
		620	}
		621
		622	test "function which returns struct with type field causes implicit comptime" {
		623	const ty = wrap(i32).T;
		624	assert(ty == i32);
		625	}

test/cases/generics.zig+1-1

...	@@ -127,7 +127,7 @@ test "generic fn with implicit cast" {	...	@@ -127,7 +127,7 @@ test "generic fn with implicit cast" {
127	}) == 0);	127	}) == 0);
128	}	128	}
129	fn getByte(ptr: ?*const u8) u8 {	129	fn getByte(ptr: ?*const u8) u8 {
130	return (??ptr).*;	130	return ptr.?.*;
131	}	131	}
132	fn getFirstByte(comptime T: type, mem: []const T) u8 {	132	fn getFirstByte(comptime T: type, mem: []const T) u8 {
133	return getByte(@ptrCast(*const u8, &mem[0]));	133	return getByte(@ptrCast(*const u8, &mem[0]));

test/cases/merge_error_sets.zig created+21

...	@@ -0,0 +1,21 @@
1	const A = error{
2	PathNotFound,
3	NotDir,
4	};
5	const B = error{OutOfMemory};
6
7	const C = A \|\| B;
8
9	fn foo() C!void {
10	return error.NotDir;
11	}
12
13	test "merge error sets" {
14	if (foo()) {
15	@panic("unexpected");
16	} else \|err\| switch (err) {
17	error.OutOfMemory => @panic("unexpected"),
18	error.PathNotFound => @panic("unexpected"),
19	error.NotDir => {},
20	}
21	}

test/cases/misc.zig+1-9

 @@ -505,7 +505,7 @@ test "@typeId" {
         assert(@typeId(@typeOf(1.0)) == Tid.ComptimeFloat);
         assert(@typeId(@typeOf(undefined)) == Tid.Undefined);
         assert(@typeId(@typeOf(null)) == Tid.Null);
-        assert(@typeId(?i32) == Tid.Nullable);
+        assert(@typeId(?i32) == Tid.Optional);
         assert(@typeId(error!i32) == Tid.ErrorUnion);
         assert(@typeId(error) == Tid.ErrorSet);
         assert(@typeId(AnEnum) == Tid.Enum);
 @@ -523,14 +523,6 @@ test "@typeId" {
     }
 }
-test "@canImplicitCast" {
-    comptime {
-        assert(@canImplicitCast(i64, i32(3)));
-        assert(!@canImplicitCast(i32, f32(1.234)));
-        assert(@canImplicitCast([]const u8, "aoeu"));
-    }
-}
 test "@typeName" {
     const Struct = struct {};
     const Union = union {

test/cases/null.zig+31-20

 @@ -1,6 +1,6 @@
 const assert = @import("std").debug.assert;
-test "nullable type" {
+test "optional type" {
     const x: ?bool = true;
     if (x) |y| {
 @@ -15,13 +15,13 @@ test "nullable type" {
     const next_x: ?i32 = null;
-    const z = next_x ?? 1234;
+    const z = next_x orelse 1234;
     assert(z == 1234);
     const final_x: ?i32 = 13;
-    const num = final_x ?? unreachable;
+    const num = final_x orelse unreachable;
     assert(num == 13);
 }
 @@ -33,12 +33,12 @@ test "test maybe object and get a pointer to the inner value" {
         b.* = false;
     }
-    assert(??maybe_bool == false);
+    assert(maybe_bool.? == false);
 }
 test "rhs maybe unwrap return" {
     const x: ?bool = true;
-    const y = x ?? return;
+    const y = x orelse return;
 }
 test "maybe return" {
 @@ -47,13 +47,13 @@ test "maybe return" {
 }
 fn maybeReturnImpl() void {
-    assert(??foo(1235));
+    assert(foo(1235).?);
     if (foo(null) != null) unreachable;
-    assert(!??foo(1234));
+    assert(!foo(1234).?);
 }
 fn foo(x: ?i32) ?bool {
-    const value = x ?? return null;
+    const value = x orelse return null;
     return value > 1234;
 }
 @@ -102,12 +102,12 @@ fn testTestNullRuntime(x: ?i32) void {
     assert(!(x != null));
 }
-test "nullable void" {
+test "optional void" {
-    nullableVoidImpl();
+    optionalVoidImpl();
-    comptime nullableVoidImpl();
+    comptime optionalVoidImpl();
 }
-fn nullableVoidImpl() void {
+fn optionalVoidImpl() void {
     assert(bar(null) == null);
     assert(bar({}) != null);
 }
 @@ -120,19 +120,19 @@ fn bar(x: ?void) ?void {
     }
 }
-const StructWithNullable = struct {
+const StructWithOptional = struct {
     field: ?i32,
 };
-var struct_with_nullable: StructWithNullable = undefined;
+var struct_with_optional: StructWithOptional = undefined;
-test "unwrap nullable which is field of global var" {
+test "unwrap optional which is field of global var" {
-    struct_with_nullable.field = null;
+    struct_with_optional.field = null;
-    if (struct_with_nullable.field) |payload| {
+    if (struct_with_optional.field) |payload| {
         unreachable;
     }
-    struct_with_nullable.field = 1234;
+    struct_with_optional.field = 1234;
-    if (struct_with_nullable.field) |payload| {
+    if (struct_with_optional.field) |payload| {
         assert(payload == 1234);
     } else {
         unreachable;
 @@ -140,6 +140,17 @@ test "unwrap nullable which is field of global var" {
 }
 test "null with default unwrap" {
-    const x: i32 = null ?? 1;
+    const x: i32 = null orelse 1;
     assert(x == 1);
 }
+test "optional types" {
+    comptime {
+        const opt_type_struct = StructWithOptionalType { .t=u8, };
+        assert(opt_type_struct.t != null and opt_type_struct.t.? == u8);
+    }
+}
+const StructWithOptionalType = struct {
+    t: ?type,
+};

test/cases/reflection.zig+1-1

...	@@ -2,7 +2,7 @@ const assert = @import("std").debug.assert;	...	@@ -2,7 +2,7 @@ const assert = @import("std").debug.assert;
2	const mem = @import("std").mem;	2	const mem = @import("std").mem;
3	const reflection = this;	3	const reflection = this;
4		4
5	test "reflection: array, pointer, nullable, error union type child" {	5	test "reflection: array, pointer, optional, error union type child" {
6	comptime {	6	comptime {
7	assert(([10]u8).Child == u8);	7	assert(([10]u8).Child == u8);
8	assert((*u8).Child == u8);	8	assert((*u8).Child == u8);

test/cases/struct.zig+17

...	@@ -421,3 +421,20 @@ const Expr = union(enum) {	...	@@ -421,3 +421,20 @@ const Expr = union(enum) {
421	fn alloc(comptime T: type) []T {	421	fn alloc(comptime T: type) []T {
422	return []T{};	422	return []T{};
423	}	423	}
		424
		425	test "call method with mutable reference to struct with no fields" {
		426	const S = struct {
		427	fn doC(s: *const this) bool {
		428	return true;
		429	}
		430	fn do(s: *this) bool {
		431	return true;
		432	}
		433	};
		434
		435	var s = S{};
		436	assert(S.doC(&s));
		437	assert(s.doC());
		438	assert(S.do(&s));
		439	assert(s.do());
		440	}

test/cases/type_info.zig+32-15

 @@ -39,12 +39,28 @@ test "type info: pointer type info" {
 fn testPointer() void {
     const u32_ptr_info = @typeInfo(*u32);
     assert(TypeId(u32_ptr_info) == TypeId.Pointer);
+    assert(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.One);
     assert(u32_ptr_info.Pointer.is_const == false);
     assert(u32_ptr_info.Pointer.is_volatile == false);
-    assert(u32_ptr_info.Pointer.alignment == 4);
+    assert(u32_ptr_info.Pointer.alignment == @alignOf(u32));
     assert(u32_ptr_info.Pointer.child == u32);
 }
+test "type info: unknown length pointer type info" {
+    testUnknownLenPtr();
+    comptime testUnknownLenPtr();
+}
+fn testUnknownLenPtr() void {
+    const u32_ptr_info = @typeInfo([*]const volatile f64);
+    assert(TypeId(u32_ptr_info) == TypeId.Pointer);
+    assert(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many);
+    assert(u32_ptr_info.Pointer.is_const == true);
+    assert(u32_ptr_info.Pointer.is_volatile == true);
+    assert(u32_ptr_info.Pointer.alignment == @alignOf(f64));
+    assert(u32_ptr_info.Pointer.child == f64);
+}
 test "type info: slice type info" {
     testSlice();
     comptime testSlice();
 @@ -52,11 +68,12 @@ test "type info: slice type info" {
 fn testSlice() void {
     const u32_slice_info = @typeInfo([]u32);
-    assert(TypeId(u32_slice_info) == TypeId.Slice);
+    assert(TypeId(u32_slice_info) == TypeId.Pointer);
-    assert(u32_slice_info.Slice.is_const == false);
+    assert(u32_slice_info.Pointer.size == TypeInfo.Pointer.Size.Slice);
-    assert(u32_slice_info.Slice.is_volatile == false);
+    assert(u32_slice_info.Pointer.is_const == false);
-    assert(u32_slice_info.Slice.alignment == 4);
+    assert(u32_slice_info.Pointer.is_volatile == false);
-    assert(u32_slice_info.Slice.child == u32);
+    assert(u32_slice_info.Pointer.alignment == 4);
+    assert(u32_slice_info.Pointer.child == u32);
 }
 test "type info: array type info" {
 @@ -71,15 +88,15 @@ fn testArray() void {
     assert(arr_info.Array.child == bool);
 }
-test "type info: nullable type info" {
+test "type info: optional type info" {
-    testNullable();
+    testOptional();
-    comptime testNullable();
+    comptime testOptional();
 }
-fn testNullable() void {
+fn testOptional() void {
     const null_info = @typeInfo(?void);
-    assert(TypeId(null_info) == TypeId.Nullable);
+    assert(TypeId(null_info) == TypeId.Optional);
-    assert(null_info.Nullable.child == void);
+    assert(null_info.Optional.child == void);
 }
 test "type info: promise info" {
 @@ -149,11 +166,11 @@ fn testUnion() void {
     assert(TypeId(typeinfo_info) == TypeId.Union);
     assert(typeinfo_info.Union.layout == TypeInfo.ContainerLayout.Auto);
     assert(typeinfo_info.Union.tag_type == TypeId);
-    assert(typeinfo_info.Union.fields.len == 26);
+    assert(typeinfo_info.Union.fields.len == 25);
     assert(typeinfo_info.Union.fields[4].enum_field != null);
-    assert((??typeinfo_info.Union.fields[4].enum_field).value == 4);
+    assert(typeinfo_info.Union.fields[4].enum_field.?.value == 4);
     assert(typeinfo_info.Union.fields[4].field_type == @typeOf(@typeInfo(u8).Int));
-    assert(typeinfo_info.Union.defs.len == 21);
+    assert(typeinfo_info.Union.defs.len == 20);
     const TestNoTagUnion = union {
         Foo: void,

test/cases/while.zig+6-6

...	@@ -81,7 +81,7 @@ test "while with else" {	...	@@ -81,7 +81,7 @@ test "while with else" {
81	assert(got_else == 1);	81	assert(got_else == 1);
82	}	82	}
83		83
84	test "while with nullable as condition" {	84	test "while with optional as condition" {
85	numbers_left = 10;	85	numbers_left = 10;
86	var sum: i32 = 0;	86	var sum: i32 = 0;
87	while (getNumberOrNull()) \|value\| {	87	while (getNumberOrNull()) \|value\| {
...	@@ -90,7 +90,7 @@ test "while with nullable as condition" {	...	@@ -90,7 +90,7 @@ test "while with nullable as condition" {
90	assert(sum == 45);	90	assert(sum == 45);
91	}	91	}
92		92
93	test "while with nullable as condition with else" {	93	test "while with optional as condition with else" {
94	numbers_left = 10;	94	numbers_left = 10;
95	var sum: i32 = 0;	95	var sum: i32 = 0;
96	var got_else: i32 = 0;	96	var got_else: i32 = 0;
...	@@ -132,7 +132,7 @@ fn getNumberOrNull() ?i32 {	...	@@ -132,7 +132,7 @@ fn getNumberOrNull() ?i32 {
132	};	132	};
133	}	133	}
134		134
135	test "while on nullable with else result follow else prong" {	135	test "while on optional with else result follow else prong" {
136	const result = while (returnNull()) \|value\| {	136	const result = while (returnNull()) \|value\| {
137	break value;	137	break value;
138	} else	138	} else
...	@@ -140,8 +140,8 @@ test "while on nullable with else result follow else prong" {	...	@@ -140,8 +140,8 @@ test "while on nullable with else result follow else prong" {
140	assert(result == 2);	140	assert(result == 2);
141	}	141	}
142		142
143	test "while on nullable with else result follow break prong" {	143	test "while on optional with else result follow break prong" {
144	const result = while (returnMaybe(10)) \|value\| {	144	const result = while (returnOptional(10)) \|value\| {
145	break value;	145	break value;
146	} else	146	} else
147	i32(2);	147	i32(2);
...	@@ -210,7 +210,7 @@ fn testContinueOuter() void {	...	@@ -210,7 +210,7 @@ fn testContinueOuter() void {
210	fn returnNull() ?i32 {	210	fn returnNull() ?i32 {
211	return null;	211	return null;
212	}	212	}
213	fn returnMaybe(x: i32) ?i32 {	213	fn returnOptional(x: i32) ?i32 {
214	return x;	214	return x;
215	}	215	}
216	fn returnError() error!i32 {	216	fn returnError() error!i32 {

test/compare_output.zig+2-2

...	@@ -284,7 +284,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -284,7 +284,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
284	cases.addC("expose function pointer to C land",	284	cases.addC("expose function pointer to C land",
285	\\const c = @cImport(@cInclude("stdlib.h"));	285	\\const c = @cImport(@cInclude("stdlib.h"));
286	\\	286	\\
287	\\export fn compare_fn(a: ?[]const c_void, b: ?[]const c_void) c_int {	287	\\export fn compare_fn(a: ?const c_void, b: ?const c_void) c_int {
288	\\ const a_int = @ptrCast(*const i32, @alignCast(@alignOf(i32), a));	288	\\ const a_int = @ptrCast(*const i32, @alignCast(@alignOf(i32), a));
289	\\ const b_int = @ptrCast(*const i32, @alignCast(@alignOf(i32), b));	289	\\ const b_int = @ptrCast(*const i32, @alignCast(@alignOf(i32), b));
290	\\ if (a_int.* < b_int.*) {	290	\\ if (a_int.* < b_int.*) {
...	@@ -299,7 +299,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -299,7 +299,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
299	\\export fn main() c_int {	299	\\export fn main() c_int {
300	\\ var array = []u32{ 1, 7, 3, 2, 0, 9, 4, 8, 6, 5 };	300	\\ var array = []u32{ 1, 7, 3, 2, 0, 9, 4, 8, 6, 5 };
301	\\	301	\\
302	\\ c.qsort(@ptrCast(?[*]c_void, array[0..].ptr), c_ulong(array.len), @sizeOf(i32), compare_fn);	302	\\ c.qsort(@ptrCast(?*c_void, array[0..].ptr), c_ulong(array.len), @sizeOf(i32), compare_fn);
303	\\	303	\\
304	\\ for (array) \|item, i\| {	304	\\ for (array) \|item, i\| {
305	\\ if (item != i) {	305	\\ if (item != i) {

test/compile_errors.zig+61-10

 @@ -1,6 +1,57 @@
 const tests = @import("tests.zig");
 pub fn addCases(cases: *tests.CompileErrorContext) void {
+    cases.add(
+        "use implicit casts to assign null to non-nullable pointer",
+        \\export fn entry() void {
+        \\    var x: i32 = 1234;
+        \\    var p: *i32 = &x;
+        \\    var pp: *?*i32 = &p;
+        \\    pp.* = null;
+        \\    var y = p.*;
+        \\}
+    ,
+        ".tmp_source.zig:4:23: error: expected type '*?*i32', found '**i32'",
+    );
+    cases.add(
+        "attempted implicit cast from T to [*]const T",
+        \\export fn entry() void {
+        \\    const x: [*]const bool = true;
+        \\}
+    ,
+        ".tmp_source.zig:2:30: error: expected type '[*]const bool', found 'bool'",
+    );
+    cases.add(
+        "dereference unknown length pointer",
+        \\export fn entry(x: [*]i32) i32 {
+        \\    return x.*;
+        \\}
+    ,
+        ".tmp_source.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'",
+    );
+    cases.add(
+        "field access of unknown length pointer",
+        \\const Foo = extern struct {
+        \\    a: i32,
+        \\};
+        \\
+        \\export fn entry(foo: [*]Foo) void {
+        \\    foo.a += 1;
+        \\}
+    ,
+        ".tmp_source.zig:6:8: error: type '[*]Foo' does not support field access",
+    );
+    cases.add(
+        "unknown length pointer to opaque",
+        \\export const T = [*]@OpaqueType();
+    ,
+        ".tmp_source.zig:1:18: error: unknown-length pointer to opaque",
+    );
     cases.add(
         "error when evaluating return type",
         \\const Foo = struct {
 @@ -1303,7 +1354,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    if (true) |x| { }
         \\}
     ,
-        ".tmp_source.zig:2:9: error: expected nullable type, found 'bool'",
+        ".tmp_source.zig:2:9: error: expected optional type, found 'bool'",
     );
     cases.add(
 @@ -1742,7 +1793,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     );
     cases.add(
-        "assign null to non-nullable pointer",
+        "assign null to non-optional pointer",
         \\const a: *u8 = null;
         \\
         \\export fn entry() usize { return @sizeOf(@typeOf(a)); }
 @@ -2258,7 +2309,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\    defer try canFail();
         \\
-        \\    const a = maybeInt() ?? return;
+        \\    const a = maybeInt() orelse return;
         \\}
         \\
         \\fn canFail() error!void { }
 @@ -2779,7 +2830,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     );
     cases.add(
-        "while expected bool, got nullable",
+        "while expected bool, got optional",
         \\export fn foo() void {
         \\    while (bar()) {}
         \\}
 @@ -2799,23 +2850,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     );
     cases.add(
-        "while expected nullable, got bool",
+        "while expected optional, got bool",
         \\export fn foo() void {
         \\    while (bar()) |x| {}
         \\}
         \\fn bar() bool { return true; }
     ,
-        ".tmp_source.zig:2:15: error: expected nullable type, found 'bool'",
+        ".tmp_source.zig:2:15: error: expected optional type, found 'bool'",
     );
     cases.add(
-        "while expected nullable, got error union",
+        "while expected optional, got error union",
         \\export fn foo() void {
         \\    while (bar()) |x| {}
         \\}
         \\fn bar() error!i32 { return 1; }
     ,
-        ".tmp_source.zig:2:15: error: expected nullable type, found 'error!i32'",
+        ".tmp_source.zig:2:15: error: expected optional type, found 'error!i32'",
     );
     cases.add(
 @@ -2829,7 +2880,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     );
     cases.add(
-        "while expected error union, got nullable",
+        "while expected error union, got optional",
         \\export fn foo() void {
         \\    while (bar()) |x| {} else |err| {}
         \\}
 @@ -3291,7 +3342,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ".tmp_source.zig:9:4: error: variable of type 'comptime_float' must be const or comptime",
         ".tmp_source.zig:10:4: error: variable of type '(block)' must be const or comptime",
         ".tmp_source.zig:11:4: error: variable of type '(null)' must be const or comptime",
-        ".tmp_source.zig:12:4: error: variable of type 'Opaque' must be const or comptime",
+        ".tmp_source.zig:12:4: error: variable of type 'Opaque' not allowed",
         ".tmp_source.zig:13:4: error: variable of type 'type' must be const or comptime",
         ".tmp_source.zig:14:4: error: variable of type '(namespace)' must be const or comptime",
         ".tmp_source.zig:15:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime",

test/tests.zig+6-6

test/translate_c.zig+20-20

...	@@ -99,7 +99,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -99,7 +99,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
99	cases.add("restrict -> noalias",	99	cases.add("restrict -> noalias",
100	\\void foo(void restrict bar, void restrict);	100	\\void foo(void restrict bar, void restrict);
101	,	101	,
102	\\pub extern fn foo(noalias bar: ?[]c_void, noalias arg1: ?[]c_void) void;	102	\\pub extern fn foo(noalias bar: ?c_void, noalias arg1: ?c_void) void;
103	);	103	);
104		104
105	cases.add("simple struct",	105	cases.add("simple struct",
...	@@ -172,7 +172,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -172,7 +172,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
172	,	172	,
173	\\pub const struct_Foo = @OpaqueType();	173	\\pub const struct_Foo = @OpaqueType();
174	,	174	,
175	\\pub extern fn some_func(foo: ?[]struct_Foo, x: c_int) ?[]struct_Foo;	175	\\pub extern fn some_func(foo: ?struct_Foo, x: c_int) ?struct_Foo;
176	,	176	,
177	\\pub const Foo = struct_Foo;	177	\\pub const Foo = struct_Foo;
178	);	178	);
...	@@ -233,7 +233,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -233,7 +233,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
233	,	233	,
234	\\pub const Foo = c_void;	234	\\pub const Foo = c_void;
235	,	235	,
236	\\pub extern fn fun(a: ?[*]Foo) Foo;	236	\\pub extern fn fun(a: ?*Foo) Foo;
237	);	237	);
238		238
239	cases.add("generate inline func for #define global extern fn",	239	cases.add("generate inline func for #define global extern fn",
...	@@ -246,13 +246,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -246,13 +246,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
246	\\pub extern var fn_ptr: ?extern fn() void;	246	\\pub extern var fn_ptr: ?extern fn() void;
247	,	247	,
248	\\pub inline fn foo() void {	248	\\pub inline fn foo() void {
249	\\ return (??fn_ptr)();	249	\\ return fn_ptr.?();
250	\\}	250	\\}
251	,	251	,
252	\\pub extern var fn_ptr2: ?extern fn(c_int, f32) u8;	252	\\pub extern var fn_ptr2: ?extern fn(c_int, f32) u8;
253	,	253	,
254	\\pub inline fn bar(arg0: c_int, arg1: f32) u8 {	254	\\pub inline fn bar(arg0: c_int, arg1: f32) u8 {
255	\\ return (??fn_ptr2)(arg0, arg1);	255	\\ return fn_ptr2.?(arg0, arg1);
256	\\}	256	\\}
257	);	257	);
258		258
...	@@ -505,7 +505,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -505,7 +505,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
505	\\ return 6;	505	\\ return 6;
506	\\}	506	\\}
507	,	507	,
508	\\pub export fn and_or_none_bool(a: c_int, b: f32, c: ?[*]c_void) c_int {	508	\\pub export fn and_or_none_bool(a: c_int, b: f32, c: ?*c_void) c_int {
509	\\ if ((a != 0) and (b != 0)) return 0;	509	\\ if ((a != 0) and (b != 0)) return 0;
510	\\ if ((b != 0) and (c != null)) return 1;	510	\\ if ((b != 0) and (c != null)) return 1;
511	\\ if ((a != 0) and (c != null)) return 2;	511	\\ if ((a != 0) and (c != null)) return 2;
...	@@ -608,7 +608,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -608,7 +608,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
608	\\ field: c_int,	608	\\ field: c_int,
609	\\};	609	\\};
610	\\pub export fn read_field(foo: ?[*]struct_Foo) c_int {	610	\\pub export fn read_field(foo: ?[*]struct_Foo) c_int {
611	\\ return (??foo).field;	611	\\ return foo.?.field;
612	\\}	612	\\}
613	);	613	);
614		614
...	@@ -653,8 +653,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -653,8 +653,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
653	\\ return x;	653	\\ return x;
654	\\}	654	\\}
655	,	655	,
656	\\pub export fn foo(x: ?[]c_ushort) ?[]c_void {	656	\\pub export fn foo(x: ?[]c_ushort) ?c_void {
657	\\ return @ptrCast(?[*]c_void, x);	657	\\ return @ptrCast(?*c_void, x);
658	\\}	658	\\}
659	);	659	);
660		660
...	@@ -969,11 +969,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -969,11 +969,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
969	\\pub export fn bar() void {	969	\\pub export fn bar() void {
970	\\ var f: ?extern fn() void = foo;	970	\\ var f: ?extern fn() void = foo;
971	\\ var b: ?extern fn() c_int = baz;	971	\\ var b: ?extern fn() c_int = baz;
972	\\ (??f)();	972	\\ f.?();
973	\\ (??f)();	973	\\ f.?();
974	\\ foo();	974	\\ foo();
975	\\ _ = (??b)();	975	\\ _ = b.?();
976	\\ _ = (??b)();	976	\\ _ = b.?();
977	\\ _ = baz();	977	\\ _ = baz();
978	\\}	978	\\}
979	);	979	);
...	@@ -984,7 +984,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -984,7 +984,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
984	\\}	984	\\}
985	,	985	,
986	\\pub export fn foo(x: ?[*]c_int) void {	986	\\pub export fn foo(x: ?[*]c_int) void {
987	\\ (??x).* = 1;	987	\\ x.?.* = 1;
988	\\}	988	\\}
989	);	989	);
990		990
...	@@ -1012,7 +1012,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1012,7 +1012,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1012	\\pub fn foo() c_int {	1012	\\pub fn foo() c_int {
1013	\\ var x: c_int = 1234;	1013	\\ var x: c_int = 1234;
1014	\\ var ptr: ?[*]c_int = &x;	1014	\\ var ptr: ?[*]c_int = &x;
1015	\\ return (??ptr).*;	1015	\\ return ptr.?.*;
1016	\\}	1016	\\}
1017	);	1017	);
1018		1018
...	@@ -1119,7 +1119,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1119,7 +1119,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1119	\\pub const glClearPFN = PFNGLCLEARPROC;	1119	\\pub const glClearPFN = PFNGLCLEARPROC;
1120	,	1120	,
1121	\\pub inline fn glClearUnion(arg0: GLbitfield) void {	1121	\\pub inline fn glClearUnion(arg0: GLbitfield) void {
1122	\\ return (??glProcs.gl.Clear)(arg0);	1122	\\ return glProcs.gl.Clear.?(arg0);
1123	\\}	1123	\\}
1124	,	1124	,
1125	\\pub const OpenGLProcs = union_OpenGLProcs;	1125	\\pub const OpenGLProcs = union_OpenGLProcs;
...	@@ -1173,7 +1173,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1173,7 +1173,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1173	\\ return !c;	1173	\\ return !c;
1174	\\}	1174	\\}
1175	,	1175	,
1176	\\pub fn foo(a: c_int, b: f32, c: ?[*]c_void) c_int {	1176	\\pub fn foo(a: c_int, b: f32, c: ?*c_void) c_int {
1177	\\ return !(a == 0);	1177	\\ return !(a == 0);
1178	\\ return !(a != 0);	1178	\\ return !(a != 0);
1179	\\ return !(b != 0);	1179	\\ return !(b != 0);
...	@@ -1231,7 +1231,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1231,7 +1231,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1231	\\ B,	1231	\\ B,
1232	\\ C,	1232	\\ C,
1233	\\};	1233	\\};
1234	\\pub fn if_none_bool(a: c_int, b: f32, c: ?[*]c_void, d: enum_SomeEnum) c_int {	1234	\\pub fn if_none_bool(a: c_int, b: f32, c: ?*c_void, d: enum_SomeEnum) c_int {
1235	\\ if (a != 0) return 0;	1235	\\ if (a != 0) return 0;
1236	\\ if (b != 0) return 1;	1236	\\ if (b != 0) return 1;
1237	\\ if (c != null) return 2;	1237	\\ if (c != null) return 2;
...	@@ -1248,7 +1248,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1248,7 +1248,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1248	\\ return 3;	1248	\\ return 3;
1249	\\}	1249	\\}
1250	,	1250	,
1251	\\pub fn while_none_bool(a: c_int, b: f32, c: ?[*]c_void) c_int {	1251	\\pub fn while_none_bool(a: c_int, b: f32, c: ?*c_void) c_int {
1252	\\ while (a != 0) return 0;	1252	\\ while (a != 0) return 0;
1253	\\ while (b != 0) return 1;	1253	\\ while (b != 0) return 1;
1254	\\ while (c != null) return 2;	1254	\\ while (c != null) return 2;
...	@@ -1264,7 +1264,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1264,7 +1264,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1264	\\ return 3;	1264	\\ return 3;
1265	\\}	1265	\\}
1266	,	1266	,
1267	\\pub fn for_none_bool(a: c_int, b: f32, c: ?[*]c_void) c_int {	1267	\\pub fn for_none_bool(a: c_int, b: f32, c: ?*c_void) c_int {
1268	\\ while (a != 0) return 0;	1268	\\ while (a != 0) return 0;
1269	\\ while (b != 0) return 1;	1269	\\ while (b != 0) return 1;
1270	\\ while (c != null) return 2;	1270	\\ while (c != null) return 2;

author	Andrew Kelley <andrew@ziglang.org> 2018-06-14 18:27:59-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-06-14 18:27:59-04:00
log	32dd98b19fe3cc384df32704dac0ff3e377dbe0c
tree	2eddf3618d80313bdd24c25bd589bd474f3d82fc
parent	ef7f69d14a017c6c2065e4a376bb8e1f05ace04b
parent	f0697c28f80d64c544302aea576e41ebc443b41c

...	@@ -464,6 +464,7 @@ set(ZIG_STD_FILES	...	@@ -464,6 +464,7 @@ set(ZIG_STD_FILES
464	"math/atan.zig"	464	"math/atan.zig"
465	"math/atan2.zig"	465	"math/atan2.zig"
466	"math/atanh.zig"	466	"math/atanh.zig"
		467	"math/big/int.zig"
467	"math/cbrt.zig"	468	"math/cbrt.zig"
468	"math/ceil.zig"	469	"math/ceil.zig"
469	"math/complex/abs.zig"	470	"math/complex/abs.zig"
...	@@ -555,6 +556,7 @@ set(ZIG_STD_FILES	...	@@ -555,6 +556,7 @@ set(ZIG_STD_FILES
555	"special/compiler_rt/aulldiv.zig"	556	"special/compiler_rt/aulldiv.zig"
556	"special/compiler_rt/aullrem.zig"	557	"special/compiler_rt/aullrem.zig"
557	"special/compiler_rt/comparetf2.zig"	558	"special/compiler_rt/comparetf2.zig"
		559	"special/compiler_rt/divti3.zig"
558	"special/compiler_rt/fixuint.zig"	560	"special/compiler_rt/fixuint.zig"
559	"special/compiler_rt/fixunsdfdi.zig"	561	"special/compiler_rt/fixunsdfdi.zig"
560	"special/compiler_rt/fixunsdfsi.zig"	562	"special/compiler_rt/fixunsdfsi.zig"
...	@@ -565,6 +567,7 @@ set(ZIG_STD_FILES	...	@@ -565,6 +567,7 @@ set(ZIG_STD_FILES
565	"special/compiler_rt/fixunstfdi.zig"	567	"special/compiler_rt/fixunstfdi.zig"
566	"special/compiler_rt/fixunstfsi.zig"	568	"special/compiler_rt/fixunstfsi.zig"
567	"special/compiler_rt/fixunstfti.zig"	569	"special/compiler_rt/fixunstfti.zig"
		570	"special/compiler_rt/muloti4.zig"
568	"special/compiler_rt/index.zig"	571	"special/compiler_rt/index.zig"
569	"special/compiler_rt/udivmod.zig"	572	"special/compiler_rt/udivmod.zig"
570	"special/compiler_rt/udivmoddi4.zig"	573	"special/compiler_rt/udivmoddi4.zig"

...	@@ -63,6 +63,7 @@ pub fn build(b: *Builder) !void {	...	@@ -63,6 +63,7 @@ pub fn build(b: *Builder) !void {
63	exe.addObjectFile(lib);	63	exe.addObjectFile(lib);
64	}	64	}
65	} else {	65	} else {
		66	addCppLib(b, exe, cmake_binary_dir, "embedded_lld_wasm");
66	addCppLib(b, exe, cmake_binary_dir, "embedded_lld_elf");	67	addCppLib(b, exe, cmake_binary_dir, "embedded_lld_elf");
67	addCppLib(b, exe, cmake_binary_dir, "embedded_lld_coff");	68	addCppLib(b, exe, cmake_binary_dir, "embedded_lld_coff");
68	addCppLib(b, exe, cmake_binary_dir, "embedded_lld_lib");	69	addCppLib(b, exe, cmake_binary_dir, "embedded_lld_lib");
...	@@ -74,7 +75,7 @@ pub fn build(b: *Builder) !void {	...	@@ -74,7 +75,7 @@ pub fn build(b: *Builder) !void {
74	cxx_compiler,	75	cxx_compiler,
75	"-print-file-name=libstdc++.a",	76	"-print-file-name=libstdc++.a",
76	});	77	});
77	const libstdcxx_path = ??mem.split(libstdcxx_path_padded, "\r\n").next();	78	const libstdcxx_path = mem.split(libstdcxx_path_padded, "\r\n").next().?;
78	if (mem.eql(u8, libstdcxx_path, "libstdc++.a")) {	79	if (mem.eql(u8, libstdcxx_path, "libstdc++.a")) {
79	warn(	80	warn(
80	\\Unable to determine path to libstdc++.a	81	\\Unable to determine path to libstdc++.a
...	@@ -101,11 +102,11 @@ pub fn build(b: *Builder) !void {	...	@@ -101,11 +102,11 @@ pub fn build(b: *Builder) !void {
101		102
102	b.default_step.dependOn(&exe.step);	103	b.default_step.dependOn(&exe.step);
103		104
104	const skip_self_hosted = b.option(bool, "skip-self-hosted", "Main test suite skips building self hosted compiler") ?? false;	105	const skip_self_hosted = b.option(bool, "skip-self-hosted", "Main test suite skips building self hosted compiler") orelse false;
105	if (!skip_self_hosted) {	106	if (!skip_self_hosted) {
106	test_step.dependOn(&exe.step);	107	test_step.dependOn(&exe.step);
107	}	108	}
108	const verbose_link_exe = b.option(bool, "verbose-link", "Print link command for self hosted compiler") ?? false;	109	const verbose_link_exe = b.option(bool, "verbose-link", "Print link command for self hosted compiler") orelse false;
109	exe.setVerboseLink(verbose_link_exe);	110	exe.setVerboseLink(verbose_link_exe);
110		111
111	b.installArtifact(exe);	112	b.installArtifact(exe);
...	@@ -113,7 +114,7 @@ pub fn build(b: *Builder) !void {	...	@@ -113,7 +114,7 @@ pub fn build(b: *Builder) !void {
113	installCHeaders(b, c_header_files);	114	installCHeaders(b, c_header_files);
114		115
115	const test_filter = b.option([]const u8, "test-filter", "Skip tests that do not match filter");	116	const test_filter = b.option([]const u8, "test-filter", "Skip tests that do not match filter");
116	const with_lldb = b.option(bool, "with-lldb", "Run tests in LLDB to get a backtrace if one fails") ?? false;	117	const with_lldb = b.option(bool, "with-lldb", "Run tests in LLDB to get a backtrace if one fails") orelse false;
117		118
118	test_step.dependOn(docs_step);	119	test_step.dependOn(docs_step);
119		120

...	@@ -99,7 +99,7 @@ pub const Args = struct {	...	@@ -99,7 +99,7 @@ pub const Args = struct {
99	error.ArgumentNotInAllowedSet => {	99	error.ArgumentNotInAllowedSet => {
100	std.debug.warn("argument '{}' is invalid for flag '{}'\n", args[i], arg);	100	std.debug.warn("argument '{}' is invalid for flag '{}'\n", args[i], arg);
101	std.debug.warn("allowed options are ");	101	std.debug.warn("allowed options are ");
102	for (??flag.allowed_set) \|possible\| {	102	for (flag.allowed_set.?) \|possible\| {
103	std.debug.warn("'{}' ", possible);	103	std.debug.warn("'{}' ", possible);
104	}	104	}
105	std.debug.warn("\n");	105	std.debug.warn("\n");
...	@@ -276,14 +276,14 @@ test "parse arguments" {	...	@@ -276,14 +276,14 @@ test "parse arguments" {
276	debug.assert(!args.present("help2"));	276	debug.assert(!args.present("help2"));
277	debug.assert(!args.present("init"));	277	debug.assert(!args.present("init"));
278		278
279	debug.assert(mem.eql(u8, ??args.single("build-file"), "build.zig"));	279	debug.assert(mem.eql(u8, args.single("build-file").?, "build.zig"));
280	debug.assert(mem.eql(u8, ??args.single("color"), "on"));	280	debug.assert(mem.eql(u8, args.single("color").?, "on"));
281		281
282	const objects = ??args.many("object");	282	const objects = args.many("object").?;
283	debug.assert(mem.eql(u8, objects[0], "obj1"));	283	debug.assert(mem.eql(u8, objects[0], "obj1"));
284	debug.assert(mem.eql(u8, objects[1], "obj2"));	284	debug.assert(mem.eql(u8, objects[1], "obj2"));
285		285
286	debug.assert(mem.eql(u8, ??args.single("library"), "lib2"));	286	debug.assert(mem.eql(u8, args.single("library").?, "lib2"));
287		287
288	const pos = args.positionals.toSliceConst();	288	const pos = args.positionals.toSliceConst();
289	debug.assert(mem.eql(u8, pos[0], "build"));	289	debug.assert(mem.eql(u8, pos[0], "build"));

...	@@ -212,7 +212,7 @@ fn cmdBuild(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -212,7 +212,7 @@ fn cmdBuild(allocator: *Allocator, args: []const []const u8) !void {
212	const build_runner_path = try os.path.join(allocator, special_dir, "build_runner.zig");	212	const build_runner_path = try os.path.join(allocator, special_dir, "build_runner.zig");
213	defer allocator.free(build_runner_path);	213	defer allocator.free(build_runner_path);
214		214
215	const build_file = flags.single("build-file") ?? "build.zig";	215	const build_file = flags.single("build-file") orelse "build.zig";
216	const build_file_abs = try os.path.resolve(allocator, ".", build_file);	216	const build_file_abs = try os.path.resolve(allocator, ".", build_file);
217	defer allocator.free(build_file_abs);	217	defer allocator.free(build_file_abs);
218		218
...	@@ -249,7 +249,7 @@ fn cmdBuild(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -249,7 +249,7 @@ fn cmdBuild(allocator: *Allocator, args: []const []const u8) !void {
249	defer build_args.deinit();	249	defer build_args.deinit();
250		250
251	const build_file_basename = os.path.basename(build_file_abs);	251	const build_file_basename = os.path.basename(build_file_abs);
252	const build_file_dirname = os.path.dirname(build_file_abs);	252	const build_file_dirname = os.path.dirname(build_file_abs) orelse ".";
253		253
254	var full_cache_dir: []u8 = undefined;	254	var full_cache_dir: []u8 = undefined;
255	if (flags.single("cache-dir")) \|cache_dir\| {	255	if (flags.single("cache-dir")) \|cache_dir\| {
...	@@ -490,7 +490,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo	...	@@ -490,7 +490,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo
490	try stderr.print("encountered --pkg-end with no matching --pkg-begin\n");	490	try stderr.print("encountered --pkg-end with no matching --pkg-begin\n");
491	os.exit(1);	491	os.exit(1);
492	}	492	}
493	cur_pkg = ??cur_pkg.parent;	493	cur_pkg = cur_pkg.parent.?;
494	}	494	}
495	}	495	}
496		496
...	@@ -514,28 +514,28 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo	...	@@ -514,28 +514,28 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo
514	},	514	},
515	}	515	}
516		516
517	const basename = os.path.basename(??in_file);	517	const basename = os.path.basename(in_file.?);
518	var it = mem.split(basename, ".");	518	var it = mem.split(basename, ".");
519	const root_name = it.next() ?? {	519	const root_name = it.next() orelse {
520	try stderr.write("file name cannot be empty\n");	520	try stderr.write("file name cannot be empty\n");
521	os.exit(1);	521	os.exit(1);
522	};	522	};
523		523
524	const asm_a = flags.many("assembly");	524	const asm_a = flags.many("assembly");
525	const obj_a = flags.many("object");	525	const obj_a = flags.many("object");
526	if (in_file == null and (obj_a == null or (??obj_a).len == 0) and (asm_a == null or (??asm_a).len == 0)) {	526	if (in_file == null and (obj_a == null or obj_a.?.len == 0) and (asm_a == null or asm_a.?.len == 0)) {
527	try stderr.write("Expected source file argument or at least one --object or --assembly argument\n");	527	try stderr.write("Expected source file argument or at least one --object or --assembly argument\n");
528	os.exit(1);	528	os.exit(1);
529	}	529	}
530		530
531	if (out_type == Module.Kind.Obj and (obj_a != null and (??obj_a).len != 0)) {	531	if (out_type == Module.Kind.Obj and (obj_a != null and obj_a.?.len != 0)) {
532	try stderr.write("When building an object file, --object arguments are invalid\n");	532	try stderr.write("When building an object file, --object arguments are invalid\n");
533	os.exit(1);	533	os.exit(1);
534	}	534	}
535		535
536	const zig_root_source_file = in_file;	536	const zig_root_source_file = in_file;
537		537
538	const full_cache_dir = os.path.resolve(allocator, ".", flags.single("cache-dir") ?? "zig-cache"[0..]) catch {	538	const full_cache_dir = os.path.resolve(allocator, ".", flags.single("cache-dir") orelse "zig-cache"[0..]) catch {
539	os.exit(1);	539	os.exit(1);
540	};	540	};
541	defer allocator.free(full_cache_dir);	541	defer allocator.free(full_cache_dir);
...	@@ -555,9 +555,9 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo	...	@@ -555,9 +555,9 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo
555	);	555	);
556	defer module.destroy();	556	defer module.destroy();
557		557
558	module.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") ?? "0", 10);	558	module.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") orelse "0", 10);
559	module.version_minor = try std.fmt.parseUnsigned(u32, flags.single("ver-minor") ?? "0", 10);	559	module.version_minor = try std.fmt.parseUnsigned(u32, flags.single("ver-minor") orelse "0", 10);
560	module.version_patch = try std.fmt.parseUnsigned(u32, flags.single("ver-patch") ?? "0", 10);	560	module.version_patch = try std.fmt.parseUnsigned(u32, flags.single("ver-patch") orelse "0", 10);
561		561
562	module.is_test = false;	562	module.is_test = false;
563		563
...	@@ -652,7 +652,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo	...	@@ -652,7 +652,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo
652	}	652	}
653		653
654	try module.build();	654	try module.build();
655	try module.link(flags.single("out-file") ?? null);	655	try module.link(flags.single("out-file") orelse null);
656		656
657	if (flags.present("print-timing-info")) {	657	if (flags.present("print-timing-info")) {
658	// codegen_print_timing_info(g, stderr);	658	// codegen_print_timing_info(g, stderr);
...	@@ -734,7 +734,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -734,7 +734,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
734	defer file.close();	734	defer file.close();
735		735
736	const source_code = io.readFileAlloc(allocator, file_path) catch \|err\| {	736	const source_code = io.readFileAlloc(allocator, file_path) catch \|err\| {
737	try stderr.print("unable to open '{}': {}", file_path, err);	737	try stderr.print("unable to open '{}': {}\n", file_path, err);
738	fmt_errors = true;	738	fmt_errors = true;
739	continue;	739	continue;
740	};	740	};

...	@@ -130,13 +130,13 @@ pub const Module = struct {	...	@@ -130,13 +130,13 @@ pub const Module = struct {
130	var name_buffer = try Buffer.init(allocator, name);	130	var name_buffer = try Buffer.init(allocator, name);
131	errdefer name_buffer.deinit();	131	errdefer name_buffer.deinit();
132		132
133	const context = c.LLVMContextCreate() ?? return error.OutOfMemory;	133	const context = c.LLVMContextCreate() orelse return error.OutOfMemory;
134	errdefer c.LLVMContextDispose(context);	134	errdefer c.LLVMContextDispose(context);
135		135
136	const module = c.LLVMModuleCreateWithNameInContext(name_buffer.ptr(), context) ?? return error.OutOfMemory;	136	const module = c.LLVMModuleCreateWithNameInContext(name_buffer.ptr(), context) orelse return error.OutOfMemory;
137	errdefer c.LLVMDisposeModule(module);	137	errdefer c.LLVMDisposeModule(module);
138		138
139	const builder = c.LLVMCreateBuilderInContext(context) ?? return error.OutOfMemory;	139	const builder = c.LLVMCreateBuilderInContext(context) orelse return error.OutOfMemory;
140	errdefer c.LLVMDisposeBuilder(builder);	140	errdefer c.LLVMDisposeBuilder(builder);
141		141
142	const module_ptr = try allocator.create(Module);	142	const module_ptr = try allocator.create(Module);
...	@@ -223,7 +223,7 @@ pub const Module = struct {	...	@@ -223,7 +223,7 @@ pub const Module = struct {
223	c.ZigLLVMParseCommandLineOptions(self.llvm_argv.len + 1, c_compatible_args.ptr);	223	c.ZigLLVMParseCommandLineOptions(self.llvm_argv.len + 1, c_compatible_args.ptr);
224	}	224	}
225		225
226	const root_src_path = self.root_src_path ?? @panic("TODO handle null root src path");	226	const root_src_path = self.root_src_path orelse @panic("TODO handle null root src path");
227	const root_src_real_path = os.path.real(self.allocator, root_src_path) catch \|err\| {	227	const root_src_real_path = os.path.real(self.allocator, root_src_path) catch \|err\| {
228	try printError("unable to get real path '{}': {}", root_src_path, err);	228	try printError("unable to get real path '{}': {}", root_src_path, err);
229	return err;	229	return err;

...	@@ -28,7 +28,6 @@ pub const Buffer = struct {	...	@@ -28,7 +28,6 @@ pub const Buffer = struct {
28	/// Must deinitialize with deinit.	28	/// Must deinitialize with deinit.
29	/// None of the other operations are valid until you do one of these:	29	/// None of the other operations are valid until you do one of these:
30	/// * ::replaceContents	30	/// * ::replaceContents
31	/// * ::replaceContentsBuffer
32	/// * ::resize	31	/// * ::resize
33	pub fn initNull(allocator: *Allocator) Buffer {	32	pub fn initNull(allocator: *Allocator) Buffer {
34	return Buffer{ .list = ArrayList(u8).init(allocator) };	33	return Buffer{ .list = ArrayList(u8).init(allocator) };
...	@@ -42,9 +41,9 @@ pub const Buffer = struct {	...	@@ -42,9 +41,9 @@ pub const Buffer = struct {
42	/// Buffer takes ownership of the passed in slice. The slice must have been	41	/// Buffer takes ownership of the passed in slice. The slice must have been
43	/// allocated with `allocator`.	42	/// allocated with `allocator`.
44	/// Must deinitialize with deinit.	43	/// Must deinitialize with deinit.
45	pub fn fromOwnedSlice(allocator: *Allocator, slice: []u8) Buffer {	44	pub fn fromOwnedSlice(allocator: *Allocator, slice: []u8) !Buffer {
46	var self = Buffer{ .list = ArrayList(u8).fromOwnedSlice(allocator, slice) };	45	var self = Buffer{ .list = ArrayList(u8).fromOwnedSlice(allocator, slice) };
47	self.list.append(0);	46	try self.list.append(0);
48	return self;	47	return self;
49	}	48	}
50		49
...	@@ -116,7 +115,7 @@ pub const Buffer = struct {	...	@@ -116,7 +115,7 @@ pub const Buffer = struct {
116	return mem.eql(u8, self.list.items[start..l], m);	115	return mem.eql(u8, self.list.items[start..l], m);
117	}	116	}
118		117
119	pub fn replaceContents(self: *const Buffer, m: []const u8) !void {	118	pub fn replaceContents(self: *Buffer, m: []const u8) !void {
120	try self.resize(m.len);	119	try self.resize(m.len);
121	mem.copy(u8, self.list.toSlice(), m);	120	mem.copy(u8, self.list.toSlice(), m);
122	}	121	}

...	@@ -136,7 +136,7 @@ pub const Builder = struct {	...	@@ -136,7 +136,7 @@ pub const Builder = struct {
136	}	136	}
137		137
138	pub fn setInstallPrefix(self: *Builder, maybe_prefix: ?[]const u8) void {	138	pub fn setInstallPrefix(self: *Builder, maybe_prefix: ?[]const u8) void {
139	self.prefix = maybe_prefix ?? "/usr/local"; // TODO better default	139	self.prefix = maybe_prefix orelse "/usr/local"; // TODO better default
140	self.lib_dir = os.path.join(self.allocator, self.prefix, "lib") catch unreachable;	140	self.lib_dir = os.path.join(self.allocator, self.prefix, "lib") catch unreachable;
141	self.exe_dir = os.path.join(self.allocator, self.prefix, "bin") catch unreachable;	141	self.exe_dir = os.path.join(self.allocator, self.prefix, "bin") catch unreachable;
142	}	142	}
...	@@ -312,9 +312,9 @@ pub const Builder = struct {	...	@@ -312,9 +312,9 @@ pub const Builder = struct {
312	if (os.getEnvVarOwned(self.allocator, "NIX_CFLAGS_COMPILE")) \|nix_cflags_compile\| {	312	if (os.getEnvVarOwned(self.allocator, "NIX_CFLAGS_COMPILE")) \|nix_cflags_compile\| {
313	var it = mem.split(nix_cflags_compile, " ");	313	var it = mem.split(nix_cflags_compile, " ");
314	while (true) {	314	while (true) {
315	const word = it.next() ?? break;	315	const word = it.next() orelse break;
316	if (mem.eql(u8, word, "-isystem")) {	316	if (mem.eql(u8, word, "-isystem")) {
317	const include_path = it.next() ?? {	317	const include_path = it.next() orelse {
318	warn("Expected argument after -isystem in NIX_CFLAGS_COMPILE\n");	318	warn("Expected argument after -isystem in NIX_CFLAGS_COMPILE\n");
319	break;	319	break;
320	};	320	};
...	@@ -330,9 +330,9 @@ pub const Builder = struct {	...	@@ -330,9 +330,9 @@ pub const Builder = struct {
330	if (os.getEnvVarOwned(self.allocator, "NIX_LDFLAGS")) \|nix_ldflags\| {	330	if (os.getEnvVarOwned(self.allocator, "NIX_LDFLAGS")) \|nix_ldflags\| {
331	var it = mem.split(nix_ldflags, " ");	331	var it = mem.split(nix_ldflags, " ");
332	while (true) {	332	while (true) {
333	const word = it.next() ?? break;	333	const word = it.next() orelse break;
334	if (mem.eql(u8, word, "-rpath")) {	334	if (mem.eql(u8, word, "-rpath")) {
335	const rpath = it.next() ?? {	335	const rpath = it.next() orelse {
336	warn("Expected argument after -rpath in NIX_LDFLAGS\n");	336	warn("Expected argument after -rpath in NIX_LDFLAGS\n");
337	break;	337	break;
338	};	338	};
...	@@ -362,7 +362,7 @@ pub const Builder = struct {	...	@@ -362,7 +362,7 @@ pub const Builder = struct {
362	}	362	}
363	self.available_options_list.append(available_option) catch unreachable;	363	self.available_options_list.append(available_option) catch unreachable;
364		364
365	const entry = self.user_input_options.get(name) ?? return null;	365	const entry = self.user_input_options.get(name) orelse return null;
366	entry.value.used = true;	366	entry.value.used = true;
367	switch (type_id) {	367	switch (type_id) {
368	TypeId.Bool => switch (entry.value.value) {	368	TypeId.Bool => switch (entry.value.value) {
...	@@ -416,9 +416,9 @@ pub const Builder = struct {	...	@@ -416,9 +416,9 @@ pub const Builder = struct {
416	pub fn standardReleaseOptions(self: *Builder) builtin.Mode {	416	pub fn standardReleaseOptions(self: *Builder) builtin.Mode {
417	if (self.release_mode) \|mode\| return mode;	417	if (self.release_mode) \|mode\| return mode;
418		418
419	const release_safe = self.option(bool, "release-safe", "optimizations on and safety on") ?? false;	419	const release_safe = self.option(bool, "release-safe", "optimizations on and safety on") orelse false;
420	const release_fast = self.option(bool, "release-fast", "optimizations on and safety off") ?? false;	420	const release_fast = self.option(bool, "release-fast", "optimizations on and safety off") orelse false;
421	const release_small = self.option(bool, "release-small", "size optimizations on and safety off") ?? false;	421	const release_small = self.option(bool, "release-small", "size optimizations on and safety off") orelse false;
422		422
423	const mode = if (release_safe and !release_fast and !release_small) builtin.Mode.ReleaseSafe else if (release_fast and !release_safe and !release_small) builtin.Mode.ReleaseFast else if (release_small and !release_fast and !release_safe) builtin.Mode.ReleaseSmall else if (!release_fast and !release_safe and !release_small) builtin.Mode.Debug else x: {	423	const mode = if (release_safe and !release_fast and !release_small) builtin.Mode.ReleaseSafe else if (release_fast and !release_safe and !release_small) builtin.Mode.ReleaseFast else if (release_small and !release_fast and !release_safe) builtin.Mode.ReleaseSmall else if (!release_fast and !release_safe and !release_small) builtin.Mode.Debug else x: {
424	warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)");	424	warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)");
...	@@ -518,7 +518,7 @@ pub const Builder = struct {	...	@@ -518,7 +518,7 @@ pub const Builder = struct {
518	// make sure all args are used	518	// make sure all args are used
519	var it = self.user_input_options.iterator();	519	var it = self.user_input_options.iterator();
520	while (true) {	520	while (true) {
521	const entry = it.next() ?? break;	521	const entry = it.next() orelse break;
522	if (!entry.value.used) {	522	if (!entry.value.used) {
523	warn("Invalid option: -D{}\n\n", entry.key);	523	warn("Invalid option: -D{}\n\n", entry.key);
524	self.markInvalidUserInput();	524	self.markInvalidUserInput();
...	@@ -617,7 +617,7 @@ pub const Builder = struct {	...	@@ -617,7 +617,7 @@ pub const Builder = struct {
617	warn("cp {} {}\n", source_path, dest_path);	617	warn("cp {} {}\n", source_path, dest_path);
618	}	618	}
619		619
620	const dirname = os.path.dirname(dest_path);	620	const dirname = os.path.dirname(dest_path) orelse ".";
621	const abs_source_path = self.pathFromRoot(source_path);	621	const abs_source_path = self.pathFromRoot(source_path);
622	os.makePath(self.allocator, dirname) catch \|err\| {	622	os.makePath(self.allocator, dirname) catch \|err\| {
623	warn("Unable to create path {}: {}\n", dirname, @errorName(err));	623	warn("Unable to create path {}: {}\n", dirname, @errorName(err));
...	@@ -1246,7 +1246,7 @@ pub const LibExeObjStep = struct {	...	@@ -1246,7 +1246,7 @@ pub const LibExeObjStep = struct {
1246	{	1246	{
1247	var it = self.link_libs.iterator();	1247	var it = self.link_libs.iterator();
1248	while (true) {	1248	while (true) {
1249	const entry = it.next() ?? break;	1249	const entry = it.next() orelse break;
1250	zig_args.append("--library") catch unreachable;	1250	zig_args.append("--library") catch unreachable;
1251	zig_args.append(entry.key) catch unreachable;	1251	zig_args.append(entry.key) catch unreachable;
1252	}	1252	}
...	@@ -1395,8 +1395,9 @@ pub const LibExeObjStep = struct {	...	@@ -1395,8 +1395,9 @@ pub const LibExeObjStep = struct {
1395	cc_args.append(abs_source_file) catch unreachable;	1395	cc_args.append(abs_source_file) catch unreachable;
1396		1396
1397	const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;	1397	const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
1398	const cache_o_dir = os.path.dirname(cache_o_src);	1398	if (os.path.dirname(cache_o_src)) \|cache_o_dir\| {
1399	try builder.makePath(cache_o_dir);	1399	try builder.makePath(cache_o_dir);
		1400	}
1400	const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());	1401	const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());
1401	cc_args.append("-o") catch unreachable;	1402	cc_args.append("-o") catch unreachable;
1402	cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;	1403	cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;
...	@@ -1509,8 +1510,9 @@ pub const LibExeObjStep = struct {	...	@@ -1509,8 +1510,9 @@ pub const LibExeObjStep = struct {
1509	cc_args.append(abs_source_file) catch unreachable;	1510	cc_args.append(abs_source_file) catch unreachable;
1510		1511
1511	const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;	1512	const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
1512	const cache_o_dir = os.path.dirname(cache_o_src);	1513	if (os.path.dirname(cache_o_src)) \|cache_o_dir\| {
1513	try builder.makePath(cache_o_dir);	1514	try builder.makePath(cache_o_dir);
		1515	}
1514	const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());	1516	const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());
1515	cc_args.append("-o") catch unreachable;	1517	cc_args.append("-o") catch unreachable;
1516	cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;	1518	cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;
...	@@ -1696,7 +1698,7 @@ pub const TestStep = struct {	...	@@ -1696,7 +1698,7 @@ pub const TestStep = struct {
1696	{	1698	{
1697	var it = self.link_libs.iterator();	1699	var it = self.link_libs.iterator();
1698	while (true) {	1700	while (true) {
1699	const entry = it.next() ?? break;	1701	const entry = it.next() orelse break;
1700	try zig_args.append("--library");	1702	try zig_args.append("--library");
1701	try zig_args.append(entry.key);	1703	try zig_args.append(entry.key);
1702	}	1704	}
...	@@ -1855,7 +1857,7 @@ pub const WriteFileStep = struct {	...	@@ -1855,7 +1857,7 @@ pub const WriteFileStep = struct {
1855	fn make(step: *Step) !void {	1857	fn make(step: *Step) !void {
1856	const self = @fieldParentPtr(WriteFileStep, "step", step);	1858	const self = @fieldParentPtr(WriteFileStep, "step", step);
1857	const full_path = self.builder.pathFromRoot(self.file_path);	1859	const full_path = self.builder.pathFromRoot(self.file_path);
1858	const full_path_dir = os.path.dirname(full_path);	1860	const full_path_dir = os.path.dirname(full_path) orelse ".";
1859	os.makePath(self.builder.allocator, full_path_dir) catch \|err\| {	1861	os.makePath(self.builder.allocator, full_path_dir) catch \|err\| {
1860	warn("unable to make path {}: {}\n", full_path_dir, @errorName(err));	1862	warn("unable to make path {}: {}\n", full_path_dir, @errorName(err));
1861	return err;	1863	return err;
...	@@ -1945,7 +1947,7 @@ pub const Step = struct {	...	@@ -1945,7 +1947,7 @@ pub const Step = struct {
1945	};	1947	};
1946		1948
1947	fn doAtomicSymLinks(allocator: *Allocator, output_path: []const u8, filename_major_only: []const u8, filename_name_only: []const u8) !void {	1949	fn doAtomicSymLinks(allocator: *Allocator, output_path: []const u8, filename_major_only: []const u8, filename_name_only: []const u8) !void {
1948	const out_dir = os.path.dirname(output_path);	1950	const out_dir = os.path.dirname(output_path) orelse ".";
1949	const out_basename = os.path.basename(output_path);	1951	const out_basename = os.path.basename(output_path);
1950	// sym link for libfoo.so.1 to libfoo.so.1.2.3	1952	// sym link for libfoo.so.1 to libfoo.so.1.2.3
1951	const major_only_path = os.path.join(allocator, out_dir, filename_major_only) catch unreachable;	1953	const major_only_path = os.path.join(allocator, out_dir, filename_major_only) catch unreachable;

...	@@ -20,11 +20,11 @@ pub extern "c" fn @"fstat$INODE64"(fd: c_int, buf: *Stat) c_int;	...	@@ -20,11 +20,11 @@ pub extern "c" fn @"fstat$INODE64"(fd: c_int, buf: *Stat) c_int;
20	pub extern "c" fn lseek(fd: c_int, offset: isize, whence: c_int) isize;	20	pub extern "c" fn lseek(fd: c_int, offset: isize, whence: c_int) isize;
21	pub extern "c" fn open(path: [*]const u8, oflag: c_int, ...) c_int;	21	pub extern "c" fn open(path: [*]const u8, oflag: c_int, ...) c_int;
22	pub extern "c" fn raise(sig: c_int) c_int;	22	pub extern "c" fn raise(sig: c_int) c_int;
23	pub extern "c" fn read(fd: c_int, buf: [*]c_void, nbyte: usize) isize;	23	pub extern "c" fn read(fd: c_int, buf: *c_void, nbyte: usize) isize;
24	pub extern "c" fn stat(noalias path: []const u8, noalias buf: Stat) c_int;	24	pub extern "c" fn stat(noalias path: []const u8, noalias buf: Stat) c_int;
25	pub extern "c" fn write(fd: c_int, buf: [*]const c_void, nbyte: usize) isize;	25	pub extern "c" fn write(fd: c_int, buf: *const c_void, nbyte: usize) isize;
26	pub extern "c" fn mmap(addr: ?[]c_void, len: usize, prot: c_int, flags: c_int, fd: c_int, offset: isize) ?[]c_void;	26	pub extern "c" fn mmap(addr: ?c_void, len: usize, prot: c_int, flags: c_int, fd: c_int, offset: isize) ?c_void;
27	pub extern "c" fn munmap(addr: [*]c_void, len: usize) c_int;	27	pub extern "c" fn munmap(addr: *c_void, len: usize) c_int;
28	pub extern "c" fn unlink(path: [*]const u8) c_int;	28	pub extern "c" fn unlink(path: [*]const u8) c_int;
29	pub extern "c" fn getcwd(buf: []u8, size: usize) ?[]u8;	29	pub extern "c" fn getcwd(buf: []u8, size: usize) ?[]u8;
30	pub extern "c" fn waitpid(pid: c_int, stat_loc: *c_int, options: c_int) c_int;	30	pub extern "c" fn waitpid(pid: c_int, stat_loc: *c_int, options: c_int) c_int;
...	@@ -48,15 +48,15 @@ pub extern "c" fn setreuid(ruid: c_uint, euid: c_uint) c_int;	...	@@ -48,15 +48,15 @@ pub extern "c" fn setreuid(ruid: c_uint, euid: c_uint) c_int;
48	pub extern "c" fn setregid(rgid: c_uint, egid: c_uint) c_int;	48	pub extern "c" fn setregid(rgid: c_uint, egid: c_uint) c_int;
49	pub extern "c" fn rmdir(path: [*]const u8) c_int;	49	pub extern "c" fn rmdir(path: [*]const u8) c_int;
50		50
51	pub extern "c" fn aligned_alloc(alignment: usize, size: usize) ?[*]c_void;	51	pub extern "c" fn aligned_alloc(alignment: usize, size: usize) ?*c_void;
52	pub extern "c" fn malloc(usize) ?[*]c_void;	52	pub extern "c" fn malloc(usize) ?*c_void;
53	pub extern "c" fn realloc([]c_void, usize) ?[]c_void;	53	pub extern "c" fn realloc(c_void, usize) ?c_void;
54	pub extern "c" fn free([*]c_void) void;	54	pub extern "c" fn free(*c_void) void;
55	pub extern "c" fn posix_memalign(memptr: []c_void, alignment: usize, size: usize) c_int;	55	pub extern "c" fn posix_memalign(memptr: **c_void, alignment: usize, size: usize) c_int;
56		56
57	pub extern "pthread" fn pthread_create(noalias newthread: pthread_t, noalias attr: ?const pthread_attr_t, start_routine: extern fn (?c_void) ?c_void, noalias arg: ?*c_void) c_int;	57	pub extern "pthread" fn pthread_create(noalias newthread: pthread_t, noalias attr: ?const pthread_attr_t, start_routine: extern fn (?c_void) ?c_void, noalias arg: ?*c_void) c_int;
58	pub extern "pthread" fn pthread_attr_init(attr: *pthread_attr_t) c_int;	58	pub extern "pthread" fn pthread_attr_init(attr: *pthread_attr_t) c_int;
59	pub extern "pthread" fn pthread_attr_setstack(attr: pthread_attr_t, stackaddr: []c_void, stacksize: usize) c_int;	59	pub extern "pthread" fn pthread_attr_setstack(attr: pthread_attr_t, stackaddr: c_void, stacksize: usize) c_int;
60	pub extern "pthread" fn pthread_attr_destroy(attr: *pthread_attr_t) c_int;	60	pub extern "pthread" fn pthread_attr_destroy(attr: *pthread_attr_t) c_int;
61	pub extern "pthread" fn pthread_join(thread: pthread_t, arg_return: ??c_void) c_int;	61	pub extern "pthread" fn pthread_join(thread: pthread_t, arg_return: ??c_void) c_int;
62		62

...	@@ -88,6 +88,16 @@ pub fn assert(ok: bool) void {	...	@@ -88,6 +88,16 @@ pub fn assert(ok: bool) void {
88	}	88	}
89	}	89	}
90		90
		91	/// TODO: add `==` operator for `error_union == error_set`, and then
		92	/// remove this function
		93	pub fn assertError(value: var, expected_error: error) void {
		94	if (value) {
		95	@panic("expected error");
		96	} else \|actual_error\| {
		97	assert(actual_error == expected_error);
		98	}
		99	}
		100
91	/// Call this function when you want to panic if the condition is not true.	101	/// Call this function when you want to panic if the condition is not true.
92	/// If `ok` is `false`, this function will panic in every release mode.	102	/// If `ok` is `false`, this function will panic in every release mode.
93	pub fn assertOrPanic(ok: bool) void {	103	pub fn assertOrPanic(ok: bool) void {
...	@@ -198,7 +208,7 @@ fn printSourceAtAddress(debug_info: *ElfStackTrace, out_stream: var, address: us	...	@@ -198,7 +208,7 @@ fn printSourceAtAddress(debug_info: *ElfStackTrace, out_stream: var, address: us
198	.name = "???",	208	.name = "???",
199	.address = address,	209	.address = address,
200	};	210	};
201	const symbol = debug_info.symbol_table.search(address) ?? &unknown;	211	const symbol = debug_info.symbol_table.search(address) orelse &unknown;
202	try out_stream.print(WHITE ++ "{}" ++ RESET ++ ": " ++ DIM ++ ptr_hex ++ " in ??? (???)" ++ RESET ++ "\n", symbol.name, address);	212	try out_stream.print(WHITE ++ "{}" ++ RESET ++ ": " ++ DIM ++ ptr_hex ++ " in ??? (???)" ++ RESET ++ "\n", symbol.name, address);
203	},	213	},
204	else => {	214	else => {
...	@@ -258,10 +268,10 @@ pub fn openSelfDebugInfo(allocator: mem.Allocator) !ElfStackTrace {	...	@@ -258,10 +268,10 @@ pub fn openSelfDebugInfo(allocator: mem.Allocator) !ElfStackTrace {
258	try st.elf.openFile(allocator, &st.self_exe_file);	268	try st.elf.openFile(allocator, &st.self_exe_file);
259	errdefer st.elf.close();	269	errdefer st.elf.close();
260		270
261	st.debug_info = (try st.elf.findSection(".debug_info")) ?? return error.MissingDebugInfo;	271	st.debug_info = (try st.elf.findSection(".debug_info")) orelse return error.MissingDebugInfo;
262	st.debug_abbrev = (try st.elf.findSection(".debug_abbrev")) ?? return error.MissingDebugInfo;	272	st.debug_abbrev = (try st.elf.findSection(".debug_abbrev")) orelse return error.MissingDebugInfo;
263	st.debug_str = (try st.elf.findSection(".debug_str")) ?? return error.MissingDebugInfo;	273	st.debug_str = (try st.elf.findSection(".debug_str")) orelse return error.MissingDebugInfo;
264	st.debug_line = (try st.elf.findSection(".debug_line")) ?? return error.MissingDebugInfo;	274	st.debug_line = (try st.elf.findSection(".debug_line")) orelse return error.MissingDebugInfo;
265	st.debug_ranges = (try st.elf.findSection(".debug_ranges"));	275	st.debug_ranges = (try st.elf.findSection(".debug_ranges"));
266	try scanAllCompileUnits(st);	276	try scanAllCompileUnits(st);
267	return st;	277	return st;
...	@@ -433,7 +443,7 @@ const Die = struct {	...	@@ -433,7 +443,7 @@ const Die = struct {
433	}	443	}
434		444
435	fn getAttrAddr(self: *const Die, id: u64) !u64 {	445	fn getAttrAddr(self: *const Die, id: u64) !u64 {
436	const form_value = self.getAttr(id) ?? return error.MissingDebugInfo;	446	const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
437	return switch (form_value.*) {	447	return switch (form_value.*) {
438	FormValue.Address => \|value\| value,	448	FormValue.Address => \|value\| value,
439	else => error.InvalidDebugInfo,	449	else => error.InvalidDebugInfo,
...	@@ -441,7 +451,7 @@ const Die = struct {	...	@@ -441,7 +451,7 @@ const Die = struct {
441	}	451	}
442		452
443	fn getAttrSecOffset(self: *const Die, id: u64) !u64 {	453	fn getAttrSecOffset(self: *const Die, id: u64) !u64 {
444	const form_value = self.getAttr(id) ?? return error.MissingDebugInfo;	454	const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
445	return switch (form_value.*) {	455	return switch (form_value.*) {
446	FormValue.Const => \|value\| value.asUnsignedLe(),	456	FormValue.Const => \|value\| value.asUnsignedLe(),
447	FormValue.SecOffset => \|value\| value,	457	FormValue.SecOffset => \|value\| value,
...	@@ -450,7 +460,7 @@ const Die = struct {	...	@@ -450,7 +460,7 @@ const Die = struct {
450	}	460	}
451		461
452	fn getAttrUnsignedLe(self: *const Die, id: u64) !u64 {	462	fn getAttrUnsignedLe(self: *const Die, id: u64) !u64 {
453	const form_value = self.getAttr(id) ?? return error.MissingDebugInfo;	463	const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
454	return switch (form_value.*) {	464	return switch (form_value.*) {
455	FormValue.Const => \|value\| value.asUnsignedLe(),	465	FormValue.Const => \|value\| value.asUnsignedLe(),
456	else => error.InvalidDebugInfo,	466	else => error.InvalidDebugInfo,
...	@@ -458,7 +468,7 @@ const Die = struct {	...	@@ -458,7 +468,7 @@ const Die = struct {
458	}	468	}
459		469
460	fn getAttrString(self: const Die, st: ElfStackTrace, id: u64) ![]u8 {	470	fn getAttrString(self: const Die, st: ElfStackTrace, id: u64) ![]u8 {
461	const form_value = self.getAttr(id) ?? return error.MissingDebugInfo;	471	const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
462	return switch (form_value.*) {	472	return switch (form_value.*) {
463	FormValue.String => \|value\| value,	473	FormValue.String => \|value\| value,
464	FormValue.StrPtr => \|offset\| getString(st, offset),	474	FormValue.StrPtr => \|offset\| getString(st, offset),
...	@@ -738,7 +748,7 @@ fn parseDie(st: ElfStackTrace, abbrev_table: const AbbrevTable, is_64: bool) !	...	@@ -738,7 +748,7 @@ fn parseDie(st: ElfStackTrace, abbrev_table: const AbbrevTable, is_64: bool) !
738	var in_file_stream = io.FileInStream.init(in_file);	748	var in_file_stream = io.FileInStream.init(in_file);
739	const in_stream = &in_file_stream.stream;	749	const in_stream = &in_file_stream.stream;
740	const abbrev_code = try readULeb128(in_stream);	750	const abbrev_code = try readULeb128(in_stream);
741	const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) ?? return error.InvalidDebugInfo;	751	const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) orelse return error.InvalidDebugInfo;
742		752
743	var result = Die{	753	var result = Die{
744	.tag_id = table_entry.tag_id,	754	.tag_id = table_entry.tag_id,

...	@@ -22,7 +22,7 @@ fn cAlloc(self: *Allocator, n: usize, alignment: u29) ![]u8 {	...	@@ -22,7 +22,7 @@ fn cAlloc(self: *Allocator, n: usize, alignment: u29) ![]u8 {
22	}	22	}
23		23
24	fn cRealloc(self: *Allocator, old_mem: []u8, new_size: usize, alignment: u29) ![]u8 {	24	fn cRealloc(self: *Allocator, old_mem: []u8, new_size: usize, alignment: u29) ![]u8 {
25	const old_ptr = @ptrCast([*]c_void, old_mem.ptr);	25	const old_ptr = @ptrCast(*c_void, old_mem.ptr);
26	if (c.realloc(old_ptr, new_size)) \|buf\| {	26	if (c.realloc(old_ptr, new_size)) \|buf\| {
27	return @ptrCast([*]u8, buf)[0..new_size];	27	return @ptrCast([*]u8, buf)[0..new_size];
28	} else if (new_size <= old_mem.len) {	28	} else if (new_size <= old_mem.len) {
...	@@ -33,7 +33,7 @@ fn cRealloc(self: *Allocator, old_mem: []u8, new_size: usize, alignment: u29) ![	...	@@ -33,7 +33,7 @@ fn cRealloc(self: *Allocator, old_mem: []u8, new_size: usize, alignment: u29) ![
33	}	33	}
34		34
35	fn cFree(self: *Allocator, old_mem: []u8) void {	35	fn cFree(self: *Allocator, old_mem: []u8) void {
36	const old_ptr = @ptrCast([*]c_void, old_mem.ptr);	36	const old_ptr = @ptrCast(*c_void, old_mem.ptr);
37	c.free(old_ptr);	37	c.free(old_ptr);
38	}	38	}
39		39
...	@@ -97,12 +97,12 @@ pub const DirectAllocator = struct {	...	@@ -97,12 +97,12 @@ pub const DirectAllocator = struct {
97	},	97	},
98	Os.windows => {	98	Os.windows => {
99	const amt = n + alignment + @sizeOf(usize);	99	const amt = n + alignment + @sizeOf(usize);
100	const heap_handle = self.heap_handle ?? blk: {	100	const heap_handle = self.heap_handle orelse blk: {
101	const hh = os.windows.HeapCreate(os.windows.HEAP_NO_SERIALIZE, amt, 0) ?? return error.OutOfMemory;	101	const hh = os.windows.HeapCreate(os.windows.HEAP_NO_SERIALIZE, amt, 0) orelse return error.OutOfMemory;
102	self.heap_handle = hh;	102	self.heap_handle = hh;
103	break :blk hh;	103	break :blk hh;
104	};	104	};
105	const ptr = os.windows.HeapAlloc(heap_handle, 0, amt) ?? return error.OutOfMemory;	105	const ptr = os.windows.HeapAlloc(heap_handle, 0, amt) orelse return error.OutOfMemory;
106	const root_addr = @ptrToInt(ptr);	106	const root_addr = @ptrToInt(ptr);
107	const rem = @rem(root_addr, alignment);	107	const rem = @rem(root_addr, alignment);
108	const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);	108	const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
...	@@ -140,9 +140,9 @@ pub const DirectAllocator = struct {	...	@@ -140,9 +140,9 @@ pub const DirectAllocator = struct {
140	const old_adjusted_addr = @ptrToInt(old_mem.ptr);	140	const old_adjusted_addr = @ptrToInt(old_mem.ptr);
141	const old_record_addr = old_adjusted_addr + old_mem.len;	141	const old_record_addr = old_adjusted_addr + old_mem.len;
142	const root_addr = @intToPtr(align(1) usize, old_record_addr).;	142	const root_addr = @intToPtr(align(1) usize, old_record_addr).;
143	const old_ptr = @intToPtr([*]c_void, root_addr);	143	const old_ptr = @intToPtr(*c_void, root_addr);
144	const amt = new_size + alignment + @sizeOf(usize);	144	const amt = new_size + alignment + @sizeOf(usize);
145	const new_ptr = os.windows.HeapReAlloc(??self.heap_handle, 0, old_ptr, amt) ?? blk: {	145	const new_ptr = os.windows.HeapReAlloc(self.heap_handle.?, 0, old_ptr, amt) orelse blk: {
146	if (new_size > old_mem.len) return error.OutOfMemory;	146	if (new_size > old_mem.len) return error.OutOfMemory;
147	const new_record_addr = old_record_addr - new_size + old_mem.len;	147	const new_record_addr = old_record_addr - new_size + old_mem.len;
148	@intToPtr(align(1) usize, new_record_addr). = root_addr;	148	@intToPtr(align(1) usize, new_record_addr). = root_addr;
...	@@ -170,8 +170,8 @@ pub const DirectAllocator = struct {	...	@@ -170,8 +170,8 @@ pub const DirectAllocator = struct {
170	Os.windows => {	170	Os.windows => {
171	const record_addr = @ptrToInt(bytes.ptr) + bytes.len;	171	const record_addr = @ptrToInt(bytes.ptr) + bytes.len;
172	const root_addr = @intToPtr(align(1) usize, record_addr).;	172	const root_addr = @intToPtr(align(1) usize, record_addr).;
173	const ptr = @intToPtr([*]c_void, root_addr);	173	const ptr = @intToPtr(*c_void, root_addr);
174	_ = os.windows.HeapFree(??self.heap_handle, 0, ptr);	174	_ = os.windows.HeapFree(self.heap_handle.?, 0, ptr);
175	},	175	},
176	else => @compileError("Unsupported OS"),	176	else => @compileError("Unsupported OS"),
177	}	177	}
...	@@ -343,7 +343,7 @@ pub const ThreadSafeFixedBufferAllocator = struct {	...	@@ -343,7 +343,7 @@ pub const ThreadSafeFixedBufferAllocator = struct {
343	if (new_end_index > self.buffer.len) {	343	if (new_end_index > self.buffer.len) {
344	return error.OutOfMemory;	344	return error.OutOfMemory;
345	}	345	}
346	end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) ?? return self.buffer[adjusted_index..new_end_index];	346	end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) orelse return self.buffer[adjusted_index..new_end_index];
347	}	347	}
348	}	348	}
349		349

...	@@ -156,7 +156,7 @@ pub const ChildProcess = struct {	...	@@ -156,7 +156,7 @@ pub const ChildProcess = struct {
156	};	156	};
157	}	157	}
158	try self.waitUnwrappedWindows();	158	try self.waitUnwrappedWindows();
159	return ??self.term;	159	return self.term.?;
160	}	160	}
161		161
162	pub fn killPosix(self: *ChildProcess) !Term {	162	pub fn killPosix(self: *ChildProcess) !Term {
...	@@ -175,7 +175,7 @@ pub const ChildProcess = struct {	...	@@ -175,7 +175,7 @@ pub const ChildProcess = struct {
175	};	175	};
176	}	176	}
177	self.waitUnwrapped();	177	self.waitUnwrapped();
178	return ??self.term;	178	return self.term.?;
179	}	179	}
180		180
181	/// Blocks until child process terminates and then cleans up all resources.	181	/// Blocks until child process terminates and then cleans up all resources.
...	@@ -212,8 +212,8 @@ pub const ChildProcess = struct {	...	@@ -212,8 +212,8 @@ pub const ChildProcess = struct {
212	defer Buffer.deinit(&stdout);	212	defer Buffer.deinit(&stdout);
213	defer Buffer.deinit(&stderr);	213	defer Buffer.deinit(&stderr);
214		214
215	var stdout_file_in_stream = io.FileInStream.init(&??child.stdout);	215	var stdout_file_in_stream = io.FileInStream.init(&child.stdout.?);
216	var stderr_file_in_stream = io.FileInStream.init(&??child.stderr);	216	var stderr_file_in_stream = io.FileInStream.init(&child.stderr.?);
217		217
218	try stdout_file_in_stream.stream.readAllBuffer(&stdout, max_output_size);	218	try stdout_file_in_stream.stream.readAllBuffer(&stdout, max_output_size);
219	try stderr_file_in_stream.stream.readAllBuffer(&stderr, max_output_size);	219	try stderr_file_in_stream.stream.readAllBuffer(&stderr, max_output_size);
...	@@ -232,7 +232,7 @@ pub const ChildProcess = struct {	...	@@ -232,7 +232,7 @@ pub const ChildProcess = struct {
232	}	232	}
233		233
234	try self.waitUnwrappedWindows();	234	try self.waitUnwrappedWindows();
235	return ??self.term;	235	return self.term.?;
236	}	236	}
237		237
238	fn waitPosix(self: *ChildProcess) !Term {	238	fn waitPosix(self: *ChildProcess) !Term {
...	@@ -242,7 +242,7 @@ pub const ChildProcess = struct {	...	@@ -242,7 +242,7 @@ pub const ChildProcess = struct {
242	}	242	}
243		243
244	self.waitUnwrapped();	244	self.waitUnwrapped();
245	return ??self.term;	245	return self.term.?;
246	}	246	}
247		247
248	pub fn deinit(self: *ChildProcess) void {	248	pub fn deinit(self: *ChildProcess) void {
...	@@ -619,13 +619,13 @@ pub const ChildProcess = struct {	...	@@ -619,13 +619,13 @@ pub const ChildProcess = struct {
619	self.term = null;	619	self.term = null;
620		620
621	if (self.stdin_behavior == StdIo.Pipe) {	621	if (self.stdin_behavior == StdIo.Pipe) {
622	os.close(??g_hChildStd_IN_Rd);	622	os.close(g_hChildStd_IN_Rd.?);
623	}	623	}
624	if (self.stderr_behavior == StdIo.Pipe) {	624	if (self.stderr_behavior == StdIo.Pipe) {
625	os.close(??g_hChildStd_ERR_Wr);	625	os.close(g_hChildStd_ERR_Wr.?);
626	}	626	}
627	if (self.stdout_behavior == StdIo.Pipe) {	627	if (self.stdout_behavior == StdIo.Pipe) {
628	os.close(??g_hChildStd_OUT_Wr);	628	os.close(g_hChildStd_OUT_Wr.?);
629	}	629	}
630	}	630	}
631		631

...	@@ -27,15 +27,15 @@ pub fn main() !void {	...	@@ -27,15 +27,15 @@ pub fn main() !void {
27	// skip my own exe name	27	// skip my own exe name
28	_ = arg_it.skip();	28	_ = arg_it.skip();
29		29
30	const zig_exe = try unwrapArg(arg_it.next(allocator) ?? {	30	const zig_exe = try unwrapArg(arg_it.next(allocator) orelse {
31	warn("Expected first argument to be path to zig compiler\n");	31	warn("Expected first argument to be path to zig compiler\n");
32	return error.InvalidArgs;	32	return error.InvalidArgs;
33	});	33	});
34	const build_root = try unwrapArg(arg_it.next(allocator) ?? {	34	const build_root = try unwrapArg(arg_it.next(allocator) orelse {
35	warn("Expected second argument to be build root directory path\n");	35	warn("Expected second argument to be build root directory path\n");
36	return error.InvalidArgs;	36	return error.InvalidArgs;
37	});	37	});
38	const cache_root = try unwrapArg(arg_it.next(allocator) ?? {	38	const cache_root = try unwrapArg(arg_it.next(allocator) orelse {
39	warn("Expected third argument to be cache root directory path\n");	39	warn("Expected third argument to be cache root directory path\n");
40	return error.InvalidArgs;	40	return error.InvalidArgs;
41	});	41	});
...	@@ -84,12 +84,12 @@ pub fn main() !void {	...	@@ -84,12 +84,12 @@ pub fn main() !void {
84	} else if (mem.eql(u8, arg, "--help")) {	84	} else if (mem.eql(u8, arg, "--help")) {
85	return usage(&builder, false, try stdout_stream);	85	return usage(&builder, false, try stdout_stream);
86	} else if (mem.eql(u8, arg, "--prefix")) {	86	} else if (mem.eql(u8, arg, "--prefix")) {
87	prefix = try unwrapArg(arg_it.next(allocator) ?? {	87	prefix = try unwrapArg(arg_it.next(allocator) orelse {
88	warn("Expected argument after --prefix\n\n");	88	warn("Expected argument after --prefix\n\n");
89	return usageAndErr(&builder, false, try stderr_stream);	89	return usageAndErr(&builder, false, try stderr_stream);
90	});	90	});
91	} else if (mem.eql(u8, arg, "--search-prefix")) {	91	} else if (mem.eql(u8, arg, "--search-prefix")) {
92	const search_prefix = try unwrapArg(arg_it.next(allocator) ?? {	92	const search_prefix = try unwrapArg(arg_it.next(allocator) orelse {
93	warn("Expected argument after --search-prefix\n\n");	93	warn("Expected argument after --search-prefix\n\n");
94	return usageAndErr(&builder, false, try stderr_stream);	94	return usageAndErr(&builder, false, try stderr_stream);
95	});	95	});

...	@@ -83,7 +83,7 @@ fn renderRoot(	...	@@ -83,7 +83,7 @@ fn renderRoot(
83	var start_col: usize = 0;	83	var start_col: usize = 0;
84	var it = tree.root_node.decls.iterator(0);	84	var it = tree.root_node.decls.iterator(0);
85	while (true) {	85	while (true) {
86	var decl = (it.next() ?? return).*;	86	var decl = (it.next() orelse return).*;
87	// look for zig fmt: off comment	87	// look for zig fmt: off comment
88	var start_token_index = decl.firstToken();	88	var start_token_index = decl.firstToken();
89	zig_fmt_loop: while (start_token_index != 0) {	89	zig_fmt_loop: while (start_token_index != 0) {
...	@@ -112,7 +112,7 @@ fn renderRoot(	...	@@ -112,7 +112,7 @@ fn renderRoot(
112	const start = tree.tokens.at(start_token_index + 1).start;	112	const start = tree.tokens.at(start_token_index + 1).start;
113	try stream.print("{}\n", tree.source[start..end_token.end]);	113	try stream.print("{}\n", tree.source[start..end_token.end]);
114	while (tree.tokens.at(decl.firstToken()).start < end_token.end) {	114	while (tree.tokens.at(decl.firstToken()).start < end_token.end) {
115	decl = (it.next() ?? return).*;	115	decl = (it.next() orelse return).*;
116	}	116	}
117	break :zig_fmt_loop;	117	break :zig_fmt_loop;
118	}	118	}
...	@@ -222,7 +222,7 @@ fn renderTopLevelDecl(allocator: mem.Allocator, stream: var, tree: ast.Tree, i	...	@@ -222,7 +222,7 @@ fn renderTopLevelDecl(allocator: mem.Allocator, stream: var, tree: ast.Tree, i
222	}	222	}
223	}	223	}
224		224
225	const value_expr = ??tag.value_expr;	225	const value_expr = tag.value_expr.?;
226	try renderToken(tree, stream, tree.prevToken(value_expr.firstToken()), indent, start_col, Space.Space); // =	226	try renderToken(tree, stream, tree.prevToken(value_expr.firstToken()), indent, start_col, Space.Space); // =
227	try renderExpression(allocator, stream, tree, indent, start_col, value_expr, Space.Comma); // value,	227	try renderExpression(allocator, stream, tree, indent, start_col, value_expr, Space.Comma); // value,
228	},	228	},
...	@@ -465,8 +465,7 @@ fn renderExpression(	...	@@ -465,8 +465,7 @@ fn renderExpression(
465	ast.Node.PrefixOp.Op.BoolNot,	465	ast.Node.PrefixOp.Op.BoolNot,
466	ast.Node.PrefixOp.Op.Negation,	466	ast.Node.PrefixOp.Op.Negation,
467	ast.Node.PrefixOp.Op.NegationWrap,	467	ast.Node.PrefixOp.Op.NegationWrap,
468	ast.Node.PrefixOp.Op.UnwrapMaybe,	468	ast.Node.PrefixOp.Op.OptionalType,
469	ast.Node.PrefixOp.Op.MaybeType,
470	ast.Node.PrefixOp.Op.AddressOf,	469	ast.Node.PrefixOp.Op.AddressOf,
471	=> {	470	=> {
472	try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None);	471	try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None);
...	@@ -513,7 +512,7 @@ fn renderExpression(	...	@@ -513,7 +512,7 @@ fn renderExpression(
513		512
514	var it = call_info.params.iterator(0);	513	var it = call_info.params.iterator(0);
515	while (true) {	514	while (true) {
516	const param_node = ??it.next();	515	const param_node = it.next().?;
517		516
518	const param_node_new_indent = if (param_node.*.id == ast.Node.Id.MultilineStringLiteral) blk: {	517	const param_node_new_indent = if (param_node.*.id == ast.Node.Id.MultilineStringLiteral) blk: {
519	break :blk indent;	518	break :blk indent;
...	@@ -559,10 +558,10 @@ fn renderExpression(	...	@@ -559,10 +558,10 @@ fn renderExpression(
559	return renderToken(tree, stream, rbracket, indent, start_col, space); // ]	558	return renderToken(tree, stream, rbracket, indent, start_col, space); // ]
560	},	559	},
561		560
562	ast.Node.SuffixOp.Op.Deref => {	561	ast.Node.SuffixOp.Op.Deref, ast.Node.SuffixOp.Op.UnwrapOptional => {
563	try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);	562	try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
564	try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, start_col, Space.None); // .	563	try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, start_col, Space.None); // .
565	return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // *	564	return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // * or ?
566	},	565	},
567		566
568	@TagType(ast.Node.SuffixOp.Op).Slice => \|range\| {	567	@TagType(ast.Node.SuffixOp.Op).Slice => \|range\| {
...	@@ -595,7 +594,7 @@ fn renderExpression(	...	@@ -595,7 +594,7 @@ fn renderExpression(
595	}	594	}
596		595
597	if (field_inits.len == 1) blk: {	596	if (field_inits.len == 1) blk: {
598	const field_init = ??field_inits.at(0).*.cast(ast.Node.FieldInitializer);	597	const field_init = field_inits.at(0).*.cast(ast.Node.FieldInitializer).?;
599		598
600	if (field_init.expr.cast(ast.Node.SuffixOp)) \|nested_suffix_op\| {	599	if (field_init.expr.cast(ast.Node.SuffixOp)) \|nested_suffix_op\| {
601	if (nested_suffix_op.op == ast.Node.SuffixOp.Op.StructInitializer) {	600	if (nested_suffix_op.op == ast.Node.SuffixOp.Op.StructInitializer) {
...	@@ -688,7 +687,7 @@ fn renderExpression(	...	@@ -688,7 +687,7 @@ fn renderExpression(
688	var count: usize = 1;	687	var count: usize = 1;
689	var it = exprs.iterator(0);	688	var it = exprs.iterator(0);
690	while (true) {	689	while (true) {
691	const expr = (??it.next()).*;	690	const expr = it.next().?.*;
692	if (it.peek()) \|next_expr\| {	691	if (it.peek()) \|next_expr\| {
693	const expr_last_token = expr.*.lastToken() + 1;	692	const expr_last_token = expr.*.lastToken() + 1;
694	const loc = tree.tokenLocation(tree.tokens.at(expr_last_token).end, next_expr.*.firstToken());	693	const loc = tree.tokenLocation(tree.tokens.at(expr_last_token).end, next_expr.*.firstToken());
...	@@ -806,7 +805,7 @@ fn renderExpression(	...	@@ -806,7 +805,7 @@ fn renderExpression(
806	},	805	},
807	}	806	}
808		807
809	return renderExpression(allocator, stream, tree, indent, start_col, ??flow_expr.rhs, space);	808	return renderExpression(allocator, stream, tree, indent, start_col, flow_expr.rhs.?, space);
810	},	809	},
811		810
812	ast.Node.Id.Payload => {	811	ast.Node.Id.Payload => {
...	@@ -1245,7 +1244,7 @@ fn renderExpression(	...	@@ -1245,7 +1244,7 @@ fn renderExpression(
1245	} else {	1244	} else {
1246	var it = switch_case.items.iterator(0);	1245	var it = switch_case.items.iterator(0);
1247	while (true) {	1246	while (true) {
1248	const node = ??it.next();	1247	const node = it.next().?;
1249	if (it.peek()) \|next_node\| {	1248	if (it.peek()) \|next_node\| {
1250	try renderExpression(allocator, stream, tree, indent, start_col, node.*, Space.None);	1249	try renderExpression(allocator, stream, tree, indent, start_col, node.*, Space.None);
1251		1250
...	@@ -1550,7 +1549,7 @@ fn renderExpression(	...	@@ -1550,7 +1549,7 @@ fn renderExpression(
1550		1549
1551	var it = asm_node.outputs.iterator(0);	1550	var it = asm_node.outputs.iterator(0);
1552	while (true) {	1551	while (true) {
1553	const asm_output = ??it.next();	1552	const asm_output = it.next().?;
1554	const node = &(asm_output.*).base;	1553	const node = &(asm_output.*).base;
1555		1554
1556	if (it.peek()) \|next_asm_output\| {	1555	if (it.peek()) \|next_asm_output\| {
...	@@ -1588,7 +1587,7 @@ fn renderExpression(	...	@@ -1588,7 +1587,7 @@ fn renderExpression(
1588		1587
1589	var it = asm_node.inputs.iterator(0);	1588	var it = asm_node.inputs.iterator(0);
1590	while (true) {	1589	while (true) {
1591	const asm_input = ??it.next();	1590	const asm_input = it.next().?;
1592	const node = &(asm_input.*).base;	1591	const node = &(asm_input.*).base;
1593		1592
1594	if (it.peek()) \|next_asm_input\| {	1593	if (it.peek()) \|next_asm_input\| {
...	@@ -1620,7 +1619,7 @@ fn renderExpression(	...	@@ -1620,7 +1619,7 @@ fn renderExpression(
1620		1619
1621	var it = asm_node.clobbers.iterator(0);	1620	var it = asm_node.clobbers.iterator(0);
1622	while (true) {	1621	while (true) {
1623	const clobber_token = ??it.next();	1622	const clobber_token = it.next().?;
1624		1623
1625	if (it.peek() == null) {	1624	if (it.peek() == null) {
1626	try renderToken(tree, stream, clobber_token.*, indent_once, start_col, Space.Newline);	1625	try renderToken(tree, stream, clobber_token.*, indent_once, start_col, Space.Newline);
...	@@ -1994,7 +1993,7 @@ fn renderDocComments(	...	@@ -1994,7 +1993,7 @@ fn renderDocComments(
1994	indent: usize,	1993	indent: usize,
1995	start_col: *usize,	1994	start_col: *usize,
1996	) (@typeOf(stream).Child.Error \|\| Error)!void {	1995	) (@typeOf(stream).Child.Error \|\| Error)!void {
1997	const comment = node.doc_comments ?? return;	1996	const comment = node.doc_comments orelse return;
1998	var it = comment.lines.iterator(0);	1997	var it = comment.lines.iterator(0);
1999	const first_token = node.firstToken();	1998	const first_token = node.firstToken();
2000	while (it.next()) \|line_token_index\| {	1999	while (it.next()) \|line_token_index\| {
...	@@ -2022,7 +2021,7 @@ fn nodeIsBlock(base: *const ast.Node) bool {	...	@@ -2022,7 +2021,7 @@ fn nodeIsBlock(base: *const ast.Node) bool {
2022	}	2021	}
2023		2022
2024	fn nodeCausesSliceOpSpace(base: *ast.Node) bool {	2023	fn nodeCausesSliceOpSpace(base: *ast.Node) bool {
2025	const infix_op = base.cast(ast.Node.InfixOp) ?? return false;	2024	const infix_op = base.cast(ast.Node.InfixOp) orelse return false;
2026	return switch (infix_op.op) {	2025	return switch (infix_op.op) {
2027	ast.Node.InfixOp.Op.Period => false,	2026	ast.Node.InfixOp.Op.Period => false,
2028	else => true,	2027	else => true,

...	@@ -282,8 +282,8 @@ pub const CompareOutputContext = struct {	...	@@ -282,8 +282,8 @@ pub const CompareOutputContext = struct {
282	var stdout = Buffer.initNull(b.allocator);	282	var stdout = Buffer.initNull(b.allocator);
283	var stderr = Buffer.initNull(b.allocator);	283	var stderr = Buffer.initNull(b.allocator);
284		284
285	var stdout_file_in_stream = io.FileInStream.init(&??child.stdout);	285	var stdout_file_in_stream = io.FileInStream.init(&child.stdout.?);
286	var stderr_file_in_stream = io.FileInStream.init(&??child.stderr);	286	var stderr_file_in_stream = io.FileInStream.init(&child.stderr.?);
287		287
288	stdout_file_in_stream.stream.readAllBuffer(&stdout, max_stdout_size) catch unreachable;	288	stdout_file_in_stream.stream.readAllBuffer(&stdout, max_stdout_size) catch unreachable;
289	stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size) catch unreachable;	289	stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size) catch unreachable;
...	@@ -601,8 +601,8 @@ pub const CompileErrorContext = struct {	...	@@ -601,8 +601,8 @@ pub const CompileErrorContext = struct {
601	var stdout_buf = Buffer.initNull(b.allocator);	601	var stdout_buf = Buffer.initNull(b.allocator);
602	var stderr_buf = Buffer.initNull(b.allocator);	602	var stderr_buf = Buffer.initNull(b.allocator);
603		603
604	var stdout_file_in_stream = io.FileInStream.init(&??child.stdout);	604	var stdout_file_in_stream = io.FileInStream.init(&child.stdout.?);
605	var stderr_file_in_stream = io.FileInStream.init(&??child.stderr);	605	var stderr_file_in_stream = io.FileInStream.init(&child.stderr.?);
606		606
607	stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable;	607	stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable;
608	stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;	608	stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;
...	@@ -872,8 +872,8 @@ pub const TranslateCContext = struct {	...	@@ -872,8 +872,8 @@ pub const TranslateCContext = struct {
872	var stdout_buf = Buffer.initNull(b.allocator);	872	var stdout_buf = Buffer.initNull(b.allocator);
873	var stderr_buf = Buffer.initNull(b.allocator);	873	var stderr_buf = Buffer.initNull(b.allocator);
874		874
875	var stdout_file_in_stream = io.FileInStream.init(&??child.stdout);	875	var stdout_file_in_stream = io.FileInStream.init(&child.stdout.?);
876	var stderr_file_in_stream = io.FileInStream.init(&??child.stderr);	876	var stderr_file_in_stream = io.FileInStream.init(&child.stderr.?);
877		877
878	stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable;	878	stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable;
879	stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;	879	stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;

Merge remote-tracking branch 'origin/master' into llvm7