Commit 2f259b8176184f063f555aed34087cf7560124fb | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-12-01 23:25:09-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-12-04 03:40:40-05:00
log	2f259b8176184f063f555aed34087cf7560124fb
tree	b4e1cc89b32673c159c68a46ba1e0683ea208102
parent	f6cbb73c7402fc100bbfb26c1a35c9f23b3f36ff

IR: re-organize where state goes to prepare for generics

 * Rip out legacy code for generics
 * put scope in instruction instead of AST nodes
 * separate top level decl stuff from AST nodes
   - remove the assumption that there is a 1:1 correspondence
     between an output instruction and an AST node
   - This way we won't have to clone AST nodes for generics.

10 files changed, 1495 insertions(+), 1886 deletions(-)

src/all_types.hpp+88-202

...	...	@@ -20,6 +20,8 @@ struct AstNode;
20	20	struct ImportTableEntry;
21	21	struct FnTableEntry;
22	22	struct Scope;
	23	struct ScopeBlock;
	24	struct ScopeFnDef;
23	25	struct TypeTableEntry;
24	26	struct VariableTableEntry;
25	27	struct ErrorTableEntry;
...	...	@@ -33,6 +35,13 @@ struct IrInstructionCast;
33	35	struct IrBasicBlock;
34	36	struct ScopeDecls;
35	37
	38	struct IrGotoItem {
	39	AstNode *source_node;
	40	IrBasicBlock *bb;
	41	size_t instruction_index;
	42	Scope *scope;
	43	};
	44
36	45	struct IrExecutable {
37	46	ZigList<IrBasicBlock *> basic_block_list;
38	47	size_t mem_slot_count;
...	...	@@ -41,8 +50,9 @@ struct IrExecutable {
41	50	size_t backward_branch_quota;
42	51	bool invalid;
43	52	ZigList<LabelTableEntry *> all_labels;
44		ZigList<AstNode *> goto_list;
	53	ZigList<IrGotoItem> goto_list;
45	54	bool is_inline;
	55	FnTableEntry *fn_entry;
46	56	};
47	57
48	58	enum OutType {
...	...	@@ -129,36 +139,62 @@ enum ReturnKnowledge {
129	139	ReturnKnowledgeSkipDefers,
130	140	};
131	141
132		struct StructValExprCodeGen {
133		TypeTableEntry *type_entry;
134		LLVMValueRef ptr;
135		AstNode *source_node;
136		};
137
138	142	enum VisibMod {
139	143	VisibModPrivate,
140	144	VisibModPub,
141	145	VisibModExport,
142	146	};
143	147
	148	enum TldId {
	149	TldIdVar,
	150	TldIdFn,
	151	TldIdContainer,
	152	TldIdTypeDef,
	153	};
	154
144	155	enum TldResolution {
145	156	TldResolutionUnresolved,
146	157	TldResolutionInvalid,
147	158	TldResolutionOk,
148	159	};
149	160
150		struct TopLevelDecl {
151		// populated by parser
	161	struct Tld {
	162	TldId id;
152	163	Buf *name;
153	164	VisibMod visib_mod;
	165	AstNode *source_node;
154	166
155		// populated by semantic analyzer
156	167	ImportTableEntry *import;
	168	Scope *parent_scope;
157	169	// set this flag temporarily to detect infinite loops
158	170	bool dep_loop_flag;
159	171	TldResolution resolution;
160		AstNode *parent_decl;
161		IrInstruction *value;
	172	Tld *parent_tld;
	173	};
	174
	175	struct TldVar {
	176	Tld base;
	177
	178	VariableTableEntry *var;
	179	};
	180
	181	struct TldFn {
	182	Tld base;
	183
	184	FnTableEntry *fn_entry;
	185	};
	186
	187	struct TldContainer {
	188	Tld base;
	189
	190	ScopeDecls *decls_scope;
	191	TypeTableEntry *type_entry;
	192	};
	193
	194	struct TldTypeDef {
	195	Tld base;
	196
	197	TypeTableEntry *type_entry;
162	198	};
163	199
164	200	struct TypeEnumField {
...	...	@@ -223,7 +259,7 @@ struct AstNodeRoot {
223	259	};
224	260
225	261	struct AstNodeFnProto {
226		TopLevelDecl top_level_decl;
	262	VisibMod visib_mod;
227	263	Buf *name;
228	264	ZigList<AstNode *> params;
229	265	AstNode *return_type;
...	...	@@ -232,28 +268,12 @@ struct AstNodeFnProto {
232	268	bool is_inline;
233	269	bool is_coldcc;
234	270	bool is_nakedcc;
235
236		// populated by semantic analyzer:
237
238		// the function definition this fn proto is inside. can be null.
239	271	AstNode *fn_def_node;
240		FnTableEntry *fn_table_entry;
241		bool skip;
242		// computed from params field
243		size_t inline_arg_count;
244		size_t inline_or_var_type_arg_count;
245		// if this is a generic function implementation, this points to the generic node
246		AstNode *generic_proto_node;
247	272	};
248	273
249	274	struct AstNodeFnDef {
250	275	AstNode *fn_proto;
251	276	AstNode *body;
252
253		// populated by semantic analyzer
254		TypeTableEntry *implicit_return_type;
255		Scope *containing_scope;
256		Scope *child_scope;
257	277	};
258	278
259	279	struct AstNodeFnDecl {
...	...	@@ -265,21 +285,10 @@ struct AstNodeParamDecl {
265	285	AstNode *type;
266	286	bool is_noalias;
267	287	bool is_inline;
268
269		// populated by semantic analyzer
270		VariableTableEntry *variable;
271	288	};
272	289
273	290	struct AstNodeBlock {
274	291	ZigList<AstNode *> statements;
275
276		// populated by semantic analyzer
277		// this one is the scope that the block itself introduces
278		Scope *child_block;
279		// this is the innermost scope created by defers and var decls.
280		// you can follow its parents up to child_block. it will equal
281		// child_block if there are no defers or var decls in the block.
282		Scope *nested_block;
283	292	};
284	293
285	294	enum ReturnKind {
...	...	@@ -298,14 +307,13 @@ struct AstNodeDefer {
298	307	ReturnKind kind;
299	308	AstNode *expr;
300	309
301		// populated by semantic analyzer:
302		size_t index_in_block;
303		LLVMBasicBlockRef basic_block;
304		Scope *child_block;
	310	// temporary data used in IR generation
	311	// TODO populate during gen_defer
	312	Scope *child_scope;
305	313	};
306	314
307	315	struct AstNodeVariableDeclaration {
308		TopLevelDecl top_level_decl;
	316	VisibMod visib_mod;
309	317	Buf *symbol;
310	318	bool is_const;
311	319	bool is_inline;
...	...	@@ -313,28 +321,19 @@ struct AstNodeVariableDeclaration {
313	321	// one or both of type and expr will be non null
314	322	AstNode *type;
315	323	AstNode *expr;
316
317		// populated by semantic analyzer
318		VariableTableEntry *variable;
319	324	};
320	325
321	326	struct AstNodeTypeDecl {
322		TopLevelDecl top_level_decl;
	327	VisibMod visib_mod;
323	328	Buf *symbol;
324	329	AstNode *child_type;
325
326		// populated by semantic analyzer
327		// if this is set, don't process the node; we've already done so
328		// and here is the type (with id TypeTableEntryIdTypeDecl)
329		TypeTableEntry *override_type;
330		TypeTableEntry *child_type_entry;
331	330	};
332	331
333	332	struct AstNodeErrorValueDecl {
334		TopLevelDecl top_level_decl;
	333	// always invalid if it's not VisibModPrivate but can be parsed that way
	334	VisibMod visib_mod;
335	335	Buf *name;
336	336
337		// populated by semantic analyzer
338	337	ErrorTableEntry *err;
339	338	};
340	339
...	...	@@ -388,19 +387,12 @@ struct AstNodeBinOpExpr {
388	387	AstNode *op1;
389	388	BinOpType bin_op;
390	389	AstNode *op2;
391
392		// populated by semantic analyzer:
393		// for when op is BinOpTypeAssign
394		VariableTableEntry *var_entry;
395	390	};
396	391
397	392	struct AstNodeUnwrapErrorExpr {
398	393	AstNode *op1;
399	394	AstNode *symbol; // can be null
400	395	AstNode *op2;
401
402		// populated by semantic analyzer:
403		VariableTableEntry *var;
404	396	};
405	397
406	398	enum CastOp {
...	...	@@ -429,21 +421,11 @@ struct AstNodeFnCallExpr {
429	421	AstNode *fn_ref_expr;
430	422	ZigList<AstNode *> params;
431	423	bool is_builtin;
432
433		// populated by semantic analyzer:
434		BuiltinFnEntry *builtin_fn;
435		FnTableEntry *fn_entry;
436		CastOp cast_op;
437		// if cast_op is CastOpArrayToString, this will be a pointer to
438		// the string struct on the stack
439		LLVMValueRef tmp_ptr;
440	424	};
441	425
442	426	struct AstNodeArrayAccessExpr {
443	427	AstNode *array_ref_expr;
444	428	AstNode *subscript;
445
446		// populated by semantic analyzer:
447	429	};
448	430
449	431	struct AstNodeSliceExpr {
...	...	@@ -451,22 +433,11 @@ struct AstNodeSliceExpr {
451	433	AstNode *start;
452	434	AstNode *end;
453	435	bool is_const;
454
455		// populated by semantic analyzer:
456		StructValExprCodeGen resolved_struct_val_expr;
457	436	};
458	437
459	438	struct AstNodeFieldAccessExpr {
460	439	AstNode *struct_expr;
461	440	Buf *field_name;
462
463		// populated by semantic analyzer
464		TypeStructField *type_struct_field;
465		TypeEnumField *type_enum_field;
466		StructValExprCodeGen resolved_struct_val_expr; // for enum values
467		TypeTableEntry *bare_container_type;
468		bool is_member_fn;
469		AstNode *container_init_expr_node;
470	441	};
471	442
472	443	enum PrefixOp {
...	...	@@ -487,24 +458,21 @@ enum PrefixOp {
487	458	struct AstNodePrefixOpExpr {
488	459	PrefixOp prefix_op;
489	460	AstNode *primary_expr;
490
491		// populated by semantic analyzer
492	461	};
493	462
494	463	struct AstNodeUse {
	464	VisibMod visib_mod;
495	465	AstNode *expr;
496	466
497		// populated by semantic analyzer
498		TopLevelDecl top_level_decl;
	467	TldResolution resolution;
	468	IrInstruction *value;
499	469	};
500	470
501	471	struct AstNodeIfBoolExpr {
502	472	AstNode *condition;
503	473	AstNode *then_block;
504	474	AstNode *else_node; // null, block node, or other if expr node
505		bool is_inline; // TODO
506
507		// populated by semantic analyzer
	475	bool is_inline; // TODO parse inline if
508	476	};
509	477
510	478	struct AstNodeIfVarExpr {
...	...	@@ -512,10 +480,7 @@ struct AstNodeIfVarExpr {
512	480	AstNode *then_block;
513	481	AstNode *else_node; // null, block node, or other if expr node
514	482	bool var_is_ptr;
515		bool is_inline; // TODO
516
517		// populated by semantic analyzer
518		TypeTableEntry *type;
	483	bool is_inline; // TODO parse inline ?if?
519	484	};
520	485
521	486	struct AstNodeWhileExpr {
...	...	@@ -523,11 +488,6 @@ struct AstNodeWhileExpr {
523	488	AstNode *continue_expr;
524	489	AstNode *body;
525	490	bool is_inline;
526
527		// populated by semantic analyzer
528		bool condition_always_true;
529		bool contains_break;
530		bool contains_continue;
531	491	};
532	492
533	493	struct AstNodeForExpr {
...	...	@@ -537,20 +497,12 @@ struct AstNodeForExpr {
537	497	AstNode *body;
538	498	bool elem_is_ptr;
539	499	bool is_inline;
540
541		// populated by semantic analyzer
542		bool contains_break;
543		bool contains_continue;
544		VariableTableEntry *elem_var;
545		VariableTableEntry *index_var;
546	500	};
547	501
548	502	struct AstNodeSwitchExpr {
549	503	AstNode *expr;
550	504	ZigList<AstNode *> prongs;
551	505	bool is_inline;
552
553		// populated by semantic analyzer
554	506	};
555	507
556	508	struct AstNodeSwitchProng {
...	...	@@ -573,10 +525,6 @@ struct AstNodeLabel {
573	525	struct AstNodeGoto {
574	526	Buf *name;
575	527	bool is_inline;
576
577		// populated by semantic analyzer
578		IrBasicBlock *bb;
579		size_t instruction_index;
580	528	};
581	529
582	530	struct AsmOutput {
...	...	@@ -584,9 +532,6 @@ struct AsmOutput {
584	532	Buf *constraint;
585	533	Buf *variable_name;
586	534	AstNode *return_type; // null unless "=r" and return
587
588		// populated by semantic analyzer
589		VariableTableEntry *variable;
590	535	};
591	536
592	537	struct AsmInput {
...	...	@@ -619,8 +564,6 @@ struct AstNodeAsmExpr {
619	564	ZigList<AsmOutput*> output_list;
620	565	ZigList<AsmInput*> input_list;
621	566	ZigList<Buf*> clobber_list;
622
623		// populated by semantic analyzer
624	567	};
625	568
626	569	enum ContainerKind {
...	...	@@ -630,23 +573,17 @@ enum ContainerKind {
630	573	};
631	574
632	575	struct AstNodeStructDecl {
633		TopLevelDecl top_level_decl;
	576	VisibMod visib_mod;
634	577	Buf *name;
635	578	ContainerKind kind;
636	579	ZigList<AstNode *> generic_params;
637	580	bool generic_params_is_var_args; // always an error but it can happen from parsing
638	581	ZigList<AstNode *> fields;
639	582	ZigList<AstNode *> decls;
640
641		// populated by semantic analyzer
642		ScopeDecls *decls_scope;
643		TypeTableEntry *type_entry;
644		TypeTableEntry *generic_fn_type;
645		bool skip;
646	583	};
647	584
648	585	struct AstNodeStructField {
649		TopLevelDecl top_level_decl;
	586	VisibMod visib_mod;
650	587	Buf *name;
651	588	AstNode *type;
652	589	};
...	...	@@ -654,14 +591,10 @@ struct AstNodeStructField {
654	591	struct AstNodeStringLiteral {
655	592	Buf *buf;
656	593	bool c;
657
658		// populated by semantic analyzer:
659	594	};
660	595
661	596	struct AstNodeCharLiteral {
662	597	uint8_t value;
663
664		// populated by semantic analyzer:
665	598	};
666	599
667	600	struct AstNodeNumberLiteral {
...	...	@@ -670,16 +603,11 @@ struct AstNodeNumberLiteral {
670	603	// overflow is true if when parsing the number, we discovered it would not
671	604	// fit without losing data in a uint64_t or double
672	605	bool overflow;
673
674		// populated by semantic analyzer
675	606	};
676	607
677	608	struct AstNodeStructValueField {
678	609	Buf *name;
679	610	AstNode *expr;
680
681		// populated by semantic analyzer
682		TypeStructField *type_struct_field;
683	611	};
684	612
685	613	enum ContainerInitKind {
...	...	@@ -691,68 +619,47 @@ struct AstNodeContainerInitExpr {
691	619	AstNode *type;
692	620	ZigList<AstNode *> entries;
693	621	ContainerInitKind kind;
694
695		// populated by semantic analyzer
696		StructValExprCodeGen resolved_struct_val_expr;
697		TypeTableEntry *enum_type;
698	622	};
699	623
700	624	struct AstNodeNullLiteral {
701		// populated by semantic analyzer
702	625	};
703	626
704	627	struct AstNodeUndefinedLiteral {
705		// populated by semantic analyzer
706	628	};
707	629
708	630	struct AstNodeZeroesLiteral {
709		// populated by semantic analyzer
710	631	};
711	632
712	633	struct AstNodeThisLiteral {
713		// populated by semantic analyzer
714	634	};
715	635
716	636	struct AstNodeSymbolExpr {
717	637	Buf *symbol;
718
719		// populated by semantic analyzer
720		TypeEnumField *enum_field;
721		uint32_t err_value;
722	638	};
723	639
724	640	struct AstNodeBoolLiteral {
725	641	bool value;
726
727		// populated by semantic analyzer
728	642	};
729	643
730	644	struct AstNodeBreakExpr {
731		// populated by semantic analyzer
732	645	};
733	646
734	647	struct AstNodeContinueExpr {
735		// populated by semantic analyzer
736	648	};
737	649
738	650	struct AstNodeArrayType {
739	651	AstNode *size;
740	652	AstNode *child_type;
741	653	bool is_const;
742
743		// populated by semantic analyzer
744	654	};
745	655
746	656	struct AstNodeErrorType {
747		// populated by semantic analyzer
748	657	};
749	658
750	659	struct AstNodeTypeLiteral {
751		// populated by semantic analyzer
752	660	};
753	661
754	662	struct AstNodeVarLiteral {
755		// populated by semantic analyzer
756	663	};
757	664
758	665	struct AstNode {
...	...	@@ -761,9 +668,6 @@ struct AstNode {
761	668	size_t column;
762	669	uint32_t create_index; // for determinism purposes
763	670	ImportTableEntry *owner;
764		// the context in which this expression/node is evaluated.
765		// for blocks, this points to the containing scope, not the block's own scope for its children.
766		Scope *scope;
767	671	union {
768	672	AstNodeRoot root;
769	673	AstNodeFnDef fn_def;
...	...	@@ -822,26 +726,12 @@ struct FnTypeParamInfo {
822	726	TypeTableEntry *type;
823	727	};
824	728
825		struct GenericParamValue {
826		TypeTableEntry *type;
827		AstNode *node;
828		size_t impl_index;
829		};
830
831		struct GenericFnTypeId {
832		AstNode *decl_node; // the generic fn or container decl node
833		GenericParamValue *generic_params;
834		size_t generic_param_count;
835		};
836
837		uint32_t generic_fn_type_id_hash(GenericFnTypeId *id);
838		bool generic_fn_type_id_eql(GenericFnTypeId a, GenericFnTypeId b);
839
840	729
841	730	struct FnTypeId {
842	731	TypeTableEntry *return_type;
843	732	FnTypeParamInfo *param_info;
844	733	size_t param_count;
	734	size_t next_param_index;
845	735	bool is_var_args;
846	736	bool is_naked;
847	737	bool is_cold;
...	...	@@ -945,6 +835,7 @@ struct FnGenParamInfo {
945	835
946	836	struct TypeTableEntryFn {
947	837	FnTypeId fn_type_id;
	838	bool is_generic;
948	839	TypeTableEntry *gen_return_type;
949	840	size_t gen_param_count;
950	841	FnGenParamInfo *gen_param_info;
...	...	@@ -955,10 +846,6 @@ struct TypeTableEntryFn {
955	846	TypeTableEntry *bound_fn_parent;
956	847	};
957	848
958		struct TypeTableEntryGenericFn {
959		AstNode *decl_node;
960		};
961
962	849	struct TypeTableEntryBoundFn {
963	850	TypeTableEntry *fn_type;
964	851	};
...	...	@@ -993,7 +880,6 @@ enum TypeTableEntryId {
993	880	TypeTableEntryIdTypeDecl,
994	881	TypeTableEntryIdNamespace,
995	882	TypeTableEntryIdBlock,
996		TypeTableEntryIdGenericFn,
997	883	TypeTableEntryIdBoundFn,
998	884	};
999	885
...	...	@@ -1018,7 +904,6 @@ struct TypeTableEntry {
1018	904	TypeTableEntryUnion unionation;
1019	905	TypeTableEntryFn fn;
1020	906	TypeTableEntryTypeDecl type_decl;
1021		TypeTableEntryGenericFn generic_fn;
1022	907	TypeTableEntryBoundFn bound_fn;
1023	908	} data;
1024	909
...	...	@@ -1056,10 +941,9 @@ enum FnAnalState {
1056	941	FnAnalStateReady,
1057	942	FnAnalStateProbing,
1058	943	FnAnalStateComplete,
1059		FnAnalStateSkipped,
	944	FnAnalStateInvalid,
1060	945	};
1061	946
1062
1063	947	enum FnInline {
1064	948	FnInlineAuto,
1065	949	FnInlineAlways,
...	...	@@ -1067,14 +951,18 @@ enum FnInline {
1067	951	};
1068	952
1069	953	struct FnTableEntry {
1070		LLVMValueRef fn_value;
	954	LLVMValueRef llvm_value;
1071	955	AstNode *proto_node;
1072	956	AstNode *fn_def_node;
	957	ScopeFnDef *fndef_scope; // parent should be the top level decls or container decls
	958	Scope *child_scope; // parent is scope for last parameter
	959	ScopeBlock *def_scope; // parent is child_scope
1073	960	ImportTableEntry *import_entry;
1074	961	Buf symbol_name;
1075	962	TypeTableEntry *type_entry; // function type
	963	TypeTableEntry *implicit_return_type;
1076	964	bool internal_linkage;
1077		bool is_extern;
	965	bool disable_export;
1078	966	bool is_test;
1079	967	FnInline fn_inline;
1080	968	FnAnalState anal_state;
...	...	@@ -1161,11 +1049,10 @@ struct CodeGen {
1161	1049	HashMap<Buf , TypeTableEntry , buf_hash, buf_eql_buf> primitive_type_table;
1162	1050	HashMap<FnTypeId , TypeTableEntry , fn_type_id_hash, fn_type_id_eql> fn_type_table;
1163	1051	HashMap<Buf , ErrorTableEntry , buf_hash, buf_eql_buf> error_table;
1164		HashMap<GenericFnTypeId , AstNode , generic_fn_type_id_hash, generic_fn_type_id_eql> generic_table;
1165	1052
1166	1053	ZigList<ImportTableEntry *> import_queue;
1167	1054	size_t import_queue_index;
1168		ZigList<AstNode *> resolve_queue;
	1055	ZigList<Tld *> resolve_queue;
1169	1056	size_t resolve_queue_index;
1170	1057	ZigList<AstNode *> use_queue;
1171	1058	size_t use_queue_index;
...	...	@@ -1249,6 +1136,7 @@ struct CodeGen {
1249	1136	// The function definitions this module includes. There must be a corresponding
1250	1137	// fn_protos entry.
1251	1138	ZigList<FnTableEntry *> fn_defs;
	1139	size_t fn_defs_index;
1252	1140	// The function prototypes this module includes. In the case of external declarations,
1253	1141	// there will not be a corresponding fn_defs entry.
1254	1142	ZigList<FnTableEntry *> fn_protos;
...	...	@@ -1258,6 +1146,7 @@ struct CodeGen {
1258	1146	FnTableEntry *cur_fn;
1259	1147	FnTableEntry *main_fn;
1260	1148	LLVMValueRef cur_ret_ptr;
	1149	LLVMValueRef cur_fn_val;
1261	1150	ZigList<LLVMBasicBlockRef> break_block_stack;
1262	1151	ZigList<LLVMBasicBlockRef> continue_block_stack;
1263	1152	bool c_want_stdint;
...	...	@@ -1295,6 +1184,7 @@ struct CodeGen {
1295	1184	IrInstruction *invalid_instruction;
1296	1185	};
1297	1186
	1187	// TODO after merging IR branch, we can probably delete some of these fields
1298	1188	struct VariableTableEntry {
1299	1189	Buf name;
1300	1190	TypeTableEntry *type;
...	...	@@ -1304,8 +1194,6 @@ struct VariableTableEntry {
1304	1194	bool is_inline;
1305	1195	// which node is the declaration of the variable
1306	1196	AstNode *decl_node;
1307		// which node contains the ConstExprValue for this variable's value
1308		AstNode *val_node;
1309	1197	ZigLLVMDILocalVariable *di_loc_var;
1310	1198	size_t src_arg_index;
1311	1199	size_t gen_arg_index;
...	...	@@ -1313,10 +1201,10 @@ struct VariableTableEntry {
1313	1201	Scope *child_scope;
1314	1202	LLVMValueRef param_value_ref;
1315	1203	bool force_depends_on_compile_var;
1316		ImportTableEntry *import;
1317	1204	bool shadowable;
1318	1205	size_t mem_slot_index;
1319	1206	size_t ref_count;
	1207	ConstExprValue *value;
1320	1208	};
1321	1209
1322	1210	struct ErrorTableEntry {
...	...	@@ -1339,9 +1227,6 @@ struct Scope {
1339	1227	Scope *parent;
1340	1228
1341	1229	ZigLLVMDIScope *di_scope;
1342
1343		bool safety_off;
1344		AstNode *safety_set_node;
1345	1230	};
1346	1231
1347	1232	// This scope comes from global declarations or from
...	...	@@ -1350,15 +1235,12 @@ struct Scope {
1350	1235	struct ScopeDecls {
1351	1236	Scope base;
1352	1237
1353		HashMap<Buf , AstNode , buf_hash, buf_eql_buf> decl_table;
1354		};
1355
1356		// This scope comes from a container declaration such as a struct,
1357		// enum, or union.
1358		struct ScopeContainer {
1359		Scope base;
1360
1361		HashMap<Buf , AstNode , buf_hash, buf_eql_buf> decl_table;
	1238	HashMap<Buf , Tld , buf_hash, buf_eql_buf> decl_table;
	1239	bool safety_off;
	1240	AstNode *safety_set_node;
	1241	ImportTableEntry *import;
	1242	// If this is a scope from a container, this is the type entry, otherwise null
	1243	TypeTableEntry *container_type;
1362	1244	};
1363	1245
1364	1246	// This scope comes from a block expression in user code.
...	...	@@ -1367,6 +1249,8 @@ struct ScopeBlock {
1367	1249	Scope base;
1368	1250
1369	1251	HashMap<Buf , LabelTableEntry , buf_hash, buf_eql_buf> label_table;
	1252	bool safety_off;
	1253	AstNode *safety_set_node;
1370	1254	};
1371	1255
1372	1256	// This scope is created from every defer expression.
...	...	@@ -1401,7 +1285,7 @@ struct ScopeLoop {
1401	1285
1402	1286	// This scope is created for a function definition.
1403	1287	// NodeTypeFnDef
1404		struct ScopeFnBody {
	1288	struct ScopeFnDef {
1405	1289	Scope base;
1406	1290
1407	1291	FnTableEntry *fn_entry;
...	...	@@ -1479,6 +1363,7 @@ enum IrInstructionId {
1479	1363
1480	1364	struct IrInstruction {
1481	1365	IrInstructionId id;
	1366	Scope *scope;
1482	1367	AstNode *source_node;
1483	1368	ConstExprValue static_value;
1484	1369	TypeTableEntry *type_entry;
...	...	@@ -1798,6 +1683,7 @@ struct IrInstructionAsm {
1798	1683	// Most information on inline assembly comes from the source node.
1799	1684	IrInstruction **input_list;
1800	1685	IrInstruction **output_types;
	1686	VariableTableEntry **output_vars;
1801	1687	size_t return_count;
1802	1688	bool has_side_effects;
1803	1689	};

src/analyze.cpp+496-806

...	...	@@ -19,8 +19,8 @@
19	19
20	20	static const size_t default_backward_branch_quota = 1000;
21	21
22		static void resolve_enum_type(CodeGen g, ImportTableEntry import, TypeTableEntry *enum_type);
23		static void resolve_struct_type(CodeGen g, ImportTableEntry import, TypeTableEntry *struct_type);
	22	static void resolve_enum_type(CodeGen g, TypeTableEntry enum_type);
	23	static void resolve_struct_type(CodeGen g, TypeTableEntry struct_type);
24	24
25	25	AstNode first_executing_node(AstNode node) {
26	26	switch (node->type) {
...	...	@@ -130,9 +130,82 @@ ScopeDecls get_container_scope(TypeTableEntry type_entry) {
130	130	return *get_container_scope_ptr(type_entry);
131	131	}
132	132
	133	void init_scope(Scope dest, AstNode node, Scope *parent) {
	134	dest->node = node;
	135	dest->parent = parent;
	136	}
	137
	138	static ScopeDecls create_decls_scope(AstNode node, Scope parent, TypeTableEntry container_type, ImportTableEntry *import) {
	139	assert(node->type == NodeTypeRoot \|\| node->type == NodeTypeContainerDecl);
	140	ScopeDecls *scope = allocate<ScopeDecls>(1);
	141	init_scope(&scope->base, node, parent);
	142	scope->decl_table.init(4);
	143	scope->container_type = container_type;
	144	scope->import = import;
	145	return scope;
	146	}
	147
	148	Scope create_block_scope(AstNode node, Scope *parent) {
	149	assert(node->type == NodeTypeBlock);
	150	ScopeBlock *scope = allocate<ScopeBlock>(1);
	151	init_scope(&scope->base, node, parent);
	152	scope->label_table.init(1);
	153	return &scope->base;
	154	}
	155
	156	Scope create_defer_scope(AstNode node, Scope *parent) {
	157	assert(node->type == NodeTypeDefer);
	158	ScopeDefer *scope = allocate<ScopeDefer>(1);
	159	init_scope(&scope->base, node, parent);
	160	return &scope->base;
	161	}
	162
	163	Scope create_var_scope(AstNode node, Scope parent, VariableTableEntry var) {
	164	assert(node->type == NodeTypeVariableDeclaration \|\| node->type == NodeTypeParamDecl);
	165	ScopeVarDecl *scope = allocate<ScopeVarDecl>(1);
	166	init_scope(&scope->base, node, parent);
	167	scope->var = var;
	168	return &scope->base;
	169	}
	170
	171	Scope create_cimport_scope(AstNode node, Scope *parent) {
	172	assert(node->type == NodeTypeFnCallExpr);
	173	ScopeCImport *scope = allocate<ScopeCImport>(1);
	174	init_scope(&scope->base, node, parent);
	175	buf_resize(&scope->c_import_buf, 0);
	176	return &scope->base;
	177	}
	178
	179	Scope create_loop_scope(AstNode node, Scope *parent) {
	180	assert(node->type == NodeTypeWhileExpr \|\| node->type == NodeTypeForExpr);
	181	ScopeLoop *scope = allocate<ScopeLoop>(1);
	182	init_scope(&scope->base, node, parent);
	183	return &scope->base;
	184	}
	185
	186	ScopeFnDef create_fndef_scope(AstNode node, Scope parent, FnTableEntry fn_entry) {
	187	assert(node->type == NodeTypeFnDef);
	188	ScopeFnDef *scope = allocate<ScopeFnDef>(1);
	189	init_scope(&scope->base, node, parent);
	190	scope->fn_entry = fn_entry;
	191	return scope;
	192	}
	193
	194	ImportTableEntry get_scope_import(Scope scope) {
	195	while (scope) {
	196	if (scope->node->type == NodeTypeRoot \|\| scope->node->type == NodeTypeContainerDecl) {
	197	ScopeDecls decls_scope = (ScopeDecls )scope;
	198	assert(decls_scope->import);
	199	return decls_scope->import;
	200	}
	201	scope = scope->parent;
	202	}
	203	zig_unreachable();
	204	}
	205
133	206	static TypeTableEntry new_container_type_entry(TypeTableEntryId id, AstNode source_node, Scope *parent_scope) {
134	207	TypeTableEntry *entry = new_type_table_entry(id);
135		*get_container_scope_ptr(entry) = create_decls_scope(source_node, parent_scope);
	208	*get_container_scope_ptr(entry) = create_decls_scope(source_node, parent_scope, entry, get_scope_import(parent_scope));
136	209	return entry;
137	210	}
138	211
...	...	@@ -179,7 +252,6 @@ bool type_is_complete(TypeTableEntry *type_entry) {
179	252	case TypeTableEntryIdTypeDecl:
180	253	case TypeTableEntryIdNamespace:
181	254	case TypeTableEntryIdBlock:
182		case TypeTableEntryIdGenericFn:
183	255	case TypeTableEntryIdBoundFn:
184	256	return true;
185	257	}
...	...	@@ -202,14 +274,6 @@ TypeTableEntry get_smallest_unsigned_int_type(CodeGen g, uint64_t x) {
202	274	return get_int_type(g, false, bits_needed_for_unsigned(x));
203	275	}
204	276
205		static TypeTableEntry get_generic_fn_type(CodeGen g, AstNode *decl_node) {
206		TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdGenericFn);
207		buf_init_from_str(&entry->name, "(generic function)");
208		entry->zero_bits = true;
209		entry->data.generic_fn.decl_node = decl_node;
210		return entry;
211		}
212
213	277	TypeTableEntry get_pointer_to_type(CodeGen g, TypeTableEntry *child_type, bool is_const) {
214	278	assert(child_type->id != TypeTableEntryIdInvalid);
215	279	TypeTableEntry **parent_pointer = &child_type->pointer_parent[(is_const ? 1 : 0)];
...	...	@@ -643,8 +707,7 @@ TypeTableEntry get_bound_fn_type(CodeGen g, FnTableEntry *fn_entry) {
643	707	return bound_fn_type;
644	708	}
645	709
646		// accepts ownership of fn_type_id memory
647		TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_info) {
	710	TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id) {
648	711	auto table_entry = g->fn_type_table.maybe_get(fn_type_id);
649	712	if (table_entry) {
650	713	return table_entry->value;
...	...	@@ -685,67 +748,65 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_inf
685	748	buf_appendf(&fn_type->name, " -> %s", buf_ptr(&fn_type_id->return_type->name));
686	749	}
687	750
688		if (gen_debug_info) {
689		// next, loop over the parameters again and compute debug information
690		// and codegen information
691		bool first_arg_return = !fn_type_id->is_extern && handle_is_ptr(fn_type_id->return_type);
692		// +1 for maybe making the first argument the return value
693		LLVMTypeRef *gen_param_types = allocate<LLVMTypeRef>(1 + fn_type_id->param_count);
694		// +1 because 0 is the return type and +1 for maybe making first arg ret val
695		ZigLLVMDIType *param_di_types = allocate<ZigLLVMDIType>(2 + fn_type_id->param_count);
696		param_di_types[0] = fn_type_id->return_type->di_type;
697		size_t gen_param_index = 0;
698		TypeTableEntry *gen_return_type;
699		if (!type_has_bits(fn_type_id->return_type)) {
700		gen_return_type = g->builtin_types.entry_void;
701		} else if (first_arg_return) {
702		TypeTableEntry *gen_type = get_pointer_to_type(g, fn_type_id->return_type, false);
	751	// next, loop over the parameters again and compute debug information
	752	// and codegen information
	753	bool first_arg_return = !fn_type_id->is_extern && handle_is_ptr(fn_type_id->return_type);
	754	// +1 for maybe making the first argument the return value
	755	LLVMTypeRef *gen_param_types = allocate<LLVMTypeRef>(1 + fn_type_id->param_count);
	756	// +1 because 0 is the return type and +1 for maybe making first arg ret val
	757	ZigLLVMDIType *param_di_types = allocate<ZigLLVMDIType>(2 + fn_type_id->param_count);
	758	param_di_types[0] = fn_type_id->return_type->di_type;
	759	size_t gen_param_index = 0;
	760	TypeTableEntry *gen_return_type;
	761	if (!type_has_bits(fn_type_id->return_type)) {
	762	gen_return_type = g->builtin_types.entry_void;
	763	} else if (first_arg_return) {
	764	TypeTableEntry *gen_type = get_pointer_to_type(g, fn_type_id->return_type, false);
	765	gen_param_types[gen_param_index] = gen_type->type_ref;
	766	gen_param_index += 1;
	767	// after the gen_param_index += 1 because 0 is the return type
	768	param_di_types[gen_param_index] = gen_type->di_type;
	769	gen_return_type = g->builtin_types.entry_void;
	770	} else {
	771	gen_return_type = fn_type_id->return_type;
	772	}
	773	fn_type->data.fn.gen_return_type = gen_return_type;
	774
	775	fn_type->data.fn.gen_param_info = allocate<FnGenParamInfo>(fn_type_id->param_count);
	776	for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
	777	FnTypeParamInfo *src_param_info = &fn_type->data.fn.fn_type_id.param_info[i];
	778	TypeTableEntry *type_entry = src_param_info->type;
	779	FnGenParamInfo *gen_param_info = &fn_type->data.fn.gen_param_info[i];
	780
	781	gen_param_info->src_index = i;
	782	gen_param_info->gen_index = SIZE_MAX;
	783
	784	assert(type_is_complete(type_entry));
	785	if (type_has_bits(type_entry)) {
	786	TypeTableEntry *gen_type;
	787	if (handle_is_ptr(type_entry)) {
	788	gen_type = get_pointer_to_type(g, type_entry, true);
	789	gen_param_info->is_byval = true;
	790	} else {
	791	gen_type = type_entry;
	792	}
703	793	gen_param_types[gen_param_index] = gen_type->type_ref;
	794	gen_param_info->gen_index = gen_param_index;
	795	gen_param_info->type = gen_type;
	796
704	797	gen_param_index += 1;
	798
705	799	// after the gen_param_index += 1 because 0 is the return type
706	800	param_di_types[gen_param_index] = gen_type->di_type;
707		gen_return_type = g->builtin_types.entry_void;
708		} else {
709		gen_return_type = fn_type_id->return_type;
710	801	}
711		fn_type->data.fn.gen_return_type = gen_return_type;
712
713		fn_type->data.fn.gen_param_info = allocate<FnGenParamInfo>(fn_type_id->param_count);
714		for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
715		FnTypeParamInfo *src_param_info = &fn_type->data.fn.fn_type_id.param_info[i];
716		TypeTableEntry *type_entry = src_param_info->type;
717		FnGenParamInfo *gen_param_info = &fn_type->data.fn.gen_param_info[i];
718
719		gen_param_info->src_index = i;
720		gen_param_info->gen_index = SIZE_MAX;
721
722		assert(type_is_complete(type_entry));
723		if (type_has_bits(type_entry)) {
724		TypeTableEntry *gen_type;
725		if (handle_is_ptr(type_entry)) {
726		gen_type = get_pointer_to_type(g, type_entry, true);
727		gen_param_info->is_byval = true;
728		} else {
729		gen_type = type_entry;
730		}
731		gen_param_types[gen_param_index] = gen_type->type_ref;
732		gen_param_info->gen_index = gen_param_index;
733		gen_param_info->type = gen_type;
	802	}
734	803
735		gen_param_index += 1;
	804	fn_type->data.fn.gen_param_count = gen_param_index;
736	805
737		// after the gen_param_index += 1 because 0 is the return type
738		param_di_types[gen_param_index] = gen_type->di_type;
739		}
740		}
741
742		fn_type->data.fn.gen_param_count = gen_param_index;
743
744		fn_type->data.fn.raw_type_ref = LLVMFunctionType(gen_return_type->type_ref,
745		gen_param_types, gen_param_index, fn_type_id->is_var_args);
746		fn_type->type_ref = LLVMPointerType(fn_type->data.fn.raw_type_ref, 0);
747		fn_type->di_type = ZigLLVMCreateSubroutineType(g->dbuilder, param_di_types, gen_param_index + 1, 0);
748		}
	806	fn_type->data.fn.raw_type_ref = LLVMFunctionType(gen_return_type->type_ref,
	807	gen_param_types, gen_param_index, fn_type_id->is_var_args);
	808	fn_type->type_ref = LLVMPointerType(fn_type->data.fn.raw_type_ref, 0);
	809	fn_type->di_type = ZigLLVMCreateSubroutineType(g->dbuilder, param_di_types, gen_param_index + 1, 0);
749	810
750	811	g->fn_type_table.put(&fn_type->data.fn.fn_type_id, fn_type);
751	812
...	...	@@ -767,6 +828,7 @@ static TypeTableEntryId container_to_type(ContainerKind kind) {
767	828	TypeTableEntry get_partial_container_type(CodeGen g, ImportTableEntry import, Scope scope,
768	829	ContainerKind kind, AstNode decl_node, const char name)
769	830	{
	831
770	832	TypeTableEntryId type_id = container_to_type(kind);
771	833	TypeTableEntry *entry = new_container_type_entry(type_id, decl_node, scope);
772	834
...	...	@@ -782,7 +844,7 @@ TypeTableEntry get_partial_container_type(CodeGen g, ImportTableEntry *import,
782	844	break;
783	845	}
784	846
785		unsigned line = decl_node ? decl_node->line : 0;
	847	unsigned line = decl_node->line;
786	848
787	849	entry->type_ref = LLVMStructCreateNamed(LLVMGetGlobalContext(), name);
788	850	entry->di_type = ZigLLVMCreateReplaceableCompositeType(g->dbuilder,
...	...	@@ -794,6 +856,14 @@ TypeTableEntry get_partial_container_type(CodeGen g, ImportTableEntry *import,
794	856	return entry;
795	857	}
796	858
	859	static TypeTableEntry get_partial_container_type_tld(CodeGen g, Scope scope, TldContainer tld_container) {
	860	ImportTableEntry *import = tld_container->base.import;
	861	AstNode *container_node = tld_container->base.source_node;
	862	assert(container_node->type == NodeTypeContainerDecl);
	863	ContainerKind kind = container_node->data.struct_decl.kind;
	864	return get_partial_container_type(g, import, scope, kind, container_node, buf_ptr(tld_container->base.name));
	865	}
	866
797	867
798	868	TypeTableEntry get_underlying_type(TypeTableEntry type_entry) {
799	869	if (type_entry->id == TypeTableEntryIdTypeDecl) {
...	...	@@ -842,9 +912,7 @@ static IrInstruction analyze_const_value(CodeGen g, Scope scope, AstNode nod
842	912	return result;
843	913	}
844	914
845		static TypeTableEntry analyze_type_expr(CodeGen g, ImportTableEntry import, Scope scope,
846		AstNode *node)
847		{
	915	static TypeTableEntry analyze_type_expr(CodeGen g, Scope scope, AstNode node) {
848	916	IrInstruction *result = analyze_const_value(g, scope, node, g->builtin_types.entry_type);
849	917	if (result->type_entry->id == TypeTableEntryIdInvalid)
850	918	return g->builtin_types.entry_invalid;
...	...	@@ -853,71 +921,77 @@ static TypeTableEntry analyze_type_expr(CodeGen g, ImportTableEntry *import, S
853	921	return result->static_value.data.x_type;
854	922	}
855	923
856		static bool fn_wants_full_static_eval(FnTableEntry *fn_table_entry) {
857		assert(fn_table_entry);
858		return false;
	924	static TypeTableEntry get_generic_fn_type(CodeGen g, FnTypeId *fn_type_id) {
	925	TypeTableEntry *fn_type = new_type_table_entry(TypeTableEntryIdFn);
	926	fn_type->data.fn.fn_type_id = *fn_type_id;
	927	fn_type->data.fn.is_generic = true;
	928	return fn_type;
859	929	}
860	930
861		// fn_table_entry is populated if and only if there is a function definition for this prototype
862		static TypeTableEntry analyze_fn_proto_type(CodeGen g, ImportTableEntry import, Scope scope,
863		TypeTableEntry expected_type, AstNode node, bool is_naked, bool is_cold, FnTableEntry *fn_table_entry)
864		{
865		assert(node->type == NodeTypeFnProto);
866		AstNodeFnProto *fn_proto = &node->data.fn_proto;
867
868		if (fn_proto->skip) {
869		return g->builtin_types.entry_invalid;
870		}
	931	static TypeTableEntry analyze_fn_type(CodeGen g, TldFn *tld_fn) {
	932	AstNode *proto_node = tld_fn->base.source_node;
	933	assert(proto_node->type == NodeTypeFnProto);
	934	AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
871	935
872	936	FnTypeId fn_type_id = {0};
873		fn_type_id.is_extern = fn_proto->is_extern \|\| (fn_proto->top_level_decl.visib_mod == VisibModExport);
874		fn_type_id.is_naked = is_naked;
875		fn_type_id.is_cold = is_cold;
	937	fn_type_id.is_extern = fn_proto->is_extern \|\| (fn_proto->visib_mod == VisibModExport);
	938	fn_type_id.is_naked = fn_proto->is_nakedcc;
	939	fn_type_id.is_cold = fn_proto->is_coldcc;
876	940	fn_type_id.param_count = fn_proto->params.length;
877	941	fn_type_id.param_info = allocate_nonzero<FnTypeParamInfo>(fn_type_id.param_count);
878
	942	fn_type_id.next_param_index = 0;
879	943	fn_type_id.is_var_args = fn_proto->is_var_args;
880	944
881		for (size_t i = 0; i < fn_type_id.param_count; i += 1) {
882		AstNode *child = fn_proto->params.at(i);
883		assert(child->type == NodeTypeParamDecl);
	945	FnTableEntry *fn_entry = tld_fn->fn_entry;
	946	Scope *child_scope = fn_entry->fndef_scope ? &fn_entry->fndef_scope->base : tld_fn->base.parent_scope;
884	947
885		TypeTableEntry *type_entry;
886		if (fn_proto->skip) {
887		type_entry = g->builtin_types.entry_invalid;
888		} else {
889		type_entry = analyze_type_expr(g, import, scope, child->data.param_decl.type);
	948	for (; fn_type_id.next_param_index < fn_type_id.param_count; fn_type_id.next_param_index += 1) {
	949	AstNode *param_node = fn_proto->params.at(fn_type_id.next_param_index);
	950	assert(param_node->type == NodeTypeParamDecl);
	951
	952	bool param_is_inline = param_node->data.param_decl.is_inline;
	953
	954	if (param_is_inline) {
	955	if (fn_type_id.is_extern) {
	956	add_node_error(g, param_node,
	957	buf_sprintf("inline parameter not allowed in extern function"));
	958	return g->builtin_types.entry_invalid;
	959	}
	960	return get_generic_fn_type(g, &fn_type_id);
	961	}
	962
	963	if (fn_entry && buf_len(param_node->data.param_decl.name) == 0) {
	964	add_node_error(g, param_node, buf_sprintf("missing parameter name"));
890	965	}
891	966
	967	TypeTableEntry *type_entry = analyze_type_expr(g, child_scope, param_node->data.param_decl.type);
	968
892	969	switch (type_entry->id) {
893	970	case TypeTableEntryIdInvalid:
894		fn_proto->skip = true;
895		break;
896		case TypeTableEntryIdNumLitFloat:
897		case TypeTableEntryIdNumLitInt:
	971	return g->builtin_types.entry_invalid;
	972	case TypeTableEntryIdUnreachable:
898	973	case TypeTableEntryIdUndefLit:
899	974	case TypeTableEntryIdNullLit:
900		case TypeTableEntryIdUnreachable:
	975	add_node_error(g, param_node->data.param_decl.type,
	976	buf_sprintf("parameter of type '%s' not allowed", buf_ptr(&type_entry->name)));
	977	return g->builtin_types.entry_invalid;
	978	case TypeTableEntryIdVar:
	979	if (fn_type_id.is_extern) {
	980	add_node_error(g, param_node->data.param_decl.type,
	981	buf_sprintf("parameter of type 'var' not allowed in extern function"));
	982	return g->builtin_types.entry_invalid;
	983	}
	984	return get_generic_fn_type(g, &fn_type_id);
	985	case TypeTableEntryIdNumLitFloat:
	986	case TypeTableEntryIdNumLitInt:
901	987	case TypeTableEntryIdNamespace:
902	988	case TypeTableEntryIdBlock:
903		case TypeTableEntryIdGenericFn:
904	989	case TypeTableEntryIdBoundFn:
905		if (!fn_proto->skip) {
906		fn_proto->skip = true;
907		add_node_error(g, child->data.param_decl.type,
908		buf_sprintf("parameter of type '%s' not allowed", buf_ptr(&type_entry->name)));
909		}
910		break;
911	990	case TypeTableEntryIdMetaType:
912		if (!child->data.param_decl.is_inline) {
913		if (!fn_proto->skip) {
914		fn_proto->skip = true;
915		add_node_error(g, child->data.param_decl.type,
916		buf_sprintf("parameter of type '%s' must be declared inline",
917		buf_ptr(&type_entry->name)));
918		}
919		}
920		break;
	991	add_node_error(g, param_node->data.param_decl.type,
	992	buf_sprintf("parameter of type '%s' must be declared inline",
	993	buf_ptr(&type_entry->name)));
	994	return g->builtin_types.entry_invalid;
921	995	case TypeTableEntryIdVoid:
922	996	case TypeTableEntryIdBool:
923	997	case TypeTableEntryIdInt:
...	...	@@ -933,44 +1007,38 @@ static TypeTableEntry analyze_fn_proto_type(CodeGen g, ImportTableEntry *impor
933	1007	case TypeTableEntryIdFn:
934	1008	case TypeTableEntryIdTypeDecl:
935	1009	break;
936		case TypeTableEntryIdVar:
937		// var types are treated as generic functions; if we get to this code we should
938		// already be an instantiated function.
939		zig_unreachable();
940	1010	}
941		if (type_entry->id == TypeTableEntryIdInvalid) {
942		fn_proto->skip = true;
943		}
944		FnTypeParamInfo *param_info = &fn_type_id.param_info[i];
	1011	FnTypeParamInfo *param_info = &fn_type_id.param_info[fn_type_id.next_param_index];
945	1012	param_info->type = type_entry;
946		param_info->is_noalias = child->data.param_decl.is_noalias;
	1013	param_info->is_noalias = param_node->data.param_decl.is_noalias;
947	1014	}
948	1015
949		if (fn_proto->skip) {
950		fn_type_id.return_type = g->builtin_types.entry_invalid;
951		} else {
952		fn_type_id.return_type = analyze_type_expr(g, import, scope, fn_proto->return_type);
953		}
	1016	fn_type_id.return_type = analyze_type_expr(g, child_scope, fn_proto->return_type);
	1017
954	1018	switch (fn_type_id.return_type->id) {
955	1019	case TypeTableEntryIdInvalid:
956		fn_proto->skip = true;
957		break;
958		case TypeTableEntryIdNumLitFloat:
959		case TypeTableEntryIdNumLitInt:
	1020	return g->builtin_types.entry_invalid;
	1021
960	1022	case TypeTableEntryIdUndefLit:
961	1023	case TypeTableEntryIdNullLit:
	1024	add_node_error(g, fn_proto->return_type,
	1025	buf_sprintf("return type '%s' not allowed", buf_ptr(&fn_type_id.return_type->name)));
	1026	return g->builtin_types.entry_invalid;
	1027
	1028	case TypeTableEntryIdNumLitFloat:
	1029	case TypeTableEntryIdNumLitInt:
962	1030	case TypeTableEntryIdNamespace:
963	1031	case TypeTableEntryIdBlock:
964		case TypeTableEntryIdGenericFn:
965	1032	case TypeTableEntryIdBoundFn:
966	1033	case TypeTableEntryIdVar:
967		if (!fn_proto->skip) {
968		fn_proto->skip = true;
	1034	case TypeTableEntryIdMetaType:
	1035	if (fn_type_id.is_extern) {
969	1036	add_node_error(g, fn_proto->return_type,
970		buf_sprintf("return type '%s' not allowed", buf_ptr(&fn_type_id.return_type->name)));
	1037	buf_sprintf("return type '%s' not allowed in extern function",
	1038	buf_ptr(&fn_type_id.return_type->name)));
	1039	return g->builtin_types.entry_invalid;
971	1040	}
972		break;
973		case TypeTableEntryIdMetaType:
	1041	return get_generic_fn_type(g, &fn_type_id);
974	1042	case TypeTableEntryIdUnreachable:
975	1043	case TypeTableEntryIdVoid:
976	1044	case TypeTableEntryIdBool:
...	...	@@ -989,114 +1057,10 @@ static TypeTableEntry analyze_fn_proto_type(CodeGen g, ImportTableEntry *impor
989	1057	break;
990	1058	}
991	1059
992
993		if (fn_proto->skip) {
994		return g->builtin_types.entry_invalid;
995		}
996
997		if (fn_table_entry && fn_type_id.return_type->id == TypeTableEntryIdMetaType) {
998		ErrorMsg *err_msg = nullptr;
999		for (size_t i = 0; i < fn_proto->params.length; i += 1) {
1000		AstNode *param_decl_node = fn_proto->params.at(i);
1001		assert(param_decl_node->type == NodeTypeParamDecl);
1002		if (!param_decl_node->data.param_decl.is_inline) {
1003		if (!err_msg) {
1004		err_msg = add_node_error(g, fn_proto->return_type,
1005		buf_sprintf("function with return type '%s' must declare all parameters inline",
1006		buf_ptr(&fn_type_id.return_type->name)));
1007		}
1008		add_error_note(g, err_msg, param_decl_node,
1009		buf_sprintf("non-inline parameter here"));
1010		}
1011		}
1012		if (err_msg) {
1013		fn_proto->skip = true;
1014		return g->builtin_types.entry_invalid;
1015		}
1016		}
1017
1018		bool gen_debug_info = fn_table_entry && !fn_wants_full_static_eval(fn_table_entry);
1019		return get_fn_type(g, &fn_type_id, gen_debug_info);
1020		}
1021
1022		static void resolve_function_proto(CodeGen g, AstNode node, FnTableEntry *fn_table_entry,
1023		ImportTableEntry import, Scope containing_scope)
1024		{
1025		assert(node->type == NodeTypeFnProto);
1026		AstNodeFnProto *fn_proto = &node->data.fn_proto;
1027
1028		if (fn_proto->skip) {
1029		return;
1030		}
1031
1032		bool is_internal = (fn_proto->top_level_decl.visib_mod != VisibModExport);
1033		bool is_c_compat = !is_internal \|\| fn_proto->is_extern;
1034		fn_table_entry->internal_linkage = !is_c_compat;
1035
1036
1037
1038		TypeTableEntry *fn_type = analyze_fn_proto_type(g, import, containing_scope, nullptr, node,
1039		fn_proto->is_nakedcc, fn_proto->is_coldcc, fn_table_entry);
1040
1041		fn_table_entry->type_entry = fn_type;
1042
1043		if (fn_type->id == TypeTableEntryIdInvalid) {
1044		fn_proto->skip = true;
1045		return;
1046		}
1047
1048		if (fn_proto->is_inline) {
1049		fn_table_entry->fn_inline = FnInlineAlways;
1050		}
1051
1052
1053		Buf *symbol_name;
1054		if (is_c_compat) {
1055		symbol_name = &fn_table_entry->symbol_name;
1056		} else {
1057		symbol_name = buf_sprintf("_%s", buf_ptr(&fn_table_entry->symbol_name));
1058		}
1059
1060		if (fn_table_entry->fn_def_node) {
1061		fn_table_entry->fn_def_node->data.fn_def.containing_scope = create_fndef_scope(
1062		fn_table_entry->fn_def_node, containing_scope, fn_table_entry);
1063		}
1064
1065		if (!fn_wants_full_static_eval(fn_table_entry)) {
1066		fn_table_entry->fn_value = LLVMAddFunction(g->module, buf_ptr(symbol_name), fn_type->data.fn.raw_type_ref);
1067
1068		switch (fn_table_entry->fn_inline) {
1069		case FnInlineAlways:
1070		LLVMAddFunctionAttr(fn_table_entry->fn_value, LLVMAlwaysInlineAttribute);
1071		break;
1072		case FnInlineNever:
1073		LLVMAddFunctionAttr(fn_table_entry->fn_value, LLVMNoInlineAttribute);
1074		break;
1075		case FnInlineAuto:
1076		break;
1077		}
1078		if (fn_type->data.fn.fn_type_id.is_naked) {
1079		LLVMAddFunctionAttr(fn_table_entry->fn_value, LLVMNakedAttribute);
1080		}
1081
1082		LLVMSetLinkage(fn_table_entry->fn_value, fn_table_entry->internal_linkage ?
1083		LLVMInternalLinkage : LLVMExternalLinkage);
1084
1085		if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdUnreachable) {
1086		LLVMAddFunctionAttr(fn_table_entry->fn_value, LLVMNoReturnAttribute);
1087		}
1088		LLVMSetFunctionCallConv(fn_table_entry->fn_value, fn_type->data.fn.calling_convention);
1089		if (!fn_table_entry->is_extern) {
1090		LLVMAddFunctionAttr(fn_table_entry->fn_value, LLVMNoUnwindAttribute);
1091		}
1092		if (!g->is_release_build && fn_table_entry->fn_inline != FnInlineAlways) {
1093		ZigLLVMAddFunctionAttr(fn_table_entry->fn_value, "no-frame-pointer-elim", "true");
1094		ZigLLVMAddFunctionAttr(fn_table_entry->fn_value, "no-frame-pointer-elim-non-leaf", nullptr);
1095		}
1096		}
	1060	return get_fn_type(g, &fn_type_id);
1097	1061	}
1098	1062
1099		static void resolve_enum_type(CodeGen g, ImportTableEntry import, TypeTableEntry *enum_type) {
	1063	static void resolve_enum_type(CodeGen g, TypeTableEntry enum_type) {
1100	1064	// if you change this logic you likely must also change similar logic in parseh.cpp
1101	1065	assert(enum_type->id == TypeTableEntryIdEnum);
1102	1066
...	...	@@ -1133,6 +1097,7 @@ static void resolve_enum_type(CodeGen g, ImportTableEntry import, TypeTableEnt
1133	1097	uint64_t biggest_union_member_size_in_bits = 0;
1134	1098
1135	1099	Scope *scope = &enum_type->data.enumeration.decls_scope->base;
	1100	ImportTableEntry *import = get_scope_import(scope);
1136	1101
1137	1102	// set temporary flag
1138	1103	enum_type->data.enumeration.embedded_in_current = true;
...	...	@@ -1142,17 +1107,16 @@ static void resolve_enum_type(CodeGen g, ImportTableEntry import, TypeTableEnt
1142	1107	AstNode *field_node = decl_node->data.struct_decl.fields.at(i);
1143	1108	TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[i];
1144	1109	type_enum_field->name = field_node->data.struct_field.name;
1145		TypeTableEntry *field_type = analyze_type_expr(g, import, scope,
1146		field_node->data.struct_field.type);
	1110	TypeTableEntry *field_type = analyze_type_expr(g, scope, field_node->data.struct_field.type);
1147	1111	type_enum_field->type_entry = field_type;
1148	1112	type_enum_field->value = i;
1149	1113
1150	1114	di_enumerators[i] = ZigLLVMCreateDebugEnumerator(g->dbuilder, buf_ptr(type_enum_field->name), i);
1151	1115
1152	1116	if (field_type->id == TypeTableEntryIdStruct) {
1153		resolve_struct_type(g, import, field_type);
	1117	resolve_struct_type(g, field_type);
1154	1118	} else if (field_type->id == TypeTableEntryIdEnum) {
1155		resolve_enum_type(g, import, field_type);
	1119	resolve_enum_type(g, field_type);
1156	1120	} else if (field_type->id == TypeTableEntryIdInvalid) {
1157	1121	enum_type->data.enumeration.is_invalid = true;
1158	1122	continue;
...	...	@@ -1281,7 +1245,7 @@ static void resolve_enum_type(CodeGen g, ImportTableEntry import, TypeTableEnt
1281	1245	}
1282	1246	}
1283	1247
1284		static void resolve_struct_type(CodeGen g, ImportTableEntry import, TypeTableEntry *struct_type) {
	1248	static void resolve_struct_type(CodeGen g, TypeTableEntry struct_type) {
1285	1249	// if you change the logic of this function likely you must make a similar change in
1286	1250	// parseh.cpp
1287	1251	assert(struct_type->id == TypeTableEntryIdStruct);
...	...	@@ -1319,22 +1283,23 @@ static void resolve_struct_type(CodeGen g, ImportTableEntry import, TypeTableE
1319	1283	struct_type->data.structure.embedded_in_current = true;
1320	1284
1321	1285	Scope *scope = &struct_type->data.structure.decls_scope->base;
	1286	ImportTableEntry *import = get_scope_import(scope);
1322	1287
1323	1288	size_t gen_field_index = 0;
1324	1289	for (size_t i = 0; i < field_count; i += 1) {
1325	1290	AstNode *field_node = decl_node->data.struct_decl.fields.at(i);
1326	1291	TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
1327	1292	type_struct_field->name = field_node->data.struct_field.name;
1328		TypeTableEntry *field_type = analyze_type_expr(g, import, scope,
	1293	TypeTableEntry *field_type = analyze_type_expr(g, scope,
1329	1294	field_node->data.struct_field.type);
1330	1295	type_struct_field->type_entry = field_type;
1331	1296	type_struct_field->src_index = i;
1332	1297	type_struct_field->gen_index = SIZE_MAX;
1333	1298
1334	1299	if (field_type->id == TypeTableEntryIdStruct) {
1335		resolve_struct_type(g, import, field_type);
	1300	resolve_struct_type(g, field_type);
1336	1301	} else if (field_type->id == TypeTableEntryIdEnum) {
1337		resolve_enum_type(g, import, field_type);
	1302	resolve_enum_type(g, field_type);
1338	1303	} else if (field_type->id == TypeTableEntryIdInvalid) {
1339	1304	struct_type->data.structure.is_invalid = true;
1340	1305	continue;
...	...	@@ -1408,16 +1373,13 @@ static void resolve_struct_type(CodeGen g, ImportTableEntry import, TypeTableE
1408	1373	struct_type->zero_bits = (debug_size_in_bits == 0);
1409	1374	}
1410	1375
1411		static void resolve_union_type(CodeGen g, ImportTableEntry import, TypeTableEntry *enum_type) {
	1376	static void resolve_union_type(CodeGen g, TypeTableEntry union_type) {
1412	1377	zig_panic("TODO");
1413	1378	}
1414	1379
1415		static void get_fully_qualified_decl_name(Buf buf, AstNode decl_node, uint8_t sep) {
1416		TopLevelDecl *tld = get_as_top_level_decl(decl_node);
1417		AstNode *parent_decl = tld->parent_decl;
1418
1419		if (parent_decl) {
1420		get_fully_qualified_decl_name(buf, parent_decl, sep);
	1380	static void get_fully_qualified_decl_name(Buf buf, Tld tld, uint8_t sep) {
	1381	if (tld->parent_tld) {
	1382	get_fully_qualified_decl_name(buf, tld->parent_tld, sep);
1421	1383	buf_append_char(buf, sep);
1422	1384	buf_append_buf(buf, tld->name);
1423	1385	} else {
...	...	@@ -1425,183 +1387,109 @@ static void get_fully_qualified_decl_name(Buf buf, AstNode decl_node, uint8_t
1425	1387	}
1426	1388	}
1427	1389
1428		static void preview_generic_fn_proto(CodeGen g, ImportTableEntry import, AstNode *node) {
1429		assert(node->type == NodeTypeContainerDecl);
1430
1431		if (node->data.struct_decl.generic_params_is_var_args) {
1432		add_node_error(g, node, buf_sprintf("generic parameters cannot be var args"));
1433		node->data.struct_decl.skip = true;
1434		node->data.struct_decl.generic_fn_type = g->builtin_types.entry_invalid;
1435		return;
1436		}
1437
1438		node->data.struct_decl.generic_fn_type = get_generic_fn_type(g, node);
1439		}
1440
1441		static bool get_is_generic_fn(AstNode *proto_node) {
	1390	static void resolve_decl_fn(CodeGen g, TldFn tld_fn) {
	1391	ImportTableEntry *import = tld_fn->base.import;
	1392	AstNode *proto_node = tld_fn->base.source_node;
1442	1393	assert(proto_node->type == NodeTypeFnProto);
1443		return proto_node->data.fn_proto.inline_or_var_type_arg_count > 0;
1444		}
1445
1446		static void preview_fn_proto_instance(CodeGen g, ImportTableEntry import, AstNode *proto_node,
1447		Scope *containing_scope)
1448		{
1449		assert(proto_node->type == NodeTypeFnProto);
1450
1451		if (proto_node->data.fn_proto.skip) {
1452		return;
1453		}
	1394	AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
1454	1395
1455		bool is_generic_instance = proto_node->data.fn_proto.generic_proto_node;
1456		bool is_generic_fn = get_is_generic_fn(proto_node);
1457		assert(!is_generic_instance \|\| !is_generic_fn);
	1396	AstNode *fn_def_node = fn_proto->fn_def_node;
1458	1397
1459		AstNode *parent_decl = proto_node->data.fn_proto.top_level_decl.parent_decl;
1460		Buf *proto_name = proto_node->data.fn_proto.name;
1461
1462		AstNode *fn_def_node = proto_node->data.fn_proto.fn_def_node;
1463		bool is_extern = proto_node->data.fn_proto.is_extern;
1464
1465		assert(!is_extern \|\| !is_generic_instance);
1466
1467		if (fn_def_node && proto_node->data.fn_proto.is_var_args) {
	1398	if (fn_def_node && fn_proto->is_var_args) {
1468	1399	add_node_error(g, proto_node,
1469	1400	buf_sprintf("variadic arguments only allowed in extern function declarations"));
	1401	tld_fn->base.resolution = TldResolutionInvalid;
	1402	return;
1470	1403	}
1471	1404
1472	1405	FnTableEntry *fn_table_entry = allocate<FnTableEntry>(1);
1473	1406	fn_table_entry->analyzed_executable.backward_branch_quota = default_backward_branch_quota;
	1407	fn_table_entry->ir_executable.fn_entry = fn_table_entry;
	1408	fn_table_entry->analyzed_executable.fn_entry = fn_table_entry;
1474	1409	fn_table_entry->import_entry = import;
1475	1410	fn_table_entry->proto_node = proto_node;
1476	1411	fn_table_entry->fn_def_node = fn_def_node;
1477		fn_table_entry->is_extern = is_extern;
	1412	fn_table_entry->fn_inline = fn_proto->is_inline ? FnInlineAlways : FnInlineAuto;
	1413	fn_table_entry->internal_linkage = (fn_proto->visib_mod != VisibModExport);
1478	1414
1479		get_fully_qualified_decl_name(&fn_table_entry->symbol_name, proto_node, '_');
	1415	get_fully_qualified_decl_name(&fn_table_entry->symbol_name, &tld_fn->base, '_');
1480	1416
1481		proto_node->data.fn_proto.fn_table_entry = fn_table_entry;
	1417	tld_fn->fn_entry = fn_table_entry;
1482	1418
1483		if (is_generic_fn) {
1484		fn_table_entry->type_entry = get_generic_fn_type(g, proto_node);
	1419	if (fn_table_entry->fn_def_node) {
	1420	fn_table_entry->fndef_scope = create_fndef_scope(
	1421	fn_table_entry->fn_def_node, tld_fn->base.parent_scope, fn_table_entry);
	1422	}
1485	1423
1486		if (is_extern \|\| proto_node->data.fn_proto.top_level_decl.visib_mod == VisibModExport) {
1487		for (size_t i = 0; i < proto_node->data.fn_proto.params.length; i += 1) {
1488		AstNode *param_decl_node = proto_node->data.fn_proto.params.at(i);
1489		if (param_decl_node->data.param_decl.is_inline) {
1490		proto_node->data.fn_proto.skip = true;
1491		add_node_error(g, param_decl_node,
1492		buf_sprintf("inline parameter not allowed in extern function"));
1493		}
1494		}
1495		}
	1424	fn_table_entry->type_entry = analyze_fn_type(g, tld_fn);
1496	1425
	1426	if (fn_table_entry->type_entry->id == TypeTableEntryIdInvalid) {
	1427	tld_fn->base.resolution = TldResolutionInvalid;
	1428	return;
	1429	}
1497	1430
1498		} else {
1499		resolve_function_proto(g, proto_node, fn_table_entry, import, containing_scope);
	1431	if (!fn_table_entry->type_entry->data.fn.is_generic) {
	1432	g->fn_protos.append(fn_table_entry);
1500	1433
1501		if (!fn_wants_full_static_eval(fn_table_entry)) {
1502		g->fn_protos.append(fn_table_entry);
	1434	if (fn_def_node)
	1435	g->fn_defs.append(fn_table_entry);
1503	1436
1504		if (fn_def_node) {
1505		g->fn_defs.append(fn_table_entry);
1506		}
	1437	Tld *parent_tld = tld_fn->base.parent_tld;
	1438	bool is_main_fn = !parent_tld && (import == g->root_import) &&
	1439	buf_eql_str(&fn_table_entry->symbol_name, "main");
	1440	if (is_main_fn)
	1441	g->main_fn = fn_table_entry;
1507	1442
1508		bool is_main_fn = !is_generic_instance &&
1509		!parent_decl && (import == g->root_import) &&
1510		!proto_node->data.fn_proto.skip &&
1511		buf_eql_str(proto_name, "main");
1512		if (is_main_fn) {
1513		g->main_fn = fn_table_entry;
1514		}
1515
1516		if (is_main_fn && !g->link_libc) {
1517		TypeTableEntry *err_void = get_error_type(g, g->builtin_types.entry_void);
1518		TypeTableEntry *actual_return_type = fn_table_entry->type_entry->data.fn.fn_type_id.return_type;
1519		if (actual_return_type != err_void) {
1520		AstNode *return_type_node = fn_table_entry->proto_node->data.fn_proto.return_type;
1521		add_node_error(g, return_type_node,
1522		buf_sprintf("expected return type of main to be '%%void', instead is '%s'",
1523		buf_ptr(&actual_return_type->name)));
1524		}
	1443	if (is_main_fn && !g->link_libc) {
	1444	TypeTableEntry *err_void = get_error_type(g, g->builtin_types.entry_void);
	1445	TypeTableEntry *actual_return_type = fn_table_entry->type_entry->data.fn.fn_type_id.return_type;
	1446	if (actual_return_type != err_void) {
	1447	add_node_error(g, fn_proto->return_type,
	1448	buf_sprintf("expected return type of main to be '%%void', instead is '%s'",
	1449	buf_ptr(&actual_return_type->name)));
1525	1450	}
1526	1451	}
1527	1452	}
1528	1453	}
1529	1454
1530		static void add_top_level_decl(CodeGen g, ImportTableEntry import, ScopeDecls *decls_scope,
1531		AstNode node, Buf name)
1532		{
1533		assert(import);
1534
1535		TopLevelDecl *tld = get_as_top_level_decl(node);
1536		tld->import = import;
1537		tld->name = name;
1538
	1455	static void add_top_level_decl(CodeGen g, ScopeDecls decls_scope, Tld *tld) {
1539	1456	bool want_to_resolve = (g->check_unused \|\| g->is_test_build \|\| tld->visib_mod == VisibModExport);
1540		bool is_generic_container = (node->type == NodeTypeContainerDecl &&
1541		node->data.struct_decl.generic_params.length > 0);
1542		if (want_to_resolve && !is_generic_container) {
1543		g->resolve_queue.append(node);
1544		}
	1457	if (want_to_resolve)
	1458	g->resolve_queue.append(tld);
1545	1459
1546		node->scope = &decls_scope->base;
1547
1548		auto entry = decls_scope->decl_table.put_unique(name, node);
	1460	auto entry = decls_scope->decl_table.put_unique(tld->name, tld);
1549	1461	if (entry) {
1550		AstNode *other_decl_node = entry->value;
1551		ErrorMsg *msg = add_node_error(g, node, buf_sprintf("redefinition of '%s'", buf_ptr(name)));
1552		add_error_note(g, msg, other_decl_node, buf_sprintf("previous definition is here"));
	1462	Tld *other_tld = entry->value;
	1463	ErrorMsg *msg = add_node_error(g, tld->source_node, buf_sprintf("redefinition of '%s'", buf_ptr(tld->name)));
	1464	add_error_note(g, msg, other_tld->source_node, buf_sprintf("previous definition is here"));
	1465	return;
1553	1466	}
1554	1467	}
1555	1468
1556		static void scan_struct_decl(CodeGen g, ImportTableEntry import, ScopeDecls decls_scope, AstNode node) {
1557		assert(node->type == NodeTypeContainerDecl);
	1469	static void scan_struct_decl(CodeGen g, ScopeDecls decls_scope, TldContainer *tld_container) {
	1470	assert(!tld_container->type_entry);
1558	1471
1559		if (node->data.struct_decl.type_entry) {
1560		// already scanned; we can ignore. This can happen from importing from an .h file.
1561		return;
1562		}
	1472	AstNode *container_node = tld_container->base.source_node;
	1473	assert(container_node->type == NodeTypeContainerDecl);
1563	1474
1564		Buf *name = node->data.struct_decl.name;
1565		TypeTableEntry *container_type = get_partial_container_type(g, import, &decls_scope->base,
1566		node->data.struct_decl.kind, node, buf_ptr(name));
1567		node->data.struct_decl.type_entry = container_type;
	1475	TypeTableEntry *container_type = get_partial_container_type_tld(g, &decls_scope->base, tld_container);
	1476	tld_container->type_entry = container_type;
1568	1477
1569	1478	// handle the member function definitions independently
1570		for (size_t i = 0; i < node->data.struct_decl.decls.length; i += 1) {
1571		AstNode *child_node = node->data.struct_decl.decls.at(i);
1572		get_as_top_level_decl(child_node)->parent_decl = node;
	1479	for (size_t i = 0; i < container_node->data.struct_decl.decls.length; i += 1) {
	1480	AstNode *child_node = container_node->data.struct_decl.decls.at(i);
1573	1481	ScopeDecls *child_scope = get_container_scope(container_type);
1574		scan_decls(g, import, child_scope, child_node);
1575		}
1576		}
1577
1578		static void count_inline_and_var_args(AstNode *proto_node) {
1579		assert(proto_node->type == NodeTypeFnProto);
1580
1581		size_t *inline_arg_count = &proto_node->data.fn_proto.inline_arg_count;
1582		size_t *inline_or_var_type_arg_count = &proto_node->data.fn_proto.inline_or_var_type_arg_count;
1583
1584		*inline_arg_count = 0;
1585		*inline_or_var_type_arg_count = 0;
1586
1587		// TODO run these nodes through the type analysis system rather than looking for
1588		// specialized ast nodes. this would get fooled by `{var}` instead of `var` which
1589		// is supposed to be equivalent
1590		for (size_t i = 0; i < proto_node->data.fn_proto.params.length; i += 1) {
1591		AstNode *param_node = proto_node->data.fn_proto.params.at(i);
1592		assert(param_node->type == NodeTypeParamDecl);
1593		if (param_node->data.param_decl.is_inline) {
1594		*inline_arg_count += 1;
1595		*inline_or_var_type_arg_count += 1;
1596		} else if (param_node->data.param_decl.type->type == NodeTypeVarLiteral) {
1597		*inline_or_var_type_arg_count += 1;
1598		}
	1482	scan_decls(g, tld_container->base.import, child_scope, child_node, &tld_container->base);
1599	1483	}
1600	1484	}
1601	1485
1602	1486	static void preview_error_value_decl(CodeGen g, AstNode node) {
1603	1487	assert(node->type == NodeTypeErrorValueDecl);
1604	1488
	1489	if (node->data.error_value_decl.visib_mod != VisibModPrivate) {
	1490	add_node_error(g, node, buf_sprintf("error values require no visibility modifier"));
	1491	}
	1492
1605	1493	ErrorTableEntry *err = allocate<ErrorTableEntry>(1);
1606	1494
1607	1495	err->decl_node = node;
...	...	@@ -1620,40 +1508,61 @@ static void preview_error_value_decl(CodeGen g, AstNode node) {
1620	1508	}
1621	1509
1622	1510	node->data.error_value_decl.err = err;
1623		node->data.error_value_decl.top_level_decl.resolution = TldResolutionOk;
1624	1511	}
1625	1512
1626		void scan_decls(CodeGen g, ImportTableEntry import, ScopeDecls decls_scope, AstNode node) {
	1513	void init_tld(Tld tld, TldId id, Buf name, VisibMod visib_mod, AstNode *source_node,
	1514	Scope parent_scope, Tld parent_tld)
	1515	{
	1516	tld->id = id;
	1517	tld->name = name;
	1518	tld->visib_mod = visib_mod;
	1519	tld->source_node = source_node;
	1520	tld->import = source_node->owner;
	1521	tld->parent_scope = parent_scope;
	1522	tld->parent_tld = parent_tld;
	1523	}
	1524
	1525	void scan_decls(CodeGen g, ImportTableEntry import, ScopeDecls decls_scope, AstNode node, Tld *parent_tld) {
1627	1526	switch (node->type) {
1628	1527	case NodeTypeRoot:
1629	1528	for (size_t i = 0; i < import->root->data.root.top_level_decls.length; i += 1) {
1630	1529	AstNode *child = import->root->data.root.top_level_decls.at(i);
1631		scan_decls(g, import, decls_scope, child);
	1530	scan_decls(g, import, decls_scope, child, parent_tld);
1632	1531	}
1633	1532	break;
1634	1533	case NodeTypeContainerDecl:
1635	1534	{
1636	1535	Buf *name = node->data.struct_decl.name;
1637		add_top_level_decl(g, import, decls_scope, node, name);
	1536	VisibMod visib_mod = node->data.struct_decl.visib_mod;
	1537	TldContainer *tld_container = allocate<TldContainer>(1);
	1538	init_tld(&tld_container->base, TldIdContainer, name, visib_mod, node, &decls_scope->base, parent_tld);
	1539	add_top_level_decl(g, decls_scope, &tld_container->base);
1638	1540	if (node->data.struct_decl.generic_params.length == 0) {
1639		scan_struct_decl(g, import, decls_scope, node);
	1541	scan_struct_decl(g, decls_scope, tld_container);
	1542	} else {
	1543	zig_panic("TODO all structs anonymous?");
1640	1544	}
1641	1545	}
1642	1546	break;
1643	1547	case NodeTypeFnDef:
1644		node->data.fn_def.fn_proto->data.fn_proto.fn_def_node = node;
1645		scan_decls(g, import, decls_scope, node->data.fn_def.fn_proto);
	1548	scan_decls(g, import, decls_scope, node->data.fn_def.fn_proto, parent_tld);
1646	1549	break;
1647	1550	case NodeTypeVariableDeclaration:
1648	1551	{
1649	1552	Buf *name = node->data.variable_declaration.symbol;
1650		add_top_level_decl(g, import, decls_scope, node, name);
	1553	VisibMod visib_mod = node->data.variable_declaration.visib_mod;
	1554	TldVar *tld_var = allocate<TldVar>(1);
	1555	init_tld(&tld_var->base, TldIdVar, name, visib_mod, node, &decls_scope->base, parent_tld);
	1556	add_top_level_decl(g, decls_scope, &tld_var->base);
1651	1557	break;
1652	1558	}
1653	1559	case NodeTypeTypeDecl:
1654	1560	{
1655	1561	Buf *name = node->data.type_decl.symbol;
1656		add_top_level_decl(g, import, decls_scope, node, name);
	1562	VisibMod visib_mod = node->data.type_decl.visib_mod;
	1563	TldTypeDef *tld_typedef = allocate<TldTypeDef>(1);
	1564	init_tld(&tld_typedef->base, TldIdTypeDef, name, visib_mod, node, &decls_scope->base, parent_tld);
	1565	add_top_level_decl(g, decls_scope, &tld_typedef->base);
1657	1566	break;
1658	1567	}
1659	1568	case NodeTypeFnProto:
...	...	@@ -1661,22 +1570,20 @@ void scan_decls(CodeGen g, ImportTableEntry import, ScopeDecls *decls_scope, A
1661	1570	// if the name is missing, we immediately announce an error
1662	1571	Buf *fn_name = node->data.fn_proto.name;
1663	1572	if (buf_len(fn_name) == 0) {
1664		node->data.fn_proto.skip = true;
1665	1573	add_node_error(g, node, buf_sprintf("missing function name"));
1666	1574	break;
1667	1575	}
1668		count_inline_and_var_args(node);
1669	1576
1670		add_top_level_decl(g, import, decls_scope, node, fn_name);
	1577	VisibMod visib_mod = node->data.fn_proto.visib_mod;
	1578	TldFn *tld_fn = allocate<TldFn>(1);
	1579	init_tld(&tld_fn->base, TldIdFn, fn_name, visib_mod, node, &decls_scope->base, parent_tld);
	1580	add_top_level_decl(g, decls_scope, &tld_fn->base);
1671	1581	break;
1672	1582	}
1673	1583	case NodeTypeUse:
1674	1584	{
1675		TopLevelDecl *tld = get_as_top_level_decl(node);
1676		tld->import = import;
1677		node->scope = &decls_scope->base;
1678	1585	g->use_queue.append(node);
1679		tld->import->use_decls.append(node);
	1586	import->use_decls.append(node);
1680	1587	break;
1681	1588	}
1682	1589	case NodeTypeErrorValueDecl:
...	...	@@ -1727,30 +1634,22 @@ void scan_decls(CodeGen g, ImportTableEntry import, ScopeDecls *decls_scope, A
1727	1634	}
1728	1635	}
1729	1636
1730		static void resolve_struct_instance(CodeGen g, ImportTableEntry import, AstNode *node) {
1731		TypeTableEntry *type_entry = node->data.struct_decl.type_entry;
	1637	static void resolve_decl_container(CodeGen g, TldContainer tld_container) {
	1638	TypeTableEntry *type_entry = tld_container->type_entry;
1732	1639	assert(type_entry);
1733	1640
1734		// struct/enum member fns will get resolved independently
1735
1736		switch (node->data.struct_decl.kind) {
1737		case ContainerKindStruct:
1738		resolve_struct_type(g, import, type_entry);
1739		break;
	1641	switch (type_entry->id) {
	1642	case TypeTableEntryIdStruct:
	1643	resolve_struct_type(g, tld_container->type_entry);
	1644	return;
1740	1645	case ContainerKindEnum:
1741		resolve_enum_type(g, import, type_entry);
1742		break;
	1646	resolve_enum_type(g, tld_container->type_entry);
	1647	return;
1743	1648	case ContainerKindUnion:
1744		resolve_union_type(g, import, type_entry);
1745		break;
1746		}
1747		}
1748
1749		static void resolve_struct_decl(CodeGen g, ImportTableEntry import, AstNode *node) {
1750		if (node->data.struct_decl.generic_params.length > 0) {
1751		return preview_generic_fn_proto(g, import, node);
1752		} else {
1753		return resolve_struct_instance(g, import, node);
	1649	resolve_union_type(g, tld_container->type_entry);
	1650	return;
	1651	default:
	1652	zig_unreachable();
1754	1653	}
1755	1654	}
1756	1655
...	...	@@ -1786,7 +1685,6 @@ TypeTableEntry validate_var_type(CodeGen g, AstNode *source_node, TypeTableEnt
1786	1685	case TypeTableEntryIdEnum:
1787	1686	case TypeTableEntryIdUnion:
1788	1687	case TypeTableEntryIdFn:
1789		case TypeTableEntryIdGenericFn:
1790	1688	case TypeTableEntryIdBoundFn:
1791	1689	return type_entry;
1792	1690	}
...	...	@@ -1795,15 +1693,16 @@ TypeTableEntry validate_var_type(CodeGen g, AstNode *source_node, TypeTableEnt
1795	1693
1796	1694	// Set name to nullptr to make the variable anonymous (not visible to programmer).
1797	1695	// TODO merge with definition of add_local_var in ir.cpp
1798		static VariableTableEntry add_local_var(CodeGen g, AstNode source_node, ImportTableEntry import,
1799		Scope parent_scope, Buf name, TypeTableEntry type_entry, bool is_const, AstNode val_node)
	1696	VariableTableEntry add_variable(CodeGen g, AstNode source_node, Scope parent_scope, Buf *name,
	1697	TypeTableEntry type_entry, bool is_const, ConstExprValue init_value)
1800	1698	{
1801	1699	VariableTableEntry *variable_entry = allocate<VariableTableEntry>(1);
1802	1700	variable_entry->type = type_entry;
1803	1701	variable_entry->parent_scope = parent_scope;
1804		variable_entry->import = import;
1805	1702	variable_entry->shadowable = false;
1806	1703	variable_entry->mem_slot_index = SIZE_MAX;
	1704	variable_entry->value = init_value;
	1705	variable_entry->src_arg_index = SIZE_MAX;
1807	1706
1808	1707	assert(name);
1809	1708
...	...	@@ -1824,11 +1723,11 @@ static VariableTableEntry add_local_var(CodeGen g, AstNode *source_node, Impor
1824	1723	buf_sprintf("variable shadows type '%s'", buf_ptr(&type->name)));
1825	1724	variable_entry->type = g->builtin_types.entry_invalid;
1826	1725	} else {
1827		AstNode *decl_node = find_decl(parent_scope, name);
1828		if (decl_node && decl_node->type != NodeTypeVariableDeclaration) {
	1726	Tld *tld = find_decl(parent_scope, name);
	1727	if (tld && tld->id != TldIdVar) {
1829	1728	ErrorMsg *msg = add_node_error(g, source_node,
1830	1729	buf_sprintf("redefinition of '%s'", buf_ptr(name)));
1831		add_error_note(g, msg, decl_node, buf_sprintf("previous definition is here"));
	1730	add_error_note(g, msg, tld->source_node, buf_sprintf("previous definition is here"));
1832	1731	variable_entry->type = g->builtin_types.entry_invalid;
1833	1732	}
1834	1733	}
...	...	@@ -1847,78 +1746,84 @@ static VariableTableEntry add_local_var(CodeGen g, AstNode *source_node, Impor
1847	1746	variable_entry->src_is_const = is_const;
1848	1747	variable_entry->gen_is_const = is_const;
1849	1748	variable_entry->decl_node = source_node;
1850		variable_entry->val_node = val_node;
1851	1749	variable_entry->child_scope = child_scope;
1852	1750
1853	1751
1854	1752	return variable_entry;
1855	1753	}
1856	1754
1857		static void resolve_var_decl(CodeGen g, ImportTableEntry import, AstNode *node) {
1858		assert(node->type == NodeTypeVariableDeclaration);
	1755	static void resolve_decl_var(CodeGen g, TldVar tld_var) {
	1756	AstNodeVariableDeclaration *var_decl = &tld_var->base.source_node->data.variable_declaration;
1859	1757
1860		AstNodeVariableDeclaration *var_decl = &node->data.variable_declaration;
1861		Scope *scope = node->scope;
1862	1758	bool is_const = var_decl->is_const;
1863		bool is_export = (var_decl->top_level_decl.visib_mod == VisibModExport);
	1759	bool is_export = (tld_var->base.visib_mod == VisibModExport);
1864	1760	bool is_extern = var_decl->is_extern;
1865	1761
1866	1762	TypeTableEntry *explicit_type = nullptr;
1867	1763	if (var_decl->type) {
1868		TypeTableEntry *proposed_type = analyze_type_expr(g, import, scope, var_decl->type);
	1764	TypeTableEntry *proposed_type = analyze_type_expr(g, tld_var->base.parent_scope, var_decl->type);
1869	1765	explicit_type = validate_var_type(g, var_decl->type, proposed_type);
1870	1766	}
1871	1767
	1768	AstNode *source_node = tld_var->base.source_node;
	1769
	1770	IrInstruction *init_value = nullptr;
	1771
1872	1772	TypeTableEntry *implicit_type = nullptr;
1873	1773	if (explicit_type && explicit_type->id == TypeTableEntryIdInvalid) {
1874	1774	implicit_type = explicit_type;
1875	1775	} else if (var_decl->expr) {
1876		IrInstruction *result = analyze_const_value(g, scope, var_decl->expr, explicit_type);
1877		assert(result);
1878		implicit_type = result->type_entry;
	1776	init_value = analyze_const_value(g, tld_var->base.parent_scope, var_decl->expr, explicit_type);
	1777	assert(init_value);
	1778	implicit_type = init_value->type_entry;
1879	1779
1880	1780	if (implicit_type->id == TypeTableEntryIdUnreachable) {
1881		add_node_error(g, node, buf_sprintf("variable initialization is unreachable"));
	1781	add_node_error(g, source_node, buf_sprintf("variable initialization is unreachable"));
1882	1782	implicit_type = g->builtin_types.entry_invalid;
1883	1783	} else if ((!is_const \|\| is_export) &&
1884	1784	(implicit_type->id == TypeTableEntryIdNumLitFloat \|\|
1885	1785	implicit_type->id == TypeTableEntryIdNumLitInt))
1886	1786	{
1887		add_node_error(g, node, buf_sprintf("unable to infer variable type"));
	1787	add_node_error(g, source_node, buf_sprintf("unable to infer variable type"));
1888	1788	implicit_type = g->builtin_types.entry_invalid;
1889	1789	} else if (implicit_type->id == TypeTableEntryIdNullLit) {
1890		add_node_error(g, node, buf_sprintf("unable to infer variable type"));
	1790	add_node_error(g, source_node, buf_sprintf("unable to infer variable type"));
1891	1791	implicit_type = g->builtin_types.entry_invalid;
1892	1792	} else if (implicit_type->id == TypeTableEntryIdMetaType && !is_const) {
1893		add_node_error(g, node, buf_sprintf("variable of type 'type' must be constant"));
	1793	add_node_error(g, source_node, buf_sprintf("variable of type 'type' must be constant"));
1894	1794	implicit_type = g->builtin_types.entry_invalid;
1895	1795	}
1896		if (implicit_type->id != TypeTableEntryIdInvalid) {
1897		assert(result->static_value.special != ConstValSpecialRuntime);
1898		var_decl->top_level_decl.value = result;
1899		}
	1796	assert(implicit_type->id == TypeTableEntryIdInvalid \|\| init_value->static_value.special != ConstValSpecialRuntime);
1900	1797	} else if (!is_extern) {
1901		add_node_error(g, node, buf_sprintf("variables must be initialized"));
	1798	add_node_error(g, source_node, buf_sprintf("variables must be initialized"));
1902	1799	implicit_type = g->builtin_types.entry_invalid;
1903	1800	}
1904	1801
1905	1802	TypeTableEntry *type = explicit_type ? explicit_type : implicit_type;
1906	1803	assert(type != nullptr); // should have been caught by the parser
1907	1804
1908		VariableTableEntry *var = add_local_var(g, node, import, scope,
1909		var_decl->symbol, type, is_const, var_decl->expr);
	1805	tld_var->var = add_variable(g, source_node, tld_var->base.parent_scope,
	1806	var_decl->symbol, type, is_const, &init_value->static_value);
	1807
	1808	g->global_vars.append(tld_var->var);
	1809	}
1910	1810
1911		var_decl->variable = var;
	1811	static void resolve_decl_typedef(CodeGen g, TldTypeDef tld_typedef) {
	1812	AstNode *typedef_node = tld_typedef->base.source_node;
	1813	assert(typedef_node->type == NodeTypeTypeDecl);
	1814	AstNode *type_node = typedef_node->data.type_decl.child_type;
	1815	Buf *decl_name = typedef_node->data.type_decl.symbol;
1912	1816
1913		g->global_vars.append(var);
	1817	TypeTableEntry *child_type = analyze_type_expr(g, tld_typedef->base.parent_scope, type_node);
	1818	tld_typedef->type_entry = (child_type->id == TypeTableEntryIdInvalid) ?
	1819	child_type : get_typedecl_type(g, buf_ptr(decl_name), child_type);
1914	1820	}
1915	1821
1916		void resolve_top_level_decl(CodeGen g, AstNode node, bool pointer_only) {
1917		TopLevelDecl *tld = get_as_top_level_decl(node);
1918		if (tld->resolution != TldResolutionUnresolved) {
	1822	void resolve_top_level_decl(CodeGen g, Tld tld, bool pointer_only) {
	1823	if (tld->resolution != TldResolutionUnresolved)
1919	1824	return;
1920		}
1921		if (pointer_only && node->type == NodeTypeContainerDecl) {
	1825	if (pointer_only && tld->id == TldIdContainer) {
	1826	g->resolve_queue.append(tld);
1922	1827	return;
1923	1828	}
1924	1829
...	...	@@ -1926,90 +1831,38 @@ void resolve_top_level_decl(CodeGen g, AstNode node, bool pointer_only) {
1926	1831	assert(import);
1927	1832
1928	1833	if (tld->dep_loop_flag) {
1929		add_node_error(g, node, buf_sprintf("'%s' depends on itself", buf_ptr(tld->name)));
	1834	add_node_error(g, tld->source_node, buf_sprintf("'%s' depends on itself", buf_ptr(tld->name)));
1930	1835	tld->resolution = TldResolutionInvalid;
1931	1836	return;
1932	1837	} else {
1933	1838	tld->dep_loop_flag = true;
1934	1839	}
1935	1840
1936		switch (node->type) {
1937		case NodeTypeFnProto:
1938		preview_fn_proto_instance(g, import, node, node->scope);
1939		break;
1940		case NodeTypeContainerDecl:
1941		resolve_struct_decl(g, import, node);
1942		break;
1943		case NodeTypeVariableDeclaration:
1944		resolve_var_decl(g, import, node);
1945		break;
1946		case NodeTypeTypeDecl:
	1841	switch (tld->id) {
	1842	case TldIdVar:
1947	1843	{
1948		AstNode *type_node = node->data.type_decl.child_type;
1949		Buf *decl_name = node->data.type_decl.symbol;
1950
1951		TypeTableEntry *entry;
1952		if (node->data.type_decl.override_type) {
1953		entry = node->data.type_decl.override_type;
1954		} else {
1955		TypeTableEntry *child_type = analyze_type_expr(g, import, &import->decls_scope->base, type_node);
1956		if (child_type->id == TypeTableEntryIdInvalid) {
1957		entry = child_type;
1958		} else {
1959		entry = get_typedecl_type(g, buf_ptr(decl_name), child_type);
1960		}
1961		}
1962		node->data.type_decl.child_type_entry = entry;
	1844	TldVar tld_var = (TldVar )tld;
	1845	resolve_decl_var(g, tld_var);
	1846	break;
	1847	}
	1848	case TldIdFn:
	1849	{
	1850	TldFn tld_fn = (TldFn )tld;
	1851	resolve_decl_fn(g, tld_fn);
	1852	break;
	1853	}
	1854	case TldIdContainer:
	1855	{
	1856	TldContainer tld_container = (TldContainer )tld;
	1857	resolve_decl_container(g, tld_container);
	1858	break;
	1859	}
	1860	case TldIdTypeDef:
	1861	{
	1862	TldTypeDef tld_typedef = (TldTypeDef )tld;
	1863	resolve_decl_typedef(g, tld_typedef);
1963	1864	break;
1964	1865	}
1965		case NodeTypeErrorValueDecl:
1966		break;
1967		case NodeTypeUse:
1968		zig_panic("TODO resolve_top_level_decl NodeTypeUse");
1969		break;
1970		case NodeTypeFnDef:
1971		case NodeTypeParamDecl:
1972		case NodeTypeFnDecl:
1973		case NodeTypeReturnExpr:
1974		case NodeTypeDefer:
1975		case NodeTypeRoot:
1976		case NodeTypeBlock:
1977		case NodeTypeBinOpExpr:
1978		case NodeTypeUnwrapErrorExpr:
1979		case NodeTypeFnCallExpr:
1980		case NodeTypeArrayAccessExpr:
1981		case NodeTypeSliceExpr:
1982		case NodeTypeNumberLiteral:
1983		case NodeTypeStringLiteral:
1984		case NodeTypeCharLiteral:
1985		case NodeTypeBoolLiteral:
1986		case NodeTypeNullLiteral:
1987		case NodeTypeUndefinedLiteral:
1988		case NodeTypeZeroesLiteral:
1989		case NodeTypeThisLiteral:
1990		case NodeTypeSymbol:
1991		case NodeTypePrefixOpExpr:
1992		case NodeTypeIfBoolExpr:
1993		case NodeTypeIfVarExpr:
1994		case NodeTypeWhileExpr:
1995		case NodeTypeForExpr:
1996		case NodeTypeSwitchExpr:
1997		case NodeTypeSwitchProng:
1998		case NodeTypeSwitchRange:
1999		case NodeTypeLabel:
2000		case NodeTypeGoto:
2001		case NodeTypeBreak:
2002		case NodeTypeContinue:
2003		case NodeTypeAsmExpr:
2004		case NodeTypeFieldAccessExpr:
2005		case NodeTypeStructField:
2006		case NodeTypeStructValueField:
2007		case NodeTypeContainerInitExpr:
2008		case NodeTypeArrayType:
2009		case NodeTypeErrorType:
2010		case NodeTypeTypeLiteral:
2011		case NodeTypeVarLiteral:
2012		zig_unreachable();
2013	1866	}
2014	1867
2015	1868	tld->resolution = TldResolutionOk;
...	...	@@ -2028,7 +1881,6 @@ static bool type_has_codegen_value(TypeTableEntry *type_entry) {
2028	1881	case TypeTableEntryIdNullLit:
2029	1882	case TypeTableEntryIdNamespace:
2030	1883	case TypeTableEntryIdBlock:
2031		case TypeTableEntryIdGenericFn:
2032	1884	case TypeTableEntryIdBoundFn:
2033	1885	return false;
2034	1886
...	...	@@ -2142,68 +1994,7 @@ bool types_match_const_cast_only(TypeTableEntry expected_type, TypeTableEntry
2142	1994	return false;
2143	1995	}
2144	1996
2145		ScopeDecls create_decls_scope(AstNode node, Scope *parent) {
2146		assert(node->type == NodeTypeRoot \|\| node->type == NodeTypeContainerDecl);
2147		ScopeDecls *scope = allocate<ScopeDecls>(1);
2148		scope->base.node = node;
2149		scope->base.parent = parent;
2150		scope->decl_table.init(4);
2151		return scope;
2152		}
2153
2154		Scope create_block_scope(AstNode node, Scope *parent) {
2155		assert(node->type == NodeTypeBlock);
2156		ScopeBlock *scope = allocate<ScopeBlock>(1);
2157		scope->base.node = node;
2158		scope->base.parent = parent;
2159		scope->label_table.init(1);
2160		return &scope->base;
2161		}
2162
2163		Scope create_defer_scope(AstNode node, Scope *parent) {
2164		assert(node->type == NodeTypeDefer);
2165		ScopeDefer *scope = allocate<ScopeDefer>(1);
2166		scope->base.node = node;
2167		scope->base.parent = parent;
2168		return &scope->base;
2169		}
2170
2171		Scope create_var_scope(AstNode node, Scope parent, VariableTableEntry var) {
2172		assert(node->type == NodeTypeVariableDeclaration \|\| node->type == NodeTypeParamDecl);
2173		ScopeVarDecl *scope = allocate<ScopeVarDecl>(1);
2174		scope->base.node = node;
2175		scope->base.parent = parent;
2176		scope->var = var;
2177		return &scope->base;
2178		}
2179
2180		Scope create_cimport_scope(AstNode node, Scope *parent) {
2181		assert(node->type == NodeTypeFnCallExpr);
2182		ScopeCImport *scope = allocate<ScopeCImport>(1);
2183		scope->base.node = node;
2184		scope->base.parent = parent;
2185		buf_resize(&scope->c_import_buf, 0);
2186		return &scope->base;
2187		}
2188
2189		Scope create_loop_scope(AstNode node, Scope *parent) {
2190		assert(node->type == NodeTypeWhileExpr \|\| node->type == NodeTypeForExpr);
2191		ScopeLoop *scope = allocate<ScopeLoop>(1);
2192		scope->base.node = node;
2193		scope->base.parent = parent;
2194		return &scope->base;
2195		}
2196
2197		Scope create_fndef_scope(AstNode node, Scope parent, FnTableEntry fn_entry) {
2198		assert(node->type == NodeTypeFnDef);
2199		ScopeFnBody *scope = allocate<ScopeFnBody>(1);
2200		scope->base.node = node;
2201		scope->base.parent = parent;
2202		scope->fn_entry = fn_entry;
2203		return &scope->base;
2204		}
2205
2206		AstNode find_decl(Scope scope, Buf *name) {
	1997	Tld find_decl(Scope scope, Buf *name) {
2207	1998	while (scope) {
2208	1999	if (scope->node->type == NodeTypeRoot \|\|
2209	2000	scope->node->type == NodeTypeContainerDecl)
...	...	@@ -2232,11 +2023,11 @@ VariableTableEntry find_variable(CodeGen g, Scope scope, Buf name) {
2232	2023	ScopeDecls decls_scope = (ScopeDecls )scope;
2233	2024	auto entry = decls_scope->decl_table.maybe_get(name);
2234	2025	if (entry) {
2235		AstNode *decl_node = entry->value;
2236		if (decl_node->type == NodeTypeVariableDeclaration) {
2237		VariableTableEntry *var = decl_node->data.variable_declaration.variable;
2238		if (var)
2239		return var;
	2026	Tld *tld = entry->value;
	2027	if (tld->id == TldIdVar) {
	2028	TldVar tld_var = (TldVar )tld;
	2029	if (tld_var->var)
	2030	return tld_var->var;
2240	2031	}
2241	2032	}
2242	2033	}
...	...	@@ -2246,6 +2037,17 @@ VariableTableEntry find_variable(CodeGen g, Scope scope, Buf name) {
2246	2037	return nullptr;
2247	2038	}
2248	2039
	2040	FnTableEntry scope_fn_entry(Scope scope) {
	2041	while (scope) {
	2042	if (scope->node->type == NodeTypeFnDef) {
	2043	ScopeFnDef fn_scope = (ScopeFnDef )scope;
	2044	return fn_scope->fn_entry;
	2045	}
	2046	scope = scope->parent;
	2047	}
	2048	return nullptr;
	2049	}
	2050
2249	2051	TypeEnumField find_enum_type_field(TypeTableEntry enum_type, Buf *name) {
2250	2052	for (uint32_t i = 0; i < enum_type->data.enumeration.src_field_count; i += 1) {
2251	2053	TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[i];
...	...	@@ -2296,7 +2098,6 @@ static bool is_container(TypeTableEntry *type_entry) {
2296	2098	case TypeTableEntryIdTypeDecl:
2297	2099	case TypeTableEntryIdNamespace:
2298	2100	case TypeTableEntryIdBlock:
2299		case TypeTableEntryIdGenericFn:
2300	2101	case TypeTableEntryIdBoundFn:
2301	2102	return false;
2302	2103	}
...	...	@@ -2317,13 +2118,13 @@ TypeTableEntry container_ref_type(TypeTableEntry type_entry) {
2317	2118	void resolve_container_type(CodeGen g, TypeTableEntry type_entry) {
2318	2119	switch (type_entry->id) {
2319	2120	case TypeTableEntryIdStruct:
2320		resolve_struct_type(g, type_entry->data.structure.decl_node->owner, type_entry);
	2121	resolve_struct_type(g, type_entry);
2321	2122	break;
2322	2123	case TypeTableEntryIdEnum:
2323		resolve_enum_type(g, type_entry->data.enumeration.decl_node->owner, type_entry);
	2124	resolve_enum_type(g, type_entry);
2324	2125	break;
2325	2126	case TypeTableEntryIdUnion:
2326		resolve_union_type(g, type_entry->data.unionation.decl_node->owner, type_entry);
	2127	resolve_union_type(g, type_entry);
2327	2128	break;
2328	2129	case TypeTableEntryIdPointer:
2329	2130	case TypeTableEntryIdMetaType:
...	...	@@ -2344,7 +2145,6 @@ void resolve_container_type(CodeGen g, TypeTableEntry type_entry) {
2344	2145	case TypeTableEntryIdTypeDecl:
2345	2146	case TypeTableEntryIdNamespace:
2346	2147	case TypeTableEntryIdBlock:
2347		case TypeTableEntryIdGenericFn:
2348	2148	case TypeTableEntryIdBoundFn:
2349	2149	case TypeTableEntryIdInvalid:
2350	2150	case TypeTableEntryIdVar:
...	...	@@ -2362,54 +2162,41 @@ bool type_is_codegen_pointer(TypeTableEntry *type) {
2362	2162	return false;
2363	2163	}
2364	2164
2365
2366
2367	2165	static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry) {
2368		ImportTableEntry *import = fn_table_entry->import_entry;
2369		AstNode *node = fn_table_entry->fn_def_node;
2370		assert(node->type == NodeTypeFnDef);
2371
2372		AstNode *fn_proto_node = node->data.fn_def.fn_proto;
2373		assert(fn_proto_node->type == NodeTypeFnProto);
2374
2375		if (fn_proto_node->data.fn_proto.skip) {
2376		// we detected an error with this function definition which prevents us
2377		// from further analyzing it.
2378		fn_table_entry->anal_state = FnAnalStateSkipped;
	2166	assert(fn_table_entry->anal_state != FnAnalStateProbing);
	2167	if (fn_table_entry->anal_state != FnAnalStateReady)
2379	2168	return;
2380		}
	2169
2381	2170	fn_table_entry->anal_state = FnAnalStateProbing;
2382	2171
2383		Scope *child_scope = node->data.fn_def.containing_scope;
	2172	AstNodeFnProto *fn_proto = &fn_table_entry->proto_node->data.fn_proto;
2384	2173
	2174	Scope *child_scope = &fn_table_entry->fndef_scope->base;
	2175	assert(child_scope);
	2176
	2177	// define local variables for parameters
2385	2178	TypeTableEntry *fn_type = fn_table_entry->type_entry;
	2179	assert(!fn_type->data.fn.is_generic);
2386	2180	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
2387		AstNodeFnProto *fn_proto = &fn_proto_node->data.fn_proto;
2388		for (size_t i = 0; i < fn_proto->params.length; i += 1) {
	2181	for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
2389	2182	AstNode *param_decl_node = fn_proto->params.at(i);
2390		assert(param_decl_node->type == NodeTypeParamDecl);
2391
2392		// define local variables for parameters
2393	2183	AstNodeParamDecl *param_decl = &param_decl_node->data.param_decl;
2394		TypeTableEntry *type = fn_type_id->param_info[i].type;
	2184	FnTypeParamInfo *param_info = &fn_type_id->param_info[i];
2395	2185
2396		if (param_decl->is_noalias && !type_is_codegen_pointer(type)) {
	2186	TypeTableEntry *param_type = param_info->type;
	2187	bool is_noalias = param_info->is_noalias;
	2188
	2189	if (is_noalias && !type_is_codegen_pointer(param_type)) {
2397	2190	add_node_error(g, param_decl_node, buf_sprintf("noalias on non-pointer parameter"));
2398	2191	}
2399	2192
2400		if (fn_type->data.fn.fn_type_id.is_extern && handle_is_ptr(type)) {
	2193	if (fn_type_id->is_extern && handle_is_ptr(param_type)) {
2401	2194	add_node_error(g, param_decl_node,
2402	2195	buf_sprintf("byvalue types not yet supported on extern function parameters"));
2403	2196	}
2404	2197
2405		if (buf_len(param_decl->name) == 0) {
2406		add_node_error(g, param_decl_node, buf_sprintf("missing parameter name"));
2407		}
2408
2409		VariableTableEntry *var = add_local_var(g, param_decl_node, import, child_scope, param_decl->name,
2410		type, true, nullptr);
	2198	VariableTableEntry *var = add_variable(g, param_decl_node, child_scope, param_decl->name, param_type, true, nullptr);
2411	2199	var->src_arg_index = i;
2412		param_decl_node->data.param_decl.variable = var;
2413	2200	child_scope = var->child_scope;
2414	2201	fn_table_entry->variable_list.append(var);
2415	2202
...	...	@@ -2418,19 +2205,18 @@ static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry) {
2418	2205	}
2419	2206	}
2420	2207
2421		node->data.fn_def.child_scope = child_scope;
	2208	fn_table_entry->child_scope = child_scope;
2422	2209
2423		TypeTableEntry *expected_type = fn_type->data.fn.fn_type_id.return_type;
	2210	TypeTableEntry *expected_type = fn_type_id->return_type;
2424	2211
2425		if (fn_type->data.fn.fn_type_id.is_extern && handle_is_ptr(expected_type)) {
2426		add_node_error(g, fn_proto_node->data.fn_proto.return_type,
	2212	if (fn_type_id->is_extern && handle_is_ptr(expected_type)) {
	2213	add_node_error(g, fn_proto->return_type,
2427	2214	buf_sprintf("byvalue types not yet supported on extern function return values"));
2428	2215	}
2429	2216
2430	2217	ir_gen_fn(g, fn_table_entry);
2431	2218	if (fn_table_entry->ir_executable.invalid) {
2432		fn_proto_node->data.fn_proto.skip = true;
2433		fn_table_entry->anal_state = FnAnalStateSkipped;
	2219	fn_table_entry->anal_state = FnAnalStateInvalid;
2434	2220	return;
2435	2221	}
2436	2222	if (g->verbose) {
...	...	@@ -2443,9 +2229,16 @@ static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry) {
2443	2229
2444	2230	TypeTableEntry *block_return_type = ir_analyze(g, &fn_table_entry->ir_executable,
2445	2231	&fn_table_entry->analyzed_executable, expected_type, fn_proto->return_type);
2446		node->data.fn_def.implicit_return_type = block_return_type;
	2232	fn_table_entry->implicit_return_type = block_return_type;
2447	2233
2448		if (block_return_type->id != TypeTableEntryIdInvalid && g->verbose) {
	2234	if (block_return_type->id == TypeTableEntryIdInvalid \|\|
	2235	fn_table_entry->analyzed_executable.invalid)
	2236	{
	2237	fn_table_entry->anal_state = FnAnalStateInvalid;
	2238	return;
	2239	}
	2240
	2241	if (g->verbose) {
2449	2242	fprintf(stderr, "{ // (analyzed)\n");
2450	2243	ir_print(stderr, &fn_table_entry->analyzed_executable, 4);
2451	2244	fprintf(stderr, "}\n");
...	...	@@ -2454,16 +2247,14 @@ static void analyze_fn_body(CodeGen g, FnTableEntry fn_table_entry) {
2454	2247	fn_table_entry->anal_state = FnAnalStateComplete;
2455	2248	}
2456	2249
2457		static void add_symbols_from_import(CodeGen g, AstNode src_use_node, AstNode *dst_use_node) {
2458		TopLevelDecl *tld = get_as_top_level_decl(dst_use_node);
2459
2460		IrInstruction *use_target_value = tld->value;
	2250	static void add_symbols_from_import(CodeGen g, AstNode dst_use_node) {
	2251	IrInstruction *use_target_value = dst_use_node->data.use.value;
2461	2252	if (use_target_value->type_entry->id == TypeTableEntryIdInvalid) {
2462		tld->import->any_imports_failed = true;
	2253	dst_use_node->owner->any_imports_failed = true;
2463	2254	return;
2464	2255	}
2465	2256
2466		tld->resolution = TldResolutionOk;
	2257	dst_use_node->data.use.resolution = TldResolutionOk;
2467	2258
2468	2259	ConstExprValue *const_val = &use_target_value->static_value;
2469	2260	assert(const_val->special != ConstValSpecialRuntime);
...	...	@@ -2472,59 +2263,60 @@ static void add_symbols_from_import(CodeGen g, AstNode src_use_node, AstNode *
2472	2263	assert(target_import);
2473	2264
2474	2265	if (target_import->any_imports_failed) {
2475		tld->import->any_imports_failed = true;
	2266	dst_use_node->owner->any_imports_failed = true;
2476	2267	}
2477	2268
2478		for (size_t i = 0; i < target_import->root->data.root.top_level_decls.length; i += 1) {
2479		AstNode *decl_node = target_import->root->data.root.top_level_decls.at(i);
2480		if (decl_node->type == NodeTypeFnDef) {
2481		decl_node = decl_node->data.fn_def.fn_proto;
2482		}
2483		TopLevelDecl *target_tld = get_as_top_level_decl(decl_node);
2484		if (!target_tld->name) {
	2269	auto it = target_import->decls_scope->decl_table.entry_iterator();
	2270	for (;;) {
	2271	auto *entry = it.next();
	2272	if (!entry)
	2273	break;
	2274
	2275	Tld *target_tld = entry->value;
	2276	if (target_tld->import != target_import \|\|
	2277	target_tld->visib_mod == VisibModPrivate)
	2278	{
2485	2279	continue;
2486	2280	}
2487		if (target_tld->visib_mod != VisibModPrivate) {
2488		auto existing_entry = tld->import->decls_scope->decl_table.put_unique(target_tld->name, decl_node);
2489		if (existing_entry) {
2490		AstNode *existing_decl = existing_entry->value;
2491		if (existing_decl != decl_node) {
2492		ErrorMsg *msg = add_node_error(g, dst_use_node,
2493		buf_sprintf("import of '%s' overrides existing definition",
2494		buf_ptr(target_tld->name)));
2495		add_error_note(g, msg, existing_decl, buf_sprintf("previous definition here"));
2496		add_error_note(g, msg, decl_node, buf_sprintf("imported definition here"));
2497		}
	2281
	2282	auto existing_entry = dst_use_node->owner->decls_scope->decl_table.put_unique(target_tld->name, target_tld);
	2283	if (existing_entry) {
	2284	Tld *existing_decl = existing_entry->value;
	2285	if (existing_decl != target_tld) {
	2286	ErrorMsg *msg = add_node_error(g, dst_use_node,
	2287	buf_sprintf("import of '%s' overrides existing definition",
	2288	buf_ptr(target_tld->name)));
	2289	add_error_note(g, msg, existing_decl->source_node, buf_sprintf("previous definition here"));
	2290	add_error_note(g, msg, target_tld->source_node, buf_sprintf("imported definition here"));
2498	2291	}
2499	2292	}
2500	2293	}
2501	2294
2502	2295	for (size_t i = 0; i < target_import->use_decls.length; i += 1) {
2503	2296	AstNode *use_decl_node = target_import->use_decls.at(i);
2504		TopLevelDecl *target_tld = get_as_top_level_decl(use_decl_node);
2505		if (target_tld->visib_mod != VisibModPrivate) {
2506		add_symbols_from_import(g, use_decl_node, dst_use_node);
2507		}
	2297	if (use_decl_node->data.use.visib_mod != VisibModPrivate)
	2298	add_symbols_from_import(g, dst_use_node);
2508	2299	}
2509
2510	2300	}
2511	2301
2512	2302	void resolve_use_decl(CodeGen g, AstNode node) {
2513	2303	assert(node->type == NodeTypeUse);
2514		if (get_as_top_level_decl(node)->resolution != TldResolutionUnresolved) {
	2304
	2305	if (node->data.use.resolution != TldResolutionUnresolved)
2515	2306	return;
2516		}
2517		add_symbols_from_import(g, node, node);
	2307	add_symbols_from_import(g, node);
2518	2308	}
2519	2309
2520	2310	void preview_use_decl(CodeGen g, AstNode node) {
2521	2311	assert(node->type == NodeTypeUse);
2522		TopLevelDecl *tld = get_as_top_level_decl(node);
2523	2312
2524		IrInstruction *result = analyze_const_value(g, &tld->import->decls_scope->base, node->data.use.expr,
2525		g->builtin_types.entry_namespace);
	2313	IrInstruction *result = analyze_const_value(g, &node->owner->decls_scope->base,
	2314	node->data.use.expr, g->builtin_types.entry_namespace);
	2315
2526	2316	if (result->type_entry->id == TypeTableEntryIdInvalid)
2527		tld->import->any_imports_failed = true;
	2317	node->owner->any_imports_failed = true;
	2318
	2319	node->data.use.value = result;
2528	2320	}
2529	2321
2530	2322	ImportTableEntry add_source_file(CodeGen g, PackageTableEntry *package,
...	...	@@ -2580,7 +2372,7 @@ ImportTableEntry add_source_file(CodeGen g, PackageTableEntry *package,
2580	2372	g->import_table.put(abs_full_path, import_entry);
2581	2373	g->import_queue.append(import_entry);
2582	2374
2583		import_entry->decls_scope = create_decls_scope(import_entry->root, nullptr);
	2375	import_entry->decls_scope = create_decls_scope(import_entry->root, nullptr, nullptr, import_entry);
2584	2376
2585	2377
2586	2378	assert(import_entry->root->type == NodeTypeRoot);
...	...	@@ -2592,7 +2384,7 @@ ImportTableEntry add_source_file(CodeGen g, PackageTableEntry *package,
2592	2384	assert(proto_node->type == NodeTypeFnProto);
2593	2385	Buf *proto_name = proto_node->data.fn_proto.name;
2594	2386
2595		bool is_private = (proto_node->data.fn_proto.top_level_decl.visib_mod == VisibModPrivate);
	2387	bool is_private = (proto_node->data.fn_proto.visib_mod == VisibModPrivate);
2596	2388
2597	2389	if (buf_eql_str(proto_name, "main") && !is_private) {
2598	2390	g->have_exported_main = true;
...	...	@@ -2607,7 +2399,7 @@ ImportTableEntry add_source_file(CodeGen g, PackageTableEntry *package,
2607	2399	void semantic_analyze(CodeGen *g) {
2608	2400	for (; g->import_queue_index < g->import_queue.length; g->import_queue_index += 1) {
2609	2401	ImportTableEntry *import = g->import_queue.at(g->import_queue_index);
2610		scan_decls(g, import, import->decls_scope, import->root);
	2402	scan_decls(g, import, import->decls_scope, import->root, nullptr);
2611	2403	}
2612	2404
2613	2405	for (; g->use_queue_index < g->use_queue.length; g->use_queue_index += 1) {
...	...	@@ -2620,82 +2412,22 @@ void semantic_analyze(CodeGen *g) {
2620	2412	resolve_use_decl(g, use_decl_node);
2621	2413	}
2622	2414
2623		for (; g->resolve_queue_index < g->resolve_queue.length; g->resolve_queue_index += 1) {
2624		AstNode *decl_node = g->resolve_queue.at(g->resolve_queue_index);
2625		bool pointer_only = false;
2626		resolve_top_level_decl(g, decl_node, pointer_only);
2627		}
	2415	while (g->resolve_queue_index < g->resolve_queue.length \|\|
	2416	g->fn_defs_index < g->fn_defs.length)
	2417	{
	2418	for (; g->resolve_queue_index < g->resolve_queue.length; g->resolve_queue_index += 1) {
	2419	Tld *tld = g->resolve_queue.at(g->resolve_queue_index);
	2420	bool pointer_only = false;
	2421	resolve_top_level_decl(g, tld, pointer_only);
	2422	}
2628	2423
2629		for (size_t i = 0; i < g->fn_defs.length; i += 1) {
2630		FnTableEntry *fn_entry = g->fn_defs.at(i);
2631		if (fn_entry->anal_state == FnAnalStateReady) {
	2424	for (; g->fn_defs_index < g->fn_defs.length; g->fn_defs_index += 1) {
	2425	FnTableEntry *fn_entry = g->fn_defs.at(g->fn_defs_index);
2632	2426	analyze_fn_body(g, fn_entry);
2633	2427	}
2634	2428	}
2635	2429	}
2636	2430
2637		TopLevelDecl get_as_top_level_decl(AstNode node) {
2638		switch (node->type) {
2639		case NodeTypeVariableDeclaration:
2640		return &node->data.variable_declaration.top_level_decl;
2641		case NodeTypeFnProto:
2642		return &node->data.fn_proto.top_level_decl;
2643		case NodeTypeFnDef:
2644		return &node->data.fn_def.fn_proto->data.fn_proto.top_level_decl;
2645		case NodeTypeContainerDecl:
2646		return &node->data.struct_decl.top_level_decl;
2647		case NodeTypeErrorValueDecl:
2648		return &node->data.error_value_decl.top_level_decl;
2649		case NodeTypeUse:
2650		return &node->data.use.top_level_decl;
2651		case NodeTypeTypeDecl:
2652		return &node->data.type_decl.top_level_decl;
2653		case NodeTypeNumberLiteral:
2654		case NodeTypeReturnExpr:
2655		case NodeTypeDefer:
2656		case NodeTypeBinOpExpr:
2657		case NodeTypeUnwrapErrorExpr:
2658		case NodeTypePrefixOpExpr:
2659		case NodeTypeFnCallExpr:
2660		case NodeTypeArrayAccessExpr:
2661		case NodeTypeSliceExpr:
2662		case NodeTypeFieldAccessExpr:
2663		case NodeTypeIfBoolExpr:
2664		case NodeTypeIfVarExpr:
2665		case NodeTypeWhileExpr:
2666		case NodeTypeForExpr:
2667		case NodeTypeSwitchExpr:
2668		case NodeTypeSwitchProng:
2669		case NodeTypeSwitchRange:
2670		case NodeTypeAsmExpr:
2671		case NodeTypeContainerInitExpr:
2672		case NodeTypeRoot:
2673		case NodeTypeFnDecl:
2674		case NodeTypeParamDecl:
2675		case NodeTypeBlock:
2676		case NodeTypeStringLiteral:
2677		case NodeTypeCharLiteral:
2678		case NodeTypeSymbol:
2679		case NodeTypeBoolLiteral:
2680		case NodeTypeNullLiteral:
2681		case NodeTypeUndefinedLiteral:
2682		case NodeTypeZeroesLiteral:
2683		case NodeTypeThisLiteral:
2684		case NodeTypeLabel:
2685		case NodeTypeGoto:
2686		case NodeTypeBreak:
2687		case NodeTypeContinue:
2688		case NodeTypeStructField:
2689		case NodeTypeStructValueField:
2690		case NodeTypeArrayType:
2691		case NodeTypeErrorType:
2692		case NodeTypeTypeLiteral:
2693		case NodeTypeVarLiteral:
2694		zig_unreachable();
2695		}
2696		zig_unreachable();
2697		}
2698
2699	2431	bool is_node_void_expr(AstNode *node) {
2700	2432	if (node->type == NodeTypeContainerInitExpr &&
2701	2433	node->data.container_init_expr.kind == ContainerInitKindArray)
...	...	@@ -2749,7 +2481,6 @@ bool handle_is_ptr(TypeTableEntry *type_entry) {
2749	2481	case TypeTableEntryIdNullLit:
2750	2482	case TypeTableEntryIdNamespace:
2751	2483	case TypeTableEntryIdBlock:
2752		case TypeTableEntryIdGenericFn:
2753	2484	case TypeTableEntryIdBoundFn:
2754	2485	case TypeTableEntryIdVar:
2755	2486	zig_unreachable();
...	...	@@ -2902,7 +2633,6 @@ static uint32_t hash_const_val(TypeTableEntry type, ConstExprValue const_val)
2902	2633	return hash_ptr(const_val->data.x_import);
2903	2634	case TypeTableEntryIdBlock:
2904	2635	return hash_ptr(const_val->data.x_block);
2905		case TypeTableEntryIdGenericFn:
2906	2636	case TypeTableEntryIdBoundFn:
2907	2637	case TypeTableEntryIdInvalid:
2908	2638	case TypeTableEntryIdUnreachable:
...	...	@@ -2912,45 +2642,6 @@ static uint32_t hash_const_val(TypeTableEntry type, ConstExprValue const_val)
2912	2642	zig_unreachable();
2913	2643	}
2914	2644
2915		uint32_t generic_fn_type_id_hash(GenericFnTypeId *id) {
2916		zig_panic("TODO generic_fn_type_id_hash");
2917		//uint32_t result = 0;
2918		//result += hash_ptr(id->decl_node);
2919		//for (size_t i = 0; i < id->generic_param_count; i += 1) {
2920		// GenericParamValue *generic_param = &id->generic_params[i];
2921		// if (generic_param->node) {
2922		// ConstExprValue *const_val = &get_resolved_expr(generic_param->node)->instruction->static_value;
2923		// assert(const_val->special != ConstValSpecialRuntime);
2924		// result += hash_const_val(generic_param->type, const_val);
2925		// }
2926		// result += hash_ptr(generic_param->type);
2927		//}
2928		//return result;
2929		}
2930
2931		bool generic_fn_type_id_eql(GenericFnTypeId a, GenericFnTypeId b) {
2932		zig_panic("TODO generic_fn_type_id_eql");
2933		//if (a->decl_node != b->decl_node) return false;
2934		//assert(a->generic_param_count == b->generic_param_count);
2935		//for (size_t i = 0; i < a->generic_param_count; i += 1) {
2936		// GenericParamValue *a_val = &a->generic_params[i];
2937		// GenericParamValue *b_val = &b->generic_params[i];
2938		// if (a_val->type != b_val->type) return false;
2939		// if (a_val->node && b_val->node) {
2940		// ConstExprValue *a_const_val = &get_resolved_expr(a_val->node)->instruction->static_value;
2941		// ConstExprValue *b_const_val = &get_resolved_expr(b_val->node)->instruction->static_value;
2942		// assert(a_const_val->special != ConstValSpecialRuntime);
2943		// assert(b_const_val->special != ConstValSpecialRuntime);
2944		// if (!const_values_equal(a_const_val, b_const_val, a_val->type)) {
2945		// return false;
2946		// }
2947		// } else {
2948		// assert(!a_val->node && !b_val->node);
2949		// }
2950		//}
2951		//return true;
2952		}
2953
2954	2645	bool type_has_bits(TypeTableEntry *type_entry) {
2955	2646	assert(type_entry);
2956	2647	assert(type_entry->id != TypeTableEntryIdInvalid);
...	...	@@ -2981,7 +2672,6 @@ static TypeTableEntry type_of_first_thing_in_memory(TypeTableEntry type_entry)
2981	2672	case TypeTableEntryIdVoid:
2982	2673	case TypeTableEntryIdNamespace:
2983	2674	case TypeTableEntryIdBlock:
2984		case TypeTableEntryIdGenericFn:
2985	2675	case TypeTableEntryIdBoundFn:
2986	2676	case TypeTableEntryIdVar:
2987	2677	zig_unreachable();

src/analyze.hpp+12-8

...	...	@@ -22,11 +22,11 @@ TypeTableEntry get_int_type(CodeGen g, bool is_signed, size_t size_in_bits);
22	22	TypeTableEntry *get_c_int_type_ptr(CodeGen g, CIntType c_int_type);
23	23	TypeTableEntry get_c_int_type(CodeGen g, CIntType c_int_type);
24	24	TypeTableEntry get_typedecl_type(CodeGen g, const char name, TypeTableEntry child_type);
25		TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_info);
	25	TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id);
26	26	TypeTableEntry get_maybe_type(CodeGen g, TypeTableEntry *child_type);
27	27	TypeTableEntry get_array_type(CodeGen g, TypeTableEntry *child_type, uint64_t array_size);
28	28	TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *child_type, bool is_const);
29		TypeTableEntry get_partial_container_type(CodeGen g, ImportTableEntry import, Scope context,
	29	TypeTableEntry get_partial_container_type(CodeGen g, ImportTableEntry import, Scope scope,
30	30	ContainerKind kind, AstNode decl_node, const char name);
31	31	TypeTableEntry get_smallest_unsigned_int_type(CodeGen g, uint64_t x);
32	32	TypeTableEntry get_error_type(CodeGen g, TypeTableEntry *child_type);
...	...	@@ -49,9 +49,8 @@ AstNode first_executing_node(AstNode node);
49	49	// TODO move these over, these used to be static
50	50	bool types_match_const_cast_only(TypeTableEntry expected_type, TypeTableEntry actual_type);
51	51	VariableTableEntry find_variable(CodeGen g, Scope orig_context, Buf name);
52		AstNode find_decl(Scope context, Buf *name);
53		void resolve_top_level_decl(CodeGen g, AstNode node, bool pointer_only);
54		TopLevelDecl get_as_top_level_decl(AstNode node);
	52	Tld find_decl(Scope scope, Buf *name);
	53	void resolve_top_level_decl(CodeGen g, Tld tld, bool pointer_only);
55	54	bool type_is_codegen_pointer(TypeTableEntry *type);
56	55	TypeTableEntry validate_var_type(CodeGen g, AstNode source_node, TypeTableEntry type_entry);
57	56	TypeTableEntry container_ref_type(TypeTableEntry type_entry);
...	...	@@ -61,16 +60,21 @@ TypeStructField find_struct_type_field(TypeTableEntry type_entry, Buf *name);
61	60	ScopeDecls get_container_scope(TypeTableEntry type_entry);
62	61	TypeEnumField find_enum_type_field(TypeTableEntry enum_type, Buf *name);
63	62	bool is_container_ref(TypeTableEntry *type_entry);
64		void scan_decls(CodeGen g, ImportTableEntry import, ScopeDecls decls_scope, AstNode node);
	63	void scan_decls(CodeGen g, ImportTableEntry import, ScopeDecls decls_scope, AstNode node, Tld *parent_tld);
65	64	void preview_use_decl(CodeGen g, AstNode node);
66	65	void resolve_use_decl(CodeGen g, AstNode node);
	66	FnTableEntry scope_fn_entry(Scope scope);
	67	ImportTableEntry get_scope_import(Scope scope);
	68	void init_tld(Tld tld, TldId id, Buf name, VisibMod visib_mod, AstNode *source_node,
	69	Scope parent_scope, Tld parent_tld);
	70	VariableTableEntry add_variable(CodeGen g, AstNode source_node, Scope parent_scope, Buf *name,
	71	TypeTableEntry type_entry, bool is_const, ConstExprValue init_value);
67	72
68		ScopeDecls create_decls_scope(AstNode node, Scope *parent);
69	73	Scope create_block_scope(AstNode node, Scope *parent);
70	74	Scope create_defer_scope(AstNode node, Scope *parent);
71	75	Scope create_var_scope(AstNode node, Scope parent, VariableTableEntry var);
72	76	Scope create_cimport_scope(AstNode node, Scope *parent);
73	77	Scope create_loop_scope(AstNode node, Scope *parent);
74		Scope create_fndef_scope(AstNode node, Scope parent, FnTableEntry fn_entry);
	78	ScopeFnDef create_fndef_scope(AstNode node, Scope parent, FnTableEntry fn_entry);
75	79
76	80	#endif

src/ast_render.cpp+4-4

...	...	@@ -377,7 +377,7 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {
377	377	break;
378	378	case NodeTypeFnProto:
379	379	{
380		const char *pub_str = visib_mod_string(node->data.fn_proto.top_level_decl.visib_mod);
	380	const char *pub_str = visib_mod_string(node->data.fn_proto.visib_mod);
381	381	const char *extern_str = extern_string(node->data.fn_proto.is_extern);
382	382	const char *inline_str = inline_string(node->data.fn_proto.is_inline);
383	383	fprintf(ar->f, "%s%s%sfn ", pub_str, inline_str, extern_str);
...	...	@@ -460,7 +460,7 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {
460	460	}
461	461	case NodeTypeVariableDeclaration:
462	462	{
463		const char *pub_str = visib_mod_string(node->data.variable_declaration.top_level_decl.visib_mod);
	463	const char *pub_str = visib_mod_string(node->data.variable_declaration.visib_mod);
464	464	const char *extern_str = extern_string(node->data.variable_declaration.is_extern);
465	465	const char *const_or_var = const_or_var_string(node->data.variable_declaration.is_const);
466	466	fprintf(ar->f, "%s%s%s ", pub_str, extern_str, const_or_var);
...	...	@@ -478,7 +478,7 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {
478	478	}
479	479	case NodeTypeTypeDecl:
480	480	{
481		const char *pub_str = visib_mod_string(node->data.type_decl.top_level_decl.visib_mod);
	481	const char *pub_str = visib_mod_string(node->data.type_decl.visib_mod);
482	482	const char *var_name = buf_ptr(node->data.type_decl.symbol);
483	483	fprintf(ar->f, "%stype %s = ", pub_str, var_name);
484	484	render_node_grouped(ar, node->data.type_decl.child_type);
...	...	@@ -575,7 +575,7 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {
575	575	case NodeTypeContainerDecl:
576	576	{
577	577	const char *struct_name = buf_ptr(node->data.struct_decl.name);
578		const char *pub_str = visib_mod_string(node->data.struct_decl.top_level_decl.visib_mod);
	578	const char *pub_str = visib_mod_string(node->data.struct_decl.visib_mod);
579	579	const char *container_str = container_string(node->data.struct_decl.kind);
580	580	fprintf(ar->f, "%s%s %s {\n", pub_str, container_str, struct_name);
581	581	ar->indent += ar->indent_size;

src/codegen.cpp+168-116

...	...	@@ -60,7 +60,6 @@ CodeGen codegen_create(Buf root_source_dir, const ZigTarget *target) {
60	60	g->primitive_type_table.init(32);
61	61	g->fn_type_table.init(32);
62	62	g->error_table.init(16);
63		g->generic_table.init(16);
64	63	g->is_release_build = false;
65	64	g->is_test_build = false;
66	65	g->want_h_file = true;
...	...	@@ -227,13 +226,59 @@ void codegen_set_rdynamic(CodeGen *g, bool rdynamic) {
227	226	static void render_const_val(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val);
228	227	static void render_const_val_global(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val);
229	228
	229	static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
	230	if (fn_table_entry->llvm_value)
	231	return fn_table_entry->llvm_value;
	232
	233	Buf *symbol_name;
	234	if (!fn_table_entry->internal_linkage) {
	235	symbol_name = &fn_table_entry->symbol_name;
	236	} else {
	237	symbol_name = buf_sprintf("_%s", buf_ptr(&fn_table_entry->symbol_name));
	238	}
	239
	240	TypeTableEntry *fn_type = fn_table_entry->type_entry;
	241	fn_table_entry->llvm_value = LLVMAddFunction(g->module, buf_ptr(symbol_name), fn_type->data.fn.raw_type_ref);
	242
	243	switch (fn_table_entry->fn_inline) {
	244	case FnInlineAlways:
	245	LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMAlwaysInlineAttribute);
	246	break;
	247	case FnInlineNever:
	248	LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoInlineAttribute);
	249	break;
	250	case FnInlineAuto:
	251	break;
	252	}
	253	if (fn_type->data.fn.fn_type_id.is_naked) {
	254	LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNakedAttribute);
	255	}
	256
	257	LLVMSetLinkage(fn_table_entry->llvm_value, fn_table_entry->internal_linkage ?
	258	LLVMInternalLinkage : LLVMExternalLinkage);
	259
	260	if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdUnreachable) {
	261	LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoReturnAttribute);
	262	}
	263	LLVMSetFunctionCallConv(fn_table_entry->llvm_value, fn_type->data.fn.calling_convention);
	264	if (!fn_type->data.fn.fn_type_id.is_extern) {
	265	LLVMAddFunctionAttr(fn_table_entry->llvm_value, LLVMNoUnwindAttribute);
	266	}
	267	if (!g->is_release_build && fn_table_entry->fn_inline != FnInlineAlways) {
	268	ZigLLVMAddFunctionAttr(fn_table_entry->llvm_value, "no-frame-pointer-elim", "true");
	269	ZigLLVMAddFunctionAttr(fn_table_entry->llvm_value, "no-frame-pointer-elim-non-leaf", nullptr);
	270	}
	271
	272	return fn_table_entry->llvm_value;
	273	}
	274
230	275	static ZigLLVMDIScope get_di_scope(CodeGen g, Scope *scope) {
231	276	if (scope->di_scope)
232	277	return scope->di_scope;
233	278
234	279	if (scope->node->type == NodeTypeFnDef) {
235	280	assert(scope->parent);
236		ScopeFnBody fn_scope = (ScopeFnBody )scope;
	281	ScopeFnDef fn_scope = (ScopeFnDef )scope;
237	282	FnTableEntry *fn_table_entry = fn_scope->fn_entry;
238	283	unsigned line_number = fn_table_entry->proto_node->line + 1;
239	284	unsigned scope_line = line_number;
...	...	@@ -247,11 +292,13 @@ static ZigLLVMDIScope get_di_scope(CodeGen g, Scope *scope) {
247	292	is_definition, scope_line, flags, is_optimized, nullptr);
248	293
249	294	scope->di_scope = ZigLLVMSubprogramToScope(subprogram);
250		ZigLLVMFnSetSubprogram(fn_table_entry->fn_value, subprogram);
251		} else if (scope->node->type == NodeTypeRoot \|\|
252		scope->node->type == NodeTypeContainerDecl)
253		{
	295	ZigLLVMFnSetSubprogram(fn_llvm_value(g, fn_table_entry), subprogram);
	296	} else if (scope->node->type == NodeTypeRoot) {
254	297	scope->di_scope = ZigLLVMFileToScope(scope->node->owner->di_file);
	298	} else if (scope->node->type == NodeTypeContainerDecl) {
	299	ScopeDecls decls_scope = (ScopeDecls )scope;
	300	assert(decls_scope->container_type);
	301	scope->di_scope = ZigLLVMTypeToScope(decls_scope->container_type->di_type);
255	302	} else {
256	303	assert(scope->parent);
257	304	ZigLLVMDILexicalBlock *di_block = ZigLLVMCreateLexicalBlock(g->dbuilder,
...	...	@@ -265,11 +312,6 @@ static ZigLLVMDIScope get_di_scope(CodeGen g, Scope *scope) {
265	312	return scope->di_scope;
266	313	}
267	314
268		static void set_debug_source_node(CodeGen g, AstNode node) {
269		assert(node->scope);
270		ZigLLVMSetCurrentDebugLocation(g->builder, node->line + 1, node->column + 1, get_di_scope(g, node->scope));
271		}
272
273	315	static void clear_debug_source_node(CodeGen *g) {
274	316	ZigLLVMClearCurrentDebugLocation(g->builder);
275	317	}
...	...	@@ -350,24 +392,25 @@ static LLVMValueRef get_handle_value(CodeGen *g, LLVMValueRef ptr, TypeTableEntr
350	392	}
351	393	}
352	394
353		static bool want_debug_safety_recursive(CodeGen g, Scope context) {
354		if (context->safety_set_node \|\| !context->parent) {
355		return !context->safety_off;
356		}
357		context->safety_off = !want_debug_safety_recursive(g, context->parent);
358		context->safety_set_node = context->parent->safety_set_node;
359		return !context->safety_off;
360		}
361
362		static bool want_debug_safety(CodeGen g, AstNode node) {
363		if (g->is_release_build) {
	395	static bool ir_want_debug_safety(CodeGen g, IrInstruction instruction) {
	396	if (g->is_release_build)
364	397	return false;
365		}
366		return want_debug_safety_recursive(g, node->scope);
367		}
368	398
369		static bool ir_want_debug_safety(CodeGen g, IrInstruction instruction) {
370		return want_debug_safety(g, instruction->source_node);
	399	// TODO memoize
	400	Scope *scope = instruction->scope;
	401	while (scope) {
	402	if (scope->node->type == NodeTypeBlock) {
	403	ScopeBlock block_scope = (ScopeBlock )scope;
	404	if (block_scope->safety_set_node)
	405	return !block_scope->safety_off;
	406	} else if (scope->node->type == NodeTypeRoot \|\| scope->node->type == NodeTypeContainerDecl) {
	407	ScopeDecls decls_scope = (ScopeDecls )scope;
	408	if (decls_scope->safety_set_node)
	409	return !decls_scope->safety_off;
	410	}
	411	scope = scope->parent;
	412	}
	413	return true;
371	414	}
372	415
373	416	static void gen_debug_safety_crash(CodeGen *g) {
...	...	@@ -388,10 +431,10 @@ static void add_bounds_check(CodeGen *g, LLVMValueRef target_val,
388	431	upper_value = nullptr;
389	432	}
390	433
391		LLVMBasicBlockRef bounds_check_fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "BoundsCheckFail");
392		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "BoundsCheckOk");
	434	LLVMBasicBlockRef bounds_check_fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "BoundsCheckFail");
	435	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "BoundsCheckOk");
393	436	LLVMBasicBlockRef lower_ok_block = upper_value ?
394		LLVMAppendBasicBlock(g->cur_fn->fn_value, "FirstBoundsCheckOk") : ok_block;
	437	LLVMAppendBasicBlock(g->cur_fn_val, "FirstBoundsCheckOk") : ok_block;
395	438
396	439	LLVMValueRef lower_ok_val = LLVMBuildICmp(g->builder, lower_pred, target_val, lower_value, "");
397	440	LLVMBuildCondBr(g->builder, lower_ok_val, lower_ok_block, bounds_check_fail_block);
...	...	@@ -408,7 +451,7 @@ static void add_bounds_check(CodeGen *g, LLVMValueRef target_val,
408	451	LLVMPositionBuilderAtEnd(g->builder, ok_block);
409	452	}
410	453
411		static LLVMValueRef gen_widen_or_shorten(CodeGen g, AstNode source_node, TypeTableEntry *actual_type_non_canon,
	454	static LLVMValueRef gen_widen_or_shorten(CodeGen g, bool want_debug_safety, TypeTableEntry actual_type_non_canon,
412	455	TypeTableEntry *wanted_type_non_canon, LLVMValueRef expr_val)
413	456	{
414	457	TypeTableEntry *actual_type = get_underlying_type(actual_type_non_canon);
...	...	@@ -430,13 +473,13 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen g, AstNode source_node, TypeT
430	473
431	474	if (actual_bits >= wanted_bits && actual_type->id == TypeTableEntryIdInt &&
432	475	!wanted_type->data.integral.is_signed && actual_type->data.integral.is_signed &&
433		want_debug_safety(g, source_node))
	476	want_debug_safety)
434	477	{
435	478	LLVMValueRef zero = LLVMConstNull(actual_type->type_ref);
436	479	LLVMValueRef ok_bit = LLVMBuildICmp(g->builder, LLVMIntSGE, expr_val, zero, "");
437	480
438		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "SignCastOk");
439		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "SignCastFail");
	481	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "SignCastOk");
	482	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "SignCastFail");
440	483	LLVMBuildCondBr(g->builder, ok_bit, ok_block, fail_block);
441	484
442	485	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -464,7 +507,7 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen g, AstNode source_node, TypeT
464	507	return LLVMBuildFPTrunc(g->builder, expr_val, wanted_type->type_ref, "");
465	508	} else if (actual_type->id == TypeTableEntryIdInt) {
466	509	LLVMValueRef trunc_val = LLVMBuildTrunc(g->builder, expr_val, wanted_type->type_ref, "");
467		if (!want_debug_safety(g, source_node)) {
	510	if (!want_debug_safety) {
468	511	return trunc_val;
469	512	}
470	513	LLVMValueRef orig_val;
...	...	@@ -474,8 +517,8 @@ static LLVMValueRef gen_widen_or_shorten(CodeGen g, AstNode source_node, TypeT
474	517	orig_val = LLVMBuildZExt(g->builder, trunc_val, actual_type->type_ref, "");
475	518	}
476	519	LLVMValueRef ok_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, expr_val, orig_val, "");
477		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "CastShortenOk");
478		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "CastShortenFail");
	520	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "CastShortenOk");
	521	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "CastShortenFail");
479	522	LLVMBuildCondBr(g->builder, ok_bit, ok_block, fail_block);
480	523
481	524	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -502,8 +545,8 @@ static LLVMValueRef gen_overflow_op(CodeGen g, TypeTableEntry type_entry, AddS
502	545	LLVMValueRef result_struct = LLVMBuildCall(g->builder, fn_val, params, 2, "");
503	546	LLVMValueRef result = LLVMBuildExtractValue(g->builder, result_struct, 0, "");
504	547	LLVMValueRef overflow_bit = LLVMBuildExtractValue(g->builder, result_struct, 1, "");
505		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "OverflowFail");
506		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "OverflowOk");
	548	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "OverflowFail");
	549	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "OverflowOk");
507	550	LLVMBuildCondBr(g->builder, overflow_bit, fail_block, ok_block);
508	551
509	552	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -645,8 +688,8 @@ static LLVMValueRef gen_overflow_shl_op(CodeGen g, TypeTableEntry type_entry,
645	688	}
646	689	LLVMValueRef ok_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, val1, orig_val, "");
647	690
648		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "OverflowOk");
649		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "OverflowFail");
	691	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "OverflowOk");
	692	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "OverflowFail");
650	693	LLVMBuildCondBr(g->builder, ok_bit, ok_block, fail_block);
651	694
652	695	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -656,11 +699,11 @@ static LLVMValueRef gen_overflow_shl_op(CodeGen g, TypeTableEntry type_entry,
656	699	return result;
657	700	}
658	701
659		static LLVMValueRef gen_div(CodeGen g, AstNode source_node, LLVMValueRef val1, LLVMValueRef val2,
	702	static LLVMValueRef gen_div(CodeGen *g, bool want_debug_safety, LLVMValueRef val1, LLVMValueRef val2,
660	703	TypeTableEntry *type_entry, bool exact)
661	704	{
662	705
663		if (want_debug_safety(g, source_node)) {
	706	if (want_debug_safety) {
664	707	LLVMValueRef zero = LLVMConstNull(type_entry->type_ref);
665	708	LLVMValueRef is_zero_bit;
666	709	if (type_entry->id == TypeTableEntryIdInt) {
...	...	@@ -670,8 +713,8 @@ static LLVMValueRef gen_div(CodeGen g, AstNode source_node, LLVMValueRef val1,
670	713	} else {
671	714	zig_unreachable();
672	715	}
673		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "DivZeroOk");
674		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "DivZeroFail");
	716	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "DivZeroOk");
	717	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "DivZeroFail");
675	718	LLVMBuildCondBr(g->builder, is_zero_bit, fail_block, ok_block);
676	719
677	720	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -688,7 +731,7 @@ static LLVMValueRef gen_div(CodeGen g, AstNode source_node, LLVMValueRef val1,
688	731	assert(type_entry->id == TypeTableEntryIdInt);
689	732
690	733	if (exact) {
691		if (want_debug_safety(g, source_node)) {
	734	if (want_debug_safety) {
692	735	LLVMValueRef remainder_val;
693	736	if (type_entry->data.integral.is_signed) {
694	737	remainder_val = LLVMBuildSRem(g->builder, val1, val2, "");
...	...	@@ -698,8 +741,8 @@ static LLVMValueRef gen_div(CodeGen g, AstNode source_node, LLVMValueRef val1,
698	741	LLVMValueRef zero = LLVMConstNull(type_entry->type_ref);
699	742	LLVMValueRef ok_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, remainder_val, zero, "");
700	743
701		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "DivExactOk");
702		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "DivExactFail");
	744	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "DivExactOk");
	745	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "DivExactFail");
703	746	LLVMBuildCondBr(g->builder, ok_bit, ok_block, fail_block);
704	747
705	748	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -727,7 +770,6 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
727	770	IrBinOp op_id = bin_op_instruction->op_id;
728	771	IrInstruction *op1 = bin_op_instruction->op1;
729	772	IrInstruction *op2 = bin_op_instruction->op2;
730		AstNode *source_node = bin_op_instruction->base.source_node;
731	773
732	774	assert(op1->type_entry == op2->type_entry);
733	775
...	...	@@ -801,7 +843,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
801	843	bool is_wrapping = (op_id == IrBinOpBitShiftLeftWrap);
802	844	if (is_wrapping) {
803	845	return LLVMBuildShl(g->builder, op1_value, op2_value, "");
804		} else if (want_debug_safety(g, source_node)) {
	846	} else if (ir_want_debug_safety(g, &bin_op_instruction->base)) {
805	847	return gen_overflow_shl_op(g, op1->type_entry, op1_value, op2_value);
806	848	} else if (op1->type_entry->data.integral.is_signed) {
807	849	return ZigLLVMBuildNSWShl(g->builder, op1_value, op2_value, "");
...	...	@@ -824,7 +866,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
824	866	bool is_wrapping = (op_id == IrBinOpSubWrap);
825	867	if (is_wrapping) {
826	868	return LLVMBuildSub(g->builder, op1_value, op2_value, "");
827		} else if (want_debug_safety(g, source_node)) {
	869	} else if (ir_want_debug_safety(g, &bin_op_instruction->base)) {
828	870	return gen_overflow_op(g, op1->type_entry, AddSubMulSub, op1_value, op2_value);
829	871	} else if (op1->type_entry->data.integral.is_signed) {
830	872	return LLVMBuildNSWSub(g->builder, op1_value, op2_value, "");
...	...	@@ -842,7 +884,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
842	884	bool is_wrapping = (op_id == IrBinOpMultWrap);
843	885	if (is_wrapping) {
844	886	return LLVMBuildMul(g->builder, op1_value, op2_value, "");
845		} else if (want_debug_safety(g, source_node)) {
	887	} else if (ir_want_debug_safety(g, &bin_op_instruction->base)) {
846	888	return gen_overflow_op(g, op1->type_entry, AddSubMulMul, op1_value, op2_value);
847	889	} else if (op1->type_entry->data.integral.is_signed) {
848	890	return LLVMBuildNSWMul(g->builder, op1_value, op2_value, "");
...	...	@@ -853,7 +895,8 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
853	895	zig_unreachable();
854	896	}
855	897	case IrBinOpDiv:
856		return gen_div(g, source_node, op1_value, op2_value, op1->type_entry, false);
	898	return gen_div(g, ir_want_debug_safety(g, &bin_op_instruction->base),
	899	op1_value, op2_value, op1->type_entry, false);
857	900	case IrBinOpMod:
858	901	if (op1->type_entry->id == TypeTableEntryIdFloat) {
859	902	return LLVMBuildFRem(g->builder, op1_value, op2_value, "");
...	...	@@ -885,8 +928,8 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
885	928	case CastOpErrToInt:
886	929	assert(actual_type->id == TypeTableEntryIdErrorUnion);
887	930	if (!type_has_bits(actual_type->data.error.child_type)) {
888		return gen_widen_or_shorten(g, cast_instruction->base.source_node,
889		g->err_tag_type, wanted_type, expr_val);
	931	return gen_widen_or_shorten(g, ir_want_debug_safety(g, &cast_instruction->base),
	932	g->err_tag_type, wanted_type, expr_val);
890	933	} else {
891	934	zig_panic("TODO");
892	935	}
...	...	@@ -954,7 +997,8 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
954	997	case CastOpPointerReinterpret:
955	998	return LLVMBuildBitCast(g->builder, expr_val, wanted_type->type_ref, "");
956	999	case CastOpWidenOrShorten:
957		return gen_widen_or_shorten(g, cast_instruction->base.source_node, actual_type, wanted_type, expr_val);
	1000	return gen_widen_or_shorten(g, ir_want_debug_safety(g, &cast_instruction->base),
	1001	actual_type, wanted_type, expr_val);
958	1002	case CastOpToUnknownSizeArray:
959	1003	{
960	1004	assert(cast_instruction->tmp_ptr);
...	...	@@ -1021,8 +1065,8 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
1021	1065	LLVMValueRef remainder_val = LLVMBuildURem(g->builder, src_len, dest_size_val, "");
1022	1066	LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_usize->type_ref);
1023	1067	LLVMValueRef ok_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, remainder_val, zero, "");
1024		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "SliceWidenOk");
1025		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "SliceWidenFail");
	1068	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "SliceWidenOk");
	1069	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "SliceWidenFail");
1026	1070	LLVMBuildCondBr(g->builder, ok_bit, ok_block, fail_block);
1027	1071
1028	1072	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -1087,10 +1131,10 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
1087	1131	return LLVMBuildZExt(g->builder, expr_val, wanted_type->type_ref, "");
1088	1132
1089	1133	case CastOpIntToEnum:
1090		return gen_widen_or_shorten(g, cast_instruction->base.source_node,
	1134	return gen_widen_or_shorten(g, ir_want_debug_safety(g, &cast_instruction->base),
1091	1135	actual_type, wanted_type->data.enumeration.tag_type, expr_val);
1092	1136	case CastOpEnumToInt:
1093		return gen_widen_or_shorten(g, cast_instruction->base.source_node,
	1137	return gen_widen_or_shorten(g, ir_want_debug_safety(g, &cast_instruction->base),
1094	1138	actual_type->data.enumeration.tag_type, wanted_type, expr_val);
1095	1139	}
1096	1140	zig_unreachable();
...	...	@@ -1197,8 +1241,8 @@ static LLVMValueRef ir_render_un_op(CodeGen g, IrExecutable executable, IrInst
1197	1241	}
1198	1242	LLVMValueRef zero = LLVMConstNull(g->err_tag_type->type_ref);
1199	1243	LLVMValueRef cond_val = LLVMBuildICmp(g->builder, LLVMIntEQ, err_val, zero, "");
1200		LLVMBasicBlockRef err_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "UnwrapErrError");
1201		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "UnwrapErrOk");
	1244	LLVMBasicBlockRef err_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapErrError");
	1245	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapErrOk");
1202	1246	LLVMBuildCondBr(g->builder, cond_val, ok_block, err_block);
1203	1247
1204	1248	LLVMPositionBuilderAtEnd(g->builder, err_block);
...	...	@@ -1231,8 +1275,8 @@ static LLVMValueRef ir_render_un_op(CodeGen g, IrExecutable executable, IrInst
1231	1275	cond_val = LLVMBuildLoad(g->builder, maybe_null_ptr, "");
1232	1276	}
1233	1277
1234		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "UnwrapMaybeOk");
1235		LLVMBasicBlockRef null_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "UnwrapMaybeNull");
	1278	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapMaybeOk");
	1279	LLVMBasicBlockRef null_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapMaybeNull");
1236	1280	LLVMBuildCondBr(g->builder, cond_val, ok_block, null_block);
1237	1281
1238	1282	LLVMPositionBuilderAtEnd(g->builder, null_block);
...	...	@@ -1408,7 +1452,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
1408	1452	LLVMValueRef fn_val;
1409	1453	TypeTableEntry *fn_type;
1410	1454	if (instruction->fn_entry) {
1411		fn_val = instruction->fn_entry->fn_value;
	1455	fn_val = fn_llvm_value(g, instruction->fn_entry);
1412	1456	fn_type = instruction->fn_entry->type_entry;
1413	1457	} else {
1414	1458	assert(instruction->fn_ref);
...	...	@@ -1563,7 +1607,7 @@ static LLVMValueRef ir_render_asm(CodeGen g, IrExecutable executable, IrInstru
1563	1607	}
1564	1608
1565	1609	if (!is_return) {
1566		VariableTableEntry *variable = asm_output->variable;
	1610	VariableTableEntry *variable = instruction->output_vars[i];
1567	1611	assert(variable);
1568	1612	param_types[param_index] = LLVMTypeOf(variable->value_ref);
1569	1613	param_values[param_index] = variable->value_ref;
...	...	@@ -1638,8 +1682,8 @@ static LLVMValueRef ir_render_unwrap_maybe(CodeGen g, IrExecutable executable,
1638	1682	LLVMValueRef maybe_ptr = ir_llvm_value(g, instruction->value);
1639	1683	if (ir_want_debug_safety(g, &instruction->base) && instruction->safety_check_on) {
1640	1684	LLVMValueRef nonnull_bit = gen_null_bit(g, ptr_type, maybe_ptr);
1641		LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "UnwrapMaybeOk");
1642		LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "UnwrapMaybeFail");
	1685	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapMaybeOk");
	1686	LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapMaybeFail");
1643	1687	LLVMBuildCondBr(g->builder, nonnull_bit, ok_block, fail_block);
1644	1688
1645	1689	LLVMPositionBuilderAtEnd(g->builder, fail_block);
...	...	@@ -1730,8 +1774,18 @@ static LLVMValueRef ir_render_ref(CodeGen g, IrExecutable executable, IrInstru
1730	1774	}
1731	1775	}
1732	1776
	1777	static void set_debug_location(CodeGen g, IrInstruction instruction) {
	1778	AstNode *source_node = instruction->source_node;
	1779	Scope *scope = instruction->scope;
	1780
	1781	assert(source_node);
	1782	assert(scope);
	1783
	1784	ZigLLVMSetCurrentDebugLocation(g->builder, source_node->line + 1, source_node->column + 1, get_di_scope(g, scope));
	1785	}
	1786
1733	1787	static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable, IrInstruction *instruction) {
1734		set_debug_source_node(g, instruction->source_node);
	1788	set_debug_location(g, instruction);
1735	1789
1736	1790	switch (instruction->id) {
1737	1791	case IrInstructionIdInvalid:
...	...	@@ -1961,7 +2015,7 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE
1961	2015	}
1962	2016	}
1963	2017	case TypeTableEntryIdFn:
1964		return const_val->data.x_fn->fn_value;
	2018	return fn_llvm_value(g, const_val->data.x_fn);
1965	2019	case TypeTableEntryIdPointer:
1966	2020	{
1967	2021	TypeTableEntry *child_type = type_entry->data.pointer.child_type;
...	...	@@ -2021,7 +2075,6 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE
2021	2075	case TypeTableEntryIdNullLit:
2022	2076	case TypeTableEntryIdNamespace:
2023	2077	case TypeTableEntryIdBlock:
2024		case TypeTableEntryIdGenericFn:
2025	2078	case TypeTableEntryIdBoundFn:
2026	2079	case TypeTableEntryIdVar:
2027	2080	zig_unreachable();
...	...	@@ -2107,7 +2160,7 @@ static LLVMValueRef gen_test_fn_val(CodeGen g, FnTableEntry fn_entry) {
2107	2160	LLVMValueRef name_val = LLVMConstStruct(name_fields, 2, false);
2108	2161	LLVMValueRef fields[] = {
2109	2162	name_val,
2110		fn_entry->fn_value,
	2163	fn_llvm_value(g, fn_entry),
2111	2164	};
2112	2165	return LLVMConstStruct(fields, 2, false);
2113	2166	}
...	...	@@ -2157,7 +2210,7 @@ static void build_all_basic_blocks(CodeGen g, FnTableEntry fn) {
2157	2210	assert(executable->basic_block_list.length > 0);
2158	2211	for (size_t block_i = 0; block_i < executable->basic_block_list.length; block_i += 1) {
2159	2212	IrBasicBlock *bb = executable->basic_block_list.at(block_i);
2160		bb->llvm_block = LLVMAppendBasicBlock(fn->fn_value, bb->name_hint);
	2213	bb->llvm_block = LLVMAppendBasicBlock(fn_llvm_value(g, fn), bb->name_hint);
2161	2214	}
2162	2215	IrBasicBlock *entry_bb = executable->basic_block_list.at(0);
2163	2216	LLVMPositionBuilderAtEnd(g->builder, entry_bb->llvm_block);
...	...	@@ -2167,11 +2220,14 @@ static void gen_global_var(CodeGen g, VariableTableEntry var, LLVMValueRef ini
2167	2220	TypeTableEntry *type_entry)
2168	2221	{
2169	2222	assert(var->gen_is_const);
2170		assert(var->import);
2171	2223	assert(type_entry);
	2224
	2225	ImportTableEntry *import = get_scope_import(var->parent_scope);
	2226	assert(import);
	2227
2172	2228	bool is_local_to_unit = true;
2173	2229	ZigLLVMCreateGlobalVariable(g->dbuilder, get_di_scope(g, var->parent_scope), buf_ptr(&var->name),
2174		buf_ptr(&var->name), var->import->di_file, var->decl_node->line + 1,
	2230	buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
2175	2231	type_entry->di_type, is_local_to_unit, init_val);
2176	2232	}
2177	2233
...	...	@@ -2187,7 +2243,7 @@ static void do_code_gen(CodeGen *g) {
2187	2243
2188	2244	if (var->type->id == TypeTableEntryIdNumLitFloat) {
2189	2245	// Generate debug info for it but that's it.
2190		ConstExprValue *const_val = &var->decl_node->data.variable_declaration.top_level_decl.value->static_value;
	2246	ConstExprValue *const_val = var->value;
2191	2247	assert(const_val->special != ConstValSpecialRuntime);
2192	2248	TypeTableEntry *var_type = g->builtin_types.entry_f64;
2193	2249	LLVMValueRef init_val = LLVMConstReal(var_type->type_ref, const_val->data.x_bignum.data.x_float);
...	...	@@ -2197,7 +2253,7 @@ static void do_code_gen(CodeGen *g) {
2197	2253
2198	2254	if (var->type->id == TypeTableEntryIdNumLitInt) {
2199	2255	// Generate debug info for it but that's it.
2200		ConstExprValue *const_val = &var->decl_node->data.variable_declaration.top_level_decl.value->static_value;
	2256	ConstExprValue *const_val = var->value;
2201	2257	assert(const_val->special != ConstValSpecialRuntime);
2202	2258	TypeTableEntry *var_type = const_val->data.x_bignum.is_negative ?
2203	2259	g->builtin_types.entry_isize : g->builtin_types.entry_usize;
...	...	@@ -2222,13 +2278,12 @@ static void do_code_gen(CodeGen *g) {
2222	2278
2223	2279	LLVMSetLinkage(global_value, LLVMExternalLinkage);
2224	2280	} else {
2225		IrInstruction *instruction = var->decl_node->data.variable_declaration.top_level_decl.value;
2226		render_const_val(g, instruction->type_entry, &instruction->static_value);
2227		render_const_val_global(g, instruction->type_entry, &instruction->static_value);
2228		global_value = instruction->static_value.llvm_global;
	2281	render_const_val(g, var->type, var->value);
	2282	render_const_val_global(g, var->type, var->value);
	2283	global_value = var->value->llvm_global;
2229	2284	// TODO debug info for function pointers
2230	2285	if (var->gen_is_const && var->type->id != TypeTableEntryIdFn) {
2231		gen_global_var(g, var, instruction->static_value.llvm_value, var->type);
	2286	gen_global_var(g, var, var->value->llvm_value, var->type);
2232	2287	}
2233	2288	}
2234	2289
...	...	@@ -2246,12 +2301,8 @@ static void do_code_gen(CodeGen *g) {
2246	2301	// Generate function prototypes
2247	2302	for (size_t fn_proto_i = 0; fn_proto_i < g->fn_protos.length; fn_proto_i += 1) {
2248	2303	FnTableEntry *fn_table_entry = g->fn_protos.at(fn_proto_i);
2249		if (should_skip_fn_codegen(g, fn_table_entry)) {
2250		// huge time saver
2251		LLVMDeleteFunction(fn_table_entry->fn_value);
2252		fn_table_entry->fn_value = nullptr;
	2304	if (should_skip_fn_codegen(g, fn_table_entry))
2253	2305	continue;
2254		}
2255	2306
2256	2307	AstNode *proto_node = fn_table_entry->proto_node;
2257	2308	assert(proto_node->type == NodeTypeFnProto);
...	...	@@ -2259,16 +2310,18 @@ static void do_code_gen(CodeGen *g) {
2259	2310
2260	2311	TypeTableEntry *fn_type = fn_table_entry->type_entry;
2261	2312
	2313	LLVMValueRef fn_val = fn_llvm_value(g, fn_table_entry);
	2314
2262	2315	if (!type_has_bits(fn_type->data.fn.fn_type_id.return_type)) {
2263	2316	// nothing to do
2264	2317	} else if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdPointer) {
2265		ZigLLVMAddNonNullAttr(fn_table_entry->fn_value, 0);
	2318	ZigLLVMAddNonNullAttr(fn_val, 0);
2266	2319	} else if (handle_is_ptr(fn_type->data.fn.fn_type_id.return_type) &&
2267	2320	!fn_type->data.fn.fn_type_id.is_extern)
2268	2321	{
2269		LLVMValueRef first_arg = LLVMGetParam(fn_table_entry->fn_value, 0);
	2322	LLVMValueRef first_arg = LLVMGetParam(fn_val, 0);
2270	2323	LLVMAddAttribute(first_arg, LLVMStructRetAttribute);
2271		ZigLLVMAddNonNullAttr(fn_table_entry->fn_value, 1);
	2324	ZigLLVMAddNonNullAttr(fn_val, 1);
2272	2325	}
2273	2326
2274	2327
...	...	@@ -2286,7 +2339,7 @@ static void do_code_gen(CodeGen *g) {
2286	2339	}
2287	2340
2288	2341	TypeTableEntry *param_type = info->type;
2289		LLVMValueRef argument_val = LLVMGetParam(fn_table_entry->fn_value, gen_index);
	2342	LLVMValueRef argument_val = LLVMGetParam(fn_val, gen_index);
2290	2343	bool param_is_noalias = param_node->data.param_decl.is_noalias;
2291	2344	if (param_is_noalias) {
2292	2345	LLVMAddAttribute(argument_val, LLVMNoAliasAttribute);
...	...	@@ -2295,7 +2348,7 @@ static void do_code_gen(CodeGen *g) {
2295	2348	LLVMAddAttribute(argument_val, LLVMReadOnlyAttribute);
2296	2349	}
2297	2350	if (param_type->id == TypeTableEntryIdPointer) {
2298		ZigLLVMAddNonNullAttr(fn_table_entry->fn_value, gen_index + 1);
	2351	ZigLLVMAddNonNullAttr(fn_val, gen_index + 1);
2299	2352	}
2300	2353	if (is_byval) {
2301	2354	// TODO
...	...	@@ -2345,14 +2398,13 @@ static void do_code_gen(CodeGen *g) {
2345	2398	// Generate function definitions.
2346	2399	for (size_t fn_i = 0; fn_i < g->fn_defs.length; fn_i += 1) {
2347	2400	FnTableEntry *fn_table_entry = g->fn_defs.at(fn_i);
2348		if (should_skip_fn_codegen(g, fn_table_entry)) {
2349		// huge time saver
	2401	if (should_skip_fn_codegen(g, fn_table_entry))
2350	2402	continue;
2351		}
2352	2403
2353	2404	ImportTableEntry *import = fn_table_entry->import_entry;
2354		LLVMValueRef fn = fn_table_entry->fn_value;
	2405	LLVMValueRef fn = fn_llvm_value(g, fn_table_entry);
2355	2406	g->cur_fn = fn_table_entry;
	2407	g->cur_fn_val = fn;
2356	2408	if (handle_is_ptr(fn_table_entry->type_entry->data.fn.fn_type_id.return_type)) {
2357	2409	g->cur_ret_ptr = LLVMGetParam(fn, 0);
2358	2410	} else {
...	...	@@ -2401,7 +2453,18 @@ static void do_code_gen(CodeGen *g) {
2401	2453	if (var->is_inline)
2402	2454	continue;
2403	2455
2404		if (var->parent_scope->node->type == NodeTypeFnDef) {
	2456	if (var->src_arg_index == SIZE_MAX) {
	2457	var->value_ref = LLVMBuildAlloca(g->builder, var->type->type_ref, buf_ptr(&var->name));
	2458
	2459
	2460	unsigned align_bytes = ZigLLVMGetPrefTypeAlignment(g->target_data_ref, var->type->type_ref);
	2461	LLVMSetAlignment(var->value_ref, align_bytes);
	2462
	2463	var->di_loc_var = ZigLLVMCreateAutoVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
	2464	buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
	2465	var->type->di_type, !g->strip_debug_symbols, 0);
	2466
	2467	} else {
2405	2468	assert(var->gen_arg_index != SIZE_MAX);
2406	2469	TypeTableEntry *gen_type;
2407	2470	if (handle_is_ptr(var->type)) {
...	...	@@ -2417,31 +2480,21 @@ static void do_code_gen(CodeGen *g) {
2417	2480	buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
2418	2481	gen_type->di_type, !g->strip_debug_symbols, 0, var->gen_arg_index + 1);
2419	2482
2420		} else {
2421		var->value_ref = LLVMBuildAlloca(g->builder, var->type->type_ref, buf_ptr(&var->name));
2422
2423
2424		unsigned align_bytes = ZigLLVMGetPrefTypeAlignment(g->target_data_ref, var->type->type_ref);
2425		LLVMSetAlignment(var->value_ref, align_bytes);
2426
2427		var->di_loc_var = ZigLLVMCreateAutoVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
2428		buf_ptr(&var->name), import->di_file, var->decl_node->line + 1,
2429		var->type->di_type, !g->strip_debug_symbols, 0);
2430	2483	}
2431	2484	}
2432	2485
2433	2486	// create debug variable declarations for parameters
	2487	// rely on the first variables in the variable_list being parameters.
	2488	size_t next_var_i = 0;
2434	2489	for (size_t param_i = 0; param_i < fn_proto->params.length; param_i += 1) {
2435		AstNode *param_decl = fn_proto->params.at(param_i);
2436		assert(param_decl->type == NodeTypeParamDecl);
2437
2438	2490	FnGenParamInfo *info = &fn_table_entry->type_entry->data.fn.gen_param_info[param_i];
2439
2440		if (info->gen_index == SIZE_MAX) {
	2491	if (info->gen_index == SIZE_MAX)
2441	2492	continue;
2442		}
2443	2493
2444		VariableTableEntry *variable = param_decl->data.param_decl.variable;
	2494	VariableTableEntry *variable = fn_table_entry->variable_list.at(next_var_i);
	2495	assert(variable->src_arg_index != SIZE_MAX);
	2496	next_var_i += 1;
	2497
2445	2498	assert(variable);
2446	2499	assert(variable->value_ref);
2447	2500
...	...	@@ -3308,7 +3361,6 @@ static void get_c_type(CodeGen g, TypeTableEntry type_entry, Buf *out_buf) {
3308	3361	zig_panic("TODO");
3309	3362	case TypeTableEntryIdInvalid:
3310	3363	case TypeTableEntryIdMetaType:
3311		case TypeTableEntryIdGenericFn:
3312	3364	case TypeTableEntryIdBoundFn:
3313	3365	case TypeTableEntryIdNamespace:
3314	3366	case TypeTableEntryIdBlock:
...	...	@@ -3343,7 +3395,7 @@ void codegen_generate_h_file(CodeGen *g) {
3343	3395	assert(proto_node->type == NodeTypeFnProto);
3344	3396	AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
3345	3397
3346		if (fn_proto->top_level_decl.visib_mod != VisibModExport)
	3398	if (fn_proto->visib_mod != VisibModExport)
3347	3399	continue;
3348	3400
3349	3401	FnTypeId *fn_type_id = &fn_table_entry->type_entry->data.fn.fn_type_id;

src/eval.cpp-1

...	...	@@ -55,7 +55,6 @@ bool const_values_equal(ConstExprValue a, ConstExprValue b, TypeTableEntry *ty
55	55	zig_panic("TODO");
56	56	case TypeTableEntryIdBlock:
57	57	zig_panic("TODO");
58		case TypeTableEntryIdGenericFn:
59	58	case TypeTableEntryIdBoundFn:
60	59	case TypeTableEntryIdInvalid:
61	60	case TypeTableEntryIdUnreachable:

src/ir.cpp+686-668

...	...	@@ -1,3 +1,10 @@
	1	/*
	2	* Copyright (c) 2016 Andrew Kelley
	3	*
	4	* This file is part of zig, which is MIT licensed.
	5	* See http://opensource.org/licenses/MIT
	6	*/
	7
1	8	#include "analyze.hpp"
2	9	#include "error.hpp"
3	10	#include "eval.hpp"
...	...	@@ -71,6 +78,10 @@ static size_t exec_next_mem_slot(IrExecutable *exec) {
71	78	return result;
72	79	}
73	80
	81	static FnTableEntry exec_fn_entry(IrExecutable exec) {
	82	return exec->fn_entry;
	83	}
	84
74	85	static void ir_link_new_instruction(IrInstruction new_instruction, IrInstruction old_instruction) {
75	86	new_instruction->other = old_instruction;
76	87	old_instruction->other = new_instruction;
...	...	@@ -289,26 +300,27 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionStructInit *) {
289	300	}
290	301
291	302	template<typename T>
292		static T ir_create_instruction(IrExecutable exec, AstNode *source_node) {
	303	static T ir_create_instruction(IrExecutable exec, Scope scope, AstNode source_node) {
293	304	T *special_instruction = allocate<T>(1);
294	305	special_instruction->base.id = ir_instruction_id(special_instruction);
	306	special_instruction->base.scope = scope;
295	307	special_instruction->base.source_node = source_node;
296	308	special_instruction->base.debug_id = exec_next_debug_id(exec);
297	309	return special_instruction;
298	310	}
299	311
300	312	template<typename T>
301		static T ir_build_instruction(IrBuilder irb, AstNode *source_node) {
	313	static T ir_build_instruction(IrBuilder irb, Scope scope, AstNode source_node) {
302	314	assert(source_node);
303		T *special_instruction = ir_create_instruction<T>(irb->exec, source_node);
	315	T *special_instruction = ir_create_instruction<T>(irb->exec, scope, source_node);
304	316	ir_instruction_append(irb->current_basic_block, &special_instruction->base);
305	317	return special_instruction;
306	318	}
307	319
308		static IrInstruction ir_build_cast(IrBuilder irb, AstNode source_node, TypeTableEntry dest_type,
	320	static IrInstruction ir_build_cast(IrBuilder irb, Scope scope, AstNode source_node, TypeTableEntry *dest_type,
309	321	IrInstruction *value, CastOp cast_op)
310	322	{
311		IrInstructionCast *cast_instruction = ir_build_instruction<IrInstructionCast>(irb, source_node);
	323	IrInstructionCast *cast_instruction = ir_build_instruction<IrInstructionCast>(irb, scope, source_node);
312	324	cast_instruction->dest_type = dest_type;
313	325	cast_instruction->value = value;
314	326	cast_instruction->cast_op = cast_op;
...	...	@@ -318,10 +330,10 @@ static IrInstruction ir_build_cast(IrBuilder irb, AstNode *source_node, TypeTa
318	330	return &cast_instruction->base;
319	331	}
320	332
321		static IrInstruction ir_build_cond_br(IrBuilder irb, AstNode source_node, IrInstruction condition,
	333	static IrInstruction ir_build_cond_br(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *condition,
322	334	IrBasicBlock then_block, IrBasicBlock else_block, bool is_inline)
323	335	{
324		IrInstructionCondBr *cond_br_instruction = ir_build_instruction<IrInstructionCondBr>(irb, source_node);
	336	IrInstructionCondBr *cond_br_instruction = ir_build_instruction<IrInstructionCondBr>(irb, scope, source_node);
325	337	cond_br_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
326	338	cond_br_instruction->base.static_value.special = ConstValSpecialStatic;
327	339	cond_br_instruction->condition = condition;
...	...	@@ -339,14 +351,14 @@ static IrInstruction ir_build_cond_br(IrBuilder irb, AstNode *source_node, IrI
339	351	static IrInstruction ir_build_cond_br_from(IrBuilder irb, IrInstruction *old_instruction,
340	352	IrInstruction condition, IrBasicBlock then_block, IrBasicBlock *else_block, bool is_inline)
341	353	{
342		IrInstruction *new_instruction = ir_build_cond_br(irb, old_instruction->source_node,
	354	IrInstruction *new_instruction = ir_build_cond_br(irb, old_instruction->scope, old_instruction->source_node,
343	355	condition, then_block, else_block, is_inline);
344	356	ir_link_new_instruction(new_instruction, old_instruction);
345	357	return new_instruction;
346	358	}
347	359
348		static IrInstruction ir_build_return(IrBuilder irb, AstNode source_node, IrInstruction return_value) {
349		IrInstructionReturn *return_instruction = ir_build_instruction<IrInstructionReturn>(irb, source_node);
	360	static IrInstruction ir_build_return(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *return_value) {
	361	IrInstructionReturn *return_instruction = ir_build_instruction<IrInstructionReturn>(irb, scope, source_node);
350	362	return_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
351	363	return_instruction->base.static_value.special = ConstValSpecialStatic;
352	364	return_instruction->value = return_value;
...	...	@@ -359,38 +371,38 @@ static IrInstruction ir_build_return(IrBuilder irb, AstNode *source_node, IrIn
359	371	static IrInstruction ir_build_return_from(IrBuilder irb, IrInstruction *old_instruction,
360	372	IrInstruction *return_value)
361	373	{
362		IrInstruction *new_instruction = ir_build_return(irb, old_instruction->source_node, return_value);
	374	IrInstruction *new_instruction = ir_build_return(irb, old_instruction->scope, old_instruction->source_node, return_value);
363	375	ir_link_new_instruction(new_instruction, old_instruction);
364	376	return new_instruction;
365	377	}
366	378
367		static IrInstruction ir_create_const(IrBuilder irb, AstNode *source_node,
	379	static IrInstruction ir_create_const(IrBuilder irb, Scope scope, AstNode source_node,
368	380	TypeTableEntry *type_entry, bool depends_on_compile_var)
369	381	{
370	382	assert(type_entry);
371		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, source_node);
	383	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, scope, source_node);
372	384	const_instruction->base.type_entry = type_entry;
373	385	const_instruction->base.static_value.special = ConstValSpecialStatic;
374	386	const_instruction->base.static_value.depends_on_compile_var = depends_on_compile_var;
375	387	return &const_instruction->base;
376	388	}
377	389
378		static IrInstruction ir_build_const_void(IrBuilder irb, AstNode *source_node) {
379		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	390	static IrInstruction ir_build_const_void(IrBuilder irb, Scope scope, AstNode source_node) {
	391	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
380	392	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_void;
381	393	const_instruction->base.static_value.special = ConstValSpecialStatic;
382	394	return &const_instruction->base;
383	395	}
384	396
385		static IrInstruction ir_build_const_undefined(IrBuilder irb, AstNode *source_node) {
386		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	397	static IrInstruction ir_build_const_undefined(IrBuilder irb, Scope scope, AstNode source_node) {
	398	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
387	399	const_instruction->base.static_value.special = ConstValSpecialUndef;
388	400	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_undef;
389	401	return &const_instruction->base;
390	402	}
391	403
392		static IrInstruction ir_build_const_bignum(IrBuilder irb, AstNode source_node, BigNum bignum) {
393		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	404	static IrInstruction ir_build_const_bignum(IrBuilder irb, Scope scope, AstNode source_node, BigNum *bignum) {
	405	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
394	406	const_instruction->base.type_entry = (bignum->kind == BigNumKindInt) ?
395	407	irb->codegen->builtin_types.entry_num_lit_int : irb->codegen->builtin_types.entry_num_lit_float;
396	408	const_instruction->base.static_value.special = ConstValSpecialStatic;
...	...	@@ -398,79 +410,77 @@ static IrInstruction ir_build_const_bignum(IrBuilder irb, AstNode *source_node
398	410	return &const_instruction->base;
399	411	}
400	412
401		static IrInstruction ir_build_const_null(IrBuilder irb, AstNode *source_node) {
402		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	413	static IrInstruction ir_build_const_null(IrBuilder irb, Scope scope, AstNode source_node) {
	414	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
403	415	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_null;
404	416	const_instruction->base.static_value.special = ConstValSpecialStatic;
405	417	return &const_instruction->base;
406	418	}
407	419
408		static IrInstruction ir_build_const_usize(IrBuilder irb, AstNode *source_node, uint64_t value) {
409		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	420	static IrInstruction ir_build_const_usize(IrBuilder irb, Scope scope, AstNode source_node, uint64_t value) {
	421	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
410	422	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_usize;
411	423	const_instruction->base.static_value.special = ConstValSpecialStatic;
412	424	bignum_init_unsigned(&const_instruction->base.static_value.data.x_bignum, value);
413	425	return &const_instruction->base;
414	426	}
415	427
416		static IrInstruction ir_create_const_type(IrBuilder irb, AstNode source_node, TypeTableEntry type_entry) {
417		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, source_node);
	428	static IrInstruction ir_create_const_type(IrBuilder irb, Scope scope, AstNode source_node,
	429	TypeTableEntry *type_entry)
	430	{
	431	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, scope, source_node);
418	432	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_type;
419	433	const_instruction->base.static_value.special = ConstValSpecialStatic;
420	434	const_instruction->base.static_value.data.x_type = type_entry;
421	435	return &const_instruction->base;
422	436	}
423	437
424		static IrInstruction ir_build_const_type(IrBuilder irb, AstNode source_node, TypeTableEntry type_entry) {
425		IrInstruction *instruction = ir_create_const_type(irb, source_node, type_entry);
	438	static IrInstruction ir_build_const_type(IrBuilder irb, Scope scope, AstNode source_node,
	439	TypeTableEntry *type_entry)
	440	{
	441	IrInstruction *instruction = ir_create_const_type(irb, scope, source_node, type_entry);
426	442	ir_instruction_append(irb->current_basic_block, instruction);
427	443	return instruction;
428	444	}
429	445
430		static IrInstruction ir_build_const_fn(IrBuilder irb, AstNode source_node, FnTableEntry fn_entry) {
431		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	446	static IrInstruction ir_build_const_fn(IrBuilder irb, Scope scope, AstNode source_node, FnTableEntry *fn_entry) {
	447	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
432	448	const_instruction->base.type_entry = fn_entry->type_entry;
433	449	const_instruction->base.static_value.special = ConstValSpecialStatic;
434	450	const_instruction->base.static_value.data.x_fn = fn_entry;
435	451	return &const_instruction->base;
436	452	}
437	453
438		static IrInstruction ir_build_const_generic_fn(IrBuilder irb, AstNode source_node, TypeTableEntry fn_type) {
439		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
440		const_instruction->base.type_entry = fn_type;
441		const_instruction->base.static_value.special = ConstValSpecialStatic;
442		const_instruction->base.static_value.data.x_type = fn_type;
443		return &const_instruction->base;
444		}
445
446		static IrInstruction ir_build_const_import(IrBuilder irb, AstNode source_node, ImportTableEntry import) {
447		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	454	static IrInstruction ir_build_const_import(IrBuilder irb, Scope scope, AstNode source_node, ImportTableEntry *import) {
	455	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
448	456	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_namespace;
449	457	const_instruction->base.static_value.special = ConstValSpecialStatic;
450	458	const_instruction->base.static_value.data.x_import = import;
451	459	return &const_instruction->base;
452	460	}
453	461
454		static IrInstruction ir_build_const_scope(IrBuilder irb, AstNode source_node, Scope scope) {
455		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	462	static IrInstruction ir_build_const_scope(IrBuilder irb, Scope parent_scope, AstNode source_node,
	463	Scope *target_scope)
	464	{
	465	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, parent_scope, source_node);
456	466	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_block;
457	467	const_instruction->base.static_value.special = ConstValSpecialStatic;
458		const_instruction->base.static_value.data.x_block = scope;
	468	const_instruction->base.static_value.data.x_block = target_scope;
459	469	return &const_instruction->base;
460	470	}
461	471
462		static IrInstruction ir_build_const_bool(IrBuilder irb, AstNode *source_node, bool value) {
463		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	472	static IrInstruction ir_build_const_bool(IrBuilder irb, Scope scope, AstNode source_node, bool value) {
	473	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
464	474	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_bool;
465	475	const_instruction->base.static_value.special = ConstValSpecialStatic;
466	476	const_instruction->base.static_value.data.x_bool = value;
467	477	return &const_instruction->base;
468	478	}
469	479
470		static IrInstruction ir_build_const_bound_fn(IrBuilder irb, AstNode *source_node,
	480	static IrInstruction ir_build_const_bound_fn(IrBuilder irb, Scope scope, AstNode source_node,
471	481	FnTableEntry fn_entry, IrInstruction first_arg, bool depends_on_compile_var)
472	482	{
473		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	483	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
474	484	const_instruction->base.type_entry = get_bound_fn_type(irb->codegen, fn_entry);
475	485	const_instruction->base.static_value.special = ConstValSpecialStatic;
476	486	const_instruction->base.static_value.depends_on_compile_var = depends_on_compile_var;
...	...	@@ -479,8 +489,8 @@ static IrInstruction ir_build_const_bound_fn(IrBuilder irb, AstNode *source_no
479	489	return &const_instruction->base;
480	490	}
481	491
482		static IrInstruction ir_build_const_str_lit(IrBuilder irb, AstNode source_node, Buf str) {
483		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	492	static IrInstruction ir_build_const_str_lit(IrBuilder irb, Scope scope, AstNode source_node, Buf *str) {
	493	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
484	494	TypeTableEntry *u8_type = irb->codegen->builtin_types.entry_u8;
485	495	TypeTableEntry *type_entry = get_array_type(irb->codegen, u8_type, buf_len(str));
486	496	const_instruction->base.type_entry = type_entry;
...	...	@@ -498,7 +508,7 @@ static IrInstruction ir_build_const_str_lit(IrBuilder irb, AstNode *source_nod
498	508	return &const_instruction->base;
499	509	}
500	510
501		static IrInstruction ir_build_const_c_str_lit(IrBuilder irb, AstNode source_node, Buf str) {
	511	static IrInstruction ir_build_const_c_str_lit(IrBuilder irb, Scope scope, AstNode source_node, Buf *str) {
502	512	// first we build the underlying array
503	513	size_t len_with_null = buf_len(str) + 1;
504	514	ConstExprValue *array_val = allocate<ConstExprValue>(1);
...	...	@@ -515,7 +525,7 @@ static IrInstruction ir_build_const_c_str_lit(IrBuilder irb, AstNode *source_n
515	525	bignum_init_unsigned(&null_char->data.x_bignum, 0);
516	526
517	527	// then make the pointer point to it
518		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	528	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
519	529	TypeTableEntry *u8_type = irb->codegen->builtin_types.entry_u8;
520	530	TypeTableEntry *type_entry = get_pointer_to_type(irb->codegen, u8_type, true);
521	531	const_instruction->base.type_entry = type_entry;
...	...	@@ -528,10 +538,10 @@ static IrInstruction ir_build_const_c_str_lit(IrBuilder irb, AstNode *source_n
528	538	return &const_instruction->base;
529	539	}
530	540
531		static IrInstruction ir_build_bin_op(IrBuilder irb, AstNode *source_node, IrBinOp op_id,
	541	static IrInstruction ir_build_bin_op(IrBuilder irb, Scope scope, AstNode source_node, IrBinOp op_id,
532	542	IrInstruction op1, IrInstruction op2)
533	543	{
534		IrInstructionBinOp *bin_op_instruction = ir_build_instruction<IrInstructionBinOp>(irb, source_node);
	544	IrInstructionBinOp *bin_op_instruction = ir_build_instruction<IrInstructionBinOp>(irb, scope, source_node);
535	545	bin_op_instruction->op_id = op_id;
536	546	bin_op_instruction->op1 = op1;
537	547	bin_op_instruction->op2 = op2;
...	...	@@ -545,13 +555,14 @@ static IrInstruction ir_build_bin_op(IrBuilder irb, AstNode *source_node, IrBi
545	555	static IrInstruction ir_build_bin_op_from(IrBuilder irb, IrInstruction *old_instruction, IrBinOp op_id,
546	556	IrInstruction op1, IrInstruction op2)
547	557	{
548		IrInstruction *new_instruction = ir_build_bin_op(irb, old_instruction->source_node, op_id, op1, op2);
	558	IrInstruction *new_instruction = ir_build_bin_op(irb, old_instruction->scope,
	559	old_instruction->source_node, op_id, op1, op2);
549	560	ir_link_new_instruction(new_instruction, old_instruction);
550	561	return new_instruction;
551	562	}
552	563
553		static IrInstruction ir_build_var_ptr(IrBuilder irb, AstNode source_node, VariableTableEntry var) {
554		IrInstructionVarPtr *instruction = ir_build_instruction<IrInstructionVarPtr>(irb, source_node);
	564	static IrInstruction ir_build_var_ptr(IrBuilder irb, Scope scope, AstNode source_node, VariableTableEntry *var) {
	565	IrInstructionVarPtr *instruction = ir_build_instruction<IrInstructionVarPtr>(irb, scope, source_node);
555	566	instruction->var = var;
556	567
557	568	ir_ref_var(var);
...	...	@@ -560,16 +571,16 @@ static IrInstruction ir_build_var_ptr(IrBuilder irb, AstNode *source_node, Var
560	571	}
561	572
562	573	static IrInstruction ir_build_var_ptr_from(IrBuilder irb, IrInstruction old_instruction, VariableTableEntry var) {
563		IrInstruction *new_instruction = ir_build_var_ptr(irb, old_instruction->source_node, var);
	574	IrInstruction *new_instruction = ir_build_var_ptr(irb, old_instruction->scope, old_instruction->source_node, var);
564	575	ir_link_new_instruction(new_instruction, old_instruction);
565	576	return new_instruction;
566	577
567	578	}
568	579
569		static IrInstruction ir_build_elem_ptr(IrBuilder irb, AstNode source_node, IrInstruction array_ptr,
	580	static IrInstruction ir_build_elem_ptr(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *array_ptr,
570	581	IrInstruction *elem_index, bool safety_check_on)
571	582	{
572		IrInstructionElemPtr *instruction = ir_build_instruction<IrInstructionElemPtr>(irb, source_node);
	583	IrInstructionElemPtr *instruction = ir_build_instruction<IrInstructionElemPtr>(irb, scope, source_node);
573	584	instruction->array_ptr = array_ptr;
574	585	instruction->elem_index = elem_index;
575	586	instruction->safety_check_on = safety_check_on;
...	...	@@ -583,16 +594,16 @@ static IrInstruction ir_build_elem_ptr(IrBuilder irb, AstNode *source_node, Ir
583	594	static IrInstruction ir_build_elem_ptr_from(IrBuilder irb, IrInstruction *old_instruction,
584	595	IrInstruction array_ptr, IrInstruction elem_index, bool safety_check_on)
585	596	{
586		IrInstruction *new_instruction = ir_build_elem_ptr(irb, old_instruction->source_node, array_ptr, elem_index,
587		safety_check_on);
	597	IrInstruction *new_instruction = ir_build_elem_ptr(irb, old_instruction->scope,
	598	old_instruction->source_node, array_ptr, elem_index, safety_check_on);
588	599	ir_link_new_instruction(new_instruction, old_instruction);
589	600	return new_instruction;
590	601	}
591	602
592		static IrInstruction ir_build_field_ptr(IrBuilder irb, AstNode *source_node,
	603	static IrInstruction ir_build_field_ptr(IrBuilder irb, Scope scope, AstNode source_node,
593	604	IrInstruction container_ptr, Buf field_name)
594	605	{
595		IrInstructionFieldPtr *instruction = ir_build_instruction<IrInstructionFieldPtr>(irb, source_node);
	606	IrInstructionFieldPtr *instruction = ir_build_instruction<IrInstructionFieldPtr>(irb, scope, source_node);
596	607	instruction->container_ptr = container_ptr;
597	608	instruction->field_name = field_name;
598	609
...	...	@@ -601,10 +612,10 @@ static IrInstruction ir_build_field_ptr(IrBuilder irb, AstNode *source_node,
601	612	return &instruction->base;
602	613	}
603	614
604		static IrInstruction ir_build_struct_field_ptr(IrBuilder irb, AstNode *source_node,
	615	static IrInstruction ir_build_struct_field_ptr(IrBuilder irb, Scope scope, AstNode source_node,
605	616	IrInstruction struct_ptr, TypeStructField field)
606	617	{
607		IrInstructionStructFieldPtr *instruction = ir_build_instruction<IrInstructionStructFieldPtr>(irb, source_node);
	618	IrInstructionStructFieldPtr *instruction = ir_build_instruction<IrInstructionStructFieldPtr>(irb, scope, source_node);
608	619	instruction->struct_ptr = struct_ptr;
609	620	instruction->field = field;
610	621
...	...	@@ -616,16 +627,16 @@ static IrInstruction ir_build_struct_field_ptr(IrBuilder irb, AstNode *source_
616	627	static IrInstruction ir_build_struct_field_ptr_from(IrBuilder irb, IrInstruction *old_instruction,
617	628	IrInstruction struct_ptr, TypeStructField type_struct_field)
618	629	{
619		IrInstruction *new_instruction = ir_build_struct_field_ptr(irb, old_instruction->source_node,
620		struct_ptr, type_struct_field);
	630	IrInstruction *new_instruction = ir_build_struct_field_ptr(irb, old_instruction->scope,
	631	old_instruction->source_node, struct_ptr, type_struct_field);
621	632	ir_link_new_instruction(new_instruction, old_instruction);
622	633	return new_instruction;
623	634	}
624	635
625		static IrInstruction ir_build_enum_field_ptr(IrBuilder irb, AstNode *source_node,
	636	static IrInstruction ir_build_enum_field_ptr(IrBuilder irb, Scope scope, AstNode source_node,
626	637	IrInstruction enum_ptr, TypeEnumField field)
627	638	{
628		IrInstructionEnumFieldPtr *instruction = ir_build_instruction<IrInstructionEnumFieldPtr>(irb, source_node);
	639	IrInstructionEnumFieldPtr *instruction = ir_build_instruction<IrInstructionEnumFieldPtr>(irb, scope, source_node);
629	640	instruction->enum_ptr = enum_ptr;
630	641	instruction->field = field;
631	642
...	...	@@ -637,16 +648,16 @@ static IrInstruction ir_build_enum_field_ptr(IrBuilder irb, AstNode *source_no
637	648	static IrInstruction ir_build_enum_field_ptr_from(IrBuilder irb, IrInstruction *old_instruction,
638	649	IrInstruction enum_ptr, TypeEnumField type_enum_field)
639	650	{
640		IrInstruction *new_instruction = ir_build_enum_field_ptr(irb, old_instruction->source_node,
641		enum_ptr, type_enum_field);
	651	IrInstruction *new_instruction = ir_build_enum_field_ptr(irb, old_instruction->scope,
	652	old_instruction->source_node, enum_ptr, type_enum_field);
642	653	ir_link_new_instruction(new_instruction, old_instruction);
643	654	return new_instruction;
644	655	}
645	656
646		static IrInstruction ir_build_call(IrBuilder irb, AstNode *source_node,
	657	static IrInstruction ir_build_call(IrBuilder irb, Scope scope, AstNode source_node,
647	658	FnTableEntry fn_entry, IrInstruction fn_ref, size_t arg_count, IrInstruction **args)
648	659	{
649		IrInstructionCall *call_instruction = ir_build_instruction<IrInstructionCall>(irb, source_node);
	660	IrInstructionCall *call_instruction = ir_build_instruction<IrInstructionCall>(irb, scope, source_node);
650	661	call_instruction->fn_entry = fn_entry;
651	662	call_instruction->fn_ref = fn_ref;
652	663	call_instruction->arg_count = arg_count;
...	...	@@ -663,18 +674,19 @@ static IrInstruction ir_build_call(IrBuilder irb, AstNode *source_node,
663	674	static IrInstruction ir_build_call_from(IrBuilder irb, IrInstruction *old_instruction,
664	675	FnTableEntry fn_entry, IrInstruction fn_ref, size_t arg_count, IrInstruction **args)
665	676	{
666		IrInstruction *new_instruction = ir_build_call(irb, old_instruction->source_node, fn_entry, fn_ref, arg_count, args);
	677	IrInstruction *new_instruction = ir_build_call(irb, old_instruction->scope,
	678	old_instruction->source_node, fn_entry, fn_ref, arg_count, args);
667	679	ir_link_new_instruction(new_instruction, old_instruction);
668	680	return new_instruction;
669	681	}
670	682
671		static IrInstruction ir_build_phi(IrBuilder irb, AstNode *source_node,
	683	static IrInstruction ir_build_phi(IrBuilder irb, Scope scope, AstNode source_node,
672	684	size_t incoming_count, IrBasicBlock incoming_blocks, IrInstruction incoming_values)
673	685	{
674	686	assert(incoming_count != 0);
675	687	assert(incoming_count != SIZE_MAX);
676	688
677		IrInstructionPhi *phi_instruction = ir_build_instruction<IrInstructionPhi>(irb, source_node);
	689	IrInstructionPhi *phi_instruction = ir_build_instruction<IrInstructionPhi>(irb, scope, source_node);
678	690	phi_instruction->incoming_count = incoming_count;
679	691	phi_instruction->incoming_blocks = incoming_blocks;
680	692	phi_instruction->incoming_values = incoming_values;
...	...	@@ -690,14 +702,16 @@ static IrInstruction ir_build_phi(IrBuilder irb, AstNode *source_node,
690	702	static IrInstruction ir_build_phi_from(IrBuilder irb, IrInstruction *old_instruction,
691	703	size_t incoming_count, IrBasicBlock incoming_blocks, IrInstruction incoming_values)
692	704	{
693		IrInstruction *new_instruction = ir_build_phi(irb, old_instruction->source_node,
	705	IrInstruction *new_instruction = ir_build_phi(irb, old_instruction->scope, old_instruction->source_node,
694	706	incoming_count, incoming_blocks, incoming_values);
695	707	ir_link_new_instruction(new_instruction, old_instruction);
696	708	return new_instruction;
697	709	}
698	710
699		static IrInstruction ir_create_br(IrBuilder irb, AstNode source_node, IrBasicBlock dest_block, bool is_inline) {
700		IrInstructionBr *br_instruction = ir_create_instruction<IrInstructionBr>(irb->exec, source_node);
	711	static IrInstruction ir_create_br(IrBuilder irb, Scope scope, AstNode source_node,
	712	IrBasicBlock *dest_block, bool is_inline)
	713	{
	714	IrInstructionBr *br_instruction = ir_create_instruction<IrInstructionBr>(irb->exec, scope, source_node);
701	715	br_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
702	716	br_instruction->base.static_value.special = ConstValSpecialStatic;
703	717	br_instruction->dest_block = dest_block;
...	...	@@ -708,20 +722,23 @@ static IrInstruction ir_create_br(IrBuilder irb, AstNode *source_node, IrBasic
708	722	return &br_instruction->base;
709	723	}
710	724
711		static IrInstruction ir_build_br(IrBuilder irb, AstNode source_node, IrBasicBlock dest_block, bool is_inline) {
712		IrInstruction *instruction = ir_create_br(irb, source_node, dest_block, is_inline);
	725	static IrInstruction ir_build_br(IrBuilder irb, Scope scope, AstNode source_node,
	726	IrBasicBlock *dest_block, bool is_inline)
	727	{
	728	IrInstruction *instruction = ir_create_br(irb, scope, source_node, dest_block, is_inline);
713	729	ir_instruction_append(irb->current_basic_block, instruction);
714	730	return instruction;
715	731	}
716	732
717	733	static IrInstruction ir_build_br_from(IrBuilder irb, IrInstruction old_instruction, IrBasicBlock dest_block) {
718		IrInstruction *new_instruction = ir_build_br(irb, old_instruction->source_node, dest_block, false);
	734	IrInstruction *new_instruction = ir_build_br(irb, old_instruction->scope,
	735	old_instruction->source_node, dest_block, false);
719	736	ir_link_new_instruction(new_instruction, old_instruction);
720	737	return new_instruction;
721	738	}
722	739
723		static IrInstruction ir_build_un_op(IrBuilder irb, AstNode source_node, IrUnOp op_id, IrInstruction value) {
724		IrInstructionUnOp *br_instruction = ir_build_instruction<IrInstructionUnOp>(irb, source_node);
	740	static IrInstruction ir_build_un_op(IrBuilder irb, Scope scope, AstNode source_node, IrUnOp op_id, IrInstruction *value) {
	741	IrInstructionUnOp *br_instruction = ir_build_instruction<IrInstructionUnOp>(irb, scope, source_node);
725	742	br_instruction->op_id = op_id;
726	743	br_instruction->value = value;
727	744
...	...	@@ -733,16 +750,17 @@ static IrInstruction ir_build_un_op(IrBuilder irb, AstNode *source_node, IrUnO
733	750	static IrInstruction ir_build_un_op_from(IrBuilder irb, IrInstruction *old_instruction,
734	751	IrUnOp op_id, IrInstruction *value)
735	752	{
736		IrInstruction *new_instruction = ir_build_un_op(irb, old_instruction->source_node, op_id, value);
	753	IrInstruction *new_instruction = ir_build_un_op(irb, old_instruction->scope,
	754	old_instruction->source_node, op_id, value);
737	755	ir_link_new_instruction(new_instruction, old_instruction);
738	756	return new_instruction;
739	757	}
740	758
741		static IrInstruction ir_build_container_init_list(IrBuilder irb, AstNode *source_node,
	759	static IrInstruction ir_build_container_init_list(IrBuilder irb, Scope scope, AstNode source_node,
742	760	IrInstruction container_type, size_t item_count, IrInstruction *items)
743	761	{
744	762	IrInstructionContainerInitList *container_init_list_instruction =
745		ir_build_instruction<IrInstructionContainerInitList>(irb, source_node);
	763	ir_build_instruction<IrInstructionContainerInitList>(irb, scope, source_node);
746	764	container_init_list_instruction->container_type = container_type;
747	765	container_init_list_instruction->item_count = item_count;
748	766	container_init_list_instruction->items = items;
...	...	@@ -758,17 +776,17 @@ static IrInstruction ir_build_container_init_list(IrBuilder irb, AstNode *sour
758	776	static IrInstruction ir_build_container_init_list_from(IrBuilder irb, IrInstruction *old_instruction,
759	777	IrInstruction container_type, size_t item_count, IrInstruction *items)
760	778	{
761		IrInstruction *new_instruction = ir_build_container_init_list(irb, old_instruction->source_node,
762		container_type, item_count, items);
	779	IrInstruction *new_instruction = ir_build_container_init_list(irb, old_instruction->scope,
	780	old_instruction->source_node, container_type, item_count, items);
763	781	ir_link_new_instruction(new_instruction, old_instruction);
764	782	return new_instruction;
765	783	}
766	784
767		static IrInstruction ir_build_container_init_fields(IrBuilder irb, AstNode *source_node,
	785	static IrInstruction ir_build_container_init_fields(IrBuilder irb, Scope scope, AstNode source_node,
768	786	IrInstruction container_type, size_t field_count, IrInstructionContainerInitFieldsField fields)
769	787	{
770	788	IrInstructionContainerInitFields *container_init_fields_instruction =
771		ir_build_instruction<IrInstructionContainerInitFields>(irb, source_node);
	789	ir_build_instruction<IrInstructionContainerInitFields>(irb, scope, source_node);
772	790	container_init_fields_instruction->container_type = container_type;
773	791	container_init_fields_instruction->field_count = field_count;
774	792	container_init_fields_instruction->fields = fields;
...	...	@@ -781,10 +799,10 @@ static IrInstruction ir_build_container_init_fields(IrBuilder irb, AstNode *so
781	799	return &container_init_fields_instruction->base;
782	800	}
783	801
784		static IrInstruction ir_build_struct_init(IrBuilder irb, AstNode *source_node,
	802	static IrInstruction ir_build_struct_init(IrBuilder irb, Scope scope, AstNode source_node,
785	803	TypeTableEntry struct_type, size_t field_count, IrInstructionStructInitField fields)
786	804	{
787		IrInstructionStructInit *struct_init_instruction = ir_build_instruction<IrInstructionStructInit>(irb, source_node);
	805	IrInstructionStructInit *struct_init_instruction = ir_build_instruction<IrInstructionStructInit>(irb, scope, source_node);
788	806	struct_init_instruction->struct_type = struct_type;
789	807	struct_init_instruction->field_count = field_count;
790	808	struct_init_instruction->fields = fields;
...	...	@@ -798,30 +816,30 @@ static IrInstruction ir_build_struct_init(IrBuilder irb, AstNode *source_node,
798	816	static IrInstruction ir_build_struct_init_from(IrBuilder irb, IrInstruction *old_instruction,
799	817	TypeTableEntry struct_type, size_t field_count, IrInstructionStructInitField fields)
800	818	{
801		IrInstruction *new_instruction = ir_build_struct_init(irb, old_instruction->source_node,
802		struct_type, field_count, fields);
	819	IrInstruction *new_instruction = ir_build_struct_init(irb, old_instruction->scope,
	820	old_instruction->source_node, struct_type, field_count, fields);
803	821	ir_link_new_instruction(new_instruction, old_instruction);
804	822	return new_instruction;
805	823	}
806	824
807		static IrInstruction ir_build_unreachable(IrBuilder irb, AstNode *source_node) {
	825	static IrInstruction ir_build_unreachable(IrBuilder irb, Scope scope, AstNode source_node) {
808	826	IrInstructionUnreachable *unreachable_instruction =
809		ir_build_instruction<IrInstructionUnreachable>(irb, source_node);
	827	ir_build_instruction<IrInstructionUnreachable>(irb, scope, source_node);
810	828	unreachable_instruction->base.static_value.special = ConstValSpecialStatic;
811	829	unreachable_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
812	830	return &unreachable_instruction->base;
813	831	}
814	832
815	833	static IrInstruction ir_build_unreachable_from(IrBuilder irb, IrInstruction *old_instruction) {
816		IrInstruction *new_instruction = ir_build_unreachable(irb, old_instruction->source_node);
	834	IrInstruction *new_instruction = ir_build_unreachable(irb, old_instruction->scope, old_instruction->source_node);
817	835	ir_link_new_instruction(new_instruction, old_instruction);
818	836	return new_instruction;
819	837	}
820	838
821		static IrInstruction ir_build_store_ptr(IrBuilder irb, AstNode *source_node,
	839	static IrInstruction ir_build_store_ptr(IrBuilder irb, Scope scope, AstNode source_node,
822	840	IrInstruction ptr, IrInstruction value)
823	841	{
824		IrInstructionStorePtr *instruction = ir_build_instruction<IrInstructionStorePtr>(irb, source_node);
	842	IrInstructionStorePtr *instruction = ir_build_instruction<IrInstructionStorePtr>(irb, scope, source_node);
825	843	instruction->base.static_value.special = ConstValSpecialStatic;
826	844	instruction->base.type_entry = irb->codegen->builtin_types.entry_void;
827	845	instruction->ptr = ptr;
...	...	@@ -836,15 +854,16 @@ static IrInstruction ir_build_store_ptr(IrBuilder irb, AstNode *source_node,
836	854	static IrInstruction ir_build_store_ptr_from(IrBuilder irb, IrInstruction *old_instruction,
837	855	IrInstruction ptr, IrInstruction value)
838	856	{
839		IrInstruction *new_instruction = ir_build_store_ptr(irb, old_instruction->source_node, ptr, value);
	857	IrInstruction *new_instruction = ir_build_store_ptr(irb, old_instruction->scope,
	858	old_instruction->source_node, ptr, value);
840	859	ir_link_new_instruction(new_instruction, old_instruction);
841	860	return new_instruction;
842	861	}
843	862
844		static IrInstruction ir_build_var_decl(IrBuilder irb, AstNode *source_node,
	863	static IrInstruction ir_build_var_decl(IrBuilder irb, Scope scope, AstNode source_node,
845	864	VariableTableEntry var, IrInstruction var_type, IrInstruction *init_value)
846	865	{
847		IrInstructionDeclVar *decl_var_instruction = ir_build_instruction<IrInstructionDeclVar>(irb, source_node);
	866	IrInstructionDeclVar *decl_var_instruction = ir_build_instruction<IrInstructionDeclVar>(irb, scope, source_node);
848	867	decl_var_instruction->base.static_value.special = ConstValSpecialStatic;
849	868	decl_var_instruction->base.type_entry = irb->codegen->builtin_types.entry_void;
850	869	decl_var_instruction->var = var;
...	...	@@ -860,13 +879,14 @@ static IrInstruction ir_build_var_decl(IrBuilder irb, AstNode *source_node,
860	879	static IrInstruction ir_build_var_decl_from(IrBuilder irb, IrInstruction *old_instruction,
861	880	VariableTableEntry var, IrInstruction var_type, IrInstruction *init_value)
862	881	{
863		IrInstruction *new_instruction = ir_build_var_decl(irb, old_instruction->source_node, var, var_type, init_value);
	882	IrInstruction *new_instruction = ir_build_var_decl(irb, old_instruction->scope,
	883	old_instruction->source_node, var, var_type, init_value);
864	884	ir_link_new_instruction(new_instruction, old_instruction);
865	885	return new_instruction;
866	886	}
867	887
868		static IrInstruction ir_build_load_ptr(IrBuilder irb, AstNode source_node, IrInstruction ptr) {
869		IrInstructionLoadPtr *instruction = ir_build_instruction<IrInstructionLoadPtr>(irb, source_node);
	888	static IrInstruction ir_build_load_ptr(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *ptr) {
	889	IrInstructionLoadPtr *instruction = ir_build_instruction<IrInstructionLoadPtr>(irb, scope, source_node);
870	890	instruction->ptr = ptr;
871	891
872	892	ir_ref_instruction(ptr);
...	...	@@ -875,13 +895,14 @@ static IrInstruction ir_build_load_ptr(IrBuilder irb, AstNode *source_node, Ir
875	895	}
876	896
877	897	static IrInstruction ir_build_load_ptr_from(IrBuilder irb, IrInstruction old_instruction, IrInstruction ptr) {
878		IrInstruction *new_instruction = ir_build_load_ptr(irb, old_instruction->source_node, ptr);
	898	IrInstruction *new_instruction = ir_build_load_ptr(irb, old_instruction->scope,
	899	old_instruction->source_node, ptr);
879	900	ir_link_new_instruction(new_instruction, old_instruction);
880	901	return new_instruction;
881	902	}
882	903
883		static IrInstruction ir_build_typeof(IrBuilder irb, AstNode source_node, IrInstruction value) {
884		IrInstructionTypeOf *instruction = ir_build_instruction<IrInstructionTypeOf>(irb, source_node);
	904	static IrInstruction ir_build_typeof(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	905	IrInstructionTypeOf *instruction = ir_build_instruction<IrInstructionTypeOf>(irb, scope, source_node);
885	906	instruction->value = value;
886	907
887	908	ir_ref_instruction(value);
...	...	@@ -889,8 +910,8 @@ static IrInstruction ir_build_typeof(IrBuilder irb, AstNode *source_node, IrIn
889	910	return &instruction->base;
890	911	}
891	912
892		static IrInstruction ir_build_to_ptr_type(IrBuilder irb, AstNode source_node, IrInstruction value) {
893		IrInstructionToPtrType *instruction = ir_build_instruction<IrInstructionToPtrType>(irb, source_node);
	913	static IrInstruction ir_build_to_ptr_type(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	914	IrInstructionToPtrType *instruction = ir_build_instruction<IrInstructionToPtrType>(irb, scope, source_node);
894	915	instruction->value = value;
895	916
896	917	ir_ref_instruction(value);
...	...	@@ -898,8 +919,8 @@ static IrInstruction ir_build_to_ptr_type(IrBuilder irb, AstNode *source_node,
898	919	return &instruction->base;
899	920	}
900	921
901		static IrInstruction ir_build_ptr_type_child(IrBuilder irb, AstNode source_node, IrInstruction value) {
902		IrInstructionPtrTypeChild *instruction = ir_build_instruction<IrInstructionPtrTypeChild>(irb, source_node);
	922	static IrInstruction ir_build_ptr_type_child(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	923	IrInstructionPtrTypeChild *instruction = ir_build_instruction<IrInstructionPtrTypeChild>(irb, scope, source_node);
903	924	instruction->value = value;
904	925
905	926	ir_ref_instruction(value);
...	...	@@ -907,10 +928,10 @@ static IrInstruction ir_build_ptr_type_child(IrBuilder irb, AstNode *source_no
907	928	return &instruction->base;
908	929	}
909	930
910		static IrInstruction ir_build_set_fn_test(IrBuilder irb, AstNode source_node, IrInstruction fn_value,
	931	static IrInstruction ir_build_set_fn_test(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *fn_value,
911	932	IrInstruction *is_test)
912	933	{
913		IrInstructionSetFnTest *instruction = ir_build_instruction<IrInstructionSetFnTest>(irb, source_node);
	934	IrInstructionSetFnTest *instruction = ir_build_instruction<IrInstructionSetFnTest>(irb, scope, source_node);
914	935	instruction->fn_value = fn_value;
915	936	instruction->is_test = is_test;
916	937
...	...	@@ -920,10 +941,10 @@ static IrInstruction ir_build_set_fn_test(IrBuilder irb, AstNode *source_node,
920	941	return &instruction->base;
921	942	}
922	943
923		static IrInstruction ir_build_set_fn_visible(IrBuilder irb, AstNode source_node, IrInstruction fn_value,
	944	static IrInstruction ir_build_set_fn_visible(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *fn_value,
924	945	IrInstruction *is_visible)
925	946	{
926		IrInstructionSetFnVisible *instruction = ir_build_instruction<IrInstructionSetFnVisible>(irb, source_node);
	947	IrInstructionSetFnVisible *instruction = ir_build_instruction<IrInstructionSetFnVisible>(irb, scope, source_node);
927	948	instruction->fn_value = fn_value;
928	949	instruction->is_visible = is_visible;
929	950
...	...	@@ -933,10 +954,10 @@ static IrInstruction ir_build_set_fn_visible(IrBuilder irb, AstNode *source_no
933	954	return &instruction->base;
934	955	}
935	956
936		static IrInstruction ir_build_set_debug_safety(IrBuilder irb, AstNode *source_node,
	957	static IrInstruction ir_build_set_debug_safety(IrBuilder irb, Scope scope, AstNode source_node,
937	958	IrInstruction scope_value, IrInstruction debug_safety_on)
938	959	{
939		IrInstructionSetDebugSafety *instruction = ir_build_instruction<IrInstructionSetDebugSafety>(irb, source_node);
	960	IrInstructionSetDebugSafety *instruction = ir_build_instruction<IrInstructionSetDebugSafety>(irb, scope, source_node);
940	961	instruction->scope_value = scope_value;
941	962	instruction->debug_safety_on = debug_safety_on;
942	963
...	...	@@ -946,10 +967,10 @@ static IrInstruction ir_build_set_debug_safety(IrBuilder irb, AstNode *source_
946	967	return &instruction->base;
947	968	}
948	969
949		static IrInstruction ir_build_array_type(IrBuilder irb, AstNode source_node, IrInstruction size,
	970	static IrInstruction ir_build_array_type(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *size,
950	971	IrInstruction *child_type)
951	972	{
952		IrInstructionArrayType *instruction = ir_build_instruction<IrInstructionArrayType>(irb, source_node);
	973	IrInstructionArrayType *instruction = ir_build_instruction<IrInstructionArrayType>(irb, scope, source_node);
953	974	instruction->size = size;
954	975	instruction->child_type = child_type;
955	976
...	...	@@ -959,10 +980,10 @@ static IrInstruction ir_build_array_type(IrBuilder irb, AstNode *source_node,
959	980	return &instruction->base;
960	981	}
961	982
962		static IrInstruction ir_build_slice_type(IrBuilder irb, AstNode *source_node, bool is_const,
	983	static IrInstruction ir_build_slice_type(IrBuilder irb, Scope scope, AstNode source_node, bool is_const,
963	984	IrInstruction *child_type)
964	985	{
965		IrInstructionSliceType *instruction = ir_build_instruction<IrInstructionSliceType>(irb, source_node);
	986	IrInstructionSliceType *instruction = ir_build_instruction<IrInstructionSliceType>(irb, scope, source_node);
966	987	instruction->is_const = is_const;
967	988	instruction->child_type = child_type;
968	989
...	...	@@ -971,12 +992,13 @@ static IrInstruction ir_build_slice_type(IrBuilder irb, AstNode *source_node,
971	992	return &instruction->base;
972	993	}
973	994
974		static IrInstruction ir_build_asm(IrBuilder irb, AstNode source_node, IrInstruction *input_list,
975		IrInstruction **output_types, size_t return_count, bool has_side_effects)
	995	static IrInstruction ir_build_asm(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction **input_list,
	996	IrInstruction output_types, VariableTableEntry output_vars, size_t return_count, bool has_side_effects)
976	997	{
977		IrInstructionAsm *instruction = ir_build_instruction<IrInstructionAsm>(irb, source_node);
	998	IrInstructionAsm *instruction = ir_build_instruction<IrInstructionAsm>(irb, scope, source_node);
978	999	instruction->input_list = input_list;
979	1000	instruction->output_types = output_types;
	1001	instruction->output_vars = output_vars;
980	1002	instruction->return_count = return_count;
981	1003	instruction->has_side_effects = has_side_effects;
982	1004
...	...	@@ -995,16 +1017,16 @@ static IrInstruction ir_build_asm(IrBuilder irb, AstNode *source_node, IrInstr
995	1017	}
996	1018
997	1019	static IrInstruction ir_build_asm_from(IrBuilder irb, IrInstruction old_instruction, IrInstruction *input_list,
998		IrInstruction **output_types, size_t return_count, bool has_side_effects)
	1020	IrInstruction output_types, VariableTableEntry output_vars, size_t return_count, bool has_side_effects)
999	1021	{
1000		IrInstruction *new_instruction = ir_build_asm(irb, old_instruction->source_node, input_list, output_types,
1001		return_count, has_side_effects);
	1022	IrInstruction *new_instruction = ir_build_asm(irb, old_instruction->scope,
	1023	old_instruction->source_node, input_list, output_types, output_vars, return_count, has_side_effects);
1002	1024	ir_link_new_instruction(new_instruction, old_instruction);
1003	1025	return new_instruction;
1004	1026	}
1005	1027
1006		static IrInstruction ir_build_compile_var(IrBuilder irb, AstNode source_node, IrInstruction name) {
1007		IrInstructionCompileVar *instruction = ir_build_instruction<IrInstructionCompileVar>(irb, source_node);
	1028	static IrInstruction ir_build_compile_var(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *name) {
	1029	IrInstructionCompileVar *instruction = ir_build_instruction<IrInstructionCompileVar>(irb, scope, source_node);
1008	1030	instruction->name = name;
1009	1031
1010	1032	ir_ref_instruction(name);
...	...	@@ -1012,8 +1034,8 @@ static IrInstruction ir_build_compile_var(IrBuilder irb, AstNode *source_node,
1012	1034	return &instruction->base;
1013	1035	}
1014	1036
1015		static IrInstruction ir_build_size_of(IrBuilder irb, AstNode source_node, IrInstruction type_value) {
1016		IrInstructionSizeOf *instruction = ir_build_instruction<IrInstructionSizeOf>(irb, source_node);
	1037	static IrInstruction ir_build_size_of(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *type_value) {
	1038	IrInstructionSizeOf *instruction = ir_build_instruction<IrInstructionSizeOf>(irb, scope, source_node);
1017	1039	instruction->type_value = type_value;
1018	1040
1019	1041	ir_ref_instruction(type_value);
...	...	@@ -1021,8 +1043,8 @@ static IrInstruction ir_build_size_of(IrBuilder irb, AstNode *source_node, IrI
1021	1043	return &instruction->base;
1022	1044	}
1023	1045
1024		static IrInstruction ir_build_test_null(IrBuilder irb, AstNode source_node, IrInstruction value) {
1025		IrInstructionTestNull *instruction = ir_build_instruction<IrInstructionTestNull>(irb, source_node);
	1046	static IrInstruction ir_build_test_null(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	1047	IrInstructionTestNull *instruction = ir_build_instruction<IrInstructionTestNull>(irb, scope, source_node);
1026	1048	instruction->value = value;
1027	1049
1028	1050	ir_ref_instruction(value);
...	...	@@ -1033,15 +1055,16 @@ static IrInstruction ir_build_test_null(IrBuilder irb, AstNode *source_node, I
1033	1055	static IrInstruction ir_build_test_null_from(IrBuilder irb, IrInstruction *old_instruction,
1034	1056	IrInstruction *value)
1035	1057	{
1036		IrInstruction *new_instruction = ir_build_test_null(irb, old_instruction->source_node, value);
	1058	IrInstruction *new_instruction = ir_build_test_null(irb, old_instruction->scope,
	1059	old_instruction->source_node, value);
1037	1060	ir_link_new_instruction(new_instruction, old_instruction);
1038	1061	return new_instruction;
1039	1062	}
1040	1063
1041		static IrInstruction ir_build_unwrap_maybe(IrBuilder irb, AstNode source_node, IrInstruction value,
	1064	static IrInstruction ir_build_unwrap_maybe(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value,
1042	1065	bool safety_check_on)
1043	1066	{
1044		IrInstructionUnwrapMaybe *instruction = ir_build_instruction<IrInstructionUnwrapMaybe>(irb, source_node);
	1067	IrInstructionUnwrapMaybe *instruction = ir_build_instruction<IrInstructionUnwrapMaybe>(irb, scope, source_node);
1045	1068	instruction->value = value;
1046	1069	instruction->safety_check_on = safety_check_on;
1047	1070
...	...	@@ -1053,14 +1076,14 @@ static IrInstruction ir_build_unwrap_maybe(IrBuilder irb, AstNode *source_node
1053	1076	static IrInstruction ir_build_unwrap_maybe_from(IrBuilder irb, IrInstruction *old_instruction,
1054	1077	IrInstruction *value, bool safety_check_on)
1055	1078	{
1056		IrInstruction *new_instruction = ir_build_unwrap_maybe(irb, old_instruction->source_node,
	1079	IrInstruction *new_instruction = ir_build_unwrap_maybe(irb, old_instruction->scope, old_instruction->source_node,
1057	1080	value, safety_check_on);
1058	1081	ir_link_new_instruction(new_instruction, old_instruction);
1059	1082	return new_instruction;
1060	1083	}
1061	1084
1062		static IrInstruction ir_build_clz(IrBuilder irb, AstNode source_node, IrInstruction value) {
1063		IrInstructionClz *instruction = ir_build_instruction<IrInstructionClz>(irb, source_node);
	1085	static IrInstruction ir_build_clz(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	1086	IrInstructionClz *instruction = ir_build_instruction<IrInstructionClz>(irb, scope, source_node);
1064	1087	instruction->value = value;
1065	1088
1066	1089	ir_ref_instruction(value);
...	...	@@ -1069,13 +1092,13 @@ static IrInstruction ir_build_clz(IrBuilder irb, AstNode *source_node, IrInstr
1069	1092	}
1070	1093
1071	1094	static IrInstruction ir_build_clz_from(IrBuilder irb, IrInstruction old_instruction, IrInstruction value) {
1072		IrInstruction *new_instruction = ir_build_clz(irb, old_instruction->source_node, value);
	1095	IrInstruction *new_instruction = ir_build_clz(irb, old_instruction->scope, old_instruction->source_node, value);
1073	1096	ir_link_new_instruction(new_instruction, old_instruction);
1074	1097	return new_instruction;
1075	1098	}
1076	1099
1077		static IrInstruction ir_build_ctz(IrBuilder irb, AstNode source_node, IrInstruction value) {
1078		IrInstructionCtz *instruction = ir_build_instruction<IrInstructionCtz>(irb, source_node);
	1100	static IrInstruction ir_build_ctz(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	1101	IrInstructionCtz *instruction = ir_build_instruction<IrInstructionCtz>(irb, scope, source_node);
1079	1102	instruction->value = value;
1080	1103
1081	1104	ir_ref_instruction(value);
...	...	@@ -1084,15 +1107,15 @@ static IrInstruction ir_build_ctz(IrBuilder irb, AstNode *source_node, IrInstr
1084	1107	}
1085	1108
1086	1109	static IrInstruction ir_build_ctz_from(IrBuilder irb, IrInstruction old_instruction, IrInstruction value) {
1087		IrInstruction *new_instruction = ir_build_ctz(irb, old_instruction->source_node, value);
	1110	IrInstruction *new_instruction = ir_build_ctz(irb, old_instruction->scope, old_instruction->source_node, value);
1088	1111	ir_link_new_instruction(new_instruction, old_instruction);
1089	1112	return new_instruction;
1090	1113	}
1091	1114
1092		static IrInstruction ir_build_switch_br(IrBuilder irb, AstNode source_node, IrInstruction target_value,
	1115	static IrInstruction ir_build_switch_br(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *target_value,
1093	1116	IrBasicBlock else_block, size_t case_count, IrInstructionSwitchBrCase cases, bool is_inline)
1094	1117	{
1095		IrInstructionSwitchBr *instruction = ir_build_instruction<IrInstructionSwitchBr>(irb, source_node);
	1118	IrInstructionSwitchBr *instruction = ir_build_instruction<IrInstructionSwitchBr>(irb, scope, source_node);
1096	1119	instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
1097	1120	instruction->base.static_value.special = ConstValSpecialStatic;
1098	1121	instruction->target_value = target_value;
...	...	@@ -1116,16 +1139,16 @@ static IrInstruction ir_build_switch_br_from(IrBuilder irb, IrInstruction *old
1116	1139	IrInstruction target_value, IrBasicBlock else_block, size_t case_count,
1117	1140	IrInstructionSwitchBrCase *cases, bool is_inline)
1118	1141	{
1119		IrInstruction *new_instruction = ir_build_switch_br(irb, old_instruction->source_node,
	1142	IrInstruction *new_instruction = ir_build_switch_br(irb, old_instruction->scope, old_instruction->source_node,
1120	1143	target_value, else_block, case_count, cases, is_inline);
1121	1144	ir_link_new_instruction(new_instruction, old_instruction);
1122	1145	return new_instruction;
1123	1146	}
1124	1147
1125		static IrInstruction ir_build_switch_target(IrBuilder irb, AstNode *source_node,
	1148	static IrInstruction ir_build_switch_target(IrBuilder irb, Scope scope, AstNode source_node,
1126	1149	IrInstruction *target_value_ptr)
1127	1150	{
1128		IrInstructionSwitchTarget *instruction = ir_build_instruction<IrInstructionSwitchTarget>(irb, source_node);
	1151	IrInstructionSwitchTarget *instruction = ir_build_instruction<IrInstructionSwitchTarget>(irb, scope, source_node);
1129	1152	instruction->target_value_ptr = target_value_ptr;
1130	1153
1131	1154	ir_ref_instruction(target_value_ptr);
...	...	@@ -1133,10 +1156,10 @@ static IrInstruction ir_build_switch_target(IrBuilder irb, AstNode *source_nod
1133	1156	return &instruction->base;
1134	1157	}
1135	1158
1136		static IrInstruction ir_build_switch_var(IrBuilder irb, AstNode *source_node,
	1159	static IrInstruction ir_build_switch_var(IrBuilder irb, Scope scope, AstNode source_node,
1137	1160	IrInstruction target_value_ptr, IrInstruction prong_value)
1138	1161	{
1139		IrInstructionSwitchVar *instruction = ir_build_instruction<IrInstructionSwitchVar>(irb, source_node);
	1162	IrInstructionSwitchVar *instruction = ir_build_instruction<IrInstructionSwitchVar>(irb, scope, source_node);
1140	1163	instruction->target_value_ptr = target_value_ptr;
1141	1164	instruction->prong_value = prong_value;
1142	1165
...	...	@@ -1146,8 +1169,8 @@ static IrInstruction ir_build_switch_var(IrBuilder irb, AstNode *source_node,
1146	1169	return &instruction->base;
1147	1170	}
1148	1171
1149		static IrInstruction ir_build_enum_tag(IrBuilder irb, AstNode source_node, IrInstruction value) {
1150		IrInstructionEnumTag *instruction = ir_build_instruction<IrInstructionEnumTag>(irb, source_node);
	1172	static IrInstruction ir_build_enum_tag(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	1173	IrInstructionEnumTag *instruction = ir_build_instruction<IrInstructionEnumTag>(irb, scope, source_node);
1151	1174	instruction->value = value;
1152	1175
1153	1176	ir_ref_instruction(value);
...	...	@@ -1156,13 +1179,14 @@ static IrInstruction ir_build_enum_tag(IrBuilder irb, AstNode *source_node, Ir
1156	1179	}
1157	1180
1158	1181	static IrInstruction ir_build_enum_tag_from(IrBuilder irb, IrInstruction old_instruction, IrInstruction value) {
1159		IrInstruction *new_instruction = ir_build_enum_tag(irb, old_instruction->source_node, value);
	1182	IrInstruction *new_instruction = ir_build_enum_tag(irb, old_instruction->scope,
	1183	old_instruction->source_node, value);
1160	1184	ir_link_new_instruction(new_instruction, old_instruction);
1161	1185	return new_instruction;
1162	1186	}
1163	1187
1164		static IrInstruction ir_build_static_eval(IrBuilder irb, AstNode source_node, IrInstruction value) {
1165		IrInstructionStaticEval *instruction = ir_build_instruction<IrInstructionStaticEval>(irb, source_node);
	1188	static IrInstruction ir_build_static_eval(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	1189	IrInstructionStaticEval *instruction = ir_build_instruction<IrInstructionStaticEval>(irb, scope, source_node);
1166	1190	instruction->value = value;
1167	1191
1168	1192	ir_ref_instruction(value);
...	...	@@ -1170,8 +1194,8 @@ static IrInstruction ir_build_static_eval(IrBuilder irb, AstNode *source_node,
1170	1194	return &instruction->base;
1171	1195	}
1172	1196
1173		static IrInstruction ir_build_import(IrBuilder irb, AstNode source_node, IrInstruction name) {
1174		IrInstructionImport *instruction = ir_build_instruction<IrInstructionImport>(irb, source_node);
	1197	static IrInstruction ir_build_import(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *name) {
	1198	IrInstructionImport *instruction = ir_build_instruction<IrInstructionImport>(irb, scope, source_node);
1175	1199	instruction->name = name;
1176	1200
1177	1201	ir_ref_instruction(name);
...	...	@@ -1179,8 +1203,8 @@ static IrInstruction ir_build_import(IrBuilder irb, AstNode *source_node, IrIn
1179	1203	return &instruction->base;
1180	1204	}
1181	1205
1182		static IrInstruction ir_build_array_len(IrBuilder irb, AstNode source_node, IrInstruction array_value) {
1183		IrInstructionArrayLen *instruction = ir_build_instruction<IrInstructionArrayLen>(irb, source_node);
	1206	static IrInstruction ir_build_array_len(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *array_value) {
	1207	IrInstructionArrayLen *instruction = ir_build_instruction<IrInstructionArrayLen>(irb, scope, source_node);
1184	1208	instruction->array_value = array_value;
1185	1209
1186	1210	ir_ref_instruction(array_value);
...	...	@@ -1191,13 +1215,14 @@ static IrInstruction ir_build_array_len(IrBuilder irb, AstNode *source_node, I
1191	1215	static IrInstruction ir_build_array_len_from(IrBuilder irb, IrInstruction *old_instruction,
1192	1216	IrInstruction *array_value)
1193	1217	{
1194		IrInstruction *new_instruction = ir_build_array_len(irb, old_instruction->source_node, array_value);
	1218	IrInstruction *new_instruction = ir_build_array_len(irb, old_instruction->scope,
	1219	old_instruction->source_node, array_value);
1195	1220	ir_link_new_instruction(new_instruction, old_instruction);
1196	1221	return new_instruction;
1197	1222	}
1198	1223
1199		static IrInstruction ir_build_ref(IrBuilder irb, AstNode source_node, IrInstruction value) {
1200		IrInstructionRef *instruction = ir_build_instruction<IrInstructionRef>(irb, source_node);
	1224	static IrInstruction ir_build_ref(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
	1225	IrInstructionRef *instruction = ir_build_instruction<IrInstructionRef>(irb, scope, source_node);
1201	1226	instruction->value = value;
1202	1227
1203	1228	ir_ref_instruction(value);
...	...	@@ -1206,12 +1231,12 @@ static IrInstruction ir_build_ref(IrBuilder irb, AstNode *source_node, IrInstr
1206	1231	}
1207	1232
1208	1233	static IrInstruction ir_build_ref_from(IrBuilder irb, IrInstruction old_instruction, IrInstruction value) {
1209		IrInstruction *new_instruction = ir_build_ref(irb, old_instruction->source_node, value);
	1234	IrInstruction *new_instruction = ir_build_ref(irb, old_instruction->scope, old_instruction->source_node, value);
1210	1235	ir_link_new_instruction(new_instruction, old_instruction);
1211	1236	return new_instruction;
1212	1237	}
1213	1238
1214		static void ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *outer_scope,
	1239	static void ir_gen_defers_for_block(IrBuilder irb, Scope parent_scope, Scope inner_scope, Scope outer_scope,
1215	1240	bool gen_error_defers, bool gen_maybe_defers)
1216	1241	{
1217	1242	while (inner_scope != outer_scope) {
...	...	@@ -1221,29 +1246,16 @@ static void ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *o
1221	1246	(gen_maybe_defers && inner_scope->node->data.defer.kind == ReturnKindMaybe)))
1222	1247	{
1223	1248	AstNode *defer_expr_node = inner_scope->node->data.defer.expr;
1224		ir_gen_node(irb, defer_expr_node, defer_expr_node->scope);
	1249	ir_gen_node(irb, defer_expr_node, parent_scope);
1225	1250	}
1226	1251	inner_scope = inner_scope->parent;
1227	1252	}
1228	1253	}
1229	1254
1230		static FnTableEntry scope_fn_entry(Scope scope) {
1231		while (scope) {
1232		if (scope->node->type == NodeTypeFnDef) {
1233		ScopeFnBody fn_scope = (ScopeFnBody )scope;
1234		return fn_scope->fn_entry;
1235		}
1236		scope = scope->parent;
1237		}
1238		return nullptr;
1239		}
1240
1241		static IrInstruction ir_gen_return(IrBuilder irb, AstNode *node) {
	1255	static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node) {
1242	1256	assert(node->type == NodeTypeReturnExpr);
1243	1257
1244		Scope *scope = node->scope;
1245
1246		if (!scope_fn_entry(scope)) {
	1258	if (!exec_fn_entry(irb->exec)) {
1247	1259	add_node_error(irb->codegen, node, buf_sprintf("return expression outside function definition"));
1248	1260	return irb->codegen->invalid_instruction;
1249	1261	}
...	...	@@ -1254,12 +1266,12 @@ static IrInstruction ir_gen_return(IrBuilder irb, AstNode *node) {
1254	1266	{
1255	1267	IrInstruction *return_value;
1256	1268	if (expr_node) {
1257		return_value = ir_gen_node(irb, expr_node, node->scope);
	1269	return_value = ir_gen_node(irb, expr_node, scope);
1258	1270	} else {
1259		return_value = ir_build_const_void(irb, node);
	1271	return_value = ir_build_const_void(irb, scope, node);
1260	1272	}
1261	1273
1262		return ir_build_return(irb, node, return_value);
	1274	return ir_build_return(irb, scope, node, return_value);
1263	1275	}
1264	1276	case ReturnKindError:
1265	1277	zig_panic("TODO gen IR for %%return");
...	...	@@ -1275,15 +1287,15 @@ static void ir_set_cursor_at_end(IrBuilder irb, IrBasicBlock basic_block) {
1275	1287	irb->current_basic_block = basic_block;
1276	1288	}
1277	1289
1278		static VariableTableEntry add_local_var(CodeGen codegen, AstNode node, Scope parent_scope,
	1290	static VariableTableEntry create_local_var(CodeGen codegen, AstNode node, Scope parent_scope,
1279	1291	Buf *name, bool src_is_const, bool gen_is_const, bool is_shadowable, bool is_inline)
1280	1292	{
1281	1293	VariableTableEntry *variable_entry = allocate<VariableTableEntry>(1);
1282	1294	variable_entry->parent_scope = parent_scope;
1283		variable_entry->import = node->owner;
1284	1295	variable_entry->shadowable = is_shadowable;
1285	1296	variable_entry->mem_slot_index = SIZE_MAX;
1286	1297	variable_entry->is_inline = is_inline;
	1298	variable_entry->src_arg_index = SIZE_MAX;
1287	1299
1288	1300	if (name) {
1289	1301	buf_init_from_buf(&variable_entry->name, name);
...	...	@@ -1302,11 +1314,11 @@ static VariableTableEntry add_local_var(CodeGen codegen, AstNode *node, Scope
1302	1314	buf_sprintf("variable shadows type '%s'", buf_ptr(&type->name)));
1303	1315	variable_entry->type = codegen->builtin_types.entry_invalid;
1304	1316	} else {
1305		AstNode *decl_node = find_decl(parent_scope, name);
1306		if (decl_node && decl_node->type != NodeTypeVariableDeclaration) {
	1317	Tld *tld = find_decl(parent_scope, name);
	1318	if (tld && tld->id != TldIdVar) {
1307	1319	ErrorMsg *msg = add_node_error(codegen, node,
1308	1320	buf_sprintf("redefinition of '%s'", buf_ptr(name)));
1309		add_error_note(codegen, msg, decl_node, buf_sprintf("previous definition is here"));
	1321	add_error_note(codegen, msg, tld->source_node, buf_sprintf("previous definition is here"));
1310	1322	variable_entry->type = codegen->builtin_types.entry_invalid;
1311	1323	}
1312	1324	}
...	...	@@ -1333,7 +1345,7 @@ static VariableTableEntry add_local_var(CodeGen codegen, AstNode *node, Scope
1333	1345	static VariableTableEntry ir_create_var(IrBuilder irb, AstNode node, Scope scope, Buf *name,
1334	1346	bool src_is_const, bool gen_is_const, bool is_shadowable, bool is_inline)
1335	1347	{
1336		VariableTableEntry *var = add_local_var(irb->codegen, node, scope, name,
	1348	VariableTableEntry *var = create_local_var(irb->codegen, node, scope, name,
1337	1349	src_is_const, gen_is_const, is_shadowable, is_inline);
1338	1350	if (is_inline \|\| gen_is_const)
1339	1351	var->mem_slot_index = exec_next_mem_slot(irb->exec);
...	...	@@ -1341,10 +1353,9 @@ static VariableTableEntry ir_create_var(IrBuilder irb, AstNode node, Scope s
1341	1353	return var;
1342	1354	}
1343	1355
1344		static IrInstruction ir_gen_block(IrBuilder irb, AstNode *block_node) {
	1356	static IrInstruction ir_gen_block(IrBuilder irb, Scope parent_scope, AstNode block_node) {
1345	1357	assert(block_node->type == NodeTypeBlock);
1346	1358
1347		Scope *parent_scope = block_node->scope;
1348	1359	Scope *outer_block_scope = create_block_scope(block_node, parent_scope);
1349	1360	Scope *child_scope = outer_block_scope;
1350	1361
...	...	@@ -1353,56 +1364,57 @@ static IrInstruction ir_gen_block(IrBuilder irb, AstNode *block_node) {
1353	1364	AstNode *statement_node = block_node->data.block.statements.at(i);
1354	1365	return_value = ir_gen_node(irb, statement_node, child_scope);
1355	1366	if (statement_node->type == NodeTypeDefer && return_value != irb->codegen->invalid_instruction) {
1356		// defer starts a new block context
1357		child_scope = statement_node->data.defer.child_block;
	1367	// defer starts a new scope
	1368	child_scope = statement_node->data.defer.child_scope;
1358	1369	assert(child_scope);
1359	1370	} else if (return_value->id == IrInstructionIdDeclVar) {
	1371	// variable declarations start a new scope
1360	1372	IrInstructionDeclVar decl_var_instruction = (IrInstructionDeclVar )return_value;
1361	1373	child_scope = decl_var_instruction->var->child_scope;
1362	1374	}
1363	1375	}
1364	1376
1365	1377	if (!return_value)
1366		return_value = ir_build_const_void(irb, block_node);
	1378	return_value = ir_build_const_void(irb, child_scope, block_node);
1367	1379
1368		ir_gen_defers_for_block(irb, child_scope, outer_block_scope, false, false);
	1380	ir_gen_defers_for_block(irb, parent_scope, child_scope, outer_block_scope, false, false);
1369	1381
1370	1382	return return_value;
1371	1383	}
1372	1384
1373		static IrInstruction ir_gen_bin_op_id(IrBuilder irb, AstNode *node, IrBinOp op_id) {
1374		IrInstruction *op1 = ir_gen_node(irb, node->data.bin_op_expr.op1, node->scope);
1375		IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, node->scope);
1376		return ir_build_bin_op(irb, node, op_id, op1, op2);
	1385	static IrInstruction ir_gen_bin_op_id(IrBuilder irb, Scope scope, AstNode node, IrBinOp op_id) {
	1386	IrInstruction *op1 = ir_gen_node(irb, node->data.bin_op_expr.op1, scope);
	1387	IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
	1388	return ir_build_bin_op(irb, scope, node, op_id, op1, op2);
1377	1389	}
1378	1390
1379		static IrInstruction ir_gen_assign(IrBuilder irb, AstNode *node) {
1380		IrInstruction *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, node->scope, LValPurposeAssign);
	1391	static IrInstruction ir_gen_assign(IrBuilder irb, Scope scope, AstNode node) {
	1392	IrInstruction *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPurposeAssign);
1381	1393	if (lvalue == irb->codegen->invalid_instruction)
1382	1394	return lvalue;
1383	1395
1384		IrInstruction *rvalue = ir_gen_node(irb, node->data.bin_op_expr.op2, node->scope);
	1396	IrInstruction *rvalue = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
1385	1397	if (rvalue == irb->codegen->invalid_instruction)
1386	1398	return rvalue;
1387	1399
1388		ir_build_store_ptr(irb, node, lvalue, rvalue);
1389		return ir_build_const_void(irb, node);
	1400	ir_build_store_ptr(irb, scope, node, lvalue, rvalue);
	1401	return ir_build_const_void(irb, scope, node);
1390	1402	}
1391	1403
1392		static IrInstruction ir_gen_assign_op(IrBuilder irb, AstNode *node, IrBinOp op_id) {
1393		IrInstruction *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, node->scope, LValPurposeAssign);
	1404	static IrInstruction ir_gen_assign_op(IrBuilder irb, Scope scope, AstNode node, IrBinOp op_id) {
	1405	IrInstruction *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPurposeAssign);
1394	1406	if (lvalue == irb->codegen->invalid_instruction)
1395	1407	return lvalue;
1396		IrInstruction *op1 = ir_build_load_ptr(irb, node->data.bin_op_expr.op1, lvalue);
1397		IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, node->scope);
	1408	IrInstruction *op1 = ir_build_load_ptr(irb, scope, node->data.bin_op_expr.op1, lvalue);
	1409	IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
1398	1410	if (op2 == irb->codegen->invalid_instruction)
1399	1411	return op2;
1400		IrInstruction *result = ir_build_bin_op(irb, node, op_id, op1, op2);
1401		ir_build_store_ptr(irb, node, lvalue, result);
1402		return ir_build_const_void(irb, node);
	1412	IrInstruction *result = ir_build_bin_op(irb, scope, node, op_id, op1, op2);
	1413	ir_build_store_ptr(irb, scope, node, lvalue, result);
	1414	return ir_build_const_void(irb, scope, node);
1403	1415	}
1404	1416
1405		static IrInstruction ir_gen_bin_op(IrBuilder irb, AstNode *node) {
	1417	static IrInstruction ir_gen_bin_op(IrBuilder irb, Scope scope, AstNode node) {
1406	1418	assert(node->type == NodeTypeBinOpExpr);
1407	1419
1408	1420	BinOpType bin_op_type = node->data.bin_op_expr.bin_op;
...	...	@@ -1410,95 +1422,95 @@ static IrInstruction ir_gen_bin_op(IrBuilder irb, AstNode *node) {
1410	1422	case BinOpTypeInvalid:
1411	1423	zig_unreachable();
1412	1424	case BinOpTypeAssign:
1413		return ir_gen_assign(irb, node);
	1425	return ir_gen_assign(irb, scope, node);
1414	1426	case BinOpTypeAssignTimes:
1415		return ir_gen_assign_op(irb, node, IrBinOpMult);
	1427	return ir_gen_assign_op(irb, scope, node, IrBinOpMult);
1416	1428	case BinOpTypeAssignTimesWrap:
1417		return ir_gen_assign_op(irb, node, IrBinOpMultWrap);
	1429	return ir_gen_assign_op(irb, scope, node, IrBinOpMultWrap);
1418	1430	case BinOpTypeAssignDiv:
1419		return ir_gen_assign_op(irb, node, IrBinOpDiv);
	1431	return ir_gen_assign_op(irb, scope, node, IrBinOpDiv);
1420	1432	case BinOpTypeAssignMod:
1421		return ir_gen_assign_op(irb, node, IrBinOpMod);
	1433	return ir_gen_assign_op(irb, scope, node, IrBinOpMod);
1422	1434	case BinOpTypeAssignPlus:
1423		return ir_gen_assign_op(irb, node, IrBinOpAdd);
	1435	return ir_gen_assign_op(irb, scope, node, IrBinOpAdd);
1424	1436	case BinOpTypeAssignPlusWrap:
1425		return ir_gen_assign_op(irb, node, IrBinOpAddWrap);
	1437	return ir_gen_assign_op(irb, scope, node, IrBinOpAddWrap);
1426	1438	case BinOpTypeAssignMinus:
1427		return ir_gen_assign_op(irb, node, IrBinOpSub);
	1439	return ir_gen_assign_op(irb, scope, node, IrBinOpSub);
1428	1440	case BinOpTypeAssignMinusWrap:
1429		return ir_gen_assign_op(irb, node, IrBinOpSubWrap);
	1441	return ir_gen_assign_op(irb, scope, node, IrBinOpSubWrap);
1430	1442	case BinOpTypeAssignBitShiftLeft:
1431		return ir_gen_assign_op(irb, node, IrBinOpBitShiftLeft);
	1443	return ir_gen_assign_op(irb, scope, node, IrBinOpBitShiftLeft);
1432	1444	case BinOpTypeAssignBitShiftLeftWrap:
1433		return ir_gen_assign_op(irb, node, IrBinOpBitShiftLeftWrap);
	1445	return ir_gen_assign_op(irb, scope, node, IrBinOpBitShiftLeftWrap);
1434	1446	case BinOpTypeAssignBitShiftRight:
1435		return ir_gen_assign_op(irb, node, IrBinOpBitShiftRight);
	1447	return ir_gen_assign_op(irb, scope, node, IrBinOpBitShiftRight);
1436	1448	case BinOpTypeAssignBitAnd:
1437		return ir_gen_assign_op(irb, node, IrBinOpBinAnd);
	1449	return ir_gen_assign_op(irb, scope, node, IrBinOpBinAnd);
1438	1450	case BinOpTypeAssignBitXor:
1439		return ir_gen_assign_op(irb, node, IrBinOpBinXor);
	1451	return ir_gen_assign_op(irb, scope, node, IrBinOpBinXor);
1440	1452	case BinOpTypeAssignBitOr:
1441		return ir_gen_assign_op(irb, node, IrBinOpBinOr);
	1453	return ir_gen_assign_op(irb, scope, node, IrBinOpBinOr);
1442	1454	case BinOpTypeAssignBoolAnd:
1443		return ir_gen_assign_op(irb, node, IrBinOpBoolAnd);
	1455	return ir_gen_assign_op(irb, scope, node, IrBinOpBoolAnd);
1444	1456	case BinOpTypeAssignBoolOr:
1445		return ir_gen_assign_op(irb, node, IrBinOpBoolOr);
	1457	return ir_gen_assign_op(irb, scope, node, IrBinOpBoolOr);
1446	1458	case BinOpTypeBoolOr:
1447	1459	case BinOpTypeBoolAnd:
1448	1460	// note: this is not a direct mapping to IrBinOpBoolOr/And
1449	1461	// because of the control flow
1450	1462	zig_panic("TODO gen IR for bool or/and");
1451	1463	case BinOpTypeCmpEq:
1452		return ir_gen_bin_op_id(irb, node, IrBinOpCmpEq);
	1464	return ir_gen_bin_op_id(irb, scope, node, IrBinOpCmpEq);
1453	1465	case BinOpTypeCmpNotEq:
1454		return ir_gen_bin_op_id(irb, node, IrBinOpCmpNotEq);
	1466	return ir_gen_bin_op_id(irb, scope, node, IrBinOpCmpNotEq);
1455	1467	case BinOpTypeCmpLessThan:
1456		return ir_gen_bin_op_id(irb, node, IrBinOpCmpLessThan);
	1468	return ir_gen_bin_op_id(irb, scope, node, IrBinOpCmpLessThan);
1457	1469	case BinOpTypeCmpGreaterThan:
1458		return ir_gen_bin_op_id(irb, node, IrBinOpCmpGreaterThan);
	1470	return ir_gen_bin_op_id(irb, scope, node, IrBinOpCmpGreaterThan);
1459	1471	case BinOpTypeCmpLessOrEq:
1460		return ir_gen_bin_op_id(irb, node, IrBinOpCmpLessOrEq);
	1472	return ir_gen_bin_op_id(irb, scope, node, IrBinOpCmpLessOrEq);
1461	1473	case BinOpTypeCmpGreaterOrEq:
1462		return ir_gen_bin_op_id(irb, node, IrBinOpCmpGreaterOrEq);
	1474	return ir_gen_bin_op_id(irb, scope, node, IrBinOpCmpGreaterOrEq);
1463	1475	case BinOpTypeBinOr:
1464		return ir_gen_bin_op_id(irb, node, IrBinOpBinOr);
	1476	return ir_gen_bin_op_id(irb, scope, node, IrBinOpBinOr);
1465	1477	case BinOpTypeBinXor:
1466		return ir_gen_bin_op_id(irb, node, IrBinOpBinXor);
	1478	return ir_gen_bin_op_id(irb, scope, node, IrBinOpBinXor);
1467	1479	case BinOpTypeBinAnd:
1468		return ir_gen_bin_op_id(irb, node, IrBinOpBinAnd);
	1480	return ir_gen_bin_op_id(irb, scope, node, IrBinOpBinAnd);
1469	1481	case BinOpTypeBitShiftLeft:
1470		return ir_gen_bin_op_id(irb, node, IrBinOpBitShiftLeft);
	1482	return ir_gen_bin_op_id(irb, scope, node, IrBinOpBitShiftLeft);
1471	1483	case BinOpTypeBitShiftLeftWrap:
1472		return ir_gen_bin_op_id(irb, node, IrBinOpBitShiftLeftWrap);
	1484	return ir_gen_bin_op_id(irb, scope, node, IrBinOpBitShiftLeftWrap);
1473	1485	case BinOpTypeBitShiftRight:
1474		return ir_gen_bin_op_id(irb, node, IrBinOpBitShiftRight);
	1486	return ir_gen_bin_op_id(irb, scope, node, IrBinOpBitShiftRight);
1475	1487	case BinOpTypeAdd:
1476		return ir_gen_bin_op_id(irb, node, IrBinOpAdd);
	1488	return ir_gen_bin_op_id(irb, scope, node, IrBinOpAdd);
1477	1489	case BinOpTypeAddWrap:
1478		return ir_gen_bin_op_id(irb, node, IrBinOpAddWrap);
	1490	return ir_gen_bin_op_id(irb, scope, node, IrBinOpAddWrap);
1479	1491	case BinOpTypeSub:
1480		return ir_gen_bin_op_id(irb, node, IrBinOpSub);
	1492	return ir_gen_bin_op_id(irb, scope, node, IrBinOpSub);
1481	1493	case BinOpTypeSubWrap:
1482		return ir_gen_bin_op_id(irb, node, IrBinOpSubWrap);
	1494	return ir_gen_bin_op_id(irb, scope, node, IrBinOpSubWrap);
1483	1495	case BinOpTypeMult:
1484		return ir_gen_bin_op_id(irb, node, IrBinOpMult);
	1496	return ir_gen_bin_op_id(irb, scope, node, IrBinOpMult);
1485	1497	case BinOpTypeMultWrap:
1486		return ir_gen_bin_op_id(irb, node, IrBinOpMultWrap);
	1498	return ir_gen_bin_op_id(irb, scope, node, IrBinOpMultWrap);
1487	1499	case BinOpTypeDiv:
1488		return ir_gen_bin_op_id(irb, node, IrBinOpDiv);
	1500	return ir_gen_bin_op_id(irb, scope, node, IrBinOpDiv);
1489	1501	case BinOpTypeMod:
1490		return ir_gen_bin_op_id(irb, node, IrBinOpMod);
	1502	return ir_gen_bin_op_id(irb, scope, node, IrBinOpMod);
1491	1503	case BinOpTypeArrayCat:
1492		return ir_gen_bin_op_id(irb, node, IrBinOpArrayCat);
	1504	return ir_gen_bin_op_id(irb, scope, node, IrBinOpArrayCat);
1493	1505	case BinOpTypeArrayMult:
1494		return ir_gen_bin_op_id(irb, node, IrBinOpArrayMult);
	1506	return ir_gen_bin_op_id(irb, scope, node, IrBinOpArrayMult);
1495	1507	case BinOpTypeUnwrapMaybe:
1496	1508	zig_panic("TODO gen IR for unwrap maybe binary operation");
1497	1509	}
1498	1510	zig_unreachable();
1499	1511	}
1500	1512
1501		static IrInstruction ir_gen_num_lit(IrBuilder irb, AstNode *node) {
	1513	static IrInstruction ir_gen_num_lit(IrBuilder irb, Scope scope, AstNode node) {
1502	1514	assert(node->type == NodeTypeNumberLiteral);
1503	1515
1504	1516	if (node->data.number_literal.overflow) {
...	...	@@ -1506,95 +1518,95 @@ static IrInstruction ir_gen_num_lit(IrBuilder irb, AstNode *node) {
1506	1518	return irb->codegen->invalid_instruction;
1507	1519	}
1508	1520
1509		return ir_build_const_bignum(irb, node, node->data.number_literal.bignum);
	1521	return ir_build_const_bignum(irb, scope, node, node->data.number_literal.bignum);
1510	1522	}
1511	1523
1512		static IrInstruction ir_gen_null_literal(IrBuilder irb, AstNode *node) {
	1524	static IrInstruction ir_gen_null_literal(IrBuilder irb, Scope scope, AstNode node) {
1513	1525	assert(node->type == NodeTypeNullLiteral);
1514	1526
1515		return ir_build_const_null(irb, node);
	1527	return ir_build_const_null(irb, scope, node);
1516	1528	}
1517	1529
1518		static IrInstruction ir_gen_decl_ref(IrBuilder irb, AstNode source_node, AstNode decl_node,
	1530	static IrInstruction ir_gen_decl_ref(IrBuilder irb, AstNode source_node, Tld tld,
1519	1531	LValPurpose lval, Scope *scope)
1520	1532	{
1521		resolve_top_level_decl(irb->codegen, decl_node, lval != LValPurposeNone);
1522		TopLevelDecl *tld = get_as_top_level_decl(decl_node);
	1533	resolve_top_level_decl(irb->codegen, tld, lval != LValPurposeNone);
1523	1534	if (tld->resolution == TldResolutionInvalid)
1524	1535	return irb->codegen->invalid_instruction;
1525	1536
1526		if (decl_node->type == NodeTypeVariableDeclaration) {
1527		VariableTableEntry *var = decl_node->data.variable_declaration.variable;
1528		IrInstruction *var_ptr = ir_build_var_ptr(irb, source_node, var);
1529		if (lval != LValPurposeNone)
1530		return var_ptr;
1531		else
1532		return ir_build_load_ptr(irb, source_node, var_ptr);
1533		} else if (decl_node->type == NodeTypeFnProto) {
1534		FnTableEntry *fn_entry = decl_node->data.fn_proto.fn_table_entry;
1535		assert(fn_entry->type_entry);
1536		IrInstruction *ref_instruction;
1537		if (fn_entry->type_entry->id == TypeTableEntryIdGenericFn) {
1538		ref_instruction = ir_build_const_generic_fn(irb, source_node, fn_entry->type_entry);
1539		} else {
1540		ref_instruction = ir_build_const_fn(irb, source_node, fn_entry);
	1537	switch (tld->id) {
	1538	case TldIdVar:
	1539	{
	1540	TldVar tld_var = (TldVar )tld;
	1541	VariableTableEntry *var = tld_var->var;
	1542	IrInstruction *var_ptr = ir_build_var_ptr(irb, scope, source_node, var);
	1543	if (lval != LValPurposeNone)
	1544	return var_ptr;
	1545	else
	1546	return ir_build_load_ptr(irb, scope, source_node, var_ptr);
1541	1547	}
1542		if (lval != LValPurposeNone)
1543		return ir_build_ref(irb, source_node, ref_instruction);
1544		else
1545		return ref_instruction;
1546		} else if (decl_node->type == NodeTypeContainerDecl) {
1547		IrInstruction *ref_instruction;
1548		if (decl_node->data.struct_decl.generic_params.length > 0) {
1549		TypeTableEntry *type_entry = decl_node->data.struct_decl.generic_fn_type;
1550		assert(type_entry);
1551		ref_instruction = ir_build_const_generic_fn(irb, source_node, type_entry);
1552		} else {
1553		ref_instruction = ir_build_const_type(irb, source_node, decl_node->data.struct_decl.type_entry);
	1548	case TldIdFn:
	1549	{
	1550	TldFn tld_fn = (TldFn )tld;
	1551	FnTableEntry *fn_entry = tld_fn->fn_entry;
	1552	assert(fn_entry->type_entry);
	1553	IrInstruction *ref_instruction = ir_build_const_fn(irb, scope, source_node, fn_entry);
	1554	if (lval != LValPurposeNone)
	1555	return ir_build_ref(irb, scope, source_node, ref_instruction);
	1556	else
	1557	return ref_instruction;
	1558	}
	1559	case TldIdContainer:
	1560	{
	1561	TldContainer tld_container = (TldContainer )tld;
	1562
	1563	IrInstruction *ref_instruction = ir_build_const_type(irb, scope, source_node, tld_container->type_entry);
	1564	if (lval != LValPurposeNone)
	1565	return ir_build_ref(irb, scope, source_node, ref_instruction);
	1566	else
	1567	return ref_instruction;
	1568	}
	1569	case TldIdTypeDef:
	1570	{
	1571	TldTypeDef tld_typedef = (TldTypeDef )tld;
	1572	TypeTableEntry *typedef_type = tld_typedef->type_entry;
	1573	IrInstruction *ref_instruction = ir_build_const_type(irb, scope, source_node, typedef_type);
	1574	if (lval != LValPurposeNone)
	1575	return ir_build_ref(irb, scope, source_node, ref_instruction);
	1576	else
	1577	return ref_instruction;
1554	1578	}
1555		if (lval != LValPurposeNone)
1556		return ir_build_ref(irb, source_node, ref_instruction);
1557		else
1558		return ref_instruction;
1559		} else if (decl_node->type == NodeTypeTypeDecl) {
1560		TypeTableEntry *child_type = decl_node->data.type_decl.child_type_entry;
1561		IrInstruction *ref_instruction = ir_build_const_type(irb, source_node, child_type);
1562		if (lval != LValPurposeNone)
1563		return ir_build_ref(irb, source_node, ref_instruction);
1564		else
1565		return ref_instruction;
1566		} else {
1567		zig_unreachable();
1568	1579	}
	1580	zig_unreachable();
1569	1581	}
1570	1582
1571		static IrInstruction ir_gen_symbol(IrBuilder irb, AstNode *node, LValPurpose lval) {
	1583	static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node, LValPurpose lval) {
1572	1584	assert(node->type == NodeTypeSymbol);
1573	1585
1574	1586	Buf *variable_name = node->data.symbol_expr.symbol;
1575	1587
1576	1588	auto primitive_table_entry = irb->codegen->primitive_type_table.maybe_get(variable_name);
1577	1589	if (primitive_table_entry) {
1578		IrInstruction *value = ir_build_const_type(irb, node, primitive_table_entry->value);
	1590	IrInstruction *value = ir_build_const_type(irb, scope, node, primitive_table_entry->value);
1579	1591	if (lval == LValPurposeAddressOf) {
1580		return ir_build_un_op(irb, node, IrUnOpAddressOf, value);
	1592	return ir_build_un_op(irb, scope, node, IrUnOpAddressOf, value);
1581	1593	} else {
1582	1594	return value;
1583	1595	}
1584	1596	}
1585	1597
1586		VariableTableEntry *var = find_variable(irb->codegen, node->scope, variable_name);
	1598	VariableTableEntry *var = find_variable(irb->codegen, scope, variable_name);
1587	1599	if (var) {
1588		IrInstruction *var_ptr = ir_build_var_ptr(irb, node, var);
	1600	IrInstruction *var_ptr = ir_build_var_ptr(irb, scope, node, var);
1589	1601	if (lval != LValPurposeNone)
1590	1602	return var_ptr;
1591	1603	else
1592		return ir_build_load_ptr(irb, node, var_ptr);
	1604	return ir_build_load_ptr(irb, scope, node, var_ptr);
1593	1605	}
1594	1606
1595		AstNode *decl_node = find_decl(node->scope, variable_name);
1596		if (decl_node)
1597		return ir_gen_decl_ref(irb, node, decl_node, lval, node->scope);
	1607	Tld *tld = find_decl(scope, variable_name);
	1608	if (tld)
	1609	return ir_gen_decl_ref(irb, node, tld, lval, scope);
1598	1610
1599	1611	if (node->owner->any_imports_failed) {
1600	1612	// skip the error message since we had a failing import in this file
...	...	@@ -1606,47 +1618,47 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, AstNode *node, LValPurpose l
1606	1618	return irb->codegen->invalid_instruction;
1607	1619	}
1608	1620
1609		static IrInstruction ir_gen_array_access(IrBuilder irb, AstNode *node, LValPurpose lval) {
	1621	static IrInstruction ir_gen_array_access(IrBuilder irb, Scope scope, AstNode node, LValPurpose lval) {
1610	1622	assert(node->type == NodeTypeArrayAccessExpr);
1611	1623
1612	1624	AstNode *array_ref_node = node->data.array_access_expr.array_ref_expr;
1613		IrInstruction *array_ref_instruction = ir_gen_node_extra(irb, array_ref_node, node->scope,
	1625	IrInstruction *array_ref_instruction = ir_gen_node_extra(irb, array_ref_node, scope,
1614	1626	LValPurposeAddressOf);
1615	1627	if (array_ref_instruction == irb->codegen->invalid_instruction)
1616	1628	return array_ref_instruction;
1617	1629
1618	1630	AstNode *subscript_node = node->data.array_access_expr.subscript;
1619		IrInstruction *subscript_instruction = ir_gen_node(irb, subscript_node, node->scope);
	1631	IrInstruction *subscript_instruction = ir_gen_node(irb, subscript_node, scope);
1620	1632	if (subscript_instruction == irb->codegen->invalid_instruction)
1621	1633	return subscript_instruction;
1622	1634
1623		IrInstruction *ptr_instruction = ir_build_elem_ptr(irb, node, array_ref_instruction,
	1635	IrInstruction *ptr_instruction = ir_build_elem_ptr(irb, scope, node, array_ref_instruction,
1624	1636	subscript_instruction, true);
1625	1637	if (lval != LValPurposeNone)
1626	1638	return ptr_instruction;
1627	1639
1628		return ir_build_load_ptr(irb, node, ptr_instruction);
	1640	return ir_build_load_ptr(irb, scope, node, ptr_instruction);
1629	1641	}
1630	1642
1631		static IrInstruction ir_gen_field_access(IrBuilder irb, AstNode *node, LValPurpose lval) {
	1643	static IrInstruction ir_gen_field_access(IrBuilder irb, Scope scope, AstNode node, LValPurpose lval) {
1632	1644	assert(node->type == NodeTypeFieldAccessExpr);
1633	1645
1634	1646	AstNode *container_ref_node = node->data.field_access_expr.struct_expr;
1635	1647	Buf *field_name = node->data.field_access_expr.field_name;
1636	1648
1637		IrInstruction *container_ref_instruction = ir_gen_node_extra(irb, container_ref_node, node->scope,
	1649	IrInstruction *container_ref_instruction = ir_gen_node_extra(irb, container_ref_node, scope,
1638	1650	LValPurposeAddressOf);
1639	1651	if (container_ref_instruction == irb->codegen->invalid_instruction)
1640	1652	return container_ref_instruction;
1641	1653
1642		IrInstruction *ptr_instruction = ir_build_field_ptr(irb, node, container_ref_instruction, field_name);
	1654	IrInstruction *ptr_instruction = ir_build_field_ptr(irb, scope, node, container_ref_instruction, field_name);
1643	1655	if (lval != LValPurposeNone)
1644	1656	return ptr_instruction;
1645	1657
1646		return ir_build_load_ptr(irb, node, ptr_instruction);
	1658	return ir_build_load_ptr(irb, scope, node, ptr_instruction);
1647	1659	}
1648	1660
1649		static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, AstNode *node) {
	1661	static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope scope, AstNode node) {
1650	1662	assert(node->type == NodeTypeFnCallExpr);
1651	1663
1652	1664	AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
...	...	@@ -1675,115 +1687,115 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, AstNode *node) {
1675	1687	case BuiltinFnIdInvalid:
1676	1688	zig_unreachable();
1677	1689	case BuiltinFnIdUnreachable:
1678		return ir_build_unreachable(irb, node);
	1690	return ir_build_unreachable(irb, scope, node);
1679	1691	case BuiltinFnIdTypeof:
1680	1692	{
1681	1693	AstNode *arg_node = node->data.fn_call_expr.params.at(0);
1682		IrInstruction *arg = ir_gen_node(irb, arg_node, node->scope);
	1694	IrInstruction *arg = ir_gen_node(irb, arg_node, scope);
1683	1695	if (arg == irb->codegen->invalid_instruction)
1684	1696	return arg;
1685		return ir_build_typeof(irb, node, arg);
	1697	return ir_build_typeof(irb, scope, node, arg);
1686	1698	}
1687	1699	case BuiltinFnIdSetFnTest:
1688	1700	{
1689	1701	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1690		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1702	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1691	1703	if (arg0_value == irb->codegen->invalid_instruction)
1692	1704	return arg0_value;
1693	1705
1694	1706	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
1695		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, node->scope);
	1707	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
1696	1708	if (arg1_value == irb->codegen->invalid_instruction)
1697	1709	return arg1_value;
1698	1710
1699		return ir_build_set_fn_test(irb, node, arg0_value, arg1_value);
	1711	return ir_build_set_fn_test(irb, scope, node, arg0_value, arg1_value);
1700	1712	}
1701	1713	case BuiltinFnIdSetFnVisible:
1702	1714	{
1703	1715	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1704		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1716	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1705	1717	if (arg0_value == irb->codegen->invalid_instruction)
1706	1718	return arg0_value;
1707	1719
1708	1720	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
1709		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, node->scope);
	1721	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
1710	1722	if (arg1_value == irb->codegen->invalid_instruction)
1711	1723	return arg1_value;
1712	1724
1713		return ir_build_set_fn_visible(irb, node, arg0_value, arg1_value);
	1725	return ir_build_set_fn_visible(irb, scope, node, arg0_value, arg1_value);
1714	1726	}
1715	1727	case BuiltinFnIdSetDebugSafety:
1716	1728	{
1717	1729	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1718		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1730	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1719	1731	if (arg0_value == irb->codegen->invalid_instruction)
1720	1732	return arg0_value;
1721	1733
1722	1734	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
1723		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, node->scope);
	1735	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
1724	1736	if (arg1_value == irb->codegen->invalid_instruction)
1725	1737	return arg1_value;
1726	1738
1727		return ir_build_set_debug_safety(irb, node, arg0_value, arg1_value);
	1739	return ir_build_set_debug_safety(irb, scope, node, arg0_value, arg1_value);
1728	1740	}
1729	1741	case BuiltinFnIdCompileVar:
1730	1742	{
1731	1743	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1732		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1744	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1733	1745	if (arg0_value == irb->codegen->invalid_instruction)
1734	1746	return arg0_value;
1735	1747
1736		return ir_build_compile_var(irb, node, arg0_value);
	1748	return ir_build_compile_var(irb, scope, node, arg0_value);
1737	1749	}
1738	1750	case BuiltinFnIdSizeof:
1739	1751	{
1740	1752	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1741		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1753	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1742	1754	if (arg0_value == irb->codegen->invalid_instruction)
1743	1755	return arg0_value;
1744	1756
1745		return ir_build_size_of(irb, node, arg0_value);
	1757	return ir_build_size_of(irb, scope, node, arg0_value);
1746	1758	}
1747	1759	case BuiltinFnIdCtz:
1748	1760	{
1749	1761	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1750		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1762	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1751	1763	if (arg0_value == irb->codegen->invalid_instruction)
1752	1764	return arg0_value;
1753	1765
1754		return ir_build_ctz(irb, node, arg0_value);
	1766	return ir_build_ctz(irb, scope, node, arg0_value);
1755	1767	}
1756	1768	case BuiltinFnIdClz:
1757	1769	{
1758	1770	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1759		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1771	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1760	1772	if (arg0_value == irb->codegen->invalid_instruction)
1761	1773	return arg0_value;
1762	1774
1763		return ir_build_clz(irb, node, arg0_value);
	1775	return ir_build_clz(irb, scope, node, arg0_value);
1764	1776	}
1765	1777	case BuiltinFnIdStaticEval:
1766	1778	{
1767	1779	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1768		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1780	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1769	1781	if (arg0_value == irb->codegen->invalid_instruction)
1770	1782	return arg0_value;
1771	1783
1772		return ir_build_static_eval(irb, node, arg0_value);
	1784	return ir_build_static_eval(irb, scope, node, arg0_value);
1773	1785	}
1774	1786	case BuiltinFnIdImport:
1775	1787	{
1776	1788	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
1777		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->scope);
	1789	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
1778	1790	if (arg0_value == irb->codegen->invalid_instruction)
1779	1791	return arg0_value;
1780	1792
1781		if (scope_fn_entry(node->scope)) {
	1793	if (exec_fn_entry(irb->exec)) {
1782	1794	add_node_error(irb->codegen, node, buf_sprintf("import valid only at top level scope"));
1783	1795	return irb->codegen->invalid_instruction;
1784	1796	}
1785	1797
1786		return ir_build_import(irb, node, arg0_value);
	1798	return ir_build_import(irb, scope, node, arg0_value);
1787	1799	}
1788	1800	case BuiltinFnIdMemcpy:
1789	1801	case BuiltinFnIdMemset:
...	...	@@ -1816,14 +1828,14 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, AstNode *node) {
1816	1828	zig_unreachable();
1817	1829	}
1818	1830
1819		static IrInstruction ir_gen_fn_call(IrBuilder irb, AstNode *node) {
	1831	static IrInstruction ir_gen_fn_call(IrBuilder irb, Scope scope, AstNode node) {
1820	1832	assert(node->type == NodeTypeFnCallExpr);
1821	1833
1822	1834	if (node->data.fn_call_expr.is_builtin)
1823		return ir_gen_builtin_fn_call(irb, node);
	1835	return ir_gen_builtin_fn_call(irb, scope, node);
1824	1836
1825	1837	AstNode *fn_ref_node = node->data.fn_call_expr.fn_ref_expr;
1826		IrInstruction *fn_ref = ir_gen_node(irb, fn_ref_node, node->scope);
	1838	IrInstruction *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
1827	1839	if (fn_ref == irb->codegen->invalid_instruction)
1828	1840	return fn_ref;
1829	1841
...	...	@@ -1831,16 +1843,16 @@ static IrInstruction ir_gen_fn_call(IrBuilder irb, AstNode *node) {
1831	1843	IrInstruction *args = allocate<IrInstruction>(arg_count);
1832	1844	for (size_t i = 0; i < arg_count; i += 1) {
1833	1845	AstNode *arg_node = node->data.fn_call_expr.params.at(i);
1834		args[i] = ir_gen_node(irb, arg_node, node->scope);
	1846	args[i] = ir_gen_node(irb, arg_node, scope);
1835	1847	}
1836	1848
1837		return ir_build_call(irb, node, nullptr, fn_ref, arg_count, args);
	1849	return ir_build_call(irb, scope, node, nullptr, fn_ref, arg_count, args);
1838	1850	}
1839	1851
1840		static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, AstNode *node) {
	1852	static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, Scope scope, AstNode node) {
1841	1853	assert(node->type == NodeTypeIfBoolExpr);
1842	1854
1843		IrInstruction *condition = ir_gen_node(irb, node->data.if_bool_expr.condition, node->scope);
	1855	IrInstruction *condition = ir_gen_node(irb, node->data.if_bool_expr.condition, scope);
1844	1856	if (condition == irb->codegen->invalid_instruction)
1845	1857	return condition;
1846	1858
...	...	@@ -1852,26 +1864,26 @@ static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, AstNode *node) {
1852	1864	IrBasicBlock *endif_block = ir_build_basic_block(irb, "EndIf");
1853	1865
1854	1866	bool is_inline = ir_should_inline(irb) \|\| node->data.if_bool_expr.is_inline;
1855		ir_build_cond_br(irb, condition->source_node, condition, then_block, else_block, is_inline);
	1867	ir_build_cond_br(irb, scope, condition->source_node, condition, then_block, else_block, is_inline);
1856	1868
1857	1869	ir_set_cursor_at_end(irb, then_block);
1858		IrInstruction *then_expr_result = ir_gen_node(irb, then_node, node->scope);
	1870	IrInstruction *then_expr_result = ir_gen_node(irb, then_node, scope);
1859	1871	if (then_expr_result == irb->codegen->invalid_instruction)
1860	1872	return then_expr_result;
1861	1873	IrBasicBlock *after_then_block = irb->current_basic_block;
1862		ir_build_br(irb, node, endif_block, is_inline);
	1874	ir_build_br(irb, scope, node, endif_block, is_inline);
1863	1875
1864	1876	ir_set_cursor_at_end(irb, else_block);
1865	1877	IrInstruction *else_expr_result;
1866	1878	if (else_node) {
1867		else_expr_result = ir_gen_node(irb, else_node, node->scope);
	1879	else_expr_result = ir_gen_node(irb, else_node, scope);
1868	1880	if (else_expr_result == irb->codegen->invalid_instruction)
1869	1881	return else_expr_result;
1870	1882	} else {
1871		else_expr_result = ir_build_const_void(irb, node);
	1883	else_expr_result = ir_build_const_void(irb, scope, node);
1872	1884	}
1873	1885	IrBasicBlock *after_else_block = irb->current_basic_block;
1874		ir_build_br(irb, node, endif_block, is_inline);
	1886	ir_build_br(irb, scope, node, endif_block, is_inline);
1875	1887
1876	1888	ir_set_cursor_at_end(irb, endif_block);
1877	1889	IrInstruction *incoming_values = allocate<IrInstruction >(2);
...	...	@@ -1881,14 +1893,14 @@ static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, AstNode *node) {
1881	1893	incoming_blocks[0] = after_then_block;
1882	1894	incoming_blocks[1] = after_else_block;
1883	1895
1884		return ir_build_phi(irb, node, 2, incoming_blocks, incoming_values);
	1896	return ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values);
1885	1897	}
1886	1898
1887		static IrInstruction ir_gen_prefix_op_id_lval(IrBuilder irb, AstNode *node, IrUnOp op_id, LValPurpose lval) {
	1899	static IrInstruction ir_gen_prefix_op_id_lval(IrBuilder irb, Scope scope, AstNode node, IrUnOp op_id, LValPurpose lval) {
1888	1900	assert(node->type == NodeTypePrefixOpExpr);
1889	1901	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
1890	1902
1891		IrInstruction *value = ir_gen_node_extra(irb, expr_node, node->scope, lval);
	1903	IrInstruction *value = ir_gen_node_extra(irb, expr_node, scope, lval);
1892	1904	if (value == irb->codegen->invalid_instruction)
1893	1905	return value;
1894	1906
...	...	@@ -1896,27 +1908,27 @@ static IrInstruction ir_gen_prefix_op_id_lval(IrBuilder irb, AstNode *node, Ir
1896	1908	return value;
1897	1909	}
1898	1910
1899		return ir_build_un_op(irb, node, op_id, value);
	1911	return ir_build_un_op(irb, scope, node, op_id, value);
1900	1912	}
1901	1913
1902		static IrInstruction ir_gen_prefix_op_id(IrBuilder irb, AstNode *node, IrUnOp op_id) {
1903		return ir_gen_prefix_op_id_lval(irb, node, op_id, LValPurposeNone);
	1914	static IrInstruction ir_gen_prefix_op_id(IrBuilder irb, Scope scope, AstNode node, IrUnOp op_id) {
	1915	return ir_gen_prefix_op_id_lval(irb, scope, node, op_id, LValPurposeNone);
1904	1916	}
1905	1917
1906		static IrInstruction ir_gen_prefix_op_unwrap_maybe(IrBuilder irb, AstNode *node, LValPurpose lval) {
	1918	static IrInstruction ir_gen_prefix_op_unwrap_maybe(IrBuilder irb, Scope scope, AstNode node, LValPurpose lval) {
1907	1919	AstNode *expr = node->data.prefix_op_expr.primary_expr;
1908		IrInstruction *value = ir_gen_node_extra(irb, expr, node->scope, LValPurposeAddressOf);
	1920	IrInstruction *value = ir_gen_node_extra(irb, expr, scope, LValPurposeAddressOf);
1909	1921	if (value == irb->codegen->invalid_instruction)
1910	1922	return value;
1911	1923
1912		IrInstruction *unwrapped_ptr = ir_build_unwrap_maybe(irb, node, value, true);
	1924	IrInstruction *unwrapped_ptr = ir_build_unwrap_maybe(irb, scope, node, value, true);
1913	1925	if (lval == LValPurposeNone)
1914		return ir_build_load_ptr(irb, node, unwrapped_ptr);
	1926	return ir_build_load_ptr(irb, scope, node, unwrapped_ptr);
1915	1927	else
1916	1928	return unwrapped_ptr;
1917	1929	}
1918	1930
1919		static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, AstNode *node, LValPurpose lval) {
	1931	static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, Scope scope, AstNode node, LValPurpose lval) {
1920	1932	assert(node->type == NodeTypePrefixOpExpr);
1921	1933
1922	1934	PrefixOp prefix_op = node->data.prefix_op_expr.prefix_op;
...	...	@@ -1925,38 +1937,38 @@ static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, AstNode *node, LValP
1925	1937	case PrefixOpInvalid:
1926	1938	zig_unreachable();
1927	1939	case PrefixOpBoolNot:
1928		return ir_gen_prefix_op_id(irb, node, IrUnOpBoolNot);
	1940	return ir_gen_prefix_op_id(irb, scope, node, IrUnOpBoolNot);
1929	1941	case PrefixOpBinNot:
1930		return ir_gen_prefix_op_id(irb, node, IrUnOpBinNot);
	1942	return ir_gen_prefix_op_id(irb, scope, node, IrUnOpBinNot);
1931	1943	case PrefixOpNegation:
1932		return ir_gen_prefix_op_id(irb, node, IrUnOpNegation);
	1944	return ir_gen_prefix_op_id(irb, scope, node, IrUnOpNegation);
1933	1945	case PrefixOpNegationWrap:
1934		return ir_gen_prefix_op_id(irb, node, IrUnOpNegationWrap);
	1946	return ir_gen_prefix_op_id(irb, scope, node, IrUnOpNegationWrap);
1935	1947	case PrefixOpAddressOf:
1936		return ir_gen_prefix_op_id_lval(irb, node, IrUnOpAddressOf, LValPurposeAddressOf);
	1948	return ir_gen_prefix_op_id_lval(irb, scope, node, IrUnOpAddressOf, LValPurposeAddressOf);
1937	1949	case PrefixOpConstAddressOf:
1938		return ir_gen_prefix_op_id_lval(irb, node, IrUnOpConstAddressOf, LValPurposeAddressOf);
	1950	return ir_gen_prefix_op_id_lval(irb, scope, node, IrUnOpConstAddressOf, LValPurposeAddressOf);
1939	1951	case PrefixOpDereference:
1940		return ir_gen_prefix_op_id_lval(irb, node, IrUnOpDereference, lval);
	1952	return ir_gen_prefix_op_id_lval(irb, scope, node, IrUnOpDereference, lval);
1941	1953	case PrefixOpMaybe:
1942		return ir_gen_prefix_op_id(irb, node, IrUnOpMaybe);
	1954	return ir_gen_prefix_op_id(irb, scope, node, IrUnOpMaybe);
1943	1955	case PrefixOpError:
1944		return ir_gen_prefix_op_id(irb, node, IrUnOpError);
	1956	return ir_gen_prefix_op_id(irb, scope, node, IrUnOpError);
1945	1957	case PrefixOpUnwrapError:
1946		return ir_gen_prefix_op_id(irb, node, IrUnOpUnwrapError);
	1958	return ir_gen_prefix_op_id(irb, scope, node, IrUnOpUnwrapError);
1947	1959	case PrefixOpUnwrapMaybe:
1948		return ir_gen_prefix_op_unwrap_maybe(irb, node, lval);
	1960	return ir_gen_prefix_op_unwrap_maybe(irb, scope, node, lval);
1949	1961	}
1950	1962	zig_unreachable();
1951	1963	}
1952	1964
1953		static IrInstruction ir_gen_container_init_expr(IrBuilder irb, AstNode *node) {
	1965	static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope scope, AstNode node) {
1954	1966	assert(node->type == NodeTypeContainerInitExpr);
1955	1967
1956	1968	AstNodeContainerInitExpr *container_init_expr = &node->data.container_init_expr;
1957	1969	ContainerInitKind kind = container_init_expr->kind;
1958	1970
1959		IrInstruction *container_type = ir_gen_node(irb, container_init_expr->type, node->scope);
	1971	IrInstruction *container_type = ir_gen_node(irb, container_init_expr->type, scope);
1960	1972	if (container_type == irb->codegen->invalid_instruction)
1961	1973	return container_type;
1962	1974
...	...	@@ -1969,7 +1981,7 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, AstNode *node)
1969	1981
1970	1982	Buf *name = entry_node->data.struct_val_field.name;
1971	1983	AstNode *expr_node = entry_node->data.struct_val_field.expr;
1972		IrInstruction *expr_value = ir_gen_node(irb, expr_node, node->scope);
	1984	IrInstruction *expr_value = ir_gen_node(irb, expr_node, scope);
1973	1985	if (expr_value == irb->codegen->invalid_instruction)
1974	1986	return expr_value;
1975	1987
...	...	@@ -1977,39 +1989,39 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, AstNode *node)
1977	1989	fields[i].value = expr_value;
1978	1990	fields[i].source_node = entry_node;
1979	1991	}
1980		return ir_build_container_init_fields(irb, node, container_type, field_count, fields);
	1992	return ir_build_container_init_fields(irb, scope, node, container_type, field_count, fields);
1981	1993	} else if (kind == ContainerInitKindArray) {
1982	1994	size_t item_count = container_init_expr->entries.length;
1983	1995	IrInstruction *values = allocate<IrInstruction >(item_count);
1984	1996	for (size_t i = 0; i < item_count; i += 1) {
1985	1997	AstNode *expr_node = container_init_expr->entries.at(i);
1986		IrInstruction *expr_value = ir_gen_node(irb, expr_node, node->scope);
	1998	IrInstruction *expr_value = ir_gen_node(irb, expr_node, scope);
1987	1999	if (expr_value == irb->codegen->invalid_instruction)
1988	2000	return expr_value;
1989	2001
1990	2002	values[i] = expr_value;
1991	2003	}
1992		return ir_build_container_init_list(irb, node, container_type, item_count, values);
	2004	return ir_build_container_init_list(irb, scope, node, container_type, item_count, values);
1993	2005	} else {
1994	2006	zig_unreachable();
1995	2007	}
1996	2008	}
1997	2009
1998		static IrInstruction ir_gen_var_decl(IrBuilder irb, AstNode *node) {
	2010	static IrInstruction ir_gen_var_decl(IrBuilder irb, Scope scope, AstNode node) {
1999	2011	assert(node->type == NodeTypeVariableDeclaration);
2000	2012
2001	2013	AstNodeVariableDeclaration *variable_declaration = &node->data.variable_declaration;
2002	2014
2003	2015	IrInstruction *type_instruction;
2004	2016	if (variable_declaration->type != nullptr) {
2005		type_instruction = ir_gen_node(irb, variable_declaration->type, node->scope);
	2017	type_instruction = ir_gen_node(irb, variable_declaration->type, scope);
2006	2018	if (type_instruction == irb->codegen->invalid_instruction)
2007	2019	return type_instruction;
2008	2020	} else {
2009	2021	type_instruction = nullptr;
2010	2022	}
2011	2023
2012		IrInstruction *init_value = ir_gen_node(irb, variable_declaration->expr, node->scope);
	2024	IrInstruction *init_value = ir_gen_node(irb, variable_declaration->expr, scope);
2013	2025	if (init_value == irb->codegen->invalid_instruction)
2014	2026	return init_value;
2015	2027
...	...	@@ -2017,7 +2029,7 @@ static IrInstruction ir_gen_var_decl(IrBuilder irb, AstNode *node) {
2017	2029	bool is_const = variable_declaration->is_const;
2018	2030	bool is_extern = variable_declaration->is_extern;
2019	2031	bool is_inline = ir_should_inline(irb) \|\| variable_declaration->is_inline;
2020		VariableTableEntry *var = ir_create_var(irb, node, node->scope,
	2032	VariableTableEntry *var = ir_create_var(irb, node, scope,
2021	2033	variable_declaration->symbol, is_const, is_const, is_shadowable, is_inline);
2022	2034	// we detect IrInstructionIdDeclVar in gen_block to make sure the next node
2023	2035	// is inside var->child_scope
...	...	@@ -2028,10 +2040,10 @@ static IrInstruction ir_gen_var_decl(IrBuilder irb, AstNode *node) {
2028	2040	return irb->codegen->invalid_instruction;
2029	2041	}
2030	2042
2031		return ir_build_var_decl(irb, node, var, type_instruction, init_value);
	2043	return ir_build_var_decl(irb, scope, node, var, type_instruction, init_value);
2032	2044	}
2033	2045
2034		static IrInstruction ir_gen_while_expr(IrBuilder irb, AstNode *node) {
	2046	static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode node) {
2035	2047	assert(node->type == NodeTypeWhileExpr);
2036	2048
2037	2049	AstNode *continue_expr_node = node->data.while_expr.continue_expr;
...	...	@@ -2043,37 +2055,35 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, AstNode *node) {
2043	2055	IrBasicBlock *end_block = ir_build_basic_block(irb, "WhileEnd");
2044	2056
2045	2057	bool is_inline = ir_should_inline(irb) \|\| node->data.while_expr.is_inline;
2046		ir_build_br(irb, node, cond_block, is_inline);
	2058	ir_build_br(irb, scope, node, cond_block, is_inline);
2047	2059
2048	2060	if (continue_expr_node) {
2049	2061	ir_set_cursor_at_end(irb, continue_block);
2050		ir_gen_node(irb, continue_expr_node, node->scope);
2051		ir_build_br(irb, node, cond_block, is_inline);
	2062	ir_gen_node(irb, continue_expr_node, scope);
	2063	ir_build_br(irb, scope, node, cond_block, is_inline);
2052	2064	}
2053	2065
2054	2066	ir_set_cursor_at_end(irb, cond_block);
2055		IrInstruction *cond_val = ir_gen_node(irb, node->data.while_expr.condition, node->scope);
2056		ir_build_cond_br(irb, node->data.while_expr.condition, cond_val, body_block, end_block, is_inline);
	2067	IrInstruction *cond_val = ir_gen_node(irb, node->data.while_expr.condition, scope);
	2068	ir_build_cond_br(irb, scope, node->data.while_expr.condition, cond_val, body_block, end_block, is_inline);
2057	2069
2058	2070	ir_set_cursor_at_end(irb, body_block);
2059	2071
2060	2072	irb->break_block_stack.append(end_block);
2061	2073	irb->continue_block_stack.append(continue_block);
2062		ir_gen_node(irb, node->data.while_expr.body, node->scope);
	2074	ir_gen_node(irb, node->data.while_expr.body, scope);
2063	2075	irb->break_block_stack.pop();
2064	2076	irb->continue_block_stack.pop();
2065	2077
2066		ir_build_br(irb, node, continue_block, is_inline);
	2078	ir_build_br(irb, scope, node, continue_block, is_inline);
2067	2079	ir_set_cursor_at_end(irb, end_block);
2068	2080
2069		return ir_build_const_void(irb, node);
	2081	return ir_build_const_void(irb, scope, node);
2070	2082	}
2071	2083
2072		static IrInstruction ir_gen_for_expr(IrBuilder irb, AstNode *node) {
	2084	static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope parent_scope, AstNode node) {
2073	2085	assert(node->type == NodeTypeForExpr);
2074	2086
2075		Scope *parent_scope = node->scope;
2076
2077	2087	AstNode *array_node = node->data.for_expr.array_expr;
2078	2088	AstNode *elem_node = node->data.for_expr.elem_node;
2079	2089	AstNode *index_node = node->data.for_expr.index_node;
...	...	@@ -2089,48 +2099,45 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, AstNode *node) {
2089	2099	if (array_val == irb->codegen->invalid_instruction)
2090	2100	return array_val;
2091	2101
2092		IrInstruction *array_type = ir_build_typeof(irb, array_node, array_val);
2093		IrInstruction *pointer_type = ir_build_to_ptr_type(irb, array_node, array_type);
	2102	IrInstruction *array_type = ir_build_typeof(irb, parent_scope, array_node, array_val);
	2103	IrInstruction *pointer_type = ir_build_to_ptr_type(irb, parent_scope, array_node, array_type);
2094	2104	IrInstruction *elem_var_type;
2095	2105	if (node->data.for_expr.elem_is_ptr) {
2096	2106	elem_var_type = pointer_type;
2097	2107	} else {
2098		elem_var_type = ir_build_ptr_type_child(irb, elem_node, pointer_type);
	2108	elem_var_type = ir_build_ptr_type_child(irb, parent_scope, elem_node, pointer_type);
2099	2109	}
2100	2110	bool is_inline = ir_should_inline(irb) \|\| node->data.for_expr.is_inline;
2101	2111
2102	2112	Scope *child_scope = create_loop_scope(node, parent_scope);
2103		elem_node->scope = child_scope;
2104	2113
2105	2114	// TODO make it an error to write to element variable or i variable.
2106	2115	Buf *elem_var_name = elem_node->data.symbol_expr.symbol;
2107		node->data.for_expr.elem_var = ir_create_var(irb, elem_node, child_scope, elem_var_name,
	2116	VariableTableEntry *elem_var = ir_create_var(irb, elem_node, child_scope, elem_var_name,
2108	2117	true, false, false, is_inline);
2109		child_scope = node->data.for_expr.elem_var->child_scope;
	2118	child_scope = elem_var->child_scope;
2110	2119
2111		IrInstruction *undefined_value = ir_build_const_undefined(irb, elem_node);
2112		ir_build_var_decl(irb, elem_node, node->data.for_expr.elem_var, elem_var_type, undefined_value);
2113		IrInstruction *elem_var_ptr = ir_build_var_ptr(irb, node, node->data.for_expr.elem_var);
	2120	IrInstruction *undefined_value = ir_build_const_undefined(irb, child_scope, elem_node);
	2121	ir_build_var_decl(irb, child_scope, elem_node, elem_var, elem_var_type, undefined_value);
	2122	IrInstruction *elem_var_ptr = ir_build_var_ptr(irb, child_scope, node, elem_var);
2114	2123
2115	2124	AstNode *index_var_source_node;
	2125	VariableTableEntry *index_var;
2116	2126	if (index_node) {
2117	2127	index_var_source_node = index_node;
2118	2128	Buf *index_var_name = index_node->data.symbol_expr.symbol;
2119		index_node->scope = child_scope;
2120		node->data.for_expr.index_var = ir_create_var(irb, index_node, child_scope, index_var_name,
2121		true, false, false, is_inline);
	2129	index_var = ir_create_var(irb, index_node, child_scope, index_var_name, true, false, false, is_inline);
2122	2130	} else {
2123	2131	index_var_source_node = node;
2124		node->data.for_expr.index_var = ir_create_var(irb, node, child_scope, nullptr,
2125		true, false, true, is_inline);
	2132	index_var = ir_create_var(irb, node, child_scope, nullptr, true, false, true, is_inline);
2126	2133	}
2127		child_scope = node->data.for_expr.index_var->child_scope;
	2134	child_scope = index_var->child_scope;
2128	2135
2129		IrInstruction *usize = ir_build_const_type(irb, node, irb->codegen->builtin_types.entry_usize);
2130		IrInstruction *zero = ir_build_const_usize(irb, node, 0);
2131		IrInstruction *one = ir_build_const_usize(irb, node, 1);
2132		ir_build_var_decl(irb, index_var_source_node, node->data.for_expr.index_var, usize, zero);
2133		IrInstruction *index_ptr = ir_build_var_ptr(irb, node, node->data.for_expr.index_var);
	2136	IrInstruction *usize = ir_build_const_type(irb, child_scope, node, irb->codegen->builtin_types.entry_usize);
	2137	IrInstruction *zero = ir_build_const_usize(irb, child_scope, node, 0);
	2138	IrInstruction *one = ir_build_const_usize(irb, child_scope, node, 1);
	2139	ir_build_var_decl(irb, child_scope, index_var_source_node, index_var, usize, zero);
	2140	IrInstruction *index_ptr = ir_build_var_ptr(irb, child_scope, node, index_var);
2134	2141
2135	2142
2136	2143	IrBasicBlock *cond_block = ir_build_basic_block(irb, "ForCond");
...	...	@@ -2138,23 +2145,23 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, AstNode *node) {
2138	2145	IrBasicBlock *end_block = ir_build_basic_block(irb, "ForEnd");
2139	2146	IrBasicBlock *continue_block = ir_build_basic_block(irb, "ForContinue");
2140	2147
2141		IrInstruction *len_val = ir_build_array_len(irb, node, array_val);
2142		ir_build_br(irb, node, cond_block, is_inline);
	2148	IrInstruction *len_val = ir_build_array_len(irb, child_scope, node, array_val);
	2149	ir_build_br(irb, child_scope, node, cond_block, is_inline);
2143	2150
2144	2151	ir_set_cursor_at_end(irb, cond_block);
2145		IrInstruction *index_val = ir_build_load_ptr(irb, node, index_ptr);
2146		IrInstruction *cond = ir_build_bin_op(irb, node, IrBinOpCmpLessThan, index_val, len_val);
2147		ir_build_cond_br(irb, node, cond, body_block, end_block, is_inline);
	2152	IrInstruction *index_val = ir_build_load_ptr(irb, child_scope, node, index_ptr);
	2153	IrInstruction *cond = ir_build_bin_op(irb, child_scope, node, IrBinOpCmpLessThan, index_val, len_val);
	2154	ir_build_cond_br(irb, child_scope, node, cond, body_block, end_block, is_inline);
2148	2155
2149	2156	ir_set_cursor_at_end(irb, body_block);
2150		IrInstruction *elem_ptr = ir_build_elem_ptr(irb, node, array_val, index_val, true);
	2157	IrInstruction *elem_ptr = ir_build_elem_ptr(irb, child_scope, node, array_val, index_val, true);
2151	2158	IrInstruction *elem_val;
2152	2159	if (node->data.for_expr.elem_is_ptr) {
2153	2160	elem_val = elem_ptr;
2154	2161	} else {
2155		elem_val = ir_build_load_ptr(irb, node, elem_ptr);
	2162	elem_val = ir_build_load_ptr(irb, child_scope, node, elem_ptr);
2156	2163	}
2157		ir_build_store_ptr(irb, node, elem_var_ptr, elem_val);
	2164	ir_build_store_ptr(irb, child_scope, node, elem_var_ptr, elem_val);
2158	2165
2159	2166	irb->break_block_stack.append(end_block);
2160	2167	irb->continue_block_stack.append(continue_block);
...	...	@@ -2162,61 +2169,60 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, AstNode *node) {
2162	2169	irb->break_block_stack.pop();
2163	2170	irb->continue_block_stack.pop();
2164	2171
2165		ir_build_br(irb, node, continue_block, is_inline);
	2172	ir_build_br(irb, child_scope, node, continue_block, is_inline);
2166	2173
2167	2174	ir_set_cursor_at_end(irb, continue_block);
2168		IrInstruction *new_index_val = ir_build_bin_op(irb, node, IrBinOpAdd, index_val, one);
2169		ir_build_store_ptr(irb, node, index_ptr, new_index_val);
2170		ir_build_br(irb, node, cond_block, is_inline);
	2175	IrInstruction *new_index_val = ir_build_bin_op(irb, child_scope, node, IrBinOpAdd, index_val, one);
	2176	ir_build_store_ptr(irb, child_scope, node, index_ptr, new_index_val);
	2177	ir_build_br(irb, child_scope, node, cond_block, is_inline);
2171	2178
2172	2179	ir_set_cursor_at_end(irb, end_block);
2173		return ir_build_const_void(irb, node);
	2180	return ir_build_const_void(irb, child_scope, node);
2174	2181
2175	2182	}
2176	2183
2177		static IrInstruction ir_gen_this_literal(IrBuilder irb, AstNode *node) {
	2184	static IrInstruction ir_gen_this_literal(IrBuilder irb, Scope scope, AstNode node) {
2178	2185	assert(node->type == NodeTypeThisLiteral);
2179	2186
2180		Scope *scope = node->scope;
2181
2182	2187	if (!scope->parent)
2183		return ir_build_const_import(irb, node, node->owner);
	2188	return ir_build_const_import(irb, scope, node, node->owner);
2184	2189
2185		FnTableEntry *fn_entry = scope_fn_entry(scope);
	2190	FnTableEntry *fn_entry = exec_fn_entry(irb->exec);
2186	2191	if (fn_entry && scope->parent && scope->parent->parent &&
2187	2192	!scope_fn_entry(scope->parent->parent))
2188	2193	{
2189		return ir_build_const_fn(irb, node, fn_entry);
	2194	return ir_build_const_fn(irb, scope, node, fn_entry);
2190	2195	}
2191	2196
2192	2197	if (scope->node->type == NodeTypeContainerDecl) {
2193		TypeTableEntry *container_type = scope->node->data.struct_decl.type_entry;
	2198	ScopeDecls decls_scope = (ScopeDecls )scope;
	2199	TypeTableEntry *container_type = decls_scope->container_type;
2194	2200	assert(container_type);
2195		return ir_build_const_type(irb, node, container_type);
	2201	return ir_build_const_type(irb, scope, node, container_type);
2196	2202	}
2197	2203
2198	2204	if (scope->node->type == NodeTypeBlock)
2199		return ir_build_const_scope(irb, node, scope);
	2205	return ir_build_const_scope(irb, scope, node, scope);
2200	2206
2201	2207	zig_unreachable();
2202	2208	}
2203	2209
2204		static IrInstruction ir_gen_bool_literal(IrBuilder irb, AstNode *node) {
	2210	static IrInstruction ir_gen_bool_literal(IrBuilder irb, Scope scope, AstNode node) {
2205	2211	assert(node->type == NodeTypeBoolLiteral);
2206		return ir_build_const_bool(irb, node, node->data.bool_literal.value);
	2212	return ir_build_const_bool(irb, scope, node, node->data.bool_literal.value);
2207	2213	}
2208	2214
2209		static IrInstruction ir_gen_string_literal(IrBuilder irb, AstNode *node) {
	2215	static IrInstruction ir_gen_string_literal(IrBuilder irb, Scope scope, AstNode node) {
2210	2216	assert(node->type == NodeTypeStringLiteral);
2211	2217
2212	2218	if (node->data.string_literal.c) {
2213		return ir_build_const_c_str_lit(irb, node, node->data.string_literal.buf);
	2219	return ir_build_const_c_str_lit(irb, scope, node, node->data.string_literal.buf);
2214	2220	} else {
2215		return ir_build_const_str_lit(irb, node, node->data.string_literal.buf);
	2221	return ir_build_const_str_lit(irb, scope, node, node->data.string_literal.buf);
2216	2222	}
2217	2223	}
2218	2224
2219		static IrInstruction ir_gen_array_type(IrBuilder irb, AstNode *node) {
	2225	static IrInstruction ir_gen_array_type(IrBuilder irb, Scope scope, AstNode node) {
2220	2226	assert(node->type == NodeTypeArrayType);
2221	2227
2222	2228	AstNode *size_node = node->data.array_type.size;
...	...	@@ -2229,35 +2235,36 @@ static IrInstruction ir_gen_array_type(IrBuilder irb, AstNode *node) {
2229	2235	return irb->codegen->invalid_instruction;
2230	2236	}
2231	2237
2232		IrInstruction *size_value = ir_gen_node(irb, size_node, node->scope);
	2238	IrInstruction *size_value = ir_gen_node(irb, size_node, scope);
2233	2239	if (size_value == irb->codegen->invalid_instruction)
2234	2240	return size_value;
2235	2241
2236		IrInstruction *child_type = ir_gen_node(irb, child_type_node, node->scope);
	2242	IrInstruction *child_type = ir_gen_node(irb, child_type_node, scope);
2237	2243	if (child_type == irb->codegen->invalid_instruction)
2238	2244	return child_type;
2239	2245
2240		return ir_build_array_type(irb, node, size_value, child_type);
	2246	return ir_build_array_type(irb, scope, node, size_value, child_type);
2241	2247	} else {
2242	2248	IrInstruction *child_type = ir_gen_node_extra(irb, child_type_node,
2243		node->scope, LValPurposeAddressOf);
	2249	scope, LValPurposeAddressOf);
2244	2250	if (child_type == irb->codegen->invalid_instruction)
2245	2251	return child_type;
2246	2252
2247		return ir_build_slice_type(irb, node, is_const, child_type);
	2253	return ir_build_slice_type(irb, scope, node, is_const, child_type);
2248	2254	}
2249	2255	}
2250	2256
2251		static IrInstruction ir_gen_undefined_literal(IrBuilder irb, AstNode *node) {
	2257	static IrInstruction ir_gen_undefined_literal(IrBuilder irb, Scope scope, AstNode node) {
2252	2258	assert(node->type == NodeTypeUndefinedLiteral);
2253		return ir_build_const_undefined(irb, node);
	2259	return ir_build_const_undefined(irb, scope, node);
2254	2260	}
2255	2261
2256		static IrInstruction ir_gen_asm_expr(IrBuilder irb, AstNode *node) {
	2262	static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode node) {
2257	2263	assert(node->type == NodeTypeAsmExpr);
2258	2264
2259	2265	IrInstruction *input_list = allocate<IrInstruction >(node->data.asm_expr.input_list.length);
2260	2266	IrInstruction *output_types = allocate<IrInstruction >(node->data.asm_expr.output_list.length);
	2267	VariableTableEntry *output_vars = allocate<VariableTableEntry >(node->data.asm_expr.output_list.length);
2261	2268	size_t return_count = 0;
2262	2269	bool is_volatile = node->data.asm_expr.is_volatile;
2263	2270	if (!is_volatile && node->data.asm_expr.output_list.length == 0) {
...	...	@@ -2270,7 +2277,7 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, AstNode *node) {
2270	2277	if (asm_output->return_type) {
2271	2278	return_count += 1;
2272	2279
2273		IrInstruction *return_type = ir_gen_node(irb, asm_output->return_type, node->scope);
	2280	IrInstruction *return_type = ir_gen_node(irb, asm_output->return_type, scope);
2274	2281	if (return_type == irb->codegen->invalid_instruction)
2275	2282	return irb->codegen->invalid_instruction;
2276	2283	if (return_count > 1) {
...	...	@@ -2281,9 +2288,9 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, AstNode *node) {
2281	2288	output_types[i] = return_type;
2282	2289	} else {
2283	2290	Buf *variable_name = asm_output->variable_name;
2284		VariableTableEntry *var = find_variable(irb->codegen, node->scope, variable_name);
	2291	VariableTableEntry *var = find_variable(irb->codegen, scope, variable_name);
2285	2292	if (var) {
2286		asm_output->variable = var;
	2293	output_vars[i] = var;
2287	2294	} else {
2288	2295	add_node_error(irb->codegen, node,
2289	2296	buf_sprintf("use of undeclared identifier '%s'", buf_ptr(variable_name)));
...	...	@@ -2293,17 +2300,17 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, AstNode *node) {
2293	2300	}
2294	2301	for (size_t i = 0; i < node->data.asm_expr.input_list.length; i += 1) {
2295	2302	AsmInput *asm_input = node->data.asm_expr.input_list.at(i);
2296		IrInstruction *input_value = ir_gen_node(irb, asm_input->expr, node->scope);
	2303	IrInstruction *input_value = ir_gen_node(irb, asm_input->expr, scope);
2297	2304	if (input_value == irb->codegen->invalid_instruction)
2298	2305	return irb->codegen->invalid_instruction;
2299	2306
2300	2307	input_list[i] = input_value;
2301	2308	}
2302	2309
2303		return ir_build_asm(irb, node, input_list, output_types, return_count, is_volatile);
	2310	return ir_build_asm(irb, scope, node, input_list, output_types, output_vars, return_count, is_volatile);
2304	2311	}
2305	2312
2306		static IrInstruction ir_gen_if_var_expr(IrBuilder irb, AstNode *node) {
	2313	static IrInstruction ir_gen_if_var_expr(IrBuilder irb, Scope scope, AstNode node) {
2307	2314	assert(node->type == NodeTypeIfVarExpr);
2308	2315
2309	2316	AstNodeVariableDeclaration *var_decl = &node->data.if_var_expr.var_decl;
...	...	@@ -2312,51 +2319,51 @@ static IrInstruction ir_gen_if_var_expr(IrBuilder irb, AstNode *node) {
2312	2319	AstNode *else_node = node->data.if_var_expr.else_node;
2313	2320	bool var_is_ptr = node->data.if_var_expr.var_is_ptr;
2314	2321
2315		IrInstruction *expr_value = ir_gen_node_extra(irb, expr_node, node->scope, LValPurposeAddressOf);
	2322	IrInstruction *expr_value = ir_gen_node_extra(irb, expr_node, scope, LValPurposeAddressOf);
2316	2323	if (expr_value == irb->codegen->invalid_instruction)
2317	2324	return expr_value;
2318	2325
2319		IrInstruction *is_nonnull_value = ir_build_test_null(irb, node, expr_value);
	2326	IrInstruction *is_nonnull_value = ir_build_test_null(irb, scope, node, expr_value);
2320	2327
2321	2328	IrBasicBlock *then_block = ir_build_basic_block(irb, "MaybeThen");
2322	2329	IrBasicBlock *else_block = ir_build_basic_block(irb, "MaybeElse");
2323	2330	IrBasicBlock *endif_block = ir_build_basic_block(irb, "MaybeEndIf");
2324	2331
2325	2332	bool is_inline = ir_should_inline(irb) \|\| node->data.if_var_expr.is_inline;
2326		ir_build_cond_br(irb, node, is_nonnull_value, then_block, else_block, is_inline);
	2333	ir_build_cond_br(irb, scope, node, is_nonnull_value, then_block, else_block, is_inline);
2327	2334
2328	2335	ir_set_cursor_at_end(irb, then_block);
2329	2336	IrInstruction *var_type = nullptr;
2330	2337	if (var_decl->type) {
2331		var_type = ir_gen_node(irb, var_decl->type, node->scope);
	2338	var_type = ir_gen_node(irb, var_decl->type, scope);
2332	2339	if (var_type == irb->codegen->invalid_instruction)
2333	2340	return irb->codegen->invalid_instruction;
2334	2341	}
2335	2342	bool is_shadowable = false;
2336	2343	bool is_const = var_decl->is_const;
2337		VariableTableEntry *var = ir_create_var(irb, node, node->scope,
	2344	VariableTableEntry *var = ir_create_var(irb, node, scope,
2338	2345	var_decl->symbol, is_const, is_const, is_shadowable, is_inline);
2339	2346
2340		IrInstruction *var_ptr_value = ir_build_unwrap_maybe(irb, node, expr_value, false);
2341		IrInstruction *var_value = var_is_ptr ? var_ptr_value : ir_build_load_ptr(irb, node, var_ptr_value);
2342		ir_build_var_decl(irb, node, var, var_type, var_value);
	2347	IrInstruction *var_ptr_value = ir_build_unwrap_maybe(irb, scope, node, expr_value, false);
	2348	IrInstruction *var_value = var_is_ptr ? var_ptr_value : ir_build_load_ptr(irb, scope, node, var_ptr_value);
	2349	ir_build_var_decl(irb, scope, node, var, var_type, var_value);
2343	2350	IrInstruction *then_expr_result = ir_gen_node(irb, then_node, var->child_scope);
2344	2351	if (then_expr_result == irb->codegen->invalid_instruction)
2345	2352	return then_expr_result;
2346	2353	IrBasicBlock *after_then_block = irb->current_basic_block;
2347		ir_build_br(irb, node, endif_block, is_inline);
	2354	ir_build_br(irb, scope, node, endif_block, is_inline);
2348	2355
2349	2356	ir_set_cursor_at_end(irb, else_block);
2350	2357	IrInstruction *else_expr_result;
2351	2358	if (else_node) {
2352		else_expr_result = ir_gen_node(irb, else_node, node->scope);
	2359	else_expr_result = ir_gen_node(irb, else_node, scope);
2353	2360	if (else_expr_result == irb->codegen->invalid_instruction)
2354	2361	return else_expr_result;
2355	2362	} else {
2356		else_expr_result = ir_build_const_void(irb, node);
	2363	else_expr_result = ir_build_const_void(irb, scope, node);
2357	2364	}
2358	2365	IrBasicBlock *after_else_block = irb->current_basic_block;
2359		ir_build_br(irb, node, endif_block, is_inline);
	2366	ir_build_br(irb, scope, node, endif_block, is_inline);
2360	2367
2361	2368	ir_set_cursor_at_end(irb, endif_block);
2362	2369	IrInstruction *incoming_values = allocate<IrInstruction >(2);
...	...	@@ -2366,10 +2373,10 @@ static IrInstruction ir_gen_if_var_expr(IrBuilder irb, AstNode *node) {
2366	2373	incoming_blocks[0] = after_then_block;
2367	2374	incoming_blocks[1] = after_else_block;
2368	2375
2369		return ir_build_phi(irb, node, 2, incoming_blocks, incoming_values);
	2376	return ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values);
2370	2377	}
2371	2378
2372		static bool ir_gen_switch_prong_expr(IrBuilder irb, AstNode switch_node, AstNode *prong_node,
	2379	static bool ir_gen_switch_prong_expr(IrBuilder irb, Scope scope, AstNode switch_node, AstNode prong_node,
2373	2380	IrBasicBlock end_block, bool is_inline, IrInstruction target_value_ptr, IrInstruction *prong_value,
2374	2381	ZigList<IrBasicBlock > incoming_blocks, ZigList<IrInstruction > incoming_values)
2375	2382	{
...	...	@@ -2386,39 +2393,39 @@ static bool ir_gen_switch_prong_expr(IrBuilder irb, AstNode switch_node, AstNo
2386	2393
2387	2394	bool is_shadowable = false;
2388	2395	bool is_const = true;
2389		VariableTableEntry *var = ir_create_var(irb, var_symbol_node, switch_node->scope,
	2396	VariableTableEntry *var = ir_create_var(irb, var_symbol_node, scope,
2390	2397	var_name, is_const, is_const, is_shadowable, is_inline);
2391	2398	child_scope = var->child_scope;
2392	2399	IrInstruction *var_value;
2393	2400	if (prong_value) {
2394		IrInstruction *var_ptr_value = ir_build_switch_var(irb, var_symbol_node, target_value_ptr, prong_value);
2395		var_value = var_is_ptr ? var_ptr_value : ir_build_load_ptr(irb, var_symbol_node, var_ptr_value);
	2401	IrInstruction *var_ptr_value = ir_build_switch_var(irb, scope, var_symbol_node, target_value_ptr, prong_value);
	2402	var_value = var_is_ptr ? var_ptr_value : ir_build_load_ptr(irb, scope, var_symbol_node, var_ptr_value);
2396	2403	} else {
2397		var_value = var_is_ptr ? target_value_ptr : ir_build_load_ptr(irb, var_symbol_node, target_value_ptr);
	2404	var_value = var_is_ptr ? target_value_ptr : ir_build_load_ptr(irb, scope, var_symbol_node, target_value_ptr);
2398	2405	}
2399	2406	IrInstruction *var_type = nullptr; // infer the type
2400		ir_build_var_decl(irb, var_symbol_node, var, var_type, var_value);
	2407	ir_build_var_decl(irb, scope, var_symbol_node, var, var_type, var_value);
2401	2408	} else {
2402		child_scope = switch_node->scope;
	2409	child_scope = scope;
2403	2410	}
2404	2411
2405	2412	IrInstruction *expr_result = ir_gen_node(irb, expr_node, child_scope);
2406	2413	if (expr_result == irb->codegen->invalid_instruction)
2407	2414	return false;
2408		ir_build_br(irb, switch_node, end_block, is_inline);
	2415	ir_build_br(irb, scope, switch_node, end_block, is_inline);
2409	2416	incoming_blocks->append(irb->current_basic_block);
2410	2417	incoming_values->append(expr_result);
2411	2418	return true;
2412	2419	}
2413	2420
2414		static IrInstruction ir_gen_switch_expr(IrBuilder irb, AstNode *node) {
	2421	static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode node) {
2415	2422	assert(node->type == NodeTypeSwitchExpr);
2416	2423
2417	2424	AstNode *target_node = node->data.switch_expr.expr;
2418		IrInstruction *target_value_ptr = ir_gen_node_extra(irb, target_node, node->scope, LValPurposeAddressOf);
	2425	IrInstruction *target_value_ptr = ir_gen_node_extra(irb, target_node, scope, LValPurposeAddressOf);
2419	2426	if (target_value_ptr == irb->codegen->invalid_instruction)
2420	2427	return target_value_ptr;
2421		IrInstruction *target_value = ir_build_switch_target(irb, node, target_value_ptr);
	2428	IrInstruction *target_value = ir_build_switch_target(irb, scope, node, target_value_ptr);
2422	2429
2423	2430	IrBasicBlock *else_block = ir_build_basic_block(irb, "SwitchElse");
2424	2431	IrBasicBlock *end_block = ir_build_basic_block(irb, "SwitchEnd");
...	...	@@ -2446,7 +2453,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, AstNode *node) {
2446	2453
2447	2454	IrBasicBlock *prev_block = irb->current_basic_block;
2448	2455	ir_set_cursor_at_end(irb, else_block);
2449		if (!ir_gen_switch_prong_expr(irb, node, prong_node, end_block,
	2456	if (!ir_gen_switch_prong_expr(irb, scope, node, prong_node, end_block,
2450	2457	is_inline, target_value_ptr, nullptr, &incoming_blocks, &incoming_values))
2451	2458	{
2452	2459	return irb->codegen->invalid_instruction;
...	...	@@ -2460,41 +2467,40 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, AstNode *node) {
2460	2467	AstNode *item_node = prong_node->data.switch_prong.items.at(item_i);
2461	2468	last_item_node = item_node;
2462	2469	if (item_node->type == NodeTypeSwitchRange) {
2463		item_node->scope = node->scope;
2464	2470	AstNode *start_node = item_node->data.switch_range.start;
2465	2471	AstNode *end_node = item_node->data.switch_range.end;
2466	2472
2467		IrInstruction *start_value = ir_gen_node(irb, start_node, node->scope);
	2473	IrInstruction *start_value = ir_gen_node(irb, start_node, scope);
2468	2474	if (start_value == irb->codegen->invalid_instruction)
2469	2475	return irb->codegen->invalid_instruction;
2470	2476
2471		IrInstruction *end_value = ir_gen_node(irb, end_node, node->scope);
	2477	IrInstruction *end_value = ir_gen_node(irb, end_node, scope);
2472	2478	if (end_value == irb->codegen->invalid_instruction)
2473	2479	return irb->codegen->invalid_instruction;
2474	2480
2475		IrInstruction *start_value_const = ir_build_static_eval(irb, start_node, start_value);
2476		IrInstruction *end_value_const = ir_build_static_eval(irb, start_node, end_value);
	2481	IrInstruction *start_value_const = ir_build_static_eval(irb, scope, start_node, start_value);
	2482	IrInstruction *end_value_const = ir_build_static_eval(irb, scope, start_node, end_value);
2477	2483
2478		IrInstruction *lower_range_ok = ir_build_bin_op(irb, item_node, IrBinOpCmpGreaterOrEq,
	2484	IrInstruction *lower_range_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpGreaterOrEq,
2479	2485	target_value, start_value_const);
2480		IrInstruction *upper_range_ok = ir_build_bin_op(irb, item_node, IrBinOpCmpLessOrEq,
	2486	IrInstruction *upper_range_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpLessOrEq,
2481	2487	target_value, end_value_const);
2482		IrInstruction *both_ok = ir_build_bin_op(irb, item_node, IrBinOpBoolAnd,
	2488	IrInstruction *both_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpBoolAnd,
2483	2489	lower_range_ok, upper_range_ok);
2484	2490	if (ok_bit) {
2485		ok_bit = ir_build_bin_op(irb, item_node, IrBinOpBoolOr, both_ok, ok_bit);
	2491	ok_bit = ir_build_bin_op(irb, scope, item_node, IrBinOpBoolOr, both_ok, ok_bit);
2486	2492	} else {
2487	2493	ok_bit = both_ok;
2488	2494	}
2489	2495	} else {
2490		IrInstruction *item_value = ir_gen_node(irb, item_node, node->scope);
	2496	IrInstruction *item_value = ir_gen_node(irb, item_node, scope);
2491	2497	if (item_value == irb->codegen->invalid_instruction)
2492	2498	return irb->codegen->invalid_instruction;
2493	2499
2494		IrInstruction *cmp_ok = ir_build_bin_op(irb, item_node, IrBinOpCmpEq,
	2500	IrInstruction *cmp_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpEq,
2495	2501	item_value, target_value);
2496	2502	if (ok_bit) {
2497		ok_bit = ir_build_bin_op(irb, item_node, IrBinOpBoolOr, cmp_ok, ok_bit);
	2503	ok_bit = ir_build_bin_op(irb, scope, item_node, IrBinOpBoolOr, cmp_ok, ok_bit);
2498	2504	} else {
2499	2505	ok_bit = cmp_ok;
2500	2506	}
...	...	@@ -2506,10 +2512,10 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, AstNode *node) {
2506	2512
2507	2513	assert(ok_bit);
2508	2514	assert(last_item_node);
2509		ir_build_cond_br(irb, last_item_node, ok_bit, range_block_yes, range_block_no, is_inline);
	2515	ir_build_cond_br(irb, scope, last_item_node, ok_bit, range_block_yes, range_block_no, is_inline);
2510	2516
2511	2517	ir_set_cursor_at_end(irb, range_block_yes);
2512		if (!ir_gen_switch_prong_expr(irb, node, prong_node, end_block,
	2518	if (!ir_gen_switch_prong_expr(irb, scope, node, prong_node, end_block,
2513	2519	is_inline, target_value_ptr, nullptr, &incoming_blocks, &incoming_values))
2514	2520	{
2515	2521	return irb->codegen->invalid_instruction;
...	...	@@ -2524,7 +2530,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, AstNode *node) {
2524	2530	AstNode *item_node = prong_node->data.switch_prong.items.at(item_i);
2525	2531	assert(item_node->type != NodeTypeSwitchRange);
2526	2532
2527		IrInstruction *item_value = ir_gen_node(irb, item_node, node->scope);
	2533	IrInstruction *item_value = ir_gen_node(irb, item_node, scope);
2528	2534	if (item_value == irb->codegen->invalid_instruction)
2529	2535	return irb->codegen->invalid_instruction;
2530	2536
...	...	@@ -2538,7 +2544,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, AstNode *node) {
2538	2544
2539	2545	IrBasicBlock *prev_block = irb->current_basic_block;
2540	2546	ir_set_cursor_at_end(irb, prong_block);
2541		if (!ir_gen_switch_prong_expr(irb, node, prong_node, end_block,
	2547	if (!ir_gen_switch_prong_expr(irb, scope, node, prong_node, end_block,
2542	2548	is_inline, target_value_ptr, only_item_value, &incoming_blocks, &incoming_values))
2543	2549	{
2544	2550	return irb->codegen->invalid_instruction;
...	...	@@ -2551,19 +2557,19 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, AstNode *node) {
2551	2557	}
2552	2558
2553	2559	if (cases.length == 0) {
2554		ir_build_br(irb, node, else_block, is_inline);
	2560	ir_build_br(irb, scope, node, else_block, is_inline);
2555	2561	} else {
2556		ir_build_switch_br(irb, node, target_value, else_block, cases.length, cases.items, is_inline);
	2562	ir_build_switch_br(irb, scope, node, target_value, else_block, cases.length, cases.items, is_inline);
2557	2563	}
2558	2564
2559	2565	if (!else_prong) {
2560	2566	ir_set_cursor_at_end(irb, else_block);
2561		ir_build_unreachable(irb, node);
	2567	ir_build_unreachable(irb, scope, node);
2562	2568	}
2563	2569
2564	2570	ir_set_cursor_at_end(irb, end_block);
2565	2571	assert(incoming_blocks.length == incoming_values.length);
2566		return ir_build_phi(irb, node, incoming_blocks.length, incoming_blocks.items, incoming_values.items);
	2572	return ir_build_phi(irb, scope, node, incoming_blocks.length, incoming_blocks.items, incoming_values.items);
2567	2573	}
2568	2574
2569	2575	static LabelTableEntry find_label(IrExecutable exec, Scope scope, Buf name) {
...	...	@@ -2589,7 +2595,7 @@ static ScopeBlock find_block_scope(IrExecutable exec, Scope *scope) {
2589	2595	return nullptr;
2590	2596	}
2591	2597
2592		static IrInstruction ir_gen_label(IrBuilder irb, AstNode *node) {
	2598	static IrInstruction ir_gen_label(IrBuilder irb, Scope scope, AstNode node) {
2593	2599	assert(node->type == NodeTypeLabel);
2594	2600
2595	2601	Buf *label_name = node->data.label.name;
...	...	@@ -2599,35 +2605,38 @@ static IrInstruction ir_gen_label(IrBuilder irb, AstNode *node) {
2599	2605	label->bb = label_block;
2600	2606	irb->exec->all_labels.append(label);
2601	2607
2602		LabelTableEntry *existing_label = find_label(irb->exec, node->scope, label_name);
	2608	LabelTableEntry *existing_label = find_label(irb->exec, scope, label_name);
2603	2609	if (existing_label) {
2604	2610	ErrorMsg *msg = add_node_error(irb->codegen, node,
2605	2611	buf_sprintf("duplicate label name '%s'", buf_ptr(label_name)));
2606	2612	add_error_note(irb->codegen, msg, existing_label->decl_node, buf_sprintf("other label here"));
2607	2613	return irb->codegen->invalid_instruction;
2608	2614	} else {
2609		ScopeBlock *scope_block = find_block_scope(irb->exec, node->scope);
	2615	ScopeBlock *scope_block = find_block_scope(irb->exec, scope);
2610	2616	scope_block->label_table.put(label_name, label);
2611	2617	}
2612	2618
2613	2619	bool is_inline = ir_should_inline(irb);
2614		ir_build_br(irb, node, label_block, is_inline);
	2620	ir_build_br(irb, scope, node, label_block, is_inline);
2615	2621	ir_set_cursor_at_end(irb, label_block);
2616		return ir_build_const_void(irb, node);
	2622	return ir_build_const_void(irb, scope, node);
2617	2623	}
2618	2624
2619		static IrInstruction ir_gen_goto(IrBuilder irb, AstNode *node) {
	2625	static IrInstruction ir_gen_goto(IrBuilder irb, Scope scope, AstNode node) {
2620	2626	assert(node->type == NodeTypeGoto);
2621	2627
2622	2628	// make a placeholder unreachable statement and a note to come back and
2623	2629	// replace the instruction with a branch instruction
2624		node->data.goto_expr.bb = irb->current_basic_block;
2625		node->data.goto_expr.instruction_index = irb->current_basic_block->instruction_list.length;
2626		irb->exec->goto_list.append(node);
2627		return ir_build_unreachable(irb, node);
	2630	IrGotoItem *goto_item = irb->exec->goto_list.add_one();
	2631	goto_item->bb = irb->current_basic_block;
	2632	goto_item->instruction_index = irb->current_basic_block->instruction_list.length;
	2633	goto_item->source_node = node;
	2634	goto_item->scope = scope;
	2635
	2636	return ir_build_unreachable(irb, scope, node);
2628	2637	}
2629	2638
2630		static IrInstruction ir_lval_wrap(IrBuilder irb, IrInstruction *value, LValPurpose lval) {
	2639	static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction value, LValPurpose lval) {
2631	2640	if (lval == LValPurposeNone)
2632	2641	return value;
2633	2642	if (value == irb->codegen->invalid_instruction)
...	...	@@ -2635,75 +2644,73 @@ static IrInstruction ir_lval_wrap(IrBuilder irb, IrInstruction *value, LValPur
2635	2644
2636	2645	// We needed a pointer to a value, but we got a value. So we create
2637	2646	// an instruction which just makes a const pointer of it.
2638		return ir_build_ref(irb, value->source_node, value);
	2647	return ir_build_ref(irb, scope, value->source_node, value);
2639	2648	}
2640	2649
2641		static IrInstruction ir_gen_type_literal(IrBuilder irb, AstNode *node) {
	2650	static IrInstruction ir_gen_type_literal(IrBuilder irb, Scope scope, AstNode node) {
2642	2651	assert(node->type == NodeTypeTypeLiteral);
2643		return ir_build_const_type(irb, node, irb->codegen->builtin_types.entry_type);
	2652	return ir_build_const_type(irb, scope, node, irb->codegen->builtin_types.entry_type);
2644	2653	}
2645	2654
2646	2655	static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scope,
2647	2656	LValPurpose lval)
2648	2657	{
2649	2658	assert(scope);
2650		node->scope = scope;
2651
2652	2659	switch (node->type) {
2653	2660	case NodeTypeStructValueField:
2654	2661	zig_unreachable();
2655	2662	case NodeTypeBlock:
2656		return ir_lval_wrap(irb, ir_gen_block(irb, node), lval);
	2663	return ir_lval_wrap(irb, scope, ir_gen_block(irb, scope, node), lval);
2657	2664	case NodeTypeBinOpExpr:
2658		return ir_lval_wrap(irb, ir_gen_bin_op(irb, node), lval);
	2665	return ir_lval_wrap(irb, scope, ir_gen_bin_op(irb, scope, node), lval);
2659	2666	case NodeTypeNumberLiteral:
2660		return ir_lval_wrap(irb, ir_gen_num_lit(irb, node), lval);
	2667	return ir_lval_wrap(irb, scope, ir_gen_num_lit(irb, scope, node), lval);
2661	2668	case NodeTypeSymbol:
2662		return ir_gen_symbol(irb, node, lval);
	2669	return ir_gen_symbol(irb, scope, node, lval);
2663	2670	case NodeTypeFnCallExpr:
2664		return ir_lval_wrap(irb, ir_gen_fn_call(irb, node), lval);
	2671	return ir_lval_wrap(irb, scope, ir_gen_fn_call(irb, scope, node), lval);
2665	2672	case NodeTypeIfBoolExpr:
2666		return ir_lval_wrap(irb, ir_gen_if_bool_expr(irb, node), lval);
	2673	return ir_lval_wrap(irb, scope, ir_gen_if_bool_expr(irb, scope, node), lval);
2667	2674	case NodeTypePrefixOpExpr:
2668		return ir_gen_prefix_op_expr(irb, node, lval);
	2675	return ir_gen_prefix_op_expr(irb, scope, node, lval);
2669	2676	case NodeTypeContainerInitExpr:
2670		return ir_lval_wrap(irb, ir_gen_container_init_expr(irb, node), lval);
	2677	return ir_lval_wrap(irb, scope, ir_gen_container_init_expr(irb, scope, node), lval);
2671	2678	case NodeTypeVariableDeclaration:
2672		return ir_lval_wrap(irb, ir_gen_var_decl(irb, node), lval);
	2679	return ir_lval_wrap(irb, scope, ir_gen_var_decl(irb, scope, node), lval);
2673	2680	case NodeTypeWhileExpr:
2674		return ir_lval_wrap(irb, ir_gen_while_expr(irb, node), lval);
	2681	return ir_lval_wrap(irb, scope, ir_gen_while_expr(irb, scope, node), lval);
2675	2682	case NodeTypeForExpr:
2676		return ir_lval_wrap(irb, ir_gen_for_expr(irb, node), lval);
	2683	return ir_lval_wrap(irb, scope, ir_gen_for_expr(irb, scope, node), lval);
2677	2684	case NodeTypeArrayAccessExpr:
2678		return ir_gen_array_access(irb, node, lval);
	2685	return ir_gen_array_access(irb, scope, node, lval);
2679	2686	case NodeTypeReturnExpr:
2680		return ir_lval_wrap(irb, ir_gen_return(irb, node), lval);
	2687	return ir_lval_wrap(irb, scope, ir_gen_return(irb, scope, node), lval);
2681	2688	case NodeTypeFieldAccessExpr:
2682		return ir_gen_field_access(irb, node, lval);
	2689	return ir_gen_field_access(irb, scope, node, lval);
2683	2690	case NodeTypeThisLiteral:
2684		return ir_lval_wrap(irb, ir_gen_this_literal(irb, node), lval);
	2691	return ir_lval_wrap(irb, scope, ir_gen_this_literal(irb, scope, node), lval);
2685	2692	case NodeTypeBoolLiteral:
2686		return ir_lval_wrap(irb, ir_gen_bool_literal(irb, node), lval);
	2693	return ir_lval_wrap(irb, scope, ir_gen_bool_literal(irb, scope, node), lval);
2687	2694	case NodeTypeArrayType:
2688		return ir_lval_wrap(irb, ir_gen_array_type(irb, node), lval);
	2695	return ir_lval_wrap(irb, scope, ir_gen_array_type(irb, scope, node), lval);
2689	2696	case NodeTypeStringLiteral:
2690		return ir_lval_wrap(irb, ir_gen_string_literal(irb, node), lval);
	2697	return ir_lval_wrap(irb, scope, ir_gen_string_literal(irb, scope, node), lval);
2691	2698	case NodeTypeUndefinedLiteral:
2692		return ir_lval_wrap(irb, ir_gen_undefined_literal(irb, node), lval);
	2699	return ir_lval_wrap(irb, scope, ir_gen_undefined_literal(irb, scope, node), lval);
2693	2700	case NodeTypeAsmExpr:
2694		return ir_lval_wrap(irb, ir_gen_asm_expr(irb, node), lval);
	2701	return ir_lval_wrap(irb, scope, ir_gen_asm_expr(irb, scope, node), lval);
2695	2702	case NodeTypeNullLiteral:
2696		return ir_lval_wrap(irb, ir_gen_null_literal(irb, node), lval);
	2703	return ir_lval_wrap(irb, scope, ir_gen_null_literal(irb, scope, node), lval);
2697	2704	case NodeTypeIfVarExpr:
2698		return ir_lval_wrap(irb, ir_gen_if_var_expr(irb, node), lval);
	2705	return ir_lval_wrap(irb, scope, ir_gen_if_var_expr(irb, scope, node), lval);
2699	2706	case NodeTypeSwitchExpr:
2700		return ir_lval_wrap(irb, ir_gen_switch_expr(irb, node), lval);
	2707	return ir_lval_wrap(irb, scope, ir_gen_switch_expr(irb, scope, node), lval);
2701	2708	case NodeTypeLabel:
2702		return ir_lval_wrap(irb, ir_gen_label(irb, node), lval);
	2709	return ir_lval_wrap(irb, scope, ir_gen_label(irb, scope, node), lval);
2703	2710	case NodeTypeGoto:
2704		return ir_lval_wrap(irb, ir_gen_goto(irb, node), lval);
	2711	return ir_lval_wrap(irb, scope, ir_gen_goto(irb, scope, node), lval);
2705	2712	case NodeTypeTypeLiteral:
2706		return ir_lval_wrap(irb, ir_gen_type_literal(irb, node), lval);
	2713	return ir_lval_wrap(irb, scope, ir_gen_type_literal(irb, scope, node), lval);
2707	2714	case NodeTypeUnwrapErrorExpr:
2708	2715	case NodeTypeDefer:
2709	2716	case NodeTypeSliceExpr:
...	...	@@ -2744,22 +2751,23 @@ static IrInstruction ir_gen_node(IrBuilder irb, AstNode node, Scope scope) {
2744	2751
2745	2752	static bool ir_goto_pass2(IrBuilder *irb) {
2746	2753	for (size_t i = 0; i < irb->exec->goto_list.length; i += 1) {
2747		AstNode *goto_node = irb->exec->goto_list.at(i);
2748		size_t instruction_index = goto_node->data.goto_expr.instruction_index;
2749		IrInstruction **slot = &goto_node->data.goto_expr.bb->instruction_list.at(instruction_index);
	2754	IrGotoItem *goto_item = &irb->exec->goto_list.at(i);
	2755	AstNode *source_node = goto_item->source_node;
	2756	size_t instruction_index = goto_item->instruction_index;
	2757	IrInstruction **slot = &goto_item->bb->instruction_list.at(instruction_index);
2750	2758	IrInstruction old_instruction = slot;
2751	2759
2752		Buf *label_name = goto_node->data.goto_expr.name;
2753		LabelTableEntry *label = find_label(irb->exec, goto_node->scope, label_name);
	2760	Buf *label_name = source_node->data.goto_expr.name;
	2761	LabelTableEntry *label = find_label(irb->exec, goto_item->scope, label_name);
2754	2762	if (!label) {
2755		add_node_error(irb->codegen, goto_node,
	2763	add_node_error(irb->codegen, source_node,
2756	2764	buf_sprintf("no label in scope named '%s'", buf_ptr(label_name)));
2757	2765	return false;
2758	2766	}
2759	2767	label->used = true;
2760	2768
2761		bool is_inline = ir_should_inline(irb) \|\| goto_node->data.goto_expr.is_inline;
2762		IrInstruction *new_instruction = ir_create_br(irb, goto_node, label->bb, is_inline);
	2769	bool is_inline = ir_should_inline(irb) \|\| source_node->data.goto_expr.is_inline;
	2770	IrInstruction *new_instruction = ir_create_br(irb, goto_item->scope, source_node, label->bb, is_inline);
2763	2771	new_instruction->ref_count = old_instruction->ref_count;
2764	2772	*slot = new_instruction;
2765	2773	}
...	...	@@ -2795,7 +2803,7 @@ IrInstruction ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutabl
2795	2803	if (irb->exec->invalid)
2796	2804	return codegen->invalid_instruction;
2797	2805
2798		IrInstruction *return_instruction = ir_build_return(irb, result->source_node, result);
	2806	IrInstruction *return_instruction = ir_build_return(irb, scope, result->source_node, result);
2799	2807	assert(return_instruction);
2800	2808
2801	2809	if (!ir_goto_pass2(irb)) {
...	...	@@ -2814,21 +2822,27 @@ IrInstruction ir_gen_fn(CodeGen codegn, FnTableEntry *fn_entry) {
2814	2822	assert(fn_def_node->type == NodeTypeFnDef);
2815	2823
2816	2824	AstNode *body_node = fn_def_node->data.fn_def.body;
2817		Scope *child_scope = fn_def_node->data.fn_def.child_scope;
	2825
	2826	assert(fn_entry->child_scope);
	2827	Scope *child_scope = fn_entry->child_scope;
2818	2828
2819	2829	return ir_gen(codegn, body_node, child_scope, ir_executable);
2820	2830	}
2821	2831
	2832	static ErrorMsg ir_add_error(IrAnalyze ira, IrInstruction source_instruction, Buf msg) {
	2833	return add_node_error(ira->codegen, source_instruction->source_node, msg);
	2834	}
	2835
2822	2836	static IrInstruction ir_eval_fn(IrAnalyze ira, IrInstruction *source_instruction,
2823	2837	size_t arg_count, IrInstruction **args)
2824	2838	{
	2839	// TODO count this as part of the backward branch quota
2825	2840	zig_panic("TODO ir_eval_fn");
2826	2841	}
2827	2842
2828	2843	static bool ir_emit_global_runtime_side_effect(IrAnalyze ira, IrInstruction source_instruction) {
2829	2844	if (ir_should_inline(&ira->new_irb)) {
2830		add_node_error(ira->codegen, source_instruction->source_node,
2831		buf_sprintf("unable to evaluate constant expression"));
	2845	ir_add_error(ira, source_instruction, buf_sprintf("unable to evaluate constant expression"));
2832	2846	return false;
2833	2847	}
2834	2848	return true;
...	...	@@ -2863,7 +2877,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
2863	2877
2864	2878	const char *num_lit_str = (const_val->data.x_bignum.kind == BigNumKindFloat) ? "float" : "integer";
2865	2879
2866		add_node_error(ira->codegen, instruction->source_node,
	2880	ir_add_error(ira, instruction,
2867	2881	buf_sprintf("%s value %s cannot be implicitly casted to type '%s'",
2868	2882	num_lit_str,
2869	2883	buf_ptr(bignum_to_buf(&const_val->data.x_bignum)),
...	...	@@ -3052,15 +3066,15 @@ static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction *source_inst
3052	3066	TypeTableEntry *wanted_type, CastOp cast_op, bool need_alloca)
3053	3067	{
3054	3068	if (value->static_value.special != ConstValSpecialRuntime) {
3055		IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->source_node, wanted_type, false);
	3069	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope, source_instr->source_node, wanted_type, false);
3056	3070	eval_const_expr_implicit_cast(cast_op, &value->static_value, value->type_entry,
3057	3071	&result->static_value, wanted_type);
3058	3072	return result;
3059	3073	} else {
3060		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->source_node, wanted_type, value, cast_op);
	3074	IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node, wanted_type, value, cast_op);
3061	3075	result->type_entry = wanted_type;
3062	3076	if (need_alloca) {
3063		FnTableEntry *fn_entry = scope_fn_entry(source_instr->source_node->scope);
	3077	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
3064	3078	if (fn_entry)
3065	3079	fn_entry->alloca_list.append(result);
3066	3080	}
...	...	@@ -3153,20 +3167,20 @@ static ConstExprValue ir_build_const_from(IrAnalyze ira, IrInstruction *old_in
3153	3167	if (old_instruction->id == IrInstructionIdVarPtr) {
3154	3168	IrInstructionVarPtr old_var_ptr_instruction = (IrInstructionVarPtr )old_instruction;
3155	3169	IrInstructionVarPtr *var_ptr_instruction = ir_create_instruction<IrInstructionVarPtr>(ira->new_irb.exec,
3156		old_instruction->source_node);
	3170	old_instruction->scope, old_instruction->source_node);
3157	3171	var_ptr_instruction->var = old_var_ptr_instruction->var;
3158	3172	new_instruction = &var_ptr_instruction->base;
3159	3173	} else if (old_instruction->id == IrInstructionIdFieldPtr) {
3160	3174	IrInstructionFieldPtr *field_ptr_instruction = ir_create_instruction<IrInstructionFieldPtr>(ira->new_irb.exec,
3161		old_instruction->source_node);
	3175	old_instruction->scope, old_instruction->source_node);
3162	3176	new_instruction = &field_ptr_instruction->base;
3163	3177	} else if (old_instruction->id == IrInstructionIdElemPtr) {
3164	3178	IrInstructionElemPtr *elem_ptr_instruction = ir_create_instruction<IrInstructionElemPtr>(ira->new_irb.exec,
3165		old_instruction->source_node);
	3179	old_instruction->scope, old_instruction->source_node);
3166	3180	new_instruction = &elem_ptr_instruction->base;
3167	3181	} else {
3168	3182	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
3169		old_instruction->source_node);
	3183	old_instruction->scope, old_instruction->source_node);
3170	3184	new_instruction = &const_instruction->base;
3171	3185	}
3172	3186	ir_link_new_instruction(new_instruction, old_instruction);
...	...	@@ -3553,13 +3567,13 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
3553	3567	if (ptr->static_value.special != ConstValSpecialRuntime) {
3554	3568	ConstExprValue *pointee = const_ptr_pointee(&ptr->static_value);
3555	3569	if (pointee->special != ConstValSpecialRuntime) {
3556		IrInstruction *result = ir_create_const(&ira->new_irb, source_instruction->source_node,
3557		child_type, pointee->depends_on_compile_var);
	3570	IrInstruction *result = ir_create_const(&ira->new_irb, source_instruction->scope,
	3571	source_instruction->source_node, child_type, pointee->depends_on_compile_var);
3558	3572	result->static_value = *pointee;
3559	3573	return result;
3560	3574	}
3561	3575	}
3562		IrInstruction *load_ptr_instruction = ir_build_load_ptr(&ira->new_irb, source_instruction->source_node, ptr);
	3576	IrInstruction *load_ptr_instruction = ir_build_load_ptr(&ira->new_irb, source_instruction->scope, source_instruction->source_node, ptr);
3563	3577	load_ptr_instruction->type_entry = child_type;
3564	3578	return load_ptr_instruction;
3565	3579	} else {
...	...	@@ -3588,7 +3602,7 @@ static TypeTableEntry ir_analyze_ref(IrAnalyze ira, IrInstruction *source_inst
3588	3602	ir_link_new_instruction(value, source_instruction);
3589	3603	return ptr_type;
3590	3604	} else {
3591		FnTableEntry *fn_entry = scope_fn_entry(source_instruction->source_node->scope);
	3605	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
3592	3606	assert(fn_entry);
3593	3607	IrInstruction *new_instruction = ir_build_ref_from(&ira->new_irb, source_instruction, value);
3594	3608	fn_entry->alloca_list.append(new_instruction);
...	...	@@ -3754,7 +3768,6 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
3754	3768	case TypeTableEntryIdTypeDecl:
3755	3769	case TypeTableEntryIdNamespace:
3756	3770	case TypeTableEntryIdBlock:
3757		case TypeTableEntryIdGenericFn:
3758	3771	case TypeTableEntryIdBoundFn:
3759	3772	if (!is_equality_cmp) {
3760	3773	add_node_error(ira->codegen, source_node,
...	...	@@ -4057,7 +4070,7 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
4057	4070	}
4058	4071
4059	4072	AstNodeVariableDeclaration *variable_declaration = &var->decl_node->data.variable_declaration;
4060		bool is_export = (variable_declaration->top_level_decl.visib_mod == VisibModExport);
	4073	bool is_export = (variable_declaration->visib_mod == VisibModExport);
4061	4074	bool is_extern = variable_declaration->is_extern;
4062	4075
4063	4076	var->ref_count = 0;
...	...	@@ -4119,7 +4132,6 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
4119	4132	case TypeTableEntryIdEnum:
4120	4133	case TypeTableEntryIdUnion:
4121	4134	case TypeTableEntryIdFn:
4122		case TypeTableEntryIdGenericFn:
4123	4135	case TypeTableEntryIdBoundFn:
4124	4136	// OK
4125	4137	break;
...	...	@@ -4136,8 +4148,7 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
4136	4148
4137	4149	ir_build_var_decl_from(&ira->new_irb, &decl_var_instruction->base, var, var_type, casted_init_value);
4138	4150
4139		Scope *scope = decl_var_instruction->base.source_node->scope;
4140		FnTableEntry *fn_entry = scope_fn_entry(scope);
	4151	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
4141	4152	if (fn_entry)
4142	4153	fn_entry->variable_list.append(var);
4143	4154
...	...	@@ -4241,7 +4252,7 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
4241	4252	fn_entry, fn_ref, call_param_count, casted_args);
4242	4253
4243	4254	if (type_has_bits(return_type) && handle_is_ptr(return_type)) {
4244		FnTableEntry *fn_entry = scope_fn_entry(call_instruction->base.source_node->scope);
	4255	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
4245	4256	assert(fn_entry);
4246	4257	fn_entry->alloca_list.append(new_call_instruction);
4247	4258	}
...	...	@@ -4288,8 +4299,6 @@ static TypeTableEntry ir_analyze_instruction_call(IrAnalyze ira, IrInstruction
4288	4299	IrInstruction *first_arg_ptr = fn_ref->static_value.data.x_bound_fn.first_arg;
4289	4300	return ir_analyze_fn_call(ira, call_instruction, fn_table_entry, fn_table_entry->type_entry,
4290	4301	nullptr, first_arg_ptr, is_inline);
4291		} else if (fn_ref->type_entry->id == TypeTableEntryIdGenericFn) {
4292		zig_panic("TODO generic fn call");
4293	4302	} else {
4294	4303	add_node_error(ira->codegen, fn_ref->source_node,
4295	4304	buf_sprintf("type '%s' not a function", buf_ptr(&fn_ref->type_entry->name)));
...	...	@@ -4360,7 +4369,6 @@ static TypeTableEntry ir_analyze_unary_prefix_op_err(IrAnalyze ira, IrInstruct
4360	4369	case TypeTableEntryIdEnum:
4361	4370	case TypeTableEntryIdUnion:
4362	4371	case TypeTableEntryIdFn:
4363		case TypeTableEntryIdGenericFn:
4364	4372	case TypeTableEntryIdBoundFn:
4365	4373	{
4366	4374	ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base,
...	...	@@ -4409,7 +4417,6 @@ static TypeTableEntry ir_analyze_unary_address_of(IrAnalyze ira, IrInstruction
4409	4417	case TypeTableEntryIdBlock:
4410	4418	case TypeTableEntryIdUnreachable:
4411	4419	case TypeTableEntryIdVar:
4412		case TypeTableEntryIdGenericFn:
4413	4420	case TypeTableEntryIdBoundFn:
4414	4421	add_node_error(ira->codegen, un_op_instruction->base.source_node,
4415	4422	buf_sprintf("unable to get address of type '%s'", buf_ptr(&target_type->name)));
...	...	@@ -4508,7 +4515,6 @@ static TypeTableEntry ir_analyze_maybe(IrAnalyze ira, IrInstructionUnOp *un_op
4508	4515	case TypeTableEntryIdFn:
4509	4516	case TypeTableEntryIdNamespace:
4510	4517	case TypeTableEntryIdBlock:
4511		case TypeTableEntryIdGenericFn:
4512	4518	case TypeTableEntryIdBoundFn:
4513	4519	{
4514	4520	ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base,
...	...	@@ -4781,9 +4787,7 @@ static TypeTableEntry ir_analyze_var_ptr(IrAnalyze ira, IrInstruction *instruc
4781	4787	if (var->mem_slot_index != SIZE_MAX)
4782	4788	mem_slot = &ira->exec_context.mem_slot_list[var->mem_slot_index];
4783	4789	} else if (var->src_is_const) {
4784		AstNode *var_decl_node = var->decl_node;
4785		assert(var_decl_node->type == NodeTypeVariableDeclaration);
4786		mem_slot = &var_decl_node->data.variable_declaration.top_level_decl.value->static_value;
	4790	mem_slot = var->value;
4787	4791	assert(mem_slot->special != ConstValSpecialRuntime);
4788	4792	}
4789	4793
...	...	@@ -4925,15 +4929,15 @@ static TypeTableEntry ir_analyze_container_member_access_inner(IrAnalyze ira,
4925	4929	if (!is_slice(bare_struct_type)) {
4926	4930	ScopeDecls *container_scope = get_container_scope(bare_struct_type);
4927	4931	auto entry = container_scope->decl_table.maybe_get(field_name);
4928		AstNode *fn_decl_node = entry ? entry->value : nullptr;
4929		if (fn_decl_node && fn_decl_node->type == NodeTypeFnProto) {
4930		resolve_top_level_decl(ira->codegen, fn_decl_node, false);
4931		TopLevelDecl *tld = get_as_top_level_decl(fn_decl_node);
	4932	Tld *tld = entry ? entry->value : nullptr;
	4933	if (tld && tld->id == TldIdFn) {
	4934	resolve_top_level_decl(ira->codegen, tld, false);
4932	4935	if (tld->resolution == TldResolutionInvalid)
4933	4936	return ira->codegen->builtin_types.entry_invalid;
4934		FnTableEntry *fn_entry = fn_decl_node->data.fn_proto.fn_table_entry;
	4937	TldFn tld_fn = (TldFn )tld;
	4938	FnTableEntry *fn_entry = tld_fn->fn_entry;
4935	4939	bool depends_on_compile_var = container_ptr->static_value.depends_on_compile_var;
4936		IrInstruction *bound_fn_value = ir_build_const_bound_fn(&ira->new_irb,
	4940	IrInstruction *bound_fn_value = ir_build_const_bound_fn(&ira->new_irb, field_ptr_instruction->base.scope,
4937	4941	field_ptr_instruction->base.source_node, fn_entry, container_ptr, depends_on_compile_var);
4938	4942	return ir_analyze_ref(ira, &field_ptr_instruction->base, bound_fn_value);
4939	4943	}
...	...	@@ -4976,53 +4980,63 @@ static TypeTableEntry ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field
4976	4980	}
4977	4981	}
4978	4982
4979		static TypeTableEntry ir_analyze_decl_ref(IrAnalyze ira, IrInstruction source_instruction, AstNode decl_node,
	4983	static TypeTableEntry ir_analyze_decl_ref(IrAnalyze ira, IrInstruction source_instruction, Tld tld,
4980	4984	bool depends_on_compile_var)
4981	4985	{
4982	4986	bool pointer_only = false;
4983		resolve_top_level_decl(ira->codegen, decl_node, pointer_only);
4984		TopLevelDecl *tld = get_as_top_level_decl(decl_node);
	4987	resolve_top_level_decl(ira->codegen, tld, pointer_only);
4985	4988	if (tld->resolution == TldResolutionInvalid)
4986	4989	return ira->codegen->builtin_types.entry_invalid;
4987	4990
4988		if (decl_node->type == NodeTypeVariableDeclaration) {
4989		VariableTableEntry *var = decl_node->data.variable_declaration.variable;
4990		return ir_analyze_var_ptr(ira, source_instruction, var);
4991		} else if (decl_node->type == NodeTypeFnProto) {
4992		FnTableEntry *fn_entry = decl_node->data.fn_proto.fn_table_entry;
4993		assert(fn_entry->type_entry);
4994
4995		// TODO instead of allocating this every time, put it in the tld value and we can reference
4996		// the same one every time
4997		ConstExprValue *const_val = allocate<ConstExprValue>(1);
4998		const_val->special = ConstValSpecialStatic;
4999		if (fn_entry->type_entry->id == TypeTableEntryIdGenericFn) {
5000		const_val->data.x_type = fn_entry->type_entry;
5001		} else {
	4991	switch (tld->id) {
	4992	case TldIdVar:
	4993	{
	4994	TldVar tld_var = (TldVar )tld;
	4995	VariableTableEntry *var = tld_var->var;
	4996	return ir_analyze_var_ptr(ira, source_instruction, var);
	4997	}
	4998	case TldIdFn:
	4999	{
	5000	TldFn tld_fn = (TldFn )tld;
	5001	FnTableEntry *fn_entry = tld_fn->fn_entry;
	5002	assert(fn_entry->type_entry);
	5003
	5004	// TODO instead of allocating this every time, put it in the tld value and we can reference
	5005	// the same one every time
	5006	ConstExprValue *const_val = allocate<ConstExprValue>(1);
	5007	const_val->special = ConstValSpecialStatic;
5002	5008	const_val->data.x_fn = fn_entry;
	5009
	5010	return ir_analyze_const_ptr(ira, source_instruction, const_val, fn_entry->type_entry, depends_on_compile_var);
5003	5011	}
	5012	case TldIdContainer:
	5013	{
	5014	TldContainer tld_container = (TldContainer )tld;
	5015	assert(tld_container->type_entry);
5004	5016
5005		return ir_analyze_const_ptr(ira, source_instruction, const_val, fn_entry->type_entry, depends_on_compile_var);
5006		} else if (decl_node->type == NodeTypeContainerDecl) {
5007		zig_panic("TODO");
5008		//ConstExprValue *out_val = ir_build_const_from(ira, source_instruction, depends_on_compile_var);
5009		//if (decl_node->data.struct_decl.generic_params.length > 0) {
5010		// TypeTableEntry *type_entry = decl_node->data.struct_decl.generic_fn_type;
5011		// assert(type_entry);
5012		// out_val->data.x_type = type_entry;
5013		// return type_entry;
5014		//} else {
5015		// out_val->data.x_type = decl_node->data.struct_decl.type_entry;
5016		// return ira->codegen->builtin_types.entry_type;
5017		//}
5018		} else if (decl_node->type == NodeTypeTypeDecl) {
5019		zig_panic("TODO");
5020		//ConstExprValue *out_val = ir_build_const_from(ira, source_instruction, depends_on_compile_var);
5021		//out_val->data.x_type = decl_node->data.type_decl.child_type_entry;
5022		//return ira->codegen->builtin_types.entry_type;
5023		} else {
5024		zig_unreachable();
	5017	// TODO instead of allocating this every time, put it in the tld value and we can reference
	5018	// the same one every time
	5019	ConstExprValue *const_val = allocate<ConstExprValue>(1);
	5020	const_val->special = ConstValSpecialStatic;
	5021	const_val->data.x_type = tld_container->type_entry;
	5022
	5023	return ir_analyze_const_ptr(ira, source_instruction, const_val, tld_container->type_entry, depends_on_compile_var);
	5024	}
	5025	case TldIdTypeDef:
	5026	{
	5027	TldTypeDef tld_typedef = (TldTypeDef )tld;
	5028	assert(tld_typedef->type_entry);
	5029
	5030	// TODO instead of allocating this every time, put it in the tld value and we can reference
	5031	// the same one every time
	5032	ConstExprValue *const_val = allocate<ConstExprValue>(1);
	5033	const_val->special = ConstValSpecialStatic;
	5034	const_val->data.x_type = tld_typedef->type_entry;
	5035
	5036	return ir_analyze_const_ptr(ira, source_instruction, const_val, tld_typedef->type_entry, depends_on_compile_var);
	5037	}
5025	5038	}
	5039	zig_unreachable();
5026	5040	}
5027	5041
5028	5042	static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFieldPtr *field_ptr_instruction) {
...	...	@@ -5068,10 +5082,10 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
5068	5082	} else if (child_type->id == TypeTableEntryIdStruct) {
5069	5083	ScopeDecls *container_scope = get_container_scope(child_type);
5070	5084	auto entry = container_scope->decl_table.maybe_get(field_name);
5071		AstNode *decl_node = entry ? entry->value : nullptr;
5072		if (decl_node) {
	5085	Tld *tld = entry ? entry->value : nullptr;
	5086	if (tld) {
5073	5087	bool depends_on_compile_var = container_ptr->static_value.depends_on_compile_var;
5074		return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, decl_node, depends_on_compile_var);
	5088	return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld, depends_on_compile_var);
5075	5089	} else {
5076	5090	add_node_error(ira->codegen, source_node,
5077	5091	buf_sprintf("container '%s' has no member called '%s'",
...	...	@@ -5098,30 +5112,29 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
5098	5112	ImportTableEntry *namespace_import = namespace_val->data.x_import;
5099	5113
5100	5114	bool depends_on_compile_var = container_ptr->static_value.depends_on_compile_var;
5101		AstNode *decl_node = find_decl(&namespace_import->decls_scope->base, field_name);
5102		if (!decl_node) {
	5115	Tld *tld = find_decl(&namespace_import->decls_scope->base, field_name);
	5116	if (!tld) {
5103	5117	// we must now resolve all the use decls
	5118	// TODO move this check to find_decl?
5104	5119	for (size_t i = 0; i < namespace_import->use_decls.length; i += 1) {
5105	5120	AstNode *use_decl_node = namespace_import->use_decls.at(i);
5106		TopLevelDecl *tld = get_as_top_level_decl(use_decl_node);
5107		if (tld->resolution == TldResolutionUnresolved) {
	5121	if (use_decl_node->data.use.resolution == TldResolutionUnresolved) {
5108	5122	preview_use_decl(ira->codegen, use_decl_node);
5109	5123	}
5110	5124	resolve_use_decl(ira->codegen, use_decl_node);
5111	5125	}
5112		decl_node = find_decl(&namespace_import->decls_scope->base, field_name);
	5126	tld = find_decl(&namespace_import->decls_scope->base, field_name);
5113	5127	}
5114		if (decl_node) {
5115		TopLevelDecl *tld = get_as_top_level_decl(decl_node);
	5128	if (tld) {
5116	5129	if (tld->visib_mod == VisibModPrivate &&
5117		decl_node->owner != source_node->owner)
	5130	tld->import != source_node->owner)
5118	5131	{
5119	5132	ErrorMsg *msg = add_node_error(ira->codegen, source_node,
5120	5133	buf_sprintf("'%s' is private", buf_ptr(field_name)));
5121		add_error_note(ira->codegen, msg, decl_node, buf_sprintf("declared here"));
	5134	add_error_note(ira->codegen, msg, tld->source_node, buf_sprintf("declared here"));
5122	5135	return ira->codegen->builtin_types.entry_invalid;
5123	5136	}
5124		return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, decl_node, depends_on_compile_var);
	5137	return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld, depends_on_compile_var);
5125	5138	} else {
5126	5139	const char *import_name = namespace_import->path ? buf_ptr(namespace_import->path) : "(C import)";
5127	5140	add_node_error(ira->codegen, source_node,
...	...	@@ -5176,7 +5189,8 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
5176	5189	if (ptr->id == IrInstructionIdVarPtr) {
5177	5190	IrInstructionVarPtr var_ptr_inst = (IrInstructionVarPtr )ptr;
5178	5191	VariableTableEntry *var = var_ptr_inst->var;
5179		new_ptr_inst = ir_build_var_ptr(&ira->new_irb, store_ptr_instruction->base.source_node, var);
	5192	new_ptr_inst = ir_build_var_ptr(&ira->new_irb, store_ptr_instruction->base.scope,
	5193	store_ptr_instruction->base.source_node, var);
5180	5194	assert(var->mem_slot_index != SIZE_MAX);
5181	5195	ConstExprValue *mem_slot = &ira->exec_context.mem_slot_list[var->mem_slot_index];
5182	5196	mem_slot->special = ConstValSpecialRuntime;
...	...	@@ -5188,7 +5202,8 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
5188	5202	zig_unreachable();
5189	5203	}
5190	5204	new_ptr_inst->type_entry = ptr->type_entry;
5191		ir_build_store_ptr(&ira->new_irb, store_ptr_instruction->base.source_node, new_ptr_inst, casted_value);
	5205	ir_build_store_ptr(&ira->new_irb, store_ptr_instruction->base.scope,
	5206	store_ptr_instruction->base.source_node, new_ptr_inst, casted_value);
5192	5207	return ir_analyze_void(ira, &store_ptr_instruction->base);
5193	5208	}
5194	5209
...	...	@@ -5212,7 +5227,6 @@ static TypeTableEntry ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructi
5212	5227	case TypeTableEntryIdNullLit:
5213	5228	case TypeTableEntryIdNamespace:
5214	5229	case TypeTableEntryIdBlock:
5215		case TypeTableEntryIdGenericFn:
5216	5230	case TypeTableEntryIdBoundFn:
5217	5231	case TypeTableEntryIdMetaType:
5218	5232	case TypeTableEntryIdVoid:
...	...	@@ -5342,14 +5356,13 @@ static TypeTableEntry ir_analyze_instruction_set_fn_visible(IrAnalyze ira,
5342	5356	fn_entry->fn_export_set_node = source_node;
5343	5357
5344	5358	AstNodeFnProto *fn_proto = &fn_entry->proto_node->data.fn_proto;
5345		if (fn_proto->top_level_decl.visib_mod != VisibModExport) {
	5359	if (fn_proto->visib_mod != VisibModExport) {
5346	5360	ErrorMsg *msg = add_node_error(ira->codegen, source_node,
5347	5361	buf_sprintf("function must be marked export to set function visibility"));
5348	5362	add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("function declared here"));
5349	5363	return ira->codegen->builtin_types.entry_invalid;
5350	5364	}
5351		if (!want_export)
5352		LLVMSetLinkage(fn_entry->fn_value, LLVMInternalLinkage);
	5365	fn_entry->internal_linkage = !want_export;
5353	5366
5354	5367	ir_build_const_from(ira, &set_fn_visible_instruction->base, false);
5355	5368	return ira->codegen->builtin_types.entry_void;
...	...	@@ -5366,24 +5379,33 @@ static TypeTableEntry ir_analyze_instruction_set_debug_safety(IrAnalyze ira,
5366	5379	if (!target_val)
5367	5380	return ira->codegen->builtin_types.entry_invalid;
5368	5381
5369		Scope *target_context;
	5382	bool *safety_off_ptr;
	5383	AstNode **safety_set_node_ptr;
5370	5384	if (target_type->id == TypeTableEntryIdBlock) {
5371		target_context = target_val->data.x_block;
	5385	ScopeBlock block_scope = (ScopeBlock )target_val->data.x_block;
	5386	safety_off_ptr = &block_scope->safety_off;
	5387	safety_set_node_ptr = &block_scope->safety_set_node;
5372	5388	} else if (target_type->id == TypeTableEntryIdFn) {
5373		target_context = target_val->data.x_fn->fn_def_node->data.fn_def.child_scope;
	5389	FnTableEntry *target_fn = target_val->data.x_fn;
	5390	assert(target_fn->def_scope);
	5391	safety_off_ptr = &target_fn->def_scope->safety_off;
	5392	safety_set_node_ptr = &target_fn->def_scope->safety_set_node;
5374	5393	} else if (target_type->id == TypeTableEntryIdMetaType) {
	5394	ScopeDecls *decls_scope;
5375	5395	TypeTableEntry *type_arg = target_val->data.x_type;
5376	5396	if (type_arg->id == TypeTableEntryIdStruct) {
5377		target_context = &type_arg->data.structure.decls_scope->base;
	5397	decls_scope = type_arg->data.structure.decls_scope;
5378	5398	} else if (type_arg->id == TypeTableEntryIdEnum) {
5379		target_context = &type_arg->data.enumeration.decls_scope->base;
	5399	decls_scope = type_arg->data.enumeration.decls_scope;
5380	5400	} else if (type_arg->id == TypeTableEntryIdUnion) {
5381		target_context = &type_arg->data.unionation.decls_scope->base;
	5401	decls_scope = type_arg->data.unionation.decls_scope;
5382	5402	} else {
5383	5403	add_node_error(ira->codegen, target_instruction->source_node,
5384	5404	buf_sprintf("expected scope reference, found type '%s'", buf_ptr(&type_arg->name)));
5385	5405	return ira->codegen->builtin_types.entry_invalid;
5386	5406	}
	5407	safety_off_ptr = &decls_scope->safety_off;
	5408	safety_set_node_ptr = &decls_scope->safety_set_node;
5387	5409	} else {
5388	5410	add_node_error(ira->codegen, target_instruction->source_node,
5389	5411	buf_sprintf("expected scope reference, found type '%s'", buf_ptr(&target_type->name)));
...	...	@@ -5396,14 +5418,14 @@ static TypeTableEntry ir_analyze_instruction_set_debug_safety(IrAnalyze ira,
5396	5418	return ira->codegen->builtin_types.entry_invalid;
5397	5419
5398	5420	AstNode *source_node = set_debug_safety_instruction->base.source_node;
5399		if (target_context->safety_set_node) {
	5421	if (*safety_set_node_ptr) {
5400	5422	ErrorMsg *msg = add_node_error(ira->codegen, source_node,
5401	5423	buf_sprintf("function test attribute set twice"));
5402		add_error_note(ira->codegen, msg, target_context->safety_set_node, buf_sprintf("first set here"));
	5424	add_error_note(ira->codegen, msg, *safety_set_node_ptr, buf_sprintf("first set here"));
5403	5425	return ira->codegen->builtin_types.entry_invalid;
5404	5426	}
5405		target_context->safety_set_node = source_node;
5406		target_context->safety_off = !want_debug_safety;
	5427	*safety_set_node_ptr = source_node;
	5428	*safety_off_ptr = !want_debug_safety;
5407	5429
5408	5430	ir_build_const_from(ira, &set_debug_safety_instruction->base, false);
5409	5431	return ira->codegen->builtin_types.entry_void;
...	...	@@ -5450,7 +5472,6 @@ static TypeTableEntry ir_analyze_instruction_slice_type(IrAnalyze ira,
5450	5472	case TypeTableEntryIdUnion:
5451	5473	case TypeTableEntryIdFn:
5452	5474	case TypeTableEntryIdNamespace:
5453		case TypeTableEntryIdGenericFn:
5454	5475	case TypeTableEntryIdBoundFn:
5455	5476	{
5456	5477	TypeTableEntry *result_type = get_slice_type(ira->codegen, resolved_child_type, is_const);
...	...	@@ -5494,7 +5515,7 @@ static TypeTableEntry ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionA
5494	5515	}
5495	5516
5496	5517	ir_build_asm_from(&ira->new_irb, &asm_instruction->base, input_list, output_types,
5497		asm_instruction->return_count, asm_instruction->has_side_effects);
	5518	asm_instruction->output_vars, asm_instruction->return_count, asm_instruction->has_side_effects);
5498	5519	return return_type;
5499	5520	}
5500	5521
...	...	@@ -5540,7 +5561,6 @@ static TypeTableEntry ir_analyze_instruction_array_type(IrAnalyze ira,
5540	5561	case TypeTableEntryIdUnion:
5541	5562	case TypeTableEntryIdFn:
5542	5563	case TypeTableEntryIdNamespace:
5543		case TypeTableEntryIdGenericFn:
5544	5564	case TypeTableEntryIdBoundFn:
5545	5565	{
5546	5566	TypeTableEntry *result_type = get_array_type(ira->codegen, child_type, size);
...	...	@@ -5611,7 +5631,6 @@ static TypeTableEntry ir_analyze_instruction_size_of(IrAnalyze ira,
5611	5631	case TypeTableEntryIdBlock:
5612	5632	case TypeTableEntryIdNumLitFloat:
5613	5633	case TypeTableEntryIdNumLitInt:
5614		case TypeTableEntryIdGenericFn:
5615	5634	case TypeTableEntryIdBoundFn:
5616	5635	case TypeTableEntryIdMetaType:
5617	5636	case TypeTableEntryIdFn:
...	...	@@ -5905,7 +5924,6 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
5905	5924	case TypeTableEntryIdMaybe:
5906	5925	case TypeTableEntryIdUnion:
5907	5926	case TypeTableEntryIdBlock:
5908		case TypeTableEntryIdGenericFn:
5909	5927	case TypeTableEntryIdBoundFn:
5910	5928	add_node_error(ira->codegen, switch_target_instruction->base.source_node,
5911	5929	buf_sprintf("invalid switch target type '%s'", buf_ptr(&target_type->name)));
...	...	@@ -6009,7 +6027,7 @@ static TypeTableEntry ir_analyze_instruction_import(IrAnalyze ira, IrInstructi
6009	6027	ImportTableEntry *target_import = add_source_file(ira->codegen, target_package,
6010	6028	abs_full_path, search_dir, import_target_path, import_code);
6011	6029
6012		scan_decls(ira->codegen, target_import, target_import->decls_scope, target_import->root);
	6030	scan_decls(ira->codegen, target_import, target_import->decls_scope, target_import->root, nullptr);
6013	6031
6014	6032	ConstExprValue *out_val = ir_build_const_from(ira, &import_instruction->base, depends_on_compile_var);
6015	6033	out_val->data.x_import = target_import;
...	...	@@ -6064,7 +6082,7 @@ static TypeTableEntry ir_analyze_container_init_fields(IrAnalyze ira, IrInstru
6064	6082
6065	6083	IrInstructionStructInitField *new_fields = allocate<IrInstructionStructInitField>(actual_field_count);
6066	6084
6067		FnTableEntry *fn_entry = scope_fn_entry(instruction->source_node->scope);
	6085	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
6068	6086	bool outside_fn = (fn_entry == nullptr);
6069	6087
6070	6088	ConstExprValue const_val = {};
...	...	@@ -6167,7 +6185,7 @@ static TypeTableEntry ir_analyze_instruction_container_init_list(IrAnalyze ira
6167	6185	const_val.data.x_array.elements = allocate<ConstExprValue>(elem_count);
6168	6186	const_val.data.x_array.size = elem_count;
6169	6187
6170		FnTableEntry *fn_entry = scope_fn_entry(instruction->base.source_node->scope);
	6188	FnTableEntry *fn_entry = exec_fn_entry(ira->new_irb.exec);
6171	6189	bool outside_fn = (fn_entry == nullptr);
6172	6190
6173	6191	IrInstruction *new_items = allocate<IrInstruction >(elem_count);

src/ir_print.cpp-8

...	...	@@ -140,14 +140,6 @@ static void ir_print_const_value(IrPrint irp, TypeTableEntry type_entry, Const
140	140	fprintf(irp->f, "(namespace: %s)", buf_ptr(import->path));
141	141	return;
142	142	}
143		case TypeTableEntryIdGenericFn:
144		{
145		TypeTableEntry *type_entry = const_val->data.x_type;
146		AstNode *decl_node = type_entry->data.generic_fn.decl_node;
147		assert(decl_node->type == NodeTypeFnProto);
148		fprintf(irp->f, "%s", buf_ptr(decl_node->data.fn_proto.name));
149		return;
150		}
151	143	case TypeTableEntryIdBoundFn:
152	144	{
153	145	FnTableEntry *fn_entry = const_val->data.x_bound_fn.fn;

src/parseh.cpp+33-66

...	...	@@ -121,7 +121,7 @@ static AstNode create_typed_var_decl_node(Context c, bool is_const, const char
121	121	AstNode *node = create_node(c, NodeTypeVariableDeclaration);
122	122	node->data.variable_declaration.symbol = buf_create_from_str(var_name);
123	123	node->data.variable_declaration.is_const = is_const;
124		node->data.variable_declaration.top_level_decl.visib_mod = c->visib_mod;
	124	node->data.variable_declaration.visib_mod = c->visib_mod;
125	125	node->data.variable_declaration.expr = init_node;
126	126	node->data.variable_declaration.type = type_node;
127	127	return node;
...	...	@@ -139,16 +139,6 @@ static AstNode create_prefix_node(Context c, PrefixOp op, AstNode *child_node)
139	139	return node;
140	140	}
141	141
142		static AstNode create_struct_field_node(Context c, const char name, AstNode type_node) {
143		assert(type_node);
144		AstNode *node = create_node(c, NodeTypeStructField);
145		node->data.struct_field.name = buf_create_from_str(name);
146		node->data.struct_field.top_level_decl.visib_mod = VisibModPub;
147		node->data.struct_field.type = type_node;
148
149		return node;
150		}
151
152	142	static AstNode create_param_decl_node(Context c, const char name, AstNode type_node, bool is_noalias) {
153	143	assert(type_node);
154	144	AstNode *node = create_node(c, NodeTypeParamDecl);
...	...	@@ -214,15 +204,6 @@ static AstNode create_num_lit_signed(Context c, int64_t x) {
214	204	return create_prefix_node(c, PrefixOpNegation, num_lit_node);
215	205	}
216	206
217		static AstNode create_type_decl_node(Context c, const char name, AstNode child_type_node) {
218		AstNode *node = create_node(c, NodeTypeTypeDecl);
219		node->data.type_decl.symbol = buf_create_from_str(name);
220		node->data.type_decl.top_level_decl.visib_mod = c->visib_mod;
221		node->data.type_decl.child_type = child_type_node;
222
223		return node;
224		}
225
226	207	static AstNode make_type_node(Context c, TypeTableEntry *type_entry) {
227	208	zig_panic("TODO bypass AST in parseh");
228	209	}
...	...	@@ -231,7 +212,7 @@ static AstNode create_fn_proto_node(Context c, Buf name, TypeTableEntry fn_t
231	212	assert(fn_type->id == TypeTableEntryIdFn);
232	213	AstNode *node = create_node(c, NodeTypeFnProto);
233	214	node->data.fn_proto.is_inline = true;
234		node->data.fn_proto.top_level_decl.visib_mod = c->visib_mod;
	215	node->data.fn_proto.visib_mod = c->visib_mod;
235	216	node->data.fn_proto.name = name;
236	217	node->data.fn_proto.return_type = make_type_node(c, fn_type->data.fn.fn_type_id.return_type);
237	218
...	...	@@ -280,25 +261,40 @@ static const char decl_name(const Decl decl) {
280	261	return (const char *)named_decl->getName().bytes_begin();
281	262	}
282	263
283		static AstNode add_typedef_node(Context c, TypeTableEntry *type_decl) {
	264	static void add_typedef_node(Context c, TypeTableEntry type_decl) {
284	265	assert(type_decl);
285	266	assert(type_decl->id == TypeTableEntryIdTypeDecl);
286	267
287		AstNode *node = create_type_decl_node(c, buf_ptr(&type_decl->name),
288		make_type_node(c, type_decl->data.type_decl.child_type));
289		node->data.type_decl.override_type = type_decl;
	268	ScopeDecls *decls_scope = c->import->decls_scope;
	269	TldTypeDef *tld_typedef = allocate<TldTypeDef>(1);
	270	init_tld(&tld_typedef->base, TldIdTypeDef, &type_decl->name, c->visib_mod, c->source_node, &decls_scope->base, nullptr);
	271	tld_typedef->type_entry = type_decl;
290	272
	273	decls_scope->decl_table.put(&type_decl->name, &tld_typedef->base);
291	274	c->global_type_table.put(&type_decl->name, type_decl);
292		c->root->data.root.top_level_decls.append(node);
293		return node;
294	275	}
295	276
296		static AstNode add_const_var_node(Context c, Buf name, TypeTableEntry type_entry) {
297		AstNode *node = create_var_decl_node(c, buf_ptr(name), make_type_node(c, type_entry));
298
	277	static void add_const_var_node(Context c, Buf name, TypeTableEntry *type_entry) {
	278	ScopeDecls *decls_scope = c->import->decls_scope;
	279	TldVar *tld_var = allocate<TldVar>(1);
	280	init_tld(&tld_var->base, TldIdVar, name, c->visib_mod, c->source_node, &decls_scope->base, nullptr);
	281	bool is_const = true;
	282	ConstExprValue *init_value = allocate<ConstExprValue>(1);
	283	init_value->special = ConstValSpecialStatic;
	284	init_value->data.x_type = type_entry;
	285	tld_var->var = add_variable(c->codegen, c->source_node, &decls_scope->base, name, type_entry, is_const, init_value);
	286
	287	decls_scope->decl_table.put(name, &tld_var->base);
299	288	c->global_type_table.put(name, type_entry);
300		c->root->data.root.top_level_decls.append(node);
301		return node;
	289	}
	290
	291	static void add_container_tld(Context c, TypeTableEntry type_entry) {
	292	ScopeDecls *decls_scope = c->import->decls_scope;
	293	TldContainer *tld_container = allocate<TldContainer>(1);
	294	init_tld(&tld_container->base, TldIdContainer, &type_entry->name, c->visib_mod, c->source_node, &decls_scope->base, nullptr);
	295	tld_container->type_entry = type_entry;
	296
	297	decls_scope->decl_table.put(&type_entry->name, &tld_container->base);
302	298	}
303	299
304	300	static AstNode create_ap_num_lit_node(Context c, const Decl *source_decl,
...	...	@@ -617,7 +613,7 @@ static TypeTableEntry resolve_type_with_table(Context c, const Type *ty, const
617	613	param_info->is_noalias = qt.isRestrictQualified();
618	614	}
619	615
620		return get_fn_type(c->codegen, &fn_type_id, true);
	616	return get_fn_type(c->codegen, &fn_type_id);
621	617	}
622	618	case Type::Record:
623	619	{
...	...	@@ -724,7 +720,7 @@ static void visit_fn_decl(Context c, const FunctionDecl fn_decl) {
724	720	node->data.fn_proto.name = fn_name;
725	721
726	722	node->data.fn_proto.is_extern = fn_type->data.fn.fn_type_id.is_extern;
727		node->data.fn_proto.top_level_decl.visib_mod = c->visib_mod;
	723	node->data.fn_proto.visib_mod = c->visib_mod;
728	724	node->data.fn_proto.is_var_args = fn_type->data.fn.fn_type_id.is_var_args;
729	725	node->data.fn_proto.return_type = make_type_node(c, fn_type->data.fn.fn_type_id.return_type);
730	726
...	...	@@ -939,9 +935,8 @@ static TypeTableEntry resolve_enum_decl(Context c, const EnumDecl *enum_decl)
939	935	static void visit_enum_decl(Context c, const EnumDecl enum_decl) {
940	936	TypeTableEntry *enum_type = resolve_enum_decl(c, enum_decl);
941	937
942		if (enum_type->id == TypeTableEntryIdInvalid) {
	938	if (enum_type->id == TypeTableEntryIdInvalid)
943	939	return;
944		}
945	940
946	941	// make an alias without the "enum_" prefix. this will get emitted at the
947	942	// end if it doesn't conflict with anything else
...	...	@@ -951,21 +946,7 @@ static void visit_enum_decl(Context c, const EnumDecl enum_decl) {
951	946
952	947	if (enum_type->id == TypeTableEntryIdEnum) {
953	948	if (enum_type->data.enumeration.complete) {
954		// now create top level decl for the type
955		AstNode *enum_node = create_node(c, NodeTypeContainerDecl);
956		enum_node->data.struct_decl.name = &enum_type->name;
957		enum_node->data.struct_decl.kind = ContainerKindEnum;
958		enum_node->data.struct_decl.top_level_decl.visib_mod = VisibModExport;
959		enum_node->data.struct_decl.type_entry = enum_type;
960
961		for (uint32_t i = 0; i < enum_type->data.enumeration.src_field_count; i += 1) {
962		TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[i];
963		AstNode *type_node = make_type_node(c, type_enum_field->type_entry);
964		AstNode *field_node = create_struct_field_node(c, buf_ptr(type_enum_field->name), type_node);
965		enum_node->data.struct_decl.fields.append(field_node);
966		}
967
968		c->root->data.root.top_level_decls.append(enum_node);
	949	add_container_tld(c, enum_type);
969	950	} else {
970	951	TypeTableEntry *typedecl_type = get_typedecl_type(c->codegen, buf_ptr(&enum_type->name),
971	952	c->codegen->builtin_types.entry_u8);
...	...	@@ -1127,21 +1108,7 @@ static void visit_record_decl(Context c, const RecordDecl record_decl) {
1127	1108	}
1128	1109
1129	1110	if (struct_type->data.structure.complete) {
1130		// now create a top level decl node for the type
1131		AstNode *struct_node = create_node(c, NodeTypeContainerDecl);
1132		struct_node->data.struct_decl.name = &struct_type->name;
1133		struct_node->data.struct_decl.kind = ContainerKindStruct;
1134		struct_node->data.struct_decl.top_level_decl.visib_mod = VisibModExport;
1135		struct_node->data.struct_decl.type_entry = struct_type;
1136
1137		for (uint32_t i = 0; i < struct_type->data.structure.src_field_count; i += 1) {
1138		TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
1139		AstNode *type_node = make_type_node(c, type_struct_field->type_entry);
1140		AstNode *field_node = create_struct_field_node(c, buf_ptr(type_struct_field->name), type_node);
1141		struct_node->data.struct_decl.fields.append(field_node);
1142		}
1143
1144		c->root->data.root.top_level_decls.append(struct_node);
	1111	add_container_tld(c, struct_type);
1145	1112	} else {
1146	1113	TypeTableEntry *typedecl_type = get_typedecl_type(c->codegen, buf_ptr(&struct_type->name),
1147	1114	c->codegen->builtin_types.entry_u8);

src/parser.cpp+8-7

...	...	@@ -1501,7 +1501,7 @@ static AstNode ast_parse_variable_declaration_expr(ParseContext pc, size_t *to
1501	1501
1502	1502	node->data.variable_declaration.is_inline = is_inline;
1503	1503	node->data.variable_declaration.is_const = is_const;
1504		node->data.variable_declaration.top_level_decl.visib_mod = visib_mod;
	1504	node->data.variable_declaration.visib_mod = visib_mod;
1505	1505
1506	1506	Token *name_token = ast_eat_token(pc, token_index, TokenIdSymbol);
1507	1507	node->data.variable_declaration.symbol = token_buf(name_token);
...	...	@@ -2079,7 +2079,7 @@ static AstNode ast_parse_fn_proto(ParseContext pc, size_t *token_index, bool m
2079	2079	}
2080	2080
2081	2081	AstNode *node = ast_create_node(pc, NodeTypeFnProto, fn_token);
2082		node->data.fn_proto.top_level_decl.visib_mod = visib_mod;
	2082	node->data.fn_proto.visib_mod = visib_mod;
2083	2083	node->data.fn_proto.is_coldcc = is_coldcc;
2084	2084	node->data.fn_proto.is_nakedcc = is_nakedcc;
2085	2085
...	...	@@ -2144,6 +2144,7 @@ static AstNode ast_parse_fn_def(ParseContext pc, size_t *token_index, bool man
2144	2144	AstNode *node = ast_create_node(pc, NodeTypeFnDef, first_token);
2145	2145	node->data.fn_def.fn_proto = fn_proto;
2146	2146	node->data.fn_def.body = ast_parse_block(pc, token_index, true);
	2147	fn_proto->data.fn_proto.fn_def_node = node;
2147	2148	return node;
2148	2149	}
2149	2150
...	...	@@ -2193,7 +2194,7 @@ static AstNode ast_parse_use(ParseContext pc, size_t *token_index, VisibMod vi
2193	2194	*token_index += 1;
2194	2195
2195	2196	AstNode *node = ast_create_node(pc, NodeTypeUse, use_kw);
2196		node->data.use.top_level_decl.visib_mod = visib_mod;
	2197	node->data.use.visib_mod = visib_mod;
2197	2198	node->data.use.expr = ast_parse_expression(pc, token_index, true);
2198	2199
2199	2200	ast_eat_token(pc, token_index, TokenIdSemicolon);
...	...	@@ -2227,7 +2228,7 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2227	2228	AstNode *node = ast_create_node(pc, NodeTypeContainerDecl, first_token);
2228	2229	node->data.struct_decl.kind = kind;
2229	2230	node->data.struct_decl.name = token_buf(struct_name);
2230		node->data.struct_decl.top_level_decl.visib_mod = visib_mod;
	2231	node->data.struct_decl.visib_mod = visib_mod;
2231	2232
2232	2233	Token paren_or_brace = &pc->tokens->at(token_index);
2233	2234	if (paren_or_brace->id == TokenIdLParen) {
...	...	@@ -2281,7 +2282,7 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2281	2282	AstNode *field_node = ast_create_node(pc, NodeTypeStructField, token);
2282	2283	*token_index += 1;
2283	2284
2284		field_node->data.struct_field.top_level_decl.visib_mod = visib_mod;
	2285	field_node->data.struct_field.visib_mod = visib_mod;
2285	2286	field_node->data.struct_field.name = token_buf(token);
2286	2287
2287	2288	Token expr_or_comma = &pc->tokens->at(token_index);
...	...	@@ -2318,7 +2319,7 @@ static AstNode ast_parse_error_value_decl(ParseContext pc, size_t *token_index
2318	2319	ast_eat_token(pc, token_index, TokenIdSemicolon);
2319	2320
2320	2321	AstNode *node = ast_create_node(pc, NodeTypeErrorValueDecl, first_token);
2321		node->data.error_value_decl.top_level_decl.visib_mod = visib_mod;
	2322	node->data.error_value_decl.visib_mod = visib_mod;
2322	2323	node->data.error_value_decl.name = token_buf(name_tok);
2323	2324
2324	2325	return node;
...	...	@@ -2344,7 +2345,7 @@ static AstNode ast_parse_type_decl(ParseContext pc, size_t *token_index, Visib
2344	2345
2345	2346	ast_eat_token(pc, token_index, TokenIdSemicolon);
2346	2347
2347		node->data.type_decl.top_level_decl.visib_mod = visib_mod;
	2348	node->data.type_decl.visib_mod = visib_mod;
2348	2349
2349	2350	return node;
2350	2351	}