Commit 3ef2f7058b0bbe2c81f79f990398aaab2e5a7a2f | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-01-10 15:13:39-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-01-10 15:13:39-07:00
log	3ef2f7058b0bbe2c81f79f990398aaab2e5a7a2f
tree	d5c6033ff111ff126dc14844ee85edbc0a0828b9
parent	d4b8852d784b6f180e5329efa8d418397ee7f1ef

refactor out the horrible beast that was codegen_node

7 files changed, 1345 insertions(+), 1103 deletions(-)

src/all_types.hpp created+928

...	@@ -0,0 +1,928 @@
1	/*
2	* Copyright (c) 2015 Andrew Kelley
3	*
4	* This file is part of zig, which is MIT licensed.
5	* See http://opensource.org/licenses/MIT
6	*/
7
8	#ifndef ZIG_ALL_TYPES_HPP
9	#define ZIG_ALL_TYPES_HPP
10
11	#include "list.hpp"
12	#include "buffer.hpp"
13	#include "zig_llvm.hpp"
14	#include "hash_map.hpp"
15	#include "errmsg.hpp"
16
17	struct AstNode;
18	struct ImportTableEntry;
19	struct AsmToken;
20	struct FnTableEntry;
21	struct BlockContext;
22	struct TypeTableEntry;
23	struct VariableTableEntry;
24	struct Cast;
25	struct BuiltinFnEntry;
26	struct LabelTableEntry;
27	struct TypeStructField;
28	struct CodeGen;
29
30	enum OutType {
31	OutTypeUnknown,
32	OutTypeExe,
33	OutTypeLib,
34	OutTypeObj,
35	};
36
37	enum CodeGenBuildType {
38	CodeGenBuildTypeDebug,
39	CodeGenBuildTypeRelease,
40	};
41
42	enum CastOp {
43	CastOpNothing,
44	CastOpPtrToInt,
45	CastOpIntWidenOrShorten,
46	CastOpToUnknownSizeArray,
47	CastOpMaybeWrap,
48	CastOpPointerReinterpret,
49	};
50
51	struct Cast {
52	CastOp op;
53	// if op is CastOpArrayToString, this will be a pointer to
54	// the string struct on the stack
55	LLVMValueRef ptr;
56	TypeTableEntry *after_type;
57	AstNode *source_node;
58	};
59
60	struct Expr {
61	TypeTableEntry *type_entry;
62	// the context in which this expression is evaluated.
63	// for blocks, this points to the containing scope, not the block's own scope for its children.
64	BlockContext *block_context;
65
66	// may be null for no cast
67	Cast implicit_cast; // happens first
68	Cast implicit_maybe_cast; // happens second
69	};
70
71	struct NumLitCodeGen {
72	TypeTableEntry *resolved_type;
73	};
74
75	struct StructValExprCodeGen {
76	TypeTableEntry *type_entry;
77	LLVMValueRef ptr;
78	AstNode *source_node;
79	};
80
81	struct TopLevelDecl {
82	// reminder: hash tables must be initialized before use
83	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> deps;
84	Buf *name;
85	ImportTableEntry *import;
86	// set this flag temporarily to detect infinite loops
87	bool in_current_deps;
88	};
89
90	enum NodeType {
91	NodeTypeRoot,
92	NodeTypeRootExportDecl,
93	NodeTypeFnProto,
94	NodeTypeFnDef,
95	NodeTypeFnDecl,
96	NodeTypeParamDecl,
97	NodeTypeType,
98	NodeTypeBlock,
99	NodeTypeExternBlock,
100	NodeTypeDirective,
101	NodeTypeReturnExpr,
102	NodeTypeVariableDeclaration,
103	NodeTypeBinOpExpr,
104	NodeTypeCastExpr,
105	NodeTypeNumberLiteral,
106	NodeTypeStringLiteral,
107	NodeTypeCharLiteral,
108	NodeTypeUnreachable,
109	NodeTypeSymbol,
110	NodeTypePrefixOpExpr,
111	NodeTypeFnCallExpr,
112	NodeTypeArrayAccessExpr,
113	NodeTypeSliceExpr,
114	NodeTypeFieldAccessExpr,
115	NodeTypeUse,
116	NodeTypeVoid,
117	NodeTypeBoolLiteral,
118	NodeTypeNullLiteral,
119	NodeTypeIfBoolExpr,
120	NodeTypeIfVarExpr,
121	NodeTypeWhileExpr,
122	NodeTypeLabel,
123	NodeTypeGoto,
124	NodeTypeBreak,
125	NodeTypeContinue,
126	NodeTypeAsmExpr,
127	NodeTypeStructDecl,
128	NodeTypeStructField,
129	NodeTypeStructValueExpr,
130	NodeTypeStructValueField,
131	NodeTypeEnumDecl,
132	NodeTypeEnumField,
133	NodeTypeCompilerFnExpr,
134	NodeTypeCompilerFnType,
135	};
136
137	struct AstNodeRoot {
138	ZigList<AstNode *> top_level_decls;
139	};
140
141	enum VisibMod {
142	VisibModPrivate,
143	VisibModPub,
144	VisibModExport,
145	};
146
147	struct AstNodeFnProto {
148	ZigList<AstNode > directives;
149	VisibMod visib_mod;
150	Buf name;
151	ZigList<AstNode *> params;
152	AstNode *return_type;
153	bool is_var_args;
154
155	// populated by semantic analyzer:
156
157	// the extern block this fn proto is inside. can be null.
158	AstNode *extern_node;
159	// the struct decl node this fn proto is inside. can be null.
160	AstNode *struct_node;
161	// the function definition this fn proto is inside. can be null.
162	AstNode *fn_def_node;
163	FnTableEntry *fn_table_entry;
164	bool skip;
165	TopLevelDecl top_level_decl;
166	};
167
168	struct AstNodeFnDef {
169	AstNode *fn_proto;
170	AstNode *body;
171
172	// populated by semantic analyzer
173	TypeTableEntry *implicit_return_type;
174	BlockContext *block_context;
175	};
176
177	struct AstNodeFnDecl {
178	AstNode *fn_proto;
179	};
180
181	struct AstNodeParamDecl {
182	Buf name;
183	AstNode *type;
184
185	// populated by semantic analyzer
186	VariableTableEntry *variable;
187	};
188
189	enum AstNodeTypeType {
190	AstNodeTypeTypePrimitive,
191	AstNodeTypeTypePointer,
192	AstNodeTypeTypeArray,
193	AstNodeTypeTypeMaybe,
194	AstNodeTypeTypeCompilerExpr,
195	};
196
197	struct AstNodeType {
198	AstNodeTypeType type;
199	Buf primitive_name;
200	AstNode *child_type;
201	AstNode *array_size; // can be null
202	bool is_const;
203	bool is_noalias;
204	AstNode *compiler_expr;
205
206	// populated by semantic analyzer
207	TypeTableEntry *entry;
208	};
209
210	struct AstNodeBlock {
211	ZigList<AstNode *> statements;
212
213	// populated by semantic analyzer
214	BlockContext *block_context;
215	Expr resolved_expr;
216	};
217
218	struct AstNodeReturnExpr {
219	// might be null in case of return void;
220	AstNode *expr;
221
222	// populated by semantic analyzer:
223	Expr resolved_expr;
224	};
225
226	struct AstNodeVariableDeclaration {
227	Buf symbol;
228	bool is_const;
229	VisibMod visib_mod;
230	// one or both of type and expr will be non null
231	AstNode *type;
232	AstNode *expr;
233
234	// populated by semantic analyzer
235	TopLevelDecl top_level_decl;
236	Expr resolved_expr;
237	};
238
239	enum BinOpType {
240	BinOpTypeInvalid,
241	BinOpTypeAssign,
242	BinOpTypeAssignTimes,
243	BinOpTypeAssignDiv,
244	BinOpTypeAssignMod,
245	BinOpTypeAssignPlus,
246	BinOpTypeAssignMinus,
247	BinOpTypeAssignBitShiftLeft,
248	BinOpTypeAssignBitShiftRight,
249	BinOpTypeAssignBitAnd,
250	BinOpTypeAssignBitXor,
251	BinOpTypeAssignBitOr,
252	BinOpTypeAssignBoolAnd,
253	BinOpTypeAssignBoolOr,
254	BinOpTypeBoolOr,
255	BinOpTypeBoolAnd,
256	BinOpTypeCmpEq,
257	BinOpTypeCmpNotEq,
258	BinOpTypeCmpLessThan,
259	BinOpTypeCmpGreaterThan,
260	BinOpTypeCmpLessOrEq,
261	BinOpTypeCmpGreaterOrEq,
262	BinOpTypeBinOr,
263	BinOpTypeBinXor,
264	BinOpTypeBinAnd,
265	BinOpTypeBitShiftLeft,
266	BinOpTypeBitShiftRight,
267	BinOpTypeAdd,
268	BinOpTypeSub,
269	BinOpTypeMult,
270	BinOpTypeDiv,
271	BinOpTypeMod,
272	BinOpTypeUnwrapMaybe,
273	};
274
275	struct AstNodeBinOpExpr {
276	AstNode *op1;
277	BinOpType bin_op;
278	AstNode *op2;
279
280	// populated by semantic analyzer:
281	// for when op is BinOpTypeAssign
282	VariableTableEntry *var_entry;
283	Expr resolved_expr;
284	};
285
286	struct AstNodeFnCallExpr {
287	AstNode *fn_ref_expr;
288	ZigList<AstNode *> params;
289	bool is_builtin;
290
291	// populated by semantic analyzer:
292	BuiltinFnEntry *builtin_fn;
293	Expr resolved_expr;
294	};
295
296	struct AstNodeArrayAccessExpr {
297	AstNode *array_ref_expr;
298	AstNode *subscript;
299
300	// populated by semantic analyzer:
301	Expr resolved_expr;
302	};
303
304	struct AstNodeSliceExpr {
305	AstNode *array_ref_expr;
306	AstNode *start;
307	AstNode *end;
308	bool is_const;
309
310	// populated by semantic analyzer:
311	Expr resolved_expr;
312	StructValExprCodeGen resolved_struct_val_expr;
313	};
314
315	struct AstNodeFieldAccessExpr {
316	AstNode *struct_expr;
317	Buf field_name;
318
319	// populated by semantic analyzer
320	int field_index;
321	TypeStructField *type_struct_field;
322	Expr resolved_expr;
323	};
324
325	struct AstNodeExternBlock {
326	ZigList<AstNode > directives;
327	ZigList<AstNode *> fn_decls;
328	};
329
330	struct AstNodeDirective {
331	Buf name;
332	Buf param;
333	};
334
335	struct AstNodeRootExportDecl {
336	Buf type;
337	Buf name;
338	ZigList<AstNode > directives;
339	};
340
341	struct AstNodeCastExpr {
342	AstNode *expr;
343	AstNode *type;
344
345	// populated by semantic analyzer
346	Cast cast;
347	Expr resolved_expr;
348	};
349
350	enum PrefixOp {
351	PrefixOpInvalid,
352	PrefixOpBoolNot,
353	PrefixOpBinNot,
354	PrefixOpNegation,
355	PrefixOpAddressOf,
356	PrefixOpConstAddressOf,
357	PrefixOpDereference,
358	};
359
360	struct AstNodePrefixOpExpr {
361	PrefixOp prefix_op;
362	AstNode *primary_expr;
363
364	// populated by semantic analyzer
365	Expr resolved_expr;
366	};
367
368	struct AstNodeUse {
369	Buf path;
370	ZigList<AstNode > directives;
371
372	// populated by semantic analyzer
373	ImportTableEntry *import;
374	};
375
376	struct AstNodeIfBoolExpr {
377	AstNode *condition;
378	AstNode *then_block;
379	AstNode *else_node; // null, block node, or other if expr node
380
381	// populated by semantic analyzer
382	Expr resolved_expr;
383	};
384
385	struct AstNodeIfVarExpr {
386	AstNodeVariableDeclaration var_decl;
387	AstNode *then_block;
388	AstNode *else_node; // null, block node, or other if expr node
389
390	// populated by semantic analyzer
391	TypeTableEntry *type;
392	BlockContext *block_context;
393	Expr resolved_expr;
394	};
395
396	struct AstNodeWhileExpr {
397	AstNode *condition;
398	AstNode *body;
399
400	// populated by semantic analyzer
401	bool condition_always_true;
402	bool contains_break;
403	Expr resolved_expr;
404	};
405
406	struct AstNodeLabel {
407	Buf name;
408
409	// populated by semantic analyzer
410	LabelTableEntry *label_entry;
411	Expr resolved_expr;
412	};
413
414	struct AstNodeGoto {
415	Buf name;
416
417	// populated by semantic analyzer
418	LabelTableEntry *label_entry;
419	Expr resolved_expr;
420	};
421
422	struct AsmOutput {
423	Buf asm_symbolic_name;
424	Buf constraint;
425	Buf variable_name;
426	AstNode *return_type; // null unless "=r" and return
427	};
428
429	struct AsmInput {
430	Buf asm_symbolic_name;
431	Buf constraint;
432	AstNode *expr;
433	};
434
435	struct SrcPos {
436	int line;
437	int column;
438	};
439
440	struct AstNodeAsmExpr {
441	bool is_volatile;
442	Buf asm_template;
443	ZigList<SrcPos> offset_map;
444	ZigList<AsmToken> token_list;
445	ZigList<AsmOutput*> output_list;
446	ZigList<AsmInput*> input_list;
447	ZigList<Buf*> clobber_list;
448
449	// populated by semantic analyzer
450	int return_count;
451	Expr resolved_expr;
452	};
453
454	struct AstNodeStructDecl {
455	Buf name;
456	ZigList<AstNode *> fields;
457	ZigList<AstNode *> fns;
458	ZigList<AstNode > directives;
459	VisibMod visib_mod;
460
461	// populated by semantic analyzer
462	TypeTableEntry *type_entry;
463	TopLevelDecl top_level_decl;
464	};
465
466	struct AstNodeStructField {
467	Buf name;
468	AstNode *type;
469	ZigList<AstNode > directives;
470	};
471
472	struct AstNodeEnumDecl {
473	Buf name;
474	ZigList<AstNode *> fields;
475	ZigList<AstNode > directives;
476	VisibMod visib_mod;
477	};
478
479	struct AstNodeEnumField {
480	Buf name;
481	ZigList<AstNode *> fields; // length 0 means simple enum
482	AstNode *val_expr;
483	};
484
485	struct AstNodeStringLiteral {
486	Buf buf;
487	bool c;
488
489	// populated by semantic analyzer:
490	Expr resolved_expr;
491	};
492
493	struct AstNodeCharLiteral {
494	uint8_t value;
495
496	// populated by semantic analyzer:
497	Expr resolved_expr;
498	};
499
500	enum NumLit {
501	NumLitF32,
502	NumLitF64,
503	NumLitF128,
504	NumLitU8,
505	NumLitU16,
506	NumLitU32,
507	NumLitU64,
508	NumLitI8,
509	NumLitI16,
510	NumLitI32,
511	NumLitI64,
512
513	NumLitCount
514	};
515
516	struct AstNodeNumberLiteral {
517	NumLit kind;
518
519	// overflow is true if when parsing the number, we discovered it would not
520	// fit without losing data in a uint64_t, int64_t, or double
521	bool overflow;
522
523	union {
524	uint64_t x_uint;
525	int64_t x_int;
526	double x_float;
527	} data;
528
529	// populated by semantic analyzer
530	NumLitCodeGen codegen;
531	Expr resolved_expr;
532	};
533
534	struct AstNodeStructValueField {
535	Buf name;
536	AstNode *expr;
537
538	// populated by semantic analyzer
539	int index;
540	};
541
542	struct AstNodeStructValueExpr {
543	AstNode *type;
544	ZigList<AstNode *> fields;
545
546	// populated by semantic analyzer
547	StructValExprCodeGen codegen;
548	Expr resolved_expr;
549	};
550
551	struct AstNodeCompilerFnExpr {
552	Buf name;
553	AstNode *expr;
554
555	// populated by semantic analyzer
556	Expr resolved_expr;
557	};
558
559	struct AstNodeCompilerFnType {
560	Buf name;
561	AstNode *type;
562
563	// populated by semantic analyzer
564	Expr resolved_expr;
565	NumLitCodeGen resolved_num_lit;
566	};
567
568	struct AstNodeNullLiteral {
569	// populated by semantic analyzer
570	StructValExprCodeGen resolved_struct_val_expr;
571	Expr resolved_expr;
572	};
573
574	struct AstNodeVoidExpr {
575	// populated by semantic analyzer
576	Expr resolved_expr;
577	};
578
579	struct AstNodeUnreachableExpr {
580	// populated by semantic analyzer
581	Expr resolved_expr;
582	};
583
584	struct AstNodeSymbolExpr {
585	Buf symbol;
586
587	// populated by semantic analyzer
588	Expr resolved_expr;
589	};
590
591	struct AstNodeBoolLiteral {
592	bool value;
593
594	// populated by semantic analyzer
595	Expr resolved_expr;
596	};
597
598	struct AstNodeBreakExpr {
599	// populated by semantic analyzer
600	Expr resolved_expr;
601	};
602
603	struct AstNodeContinueExpr {
604	// populated by semantic analyzer
605	Expr resolved_expr;
606	};
607
608	struct AstNode {
609	enum NodeType type;
610	int line;
611	int column;
612	uint32_t create_index; // for determinism purposes
613	ImportTableEntry *owner;
614	union {
615	AstNodeRoot root;
616	AstNodeRootExportDecl root_export_decl;
617	AstNodeFnDef fn_def;
618	AstNodeFnDecl fn_decl;
619	AstNodeFnProto fn_proto;
620	AstNodeType type;
621	AstNodeParamDecl param_decl;
622	AstNodeBlock block;
623	AstNodeReturnExpr return_expr;
624	AstNodeVariableDeclaration variable_declaration;
625	AstNodeBinOpExpr bin_op_expr;
626	AstNodeExternBlock extern_block;
627	AstNodeDirective directive;
628	AstNodeCastExpr cast_expr;
629	AstNodePrefixOpExpr prefix_op_expr;
630	AstNodeFnCallExpr fn_call_expr;
631	AstNodeArrayAccessExpr array_access_expr;
632	AstNodeSliceExpr slice_expr;
633	AstNodeUse use;
634	AstNodeIfBoolExpr if_bool_expr;
635	AstNodeIfVarExpr if_var_expr;
636	AstNodeWhileExpr while_expr;
637	AstNodeLabel label;
638	AstNodeGoto goto_expr;
639	AstNodeAsmExpr asm_expr;
640	AstNodeFieldAccessExpr field_access_expr;
641	AstNodeStructDecl struct_decl;
642	AstNodeStructField struct_field;
643	AstNodeEnumDecl enum_decl;
644	AstNodeEnumField enum_field;
645	AstNodeStringLiteral string_literal;
646	AstNodeCharLiteral char_literal;
647	AstNodeNumberLiteral number_literal;
648	AstNodeStructValueExpr struct_val_expr;
649	AstNodeStructValueField struct_val_field;
650	AstNodeCompilerFnExpr compiler_fn_expr;
651	AstNodeCompilerFnType compiler_fn_type;
652	AstNodeNullLiteral null_literal;
653	AstNodeVoidExpr void_expr;
654	AstNodeUnreachableExpr unreachable_expr;
655	AstNodeSymbolExpr symbol_expr;
656	AstNodeBoolLiteral bool_literal;
657	AstNodeBreakExpr break_expr;
658	AstNodeContinueExpr continue_expr;
659	} data;
660	};
661
662	enum AsmTokenId {
663	AsmTokenIdTemplate,
664	AsmTokenIdPercent,
665	AsmTokenIdVar,
666	};
667
668	struct AsmToken {
669	enum AsmTokenId id;
670	int start;
671	int end;
672	};
673
674	struct TypeTableEntryPointer {
675	TypeTableEntry *child_type;
676	bool is_const;
677	bool is_noalias;
678	};
679
680	struct TypeTableEntryInt {
681	bool is_signed;
682	};
683
684	struct TypeTableEntryArray {
685	TypeTableEntry *child_type;
686	uint64_t len;
687	};
688
689	struct TypeStructField {
690	Buf *name;
691	TypeTableEntry *type_entry;
692	};
693
694	struct TypeTableEntryStruct {
695	AstNode *decl_node;
696	bool is_packed;
697	int field_count;
698	TypeStructField *fields;
699	uint64_t size_bytes;
700	bool is_invalid; // true if any fields are invalid
701	bool is_unknown_size_array;
702	// reminder: hash tables must be initialized before use
703	HashMap<Buf , FnTableEntry , buf_hash, buf_eql_buf> fn_table;
704
705	// set this flag temporarily to detect infinite loops
706	bool embedded_in_current;
707	bool reported_infinite_err;
708	};
709
710	struct TypeTableEntryNumLit {
711	NumLit kind;
712	};
713
714	struct TypeTableEntryMaybe {
715	TypeTableEntry *child_type;
716	};
717
718	enum TypeTableEntryId {
719	TypeTableEntryIdInvalid,
720	TypeTableEntryIdVoid,
721	TypeTableEntryIdBool,
722	TypeTableEntryIdUnreachable,
723	TypeTableEntryIdInt,
724	TypeTableEntryIdFloat,
725	TypeTableEntryIdPointer,
726	TypeTableEntryIdArray,
727	TypeTableEntryIdStruct,
728	TypeTableEntryIdNumberLiteral,
729	TypeTableEntryIdMaybe,
730	};
731
732	struct TypeTableEntry {
733	TypeTableEntryId id;
734
735	LLVMTypeRef type_ref;
736	LLVMZigDIType *di_type;
737	uint64_t size_in_bits;
738	uint64_t align_in_bits;
739
740	Buf name;
741
742	union {
743	TypeTableEntryPointer pointer;
744	TypeTableEntryInt integral;
745	TypeTableEntryArray array;
746	TypeTableEntryStruct structure;
747	TypeTableEntryNumLit num_lit;
748	TypeTableEntryMaybe maybe;
749	} data;
750
751	// use these fields to make sure we don't duplicate type table entries for the same type
752	TypeTableEntry *pointer_parent[2][2]; // 0 - const. 1 - noalias
753	TypeTableEntry *unknown_size_array_parent[2][2]; // 0 - const. 1 - noalias
754	HashMap<uint64_t, TypeTableEntry *, uint64_hash, uint64_eq> arrays_by_size;
755	TypeTableEntry *maybe_parent;
756
757	};
758
759	struct ImporterInfo {
760	ImportTableEntry *import;
761	AstNode *source_node;
762	};
763
764	struct ImportTableEntry {
765	AstNode *root;
766	Buf *path; // relative to root_source_dir
767	LLVMZigDIFile *di_file;
768	Buf *source_code;
769	ZigList<int> *line_offsets;
770	BlockContext *block_context;
771	ZigList<ImporterInfo> importers;
772
773	// reminder: hash tables must be initialized before use
774	HashMap<Buf , FnTableEntry , buf_hash, buf_eql_buf> fn_table;
775	HashMap<Buf , TypeTableEntry , buf_hash, buf_eql_buf> type_table;
776	};
777
778	struct LabelTableEntry {
779	AstNode *label_node;
780	LLVMBasicBlockRef basic_block;
781	bool used;
782	bool entered_from_fallthrough;
783	};
784
785	enum FnAttrId {
786	FnAttrIdNaked,
787	FnAttrIdAlwaysInline,
788	};
789
790	struct FnTableEntry {
791	LLVMValueRef fn_value;
792	AstNode *proto_node;
793	AstNode *fn_def_node;
794	bool is_extern;
795	bool internal_linkage;
796	unsigned calling_convention;
797	ImportTableEntry *import_entry;
798	ZigList<FnAttrId> fn_attr_list;
799	// Required to be a pre-order traversal of the AST. (parents must come before children)
800	ZigList<BlockContext *> all_block_contexts;
801	TypeTableEntry *member_of_struct;
802	Buf symbol_name;
803
804	// reminder: hash tables must be initialized before use
805	HashMap<Buf , LabelTableEntry , buf_hash, buf_eql_buf> label_table;
806	};
807
808	enum BuiltinFnId {
809	BuiltinFnIdInvalid,
810	BuiltinFnIdArithmeticWithOverflow,
811	BuiltinFnIdMemcpy,
812	BuiltinFnIdMemset,
813	};
814
815	struct BuiltinFnEntry {
816	BuiltinFnId id;
817	Buf name;
818	int param_count;
819	TypeTableEntry *return_type;
820	TypeTableEntry **param_types;
821	LLVMValueRef fn_val;
822	};
823
824	struct CodeGen {
825	LLVMModuleRef module;
826	ZigList<ErrorMsg*> errors;
827	LLVMBuilderRef builder;
828	LLVMZigDIBuilder *dbuilder;
829	LLVMZigDICompileUnit *compile_unit;
830
831	ZigList<Buf *> lib_search_paths;
832
833	// reminder: hash tables must be initialized before use
834	HashMap<Buf *, LLVMValueRef, buf_hash, buf_eql_buf> str_table;
835	HashMap<Buf *, bool, buf_hash, buf_eql_buf> link_table;
836	HashMap<Buf , ImportTableEntry , buf_hash, buf_eql_buf> import_table;
837	HashMap<Buf , BuiltinFnEntry , buf_hash, buf_eql_buf> builtin_fn_table;
838	HashMap<Buf , TypeTableEntry , buf_hash, buf_eql_buf> primitive_type_table;
839	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> unresolved_top_level_decls;
840
841	uint32_t next_unresolved_index;
842
843	struct {
844	TypeTableEntry *entry_bool;
845	TypeTableEntry *entry_u8;
846	TypeTableEntry *entry_u16;
847	TypeTableEntry *entry_u32;
848	TypeTableEntry *entry_u64;
849	TypeTableEntry *entry_i8;
850	TypeTableEntry *entry_i16;
851	TypeTableEntry *entry_i32;
852	TypeTableEntry *entry_i64;
853	TypeTableEntry *entry_isize;
854	TypeTableEntry *entry_usize;
855	TypeTableEntry *entry_f32;
856	TypeTableEntry *entry_f64;
857	TypeTableEntry *entry_c_string_literal;
858	TypeTableEntry *entry_void;
859	TypeTableEntry *entry_unreachable;
860	TypeTableEntry *entry_invalid;
861	} builtin_types;
862
863	TypeTableEntry *num_lit_types[NumLitCount];
864
865	LLVMTargetDataRef target_data_ref;
866	unsigned pointer_size_bytes;
867	bool is_static;
868	bool strip_debug_symbols;
869	bool have_exported_main;
870	bool link_libc;
871	Buf *libc_path;
872	CodeGenBuildType build_type;
873	LLVMTargetMachineRef target_machine;
874	LLVMZigDIFile *dummy_di_file;
875	bool is_native_target;
876	Buf *root_source_dir;
877	Buf *root_out_name;
878
879	// The function definitions this module includes. There must be a corresponding
880	// fn_protos entry.
881	ZigList<FnTableEntry *> fn_defs;
882	// The function prototypes this module includes. In the case of external declarations,
883	// there will not be a corresponding fn_defs entry.
884	ZigList<FnTableEntry *> fn_protos;
885	ZigList<VariableTableEntry *> global_vars;
886
887	OutType out_type;
888	FnTableEntry *cur_fn;
889	BlockContext *cur_block_context;
890	ZigList<LLVMBasicBlockRef> break_block_stack;
891	ZigList<LLVMBasicBlockRef> continue_block_stack;
892	bool c_stdint_used;
893	AstNode *root_export_decl;
894	int version_major;
895	int version_minor;
896	int version_patch;
897	bool verbose;
898	ErrColor err_color;
899	ImportTableEntry *root_import;
900	ImportTableEntry *bootstrap_import;
901	LLVMValueRef memcpy_fn_val;
902	bool error_during_imports;
903	};
904
905	struct VariableTableEntry {
906	Buf name;
907	TypeTableEntry *type;
908	LLVMValueRef value_ref;
909	bool is_const;
910	bool is_ptr; // if true, value_ref is a pointer
911	AstNode *decl_node;
912	LLVMZigDILocalVariable *di_loc_var;
913	int arg_index;
914	};
915
916	struct BlockContext {
917	AstNode *node; // either NodeTypeFnDef or NodeTypeBlock or NodeTypeRoot
918	FnTableEntry *fn_entry; // null at the module scope
919	BlockContext *parent; // null when this is the root
920	HashMap<Buf , VariableTableEntry , buf_hash, buf_eql_buf> variable_table;
921	ZigList<Cast *> cast_expr_alloca_list;
922	ZigList<StructValExprCodeGen *> struct_val_expr_alloca_list;
923	AstNode *parent_loop_node;
924	AstNode *next_child_parent_loop_node;
925	LLVMZigDIScope *di_scope;
926	};
927
928	#endif

