Commit 07a24bec9a578857920f4c5508f1d7eea65177b8 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-06-11 21:00:39+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2024-06-15 00:57:52+01:00
log	07a24bec9a578857920f4c5508f1d7eea65177b8
tree	3edd81d1bff8219dd9122291041b28c5ea5ec9ce
parent	e39cc0dff7fff510c3d72f61947b977589ea5583
signature	Commit is signed but in an unrecognized format.

compiler: move LazySrcLoc out of std

This is in preparation for some upcoming changes to how we represent
source locations in the compiler. The bulk of the change here is dealing
with the removal of `src()` methods from `Zir` types.

12 files changed, 632 insertions(+), 679 deletions(-)

lib
- std
  - zig.zig
  - zig
    Zir.zig
src
- InternPool.zig
- Module.zig
- Sema.zig
- Sema
  - comptime_ptr_access.zig
- arch
  - wasm
    CodeGen.zig
- codegen
- print_zir.zig

lib/std/zig.zig-373

...	@@ -350,379 +350,6 @@ pub fn serializeCpuAlloc(ally: Allocator, cpu: std.Target.Cpu) Allocator.Error![	...	@@ -350,379 +350,6 @@ pub fn serializeCpuAlloc(ally: Allocator, cpu: std.Target.Cpu) Allocator.Error![
350	return buffer.toOwnedSlice();	350	return buffer.toOwnedSlice();
351	}	351	}
352		352
353	pub const DeclIndex = enum(u32) {
354	_,
355
356	pub fn toOptional(i: DeclIndex) OptionalDeclIndex {
357	return @enumFromInt(@intFromEnum(i));
358	}
359	};
360
361	pub const OptionalDeclIndex = enum(u32) {
362	none = std.math.maxInt(u32),
363	_,
364
365	pub fn init(oi: ?DeclIndex) OptionalDeclIndex {
366	return @enumFromInt(@intFromEnum(oi orelse return .none));
367	}
368
369	pub fn unwrap(oi: OptionalDeclIndex) ?DeclIndex {
370	if (oi == .none) return null;
371	return @enumFromInt(@intFromEnum(oi));
372	}
373	};
374
375	/// Resolving a source location into a byte offset may require doing work
376	/// that we would rather not do unless the error actually occurs.
377	/// Therefore we need a data structure that contains the information necessary
378	/// to lazily produce a `SrcLoc` as required.
379	/// Most of the offsets in this data structure are relative to the containing Decl.
380	/// This makes the source location resolve properly even when a Decl gets
381	/// shifted up or down in the file, as long as the Decl's contents itself
382	/// do not change.
383	pub const LazySrcLoc = union(enum) {
384	/// When this tag is set, the code that constructed this `LazySrcLoc` is asserting
385	/// that all code paths which would need to resolve the source location are
386	/// unreachable. If you are debugging this tag incorrectly being this value,
387	/// look into using reverse-continue with a memory watchpoint to see where the
388	/// value is being set to this tag.
389	unneeded,
390	/// Means the source location points to an entire file; not any particular
391	/// location within the file. `file_scope` union field will be active.
392	entire_file,
393	/// The source location points to a byte offset within a source file,
394	/// offset from 0. The source file is determined contextually.
395	/// Inside a `SrcLoc`, the `file_scope` union field will be active.
396	byte_abs: u32,
397	/// The source location points to a token within a source file,
398	/// offset from 0. The source file is determined contextually.
399	/// Inside a `SrcLoc`, the `file_scope` union field will be active.
400	token_abs: u32,
401	/// The source location points to an AST node within a source file,
402	/// offset from 0. The source file is determined contextually.
403	/// Inside a `SrcLoc`, the `file_scope` union field will be active.
404	node_abs: u32,
405	/// The source location points to a byte offset within a source file,
406	/// offset from the byte offset of the Decl within the file.
407	/// The Decl is determined contextually.
408	byte_offset: u32,
409	/// This data is the offset into the token list from the Decl token.
410	/// The Decl is determined contextually.
411	token_offset: u32,
412	/// The source location points to an AST node, which is this value offset
413	/// from its containing Decl node AST index.
414	/// The Decl is determined contextually.
415	node_offset: TracedOffset,
416	/// The source location points to the main token of an AST node, found
417	/// by taking this AST node index offset from the containing Decl AST node.
418	/// The Decl is determined contextually.
419	node_offset_main_token: i32,
420	/// The source location points to the beginning of a struct initializer.
421	/// The Decl is determined contextually.
422	node_offset_initializer: i32,
423	/// The source location points to a variable declaration type expression,
424	/// found by taking this AST node index offset from the containing
425	/// Decl AST node, which points to a variable declaration AST node. Next, navigate
426	/// to the type expression.
427	/// The Decl is determined contextually.
428	node_offset_var_decl_ty: i32,
429	/// The source location points to the alignment expression of a var decl.
430	/// The Decl is determined contextually.
431	node_offset_var_decl_align: i32,
432	/// The source location points to the linksection expression of a var decl.
433	/// The Decl is determined contextually.
434	node_offset_var_decl_section: i32,
435	/// The source location points to the addrspace expression of a var decl.
436	/// The Decl is determined contextually.
437	node_offset_var_decl_addrspace: i32,
438	/// The source location points to the initializer of a var decl.
439	/// The Decl is determined contextually.
440	node_offset_var_decl_init: i32,
441	/// The source location points to the first parameter of a builtin
442	/// function call, found by taking this AST node index offset from the containing
443	/// Decl AST node, which points to a builtin call AST node. Next, navigate
444	/// to the first parameter.
445	/// The Decl is determined contextually.
446	node_offset_builtin_call_arg0: i32,
447	/// Same as `node_offset_builtin_call_arg0` except arg index 1.
448	node_offset_builtin_call_arg1: i32,
449	node_offset_builtin_call_arg2: i32,
450	node_offset_builtin_call_arg3: i32,
451	node_offset_builtin_call_arg4: i32,
452	node_offset_builtin_call_arg5: i32,
453	/// Like `node_offset_builtin_call_arg0` but recurses through arbitrarily many calls
454	/// to pointer cast builtins.
455	node_offset_ptrcast_operand: i32,
456	/// The source location points to the index expression of an array access
457	/// expression, found by taking this AST node index offset from the containing
458	/// Decl AST node, which points to an array access AST node. Next, navigate
459	/// to the index expression.
460	/// The Decl is determined contextually.
461	node_offset_array_access_index: i32,
462	/// The source location points to the LHS of a slice expression
463	/// expression, found by taking this AST node index offset from the containing
464	/// Decl AST node, which points to a slice AST node. Next, navigate
465	/// to the sentinel expression.
466	/// The Decl is determined contextually.
467	node_offset_slice_ptr: i32,
468	/// The source location points to start expression of a slice expression
469	/// expression, found by taking this AST node index offset from the containing
470	/// Decl AST node, which points to a slice AST node. Next, navigate
471	/// to the sentinel expression.
472	/// The Decl is determined contextually.
473	node_offset_slice_start: i32,
474	/// The source location points to the end expression of a slice
475	/// expression, found by taking this AST node index offset from the containing
476	/// Decl AST node, which points to a slice AST node. Next, navigate
477	/// to the sentinel expression.
478	/// The Decl is determined contextually.
479	node_offset_slice_end: i32,
480	/// The source location points to the sentinel expression of a slice
481	/// expression, found by taking this AST node index offset from the containing
482	/// Decl AST node, which points to a slice AST node. Next, navigate
483	/// to the sentinel expression.
484	/// The Decl is determined contextually.
485	node_offset_slice_sentinel: i32,
486	/// The source location points to the callee expression of a function
487	/// call expression, found by taking this AST node index offset from the containing
488	/// Decl AST node, which points to a function call AST node. Next, navigate
489	/// to the callee expression.
490	/// The Decl is determined contextually.
491	node_offset_call_func: i32,
492	/// The payload is offset from the containing Decl AST node.
493	/// The source location points to the field name of:
494	/// * a field access expression (`a.b`), or
495	/// * the callee of a method call (`a.b()`)
496	/// The Decl is determined contextually.
497	node_offset_field_name: i32,
498	/// The payload is offset from the containing Decl AST node.
499	/// The source location points to the field name of the operand ("b" node)
500	/// of a field initialization expression (`.a = b`)
501	/// The Decl is determined contextually.
502	node_offset_field_name_init: i32,
503	/// The source location points to the pointer of a pointer deref expression,
504	/// found by taking this AST node index offset from the containing
505	/// Decl AST node, which points to a pointer deref AST node. Next, navigate
506	/// to the pointer expression.
507	/// The Decl is determined contextually.
508	node_offset_deref_ptr: i32,
509	/// The source location points to the assembly source code of an inline assembly
510	/// expression, found by taking this AST node index offset from the containing
511	/// Decl AST node, which points to inline assembly AST node. Next, navigate
512	/// to the asm template source code.
513	/// The Decl is determined contextually.
514	node_offset_asm_source: i32,
515	/// The source location points to the return type of an inline assembly
516	/// expression, found by taking this AST node index offset from the containing
517	/// Decl AST node, which points to inline assembly AST node. Next, navigate
518	/// to the return type expression.
519	/// The Decl is determined contextually.
520	node_offset_asm_ret_ty: i32,
521	/// The source location points to the condition expression of an if
522	/// expression, found by taking this AST node index offset from the containing
523	/// Decl AST node, which points to an if expression AST node. Next, navigate
524	/// to the condition expression.
525	/// The Decl is determined contextually.
526	node_offset_if_cond: i32,
527	/// The source location points to a binary expression, such as `a + b`, found
528	/// by taking this AST node index offset from the containing Decl AST node.
529	/// The Decl is determined contextually.
530	node_offset_bin_op: i32,
531	/// The source location points to the LHS of a binary expression, found
532	/// by taking this AST node index offset from the containing Decl AST node,
533	/// which points to a binary expression AST node. Next, navigate to the LHS.
534	/// The Decl is determined contextually.
535	node_offset_bin_lhs: i32,
536	/// The source location points to the RHS of a binary expression, found
537	/// by taking this AST node index offset from the containing Decl AST node,
538	/// which points to a binary expression AST node. Next, navigate to the RHS.
539	/// The Decl is determined contextually.
540	node_offset_bin_rhs: i32,
541	/// The source location points to the operand of a switch expression, found
542	/// by taking this AST node index offset from the containing Decl AST node,
543	/// which points to a switch expression AST node. Next, navigate to the operand.
544	/// The Decl is determined contextually.
545	node_offset_switch_operand: i32,
546	/// The source location points to the else/`_` prong of a switch expression, found
547	/// by taking this AST node index offset from the containing Decl AST node,
548	/// which points to a switch expression AST node. Next, navigate to the else/`_` prong.
549	/// The Decl is determined contextually.
550	node_offset_switch_special_prong: i32,
551	/// The source location points to all the ranges of a switch expression, found
552	/// by taking this AST node index offset from the containing Decl AST node,
553	/// which points to a switch expression AST node. Next, navigate to any of the
554	/// range nodes. The error applies to all of them.
555	/// The Decl is determined contextually.
556	node_offset_switch_range: i32,
557	/// The source location points to the capture of a switch_prong.
558	/// The Decl is determined contextually.
559	node_offset_switch_prong_capture: i32,
560	/// The source location points to the tag capture of a switch_prong.
561	/// The Decl is determined contextually.
562	node_offset_switch_prong_tag_capture: i32,
563	/// The source location points to the align expr of a function type
564	/// expression, found by taking this AST node index offset from the containing
565	/// Decl AST node, which points to a function type AST node. Next, navigate to
566	/// the calling convention node.
567	/// The Decl is determined contextually.
568	node_offset_fn_type_align: i32,
569	/// The source location points to the addrspace expr of a function type
570	/// expression, found by taking this AST node index offset from the containing
571	/// Decl AST node, which points to a function type AST node. Next, navigate to
572	/// the calling convention node.
573	/// The Decl is determined contextually.
574	node_offset_fn_type_addrspace: i32,
575	/// The source location points to the linksection expr of a function type
576	/// expression, found by taking this AST node index offset from the containing
577	/// Decl AST node, which points to a function type AST node. Next, navigate to
578	/// the calling convention node.
579	/// The Decl is determined contextually.
580	node_offset_fn_type_section: i32,
581	/// The source location points to the calling convention of a function type
582	/// expression, found by taking this AST node index offset from the containing
583	/// Decl AST node, which points to a function type AST node. Next, navigate to
584	/// the calling convention node.
585	/// The Decl is determined contextually.
586	node_offset_fn_type_cc: i32,
587	/// The source location points to the return type of a function type
588	/// expression, found by taking this AST node index offset from the containing
589	/// Decl AST node, which points to a function type AST node. Next, navigate to
590	/// the return type node.
591	/// The Decl is determined contextually.
592	node_offset_fn_type_ret_ty: i32,
593	node_offset_param: i32,
594	token_offset_param: i32,
595	/// The source location points to the type expression of an `anyframe->T`
596	/// expression, found by taking this AST node index offset from the containing
597	/// Decl AST node, which points to a `anyframe->T` expression AST node. Next, navigate
598	/// to the type expression.
599	/// The Decl is determined contextually.
600	node_offset_anyframe_type: i32,
601	/// The source location points to the string literal of `extern "foo"`, found
602	/// by taking this AST node index offset from the containing
603	/// Decl AST node, which points to a function prototype or variable declaration
604	/// expression AST node. Next, navigate to the string literal of the `extern "foo"`.
605	/// The Decl is determined contextually.
606	node_offset_lib_name: i32,
607	/// The source location points to the len expression of an `[N:S]T`
608	/// expression, found by taking this AST node index offset from the containing
609	/// Decl AST node, which points to an `[N:S]T` expression AST node. Next, navigate
610	/// to the len expression.
611	/// The Decl is determined contextually.
612	node_offset_array_type_len: i32,
613	/// The source location points to the sentinel expression of an `[N:S]T`
614	/// expression, found by taking this AST node index offset from the containing
615	/// Decl AST node, which points to an `[N:S]T` expression AST node. Next, navigate
616	/// to the sentinel expression.
617	/// The Decl is determined contextually.
618	node_offset_array_type_sentinel: i32,
619	/// The source location points to the elem expression of an `[N:S]T`
620	/// expression, found by taking this AST node index offset from the containing
621	/// Decl AST node, which points to an `[N:S]T` expression AST node. Next, navigate
622	/// to the elem expression.
623	/// The Decl is determined contextually.
624	node_offset_array_type_elem: i32,
625	/// The source location points to the operand of an unary expression.
626	/// The Decl is determined contextually.
627	node_offset_un_op: i32,
628	/// The source location points to the elem type of a pointer.
629	/// The Decl is determined contextually.
630	node_offset_ptr_elem: i32,
631	/// The source location points to the sentinel of a pointer.
632	/// The Decl is determined contextually.
633	node_offset_ptr_sentinel: i32,
634	/// The source location points to the align expr of a pointer.
635	/// The Decl is determined contextually.
636	node_offset_ptr_align: i32,
637	/// The source location points to the addrspace expr of a pointer.
638	/// The Decl is determined contextually.
639	node_offset_ptr_addrspace: i32,
640	/// The source location points to the bit-offset of a pointer.
641	/// The Decl is determined contextually.
642	node_offset_ptr_bitoffset: i32,
643	/// The source location points to the host size of a pointer.
644	/// The Decl is determined contextually.
645	node_offset_ptr_hostsize: i32,
646	/// The source location points to the tag type of an union or an enum.
647	/// The Decl is determined contextually.
648	node_offset_container_tag: i32,
649	/// The source location points to the default value of a field.
650	/// The Decl is determined contextually.
651	node_offset_field_default: i32,
652	/// The source location points to the type of an array or struct initializer.
653	/// The Decl is determined contextually.
654	node_offset_init_ty: i32,
655	/// The source location points to the LHS of an assignment.
656	/// The Decl is determined contextually.
657	node_offset_store_ptr: i32,
658	/// The source location points to the RHS of an assignment.
659	/// The Decl is determined contextually.
660	node_offset_store_operand: i32,
661	/// The source location points to the operand of a `return` statement, or
662	/// the `return` itself if there is no explicit operand.
663	/// The Decl is determined contextually.
664	node_offset_return_operand: i32,
665	/// The source location points to a for loop input.
666	/// The Decl is determined contextually.
667	for_input: struct {
668	/// Points to the for loop AST node.
669	for_node_offset: i32,
670	/// Picks one of the inputs from the condition.
671	input_index: u32,
672	},
673	/// The source location points to one of the captures of a for loop, found
674	/// by taking this AST node index offset from the containing
675	/// Decl AST node, which points to one of the input nodes of a for loop.
676	/// Next, navigate to the corresponding capture.
677	/// The Decl is determined contextually.
678	for_capture_from_input: i32,
679	/// The source location points to the argument node of a function call.
680	call_arg: struct {
681	decl: DeclIndex,
682	/// Points to the function call AST node.
683	call_node_offset: i32,
684	/// The index of the argument the source location points to.
685	arg_index: u32,
686	},
687	fn_proto_param: struct {
688	decl: DeclIndex,
689	/// Points to the function prototype AST node.
690	fn_proto_node_offset: i32,
691	/// The index of the parameter the source location points to.
692	param_index: u32,
693	},
694	array_cat_lhs: ArrayCat,
695	array_cat_rhs: ArrayCat,
696
697	const ArrayCat = struct {
698	/// Points to the array concat AST node.
699	array_cat_offset: i32,
700	/// The index of the element the source location points to.
701	elem_index: u32,
702	};
703
704	pub const nodeOffset = if (TracedOffset.want_tracing) nodeOffsetDebug else nodeOffsetRelease;
705
706	noinline fn nodeOffsetDebug(node_offset: i32) LazySrcLoc {
707	var result: LazySrcLoc = .{ .node_offset = .{ .x = node_offset } };
708	result.node_offset.trace.addAddr(@returnAddress(), "init");
709	return result;
710	}
711
712	fn nodeOffsetRelease(node_offset: i32) LazySrcLoc {
713	return .{ .node_offset = .{ .x = node_offset } };
714	}
715
716	/// This wraps a simple integer in debug builds so that later on we can find out
717	/// where in semantic analysis the value got set.
718	pub const TracedOffset = struct {
719	x: i32,
720	trace: std.debug.Trace = std.debug.Trace.init,
721
722	const want_tracing = false;
723	};
724	};
725
726	const std = @import("std.zig");	353	const std = @import("std.zig");
727	const tokenizer = @import("zig/tokenizer.zig");	354	const tokenizer = @import("zig/tokenizer.zig");
728	const assert = std.debug.assert;	355	const assert = std.debug.assert;