src/analyze.cpp+353-177

 @@ -6,6 +6,7 @@
  */
 #include "analyze.hpp"
+#include "parser.hpp"
 #include "error.hpp"
 #include "zig_llvm.hpp"
 #include "os.hpp"
 @@ -14,7 +15,7 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
         TypeTableEntry *expected_type, AstNode *node);
 static TypeTableEntry *eval_const_expr(CodeGen *g, BlockContext *context,
         AstNode *node, AstNodeNumberLiteral *out_number_literal);
-static void collect_type_decl_deps(CodeGen *g, ImportTableEntry *import, AstNode *type_node, DeclNode *decl_node);
+static void collect_type_decl_deps(CodeGen *g, ImportTableEntry *import, AstNode *type_node, TopLevelDecl *decl_node);
 static VariableTableEntry *analyze_variable_declaration(CodeGen *g, ImportTableEntry *import,
         BlockContext *context, TypeTableEntry *expected_type, AstNode *node);
 @@ -317,7 +318,7 @@ static TypeTableEntry *eval_const_expr_bin_op(CodeGen *g, BlockContext *context,
                     out_number_literal->kind = NumLitU8;
                     out_number_literal->overflow = false;
                     out_number_literal->data.x_uint = (op1_lit.data.x_uint != op2_lit.data.x_uint);
-                    return node->codegen_node->expr_node.type_entry;
+                    return get_resolved_expr(node)->type_entry;
                 } else {
                     return g->builtin_types.entry_invalid;
                 }
 @@ -330,7 +331,7 @@ static TypeTableEntry *eval_const_expr_bin_op(CodeGen *g, BlockContext *context,
                     out_number_literal->kind = NumLitU8;
                     out_number_literal->overflow = false;
                     out_number_literal->data.x_uint = (op1_lit.data.x_uint < op2_lit.data.x_uint);
-                    return node->codegen_node->expr_node.type_entry;
+                    return get_resolved_expr(node)->type_entry;
                 } else {
                     return g->builtin_types.entry_invalid;
                 }
 @@ -343,7 +344,7 @@ static TypeTableEntry *eval_const_expr_bin_op(CodeGen *g, BlockContext *context,
                     out_number_literal->kind = NumLitU64;
                     out_number_literal->overflow = false;
                     out_number_literal->data.x_uint = (op1_lit.data.x_uint % op2_lit.data.x_uint);
-                    return node->codegen_node->expr_node.type_entry;
+                    return get_resolved_expr(node)->type_entry;
                 } else {
                     return g->builtin_types.entry_invalid;
                 }
 @@ -390,20 +391,20 @@ static TypeTableEntry *eval_const_expr(CodeGen *g, BlockContext *context,
     switch (node->type) {
         case NodeTypeNumberLiteral:
             *out_number_literal = node->data.number_literal;
-            return node->codegen_node->expr_node.type_entry;
+            return get_resolved_expr(node)->type_entry;
         case NodeTypeBoolLiteral:
-            out_number_literal->data.x_uint = node->data.bool_literal ? 1 : 0;
+            out_number_literal->data.x_uint = node->data.bool_literal.value ? 1 : 0;
-            return node->codegen_node->expr_node.type_entry;
+            return get_resolved_expr(node)->type_entry;
         case NodeTypeNullLiteral:
-            return node->codegen_node->expr_node.type_entry;
+            return get_resolved_expr(node)->type_entry;
         case NodeTypeBinOpExpr:
             return eval_const_expr_bin_op(g, context, node, out_number_literal);
         case NodeTypeCompilerFnType:
             {
                 Buf *name = &node->data.compiler_fn_type.name;
-                TypeTableEntry *expr_type = node->codegen_node->expr_node.type_entry;
+                TypeTableEntry *expr_type = get_resolved_expr(node)->type_entry;
                 if (buf_eql_str(name, "sizeof")) {
-                    TypeTableEntry *target_type = node->data.compiler_fn_type.type->codegen_node->data.type_node.entry;
+                    TypeTableEntry *target_type = node->data.compiler_fn_type.type->data.type.entry;
                     out_number_literal->overflow = false;
                     out_number_literal->data.x_uint = target_type->size_in_bits / 8;
                     out_number_literal->kind = get_number_literal_kind_unsigned(out_number_literal->data.x_uint);
 @@ -420,11 +421,11 @@ static TypeTableEntry *eval_const_expr(CodeGen *g, BlockContext *context,
             }
         case NodeTypeSymbol:
             {
-                VariableTableEntry *var = find_variable(context, &node->data.symbol);
+                VariableTableEntry *var = find_variable(context, &node->data.symbol_expr.symbol);
                 assert(var);
                 AstNode *decl_node = var->decl_node;
                 AstNode *expr_node = decl_node->data.variable_declaration.expr;
-                BlockContext *next_context = expr_node->codegen_node->expr_node.block_context;
+                BlockContext *next_context = get_resolved_expr(expr_node)->block_context;
                 return eval_const_expr(g, next_context, expr_node, out_number_literal);
             }
         default:
 @@ -436,8 +437,6 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
         BlockContext *context, bool noalias_allowed)
 {
     assert(node->type == NodeTypeType);
-    alloc_codegen_node(node);
-    TypeNode *type_node = &node->codegen_node->data.type_node;
     switch (node->data.type.type) {
         case AstNodeTypeTypePrimitive:
             {
 @@ -447,13 +446,13 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
                     table_entry = g->primitive_type_table.maybe_get(name);
                 }
                 if (table_entry) {
-                    type_node->entry = table_entry->value;
+                    node->data.type.entry = table_entry->value;
                 } else {
                     add_node_error(g, node,
                             buf_sprintf("invalid type name: '%s'", buf_ptr(name)));
-                    type_node->entry = g->builtin_types.entry_invalid;
+                    node->data.type.entry = g->builtin_types.entry_invalid;
                 }
-                return type_node->entry;
+                return node->data.type.entry;
             }
         case AstNodeTypeTypePointer:
             {
 @@ -468,19 +467,19 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
                 }
                 resolve_type(g, node->data.type.child_type, import, context, false);
-                TypeTableEntry *child_type = node->data.type.child_type->codegen_node->data.type_node.entry;
+                TypeTableEntry *child_type = node->data.type.child_type->data.type.entry;
                 assert(child_type);
                 if (child_type->id == TypeTableEntryIdUnreachable) {
                     add_node_error(g, node,
                             buf_create_from_str("pointer to unreachable not allowed"));
-                    type_node->entry = g->builtin_types.entry_invalid;
+                    node->data.type.entry = g->builtin_types.entry_invalid;
-                    return type_node->entry;
+                    return node->data.type.entry;
                 } else if (child_type->id == TypeTableEntryIdInvalid) {
-                    type_node->entry = child_type;
+                    node->data.type.entry = child_type;
                     return child_type;
                 } else {
-                    type_node->entry = get_pointer_to_type(g, child_type, node->data.type.is_const, use_noalias);
+                    node->data.type.entry = get_pointer_to_type(g, child_type, node->data.type.is_const, use_noalias);
-                    return type_node->entry;
+                    return node->data.type.entry;
                 }
             }
         case AstNodeTypeTypeArray:
 @@ -501,16 +500,16 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
                 if (child_type->id == TypeTableEntryIdUnreachable) {
                     add_node_error(g, node,
                             buf_create_from_str("array of unreachable not allowed"));
-                    type_node->entry = g->builtin_types.entry_invalid;
+                    node->data.type.entry = g->builtin_types.entry_invalid;
-                    return type_node->entry;
+                    return node->data.type.entry;
                 }
                 if (size_node) {
                     TypeTableEntry *size_type = analyze_expression(g, import, context,
                             g->builtin_types.entry_usize, size_node);
                     if (size_type->id == TypeTableEntryIdInvalid) {
-                        type_node->entry = g->builtin_types.entry_invalid;
+                        node->data.type.entry = g->builtin_types.entry_invalid;
-                        return type_node->entry;
+                        return node->data.type.entry;
                     }
                     AstNodeNumberLiteral number_literal;
 @@ -520,27 +519,27 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
                         if (resolved_type->data.integral.is_signed) {
                             add_node_error(g, size_node,
                                 buf_create_from_str("array size must be unsigned integer"));
-                            type_node->entry = g->builtin_types.entry_invalid;
+                            node->data.type.entry = g->builtin_types.entry_invalid;
                         } else {
-                            type_node->entry = get_array_type(g, import, child_type, number_literal.data.x_uint);
+                            node->data.type.entry = get_array_type(g, import, child_type, number_literal.data.x_uint);
                         }
                     } else {
                         add_node_error(g, size_node,
                             buf_create_from_str("unable to resolve constant expression"));
-                        type_node->entry = g->builtin_types.entry_invalid;
+                        node->data.type.entry = g->builtin_types.entry_invalid;
                     }
-                    return type_node->entry;
+                    return node->data.type.entry;
                 } else {
-                    type_node->entry = get_unknown_size_array_type(g, import, child_type,
+                    node->data.type.entry = get_unknown_size_array_type(g, import, child_type,
                             node->data.type.is_const, use_noalias);
-                    return type_node->entry;
+                    return node->data.type.entry;
                 }
             }
         case AstNodeTypeTypeMaybe:
             {
                 resolve_type(g, node->data.type.child_type, import, context, false);
-                TypeTableEntry *child_type = node->data.type.child_type->codegen_node->data.type_node.entry;
+                TypeTableEntry *child_type = node->data.type.child_type->data.type.entry;
                 assert(child_type);
                 if (child_type->id == TypeTableEntryIdUnreachable) {
                     add_node_error(g, node,
 @@ -548,22 +547,22 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
                 } else if (child_type->id == TypeTableEntryIdInvalid) {
                     return child_type;
                 }
-                type_node->entry = get_maybe_type(g, import, child_type);
+                node->data.type.entry = get_maybe_type(g, import, child_type);
-                return type_node->entry;
+                return node->data.type.entry;
             }
         case AstNodeTypeTypeCompilerExpr:
             {
                 AstNode *compiler_expr_node = node->data.type.compiler_expr;
                 Buf *fn_name = &compiler_expr_node->data.compiler_fn_expr.name;
                 if (buf_eql_str(fn_name, "typeof")) {
-                    type_node->entry = analyze_expression(g, import, context, nullptr,
+                    node->data.type.entry = analyze_expression(g, import, context, nullptr,
                             compiler_expr_node->data.compiler_fn_expr.expr);
                 } else {
                     add_node_error(g, node,
                             buf_sprintf("invalid compiler function: '%s'", buf_ptr(fn_name)));
-                    type_node->entry = g->builtin_types.entry_invalid;
+                    node->data.type.entry = g->builtin_types.entry_invalid;
                 }
-                return type_node->entry;
+                return node->data.type.entry;
             }
     }
     zig_unreachable();
 @@ -631,8 +630,7 @@ static void preview_function_labels(CodeGen *g, AstNode *node, FnTableEntry *fn_
         Buf *name = &label_node->data.label.name;
         fn_table_entry->label_table.put(name, label_entry);
-        alloc_codegen_node(label_node);
+        label_node->data.label.label_entry = label_entry;
-        label_node->codegen_node->data.label_entry = label_entry;
     }
 }
 @@ -732,7 +730,8 @@ static void preview_fn_proto(CodeGen *g, ImportTableEntry *import,
     AstNode *struct_node = proto_node->data.fn_proto.struct_node;
     TypeTableEntry *struct_type;
     if (struct_node) {
-        struct_type = struct_node->codegen_node->data.struct_decl_node.type_entry;
+        assert(struct_node->type == NodeTypeStructDecl);
+        struct_type = struct_node->data.struct_decl.type_entry;
     } else {
         struct_type = nullptr;
     }
 @@ -749,13 +748,14 @@ static void preview_fn_proto(CodeGen *g, ImportTableEntry *import,
     if (entry) {
         add_node_error(g, proto_node,
                 buf_sprintf("redefinition of '%s'", buf_ptr(proto_name)));
-        proto_node->codegen_node->data.fn_proto_node.skip = true;
+        proto_node->data.fn_proto.skip = true;
         skip = true;
     } else if (is_pub) {
+        // TODO is this else if branch a mistake?
         auto entry = fn_table->maybe_get(proto_name);
         if (entry) {
             add_node_error(g, proto_node, buf_sprintf("redefinition of '%s'", buf_ptr(proto_name)));
-            proto_node->codegen_node->data.fn_proto_node.skip = true;
+            proto_node->data.fn_proto.skip = true;
             skip = true;
         }
     }
 @@ -804,7 +804,7 @@ static void preview_fn_proto(CodeGen *g, ImportTableEntry *import,
     resolve_function_proto(g, proto_node, fn_table_entry, import);
-    proto_node->codegen_node->data.fn_proto_node.fn_table_entry = fn_table_entry;
+    proto_node->data.fn_proto.fn_table_entry = fn_table_entry;
     if (fn_def_node) {
         preview_function_labels(g, fn_def_node->data.fn_def.body, fn_table_entry);
 @@ -888,8 +888,7 @@ static void resolve_top_level_decl(CodeGen *g, ImportTableEntry *import, AstNode
             break;
         case NodeTypeStructDecl:
             {
-                StructDeclNode *struct_codegen = &node->codegen_node->data.struct_decl_node;
+                TypeTableEntry *type_entry = node->data.struct_decl.type_entry;
-                TypeTableEntry *type_entry = struct_codegen->type_entry;
                 resolve_struct_type(g, import, type_entry);
 @@ -962,8 +961,8 @@ static TypeTableEntry *get_return_type(BlockContext *context) {
     AstNode *fn_proto_node = fn_entry->proto_node;
     assert(fn_proto_node->type == NodeTypeFnProto);
     AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
-    assert(return_type_node->codegen_node);
+    assert(return_type_node->type == NodeTypeType);
-    return return_type_node->codegen_node->data.type_node.entry;
+    return return_type_node->data.type.entry;
 }
 static bool num_lit_fits_in_other_type(CodeGen *g, TypeTableEntry *literal_type, TypeTableEntry *other_type) {
 @@ -1003,15 +1002,14 @@ static bool num_lit_fits_in_other_type(CodeGen *g, TypeTableEntry *literal_type,
     zig_unreachable();
 }
-static TypeTableEntry * resolve_rhs_number_literal(CodeGen *g, AstNode *non_literal_node,
+static TypeTableEntry *resolve_rhs_number_literal(CodeGen *g, AstNode *non_literal_node,
         TypeTableEntry *non_literal_type, AstNode *literal_node, TypeTableEntry *literal_type)
 {
-    assert(literal_node->codegen_node);
+    NumLitCodeGen *num_lit_codegen = get_resolved_num_lit(literal_node);
-    NumberLiteralNode *codegen_num_lit = &literal_node->codegen_node->data.num_lit_node;
     if (non_literal_type && num_lit_fits_in_other_type(g, literal_type, non_literal_type)) {
-        assert(!codegen_num_lit->resolved_type);
+        assert(!num_lit_codegen->resolved_type);
-        codegen_num_lit->resolved_type = non_literal_type;
+        num_lit_codegen->resolved_type = non_literal_type;
         return non_literal_type;
     } else {
         return nullptr;
 @@ -1024,11 +1022,8 @@ static TypeTableEntry * resolve_number_literals(CodeGen *g, AstNode *node1, AstN
     if (type1->id == TypeTableEntryIdNumberLiteral &&
         type2->id == TypeTableEntryIdNumberLiteral)
     {
-        assert(node1->codegen_node);
+        NumLitCodeGen *codegen_num_lit_1 = get_resolved_num_lit(node1);
-        assert(node2->codegen_node);
+        NumLitCodeGen *codegen_num_lit_2 = get_resolved_num_lit(node2);
-        NumberLiteralNode *codegen_num_lit_1 = &node1->codegen_node->data.num_lit_node;
-        NumberLiteralNode *codegen_num_lit_2 = &node2->codegen_node->data.num_lit_node;
         assert(!codegen_num_lit_1->resolved_type);
         assert(!codegen_num_lit_2->resolved_type);
 @@ -1113,9 +1108,10 @@ static TypeTableEntry *resolve_type_compatibility(CodeGen *g, BlockContext *cont
     if (actual_type->id == TypeTableEntryIdNumberLiteral &&
         num_lit_fits_in_other_type(g, actual_type, expected_type))
     {
-        assert(!node->codegen_node->data.num_lit_node.resolved_type ||
+        NumLitCodeGen *num_lit_code_gen = get_resolved_num_lit(node);
-                node->codegen_node->data.num_lit_node.resolved_type == expected_type);
+        assert(!num_lit_code_gen->resolved_type ||
-        node->codegen_node->data.num_lit_node.resolved_type = expected_type;
+                num_lit_code_gen->resolved_type == expected_type);
+        num_lit_code_gen->resolved_type = expected_type;
         return expected_type;
     }
 @@ -1134,10 +1130,11 @@ static TypeTableEntry *resolve_type_compatibility(CodeGen *g, BlockContext *cont
         if (resolved_type->id == TypeTableEntryIdInvalid) {
             return resolved_type;
         }
-        node->codegen_node->expr_node.implicit_maybe_cast.op = CastOpMaybeWrap;
+        Expr *expr = get_resolved_expr(node);
-        node->codegen_node->expr_node.implicit_maybe_cast.after_type = expected_type;
+        expr->implicit_maybe_cast.op = CastOpMaybeWrap;
-        node->codegen_node->expr_node.implicit_maybe_cast.source_node = node;
+        expr->implicit_maybe_cast.after_type = expected_type;
-        context->cast_expr_alloca_list.append(&node->codegen_node->expr_node.implicit_maybe_cast);
+        expr->implicit_maybe_cast.source_node = node;
+        context->cast_expr_alloca_list.append(&expr->implicit_maybe_cast);
         return expected_type;
     }
 @@ -1147,9 +1144,10 @@ static TypeTableEntry *resolve_type_compatibility(CodeGen *g, BlockContext *cont
         expected_type->data.integral.is_signed == actual_type->data.integral.is_signed &&
         expected_type->size_in_bits > actual_type->size_in_bits)
     {
-        node->codegen_node->expr_node.implicit_cast.after_type = expected_type;
+        Expr *expr = get_resolved_expr(node);
-        node->codegen_node->expr_node.implicit_cast.op = CastOpIntWidenOrShorten;
+        expr->implicit_cast.after_type = expected_type;
-        node->codegen_node->expr_node.implicit_cast.source_node = node;
+        expr->implicit_cast.op = CastOpIntWidenOrShorten;
+        expr->implicit_cast.source_node = node;
         return expected_type;
     }
 @@ -1159,10 +1157,11 @@ static TypeTableEntry *resolve_type_compatibility(CodeGen *g, BlockContext *cont
         actual_type->id == TypeTableEntryIdArray &&
         actual_type->data.array.child_type == expected_type->data.structure.fields[0].type_entry->data.pointer.child_type)
     {
-        node->codegen_node->expr_node.implicit_cast.after_type = expected_type;
+        Expr *expr = get_resolved_expr(node);
-        node->codegen_node->expr_node.implicit_cast.op = CastOpToUnknownSizeArray;
+        expr->implicit_cast.after_type = expected_type;
-        node->codegen_node->expr_node.implicit_cast.source_node = node;
+        expr->implicit_cast.op = CastOpToUnknownSizeArray;
-        context->cast_expr_alloca_list.append(&node->codegen_node->expr_node.implicit_cast);
+        expr->implicit_cast.source_node = node;
+        context->cast_expr_alloca_list.append(&expr->implicit_cast);
         return expected_type;
     }
 @@ -1225,7 +1224,7 @@ BlockContext *new_block_context(AstNode *node, BlockContext *parent) {
     if (node && node->type == NodeTypeFnDef) {
         AstNode *fn_proto_node = node->data.fn_def.fn_proto;
-        context->fn_entry = fn_proto_node->codegen_node->data.fn_proto_node.fn_table_entry;
+        context->fn_entry = fn_proto_node->data.fn_proto.fn_table_entry;
     } else if (parent) {
         context->fn_entry = parent->fn_entry;
     }
 @@ -1275,6 +1274,8 @@ static void get_struct_field(TypeTableEntry *struct_type, Buf *name, TypeStructF
 static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         AstNode *node)
 {
+    assert(node->type == NodeTypeFieldAccessExpr);
     TypeTableEntry *struct_type = analyze_expression(g, import, context, nullptr,
             node->data.field_access_expr.struct_expr);
 @@ -1283,20 +1284,16 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i
     if (struct_type->id == TypeTableEntryIdStruct || (struct_type->id == TypeTableEntryIdPointer &&
          struct_type->data.pointer.child_type->id == TypeTableEntryIdStruct))
     {
-        assert(node->codegen_node);
-        FieldAccessNode *codegen_field_access = &node->codegen_node->data.field_access_node;
-        assert(codegen_field_access);
         Buf *field_name = &node->data.field_access_expr.field_name;
         TypeTableEntry *bare_struct_type = (struct_type->id == TypeTableEntryIdStruct) ?
             struct_type : struct_type->data.pointer.child_type;
         get_struct_field(bare_struct_type, field_name,
-                &codegen_field_access->type_struct_field,
+                &node->data.field_access_expr.type_struct_field,
-                &codegen_field_access->field_index);
+                &node->data.field_access_expr.field_index);
-        if (codegen_field_access->type_struct_field) {
+        if (node->data.field_access_expr.type_struct_field) {
-            return_type = codegen_field_access->type_struct_field->type_entry;
+            return_type = node->data.field_access_expr.type_struct_field->type_entry;
         } else {
             add_node_error(g, node,
                 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name), buf_ptr(&struct_type->name)));
 @@ -1329,6 +1326,8 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i
 static TypeTableEntry *analyze_slice_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         AstNode *node)
 {
+    assert(node->type == NodeTypeSliceExpr);
     TypeTableEntry *array_type = analyze_expression(g, import, context, nullptr,
             node->data.slice_expr.array_ref_expr);
 @@ -1355,10 +1354,9 @@ static TypeTableEntry *analyze_slice_expr(CodeGen *g, ImportTableEntry *import,
     }
     if (return_type->id != TypeTableEntryIdInvalid) {
-        assert(node->codegen_node);
+        node->data.slice_expr.resolved_struct_val_expr.type_entry = return_type;
-        node->codegen_node->data.struct_val_expr_node.type_entry = return_type;
+        node->data.slice_expr.resolved_struct_val_expr.source_node = node;
-        node->codegen_node->data.struct_val_expr_node.source_node = node;
+        context->struct_val_expr_alloca_list.append(&node->data.slice_expr.resolved_struct_val_expr);
-        context->struct_val_expr_alloca_list.append(&node->codegen_node->data.struct_val_expr_node);
     }
     analyze_expression(g, import, context, g->builtin_types.entry_usize, node->data.slice_expr.start);
 @@ -1463,6 +1461,8 @@ static bool is_op_allowed(TypeTableEntry *type, BinOpType op) {
 static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
+    assert(node->type == NodeTypeCastExpr);
     TypeTableEntry *wanted_type = resolve_type(g, node->data.cast_expr.type, import, context, false);
     TypeTableEntry *actual_type = analyze_expression(g, import, context, nullptr, node->data.cast_expr.expr);
 @@ -1472,43 +1472,41 @@ static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, B
         return g->builtin_types.entry_invalid;
     }
-    CastNode *cast_node = &node->codegen_node->data.cast_node;
+    Cast *cast = &node->data.cast_expr.cast;
-    cast_node->source_node = node;
+    cast->source_node = node;
-    cast_node->after_type = wanted_type;
+    cast->after_type = wanted_type;
-    // special casing this for now, TODO think about casting and do a general solution
     if ((wanted_type == g->builtin_types.entry_isize || wanted_type == g->builtin_types.entry_usize) &&
         actual_type->id == TypeTableEntryIdPointer)
     {
-        cast_node->op = CastOpPtrToInt;
+        cast->op = CastOpPtrToInt;
         return wanted_type;
     } else if (wanted_type->id == TypeTableEntryIdInt &&
                 actual_type->id == TypeTableEntryIdInt)
     {
-        cast_node->op = CastOpIntWidenOrShorten;
+        cast->op = CastOpIntWidenOrShorten;
         return wanted_type;
     } else if (wanted_type->id == TypeTableEntryIdStruct &&
                wanted_type->data.structure.is_unknown_size_array &&
                actual_type->id == TypeTableEntryIdArray &&
                actual_type->data.array.child_type == wanted_type->data.structure.fields[0].type_entry)
     {
-        cast_node->op = CastOpToUnknownSizeArray;
+        cast->op = CastOpToUnknownSizeArray;
-        context->cast_expr_alloca_list.append(cast_node);
+        context->cast_expr_alloca_list.append(cast);
         return wanted_type;
     } else if (actual_type->id == TypeTableEntryIdNumberLiteral &&
                num_lit_fits_in_other_type(g, actual_type, wanted_type))
     {
         AstNode *literal_node = node->data.cast_expr.expr;
-        assert(literal_node->codegen_node);
+        NumLitCodeGen *codegen_num_lit = get_resolved_num_lit(literal_node);
-        NumberLiteralNode *codegen_num_lit = &literal_node->codegen_node->data.num_lit_node;
         assert(!codegen_num_lit->resolved_type);
         codegen_num_lit->resolved_type = wanted_type;
-        cast_node->op = CastOpNothing;
+        cast->op = CastOpNothing;
         return wanted_type;
     } else if (actual_type->id == TypeTableEntryIdPointer &&
                wanted_type->id == TypeTableEntryIdPointer)
     {
-        cast_node->op = CastOpPointerReinterpret;
+        cast->op = CastOpPointerReinterpret;
         return wanted_type;
     } else {
         add_node_error(g, node,
 @@ -1529,7 +1527,7 @@ static TypeTableEntry *analyze_lvalue(CodeGen *g, ImportTableEntry *import, Bloc
 {
     TypeTableEntry *expected_rhs_type = nullptr;
     if (lhs_node->type == NodeTypeSymbol) {
-        Buf *name = &lhs_node->data.symbol;
+        Buf *name = &lhs_node->data.symbol_expr.symbol;
         VariableTableEntry *var = find_variable(block_context, name);
         if (var) {
             if (purpose == LValPurposeAssign && var->is_const) {
 @@ -1551,7 +1549,6 @@ static TypeTableEntry *analyze_lvalue(CodeGen *g, ImportTableEntry *import, Bloc
     } else if (lhs_node->type == NodeTypeArrayAccessExpr) {
         expected_rhs_type = analyze_array_access_expr(g, import, block_context, lhs_node);
     } else if (lhs_node->type == NodeTypeFieldAccessExpr) {
-        alloc_codegen_node(lhs_node);
         expected_rhs_type = analyze_field_access_expr(g, import, block_context, lhs_node);
     } else if (lhs_node->type == NodeTypePrefixOpExpr &&
             lhs_node->data.prefix_op_expr.prefix_op == PrefixOpDereference)
 @@ -1774,10 +1771,9 @@ static TypeTableEntry *analyze_null_literal_expr(CodeGen *g, ImportTableEntry *i
     if (expected_type) {
         assert(expected_type->id == TypeTableEntryIdMaybe);
-        assert(node->codegen_node);
+        node->data.null_literal.resolved_struct_val_expr.type_entry = expected_type;
-        node->codegen_node->data.struct_val_expr_node.type_entry = expected_type;
+        node->data.null_literal.resolved_struct_val_expr.source_node = node;
-        node->codegen_node->data.struct_val_expr_node.source_node = node;
+        block_context->struct_val_expr_alloca_list.append(&node->data.null_literal.resolved_struct_val_expr);
-        block_context->struct_val_expr_alloca_list.append(&node->codegen_node->data.struct_val_expr_node);
         return expected_type;
     } else {
 @@ -1796,7 +1792,7 @@ static TypeTableEntry *analyze_number_literal_expr(CodeGen *g, ImportTableEntry
                 buf_sprintf("number literal too large to be represented in any type"));
         return g->builtin_types.entry_invalid;
     } else if (expected_type) {
-        NumberLiteralNode *codegen_num_lit = &node->codegen_node->data.num_lit_node;
+        NumLitCodeGen *codegen_num_lit = get_resolved_num_lit(node);
         assert(!codegen_num_lit->resolved_type);
         TypeTableEntry *after_implicit_cast_resolved_type =
             resolve_type_compatibility(g, block_context, node, expected_type, num_lit_type);
 @@ -1837,10 +1833,9 @@ static TypeTableEntry *analyze_struct_val_expr(CodeGen *g, ImportTableEntry *imp
         return g->builtin_types.entry_invalid;
     }
-    assert(node->codegen_node);
+    node->data.struct_val_expr.codegen.type_entry = type_entry;
-    node->codegen_node->data.struct_val_expr_node.type_entry = type_entry;
+    node->data.struct_val_expr.codegen.source_node = node;
-    node->codegen_node->data.struct_val_expr_node.source_node = node;
+    context->struct_val_expr_alloca_list.append(&node->data.struct_val_expr.codegen);
-    context->struct_val_expr_alloca_list.append(&node->codegen_node->data.struct_val_expr_node);
     int expr_field_count = struct_val_expr->fields.length;
     int actual_field_count = type_entry->data.structure.field_count;
 @@ -1848,6 +1843,8 @@ static TypeTableEntry *analyze_struct_val_expr(CodeGen *g, ImportTableEntry *imp
     int *field_use_counts = allocate<int>(actual_field_count);
     for (int i = 0; i < expr_field_count; i += 1) {
         AstNode *val_field_node = struct_val_expr->fields.at(i);
+        assert(val_field_node->type == NodeTypeStructValueField);
         int field_index;
         TypeStructField *type_field = find_struct_type_field(type_entry,
                 &val_field_node->data.struct_val_field.name, &field_index);
 @@ -1865,8 +1862,7 @@ static TypeTableEntry *analyze_struct_val_expr(CodeGen *g, ImportTableEntry *imp
             continue;
         }
-        alloc_codegen_node(val_field_node);
+        val_field_node->data.struct_val_field.index = field_index;
-        val_field_node->codegen_node->data.struct_val_field_node.index = field_index;
         analyze_expression(g, import, context, type_field->type_entry,
                 val_field_node->data.struct_val_field.expr);
 @@ -1885,6 +1881,8 @@ static TypeTableEntry *analyze_struct_val_expr(CodeGen *g, ImportTableEntry *imp
 static TypeTableEntry *analyze_while_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
+    assert(node->type == NodeTypeWhileExpr);
     AstNode *condition_node = node->data.while_expr.condition;
     AstNode *while_body_node = node->data.while_expr.body;
     TypeTableEntry *condition_type = analyze_expression(g, import, context,
 @@ -1907,8 +1905,8 @@ static TypeTableEntry *analyze_while_expr(CodeGen *g, ImportTableEntry *import,
             assert(resolved_type->id == TypeTableEntryIdBool);
             bool constant_cond_value = number_literal.data.x_uint;
             if (constant_cond_value) {
-                node->codegen_node->data.while_node.condition_always_true = true;
+                node->data.while_expr.condition_always_true = true;
-                if (!node->codegen_node->data.while_node.contains_break) {
+                if (!node->data.while_expr.contains_break) {
                     expr_return_type = g->builtin_types.entry_unreachable;
                 }
             }
 @@ -1921,12 +1919,14 @@ static TypeTableEntry *analyze_while_expr(CodeGen *g, ImportTableEntry *import,
 static TypeTableEntry *analyze_break_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
+    assert(node->type == NodeTypeBreak);
     AstNode *loop_node = context->parent_loop_node;
     if (loop_node) {
-        loop_node->codegen_node->data.while_node.contains_break = true;
+        assert(loop_node->type == NodeTypeWhileExpr);
+        loop_node->data.while_expr.contains_break = true;
     } else {
-        add_node_error(g, node,
+        add_node_error(g, node, buf_sprintf("'break' expression outside loop"));
-                buf_sprintf("'break' expression outside loop"));
     }
     return g->builtin_types.entry_unreachable;
 }
 @@ -1935,8 +1935,7 @@ static TypeTableEntry *analyze_continue_expr(CodeGen *g, ImportTableEntry *impor
         TypeTableEntry *expected_type, AstNode *node)
 {
     if (!context->parent_loop_node) {
-        add_node_error(g, node,
+        add_node_error(g, node, buf_sprintf("'continue' expression outside loop"));
-                buf_sprintf("'continue' expression outside loop"));
     }
     return g->builtin_types.entry_unreachable;
 }
 @@ -1981,7 +1980,7 @@ static TypeTableEntry *analyze_if_var_expr(CodeGen *g, ImportTableEntry *import,
     assert(node->type == NodeTypeIfVarExpr);
     BlockContext *child_context = new_block_context(node, context);
-    node->codegen_node->data.if_var_node.block_context = child_context;
+    node->data.if_var_expr.block_context = child_context;
     analyze_variable_declaration_raw(g, import, child_context, node, &node->data.if_var_expr.var_decl, true);
 @@ -2032,8 +2031,10 @@ static TypeTableEntry *analyze_compiler_fn_type(CodeGen *g, ImportTableEntry *im
 static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
+    assert(node->type == NodeTypeFnCallExpr);
     AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
-    Buf *name = &fn_ref_expr->data.symbol;
+    Buf *name = &fn_ref_expr->data.symbol_expr.symbol;
     auto entry = g->builtin_fn_table.maybe_get(name);
 @@ -2041,8 +2042,7 @@ static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry
         BuiltinFnEntry *builtin_fn = entry->value;
         int actual_param_count = node->data.fn_call_expr.params.length;
-        assert(node->codegen_node);
+        node->data.fn_call_expr.builtin_fn = builtin_fn;
-        node->codegen_node->data.fn_call_node.builtin_fn = builtin_fn;
         if (builtin_fn->param_count != actual_param_count) {
             add_node_error(g, node,
 @@ -2155,7 +2155,7 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import
         if (node->data.fn_call_expr.is_builtin) {
             return analyze_builtin_fn_call_expr(g, import, context, expected_type, node);
         }
-        name = &fn_ref_expr->data.symbol;
+        name = &fn_ref_expr->data.symbol_expr.symbol;
     } else {
         add_node_error(g, node,
                 buf_sprintf("function pointers not yet supported"));
 @@ -2210,13 +2210,15 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import
                 AstNode *param_decl_node = fn_proto->params.at(fn_proto_i);
                 assert(param_decl_node->type == NodeTypeParamDecl);
                 AstNode *param_type_node = param_decl_node->data.param_decl.type;
-                if (param_type_node->codegen_node)
+                assert(param_type_node->type == NodeTypeType);
-                    expected_param_type = param_type_node->codegen_node->data.type_node.entry;
+                if (param_type_node->data.type.entry) {
+                    expected_param_type = param_type_node->data.type.entry;
+                }
             }
             analyze_expression(g, import, context, expected_param_type, child);
         }
-        return fn_proto->return_type->codegen_node->data.type_node.entry;
+        return fn_proto->return_type->data.type.entry;
     }
 }
 @@ -2224,18 +2226,17 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
         TypeTableEntry *expected_type, AstNode *node)
 {
     TypeTableEntry *return_type = nullptr;
-    alloc_codegen_node(node);
     switch (node->type) {
         case NodeTypeBlock:
             {
                 BlockContext *child_context = new_block_context(node, context);
-                node->codegen_node->data.block_node.block_context = child_context;
+                node->data.block.block_context = child_context;
                 return_type = g->builtin_types.entry_void;
                 for (int i = 0; i < node->data.block.statements.length; i += 1) {
                     AstNode *child = node->data.block.statements.at(i);
                     if (child->type == NodeTypeLabel) {
-                        LabelTableEntry *label_entry = child->codegen_node->data.label_entry;
+                        LabelTableEntry *label_entry = child->data.label.label_entry;
                         assert(label_entry);
                         label_entry->entered_from_fallthrough = (return_type->id != TypeTableEntryIdUnreachable);
                         return_type = g->builtin_types.entry_void;
 @@ -2288,13 +2289,13 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
         case NodeTypeGoto:
             {
                 FnTableEntry *fn_table_entry = get_context_fn_entry(context);
-                auto table_entry = fn_table_entry->label_table.maybe_get(&node->data.go_to.name);
+                auto table_entry = fn_table_entry->label_table.maybe_get(&node->data.goto_expr.name);
                 if (table_entry) {
-                    node->codegen_node->data.label_entry = table_entry->value;
+                    node->data.goto_expr.label_entry = table_entry->value;
                     table_entry->value->used = true;
                 } else {
                     add_node_error(g, node,
-                            buf_sprintf("use of undeclared label '%s'", buf_ptr(&node->data.go_to.name)));
+                            buf_sprintf("use of undeclared label '%s'", buf_ptr(&node->data.goto_expr.name)));
                 }
                 return_type = g->builtin_types.entry_unreachable;
                 break;
 @@ -2380,7 +2381,7 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
         case NodeTypeSymbol:
             {
-                return_type = analyze_variable_name(g, import, context, node, &node->data.symbol);
+                return_type = analyze_variable_name(g, import, context, node, &node->data.symbol_expr.symbol);
                 break;
             }
         case NodeTypeCastExpr:
 @@ -2507,8 +2508,8 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
     assert(return_type);
     resolve_type_compatibility(g, context, node, expected_type, return_type);
-    node->codegen_node->expr_node.type_entry = return_type;
+    get_resolved_expr(node)->type_entry = return_type;
-    node->codegen_node->expr_node.block_context = context;
+    get_resolved_expr(node)->block_context = context;
     return return_type;
 }
 @@ -2519,15 +2520,14 @@ static void analyze_top_level_fn_def(CodeGen *g, ImportTableEntry *import, AstNo
     AstNode *fn_proto_node = node->data.fn_def.fn_proto;
     assert(fn_proto_node->type == NodeTypeFnProto);
-    if (fn_proto_node->codegen_node->data.fn_proto_node.skip) {
+    if (fn_proto_node->data.fn_proto.skip) {
         // we detected an error with this function definition which prevents us
         // from further analyzing it.
         return;
     }
-    alloc_codegen_node(node);
     BlockContext *context = new_block_context(node, import->block_context);
-    node->codegen_node->data.fn_def_node.block_context = context;
+    node->data.fn_def.block_context = context;
     AstNodeFnProto *fn_proto = &fn_proto_node->data.fn_proto;
     bool is_exported = (fn_proto->visib_mod == VisibModExport);
 @@ -2538,7 +2538,7 @@ static void analyze_top_level_fn_def(CodeGen *g, ImportTableEntry *import, AstNo
         // define local variables for parameters
         AstNodeParamDecl *param_decl = &param_decl_node->data.param_decl;
         assert(param_decl->type->type == NodeTypeType);
-        TypeTableEntry *type = param_decl->type->codegen_node->data.type_node.entry;
+        TypeTableEntry *type = param_decl->type->data.type.entry;
         if (is_exported && type->id == TypeTableEntryIdStruct) {
             add_node_error(g, param_decl_node,
 @@ -2552,8 +2552,7 @@ static void analyze_top_level_fn_def(CodeGen *g, ImportTableEntry *import, AstNo
         variable_entry->decl_node = param_decl_node;
         variable_entry->arg_index = i;
-        alloc_codegen_node(param_decl_node);
+        param_decl_node->data.param_decl.variable = variable_entry;
-        param_decl_node->codegen_node->data.param_decl_node.variable = variable_entry;
         VariableTableEntry *existing_entry = find_local_variable(context, &variable_entry->name);
         if (!existing_entry) {
 @@ -2571,13 +2570,13 @@ static void analyze_top_level_fn_def(CodeGen *g, ImportTableEntry *import, AstNo
         }
     }
-    TypeTableEntry *expected_type = fn_proto->return_type->codegen_node->data.type_node.entry;
+    TypeTableEntry *expected_type = fn_proto->return_type->data.type.entry;
     TypeTableEntry *block_return_type = analyze_expression(g, import, context, expected_type, node->data.fn_def.body);
-    node->codegen_node->data.fn_def_node.implicit_return_type = block_return_type;
+    node->data.fn_def.implicit_return_type = block_return_type;
     {
-        FnTableEntry *fn_table_entry = fn_proto_node->codegen_node->data.fn_proto_node.fn_table_entry;
+        FnTableEntry *fn_table_entry = fn_proto_node->data.fn_proto.fn_table_entry;
         auto it = fn_table_entry->label_table.entry_iterator();
         for (;;) {
             auto *entry = it.next();
 @@ -2656,7 +2655,7 @@ static void analyze_top_level_decl(CodeGen *g, ImportTableEntry *import, AstNode
 }
 static void collect_expr_decl_deps(CodeGen *g, ImportTableEntry *import, AstNode *expr_node,
-        DeclNode *decl_node)
+        TopLevelDecl *decl_node)
 {
     switch (expr_node->type) {
         case NodeTypeNumberLiteral:
 @@ -2672,7 +2671,7 @@ static void collect_expr_decl_deps(CodeGen *g, ImportTableEntry *import, AstNode
             // no dependencies on other top level declarations
             break;
         case NodeTypeSymbol:
-            decl_node->deps.put(&expr_node->data.symbol, expr_node);
+            decl_node->deps.put(&expr_node->data.symbol_expr.symbol, expr_node);
             break;
         case NodeTypeBinOpExpr:
             collect_expr_decl_deps(g, import, expr_node->data.bin_op_expr.op1, decl_node);
 @@ -2787,7 +2786,7 @@ static void collect_expr_decl_deps(CodeGen *g, ImportTableEntry *import, AstNode
     }
 }
-static void collect_type_decl_deps(CodeGen *g, ImportTableEntry *import, AstNode *type_node, DeclNode *decl_node) {
+static void collect_type_decl_deps(CodeGen *g, ImportTableEntry *import, AstNode *type_node, TopLevelDecl *decl_node) {
     assert(type_node->type == NodeTypeType);
     switch (type_node->data.type.type) {
         case AstNodeTypeTypePrimitive:
 @@ -2824,16 +2823,13 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
     switch (node->type) {
         case NodeTypeStructDecl:
             {
-                alloc_codegen_node(node);
-                StructDeclNode *struct_codegen = &node->codegen_node->data.struct_decl_node;
                 Buf *name = &node->data.struct_decl.name;
                 auto table_entry = g->primitive_type_table.maybe_get(name);
                 if (!table_entry) {
                     table_entry = import->type_table.maybe_get(name);
                 }
                 if (table_entry) {
-                    struct_codegen->type_entry = table_entry->value;
+                    node->data.struct_decl.type_entry = table_entry->value;
                     add_node_error(g, node,
                             buf_sprintf("redefinition of '%s'", buf_ptr(name)));
                 } else {
 @@ -2848,7 +2844,7 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
                     // put off adding the debug type until we do the full struct body
                     // this type is incomplete until we do another pass
                     import->type_table.put(&entry->name, entry);
-                    struct_codegen->type_entry = entry;
+                    node->data.struct_decl.type_entry = entry;
                     bool is_pub = (node->data.struct_decl.visib_mod != VisibModPrivate);
                     if (is_pub) {
 @@ -2867,14 +2863,15 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
                 }
                 // determine which other top level declarations this struct depends on.
-                DeclNode *decl_node = &node->codegen_node->decl_node;
+                TopLevelDecl *decl_node = &node->data.struct_decl.top_level_decl;
+                decl_node->deps.init(1);
                 for (int i = 0; i < node->data.struct_decl.fields.length; i += 1) {
                     AstNode *field_node = node->data.struct_decl.fields.at(i);
                     AstNode *type_node = field_node->data.struct_field.type;
                     collect_type_decl_deps(g, import, type_node, decl_node);
                 }
-                node->codegen_node->decl_node.name = name;
+                decl_node->name = name;
-                node->codegen_node->decl_node.import = import;
+                decl_node->import = import;
                 if (decl_node->deps.size() > 0) {
                     g->unresolved_top_level_decls.put(name, node);
                 } else {
 @@ -2913,8 +2910,8 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
         case NodeTypeVariableDeclaration:
             {
                 // determine which other top level declarations this variable declaration depends on.
-                alloc_codegen_node(node);
+                TopLevelDecl *decl_node = &node->data.variable_declaration.top_level_decl;
-                DeclNode *decl_node = &node->codegen_node->decl_node;
+                decl_node->deps.init(1);
                 if (node->data.variable_declaration.type) {
                     collect_type_decl_deps(g, import, node->data.variable_declaration.type, decl_node);
                 }
 @@ -2922,8 +2919,8 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
                     collect_expr_decl_deps(g, import, node->data.variable_declaration.expr, decl_node);
                 }
                 Buf *name = &node->data.variable_declaration.symbol;
-                node->codegen_node->decl_node.name = name;
+                decl_node->name = name;
-                node->codegen_node->decl_node.import = import;
+                decl_node->import = import;
                 if (decl_node->deps.size() > 0) {
                     g->unresolved_top_level_decls.put(name, node);
                 } else {
 @@ -2934,8 +2931,8 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
         case NodeTypeFnProto:
             {
                 // determine which other top level declarations this function prototype depends on.
-                alloc_codegen_node(node);
+                TopLevelDecl *decl_node = &node->data.fn_proto.top_level_decl;
-                DeclNode *decl_node = &node->codegen_node->decl_node;
+                decl_node->deps.init(1);
                 for (int i = 0; i < node->data.fn_proto.params.length; i += 1) {
                     AstNode *param_node = node->data.fn_proto.params.at(i);
                     assert(param_node->type == NodeTypeParamDecl);
 @@ -2943,8 +2940,8 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
                 }
                 Buf *name = &node->data.fn_proto.name;
-                node->codegen_node->decl_node.name = name;
+                decl_node->name = name;
-                node->codegen_node->decl_node.import = import;
+                decl_node->import = import;
                 if (decl_node->deps.size() > 0) {
                     g->unresolved_top_level_decls.put(name, node);
                 } else {
 @@ -2999,7 +2996,7 @@ static void detect_top_level_decl_deps(CodeGen *g, ImportTableEntry *import, Ast
 }
 static void recursive_resolve_decl(CodeGen *g, ImportTableEntry *import, AstNode *node) {
-    auto it = node->codegen_node->decl_node.deps.entry_iterator();
+    auto it = get_resolved_top_level_decl(node)->deps.entry_iterator();
     for (;;) {
         auto *entry = it.next();
         if (!entry)
 @@ -3012,23 +3009,24 @@ static void recursive_resolve_decl(CodeGen *g, ImportTableEntry *import, AstNode
         AstNode *child_node = unresolved_entry->value;
-        if (child_node->codegen_node->decl_node.in_current_deps) {
+        if (get_resolved_top_level_decl(child_node)->in_current_deps) {
             // dependency loop. we'll let the fact that it's not in the respective
             // table cause an error in resolve_top_level_decl.
             continue;
         }
         // set temporary flag
-        child_node->codegen_node->decl_node.in_current_deps = true;
+        TopLevelDecl *top_level_decl = get_resolved_top_level_decl(child_node);
+        top_level_decl->in_current_deps = true;
-        recursive_resolve_decl(g, child_node->codegen_node->decl_node.import, child_node);
+        recursive_resolve_decl(g, top_level_decl->import, child_node);
         // unset temporary flag
-        child_node->codegen_node->decl_node.in_current_deps = false;
+        top_level_decl->in_current_deps = false;
     }
     resolve_top_level_decl(g, import, node);
-    g->unresolved_top_level_decls.remove(node->codegen_node->decl_node.name);
+    g->unresolved_top_level_decls.remove(get_resolved_top_level_decl(node)->name);
 }
 static void resolve_top_level_declarations_root(CodeGen *g, ImportTableEntry *import, AstNode *node) {
 @@ -3051,12 +3049,13 @@ static void resolve_top_level_declarations_root(CodeGen *g, ImportTableEntry *im
         }
         // set temporary flag
-        decl_node->codegen_node->decl_node.in_current_deps = true;
+        TopLevelDecl *top_level_decl = get_resolved_top_level_decl(decl_node);
+        top_level_decl->in_current_deps = true;
-        recursive_resolve_decl(g, decl_node->codegen_node->decl_node.import, decl_node);
+        recursive_resolve_decl(g, top_level_decl->import, decl_node);
         // unset temporary flag
-        decl_node->codegen_node->decl_node.in_current_deps = false;
+        top_level_decl->in_current_deps = false;
     }
 }
 @@ -3089,7 +3088,7 @@ void semantic_analyze(CodeGen *g) {
                                 buf_sprintf("invalid directive: '%s'", buf_ptr(name)));
                     }
-                    ImportTableEntry *target_import = child->codegen_node->data.import_node.import;
+                    ImportTableEntry *target_import = child->data.use.import;
                     assert(target_import);
                     target_import->importers.append({import, child});
 @@ -3144,9 +3143,186 @@ void semantic_analyze(CodeGen *g) {
     }
 }
-void alloc_codegen_node(AstNode *node) {
+Expr *get_resolved_expr(AstNode *node) {
-    assert(!node->codegen_node);
+    switch (node->type) {
-    node->codegen_node = allocate<CodeGenNode>(1);
+        case NodeTypeReturnExpr:
-    node->codegen_node->decl_node.deps.init(1);
+            return &node->data.return_expr.resolved_expr;
+        case NodeTypeBinOpExpr:
+            return &node->data.bin_op_expr.resolved_expr;
+        case NodeTypeCastExpr:
+            return &node->data.cast_expr.resolved_expr;
+        case NodeTypePrefixOpExpr:
+            return &node->data.prefix_op_expr.resolved_expr;
+        case NodeTypeFnCallExpr:
+            return &node->data.fn_call_expr.resolved_expr;
+        case NodeTypeArrayAccessExpr:
+            return &node->data.array_access_expr.resolved_expr;
+        case NodeTypeSliceExpr:
+            return &node->data.slice_expr.resolved_expr;
+        case NodeTypeFieldAccessExpr:
+            return &node->data.field_access_expr.resolved_expr;
+        case NodeTypeIfBoolExpr:
+            return &node->data.if_bool_expr.resolved_expr;
+        case NodeTypeIfVarExpr:
+            return &node->data.if_var_expr.resolved_expr;
+        case NodeTypeWhileExpr:
+            return &node->data.while_expr.resolved_expr;
+        case NodeTypeAsmExpr:
+            return &node->data.asm_expr.resolved_expr;
+        case NodeTypeStructValueExpr:
+            return &node->data.struct_val_expr.resolved_expr;
+        case NodeTypeNumberLiteral:
+            return &node->data.number_literal.resolved_expr;
+        case NodeTypeStringLiteral:
+            return &node->data.string_literal.resolved_expr;
+        case NodeTypeBlock:
+            return &node->data.block.resolved_expr;
+        case NodeTypeVoid:
+            return &node->data.void_expr.resolved_expr;
+        case NodeTypeUnreachable:
+            return &node->data.unreachable_expr.resolved_expr;
+        case NodeTypeSymbol:
+            return &node->data.symbol_expr.resolved_expr;
+        case NodeTypeVariableDeclaration:
+            return &node->data.variable_declaration.resolved_expr;
+        case NodeTypeCharLiteral:
+            return &node->data.char_literal.resolved_expr;
+        case NodeTypeBoolLiteral:
+            return &node->data.bool_literal.resolved_expr;
+        case NodeTypeNullLiteral:
+            return &node->data.null_literal.resolved_expr;
+        case NodeTypeGoto:
+            return &node->data.goto_expr.resolved_expr;
+        case NodeTypeBreak:
+            return &node->data.break_expr.resolved_expr;
+        case NodeTypeContinue:
+            return &node->data.continue_expr.resolved_expr;
+        case NodeTypeCompilerFnExpr:
+            return &node->data.compiler_fn_expr.resolved_expr;
+        case NodeTypeCompilerFnType:
+            return &node->data.compiler_fn_type.resolved_expr;
+        case NodeTypeLabel:
+            return &node->data.label.resolved_expr;
+        case NodeTypeRoot:
+        case NodeTypeRootExportDecl:
+        case NodeTypeFnProto:
+        case NodeTypeFnDef:
+        case NodeTypeFnDecl:
+        case NodeTypeParamDecl:
+        case NodeTypeType:
+        case NodeTypeExternBlock:
+        case NodeTypeDirective:
+        case NodeTypeUse:
+        case NodeTypeStructDecl:
+        case NodeTypeStructField:
+        case NodeTypeStructValueField:
+        case NodeTypeEnumDecl:
+        case NodeTypeEnumField:
+            zig_unreachable();
+    }
+}
+NumLitCodeGen *get_resolved_num_lit(AstNode *node) {
+    switch (node->type) {
+        case NodeTypeNumberLiteral:
+            return &node->data.number_literal.codegen;
+        case NodeTypeCompilerFnType:
+            return &node->data.compiler_fn_type.resolved_num_lit;
+        case NodeTypeReturnExpr:
+        case NodeTypeBinOpExpr:
+        case NodeTypeCastExpr:
+        case NodeTypePrefixOpExpr:
+        case NodeTypeFnCallExpr:
+        case NodeTypeArrayAccessExpr:
+        case NodeTypeSliceExpr:
+        case NodeTypeFieldAccessExpr:
+        case NodeTypeIfBoolExpr:
+        case NodeTypeIfVarExpr:
+        case NodeTypeWhileExpr:
+        case NodeTypeAsmExpr:
+        case NodeTypeStructValueExpr:
+        case NodeTypeRoot:
+        case NodeTypeRootExportDecl:
+        case NodeTypeFnProto:
+        case NodeTypeFnDef:
+        case NodeTypeFnDecl:
+        case NodeTypeParamDecl:
+        case NodeTypeType:
+        case NodeTypeBlock:
+        case NodeTypeExternBlock:
+        case NodeTypeDirective:
+        case NodeTypeVariableDeclaration:
+        case NodeTypeStringLiteral:
+        case NodeTypeCharLiteral:
+        case NodeTypeUnreachable:
+        case NodeTypeSymbol:
+        case NodeTypeUse:
+        case NodeTypeVoid:
+        case NodeTypeBoolLiteral:
+        case NodeTypeNullLiteral:
+        case NodeTypeLabel:
+        case NodeTypeGoto:
+        case NodeTypeBreak:
+        case NodeTypeContinue:
+        case NodeTypeStructDecl:
+        case NodeTypeStructField:
+        case NodeTypeStructValueField:
+        case NodeTypeEnumDecl:
+        case NodeTypeEnumField:
+        case NodeTypeCompilerFnExpr:
+            zig_unreachable();
+    }
 }
+TopLevelDecl *get_resolved_top_level_decl(AstNode *node) {
+    switch (node->type) {
+        case NodeTypeVariableDeclaration:
+            return &node->data.variable_declaration.top_level_decl;
+        case NodeTypeFnProto:
+            return &node->data.fn_proto.top_level_decl;
+        case NodeTypeStructDecl:
+            return &node->data.struct_decl.top_level_decl;
+        case NodeTypeNumberLiteral:
+        case NodeTypeReturnExpr:
+        case NodeTypeBinOpExpr:
+        case NodeTypeCastExpr:
+        case NodeTypePrefixOpExpr:
+        case NodeTypeFnCallExpr:
+        case NodeTypeArrayAccessExpr:
+        case NodeTypeSliceExpr:
+        case NodeTypeFieldAccessExpr:
+        case NodeTypeIfBoolExpr:
+        case NodeTypeIfVarExpr:
+        case NodeTypeWhileExpr:
+        case NodeTypeAsmExpr:
+        case NodeTypeStructValueExpr:
+        case NodeTypeRoot:
+        case NodeTypeRootExportDecl:
+        case NodeTypeFnDef:
+        case NodeTypeFnDecl:
+        case NodeTypeParamDecl:
+        case NodeTypeType:
+        case NodeTypeBlock:
+        case NodeTypeExternBlock:
+        case NodeTypeDirective:
+        case NodeTypeStringLiteral:
+        case NodeTypeCharLiteral:
+        case NodeTypeUnreachable:
+        case NodeTypeSymbol:
+        case NodeTypeUse:
+        case NodeTypeVoid:
+        case NodeTypeBoolLiteral:
+        case NodeTypeNullLiteral:
+        case NodeTypeLabel:
+        case NodeTypeGoto:
+        case NodeTypeBreak:
+        case NodeTypeContinue:
+        case NodeTypeStructField:
+        case NodeTypeStructValueField:
+        case NodeTypeEnumDecl:
+        case NodeTypeEnumField:
+        case NodeTypeCompilerFnExpr:
+        case NodeTypeCompilerFnType:
+            zig_unreachable();
+    }
+}

src/analyze.hpp+4-402

...	@@ -8,414 +8,16 @@	...	@@ -8,414 +8,16 @@
8	#ifndef ZIG_ANALYZE_HPP	8	#ifndef ZIG_ANALYZE_HPP
9	#define ZIG_ANALYZE_HPP	9	#define ZIG_ANALYZE_HPP
10		10
11	#include "codegen.hpp"	11	#include "all_types.hpp"
12	#include "hash_map.hpp"
13	#include "zig_llvm.hpp"
14	#include "errmsg.hpp"
15
16	struct FnTableEntry;
17	struct BlockContext;
18	struct TypeTableEntry;
19	struct VariableTableEntry;
20	struct CastNode;
21	struct StructValExprNode;
22
23	struct TypeTableEntryPointer {
24	TypeTableEntry *child_type;
25	bool is_const;
26	bool is_noalias;
27	};
28
29	struct TypeTableEntryInt {
30	bool is_signed;
31	};
32
33	struct TypeTableEntryArray {
34	TypeTableEntry *child_type;
35	uint64_t len;
36	};
37
38	struct TypeStructField {
39	Buf *name;
40	TypeTableEntry *type_entry;
41	};
42
43	struct TypeTableEntryStruct {
44	AstNode *decl_node;
45	bool is_packed;
46	int field_count;
47	TypeStructField *fields;
48	uint64_t size_bytes;
49	bool is_invalid; // true if any fields are invalid
50	bool is_unknown_size_array;
51	// reminder: hash tables must be initialized before use
52	HashMap<Buf , FnTableEntry , buf_hash, buf_eql_buf> fn_table;
53
54	// set this flag temporarily to detect infinite loops
55	bool embedded_in_current;
56	bool reported_infinite_err;
57	};
58
59	struct TypeTableEntryNumLit {
60	NumLit kind;
61	};
62
63	struct TypeTableEntryMaybe {
64	TypeTableEntry *child_type;
65	};
66
67	enum TypeTableEntryId {
68	TypeTableEntryIdInvalid,
69	TypeTableEntryIdVoid,
70	TypeTableEntryIdBool,
71	TypeTableEntryIdUnreachable,
72	TypeTableEntryIdInt,
73	TypeTableEntryIdFloat,
74	TypeTableEntryIdPointer,
75	TypeTableEntryIdArray,
76	TypeTableEntryIdStruct,
77	TypeTableEntryIdNumberLiteral,
78	TypeTableEntryIdMaybe,
79	};
80
81	struct TypeTableEntry {
82	TypeTableEntryId id;
83
84	LLVMTypeRef type_ref;
85	LLVMZigDIType *di_type;
86	uint64_t size_in_bits;
87	uint64_t align_in_bits;
88
89	Buf name;
90
91	union {
92	TypeTableEntryPointer pointer;
93	TypeTableEntryInt integral;
94	TypeTableEntryArray array;
95	TypeTableEntryStruct structure;
96	TypeTableEntryNumLit num_lit;
97	TypeTableEntryMaybe maybe;
98	} data;
99
100	// use these fields to make sure we don't duplicate type table entries for the same type
101	TypeTableEntry *pointer_parent[2][2]; // 0 - const. 1 - noalias
102	TypeTableEntry *unknown_size_array_parent[2][2]; // 0 - const. 1 - noalias
103	HashMap<uint64_t, TypeTableEntry *, uint64_hash, uint64_eq> arrays_by_size;
104	TypeTableEntry *maybe_parent;
105
106	};
107
108	struct ImporterInfo {
109	ImportTableEntry *import;
110	AstNode *source_node;
111	};
112
113	struct ImportTableEntry {
114	AstNode *root;
115	Buf *path; // relative to root_source_dir
116	LLVMZigDIFile *di_file;
117	Buf *source_code;
118	ZigList<int> *line_offsets;
119	BlockContext *block_context;
120	ZigList<ImporterInfo> importers;
121
122	// reminder: hash tables must be initialized before use
123	HashMap<Buf , FnTableEntry , buf_hash, buf_eql_buf> fn_table;
124	HashMap<Buf , TypeTableEntry , buf_hash, buf_eql_buf> type_table;
125	};
126
127	struct LabelTableEntry {
128	AstNode *label_node;
129	LLVMBasicBlockRef basic_block;
130	bool used;
131	bool entered_from_fallthrough;
132	};
133
134	enum FnAttrId {
135	FnAttrIdNaked,
136	FnAttrIdAlwaysInline,
137	};
138
139	struct FnTableEntry {
140	LLVMValueRef fn_value;
141	AstNode *proto_node;
142	AstNode *fn_def_node;
143	bool is_extern;
144	bool internal_linkage;
145	unsigned calling_convention;
146	ImportTableEntry *import_entry;
147	ZigList<FnAttrId> fn_attr_list;
148	// Required to be a pre-order traversal of the AST. (parents must come before children)
149	ZigList<BlockContext *> all_block_contexts;
150	TypeTableEntry *member_of_struct;
151	Buf symbol_name;
152
153	// reminder: hash tables must be initialized before use
154	HashMap<Buf , LabelTableEntry , buf_hash, buf_eql_buf> label_table;
155	};
156
157	enum BuiltinFnId {
158	BuiltinFnIdInvalid,
159	BuiltinFnIdArithmeticWithOverflow,
160	BuiltinFnIdMemcpy,
161	BuiltinFnIdMemset,
162	};
163
164	struct BuiltinFnEntry {
165	BuiltinFnId id;
166	Buf name;
167	int param_count;
168	TypeTableEntry *return_type;
169	TypeTableEntry **param_types;
170	LLVMValueRef fn_val;
171	};
172
173	struct CodeGen {
174	LLVMModuleRef module;
175	ZigList<ErrorMsg*> errors;
176	LLVMBuilderRef builder;
177	LLVMZigDIBuilder *dbuilder;
178	LLVMZigDICompileUnit *compile_unit;
179
180	ZigList<Buf *> lib_search_paths;
181
182	// reminder: hash tables must be initialized before use
183	HashMap<Buf *, LLVMValueRef, buf_hash, buf_eql_buf> str_table;
184	HashMap<Buf *, bool, buf_hash, buf_eql_buf> link_table;
185	HashMap<Buf , ImportTableEntry , buf_hash, buf_eql_buf> import_table;
186	HashMap<Buf , BuiltinFnEntry , buf_hash, buf_eql_buf> builtin_fn_table;
187	HashMap<Buf , TypeTableEntry , buf_hash, buf_eql_buf> primitive_type_table;
188	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> unresolved_top_level_decls;
189
190	uint32_t next_unresolved_index;
191
192	struct {
193	TypeTableEntry *entry_bool;
194	TypeTableEntry *entry_u8;
195	TypeTableEntry *entry_u16;
196	TypeTableEntry *entry_u32;
197	TypeTableEntry *entry_u64;
198	TypeTableEntry *entry_i8;
199	TypeTableEntry *entry_i16;
200	TypeTableEntry *entry_i32;
201	TypeTableEntry *entry_i64;
202	TypeTableEntry *entry_isize;
203	TypeTableEntry *entry_usize;
204	TypeTableEntry *entry_f32;
205	TypeTableEntry *entry_f64;
206	TypeTableEntry *entry_c_string_literal;
207	TypeTableEntry *entry_void;
208	TypeTableEntry *entry_unreachable;
209	TypeTableEntry *entry_invalid;
210	} builtin_types;
211
212	TypeTableEntry *num_lit_types[NumLitCount];
213
214	LLVMTargetDataRef target_data_ref;
215	unsigned pointer_size_bytes;
216	bool is_static;
217	bool strip_debug_symbols;
218	bool have_exported_main;
219	bool link_libc;
220	Buf *libc_path;
221	CodeGenBuildType build_type;
222	LLVMTargetMachineRef target_machine;
223	LLVMZigDIFile *dummy_di_file;
224	bool is_native_target;
225	Buf *root_source_dir;
226	Buf *root_out_name;
227
228	// The function definitions this module includes. There must be a corresponding
229	// fn_protos entry.
230	ZigList<FnTableEntry *> fn_defs;
231	// The function prototypes this module includes. In the case of external declarations,
232	// there will not be a corresponding fn_defs entry.
233	ZigList<FnTableEntry *> fn_protos;
234	ZigList<VariableTableEntry *> global_vars;
235
236	OutType out_type;
237	FnTableEntry *cur_fn;
238	BlockContext *cur_block_context;
239	ZigList<LLVMBasicBlockRef> break_block_stack;
240	ZigList<LLVMBasicBlockRef> continue_block_stack;
241	bool c_stdint_used;
242	AstNode *root_export_decl;
243	int version_major;
244	int version_minor;
245	int version_patch;
246	bool verbose;
247	ErrColor err_color;
248	ImportTableEntry *root_import;
249	ImportTableEntry *bootstrap_import;
250	LLVMValueRef memcpy_fn_val;
251	bool error_during_imports;
252	};
253
254	struct VariableTableEntry {
255	Buf name;
256	TypeTableEntry *type;
257	LLVMValueRef value_ref;
258	bool is_const;
259	bool is_ptr; // if true, value_ref is a pointer
260	AstNode *decl_node;
261	LLVMZigDILocalVariable *di_loc_var;
262	int arg_index;
263	};
264
265	struct BlockContext {
266	AstNode *node; // either NodeTypeFnDef or NodeTypeBlock or NodeTypeRoot
267	FnTableEntry *fn_entry; // null at the module scope
268	BlockContext *parent; // null when this is the root
269	HashMap<Buf , VariableTableEntry , buf_hash, buf_eql_buf> variable_table;
270	ZigList<CastNode *> cast_expr_alloca_list;
271	ZigList<StructValExprNode *> struct_val_expr_alloca_list;
272	AstNode *parent_loop_node;
273	AstNode *next_child_parent_loop_node;
274	LLVMZigDIScope *di_scope;
275	};
276
277	struct TypeNode {
278	TypeTableEntry *entry;
279	};
280
281	struct FnProtoNode {
282	FnTableEntry *fn_table_entry;
283	bool skip;
284	};
285
286	struct FnDefNode {
287	TypeTableEntry *implicit_return_type;
288	BlockContext *block_context;
289	};
290
291
292	struct AssignNode {
293	VariableTableEntry *var_entry;
294	};
295
296	struct BlockNode {
297	BlockContext *block_context;
298	};
299
300	struct StructDeclNode {
301	TypeTableEntry *type_entry;
302	};
303
304	struct FieldAccessNode {
305	int field_index;
306	TypeStructField *type_struct_field;
307	};
308
309	enum CastOp {
310	CastOpNothing,
311	CastOpPtrToInt,
312	CastOpIntWidenOrShorten,
313	CastOpToUnknownSizeArray,
314	CastOpMaybeWrap,
315	CastOpPointerReinterpret,
316	};
317
318	struct CastNode {
319	CastOp op;
320	// if op is CastOpArrayToString, this will be a pointer to
321	// the string struct on the stack
322	LLVMValueRef ptr;
323	TypeTableEntry *after_type;
324	AstNode *source_node;
325	};
326
327	struct ExprNode {
328	TypeTableEntry *type_entry;
329	// the context in which this expression is evaluated.
330	// for blocks, this points to the containing scope, not the block's own scope for its children.
331	BlockContext *block_context;
332
333	// may be null for no cast
334	CastNode implicit_cast; // happens first
335	CastNode implicit_maybe_cast; // happens second
336	};
337
338	struct NumberLiteralNode {
339	TypeTableEntry *resolved_type;
340	};
341
342	struct VarDeclNode {
343	TypeTableEntry *type;
344	};
345
346	struct StructValFieldNode {
347	int index;
348	};
349
350	struct StructValExprNode {
351	TypeTableEntry *type_entry;
352	LLVMValueRef ptr;
353	AstNode *source_node;
354	};
355
356	struct IfVarNode {
357	BlockContext *block_context;
358	};
359
360	struct ParamDeclNode {
361	VariableTableEntry *variable;
362	};
363
364	struct ImportNode {
365	ImportTableEntry *import;
366	};
367
368	struct WhileNode {
369	bool condition_always_true;
370	bool contains_break;
371	};
372
373	struct FnCallNode {
374	BuiltinFnEntry *builtin_fn;
375	};
376
377	struct DeclNode {
378	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> deps;
379	Buf *name;
380	ImportTableEntry *import;
381	// set this flag temporarily to detect infinite loops
382	bool in_current_deps;
383	};
384
385	// TODO get rid of this structure and put the data directly in the appropriate AST node
386	struct CodeGenNode {
387	union {
388	TypeNode type_node; // for NodeTypeType
389	FnDefNode fn_def_node; // for NodeTypeFnDef
390	FnProtoNode fn_proto_node; // for NodeTypeFnProto
391	LabelTableEntry *label_entry; // for NodeTypeGoto and NodeTypeLabel
392	AssignNode assign_node; // for NodeTypeBinOpExpr where op is BinOpTypeAssign
393	BlockNode block_node; // for NodeTypeBlock
394	StructDeclNode struct_decl_node; // for NodeTypeStructDecl
395	FieldAccessNode field_access_node; // for NodeTypeFieldAccessExpr
396	CastNode cast_node; // for NodeTypeCastExpr
397	// note: I've been using this field on some non-number literal nodes too.
398	NumberLiteralNode num_lit_node; // for NodeTypeNumberLiteral
399	VarDeclNode var_decl_node; // for NodeTypeVariableDeclaration
400	StructValFieldNode struct_val_field_node; // for NodeTypeStructValueField
401	// note: I've been using this field on some non-struct val expressions too.
402	StructValExprNode struct_val_expr_node; // for NodeTypeStructValueExpr
403	IfVarNode if_var_node; // for NodeTypeStructValueExpr
404	ParamDeclNode param_decl_node; // for NodeTypeParamDecl
405	ImportNode import_node; // for NodeTypeUse
406	WhileNode while_node; // for NodeTypeWhileExpr
407	FnCallNode fn_call_node; // for NodeTypeFnCallExpr
408	} data;
409	ExprNode expr_node; // for all the expression nodes
410	DeclNode decl_node; // for all top level decls
411	};
412		12
413	void semantic_analyze(CodeGen *g);	13	void semantic_analyze(CodeGen *g);
414	void add_node_error(CodeGen g, AstNode node, Buf *msg);	14	void add_node_error(CodeGen g, AstNode node, Buf *msg);
415	void alloc_codegen_node(AstNode *node);
416	TypeTableEntry *new_type_table_entry(TypeTableEntryId id);	15	TypeTableEntry *new_type_table_entry(TypeTableEntryId id);
417	TypeTableEntry get_pointer_to_type(CodeGen g, TypeTableEntry *child_type, bool is_const, bool is_noalias);	16	TypeTableEntry get_pointer_to_type(CodeGen g, TypeTableEntry *child_type, bool is_const, bool is_noalias);
418	VariableTableEntry find_variable(BlockContext context, Buf *name);	17	VariableTableEntry find_variable(BlockContext context, Buf *name);
419	BlockContext new_block_context(AstNode node, BlockContext *parent);	18	BlockContext new_block_context(AstNode node, BlockContext *parent);
		19	Expr get_resolved_expr(AstNode node);
		20	NumLitCodeGen get_resolved_num_lit(AstNode node);
		21	TopLevelDecl get_resolved_top_level_decl(AstNode node);
420		22
421	#endif	23	#endif

src/codegen.cpp+50-61

 @@ -75,9 +75,7 @@ static LLVMValueRef gen_assign_raw(CodeGen *g, AstNode *source_node, BinOpType b
 static TypeTableEntry *get_type_for_type_node(CodeGen *g, AstNode *type_node) {
     assert(type_node->type == NodeTypeType);
-    assert(type_node->codegen_node);
+    return type_node->data.type.entry;
-    assert(type_node->codegen_node->data.type_node.entry);
-    return type_node->codegen_node->data.type_node.entry;
 }
 static TypeTableEntry *fn_proto_type_from_type_node(CodeGen *g, AstNode *type_node) {
 @@ -138,15 +136,16 @@ static LLVMValueRef find_or_create_string(CodeGen *g, Buf *str, bool c) {
 }
 static TypeTableEntry *get_expr_type(AstNode *node) {
-    TypeTableEntry *cast_type = node->codegen_node->expr_node.implicit_cast.after_type;
+    Expr *expr = get_resolved_expr(node);
-    return cast_type ? cast_type : node->codegen_node->expr_node.type_entry;
+    TypeTableEntry *cast_type = expr->implicit_cast.after_type;
+    return cast_type ? cast_type : expr->type_entry;
 }
 static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
     assert(node->type == NodeTypeFnCallExpr);
     AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
     assert(fn_ref_expr->type == NodeTypeSymbol);
-    BuiltinFnEntry *builtin_fn = node->codegen_node->data.fn_call_node.builtin_fn;
+    BuiltinFnEntry *builtin_fn = node->data.fn_call_expr.builtin_fn;
     switch (builtin_fn->id) {
         case BuiltinFnIdInvalid:
 @@ -265,7 +264,7 @@ static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
         // Assume that the expression evaluates to a simple name and return the buf
         // TODO after we support function pointers we can make this generic
         assert(fn_ref_expr->type == NodeTypeSymbol);
-        Buf *name = &fn_ref_expr->data.symbol;
+        Buf *name = &fn_ref_expr->data.symbol_expr.symbol;
         struct_type = nullptr;
         first_param_expr = nullptr;
 @@ -388,8 +387,8 @@ static LLVMValueRef gen_field_ptr(CodeGen *g, AstNode *node, TypeTableEntry **ou
     LLVMValueRef struct_ptr;
     if (struct_expr_node->type == NodeTypeSymbol) {
-        VariableTableEntry *var = find_variable(struct_expr_node->codegen_node->expr_node.block_context,
+        VariableTableEntry *var = find_variable(get_resolved_expr(struct_expr_node)->block_context,
-                &struct_expr_node->data.symbol);
+                &struct_expr_node->data.symbol_expr.symbol);
         assert(var);
         if (var->is_ptr && var->type->id == TypeTableEntryIdPointer) {
 @@ -413,14 +412,12 @@ static LLVMValueRef gen_field_ptr(CodeGen *g, AstNode *node, TypeTableEntry **ou
     assert(LLVMGetTypeKind(LLVMTypeOf(struct_ptr)) == LLVMPointerTypeKind);
     assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(struct_ptr))) == LLVMStructTypeKind);
-    FieldAccessNode *codegen_field_access = &node->codegen_node->data.field_access_node;
+    assert(node->data.field_access_expr.field_index >= 0);
-    assert(codegen_field_access->field_index >= 0);
+    *out_type_entry = node->data.field_access_expr.type_struct_field->type_entry;
-    *out_type_entry = codegen_field_access->type_struct_field->type_entry;
     add_debug_source_node(g, node);
-    return LLVMBuildStructGEP(g->builder, struct_ptr, codegen_field_access->field_index, "");
+    return LLVMBuildStructGEP(g->builder, struct_ptr, node->data.field_access_expr.field_index, "");
 }
 static LLVMValueRef gen_slice_expr(CodeGen *g, AstNode *node) {
 @@ -429,7 +426,7 @@ static LLVMValueRef gen_slice_expr(CodeGen *g, AstNode *node) {
     AstNode *array_ref_node = node->data.slice_expr.array_ref_expr;
     TypeTableEntry *array_type = get_expr_type(array_ref_node);
-    LLVMValueRef tmp_struct_ptr = node->codegen_node->data.struct_val_expr_node.ptr;
+    LLVMValueRef tmp_struct_ptr = node->data.slice_expr.resolved_struct_val_expr.ptr;
     LLVMValueRef array_ptr = gen_array_base_ptr(g, array_ref_node);
     if (array_type->id == TypeTableEntryIdArray) {
 @@ -545,8 +542,8 @@ static LLVMValueRef gen_lvalue(CodeGen *g, AstNode *expr_node, AstNode *node,
     LLVMValueRef target_ref;
     if (node->type == NodeTypeSymbol) {
-        VariableTableEntry *var = find_variable(expr_node->codegen_node->expr_node.block_context,
+        VariableTableEntry *var = find_variable(get_resolved_expr(expr_node)->block_context,
-                &node->data.symbol);
+                &node->data.symbol_expr.symbol);
         assert(var);
         // semantic checking ensures no variables are constant
         assert(!var->is_const);
 @@ -630,7 +627,7 @@ static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
 }
 static LLVMValueRef gen_bare_cast(CodeGen *g, AstNode *node, LLVMValueRef expr_val,
-        TypeTableEntry *actual_type, TypeTableEntry *wanted_type, CastNode *cast_node)
+        TypeTableEntry *actual_type, TypeTableEntry *wanted_type, Cast *cast_node)
 {
     switch (cast_node->op) {
         case CastOpNothing:
 @@ -705,7 +702,7 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
     TypeTableEntry *actual_type = get_expr_type(node->data.cast_expr.expr);
     TypeTableEntry *wanted_type = get_expr_type(node);
-    CastNode *cast_node = &node->codegen_node->data.cast_node;
+    Cast *cast_node = &node->data.cast_expr.cast;
     return gen_bare_cast(g, node, expr_val, actual_type, wanted_type, cast_node);
 @@ -1218,7 +1215,7 @@ static LLVMValueRef gen_if_var_expr(CodeGen *g, AstNode *node) {
     assert(node->data.if_var_expr.var_decl.expr);
     BlockContext *old_block_context = g->cur_block_context;
-    BlockContext *new_block_context = node->codegen_node->data.if_var_node.block_context;
+    BlockContext *new_block_context = node->data.if_var_expr.block_context;
     LLVMValueRef init_val;
     gen_var_decl_raw(g, node, &node->data.if_var_expr.var_decl, new_block_context, true, &init_val);
 @@ -1242,7 +1239,7 @@ static LLVMValueRef gen_block(CodeGen *g, AstNode *block_node, TypeTableEntry *i
     assert(block_node->type == NodeTypeBlock);
     BlockContext *old_block_context = g->cur_block_context;
-    g->cur_block_context = block_node->codegen_node->data.block_node.block_context;
+    g->cur_block_context = block_node->data.block.block_context;
     LLVMValueRef return_value;
     for (int i = 0; i < block_node->data.block.statements.length; i += 1) {
 @@ -1347,7 +1344,7 @@ static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
         if (!is_return) {
             VariableTableEntry *variable = find_variable(
-                    node->codegen_node->expr_node.block_context,
+                    get_resolved_expr(node)->block_context,
                     &asm_output->variable_name);
             assert(variable);
             param_types[param_index] = LLVMTypeOf(variable->value_ref);
 @@ -1396,7 +1393,7 @@ static LLVMValueRef gen_null_literal(CodeGen *g, AstNode *node) {
     TypeTableEntry *type_entry = get_expr_type(node);
     assert(type_entry->id == TypeTableEntryIdMaybe);
-    LLVMValueRef tmp_struct_ptr = node->codegen_node->data.struct_val_expr_node.ptr;
+    LLVMValueRef tmp_struct_ptr = node->data.null_literal.resolved_struct_val_expr.ptr;
     add_debug_source_node(g, node);
     LLVMValueRef field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, 1, "");
 @@ -1416,12 +1413,13 @@ static LLVMValueRef gen_struct_val_expr(CodeGen *g, AstNode *node) {
     int field_count = type_entry->data.structure.field_count;
     assert(field_count == node->data.struct_val_expr.fields.length);
-    StructValExprNode *struct_val_expr_node = &node->codegen_node->data.struct_val_expr_node;
+    StructValExprCodeGen *struct_val_expr_node = &node->data.struct_val_expr.codegen;
     LLVMValueRef tmp_struct_ptr = struct_val_expr_node->ptr;
     for (int i = 0; i < field_count; i += 1) {
         AstNode *field_node = node->data.struct_val_expr.fields.at(i);
-        int index = field_node->codegen_node->data.struct_val_field_node.index;
+        assert(field_node->type == NodeTypeStructValueField);
+        int index = field_node->data.struct_val_field.index;
         TypeStructField *type_struct_field = &type_entry->data.structure.fields[index];
         assert(buf_eql_buf(type_struct_field->name, &field_node->data.struct_val_field.name));
 @@ -1439,8 +1437,8 @@ static LLVMValueRef gen_while_expr(CodeGen *g, AstNode *node) {
     assert(node->data.while_expr.condition);
     assert(node->data.while_expr.body);
-    bool condition_always_true = node->codegen_node->data.while_node.condition_always_true;
+    bool condition_always_true = node->data.while_expr.condition_always_true;
-    bool contains_break = node->codegen_node->data.while_node.contains_break;
+    bool contains_break = node->data.while_expr.contains_break;
     if (condition_always_true) {
         // generate a forever loop
 @@ -1559,17 +1557,17 @@ static LLVMValueRef gen_var_decl_raw(CodeGen *g, AstNode *source_node, AstNodeVa
 static LLVMValueRef gen_var_decl_expr(CodeGen *g, AstNode *node) {
     LLVMValueRef init_val;
     return gen_var_decl_raw(g, node, &node->data.variable_declaration,
-            node->codegen_node->expr_node.block_context, false, &init_val);
+            get_resolved_expr(node)->block_context, false, &init_val);
 }
 static LLVMValueRef gen_number_literal_raw(CodeGen *g, AstNode *source_node,
-        NumberLiteralNode *codegen_num_lit, AstNodeNumberLiteral *num_lit_node)
+        NumLitCodeGen *codegen_num_lit, AstNodeNumberLiteral *num_lit_node)
 {
     TypeTableEntry *type_entry = codegen_num_lit->resolved_type;
     assert(type_entry);
     // override the expression type for number literals
-    source_node->codegen_node->expr_node.type_entry = type_entry;
+    get_resolved_expr(source_node)->type_entry = type_entry;
     if (type_entry->id == TypeTableEntryIdInt) {
         // here the union has int64_t and uint64_t and we purposefully read
 @@ -1594,7 +1592,7 @@ static LLVMValueRef gen_compiler_fn_type(CodeGen *g, AstNode *node) {
     Buf *name = &node->data.compiler_fn_type.name;
     TypeTableEntry *type_entry = get_type_for_type_node(g, node->data.compiler_fn_type.type);
     if (buf_eql_str(name, "sizeof")) {
-        NumberLiteralNode *codegen_num_lit = &node->codegen_node->data.num_lit_node;
+        NumLitCodeGen *codegen_num_lit = get_resolved_num_lit(node);
         AstNodeNumberLiteral num_lit_node;
         num_lit_node.kind = type_entry->data.num_lit.kind;
         num_lit_node.overflow = false;
 @@ -1632,7 +1630,7 @@ static LLVMValueRef gen_compiler_fn_type(CodeGen *g, AstNode *node) {
 static LLVMValueRef gen_number_literal(CodeGen *g, AstNode *node) {
     assert(node->type == NodeTypeNumberLiteral);
-    NumberLiteralNode *codegen_num_lit = &node->codegen_node->data.num_lit_node;
+    NumLitCodeGen *codegen_num_lit = get_resolved_num_lit(node);
     assert(codegen_num_lit);
     return gen_number_literal_raw(g, node, codegen_num_lit, &node->data.number_literal);
 @@ -1664,7 +1662,7 @@ static LLVMValueRef gen_expr_no_cast(CodeGen *g, AstNode *node) {
         case NodeTypeVoid:
             return nullptr;
         case NodeTypeBoolLiteral:
-            if (node->data.bool_literal)
+            if (node->data.bool_literal.value)
                 return LLVMConstAllOnes(LLVMInt1Type());
             else
                 return LLVMConstNull(LLVMInt1Type());
 @@ -1696,8 +1694,8 @@ static LLVMValueRef gen_expr_no_cast(CodeGen *g, AstNode *node) {
         case NodeTypeSymbol:
             {
                 VariableTableEntry *variable = find_variable(
-                        node->codegen_node->expr_node.block_context,
+                        get_resolved_expr(node)->block_context,
-                        &node->data.symbol);
+                        &node->data.symbol_expr.symbol);
                 assert(variable);
                 if (variable->type->id == TypeTableEntryIdVoid) {
                     return nullptr;
 @@ -1721,14 +1719,14 @@ static LLVMValueRef gen_expr_no_cast(CodeGen *g, AstNode *node) {
             return gen_block(g, node, nullptr);
         case NodeTypeGoto:
             add_debug_source_node(g, node);
-            return LLVMBuildBr(g->builder, node->codegen_node->data.label_entry->basic_block);
+            return LLVMBuildBr(g->builder, node->data.goto_expr.label_entry->basic_block);
         case NodeTypeBreak:
             return gen_break(g, node);
         case NodeTypeContinue:
             return gen_continue(g, node);
         case NodeTypeLabel:
             {
-                LabelTableEntry *label_entry = node->codegen_node->data.label_entry;
+                LabelTableEntry *label_entry = node->data.label.label_entry;
                 assert(label_entry);
                 LLVMBasicBlockRef basic_block = label_entry->basic_block;
                 if (label_entry->entered_from_fallthrough) {
 @@ -1770,19 +1768,19 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) {
         return val;
     }
-    assert(node->codegen_node);
+    Expr *expr = get_resolved_expr(node);
-    TypeTableEntry *before_type = node->codegen_node->expr_node.type_entry;
+    TypeTableEntry *before_type = expr->type_entry;
     if (before_type && before_type->id == TypeTableEntryIdUnreachable) {
         return val;
     }
-    CastNode *cast_node = &node->codegen_node->expr_node.implicit_cast;
+    Cast *cast_node = &expr->implicit_cast;
     if (cast_node->after_type) {
         val = gen_bare_cast(g, node, val, before_type, cast_node->after_type, cast_node);
         before_type = cast_node->after_type;
     }
-    cast_node = &node->codegen_node->expr_node.implicit_maybe_cast;
+    cast_node = &expr->implicit_maybe_cast;
     if (cast_node->after_type) {
         val = gen_bare_cast(g, node, val, before_type, cast_node->after_type, cast_node);
     }
 @@ -1798,7 +1796,7 @@ static void build_label_blocks(CodeGen *g, AstNode *block_node) {
             continue;
         Buf *name = &label_node->data.label.name;
-        label_node->codegen_node->data.label_entry->basic_block = LLVMAppendBasicBlock(
+        label_node->data.label.label_entry->basic_block = LLVMAppendBasicBlock(
                 g->cur_fn->fn_value, buf_ptr(name));
     }
 @@ -1944,13 +1942,7 @@ static void do_code_gen(CodeGen *g) {
         LLVMBasicBlockRef entry_block = LLVMAppendBasicBlock(fn, "entry");
         LLVMPositionBuilderAtEnd(g->builder, entry_block);
-        CodeGenNode *codegen_node = fn_def_node->codegen_node;
+        fn_def_node->data.fn_def.block_context->di_scope = LLVMZigSubprogramToScope(subprogram);
-        assert(codegen_node);
-        FnDefNode *codegen_fn_def = &codegen_node->data.fn_def_node;
-        assert(codegen_fn_def);
-        codegen_fn_def->block_context->di_scope = LLVMZigSubprogramToScope(subprogram);
         int non_void_param_count = count_non_void_params(g, &fn_proto->params);
         assert(non_void_param_count == (int)LLVMCountParams(fn));
 @@ -1963,7 +1955,7 @@ static void do_code_gen(CodeGen *g) {
             assert(param_decl->type == NodeTypeParamDecl);
             if (is_param_decl_type_void(g, param_decl))
                 continue;
-            VariableTableEntry *parameter_variable = fn_def_node->codegen_node->data.fn_def_node.block_context->variable_table.get(&param_decl->data.param_decl.name);
+            VariableTableEntry *parameter_variable = fn_def_node->data.fn_def.block_context->variable_table.get(&param_decl->data.param_decl.name);
             parameter_variable->value_ref = params[non_void_index];
             non_void_index += 1;
         }
 @@ -2019,14 +2011,14 @@ static void do_code_gen(CodeGen *g) {
             // allocate structs which are the result of casts
             for (int cea_i = 0; cea_i < block_context->cast_expr_alloca_list.length; cea_i += 1) {
-                CastNode *cast_node = block_context->cast_expr_alloca_list.at(cea_i);
+                Cast *cast_node = block_context->cast_expr_alloca_list.at(cea_i);
                 add_debug_source_node(g, cast_node->source_node);
                 cast_node->ptr = LLVMBuildAlloca(g->builder, cast_node->after_type->type_ref, "");
             }
             // allocate structs which are struct value expressions
             for (int alloca_i = 0; alloca_i < block_context->struct_val_expr_alloca_list.length; alloca_i += 1) {
-                StructValExprNode *struct_val_expr_node = block_context->struct_val_expr_alloca_list.at(alloca_i);
+                StructValExprCodeGen *struct_val_expr_node = block_context->struct_val_expr_alloca_list.at(alloca_i);
                 add_debug_source_node(g, struct_val_expr_node->source_node);
                 struct_val_expr_node->ptr = LLVMBuildAlloca(g->builder,
                         struct_val_expr_node->type_entry->type_ref, "");
 @@ -2041,15 +2033,15 @@ static void do_code_gen(CodeGen *g) {
             if (is_param_decl_type_void(g, param_decl))
                 continue;
-            VariableTableEntry *variable = param_decl->codegen_node->data.param_decl_node.variable;
+            VariableTableEntry *variable = param_decl->data.param_decl.variable;
             LLVMZigDILocation *debug_loc = LLVMZigGetDebugLoc(param_decl->line + 1, param_decl->column + 1,
-                    codegen_fn_def->block_context->di_scope);
+                    fn_def_node->data.fn_def.block_context->di_scope);
             LLVMZigInsertDeclareAtEnd(g->dbuilder, variable->value_ref, variable->di_loc_var, debug_loc,
                     entry_block);
         }
-        TypeTableEntry *implicit_return_type = codegen_fn_def->implicit_return_type;
+        TypeTableEntry *implicit_return_type = fn_def_node->data.fn_def.implicit_return_type;
         gen_block(g, fn_def_node->data.fn_def.body, implicit_return_type);
     }
 @@ -2549,8 +2541,6 @@ static ImportTableEntry *codegen_add_code(CodeGen *g, Buf *abs_full_path,
             Buf *import_code = buf_alloc();
             bool found_it = false;
-            alloc_codegen_node(top_level_decl);
             for (int path_i = 0; path_i < g->lib_search_paths.length; path_i += 1) {
                 Buf *search_path = g->lib_search_paths.at(path_i);
                 os_path_join(search_path, import_target_path, &full_path);
 @@ -2570,7 +2560,7 @@ static ImportTableEntry *codegen_add_code(CodeGen *g, Buf *abs_full_path,
                 auto entry = g->import_table.maybe_get(abs_full_path);
                 if (entry) {
                     found_it = true;
-                    top_level_decl->codegen_node->data.import_node.import = entry->value;
+                    top_level_decl->data.use.import = entry->value;
                 } else {
                     if ((err = os_fetch_file_path(abs_full_path, import_code))) {
                         if (err == ErrorFileNotFound) {
 @@ -2582,7 +2572,7 @@ static ImportTableEntry *codegen_add_code(CodeGen *g, Buf *abs_full_path,
                             goto done_looking_at_imports;
                         }
                     }
-                    top_level_decl->codegen_node->data.import_node.import = codegen_add_code(g,
+                    top_level_decl->data.use.import = codegen_add_code(g,
                             abs_full_path, search_path, &top_level_decl->data.use.path, import_code);
                     found_it = true;
                 }
 @@ -2682,9 +2672,8 @@ void codegen_add_root_code(CodeGen *g, Buf *src_dir, Buf *src_basename, Buf *sou
 static void to_c_type(CodeGen *g, AstNode *type_node, Buf *out_buf) {
     assert(type_node->type == NodeTypeType);
-    assert(type_node->codegen_node);
-    TypeTableEntry *type_entry = type_node->codegen_node->data.type_node.entry;
+    TypeTableEntry *type_entry = type_node->data.type.entry;
     assert(type_entry);
     if (type_entry == g->builtin_types.entry_u8) {

src/codegen.hpp-13

...	@@ -11,21 +11,8 @@	...	@@ -11,21 +11,8 @@
11	#include "parser.hpp"	11	#include "parser.hpp"
12	#include "errmsg.hpp"	12	#include "errmsg.hpp"
13		13
14	struct CodeGen;
15
16	enum OutType {
17	OutTypeUnknown,
18	OutTypeExe,
19	OutTypeLib,
20	OutTypeObj,
21	};
22
23	CodeGen codegen_create(Buf root_source_dir);	14	CodeGen codegen_create(Buf root_source_dir);
24		15
25	enum CodeGenBuildType {
26	CodeGenBuildTypeDebug,
27	CodeGenBuildTypeRelease,
28	};
29	void codegen_set_build_type(CodeGen *codegen, CodeGenBuildType build_type);	16	void codegen_set_build_type(CodeGen *codegen, CodeGenBuildType build_type);
30	void codegen_set_is_static(CodeGen *codegen, bool is_static);	17	void codegen_set_is_static(CodeGen *codegen, bool is_static);
31	void codegen_set_strip(CodeGen *codegen, bool strip);	18	void codegen_set_strip(CodeGen *codegen, bool strip);

src/parser.cpp+9-9

...	@@ -356,8 +356,7 @@ void ast_print(AstNode *node, int indent) {	...	@@ -356,8 +356,7 @@ void ast_print(AstNode *node, int indent) {
356	fprintf(stderr, "Unreachable\n");	356	fprintf(stderr, "Unreachable\n");
357	break;	357	break;
358	case NodeTypeSymbol:	358	case NodeTypeSymbol:
359	fprintf(stderr, "Symbol %s\n",	359	fprintf(stderr, "Symbol %s\n", buf_ptr(&node->data.symbol_expr.symbol));
360	buf_ptr(&node->data.symbol));
361	break;	360	break;
362	case NodeTypeUse:	361	case NodeTypeUse:
363	fprintf(stderr, "%s '%s'\n", node_type_str(node->type), buf_ptr(&node->data.use.path));	362	fprintf(stderr, "%s '%s'\n", node_type_str(node->type), buf_ptr(&node->data.use.path));
...	@@ -366,7 +365,8 @@ void ast_print(AstNode *node, int indent) {	...	@@ -366,7 +365,8 @@ void ast_print(AstNode *node, int indent) {
366	fprintf(stderr, "%s\n", node_type_str(node->type));	365	fprintf(stderr, "%s\n", node_type_str(node->type));
367	break;	366	break;
368	case NodeTypeBoolLiteral:	367	case NodeTypeBoolLiteral:
369	fprintf(stderr, "%s '%s'\n", node_type_str(node->type), node->data.bool_literal ? "true" : "false");	368	fprintf(stderr, "%s '%s'\n", node_type_str(node->type),
		369	node->data.bool_literal.value ? "true" : "false");
370	break;	370	break;
371	case NodeTypeNullLiteral:	371	case NodeTypeNullLiteral:
372	fprintf(stderr, "%s\n", node_type_str(node->type));	372	fprintf(stderr, "%s\n", node_type_str(node->type));
...	@@ -401,7 +401,7 @@ void ast_print(AstNode *node, int indent) {	...	@@ -401,7 +401,7 @@ void ast_print(AstNode *node, int indent) {
401	fprintf(stderr, "%s '%s'\n", node_type_str(node->type), buf_ptr(&node->data.label.name));	401	fprintf(stderr, "%s '%s'\n", node_type_str(node->type), buf_ptr(&node->data.label.name));
402	break;	402	break;
403	case NodeTypeGoto:	403	case NodeTypeGoto:
404	fprintf(stderr, "%s '%s'\n", node_type_str(node->type), buf_ptr(&node->data.go_to.name));	404	fprintf(stderr, "%s '%s'\n", node_type_str(node->type), buf_ptr(&node->data.goto_expr.name));
405	break;	405	break;
406	case NodeTypeBreak:	406	case NodeTypeBreak:
407	fprintf(stderr, "%s\n", node_type_str(node->type));	407	fprintf(stderr, "%s\n", node_type_str(node->type));
...	@@ -1369,12 +1369,12 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool	...	@@ -1369,12 +1369,12 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool
1369	return node;	1369	return node;
1370	} else if (token->id == TokenIdKeywordTrue) {	1370	} else if (token->id == TokenIdKeywordTrue) {
1371	AstNode *node = ast_create_node(pc, NodeTypeBoolLiteral, token);	1371	AstNode *node = ast_create_node(pc, NodeTypeBoolLiteral, token);
1372	node->data.bool_literal = true;	1372	node->data.bool_literal.value = true;
1373	*token_index += 1;	1373	*token_index += 1;
1374	return node;	1374	return node;
1375	} else if (token->id == TokenIdKeywordFalse) {	1375	} else if (token->id == TokenIdKeywordFalse) {
1376	AstNode *node = ast_create_node(pc, NodeTypeBoolLiteral, token);	1376	AstNode *node = ast_create_node(pc, NodeTypeBoolLiteral, token);
1377	node->data.bool_literal = false;	1377	node->data.bool_literal.value = false;
1378	*token_index += 1;	1378	*token_index += 1;
1379	return node;	1379	return node;
1380	} else if (token->id == TokenIdKeywordNull) {	1380	} else if (token->id == TokenIdKeywordNull) {
...	@@ -1385,7 +1385,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool	...	@@ -1385,7 +1385,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool
1385	*token_index += 1;	1385	*token_index += 1;
1386	Token *name_tok = ast_eat_token(pc, token_index, TokenIdSymbol);	1386	Token *name_tok = ast_eat_token(pc, token_index, TokenIdSymbol);
1387	AstNode *name_node = ast_create_node(pc, NodeTypeSymbol, name_tok);	1387	AstNode *name_node = ast_create_node(pc, NodeTypeSymbol, name_tok);
1388	ast_buf_from_token(pc, name_tok, &name_node->data.symbol);	1388	ast_buf_from_token(pc, name_tok, &name_node->data.symbol_expr.symbol);
1389		1389
1390	AstNode *node = ast_create_node(pc, NodeTypeFnCallExpr, token);	1390	AstNode *node = ast_create_node(pc, NodeTypeFnCallExpr, token);
1391	node->data.fn_call_expr.fn_ref_expr = name_node;	1391	node->data.fn_call_expr.fn_ref_expr = name_node;
...	@@ -1401,7 +1401,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool	...	@@ -1401,7 +1401,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool
1401	} else {	1401	} else {
1402	*token_index += 1;	1402	*token_index += 1;
1403	AstNode *node = ast_create_node(pc, NodeTypeSymbol, token);	1403	AstNode *node = ast_create_node(pc, NodeTypeSymbol, token);
1404	ast_buf_from_token(pc, token, &node->data.symbol);	1404	ast_buf_from_token(pc, token, &node->data.symbol_expr.symbol);
1405	return node;	1405	return node;
1406	}	1406	}
1407	} else if (token->id == TokenIdKeywordGoto) {	1407	} else if (token->id == TokenIdKeywordGoto) {
...	@@ -1412,7 +1412,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool	...	@@ -1412,7 +1412,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, int *token_index, bool
1412	*token_index += 1;	1412	*token_index += 1;
1413	ast_expect_token(pc, dest_symbol, TokenIdSymbol);	1413	ast_expect_token(pc, dest_symbol, TokenIdSymbol);
1414		1414
1415	ast_buf_from_token(pc, dest_symbol, &node->data.go_to.name);	1415	ast_buf_from_token(pc, dest_symbol, &node->data.goto_expr.name);
1416	return node;	1416	return node;
1417	} else if (token->id == TokenIdKeywordBreak) {	1417	} else if (token->id == TokenIdKeywordBreak) {
1418	AstNode *node = ast_create_node(pc, NodeTypeBreak, token);	1418	AstNode *node = ast_create_node(pc, NodeTypeBreak, token);

src/parser.hpp+1-441

...	@@ -8,450 +8,10 @@	...	@@ -8,450 +8,10 @@
8	#ifndef ZIG_PARSER_HPP	8	#ifndef ZIG_PARSER_HPP
9	#define ZIG_PARSER_HPP	9	#define ZIG_PARSER_HPP
10		10
11	#include "list.hpp"	11	#include "all_types.hpp"
12	#include "buffer.hpp"
13	#include "tokenizer.hpp"	12	#include "tokenizer.hpp"
14	#include "errmsg.hpp"	13	#include "errmsg.hpp"
15		14
16	struct AstNode;
17	struct CodeGenNode;
18	struct ImportTableEntry;
19	struct AsmToken;
20
21	enum NodeType {
22	NodeTypeRoot,
23	NodeTypeRootExportDecl,
24	NodeTypeFnProto,
25	NodeTypeFnDef,
26	NodeTypeFnDecl,
27	NodeTypeParamDecl,
28	NodeTypeType,
29	NodeTypeBlock,
30	NodeTypeExternBlock,
31	NodeTypeDirective,
32	NodeTypeReturnExpr,
33	NodeTypeVariableDeclaration,
34	NodeTypeBinOpExpr,
35	NodeTypeCastExpr,
36	NodeTypeNumberLiteral,
37	NodeTypeStringLiteral,
38	NodeTypeCharLiteral,
39	NodeTypeUnreachable,
40	NodeTypeSymbol,
41	NodeTypePrefixOpExpr,
42	NodeTypeFnCallExpr,
43	NodeTypeArrayAccessExpr,
44	NodeTypeSliceExpr,
45	NodeTypeFieldAccessExpr,
46	NodeTypeUse,
47	NodeTypeVoid,
48	NodeTypeBoolLiteral,
49	NodeTypeNullLiteral,
50	NodeTypeIfBoolExpr,
51	NodeTypeIfVarExpr,
52	NodeTypeWhileExpr,
53	NodeTypeLabel,
54	NodeTypeGoto,
55	NodeTypeBreak,
56	NodeTypeContinue,
57	NodeTypeAsmExpr,
58	NodeTypeStructDecl,
59	NodeTypeStructField,
60	NodeTypeStructValueExpr,
61	NodeTypeStructValueField,
62	NodeTypeEnumDecl,
63	NodeTypeEnumField,
64	NodeTypeCompilerFnExpr,
65	NodeTypeCompilerFnType,
66	};
67
68	struct AstNodeRoot {
69	ZigList<AstNode *> top_level_decls;
70	};
71
72	enum VisibMod {
73	VisibModPrivate,
74	VisibModPub,
75	VisibModExport,
76	};
77
78	struct AstNodeFnProto {
79	ZigList<AstNode > directives;
80	VisibMod visib_mod;
81	Buf name;
82	ZigList<AstNode *> params;
83	AstNode *return_type;
84	bool is_var_args;
85
86	// the extern block this fn proto is inside. can be null.
87	// populated by semantic analyzer.
88	AstNode *extern_node;
89	// the struct decl node this fn proto is inside. can be null.
90	// populated by semantic analyzer.
91	AstNode *struct_node;
92	// the function definition this fn proto is inside. can be null.
93	// populated by semantic analyzer.
94	AstNode *fn_def_node;
95	};
96
97	struct AstNodeFnDef {
98	AstNode *fn_proto;
99	AstNode *body;
100	};
101
102	struct AstNodeFnDecl {
103	AstNode *fn_proto;
104	};
105
106	struct AstNodeParamDecl {
107	Buf name;
108	AstNode *type;
109	};
110
111	enum AstNodeTypeType {
112	AstNodeTypeTypePrimitive,
113	AstNodeTypeTypePointer,
114	AstNodeTypeTypeArray,
115	AstNodeTypeTypeMaybe,
116	AstNodeTypeTypeCompilerExpr,
117	};
118
119	struct AstNodeType {
120	AstNodeTypeType type;
121	Buf primitive_name;
122	AstNode *child_type;
123	AstNode *array_size; // can be null
124	bool is_const;
125	bool is_noalias;
126	AstNode *compiler_expr;
127	};
128
129	struct AstNodeBlock {
130	ZigList<AstNode *> statements;
131	};
132
133	struct AstNodeReturnExpr {
134	// might be null in case of return void;
135	AstNode *expr;
136	};
137
138	struct AstNodeVariableDeclaration {
139	Buf symbol;
140	bool is_const;
141	VisibMod visib_mod;
142	// one or both of type and expr will be non null
143	AstNode *type;
144	AstNode *expr;
145	};
146
147	enum BinOpType {
148	BinOpTypeInvalid,
149	BinOpTypeAssign,
150	BinOpTypeAssignTimes,
151	BinOpTypeAssignDiv,
152	BinOpTypeAssignMod,
153	BinOpTypeAssignPlus,
154	BinOpTypeAssignMinus,
155	BinOpTypeAssignBitShiftLeft,
156	BinOpTypeAssignBitShiftRight,
157	BinOpTypeAssignBitAnd,
158	BinOpTypeAssignBitXor,
159	BinOpTypeAssignBitOr,
160	BinOpTypeAssignBoolAnd,
161	BinOpTypeAssignBoolOr,
162	BinOpTypeBoolOr,
163	BinOpTypeBoolAnd,
164	BinOpTypeCmpEq,
165	BinOpTypeCmpNotEq,
166	BinOpTypeCmpLessThan,
167	BinOpTypeCmpGreaterThan,
168	BinOpTypeCmpLessOrEq,
169	BinOpTypeCmpGreaterOrEq,
170	BinOpTypeBinOr,
171	BinOpTypeBinXor,
172	BinOpTypeBinAnd,
173	BinOpTypeBitShiftLeft,
174	BinOpTypeBitShiftRight,
175	BinOpTypeAdd,
176	BinOpTypeSub,
177	BinOpTypeMult,
178	BinOpTypeDiv,
179	BinOpTypeMod,
180	BinOpTypeUnwrapMaybe,
181	};
182
183	struct AstNodeBinOpExpr {
184	AstNode *op1;
185	BinOpType bin_op;
186	AstNode *op2;
187	};
188
189	struct AstNodeFnCallExpr {
190	AstNode *fn_ref_expr;
191	ZigList<AstNode *> params;
192	bool is_builtin;
193	};
194
195	struct AstNodeArrayAccessExpr {
196	AstNode *array_ref_expr;
197	AstNode *subscript;
198	};
199
200	struct AstNodeSliceExpr {
201	AstNode *array_ref_expr;
202	AstNode *start;
203	AstNode *end;
204	bool is_const;
205	};
206
207	struct AstNodeFieldAccessExpr {
208	AstNode *struct_expr;
209	Buf field_name;
210	};
211
212	struct AstNodeExternBlock {
213	ZigList<AstNode > directives;
214	ZigList<AstNode *> fn_decls;
215	};
216
217	struct AstNodeDirective {
218	Buf name;
219	Buf param;
220	};
221
222	struct AstNodeRootExportDecl {
223	Buf type;
224	Buf name;
225	ZigList<AstNode > directives;
226	};
227
228	struct AstNodeCastExpr {
229	AstNode *expr;
230	AstNode *type;
231	};
232
233	enum PrefixOp {
234	PrefixOpInvalid,
235	PrefixOpBoolNot,
236	PrefixOpBinNot,
237	PrefixOpNegation,
238	PrefixOpAddressOf,
239	PrefixOpConstAddressOf,
240	PrefixOpDereference,
241	};
242
243	struct AstNodePrefixOpExpr {
244	PrefixOp prefix_op;
245	AstNode *primary_expr;
246	};
247
248	struct AstNodeUse {
249	Buf path;
250	ZigList<AstNode > directives;
251	};
252
253	struct AstNodeIfBoolExpr {
254	AstNode *condition;
255	AstNode *then_block;
256	AstNode *else_node; // null, block node, or other if expr node
257	};
258
259	struct AstNodeIfVarExpr {
260	AstNodeVariableDeclaration var_decl;
261	AstNode *then_block;
262	AstNode *else_node; // null, block node, or other if expr node
263	};
264
265	struct AstNodeWhileExpr {
266	AstNode *condition;
267	AstNode *body;
268	};
269
270	struct AstNodeLabel {
271	Buf name;
272	};
273
274	struct AstNodeGoto {
275	Buf name;
276	};
277
278	struct AsmOutput {
279	Buf asm_symbolic_name;
280	Buf constraint;
281	Buf variable_name;
282	AstNode *return_type; // null unless "=r" and return
283	};
284
285	struct AsmInput {
286	Buf asm_symbolic_name;
287	Buf constraint;
288	AstNode *expr;
289	};
290
291	struct SrcPos {
292	int line;
293	int column;
294	};
295
296	struct AstNodeAsmExpr {
297	bool is_volatile;
298	Buf asm_template;
299	ZigList<SrcPos> offset_map;
300	ZigList<AsmToken> token_list;
301	ZigList<AsmOutput*> output_list;
302	ZigList<AsmInput*> input_list;
303	ZigList<Buf*> clobber_list;
304	int return_count; // populated by analyze
305	};
306
307	struct AstNodeStructDecl {
308	Buf name;
309	ZigList<AstNode *> fields;
310	ZigList<AstNode *> fns;
311	ZigList<AstNode > directives;
312	VisibMod visib_mod;
313	};
314
315	struct AstNodeStructField {
316	Buf name;
317	AstNode *type;
318	ZigList<AstNode > directives;
319	};
320
321	struct AstNodeEnumDecl {
322	Buf name;
323	ZigList<AstNode *> fields;
324	ZigList<AstNode > directives;
325	VisibMod visib_mod;
326	};
327
328	struct AstNodeEnumField {
329	Buf name;
330	ZigList<AstNode *> fields; // length 0 means simple enum
331	AstNode *val_expr;
332	};
333
334	struct AstNodeStringLiteral {
335	Buf buf;
336	bool c;
337	};
338
339	struct AstNodeCharLiteral {
340	uint8_t value;
341	};
342
343	enum NumLit {
344	NumLitF32,
345	NumLitF64,
346	NumLitF128,
347	NumLitU8,
348	NumLitU16,
349	NumLitU32,
350	NumLitU64,
351	NumLitI8,
352	NumLitI16,
353	NumLitI32,
354	NumLitI64,
355
356	NumLitCount
357	};
358
359	struct AstNodeNumberLiteral {
360	NumLit kind;
361
362	// overflow is true if when parsing the number, we discovered it would not
363	// fit without losing data in a uint64_t, int64_t, or double
364	bool overflow;
365
366	union {
367	uint64_t x_uint;
368	int64_t x_int;
369	double x_float;
370	} data;
371	};
372
373	struct AstNodeStructValueField {
374	Buf name;
375	AstNode *expr;
376	};
377
378	struct AstNodeStructValueExpr {
379	AstNode *type;
380	ZigList<AstNode *> fields;
381	};
382
383	struct AstNodeCompilerFnExpr {
384	Buf name;
385	AstNode *expr;
386	};
387
388	struct AstNodeCompilerFnType {
389	Buf name;
390	AstNode *type;
391	};
392
393	struct AstNode {
394	enum NodeType type;
395	int line;
396	int column;
397	uint32_t create_index; // for determinism purposes
398	CodeGenNode *codegen_node;
399	ImportTableEntry *owner;
400	union {
401	AstNodeRoot root;
402	AstNodeRootExportDecl root_export_decl;
403	AstNodeFnDef fn_def;
404	AstNodeFnDecl fn_decl;
405	AstNodeFnProto fn_proto;
406	AstNodeType type;
407	AstNodeParamDecl param_decl;
408	AstNodeBlock block;
409	AstNodeReturnExpr return_expr;
410	AstNodeVariableDeclaration variable_declaration;
411	AstNodeBinOpExpr bin_op_expr;
412	AstNodeExternBlock extern_block;
413	AstNodeDirective directive;
414	AstNodeCastExpr cast_expr;
415	AstNodePrefixOpExpr prefix_op_expr;
416	AstNodeFnCallExpr fn_call_expr;
417	AstNodeArrayAccessExpr array_access_expr;
418	AstNodeSliceExpr slice_expr;
419	AstNodeUse use;
420	AstNodeIfBoolExpr if_bool_expr;
421	AstNodeIfVarExpr if_var_expr;
422	AstNodeWhileExpr while_expr;
423	AstNodeLabel label;
424	AstNodeGoto go_to;
425	AstNodeAsmExpr asm_expr;
426	AstNodeFieldAccessExpr field_access_expr;
427	AstNodeStructDecl struct_decl;
428	AstNodeStructField struct_field;
429	AstNodeEnumDecl enum_decl;
430	AstNodeEnumField enum_field;
431	AstNodeStringLiteral string_literal;
432	AstNodeCharLiteral char_literal;
433	AstNodeNumberLiteral number_literal;
434	AstNodeStructValueExpr struct_val_expr;
435	AstNodeStructValueField struct_val_field;
436	AstNodeCompilerFnExpr compiler_fn_expr;
437	AstNodeCompilerFnType compiler_fn_type;
438	Buf symbol;
439	bool bool_literal;
440	} data;
441	};
442
443	enum AsmTokenId {
444	AsmTokenIdTemplate,
445	AsmTokenIdPercent,
446	AsmTokenIdVar,
447	};
448
449	struct AsmToken {
450	enum AsmTokenId id;
451	int start;
452	int end;
453	};
454
455	__attribute__ ((format (printf, 2, 3)))	15	__attribute__ ((format (printf, 2, 3)))
456	void ast_token_error(Token token, const char format, ...);	16	void ast_token_error(Token token, const char format, ...);
457		17