lib/std/zig/Zir.zig-61

 @@ -20,7 +20,6 @@ const BigIntMutable = std.math.big.int.Mutable;
 const Ast = std.zig.Ast;
 const Zir = @This();
-const LazySrcLoc = std.zig.LazySrcLoc;
 instructions: std.MultiArrayList(Inst).Slice,
 /// In order to store references to strings in fewer bytes, we copy all
 @@ -2221,10 +2220,6 @@ pub const Inst = struct {
             src_node: i32,
             /// The meaning of this operand depends on the corresponding `Tag`.
             operand: Ref,
-            pub fn src(self: @This()) LazySrcLoc {
-                return LazySrcLoc.nodeOffset(self.src_node);
-            }
         },
         /// Used for unary operators, with a token source location.
         un_tok: struct {
 @@ -2232,10 +2227,6 @@ pub const Inst = struct {
             src_tok: Ast.TokenIndex,
             /// The meaning of this operand depends on the corresponding `Tag`.
             operand: Ref,
-            pub fn src(self: @This()) LazySrcLoc {
-                return .{ .token_offset = self.src_tok };
-            }
         },
         pl_node: struct {
             /// Offset from Decl AST node index.
 @@ -2244,10 +2235,6 @@ pub const Inst = struct {
             /// index into extra.
             /// `Tag` determines what lives there.
             payload_index: u32,
-            pub fn src(self: @This()) LazySrcLoc {
-                return LazySrcLoc.nodeOffset(self.src_node);
-            }
         },
         pl_tok: struct {
             /// Offset from Decl AST token index.
 @@ -2255,10 +2242,6 @@ pub const Inst = struct {
             /// index into extra.
             /// `Tag` determines what lives there.
             payload_index: u32,
-            pub fn src(self: @This()) LazySrcLoc {
-                return .{ .token_offset = self.src_tok };
-            }
         },
         bin: Bin,
         /// For strings which may contain null bytes.
 @@ -2281,10 +2264,6 @@ pub const Inst = struct {
             pub fn get(self: @This(), code: Zir) [:0]const u8 {
                 return code.nullTerminatedString(self.start);
             }
-            pub fn src(self: @This()) LazySrcLoc {
-                return .{ .token_offset = self.src_tok };
-            }
         },
         /// Offset from Decl AST token index.
         tok: Ast.TokenIndex,
 @@ -2313,19 +2292,11 @@ pub const Inst = struct {
             src_node: i32,
             signedness: std.builtin.Signedness,
             bit_count: u16,
-            pub fn src(self: @This()) LazySrcLoc {
-                return LazySrcLoc.nodeOffset(self.src_node);
-            }
         },
         @"unreachable": struct {
             /// Offset from Decl AST node index.
             /// `Tag` determines which kind of AST node this points to.
             src_node: i32,
-            pub fn src(self: @This()) LazySrcLoc {
-                return LazySrcLoc.nodeOffset(self.src_node);
-            }
         },
         @"break": struct {
             operand: Ref,
 @@ -2339,10 +2310,6 @@ pub const Inst = struct {
             src_node: i32,
             /// The meaning of this operand depends on the corresponding `Tag`.
             inst: Index,
-            pub fn src(self: @This()) LazySrcLoc {
-                return LazySrcLoc.nodeOffset(self.src_node);
-            }
         },
         str_op: struct {
             /// Offset into `string_bytes`. Null-terminated.
 @@ -2375,10 +2342,6 @@ pub const Inst = struct {
             src_node: Ast.Node.Index,
             /// index into extra to a `Declaration` payload.
             payload_index: u32,
-            pub fn src(self: @This()) LazySrcLoc {
-                return .{ .node_abs = self.src_node };
-            }
         },
         // Make sure we don't accidentally add a field to make this union
 @@ -3032,10 +2995,6 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
-        pub fn src(self: StructDecl) LazySrcLoc {
-            return .{ .node_abs = self.src_node };
-        }
         pub const Small = packed struct {
             has_captures_len: bool,
             has_fields_len: bool,
 @@ -3165,10 +3124,6 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
-        pub fn src(self: EnumDecl) LazySrcLoc {
-            return .{ .node_abs = self.src_node };
-        }
         pub const Small = packed struct {
             has_tag_type: bool,
             has_captures_len: bool,
 @@ -3214,10 +3169,6 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
-        pub fn src(self: UnionDecl) LazySrcLoc {
-            return .{ .node_abs = self.src_node };
-        }
         pub const Small = packed struct {
             has_tag_type: bool,
             has_captures_len: bool,
 @@ -3247,10 +3198,6 @@ pub const Inst = struct {
         /// This node provides a new absolute baseline node for all instructions within this struct.
         src_node: Ast.Node.Index,
-        pub fn src(self: OpaqueDecl) LazySrcLoc {
-            return .{ .node_abs = self.src_node };
-        }
         pub const Small = packed struct {
             has_captures_len: bool,
             has_decls_len: bool,
 @@ -3367,10 +3314,6 @@ pub const Inst = struct {
         parent_ptr_type: Ref,
         field_name: Ref,
         field_ptr: Ref,
-        pub fn src(self: FieldParentPtr) LazySrcLoc {
-            return LazySrcLoc.nodeOffset(self.src_node);
-        }
     };
     pub const Shuffle = struct {
 @@ -3520,10 +3463,6 @@ pub const Inst = struct {
         block: Ref,
         /// If `.none`, restore unconditionally.
         operand: Ref,
-        pub fn src(self: RestoreErrRetIndex) LazySrcLoc {
-            return LazySrcLoc.nodeOffset(self.src_node);
-        }
     };
 };

src/InternPool.zig+21-2

...	@@ -391,8 +391,27 @@ pub const RuntimeIndex = enum(u32) {	...	@@ -391,8 +391,27 @@ pub const RuntimeIndex = enum(u32) {
391		391
392	pub const ComptimeAllocIndex = enum(u32) { _ };	392	pub const ComptimeAllocIndex = enum(u32) { _ };
393		393
394	pub const DeclIndex = std.zig.DeclIndex;	394	pub const DeclIndex = enum(u32) {
395	pub const OptionalDeclIndex = std.zig.OptionalDeclIndex;	395	_,
		396
		397	pub fn toOptional(i: DeclIndex) OptionalDeclIndex {
		398	return @enumFromInt(@intFromEnum(i));
		399	}
		400	};
		401
		402	pub const OptionalDeclIndex = enum(u32) {
		403	none = std.math.maxInt(u32),
		404	_,
		405
		406	pub fn init(oi: ?DeclIndex) OptionalDeclIndex {
		407	return @enumFromInt(@intFromEnum(oi orelse return .none));
		408	}
		409
		410	pub fn unwrap(oi: OptionalDeclIndex) ?DeclIndex {
		411	if (oi == .none) return null;
		412	return @enumFromInt(@intFromEnum(oi));
		413	}
		414	};
396		415
397	pub const NamespaceIndex = enum(u32) {	416	pub const NamespaceIndex = enum(u32) {
398	_,	417	_,

src/Module.zig+351-1

...	@@ -13,7 +13,6 @@ const BigIntConst = std.math.big.int.Const;	...	@@ -13,7 +13,6 @@ const BigIntConst = std.math.big.int.Const;
13	const BigIntMutable = std.math.big.int.Mutable;	13	const BigIntMutable = std.math.big.int.Mutable;
14	const Target = std.Target;	14	const Target = std.Target;
15	const Ast = std.zig.Ast;	15	const Ast = std.zig.Ast;
16	const LazySrcLoc = std.zig.LazySrcLoc;
17		16
18	/// Deprecated, use `Zcu`.	17	/// Deprecated, use `Zcu`.
19	const Module = Zcu;	18	const Module = Zcu;
...	@@ -1905,6 +1904,357 @@ pub const SrcLoc = struct {	...	@@ -1905,6 +1904,357 @@ pub const SrcLoc = struct {
1905	}	1904	}
1906	};	1905	};
1907		1906
		1907	/// Resolving a source location into a byte offset may require doing work
		1908	/// that we would rather not do unless the error actually occurs.
		1909	/// Therefore we need a data structure that contains the information necessary
		1910	/// to lazily produce a `SrcLoc` as required.
		1911	/// Most of the offsets in this data structure are relative to the containing Decl.
		1912	/// This makes the source location resolve properly even when a Decl gets
		1913	/// shifted up or down in the file, as long as the Decl's contents itself
		1914	/// do not change.
		1915	pub const LazySrcLoc = union(enum) {
		1916	/// When this tag is set, the code that constructed this `LazySrcLoc` is asserting
		1917	/// that all code paths which would need to resolve the source location are
		1918	/// unreachable. If you are debugging this tag incorrectly being this value,
		1919	/// look into using reverse-continue with a memory watchpoint to see where the
		1920	/// value is being set to this tag.
		1921	unneeded,
		1922	/// Means the source location points to an entire file; not any particular
		1923	/// location within the file. `file_scope` union field will be active.
		1924	entire_file,
		1925	/// The source location points to a byte offset within a source file,
		1926	/// offset from 0. The source file is determined contextually.
		1927	/// Inside a `SrcLoc`, the `file_scope` union field will be active.
		1928	byte_abs: u32,
		1929	/// The source location points to a token within a source file,
		1930	/// offset from 0. The source file is determined contextually.
		1931	/// Inside a `SrcLoc`, the `file_scope` union field will be active.
		1932	token_abs: u32,
		1933	/// The source location points to an AST node within a source file,
		1934	/// offset from 0. The source file is determined contextually.
		1935	/// Inside a `SrcLoc`, the `file_scope` union field will be active.
		1936	node_abs: u32,
		1937	/// The source location points to a byte offset within a source file,
		1938	/// offset from the byte offset of the Decl within the file.
		1939	/// The Decl is determined contextually.
		1940	byte_offset: u32,
		1941	/// This data is the offset into the token list from the Decl token.
		1942	/// The Decl is determined contextually.
		1943	token_offset: u32,
		1944	/// The source location points to an AST node, which is this value offset
		1945	/// from its containing Decl node AST index.
		1946	/// The Decl is determined contextually.
		1947	node_offset: TracedOffset,
		1948	/// The source location points to the main token of an AST node, found
		1949	/// by taking this AST node index offset from the containing Decl AST node.
		1950	/// The Decl is determined contextually.
		1951	node_offset_main_token: i32,
		1952	/// The source location points to the beginning of a struct initializer.
		1953	/// The Decl is determined contextually.
		1954	node_offset_initializer: i32,
		1955	/// The source location points to a variable declaration type expression,
		1956	/// found by taking this AST node index offset from the containing
		1957	/// Decl AST node, which points to a variable declaration AST node. Next, navigate
		1958	/// to the type expression.
		1959	/// The Decl is determined contextually.
		1960	node_offset_var_decl_ty: i32,
		1961	/// The source location points to the alignment expression of a var decl.
		1962	/// The Decl is determined contextually.
		1963	node_offset_var_decl_align: i32,
		1964	/// The source location points to the linksection expression of a var decl.
		1965	/// The Decl is determined contextually.
		1966	node_offset_var_decl_section: i32,
		1967	/// The source location points to the addrspace expression of a var decl.
		1968	/// The Decl is determined contextually.
		1969	node_offset_var_decl_addrspace: i32,
		1970	/// The source location points to the initializer of a var decl.
		1971	/// The Decl is determined contextually.
		1972	node_offset_var_decl_init: i32,
		1973	/// The source location points to the first parameter of a builtin
		1974	/// function call, found by taking this AST node index offset from the containing
		1975	/// Decl AST node, which points to a builtin call AST node. Next, navigate
		1976	/// to the first parameter.
		1977	/// The Decl is determined contextually.
		1978	node_offset_builtin_call_arg0: i32,
		1979	/// Same as `node_offset_builtin_call_arg0` except arg index 1.
		1980	node_offset_builtin_call_arg1: i32,
		1981	node_offset_builtin_call_arg2: i32,
		1982	node_offset_builtin_call_arg3: i32,
		1983	node_offset_builtin_call_arg4: i32,
		1984	node_offset_builtin_call_arg5: i32,
		1985	/// Like `node_offset_builtin_call_arg0` but recurses through arbitrarily many calls
		1986	/// to pointer cast builtins.
		1987	node_offset_ptrcast_operand: i32,
		1988	/// The source location points to the index expression of an array access
		1989	/// expression, found by taking this AST node index offset from the containing
		1990	/// Decl AST node, which points to an array access AST node. Next, navigate
		1991	/// to the index expression.
		1992	/// The Decl is determined contextually.
		1993	node_offset_array_access_index: i32,
		1994	/// The source location points to the LHS of a slice expression
		1995	/// expression, found by taking this AST node index offset from the containing
		1996	/// Decl AST node, which points to a slice AST node. Next, navigate
		1997	/// to the sentinel expression.
		1998	/// The Decl is determined contextually.
		1999	node_offset_slice_ptr: i32,
		2000	/// The source location points to start expression of a slice expression
		2001	/// expression, found by taking this AST node index offset from the containing
		2002	/// Decl AST node, which points to a slice AST node. Next, navigate
		2003	/// to the sentinel expression.
		2004	/// The Decl is determined contextually.
		2005	node_offset_slice_start: i32,
		2006	/// The source location points to the end expression of a slice
		2007	/// expression, found by taking this AST node index offset from the containing
		2008	/// Decl AST node, which points to a slice AST node. Next, navigate
		2009	/// to the sentinel expression.
		2010	/// The Decl is determined contextually.
		2011	node_offset_slice_end: i32,
		2012	/// The source location points to the sentinel expression of a slice
		2013	/// expression, found by taking this AST node index offset from the containing
		2014	/// Decl AST node, which points to a slice AST node. Next, navigate
		2015	/// to the sentinel expression.
		2016	/// The Decl is determined contextually.
		2017	node_offset_slice_sentinel: i32,
		2018	/// The source location points to the callee expression of a function
		2019	/// call expression, found by taking this AST node index offset from the containing
		2020	/// Decl AST node, which points to a function call AST node. Next, navigate
		2021	/// to the callee expression.
		2022	/// The Decl is determined contextually.
		2023	node_offset_call_func: i32,
		2024	/// The payload is offset from the containing Decl AST node.
		2025	/// The source location points to the field name of:
		2026	/// * a field access expression (`a.b`), or
		2027	/// * the callee of a method call (`a.b()`)
		2028	/// The Decl is determined contextually.
		2029	node_offset_field_name: i32,
		2030	/// The payload is offset from the containing Decl AST node.
		2031	/// The source location points to the field name of the operand ("b" node)
		2032	/// of a field initialization expression (`.a = b`)
		2033	/// The Decl is determined contextually.
		2034	node_offset_field_name_init: i32,
		2035	/// The source location points to the pointer of a pointer deref expression,
		2036	/// found by taking this AST node index offset from the containing
		2037	/// Decl AST node, which points to a pointer deref AST node. Next, navigate
		2038	/// to the pointer expression.
		2039	/// The Decl is determined contextually.
		2040	node_offset_deref_ptr: i32,
		2041	/// The source location points to the assembly source code of an inline assembly
		2042	/// expression, found by taking this AST node index offset from the containing
		2043	/// Decl AST node, which points to inline assembly AST node. Next, navigate
		2044	/// to the asm template source code.
		2045	/// The Decl is determined contextually.
		2046	node_offset_asm_source: i32,
		2047	/// The source location points to the return type of an inline assembly
		2048	/// expression, found by taking this AST node index offset from the containing
		2049	/// Decl AST node, which points to inline assembly AST node. Next, navigate
		2050	/// to the return type expression.
		2051	/// The Decl is determined contextually.
		2052	node_offset_asm_ret_ty: i32,
		2053	/// The source location points to the condition expression of an if
		2054	/// expression, found by taking this AST node index offset from the containing
		2055	/// Decl AST node, which points to an if expression AST node. Next, navigate
		2056	/// to the condition expression.
		2057	/// The Decl is determined contextually.
		2058	node_offset_if_cond: i32,
		2059	/// The source location points to a binary expression, such as `a + b`, found
		2060	/// by taking this AST node index offset from the containing Decl AST node.
		2061	/// The Decl is determined contextually.
		2062	node_offset_bin_op: i32,
		2063	/// The source location points to the LHS of a binary expression, found
		2064	/// by taking this AST node index offset from the containing Decl AST node,
		2065	/// which points to a binary expression AST node. Next, navigate to the LHS.
		2066	/// The Decl is determined contextually.
		2067	node_offset_bin_lhs: i32,
		2068	/// The source location points to the RHS of a binary expression, found
		2069	/// by taking this AST node index offset from the containing Decl AST node,
		2070	/// which points to a binary expression AST node. Next, navigate to the RHS.
		2071	/// The Decl is determined contextually.
		2072	node_offset_bin_rhs: i32,
		2073	/// The source location points to the operand of a switch expression, found
		2074	/// by taking this AST node index offset from the containing Decl AST node,
		2075	/// which points to a switch expression AST node. Next, navigate to the operand.
		2076	/// The Decl is determined contextually.
		2077	node_offset_switch_operand: i32,
		2078	/// The source location points to the else/`_` prong of a switch expression, found
		2079	/// by taking this AST node index offset from the containing Decl AST node,
		2080	/// which points to a switch expression AST node. Next, navigate to the else/`_` prong.
		2081	/// The Decl is determined contextually.
		2082	node_offset_switch_special_prong: i32,
		2083	/// The source location points to all the ranges of a switch expression, found
		2084	/// by taking this AST node index offset from the containing Decl AST node,
		2085	/// which points to a switch expression AST node. Next, navigate to any of the
		2086	/// range nodes. The error applies to all of them.
		2087	/// The Decl is determined contextually.
		2088	node_offset_switch_range: i32,
		2089	/// The source location points to the capture of a switch_prong.
		2090	/// The Decl is determined contextually.
		2091	node_offset_switch_prong_capture: i32,
		2092	/// The source location points to the tag capture of a switch_prong.
		2093	/// The Decl is determined contextually.
		2094	node_offset_switch_prong_tag_capture: i32,
		2095	/// The source location points to the align expr of a function type
		2096	/// expression, found by taking this AST node index offset from the containing
		2097	/// Decl AST node, which points to a function type AST node. Next, navigate to
		2098	/// the calling convention node.
		2099	/// The Decl is determined contextually.
		2100	node_offset_fn_type_align: i32,
		2101	/// The source location points to the addrspace expr of a function type
		2102	/// expression, found by taking this AST node index offset from the containing
		2103	/// Decl AST node, which points to a function type AST node. Next, navigate to
		2104	/// the calling convention node.
		2105	/// The Decl is determined contextually.
		2106	node_offset_fn_type_addrspace: i32,
		2107	/// The source location points to the linksection expr of a function type
		2108	/// expression, found by taking this AST node index offset from the containing
		2109	/// Decl AST node, which points to a function type AST node. Next, navigate to
		2110	/// the calling convention node.
		2111	/// The Decl is determined contextually.
		2112	node_offset_fn_type_section: i32,
		2113	/// The source location points to the calling convention of a function type
		2114	/// expression, found by taking this AST node index offset from the containing
		2115	/// Decl AST node, which points to a function type AST node. Next, navigate to
		2116	/// the calling convention node.
		2117	/// The Decl is determined contextually.
		2118	node_offset_fn_type_cc: i32,
		2119	/// The source location points to the return type of a function type
		2120	/// expression, found by taking this AST node index offset from the containing
		2121	/// Decl AST node, which points to a function type AST node. Next, navigate to
		2122	/// the return type node.
		2123	/// The Decl is determined contextually.
		2124	node_offset_fn_type_ret_ty: i32,
		2125	node_offset_param: i32,
		2126	token_offset_param: i32,
		2127	/// The source location points to the type expression of an `anyframe->T`
		2128	/// expression, found by taking this AST node index offset from the containing
		2129	/// Decl AST node, which points to a `anyframe->T` expression AST node. Next, navigate
		2130	/// to the type expression.
		2131	/// The Decl is determined contextually.
		2132	node_offset_anyframe_type: i32,
		2133	/// The source location points to the string literal of `extern "foo"`, found
		2134	/// by taking this AST node index offset from the containing
		2135	/// Decl AST node, which points to a function prototype or variable declaration
		2136	/// expression AST node. Next, navigate to the string literal of the `extern "foo"`.
		2137	/// The Decl is determined contextually.
		2138	node_offset_lib_name: i32,
		2139	/// The source location points to the len expression of an `[N:S]T`
		2140	/// expression, found by taking this AST node index offset from the containing
		2141	/// Decl AST node, which points to an `[N:S]T` expression AST node. Next, navigate
		2142	/// to the len expression.
		2143	/// The Decl is determined contextually.
		2144	node_offset_array_type_len: i32,
		2145	/// The source location points to the sentinel expression of an `[N:S]T`
		2146	/// expression, found by taking this AST node index offset from the containing
		2147	/// Decl AST node, which points to an `[N:S]T` expression AST node. Next, navigate
		2148	/// to the sentinel expression.
		2149	/// The Decl is determined contextually.
		2150	node_offset_array_type_sentinel: i32,
		2151	/// The source location points to the elem expression of an `[N:S]T`
		2152	/// expression, found by taking this AST node index offset from the containing
		2153	/// Decl AST node, which points to an `[N:S]T` expression AST node. Next, navigate
		2154	/// to the elem expression.
		2155	/// The Decl is determined contextually.
		2156	node_offset_array_type_elem: i32,
		2157	/// The source location points to the operand of an unary expression.
		2158	/// The Decl is determined contextually.
		2159	node_offset_un_op: i32,
		2160	/// The source location points to the elem type of a pointer.
		2161	/// The Decl is determined contextually.
		2162	node_offset_ptr_elem: i32,
		2163	/// The source location points to the sentinel of a pointer.
		2164	/// The Decl is determined contextually.
		2165	node_offset_ptr_sentinel: i32,
		2166	/// The source location points to the align expr of a pointer.
		2167	/// The Decl is determined contextually.
		2168	node_offset_ptr_align: i32,
		2169	/// The source location points to the addrspace expr of a pointer.
		2170	/// The Decl is determined contextually.
		2171	node_offset_ptr_addrspace: i32,
		2172	/// The source location points to the bit-offset of a pointer.
		2173	/// The Decl is determined contextually.
		2174	node_offset_ptr_bitoffset: i32,
		2175	/// The source location points to the host size of a pointer.
		2176	/// The Decl is determined contextually.
		2177	node_offset_ptr_hostsize: i32,
		2178	/// The source location points to the tag type of an union or an enum.
		2179	/// The Decl is determined contextually.
		2180	node_offset_container_tag: i32,
		2181	/// The source location points to the default value of a field.
		2182	/// The Decl is determined contextually.
		2183	node_offset_field_default: i32,
		2184	/// The source location points to the type of an array or struct initializer.
		2185	/// The Decl is determined contextually.
		2186	node_offset_init_ty: i32,
		2187	/// The source location points to the LHS of an assignment.
		2188	/// The Decl is determined contextually.
		2189	node_offset_store_ptr: i32,
		2190	/// The source location points to the RHS of an assignment.
		2191	/// The Decl is determined contextually.
		2192	node_offset_store_operand: i32,
		2193	/// The source location points to the operand of a `return` statement, or
		2194	/// the `return` itself if there is no explicit operand.
		2195	/// The Decl is determined contextually.
		2196	node_offset_return_operand: i32,
		2197	/// The source location points to a for loop input.
		2198	/// The Decl is determined contextually.
		2199	for_input: struct {
		2200	/// Points to the for loop AST node.
		2201	for_node_offset: i32,
		2202	/// Picks one of the inputs from the condition.
		2203	input_index: u32,
		2204	},
		2205	/// The source location points to one of the captures of a for loop, found
		2206	/// by taking this AST node index offset from the containing
		2207	/// Decl AST node, which points to one of the input nodes of a for loop.
		2208	/// Next, navigate to the corresponding capture.
		2209	/// The Decl is determined contextually.
		2210	for_capture_from_input: i32,
		2211	/// The source location points to the argument node of a function call.
		2212	call_arg: struct {
		2213	decl: Decl.Index,
		2214	/// Points to the function call AST node.
		2215	call_node_offset: i32,
		2216	/// The index of the argument the source location points to.
		2217	arg_index: u32,
		2218	},
		2219	fn_proto_param: struct {
		2220	decl: Decl.Index,
		2221	/// Points to the function prototype AST node.
		2222	fn_proto_node_offset: i32,
		2223	/// The index of the parameter the source location points to.
		2224	param_index: u32,
		2225	},
		2226	array_cat_lhs: ArrayCat,
		2227	array_cat_rhs: ArrayCat,
		2228
		2229	const ArrayCat = struct {
		2230	/// Points to the array concat AST node.
		2231	array_cat_offset: i32,
		2232	/// The index of the element the source location points to.
		2233	elem_index: u32,
		2234	};
		2235
		2236	pub const nodeOffset = if (TracedOffset.want_tracing) nodeOffsetDebug else nodeOffsetRelease;
		2237
		2238	noinline fn nodeOffsetDebug(node_offset: i32) LazySrcLoc {
		2239	var result: LazySrcLoc = .{ .node_offset = .{ .x = node_offset } };
		2240	result.node_offset.trace.addAddr(@returnAddress(), "init");
		2241	return result;
		2242	}
		2243
		2244	fn nodeOffsetRelease(node_offset: i32) LazySrcLoc {
		2245	return .{ .node_offset = .{ .x = node_offset } };
		2246	}
		2247
		2248	/// This wraps a simple integer in debug builds so that later on we can find out
		2249	/// where in semantic analysis the value got set.
		2250	pub const TracedOffset = struct {
		2251	x: i32,
		2252	trace: std.debug.Trace = std.debug.Trace.init,
		2253
		2254	const want_tracing = false;
		2255	};
		2256	};
		2257
1908	pub const SemaError = error{ OutOfMemory, AnalysisFail };	2258	pub const SemaError = error{ OutOfMemory, AnalysisFail };
1909	pub const CompileError = error{	2259	pub const CompileError = error{
1910	OutOfMemory,	2260	OutOfMemory,

src/Sema.zig+183-165

src/Sema/comptime_ptr_access.zig+2-1

...	@@ -1048,7 +1048,6 @@ fn checkComptimeVarStore(	...	@@ -1048,7 +1048,6 @@ fn checkComptimeVarStore(
1048	const std = @import("std");	1048	const std = @import("std");
1049	const assert = std.debug.assert;	1049	const assert = std.debug.assert;
1050	const Allocator = std.mem.Allocator;	1050	const Allocator = std.mem.Allocator;
1051	const LazySrcLoc = std.zig.LazySrcLoc;
1052		1051
1053	const InternPool = @import("../InternPool.zig");	1052	const InternPool = @import("../InternPool.zig");
1054	const ComptimeAllocIndex = InternPool.ComptimeAllocIndex;	1053	const ComptimeAllocIndex = InternPool.ComptimeAllocIndex;
...	@@ -1057,3 +1056,5 @@ const Block = Sema.Block;	...	@@ -1057,3 +1056,5 @@ const Block = Sema.Block;
1057	const MutableValue = @import("../mutable_value.zig").MutableValue;	1056	const MutableValue = @import("../mutable_value.zig").MutableValue;
1058	const Type = @import("../type.zig").Type;	1057	const Type = @import("../type.zig").Type;
1059	const Value = @import("../Value.zig");	1058	const Value = @import("../Value.zig");
		1059	const Zcu = @import("../Module.zig");
		1060	const LazySrcLoc = Zcu.LazySrcLoc;

src/arch/wasm/CodeGen.zig+1-1

...	@@ -16,7 +16,7 @@ const Decl = Module.Decl;	...	@@ -16,7 +16,7 @@ const Decl = Module.Decl;
16	const Type = @import("../../type.zig").Type;	16	const Type = @import("../../type.zig").Type;
17	const Value = @import("../../Value.zig");	17	const Value = @import("../../Value.zig");
18	const Compilation = @import("../../Compilation.zig");	18	const Compilation = @import("../../Compilation.zig");
19	const LazySrcLoc = std.zig.LazySrcLoc;	19	const LazySrcLoc = Module.LazySrcLoc;
20	const link = @import("../../link.zig");	20	const link = @import("../../link.zig");
21	const Air = @import("../../Air.zig");	21	const Air = @import("../../Air.zig");
22	const Liveness = @import("../../Liveness.zig");	22	const Liveness = @import("../../Liveness.zig");

src/codegen/c.zig+1-1

...	@@ -13,7 +13,7 @@ const Type = @import("../type.zig").Type;	...	@@ -13,7 +13,7 @@ const Type = @import("../type.zig").Type;
13	const C = link.File.C;	13	const C = link.File.C;
14	const Decl = Zcu.Decl;	14	const Decl = Zcu.Decl;
15	const trace = @import("../tracy.zig").trace;	15	const trace = @import("../tracy.zig").trace;
16	const LazySrcLoc = std.zig.LazySrcLoc;	16	const LazySrcLoc = Zcu.LazySrcLoc;
17	const Air = @import("../Air.zig");	17	const Air = @import("../Air.zig");
18	const Liveness = @import("../Liveness.zig");	18	const Liveness = @import("../Liveness.zig");
19	const InternPool = @import("../InternPool.zig");	19	const InternPool = @import("../InternPool.zig");

src/codegen/c/Type.zig+1-1

 @@ -2581,8 +2581,8 @@ pub const AlignAs = packed struct {
 const Alignment = @import("../../InternPool.zig").Alignment;
 const assert = std.debug.assert;
 const CType = @This();
-const DeclIndex = std.zig.DeclIndex;
 const Module = @import("../../Package/Module.zig");
 const std = @import("std");
 const Type = @import("../../type.zig").Type;
 const Zcu = @import("../../Module.zig");
+const DeclIndex = @import("../../InternPool.zig").DeclIndex;

src/codegen/llvm.zig+1-1

...	@@ -22,7 +22,7 @@ const Air = @import("../Air.zig");	...	@@ -22,7 +22,7 @@ const Air = @import("../Air.zig");
22	const Liveness = @import("../Liveness.zig");	22	const Liveness = @import("../Liveness.zig");
23	const Value = @import("../Value.zig");	23	const Value = @import("../Value.zig");
24	const Type = @import("../type.zig").Type;	24	const Type = @import("../type.zig").Type;
25	const LazySrcLoc = std.zig.LazySrcLoc;	25	const LazySrcLoc = Zcu.LazySrcLoc;
26	const x86_64_abi = @import("../arch/x86_64/abi.zig");	26	const x86_64_abi = @import("../arch/x86_64/abi.zig");
27	const wasm_c_abi = @import("../arch/wasm/abi.zig");	27	const wasm_c_abi = @import("../arch/wasm/abi.zig");
28	const aarch64_c_abi = @import("../arch/aarch64/abi.zig");	28	const aarch64_c_abi = @import("../arch/aarch64/abi.zig");

src/codegen/spirv.zig+1-1

...	@@ -9,7 +9,7 @@ const Module = @import("../Module.zig");	...	@@ -9,7 +9,7 @@ const Module = @import("../Module.zig");
9	const Decl = Module.Decl;	9	const Decl = Module.Decl;
10	const Type = @import("../type.zig").Type;	10	const Type = @import("../type.zig").Type;
11	const Value = @import("../Value.zig");	11	const Value = @import("../Value.zig");
12	const LazySrcLoc = std.zig.LazySrcLoc;	12	const LazySrcLoc = Module.LazySrcLoc;
13	const Air = @import("../Air.zig");	13	const Air = @import("../Air.zig");
14	const Liveness = @import("../Liveness.zig");	14	const Liveness = @import("../Liveness.zig");
15	const InternPool = @import("../InternPool.zig");	15	const InternPool = @import("../InternPool.zig");

src/print_zir.zig+70-71

...	@@ -6,8 +6,9 @@ const Ast = std.zig.Ast;	...	@@ -6,8 +6,9 @@ const Ast = std.zig.Ast;
6	const InternPool = @import("InternPool.zig");	6	const InternPool = @import("InternPool.zig");
7		7
8	const Zir = std.zig.Zir;	8	const Zir = std.zig.Zir;
9	const Module = @import("Module.zig");	9	const Zcu = @import("Module.zig");
10	const LazySrcLoc = std.zig.LazySrcLoc;	10	const Module = Zcu;
		11	const LazySrcLoc = Zcu.LazySrcLoc;
11		12
12	/// Write human-readable, debug formatted ZIR code to a file.	13	/// Write human-readable, debug formatted ZIR code to a file.
13	pub fn renderAsTextToFile(	14	pub fn renderAsTextToFile(
...	@@ -630,7 +631,7 @@ const Writer = struct {	...	@@ -630,7 +631,7 @@ const Writer = struct {
630	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_node;	631	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
631	try self.writeInstRef(stream, inst_data.operand);	632	try self.writeInstRef(stream, inst_data.operand);
632	try stream.writeAll(") ");	633	try stream.writeAll(") ");
633	try self.writeSrc(stream, inst_data.src());	634	try self.writeSrcNode(stream, inst_data.src_node);
634	}	635	}
635		636
636	fn writeUnTok(	637	fn writeUnTok(
...	@@ -641,7 +642,7 @@ const Writer = struct {	...	@@ -641,7 +642,7 @@ const Writer = struct {
641	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;	642	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;
642	try self.writeInstRef(stream, inst_data.operand);	643	try self.writeInstRef(stream, inst_data.operand);
643	try stream.writeAll(") ");	644	try stream.writeAll(") ");
644	try self.writeSrc(stream, inst_data.src());	645	try self.writeSrcTok(stream, inst_data.src_tok);
645	}	646	}
646		647
647	fn writeValidateDestructure(	648	fn writeValidateDestructure(
...	@@ -655,7 +656,7 @@ const Writer = struct {	...	@@ -655,7 +656,7 @@ const Writer = struct {
655	try stream.print(", {d}) (destructure=", .{extra.expect_len});	656	try stream.print(", {d}) (destructure=", .{extra.expect_len});
656	try self.writeSrc(stream, LazySrcLoc.nodeOffset(extra.destructure_node));	657	try self.writeSrc(stream, LazySrcLoc.nodeOffset(extra.destructure_node));
657	try stream.writeAll(") ");	658	try stream.writeAll(") ");
658	try self.writeSrc(stream, inst_data.src());	659	try self.writeSrcNode(stream, inst_data.src_node);
659	}	660	}
660		661
661	fn writeValidateArrayInitTy(	662	fn writeValidateArrayInitTy(
...	@@ -667,7 +668,7 @@ const Writer = struct {	...	@@ -667,7 +668,7 @@ const Writer = struct {
667	const extra = self.code.extraData(Zir.Inst.ArrayInit, inst_data.payload_index).data;	668	const extra = self.code.extraData(Zir.Inst.ArrayInit, inst_data.payload_index).data;
668	try self.writeInstRef(stream, extra.ty);	669	try self.writeInstRef(stream, extra.ty);
669	try stream.print(", {d}) ", .{extra.init_count});	670	try stream.print(", {d}) ", .{extra.init_count});
670	try self.writeSrc(stream, inst_data.src());	671	try self.writeSrcNode(stream, inst_data.src_node);
671	}	672	}
672		673
673	fn writeArrayTypeSentinel(	674	fn writeArrayTypeSentinel(
...	@@ -683,7 +684,7 @@ const Writer = struct {	...	@@ -683,7 +684,7 @@ const Writer = struct {
683	try stream.writeAll(", ");	684	try stream.writeAll(", ");
684	try self.writeInstRef(stream, extra.elem_type);	685	try self.writeInstRef(stream, extra.elem_type);
685	try stream.writeAll(") ");	686	try stream.writeAll(") ");
686	try self.writeSrc(stream, inst_data.src());	687	try self.writeSrcNode(stream, inst_data.src_node);
687	}	688	}
688		689
689	fn writePtrType(	690	fn writePtrType(
...	@@ -763,11 +764,10 @@ const Writer = struct {	...	@@ -763,11 +764,10 @@ const Writer = struct {
763	fn writeFloat128(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	764	fn writeFloat128(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
764	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	765	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
765	const extra = self.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data;	766	const extra = self.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data;
766	const src = inst_data.src();
767	const number = extra.get();	767	const number = extra.get();
768	// TODO improve std.format to be able to print f128 values	768	// TODO improve std.format to be able to print f128 values
769	try stream.print("{d}) ", .{@as(f64, @floatCast(number))});	769	try stream.print("{d}) ", .{@as(f64, @floatCast(number))});
770	try self.writeSrc(stream, src);	770	try self.writeSrcNode(stream, inst_data.src_node);
771	}	771	}
772		772
773	fn writeStr(	773	fn writeStr(
...	@@ -787,7 +787,7 @@ const Writer = struct {	...	@@ -787,7 +787,7 @@ const Writer = struct {
787	try stream.writeAll(", ");	787	try stream.writeAll(", ");
788	try self.writeInstRef(stream, extra.start);	788	try self.writeInstRef(stream, extra.start);
789	try stream.writeAll(") ");	789	try stream.writeAll(") ");
790	try self.writeSrc(stream, inst_data.src());	790	try self.writeSrcNode(stream, inst_data.src_node);
791	}	791	}
792		792
793	fn writeSliceEnd(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	793	fn writeSliceEnd(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -799,7 +799,7 @@ const Writer = struct {	...	@@ -799,7 +799,7 @@ const Writer = struct {
799	try stream.writeAll(", ");	799	try stream.writeAll(", ");
800	try self.writeInstRef(stream, extra.end);	800	try self.writeInstRef(stream, extra.end);
801	try stream.writeAll(") ");	801	try stream.writeAll(") ");
802	try self.writeSrc(stream, inst_data.src());	802	try self.writeSrcNode(stream, inst_data.src_node);
803	}	803	}
804		804
805	fn writeSliceSentinel(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	805	fn writeSliceSentinel(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -813,7 +813,7 @@ const Writer = struct {	...	@@ -813,7 +813,7 @@ const Writer = struct {
813	try stream.writeAll(", ");	813	try stream.writeAll(", ");
814	try self.writeInstRef(stream, extra.sentinel);	814	try self.writeInstRef(stream, extra.sentinel);
815	try stream.writeAll(") ");	815	try stream.writeAll(") ");
816	try self.writeSrc(stream, inst_data.src());	816	try self.writeSrcNode(stream, inst_data.src_node);
817	}	817	}
818		818
819	fn writeSliceLength(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	819	fn writeSliceLength(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -829,7 +829,7 @@ const Writer = struct {	...	@@ -829,7 +829,7 @@ const Writer = struct {
829	try self.writeInstRef(stream, extra.sentinel);	829	try self.writeInstRef(stream, extra.sentinel);
830	}	830	}
831	try stream.writeAll(") ");	831	try stream.writeAll(") ");
832	try self.writeSrc(stream, inst_data.src());	832	try self.writeSrcNode(stream, inst_data.src_node);
833	}	833	}
834		834
835	fn writeUnionInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	835	fn writeUnionInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -841,7 +841,7 @@ const Writer = struct {	...	@@ -841,7 +841,7 @@ const Writer = struct {
841	try stream.writeAll(", ");	841	try stream.writeAll(", ");
842	try self.writeInstRef(stream, extra.init);	842	try self.writeInstRef(stream, extra.init);
843	try stream.writeAll(") ");	843	try stream.writeAll(") ");
844	try self.writeSrc(stream, inst_data.src());	844	try self.writeSrcNode(stream, inst_data.src_node);
845	}	845	}
846		846
847	fn writeShuffle(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	847	fn writeShuffle(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -855,7 +855,7 @@ const Writer = struct {	...	@@ -855,7 +855,7 @@ const Writer = struct {
855	try stream.writeAll(", ");	855	try stream.writeAll(", ");
856	try self.writeInstRef(stream, extra.mask);	856	try self.writeInstRef(stream, extra.mask);
857	try stream.writeAll(") ");	857	try stream.writeAll(") ");
858	try self.writeSrc(stream, inst_data.src());	858	try self.writeSrcNode(stream, inst_data.src_node);
859	}	859	}
860		860
861	fn writeSelect(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {	861	fn writeSelect(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
...	@@ -880,7 +880,7 @@ const Writer = struct {	...	@@ -880,7 +880,7 @@ const Writer = struct {
880	try stream.writeAll(", ");	880	try stream.writeAll(", ");
881	try self.writeInstRef(stream, extra.addend);	881	try self.writeInstRef(stream, extra.addend);
882	try stream.writeAll(") ");	882	try stream.writeAll(") ");
883	try self.writeSrc(stream, inst_data.src());	883	try self.writeSrcNode(stream, inst_data.src_node);
884	}	884	}
885		885
886	fn writeBuiltinCall(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	886	fn writeBuiltinCall(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -896,7 +896,7 @@ const Writer = struct {	...	@@ -896,7 +896,7 @@ const Writer = struct {
896	try stream.writeAll(", ");	896	try stream.writeAll(", ");
897	try self.writeInstRef(stream, extra.args);	897	try self.writeInstRef(stream, extra.args);
898	try stream.writeAll(") ");	898	try stream.writeAll(") ");
899	try self.writeSrc(stream, inst_data.src());	899	try self.writeSrcNode(stream, inst_data.src_node);
900	}	900	}
901		901
902	fn writeFieldParentPtr(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {	902	fn writeFieldParentPtr(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
...	@@ -913,7 +913,7 @@ const Writer = struct {	...	@@ -913,7 +913,7 @@ const Writer = struct {
913	try stream.writeAll(", ");	913	try stream.writeAll(", ");
914	try self.writeInstRef(stream, extra.field_ptr);	914	try self.writeInstRef(stream, extra.field_ptr);
915	try stream.writeAll(") ");	915	try stream.writeAll(") ");
916	try self.writeSrc(stream, extra.src());	916	try self.writeSrcNode(stream, extra.src_node);
917	}	917	}
918		918
919	fn writeBuiltinAsyncCall(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {	919	fn writeBuiltinAsyncCall(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
...	@@ -944,7 +944,7 @@ const Writer = struct {	...	@@ -944,7 +944,7 @@ const Writer = struct {
944	}	944	}
945	try self.writeBracedBody(stream, body);	945	try self.writeBracedBody(stream, body);
946	try stream.writeAll(") ");	946	try stream.writeAll(") ");
947	try self.writeSrc(stream, inst_data.src());	947	try self.writeSrcTok(stream, inst_data.src_tok);
948	}	948	}
949		949
950	fn writePlNodeBin(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	950	fn writePlNodeBin(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -954,7 +954,7 @@ const Writer = struct {	...	@@ -954,7 +954,7 @@ const Writer = struct {
954	try stream.writeAll(", ");	954	try stream.writeAll(", ");
955	try self.writeInstRef(stream, extra.rhs);	955	try self.writeInstRef(stream, extra.rhs);
956	try stream.writeAll(") ");	956	try stream.writeAll(") ");
957	try self.writeSrc(stream, inst_data.src());	957	try self.writeSrcNode(stream, inst_data.src_node);
958	}	958	}
959		959
960	fn writePlNodeMultiOp(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	960	fn writePlNodeMultiOp(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -967,7 +967,7 @@ const Writer = struct {	...	@@ -967,7 +967,7 @@ const Writer = struct {
967	try self.writeInstRef(stream, arg);	967	try self.writeInstRef(stream, arg);
968	}	968	}
969	try stream.writeAll("}) ");	969	try stream.writeAll("}) ");
970	try self.writeSrc(stream, inst_data.src());	970	try self.writeSrcNode(stream, inst_data.src_node);
971	}	971	}
972		972
973	fn writeArrayMul(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	973	fn writeArrayMul(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -979,7 +979,7 @@ const Writer = struct {	...	@@ -979,7 +979,7 @@ const Writer = struct {
979	try stream.writeAll(", ");	979	try stream.writeAll(", ");
980	try self.writeInstRef(stream, extra.rhs);	980	try self.writeInstRef(stream, extra.rhs);
981	try stream.writeAll(") ");	981	try stream.writeAll(") ");
982	try self.writeSrc(stream, inst_data.src());	982	try self.writeSrcNode(stream, inst_data.src_node);
983	}	983	}
984		984
985	fn writeElemValImm(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	985	fn writeElemValImm(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -994,7 +994,7 @@ const Writer = struct {	...	@@ -994,7 +994,7 @@ const Writer = struct {
994		994
995	try self.writeInstRef(stream, extra.ptr);	995	try self.writeInstRef(stream, extra.ptr);
996	try stream.print(", {d}) ", .{extra.index});	996	try stream.print(", {d}) ", .{extra.index});
997	try self.writeSrc(stream, inst_data.src());	997	try self.writeSrcNode(stream, inst_data.src_node);
998	}	998	}
999		999
1000	fn writePlNodeExport(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1000	fn writePlNodeExport(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1006,7 +1006,7 @@ const Writer = struct {	...	@@ -1006,7 +1006,7 @@ const Writer = struct {
1006	try stream.print(", {p}, ", .{std.zig.fmtId(decl_name)});	1006	try stream.print(", {p}, ", .{std.zig.fmtId(decl_name)});
1007	try self.writeInstRef(stream, extra.options);	1007	try self.writeInstRef(stream, extra.options);
1008	try stream.writeAll(") ");	1008	try stream.writeAll(") ");
1009	try self.writeSrc(stream, inst_data.src());	1009	try self.writeSrcNode(stream, inst_data.src_node);
1010	}	1010	}
1011		1011
1012	fn writePlNodeExportValue(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1012	fn writePlNodeExportValue(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1017,7 +1017,7 @@ const Writer = struct {	...	@@ -1017,7 +1017,7 @@ const Writer = struct {
1017	try stream.writeAll(", ");	1017	try stream.writeAll(", ");
1018	try self.writeInstRef(stream, extra.options);	1018	try self.writeInstRef(stream, extra.options);
1019	try stream.writeAll(") ");	1019	try stream.writeAll(") ");
1020	try self.writeSrc(stream, inst_data.src());	1020	try self.writeSrcNode(stream, inst_data.src_node);
1021	}	1021	}
1022		1022
1023	fn writeValidateArrayInitRefTy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1023	fn writeValidateArrayInitRefTy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1027,7 +1027,7 @@ const Writer = struct {	...	@@ -1027,7 +1027,7 @@ const Writer = struct {
1027	try self.writeInstRef(stream, extra.ptr_ty);	1027	try self.writeInstRef(stream, extra.ptr_ty);
1028	try stream.writeAll(", ");	1028	try stream.writeAll(", ");
1029	try stream.print(", {}) ", .{extra.elem_count});	1029	try stream.print(", {}) ", .{extra.elem_count});
1030	try self.writeSrc(stream, inst_data.src());	1030	try self.writeSrcNode(stream, inst_data.src_node);
1031	}	1031	}
1032		1032
1033	fn writeStructInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1033	fn writeStructInit(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1051,7 +1051,7 @@ const Writer = struct {	...	@@ -1051,7 +1051,7 @@ const Writer = struct {
1051	try stream.writeAll("]");	1051	try stream.writeAll("]");
1052	}	1052	}
1053	try stream.writeAll(") ");	1053	try stream.writeAll(") ");
1054	try self.writeSrc(stream, inst_data.src());	1054	try self.writeSrcNode(stream, inst_data.src_node);
1055	}	1055	}
1056		1056
1057	fn writeCmpxchg(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {	1057	fn writeCmpxchg(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
...	@@ -1110,7 +1110,7 @@ const Writer = struct {	...	@@ -1110,7 +1110,7 @@ const Writer = struct {
1110	try stream.writeAll(", ");	1110	try stream.writeAll(", ");
1111	try self.writeInstRef(stream, extra.ordering);	1111	try self.writeInstRef(stream, extra.ordering);
1112	try stream.writeAll(") ");	1112	try stream.writeAll(") ");
1113	try self.writeSrc(stream, inst_data.src());	1113	try self.writeSrcNode(stream, inst_data.src_node);
1114	}	1114	}
1115		1115
1116	fn writeAtomicStore(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1116	fn writeAtomicStore(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1123,7 +1123,7 @@ const Writer = struct {	...	@@ -1123,7 +1123,7 @@ const Writer = struct {
1123	try stream.writeAll(", ");	1123	try stream.writeAll(", ");
1124	try self.writeInstRef(stream, extra.ordering);	1124	try self.writeInstRef(stream, extra.ordering);
1125	try stream.writeAll(") ");	1125	try stream.writeAll(") ");
1126	try self.writeSrc(stream, inst_data.src());	1126	try self.writeSrcNode(stream, inst_data.src_node);
1127	}	1127	}
1128		1128
1129	fn writeAtomicRmw(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1129	fn writeAtomicRmw(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1138,7 +1138,7 @@ const Writer = struct {	...	@@ -1138,7 +1138,7 @@ const Writer = struct {
1138	try stream.writeAll(", ");	1138	try stream.writeAll(", ");
1139	try self.writeInstRef(stream, extra.ordering);	1139	try self.writeInstRef(stream, extra.ordering);
1140	try stream.writeAll(") ");	1140	try stream.writeAll(") ");
1141	try self.writeSrc(stream, inst_data.src());	1141	try self.writeSrcNode(stream, inst_data.src_node);
1142	}	1142	}
1143		1143
1144	fn writeStructInitAnon(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1144	fn writeStructInitAnon(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1159,7 +1159,7 @@ const Writer = struct {	...	@@ -1159,7 +1159,7 @@ const Writer = struct {
1159	try stream.writeAll("]");	1159	try stream.writeAll("]");
1160	}	1160	}
1161	try stream.writeAll(") ");	1161	try stream.writeAll(") ");
1162	try self.writeSrc(stream, inst_data.src());	1162	try self.writeSrcNode(stream, inst_data.src_node);
1163	}	1163	}
1164		1164
1165	fn writeStructInitFieldType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1165	fn writeStructInitFieldType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1168,7 +1168,7 @@ const Writer = struct {	...	@@ -1168,7 +1168,7 @@ const Writer = struct {
1168	try self.writeInstRef(stream, extra.container_type);	1168	try self.writeInstRef(stream, extra.container_type);
1169	const field_name = self.code.nullTerminatedString(extra.name_start);	1169	const field_name = self.code.nullTerminatedString(extra.name_start);
1170	try stream.print(", {s}) ", .{field_name});	1170	try stream.print(", {s}) ", .{field_name});
1171	try self.writeSrc(stream, inst_data.src());	1171	try self.writeSrcNode(stream, inst_data.src_node);
1172	}	1172	}
1173		1173
1174	fn writeFieldTypeRef(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1174	fn writeFieldTypeRef(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1178,7 +1178,7 @@ const Writer = struct {	...	@@ -1178,7 +1178,7 @@ const Writer = struct {
1178	try stream.writeAll(", ");	1178	try stream.writeAll(", ");
1179	try self.writeInstRef(stream, extra.field_name);	1179	try self.writeInstRef(stream, extra.field_name);
1180	try stream.writeAll(") ");	1180	try stream.writeAll(") ");
1181	try self.writeSrc(stream, inst_data.src());	1181	try self.writeSrcNode(stream, inst_data.src_node);
1182	}	1182	}
1183		1183
1184	fn writeNodeMultiOp(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {	1184	fn writeNodeMultiOp(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
...	@@ -1202,7 +1202,7 @@ const Writer = struct {	...	@@ -1202,7 +1202,7 @@ const Writer = struct {
1202	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].inst_node;	1202	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].inst_node;
1203	try self.writeInstIndex(stream, inst_data.inst);	1203	try self.writeInstIndex(stream, inst_data.inst);
1204	try stream.writeAll(") ");	1204	try stream.writeAll(") ");
1205	try self.writeSrc(stream, inst_data.src());	1205	try self.writeSrcNode(stream, inst_data.src_node);
1206	}	1206	}
1207		1207
1208	fn writeAsm(	1208	fn writeAsm(
...	@@ -1347,13 +1347,13 @@ const Writer = struct {	...	@@ -1347,13 +1347,13 @@ const Writer = struct {
1347	}	1347	}
1348		1348
1349	try stream.writeAll("]) ");	1349	try stream.writeAll("]) ");
1350	try self.writeSrc(stream, inst_data.src());	1350	try self.writeSrcNode(stream, inst_data.src_node);
1351	}	1351	}
1352		1352
1353	fn writeBlock(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1353	fn writeBlock(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
1354	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	1354	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
1355	try self.writePlNodeBlockWithoutSrc(stream, inst);	1355	try self.writePlNodeBlockWithoutSrc(stream, inst);
1356	try self.writeSrc(stream, inst_data.src());	1356	try self.writeSrcNode(stream, inst_data.src_node);
1357	}	1357	}
1358		1358
1359	fn writePlNodeBlockWithoutSrc(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1359	fn writePlNodeBlockWithoutSrc(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1375,7 +1375,7 @@ const Writer = struct {	...	@@ -1375,7 +1375,7 @@ const Writer = struct {
1375	try stream.writeAll(", ");	1375	try stream.writeAll(", ");
1376	try self.writeBracedBody(stream, else_body);	1376	try self.writeBracedBody(stream, else_body);
1377	try stream.writeAll(") ");	1377	try stream.writeAll(") ");
1378	try self.writeSrc(stream, inst_data.src());	1378	try self.writeSrcNode(stream, inst_data.src_node);
1379	}	1379	}
1380		1380
1381	fn writeTry(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1381	fn writeTry(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -1386,7 +1386,7 @@ const Writer = struct {	...	@@ -1386,7 +1386,7 @@ const Writer = struct {
1386	try stream.writeAll(", ");	1386	try stream.writeAll(", ");
1387	try self.writeBracedBody(stream, body);	1387	try self.writeBracedBody(stream, body);
1388	try stream.writeAll(") ");	1388	try stream.writeAll(") ");
1389	try self.writeSrc(stream, inst_data.src());	1389	try self.writeSrcNode(stream, inst_data.src_node);
1390	}	1390	}
1391		1391
1392	fn writeStructDecl(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {	1392	fn writeStructDecl(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
...	@@ -1480,7 +1480,7 @@ const Writer = struct {	...	@@ -1480,7 +1480,7 @@ const Writer = struct {
1480	}	1480	}
1481		1481
1482	if (fields_len == 0) {	1482	if (fields_len == 0) {
1483	try stream.writeAll("{}, {})");	1483	try stream.writeAll("{}, {}) ");
1484	} else {	1484	} else {
1485	const bits_per_field = 4;	1485	const bits_per_field = 4;
1486	const fields_per_u32 = 32 / bits_per_field;	1486	const fields_per_u32 = 32 / bits_per_field;
...	@@ -1596,7 +1596,7 @@ const Writer = struct {	...	@@ -1596,7 +1596,7 @@ const Writer = struct {
1596		1596
1597	self.indent -= 2;	1597	self.indent -= 2;
1598	try stream.writeByteNTimes(' ', self.indent);	1598	try stream.writeByteNTimes(' ', self.indent);
1599	try stream.writeAll("})");	1599	try stream.writeAll("}) ");
1600	}	1600	}
1601	try self.writeSrcNode(stream, 0);	1601	try self.writeSrcNode(stream, 0);
1602	}	1602	}
...	@@ -1688,7 +1688,7 @@ const Writer = struct {	...	@@ -1688,7 +1688,7 @@ const Writer = struct {
1688	}	1688	}
1689		1689
1690	if (fields_len == 0) {	1690	if (fields_len == 0) {
1691	try stream.writeAll("})");	1691	try stream.writeAll("}) ");
1692	try self.writeSrcNode(stream, 0);	1692	try self.writeSrcNode(stream, 0);
1693	return;	1693	return;
1694	}	1694	}
...	@@ -1762,7 +1762,7 @@ const Writer = struct {	...	@@ -1762,7 +1762,7 @@ const Writer = struct {
1762		1762
1763	self.indent -= 2;	1763	self.indent -= 2;
1764	try stream.writeByteNTimes(' ', self.indent);	1764	try stream.writeByteNTimes(' ', self.indent);
1765	try stream.writeAll("})");	1765	try stream.writeAll("}) ");
1766	try self.writeSrcNode(stream, 0);	1766	try self.writeSrcNode(stream, 0);
1767	}	1767	}
1768		1768
...	@@ -1855,7 +1855,7 @@ const Writer = struct {	...	@@ -1855,7 +1855,7 @@ const Writer = struct {
1855		1855
1856	try self.writeBracedDecl(stream, body);	1856	try self.writeBracedDecl(stream, body);
1857	if (fields_len == 0) {	1857	if (fields_len == 0) {
1858	try stream.writeAll(", {})");	1858	try stream.writeAll(", {}) ");
1859	} else {	1859	} else {
1860	try stream.writeAll(", {\n");	1860	try stream.writeAll(", {\n");
1861		1861
...	@@ -1896,7 +1896,7 @@ const Writer = struct {	...	@@ -1896,7 +1896,7 @@ const Writer = struct {
1896	}	1896	}
1897	self.indent -= 2;	1897	self.indent -= 2;
1898	try stream.writeByteNTimes(' ', self.indent);	1898	try stream.writeByteNTimes(' ', self.indent);
1899	try stream.writeAll("})");	1899	try stream.writeAll("}) ");
1900	}	1900	}
1901	try self.writeSrcNode(stream, 0);	1901	try self.writeSrcNode(stream, 0);
1902	}	1902	}
...	@@ -1944,14 +1944,14 @@ const Writer = struct {	...	@@ -1944,14 +1944,14 @@ const Writer = struct {
1944	}	1944	}
1945		1945
1946	if (decls_len == 0) {	1946	if (decls_len == 0) {
1947	try stream.writeAll("{})");	1947	try stream.writeAll("{}) ");
1948	} else {	1948	} else {
1949	try stream.writeAll("{\n");	1949	try stream.writeAll("{\n");
1950	self.indent += 2;	1950	self.indent += 2;
1951	try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));	1951	try self.writeBody(stream, self.code.bodySlice(extra_index, decls_len));
1952	self.indent -= 2;	1952	self.indent -= 2;
1953	try stream.writeByteNTimes(' ', self.indent);	1953	try stream.writeByteNTimes(' ', self.indent);
1954	try stream.writeAll("})");	1954	try stream.writeAll("}) ");
1955	}	1955	}
1956	try self.writeSrcNode(stream, 0);	1956	try self.writeSrcNode(stream, 0);
1957	}	1957	}
...	@@ -1982,7 +1982,7 @@ const Writer = struct {	...	@@ -1982,7 +1982,7 @@ const Writer = struct {
1982	try stream.writeByteNTimes(' ', self.indent);	1982	try stream.writeByteNTimes(' ', self.indent);
1983	try stream.writeAll("}) ");	1983	try stream.writeAll("}) ");
1984		1984
1985	try self.writeSrc(stream, inst_data.src());	1985	try self.writeSrcNode(stream, inst_data.src_node);
1986	}	1986	}
1987		1987
1988	fn writeSwitchBlockErrUnion(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	1988	fn writeSwitchBlockErrUnion(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2119,7 +2119,7 @@ const Writer = struct {	...	@@ -2119,7 +2119,7 @@ const Writer = struct {
2119	self.indent -= 2;	2119	self.indent -= 2;
2120		2120
2121	try stream.writeAll(") ");	2121	try stream.writeAll(") ");
2122	try self.writeSrc(stream, inst_data.src());	2122	try self.writeSrcNode(stream, inst_data.src_node);
2123	}	2123	}
2124		2124
2125	fn writeSwitchBlock(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2125	fn writeSwitchBlock(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2249,7 +2249,7 @@ const Writer = struct {	...	@@ -2249,7 +2249,7 @@ const Writer = struct {
2249	self.indent -= 2;	2249	self.indent -= 2;
2250		2250
2251	try stream.writeAll(") ");	2251	try stream.writeAll(") ");
2252	try self.writeSrc(stream, inst_data.src());	2252	try self.writeSrcNode(stream, inst_data.src_node);
2253	}	2253	}
2254		2254
2255	fn writePlNodeField(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2255	fn writePlNodeField(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2258,7 +2258,7 @@ const Writer = struct {	...	@@ -2258,7 +2258,7 @@ const Writer = struct {
2258	const name = self.code.nullTerminatedString(extra.field_name_start);	2258	const name = self.code.nullTerminatedString(extra.field_name_start);
2259	try self.writeInstRef(stream, extra.lhs);	2259	try self.writeInstRef(stream, extra.lhs);
2260	try stream.print(", \"{}\") ", .{std.zig.fmtEscapes(name)});	2260	try stream.print(", \"{}\") ", .{std.zig.fmtEscapes(name)});
2261	try self.writeSrc(stream, inst_data.src());	2261	try self.writeSrcNode(stream, inst_data.src_node);
2262	}	2262	}
2263		2263
2264	fn writePlNodeFieldNamed(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2264	fn writePlNodeFieldNamed(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2268,7 +2268,7 @@ const Writer = struct {	...	@@ -2268,7 +2268,7 @@ const Writer = struct {
2268	try stream.writeAll(", ");	2268	try stream.writeAll(", ");
2269	try self.writeInstRef(stream, extra.field_name);	2269	try self.writeInstRef(stream, extra.field_name);
2270	try stream.writeAll(") ");	2270	try stream.writeAll(") ");
2271	try self.writeSrc(stream, inst_data.src());	2271	try self.writeSrcNode(stream, inst_data.src_node);
2272	}	2272	}
2273		2273
2274	fn writeAs(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2274	fn writeAs(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2278,7 +2278,7 @@ const Writer = struct {	...	@@ -2278,7 +2278,7 @@ const Writer = struct {
2278	try stream.writeAll(", ");	2278	try stream.writeAll(", ");
2279	try self.writeInstRef(stream, extra.operand);	2279	try self.writeInstRef(stream, extra.operand);
2280	try stream.writeAll(") ");	2280	try stream.writeAll(") ");
2281	try self.writeSrc(stream, inst_data.src());	2281	try self.writeSrcNode(stream, inst_data.src_node);
2282	}	2282	}
2283		2283
2284	fn writeNode(	2284	fn writeNode(
...	@@ -2300,7 +2300,7 @@ const Writer = struct {	...	@@ -2300,7 +2300,7 @@ const Writer = struct {
2300	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;	2300	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
2301	const str = inst_data.get(self.code);	2301	const str = inst_data.get(self.code);
2302	try stream.print("\"{}\") ", .{std.zig.fmtEscapes(str)});	2302	try stream.print("\"{}\") ", .{std.zig.fmtEscapes(str)});
2303	try self.writeSrc(stream, inst_data.src());	2303	try self.writeSrcTok(stream, inst_data.src_tok);
2304	}	2304	}
2305		2305
2306	fn writeStrOp(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2306	fn writeStrOp(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2317,7 +2317,6 @@ const Writer = struct {	...	@@ -2317,7 +2317,6 @@ const Writer = struct {
2317	inferred_error_set: bool,	2317	inferred_error_set: bool,
2318	) !void {	2318	) !void {
2319	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	2319	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
2320	const src = inst_data.src();
2321	const extra = self.code.extraData(Zir.Inst.Func, inst_data.payload_index);	2320	const extra = self.code.extraData(Zir.Inst.Func, inst_data.payload_index);
2322		2321
2323	var extra_index = extra.end;	2322	var extra_index = extra.end;
...	@@ -2364,7 +2363,7 @@ const Writer = struct {	...	@@ -2364,7 +2363,7 @@ const Writer = struct {
2364	ret_ty_body,	2363	ret_ty_body,
2365		2364
2366	body,	2365	body,
2367	src,	2366	inst_data.src_node,
2368	src_locs,	2367	src_locs,
2369	0,	2368	0,
2370	);	2369	);
...	@@ -2373,7 +2372,6 @@ const Writer = struct {	...	@@ -2373,7 +2372,6 @@ const Writer = struct {
2373	fn writeFuncFancy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2372	fn writeFuncFancy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
2374	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	2373	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
2375	const extra = self.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);	2374	const extra = self.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);
2376	const src = inst_data.src();
2377		2375
2378	var extra_index: usize = extra.end;	2376	var extra_index: usize = extra.end;
2379	var align_ref: Zir.Inst.Ref = .none;	2377	var align_ref: Zir.Inst.Ref = .none;
...	@@ -2470,7 +2468,7 @@ const Writer = struct {	...	@@ -2470,7 +2468,7 @@ const Writer = struct {
2470	ret_ty_ref,	2468	ret_ty_ref,
2471	ret_ty_body,	2469	ret_ty_body,
2472	body,	2470	body,
2473	src,	2471	inst_data.src_node,
2474	src_locs,	2472	src_locs,
2475	noalias_bits,	2473	noalias_bits,
2476	);	2474	);
...	@@ -2551,7 +2549,7 @@ const Writer = struct {	...	@@ -2551,7 +2549,7 @@ const Writer = struct {
2551	try stream.writeAll(", ");	2549	try stream.writeAll(", ");
2552	try self.writeBracedBody(stream, body);	2550	try self.writeBracedBody(stream, body);
2553	try stream.writeAll(") ");	2551	try stream.writeAll(") ");
2554	try self.writeSrc(stream, inst_data.src());	2552	try self.writeSrcNode(stream, inst_data.src_node);
2555	}	2553	}
2556		2554
2557	fn writeIntType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2555	fn writeIntType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2561,7 +2559,7 @@ const Writer = struct {	...	@@ -2561,7 +2559,7 @@ const Writer = struct {
2561	.unsigned => 'u',	2559	.unsigned => 'u',
2562	};	2560	};
2563	try stream.print("{c}{d}) ", .{ prefix, int_type.bit_count });	2561	try stream.print("{c}{d}) ", .{ prefix, int_type.bit_count });
2564	try self.writeSrc(stream, int_type.src());	2562	try self.writeSrcNode(stream, int_type.src_node);
2565	}	2563	}
2566		2564
2567	fn writeSaveErrRetIndex(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2565	fn writeSaveErrRetIndex(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2579,7 +2577,7 @@ const Writer = struct {	...	@@ -2579,7 +2577,7 @@ const Writer = struct {
2579	try self.writeInstRef(stream, extra.operand);	2577	try self.writeInstRef(stream, extra.operand);
2580		2578
2581	try stream.writeAll(") ");	2579	try stream.writeAll(") ");
2582	try self.writeSrc(stream, extra.src());	2580	try self.writeSrcNode(stream, extra.src_node);
2583	}	2581	}
2584		2582
2585	fn writeBreak(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2583	fn writeBreak(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2605,7 +2603,7 @@ const Writer = struct {	...	@@ -2605,7 +2603,7 @@ const Writer = struct {
2605	try self.writeInstRef(stream, arg);	2603	try self.writeInstRef(stream, arg);
2606	}	2604	}
2607	try stream.writeAll("}) ");	2605	try stream.writeAll("}) ");
2608	try self.writeSrc(stream, inst_data.src());	2606	try self.writeSrcNode(stream, inst_data.src_node);
2609	}	2607	}
2610		2608
2611	fn writeArrayInitAnon(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2609	fn writeArrayInitAnon(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2620,7 +2618,7 @@ const Writer = struct {	...	@@ -2620,7 +2618,7 @@ const Writer = struct {
2620	try self.writeInstRef(stream, arg);	2618	try self.writeInstRef(stream, arg);
2621	}	2619	}
2622	try stream.writeAll("}) ");	2620	try stream.writeAll("}) ");
2623	try self.writeSrc(stream, inst_data.src());	2621	try self.writeSrcNode(stream, inst_data.src_node);
2624	}	2622	}
2625		2623
2626	fn writeArrayInitSent(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2624	fn writeArrayInitSent(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2640,13 +2638,13 @@ const Writer = struct {	...	@@ -2640,13 +2638,13 @@ const Writer = struct {
2640	try self.writeInstRef(stream, elem);	2638	try self.writeInstRef(stream, elem);
2641	}	2639	}
2642	try stream.writeAll("}) ");	2640	try stream.writeAll("}) ");
2643	try self.writeSrc(stream, inst_data.src());	2641	try self.writeSrcNode(stream, inst_data.src_node);
2644	}	2642	}
2645		2643
2646	fn writeUnreachable(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2644	fn writeUnreachable(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
2647	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"unreachable";	2645	const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"unreachable";
2648	try stream.writeAll(") ");	2646	try stream.writeAll(") ");
2649	try self.writeSrc(stream, inst_data.src());	2647	try self.writeSrcNode(stream, inst_data.src_node);
2650	}	2648	}
2651		2649
2652	fn writeFuncCommon(	2650	fn writeFuncCommon(
...	@@ -2667,7 +2665,7 @@ const Writer = struct {	...	@@ -2667,7 +2665,7 @@ const Writer = struct {
2667	ret_ty_ref: Zir.Inst.Ref,	2665	ret_ty_ref: Zir.Inst.Ref,
2668	ret_ty_body: []const Zir.Inst.Index,	2666	ret_ty_body: []const Zir.Inst.Index,
2669	body: []const Zir.Inst.Index,	2667	body: []const Zir.Inst.Index,
2670	src: LazySrcLoc,	2668	src_node: i32,
2671	src_locs: Zir.Inst.Func.SrcLocs,	2669	src_locs: Zir.Inst.Func.SrcLocs,
2672	noalias_bits: u32,	2670	noalias_bits: u32,
2673	) !void {	2671	) !void {
...	@@ -2694,7 +2692,7 @@ const Writer = struct {	...	@@ -2694,7 +2692,7 @@ const Writer = struct {
2694	src_locs.rbrace_line + 1, @as(u16, @truncate(src_locs.columns >> 16)) + 1,	2692	src_locs.rbrace_line + 1, @as(u16, @truncate(src_locs.columns >> 16)) + 1,
2695	});	2693	});
2696	}	2694	}
2697	try self.writeSrc(stream, src);	2695	try self.writeSrcNode(stream, src_node);
2698	}	2696	}
2699		2697
2700	fn writeDbgStmt(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {	2698	fn writeDbgStmt(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
...	@@ -2878,11 +2876,12 @@ const Writer = struct {	...	@@ -2878,11 +2876,12 @@ const Writer = struct {
2878	}	2876	}
2879	}	2877	}
2880		2878
2881	fn writeSrcNode(self: *Writer, stream: anytype, src_node: ?i32) !void {	2879	fn writeSrcNode(self: *Writer, stream: anytype, src_node: i32) !void {
2882	const node_offset = src_node orelse return;	2880	return self.writeSrc(stream, LazySrcLoc.nodeOffset(src_node));
2883	const src = LazySrcLoc.nodeOffset(node_offset);	2881	}
2884	try stream.writeAll(" ");	2882
2885	return self.writeSrc(stream, src);	2883	fn writeSrcTok(self: *Writer, stream: anytype, src_tok: u32) !void {
		2884	return self.writeSrc(stream, .{ .token_offset = src_tok });
2886	}	2885	}
2887		2886
2888	fn writeBracedDecl(self: *Writer, stream: anytype, body: []const Zir.Inst.Index) !void {	2887	fn writeBracedDecl(self: *Writer, stream: anytype, body: []const Zir.Inst.Index) !void {

...	@@ -182,7 +182,7 @@ const Namespace = Module.Namespace;	...	@@ -182,7 +182,7 @@ const Namespace = Module.Namespace;
182	const CompileError = Module.CompileError;	182	const CompileError = Module.CompileError;
183	const SemaError = Module.SemaError;	183	const SemaError = Module.SemaError;
184	const Decl = Module.Decl;	184	const Decl = Module.Decl;
185	const LazySrcLoc = std.zig.LazySrcLoc;	185	const LazySrcLoc = Zcu.LazySrcLoc;
186	const RangeSet = @import("RangeSet.zig");	186	const RangeSet = @import("RangeSet.zig");
187	const target_util = @import("target.zig");	187	const target_util = @import("target.zig");
188	const Package = @import("Package.zig");	188	const Package = @import("Package.zig");
...	@@ -395,6 +395,18 @@ pub const Block = struct {	...	@@ -395,6 +395,18 @@ pub const Block = struct {
395	/// `block` in order for codegen to match lexical scoping for debug vars.	395	/// `block` in order for codegen to match lexical scoping for debug vars.
396	need_debug_scope: ?*bool = null,	396	need_debug_scope: ?*bool = null,
397		397
		398	// These functions will be less stupid soon!
		399
		400	fn nodeOffset(block: Block, node_offset: i32) LazySrcLoc {
		401	_ = block;
		402	return LazySrcLoc.nodeOffset(node_offset);
		403	}
		404
		405	fn tokenOffset(block: Block, tok_offset: u32) LazySrcLoc {
		406	_ = block;
		407	return .{ .token_offset = tok_offset };
		408	}
		409
398	const ComptimeReason = union(enum) {	410	const ComptimeReason = union(enum) {
399	c_import: struct {	411	c_import: struct {
400	block: *Block,	412	block: *Block,
...	@@ -1449,7 +1461,7 @@ fn analyzeBodyInner(	...	@@ -1449,7 +1461,7 @@ fn analyzeBodyInner(
1449	.check_comptime_control_flow => {	1461	.check_comptime_control_flow => {
1450	if (!block.is_comptime) {	1462	if (!block.is_comptime) {
1451	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;	1463	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
1452	const src = inst_data.src();	1464	const src = block.nodeOffset(inst_data.src_node);
1453	const inline_block = inst_data.operand.toIndex().?;	1465	const inline_block = inst_data.operand.toIndex().?;
1454		1466
1455	var check_block = block;	1467	var check_block = block;
...	@@ -1482,13 +1494,13 @@ fn analyzeBodyInner(	...	@@ -1482,13 +1494,13 @@ fn analyzeBodyInner(
1482	},	1494	},
1483	.restore_err_ret_index_unconditional => {	1495	.restore_err_ret_index_unconditional => {
1484	const un_node = datas[@intFromEnum(inst)].un_node;	1496	const un_node = datas[@intFromEnum(inst)].un_node;
1485	try sema.restoreErrRetIndex(block, un_node.src(), un_node.operand, .none);	1497	try sema.restoreErrRetIndex(block, block.nodeOffset(un_node.src_node), un_node.operand, .none);