Commit b581da41f82cd1e19701030bf47675b426608adf | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-09-28 02:33:32-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-09-28 02:33:32-04:00
log	b581da41f82cd1e19701030bf47675b426608adf
tree	bbfebb52858935e2e91ffabd8b0c2b02fb58ca27
parent	e5fd8efcb60cd0223a7dd5e5825d3b9efc006c2a

remove compiler directives

 * add `setFnTest`, `setFnVisible`, `setFnStaticEval`,
   `setFnNoInline` builtin functions to replace previous
   directive functionality
 * add `coldcc` and `nakedcc` as keywords which can be used as part
   of a function prototype.
 * `setDebugSafety` builtin can be used to set debug safety features
   at a per block scope level.
 * closes #169

40 files changed, 812 insertions(+), 528 deletions(-)

doc/langref.md+6-6

...	...	@@ -3,9 +3,11 @@
3	3	## Grammar
4	4
5	5	```
6		Root = many(TopLevelDecl) "EOF"
	6	Root = many(TopLevelItem) "EOF"
7	7
8		TopLevelDecl = many(Directive) option(VisibleMod) (FnDef \| ExternDecl \| ContainerDecl \| GlobalVarDecl \| ErrorValueDecl \| TypeDecl \| UseDecl)
	8	TopLevelItem = ErrorValueDecl \| Block \| TopLevelDecl
	9
	10	TopLevelDecl = option(VisibleMod) (FnDef \| ExternDecl \| ContainerDecl \| GlobalVarDecl \| TypeDecl \| UseDecl)
9	11
10	12	TypeDecl = "type" Symbol "=" TypeExpr ";"
11	13
...	...	@@ -17,7 +19,7 @@ VariableDeclaration = ("var" \| "const") Symbol option(":" TypeExpr) "=" Expressi
17	19
18	20	ContainerDecl = ("struct" \| "enum" \| "union") Symbol option(ParamDeclList) "{" many(StructMember) "}"
19	21
20		StructMember = many(Directive) option(VisibleMod) (StructField \| FnDef \| GlobalVarDecl \| ContainerDecl)
	22	StructMember = (StructField \| FnDef \| GlobalVarDecl \| ContainerDecl)
21	23
22	24	StructField = Symbol option(":" Expression) ",")
23	25
...	...	@@ -25,9 +27,7 @@ UseDecl = "use" Expression ";"
25	27
26	28	ExternDecl = "extern" (FnProto \| VariableDeclaration) ";"
27	29
28		FnProto = "fn" option(Symbol) ParamDeclList option("->" TypeExpr)
29
30		Directive = "#" Symbol "(" Expression ")"
	30	FnProto = option("coldcc" \| "nakedcc") "fn" option(Symbol) ParamDeclList option("->" TypeExpr)
31	31
32	32	VisibleMod = "pub" \| "export"
33	33

doc/vim/syntax/zig.vim+1-1

...	...	@@ -8,7 +8,7 @@ if exists("b:current_syntax")
8	8	endif
9	9	let b:current_syntax = "zig"
10	10
11		syn keyword zigStorage const var extern export pub noalias inline noinline
	11	syn keyword zigStorage const var extern export pub noalias inline nakedcc coldcc
12	12	syn keyword zigStructure struct enum union
13	13	syn keyword zigStatement goto break return continue asm defer
14	14	syn keyword zigConditional if else switch

src/all_types.hpp+13-9

...	...	@@ -129,7 +129,6 @@ enum TldResolution {
129	129	struct TopLevelDecl {
130	130	// populated by parser
131	131	Buf *name;
132		ZigList<AstNode > directives;
133	132	VisibMod visib_mod;
134	133
135	134	// populated by semantic analyzer
...	...	@@ -153,7 +152,6 @@ enum NodeType {
153	152	NodeTypeFnDecl,
154	153	NodeTypeParamDecl,
155	154	NodeTypeBlock,
156		NodeTypeDirective,
157	155	NodeTypeReturnExpr,
158	156	NodeTypeDefer,
159	157	NodeTypeVariableDeclaration,
...	...	@@ -210,6 +208,8 @@ struct AstNodeFnProto {
210	208	bool is_var_args;
211	209	bool is_extern;
212	210	bool is_inline;
	211	bool is_coldcc;
	212	bool is_nakedcc;
213	213
214	214	// populated by semantic analyzer:
215	215
...	...	@@ -459,11 +459,6 @@ struct AstNodeFieldAccessExpr {
459	459	AstNode *container_init_expr_node;
460	460	};
461	461
462		struct AstNodeDirective {
463		Buf *name;
464		AstNode *expr;
465		};
466
467	462	enum PrefixOp {
468	463	PrefixOpInvalid,
469	464	PrefixOpBoolNot,
...	...	@@ -802,7 +797,6 @@ struct AstNode {
802	797	AstNodeErrorValueDecl error_value_decl;
803	798	AstNodeBinOpExpr bin_op_expr;
804	799	AstNodeUnwrapErrorExpr unwrap_err_expr;
805		AstNodeDirective directive;
806	800	AstNodePrefixOpExpr prefix_op_expr;
807	801	AstNodeFnCallExpr fn_call_expr;
808	802	AstNodeArrayAccessExpr array_access_expr;
...	...	@@ -1109,10 +1103,14 @@ struct FnTableEntry {
1109	1103	WantPure want_pure;
1110	1104	AstNode *want_pure_attr_node;
1111	1105	AstNode *want_pure_return_type;
1112		bool safety_off;
1113	1106	FnInline fn_inline;
1114	1107	FnAnalState anal_state;
1115	1108
	1109	AstNode *fn_no_inline_set_node;
	1110	AstNode *fn_export_set_node;
	1111	AstNode *fn_test_set_node;
	1112	AstNode *fn_static_eval_set_node;
	1113
1116	1114	ZigList<AstNode *> cast_alloca_list;
1117	1115	ZigList<StructValExprCodeGen *> struct_val_expr_alloca_list;
1118	1116	ZigList<VariableTableEntry *> variable_list;
...	...	@@ -1154,6 +1152,11 @@ enum BuiltinFnId {
1154	1152	BuiltinFnIdTruncate,
1155	1153	BuiltinFnIdIntType,
1156	1154	BuiltinFnIdUnreachable,
	1155	BuiltinFnIdSetFnTest,
	1156	BuiltinFnIdSetFnVisible,
	1157	BuiltinFnIdSetFnStaticEval,
	1158	BuiltinFnIdSetFnNoInline,
	1159	BuiltinFnIdSetDebugSafety,
1157	1160	};
1158	1161
1159	1162	struct BuiltinFnEntry {
...	...	@@ -1373,6 +1376,7 @@ struct BlockContext {
1373	1376	bool codegen_excluded;
1374	1377
1375	1378	bool safety_off;
	1379	AstNode *safety_set_node;
1376	1380	};
1377	1381
1378	1382	enum AtomicOrder {

src/analyze.cpp+231-96

...	...	@@ -75,7 +75,6 @@ static AstNode first_executing_node(AstNode node) {
75	75	case NodeTypeFnDecl:
76	76	case NodeTypeParamDecl:
77	77	case NodeTypeBlock:
78		case NodeTypeDirective:
79	78	case NodeTypeReturnExpr:
80	79	case NodeTypeDefer:
81	80	case NodeTypeVariableDeclaration:
...	...	@@ -1123,6 +1122,28 @@ static bool resolve_const_expr_bool(CodeGen g, ImportTableEntry import, BlockC
1123	1122	return true;
1124	1123	}
1125	1124
	1125	static FnTableEntry resolve_const_expr_fn(CodeGen g, ImportTableEntry import, BlockContext context,
	1126	AstNode **node)
	1127	{
	1128	TypeTableEntry resolved_type = analyze_expression(g, import, context, nullptr, node);
	1129
	1130	if (resolved_type->id == TypeTableEntryIdInvalid) {
	1131	return nullptr;
	1132	} else if (resolved_type->id == TypeTableEntryIdFn) {
	1133	ConstExprValue const_val = &get_resolved_expr(node)->const_val;
	1134
	1135	if (!const_val->ok) {
	1136	add_node_error(g, *node, buf_sprintf("unable to evaluate constant expression"));
	1137	return nullptr;
	1138	}
	1139
	1140	return const_val->data.x_fn;
	1141	} else {
	1142	add_node_error(g, *node, buf_sprintf("expected function, got '%s'", buf_ptr(&resolved_type->name)));
	1143	return nullptr;
	1144	}
	1145	}
	1146
1126	1147	static void resolve_function_proto(CodeGen g, AstNode node, FnTableEntry *fn_table_entry,
1127	1148	ImportTableEntry import, BlockContext containing_context)
1128	1149	{
...	...	@@ -1133,85 +1154,6 @@ static void resolve_function_proto(CodeGen g, AstNode node, FnTableEntry *fn_t
1133	1154	return;
1134	1155	}
1135	1156
1136		bool is_cold = false;
1137		bool is_naked = false;
1138		bool is_test = false;
1139		bool is_noinline = false;
1140
1141		if (fn_proto->top_level_decl.directives) {
1142		for (size_t i = 0; i < fn_proto->top_level_decl.directives->length; i += 1) {
1143		AstNode *directive_node = fn_proto->top_level_decl.directives->at(i);
1144		Buf *name = directive_node->data.directive.name;
1145
1146		if (buf_eql_str(name, "attribute")) {
1147		if (fn_table_entry->fn_def_node) {
1148		Buf *attr_name = resolve_const_expr_str(g, import, import->block_context,
1149		&directive_node->data.directive.expr);
1150		if (attr_name) {
1151		if (buf_eql_str(attr_name, "naked")) {
1152		is_naked = true;
1153		} else if (buf_eql_str(attr_name, "noinline")) {
1154		is_noinline = true;
1155		} else if (buf_eql_str(attr_name, "cold")) {
1156		is_cold = true;
1157		} else if (buf_eql_str(attr_name, "test")) {
1158		is_test = true;
1159		g->test_fn_count += 1;
1160		} else {
1161		add_node_error(g, directive_node,
1162		buf_sprintf("invalid function attribute: '%s'", buf_ptr(name)));
1163		}
1164		}
1165		} else {
1166		add_node_error(g, directive_node,
1167		buf_sprintf("invalid function attribute: '%s'", buf_ptr(name)));
1168		}
1169		} else if (buf_eql_str(name, "debug_safety")) {
1170		if (!fn_table_entry->fn_def_node) {
1171		add_node_error(g, directive_node,
1172		buf_sprintf("#debug_safety valid only on function definitions"));
1173		} else {
1174		bool enable;
1175		bool ok = resolve_const_expr_bool(g, import, import->block_context,
1176		&directive_node->data.directive.expr, &enable);
1177		if (ok && !enable) {
1178		fn_table_entry->safety_off = true;
1179		}
1180		}
1181		} else if (buf_eql_str(name, "condition")) {
1182		if (fn_proto->top_level_decl.visib_mod == VisibModExport) {
1183		bool include;
1184		bool ok = resolve_const_expr_bool(g, import, import->block_context,
1185		&directive_node->data.directive.expr, &include);
1186		if (ok && !include) {
1187		fn_proto->top_level_decl.visib_mod = VisibModPub;
1188		}
1189		} else {
1190		add_node_error(g, directive_node,
1191		buf_sprintf("#condition valid only on exported symbols"));
1192		}
1193		} else if (buf_eql_str(name, "static_eval_enable")) {
1194		if (!fn_table_entry->fn_def_node) {
1195		add_node_error(g, directive_node,
1196		buf_sprintf("#static_val_enable valid only on function definitions"));
1197		} else {
1198		bool enable;
1199		bool ok = resolve_const_expr_bool(g, import, import->block_context,
1200		&directive_node->data.directive.expr, &enable);
1201		if (!ok \|\| !enable) {
1202		fn_table_entry->want_pure = WantPureFalse;
1203		} else if (ok && enable) {
1204		fn_table_entry->want_pure = WantPureTrue;
1205		fn_table_entry->want_pure_attr_node = directive_node->data.directive.expr;
1206		}
1207		}
1208		} else {
1209		add_node_error(g, directive_node,
1210		buf_sprintf("invalid directive: '%s'", buf_ptr(name)));
1211		}
1212		}
1213		}
1214
1215	1157	bool is_internal = (fn_proto->top_level_decl.visib_mod != VisibModExport);
1216	1158	bool is_c_compat = !is_internal \|\| fn_proto->is_extern;
1217	1159	fn_table_entry->internal_linkage = !is_c_compat;
...	...	@@ -1219,24 +1161,17 @@ static void resolve_function_proto(CodeGen g, AstNode node, FnTableEntry *fn_t
1219	1161
1220	1162
1221	1163	TypeTableEntry *fn_type = analyze_fn_proto_type(g, import, containing_context, nullptr, node,
1222		is_naked, is_cold, fn_table_entry);
	1164	fn_proto->is_nakedcc, fn_proto->is_coldcc, fn_table_entry);
1223	1165
1224	1166	fn_table_entry->type_entry = fn_type;
1225		fn_table_entry->is_test = is_test;
1226	1167
1227	1168	if (fn_type->id == TypeTableEntryIdInvalid) {
1228	1169	fn_proto->skip = true;
1229	1170	return;
1230	1171	}
1231	1172
1232		if (fn_proto->is_inline && is_noinline) {
1233		add_node_error(g, node, buf_sprintf("function is both inline and noinline"));
1234		fn_proto->skip = true;
1235		return;
1236		} else if (fn_proto->is_inline) {
	1173	if (fn_proto->is_inline) {
1237	1174	fn_table_entry->fn_inline = FnInlineAlways;
1238		} else if (is_noinline) {
1239		fn_table_entry->fn_inline = FnInlineNever;
1240	1175	}
1241	1176
1242	1177
...	...	@@ -1881,7 +1816,6 @@ static void resolve_top_level_decl(CodeGen g, AstNode node, bool pointer_only)
1881	1816	zig_panic("TODO resolve_top_level_decl NodeTypeUse");
1882	1817	break;
1883	1818	case NodeTypeFnDef:
1884		case NodeTypeDirective:
1885	1819	case NodeTypeParamDecl:
1886	1820	case NodeTypeFnDecl:
1887	1821	case NodeTypeReturnExpr:
...	...	@@ -2406,13 +2340,11 @@ BlockContext new_block_context(AstNode node, BlockContext *parent) {
2406	2340	context->parent_loop_node = parent->parent_loop_node;
2407	2341	context->c_import_buf = parent->c_import_buf;
2408	2342	context->codegen_excluded = parent->codegen_excluded;
2409		context->safety_off = parent->safety_off;
2410	2343	}
2411	2344
2412	2345	if (node && node->type == NodeTypeFnDef) {
2413	2346	AstNode *fn_proto_node = node->data.fn_def.fn_proto;
2414	2347	context->fn_entry = fn_proto_node->data.fn_proto.fn_table_entry;
2415		context->safety_off = context->fn_entry->safety_off;
2416	2348	} else if (parent) {
2417	2349	context->fn_entry = parent->fn_entry;
2418	2350	}
...	...	@@ -5246,6 +5178,203 @@ static TypeTableEntry analyze_int_type(CodeGen g, ImportTableEntry *import,
5246	5178
5247	5179	}
5248	5180
	5181	static TypeTableEntry analyze_set_fn_test(CodeGen g, ImportTableEntry *import,
	5182	BlockContext context, AstNode node)
	5183	{
	5184	AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
	5185	AstNode **value_node = &node->data.fn_call_expr.params.at(1);
	5186
	5187	FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
	5188	if (!fn_entry) {
	5189	return g->builtin_types.entry_invalid;
	5190	}
	5191
	5192	bool ok = resolve_const_expr_bool(g, import, context, value_node, &fn_entry->is_test);
	5193	if (!ok) {
	5194	return g->builtin_types.entry_invalid;
	5195	}
	5196
	5197	if (fn_entry->fn_test_set_node) {
	5198	ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function test attribute set twice"));
	5199	add_error_note(g, msg, fn_entry->fn_test_set_node, buf_sprintf("first set here"));
	5200	return g->builtin_types.entry_invalid;
	5201	}
	5202	fn_entry->fn_test_set_node = node;
	5203
	5204	g->test_fn_count += 1;
	5205	return g->builtin_types.entry_void;
	5206	}
	5207
	5208	static TypeTableEntry analyze_set_fn_no_inline(CodeGen g, ImportTableEntry *import,
	5209	BlockContext context, AstNode node)
	5210	{
	5211	AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
	5212	AstNode **value_node = &node->data.fn_call_expr.params.at(1);
	5213
	5214	FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
	5215	if (!fn_entry) {
	5216	return g->builtin_types.entry_invalid;
	5217	}
	5218
	5219	bool is_noinline;
	5220	bool ok = resolve_const_expr_bool(g, import, context, value_node, &is_noinline);
	5221	if (!ok) {
	5222	return g->builtin_types.entry_invalid;
	5223	}
	5224
	5225	if (fn_entry->fn_no_inline_set_node) {
	5226	ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function no inline attribute set twice"));
	5227	add_error_note(g, msg, fn_entry->fn_no_inline_set_node, buf_sprintf("first set here"));
	5228	return g->builtin_types.entry_invalid;
	5229	}
	5230	fn_entry->fn_no_inline_set_node = node;
	5231
	5232	if (fn_entry->fn_inline == FnInlineAlways) {
	5233	add_node_error(g, node, buf_sprintf("function is both inline and noinline"));
	5234	fn_entry->proto_node->data.fn_proto.skip = true;
	5235	return g->builtin_types.entry_invalid;
	5236	} else if (is_noinline) {
	5237	fn_entry->fn_inline = FnInlineNever;
	5238	}
	5239
	5240	return g->builtin_types.entry_void;
	5241	}
	5242
	5243	static TypeTableEntry analyze_set_fn_static_eval(CodeGen g, ImportTableEntry *import,
	5244	BlockContext context, AstNode node)
	5245	{
	5246	AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
	5247	AstNode **value_node = &node->data.fn_call_expr.params.at(1);
	5248
	5249	FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
	5250	if (!fn_entry) {
	5251	return g->builtin_types.entry_invalid;
	5252	}
	5253
	5254	bool want_static_eval;
	5255	bool ok = resolve_const_expr_bool(g, import, context, value_node, &want_static_eval);
	5256	if (!ok) {
	5257	return g->builtin_types.entry_invalid;
	5258	}
	5259
	5260	if (fn_entry->fn_static_eval_set_node) {
	5261	ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function static eval attribute set twice"));
	5262	add_error_note(g, msg, fn_entry->fn_static_eval_set_node, buf_sprintf("first set here"));
	5263	return g->builtin_types.entry_invalid;
	5264	}
	5265	fn_entry->fn_static_eval_set_node = node;
	5266
	5267	if (want_static_eval && !context->fn_entry->is_pure) {
	5268	add_node_error(g, node, buf_sprintf("attribute appears too late within function"));
	5269	return g->builtin_types.entry_invalid;
	5270	}
	5271
	5272	if (want_static_eval) {
	5273	fn_entry->want_pure = WantPureTrue;
	5274	fn_entry->want_pure_attr_node = node;
	5275	} else {
	5276	fn_entry->want_pure = WantPureFalse;
	5277	fn_entry->is_pure = false;
	5278	}
	5279
	5280	return g->builtin_types.entry_void;
	5281	}
	5282
	5283	static TypeTableEntry analyze_set_fn_visible(CodeGen g, ImportTableEntry *import,
	5284	BlockContext context, AstNode node)
	5285	{
	5286	AstNode **fn_node = &node->data.fn_call_expr.params.at(0);
	5287	AstNode **value_node = &node->data.fn_call_expr.params.at(1);
	5288
	5289	FnTableEntry *fn_entry = resolve_const_expr_fn(g, import, context, fn_node);
	5290	if (!fn_entry) {
	5291	return g->builtin_types.entry_invalid;
	5292	}
	5293
	5294	bool want_export;
	5295	bool ok = resolve_const_expr_bool(g, import, context, value_node, &want_export);
	5296	if (!ok) {
	5297	return g->builtin_types.entry_invalid;
	5298	}
	5299
	5300	if (fn_entry->fn_export_set_node) {
	5301	ErrorMsg *msg = add_node_error(g, node, buf_sprintf("function visibility set twice"));
	5302	add_error_note(g, msg, fn_entry->fn_export_set_node, buf_sprintf("first set here"));
	5303	return g->builtin_types.entry_invalid;
	5304	}
	5305	fn_entry->fn_export_set_node = node;
	5306
	5307	AstNodeFnProto *fn_proto = &fn_entry->proto_node->data.fn_proto;
	5308	if (fn_proto->top_level_decl.visib_mod != VisibModExport) {
	5309	ErrorMsg *msg = add_node_error(g, node,
	5310	buf_sprintf("function must be marked export to set function visibility"));
	5311	add_error_note(g, msg, fn_entry->proto_node, buf_sprintf("function declared here"));
	5312	return g->builtin_types.entry_void;
	5313	}
	5314	if (!want_export) {
	5315	fn_proto->top_level_decl.visib_mod = VisibModPub;
	5316	}
	5317
	5318	return g->builtin_types.entry_void;
	5319	}
	5320
	5321	static TypeTableEntry analyze_set_debug_safety(CodeGen g, ImportTableEntry *import,
	5322	BlockContext parent_context, AstNode node)
	5323	{
	5324	AstNode **target_node = &node->data.fn_call_expr.params.at(0);
	5325	AstNode **value_node = &node->data.fn_call_expr.params.at(1);
	5326
	5327	TypeTableEntry target_type = analyze_expression(g, import, parent_context, nullptr, target_node);
	5328	BlockContext *target_context;
	5329	ConstExprValue const_val = &get_resolved_expr(target_node)->const_val;
	5330	if (target_type->id == TypeTableEntryIdInvalid) {
	5331	return g->builtin_types.entry_invalid;
	5332	}
	5333	if (!const_val->ok) {
	5334	add_node_error(g, *target_node, buf_sprintf("unable to evaluate constant expression"));
	5335	return g->builtin_types.entry_invalid;
	5336	}
	5337	if (target_type->id == TypeTableEntryIdBlock) {
	5338	target_context = const_val->data.x_block;
	5339	} else if (target_type->id == TypeTableEntryIdFn) {
	5340	target_context = const_val->data.x_fn->fn_def_node->data.fn_def.block_context;
	5341	} else if (target_type->id == TypeTableEntryIdMetaType) {
	5342	TypeTableEntry *type_arg = const_val->data.x_type;
	5343	if (type_arg->id == TypeTableEntryIdStruct) {
	5344	target_context = type_arg->data.structure.block_context;
	5345	} else if (type_arg->id == TypeTableEntryIdEnum) {
	5346	target_context = type_arg->data.enumeration.block_context;
	5347	} else if (type_arg->id == TypeTableEntryIdUnion) {
	5348	target_context = type_arg->data.unionation.block_context;
	5349	} else {
	5350	add_node_error(g, *target_node,
	5351	buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&type_arg->name)));
	5352	return g->builtin_types.entry_invalid;
	5353	}
	5354	} else {
	5355	add_node_error(g, *target_node,
	5356	buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&target_type->name)));
	5357	return g->builtin_types.entry_invalid;
	5358	}
	5359
	5360	bool want_debug_safety;
	5361	bool ok = resolve_const_expr_bool(g, import, parent_context, value_node, &want_debug_safety);
	5362	if (!ok) {
	5363	return g->builtin_types.entry_invalid;
	5364	}
	5365
	5366	if (target_context->safety_set_node) {
	5367	ErrorMsg *msg = add_node_error(g, node, buf_sprintf("debug safety for scope set twice"));
	5368	add_error_note(g, msg, target_context->safety_set_node, buf_sprintf("first set here"));
	5369	return g->builtin_types.entry_invalid;
	5370	}
	5371	target_context->safety_set_node = node;
	5372
	5373	target_context->safety_off = !want_debug_safety;
	5374
	5375	return g->builtin_types.entry_void;
	5376	}
	5377
5249	5378	static TypeTableEntry analyze_builtin_fn_call_expr(CodeGen g, ImportTableEntry import, BlockContext context,
5250	5379	TypeTableEntry expected_type, AstNode node)
5251	5380	{
...	...	@@ -5607,6 +5736,16 @@ static TypeTableEntry analyze_builtin_fn_call_expr(CodeGen g, ImportTableEntry
5607	5736	return analyze_int_type(g, import, context, node);
5608	5737	case BuiltinFnIdUnreachable:
5609	5738	return g->builtin_types.entry_unreachable;
	5739	case BuiltinFnIdSetFnTest:
	5740	return analyze_set_fn_test(g, import, context, node);
	5741	case BuiltinFnIdSetFnNoInline:
	5742	return analyze_set_fn_no_inline(g, import, context, node);
	5743	case BuiltinFnIdSetFnStaticEval:
	5744	return analyze_set_fn_static_eval(g, import, context, node);
	5745	case BuiltinFnIdSetFnVisible:
	5746	return analyze_set_fn_visible(g, import, context, node);
	5747	case BuiltinFnIdSetDebugSafety:
	5748	return analyze_set_debug_safety(g, import, context, node);
5610	5749	}
5611	5750	zig_unreachable();
5612	5751	}
...	...	@@ -6876,7 +7015,6 @@ static TypeTableEntry analyze_expression_pointer_only(CodeGen g, ImportTableEn
6876	7015	break;
6877	7016	case NodeTypeSwitchProng:
6878	7017	case NodeTypeSwitchRange:
6879		case NodeTypeDirective:
6880	7018	case NodeTypeFnDecl:
6881	7019	case NodeTypeParamDecl:
6882	7020	case NodeTypeRoot:
...	...	@@ -7109,7 +7247,6 @@ static void scan_decls(CodeGen g, ImportTableEntry import, BlockContext *conte
7109	7247	// error value declarations do not depend on other top level decls
7110	7248	preview_error_value_decl(g, node);
7111	7249	break;
7112		case NodeTypeDirective:
7113	7250	case NodeTypeParamDecl:
7114	7251	case NodeTypeFnDecl:
7115	7252	case NodeTypeReturnExpr:
...	...	@@ -7418,7 +7555,6 @@ Expr get_resolved_expr(AstNode node) {
7418	7555	case NodeTypeFnDef:
7419	7556	case NodeTypeFnDecl:
7420	7557	case NodeTypeParamDecl:
7421		case NodeTypeDirective:
7422	7558	case NodeTypeUse:
7423	7559	case NodeTypeContainerDecl:
7424	7560	case NodeTypeStructField:
...	...	@@ -7469,7 +7605,6 @@ static TopLevelDecl get_as_top_level_decl(AstNode node) {
7469	7605	case NodeTypeFnDecl:
7470	7606	case NodeTypeParamDecl:
7471	7607	case NodeTypeBlock:
7472		case NodeTypeDirective:
7473	7608	case NodeTypeStringLiteral:
7474	7609	case NodeTypeCharLiteral:
7475	7610	case NodeTypeSymbol:

src/ast_render.cpp-14

...	...	@@ -141,8 +141,6 @@ static const char *node_type_str(NodeType node_type) {
141	141	return "ArrayAccessExpr";
142	142	case NodeTypeSliceExpr:
143	143	return "SliceExpr";
144		case NodeTypeDirective:
145		return "Directive";
146	144	case NodeTypeReturnExpr:
147	145	return "ReturnExpr";
148	146	case NodeTypeDefer:
...	...	@@ -416,13 +414,6 @@ static void render_node(AstRender ar, AstNode node) {
416	414	}
417	415	case NodeTypeFnDef:
418	416	{
419		ZigList<AstNode > directives =
420		node->data.fn_def.fn_proto->data.fn_proto.top_level_decl.directives;
421		if (directives) {
422		for (size_t i = 0; i < directives->length; i += 1) {
423		render_node(ar, directives->at(i));
424		}
425		}
426	417	render_node(ar, node->data.fn_def.fn_proto);
427	418	fprintf(ar->f, " ");
428	419	render_node(ar, node->data.fn_def.body);
...	...	@@ -445,11 +436,6 @@ static void render_node(AstRender ar, AstNode node) {
445	436	print_indent(ar);
446	437	fprintf(ar->f, "}");
447	438	break;
448		case NodeTypeDirective:
449		fprintf(ar->f, "#%s(", buf_ptr(node->data.directive.name));
450		render_node(ar, node->data.directive.expr);
451		fprintf(ar->f, ")\n");
452		break;
453	439	case NodeTypeReturnExpr:
454	440	{
455	441	const char *return_str = return_string(node->data.return_expr.kind);

src/codegen.cpp+25-2

...	...	@@ -352,8 +352,20 @@ static LLVMValueRef get_handle_value(CodeGen g, AstNode source_node, LLVMValue
352	352	}
353	353	}
354	354
	355	static bool want_debug_safety_recursive(CodeGen g, BlockContext context) {
	356	if (context->safety_set_node \|\| !context->parent) {
	357	return !context->safety_off;
	358	}
	359	context->safety_off = want_debug_safety_recursive(g, context->parent);
	360	context->safety_set_node = context->parent->safety_set_node;
	361	return !context->safety_off;
	362	}
	363
355	364	static bool want_debug_safety(CodeGen g, AstNode node) {
356		return !g->is_release_build && !node->block_context->safety_off;
	365	if (g->is_release_build) {
	366	return false;
	367	}
	368	return want_debug_safety_recursive(g, node->block_context);
357	369	}
358	370
359	371	static void gen_debug_safety_crash(CodeGen *g) {
...	...	@@ -709,6 +721,13 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen g, AstNode node) {
709	721	return gen_truncate(g, node);
710	722	case BuiltinFnIdUnreachable:
711	723	return gen_unreachable(g, node);
	724	case BuiltinFnIdSetFnTest:
	725	case BuiltinFnIdSetFnVisible:
	726	case BuiltinFnIdSetFnStaticEval:
	727	case BuiltinFnIdSetFnNoInline:
	728	case BuiltinFnIdSetDebugSafety:
	729	// do nothing
	730	return nullptr;
712	731	}
713	732	zig_unreachable();
714	733	}
...	...	@@ -3617,7 +3636,6 @@ static LLVMValueRef gen_expr(CodeGen g, AstNode node) {
3617	3636	case NodeTypeFnDef:
3618	3637	case NodeTypeFnDecl:
3619	3638	case NodeTypeParamDecl:
3620		case NodeTypeDirective:
3621	3639	case NodeTypeUse:
3622	3640	case NodeTypeContainerDecl:
3623	3641	case NodeTypeStructField:
...	...	@@ -4880,6 +4898,11 @@ static void define_builtin_fns(CodeGen *g) {
4880	4898	create_builtin_fn_with_arg_count(g, BuiltinFnIdCompileErr, "compileError", 1);
4881	4899	create_builtin_fn_with_arg_count(g, BuiltinFnIdIntType, "intType", 2);
4882	4900	create_builtin_fn_with_arg_count(g, BuiltinFnIdUnreachable, "unreachable", 0);
	4901	create_builtin_fn_with_arg_count(g, BuiltinFnIdSetFnTest, "setFnTest", 2);
	4902	create_builtin_fn_with_arg_count(g, BuiltinFnIdSetFnVisible, "setFnVisible", 2);
	4903	create_builtin_fn_with_arg_count(g, BuiltinFnIdSetFnStaticEval, "setFnStaticEval", 2);
	4904	create_builtin_fn_with_arg_count(g, BuiltinFnIdSetFnNoInline, "setFnNoInline", 2);
	4905	create_builtin_fn_with_arg_count(g, BuiltinFnIdSetDebugSafety, "setDebugSafety", 2);
4883	4906	}
4884	4907
4885	4908	static void init(CodeGen g, Buf source_path) {

src/eval.cpp+6-1

...	...	@@ -963,6 +963,12 @@ static bool eval_fn_call_builtin(EvalFn ef, AstNode node, ConstExprValue *out_
963	963	case BuiltinFnIdCompileErr:
964	964	case BuiltinFnIdIntType:
965	965	zig_unreachable();
	966	case BuiltinFnIdSetFnTest:
	967	case BuiltinFnIdSetFnVisible:
	968	case BuiltinFnIdSetFnStaticEval:
	969	case BuiltinFnIdSetFnNoInline:
	970	case BuiltinFnIdSetDebugSafety:
	971	return false;
966	972	}
967	973
968	974	return false;
...	...	@@ -1398,7 +1404,6 @@ static bool eval_expr(EvalFn ef, AstNode node, ConstExprValue *out) {
1398	1404	case NodeTypeUse:
1399	1405	case NodeTypeAsmExpr:
1400	1406	case NodeTypeParamDecl:
1401		case NodeTypeDirective:
1402	1407	case NodeTypeTypeDecl:
1403	1408	zig_unreachable();
1404	1409	}

src/parseh.cpp-1

...	...	@@ -124,7 +124,6 @@ static AstNode create_typed_var_decl_node(Context c, bool is_const, const char
124	124	node->data.variable_declaration.is_const = is_const;
125	125	node->data.variable_declaration.top_level_decl.visib_mod = c->visib_mod;
126	126	node->data.variable_declaration.expr = init_node;
127		node->data.variable_declaration.top_level_decl.directives = nullptr;
128	127	node->data.variable_declaration.type = type_node;
129	128	normalize_parent_ptrs(node);
130	129	return node;

src/parser.cpp+53-150

...	...	@@ -211,8 +211,7 @@ static AstNode ast_parse_if_expr(ParseContext pc, size_t *token_index, bool ma
211	211	static AstNode ast_parse_block_expr(ParseContext pc, size_t *token_index, bool mandatory);
212	212	static AstNode ast_parse_unwrap_expr(ParseContext pc, size_t *token_index, bool mandatory);
213	213	static AstNode ast_parse_prefix_op_expr(ParseContext pc, size_t *token_index, bool mandatory);
214		static AstNode ast_parse_fn_proto(ParseContext pc, size_t *token_index, bool mandatory,
215		ZigList<AstNode> directives, VisibMod visib_mod);
	214	static AstNode ast_parse_fn_proto(ParseContext pc, size_t *token_index, bool mandatory, VisibMod visib_mod);
216	215	static AstNode ast_parse_return_expr(ParseContext pc, size_t *token_index);
217	216	static AstNode ast_parse_grouped_expr(ParseContext pc, size_t *token_index, bool mandatory);
218	217
...	...	@@ -233,39 +232,6 @@ static Token ast_eat_token(ParseContext pc, size_t *token_index, TokenId token
233	232	return token;
234	233	}
235	234
236		/*
237		Directive = "#" "Symbol" "(" Expression ")"
238		*/
239		static AstNode ast_parse_directive(ParseContext pc, size_t *token_index) {
240		Token *number_sign = ast_eat_token(pc, token_index, TokenIdNumberSign);
241
242		AstNode *node = ast_create_node(pc, NodeTypeDirective, number_sign);
243
244		Token *name_symbol = ast_eat_token(pc, token_index, TokenIdSymbol);
245
246		node->data.directive.name = token_buf(name_symbol);
247
248		node->data.directive.expr = ast_parse_grouped_expr(pc, token_index, true);
249
250		normalize_parent_ptrs(node);
251		return node;
252		}
253
254		static void ast_parse_directives(ParseContext pc, size_t token_index,
255		ZigList<AstNode > directives)
256		{
257		for (;;) {
258		Token token = &pc->tokens->at(token_index);
259		if (token->id == TokenIdNumberSign) {
260		AstNode *directive_node = ast_parse_directive(pc, token_index);
261		directives->append(directive_node);
262		} else {
263		return;
264		}
265		}
266		zig_unreachable();
267		}
268
269	235	/*
270	236	TypeExpr = PrefixOpExpression \| "var"
271	237	*/
...	...	@@ -686,7 +652,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, size_t *token_index, bo
686	652	return node;
687	653	} else if (token->id == TokenIdKeywordExtern) {
688	654	*token_index += 1;
689		AstNode *node = ast_parse_fn_proto(pc, token_index, true, nullptr, VisibModPrivate);
	655	AstNode *node = ast_parse_fn_proto(pc, token_index, true, VisibModPrivate);
690	656	node->data.fn_proto.is_extern = true;
691	657	return node;
692	658	} else if (token->id == TokenIdAtSign) {
...	...	@@ -735,7 +701,7 @@ static AstNode ast_parse_primary_expr(ParseContext pc, size_t *token_index, bo
735	701	return array_type_node;
736	702	}
737	703
738		AstNode *fn_proto_node = ast_parse_fn_proto(pc, token_index, false, nullptr, VisibModPrivate);
	704	AstNode *fn_proto_node = ast_parse_fn_proto(pc, token_index, false, VisibModPrivate);
739	705	if (fn_proto_node) {
740	706	return fn_proto_node;
741	707	}
...	...	@@ -1487,7 +1453,7 @@ static AstNode ast_parse_defer_expr(ParseContext pc, size_t *token_index) {
1487	1453	VariableDeclaration : ("var" \| "const") "Symbol" ("=" Expression \| ":" PrefixOpExpression option("=" Expression))
1488	1454	*/
1489	1455	static AstNode ast_parse_variable_declaration_expr(ParseContext pc, size_t *token_index, bool mandatory,
1490		ZigList<AstNode> directives, VisibMod visib_mod)
	1456	VisibMod visib_mod)
1491	1457	{
1492	1458	Token first_token = &pc->tokens->at(token_index);
1493	1459
...	...	@@ -1509,7 +1475,6 @@ static AstNode ast_parse_variable_declaration_expr(ParseContext pc, size_t *to
1509	1475
1510	1476	node->data.variable_declaration.is_const = is_const;
1511	1477	node->data.variable_declaration.top_level_decl.visib_mod = visib_mod;
1512		node->data.variable_declaration.top_level_decl.directives = directives;
1513	1478
1514	1479	Token *name_token = ast_eat_token(pc, token_index, TokenIdSymbol);
1515	1480	node->data.variable_declaration.symbol = token_buf(name_token);
...	...	@@ -1985,8 +1950,7 @@ static AstNode ast_parse_block(ParseContext pc, size_t *token_index, bool mand
1985	1950	if (statement_node) {
1986	1951	semicolon_expected = false;
1987	1952	} else {
1988		statement_node = ast_parse_variable_declaration_expr(pc, token_index, false,
1989		nullptr, VisibModPrivate);
	1953	statement_node = ast_parse_variable_declaration_expr(pc, token_index, false, VisibModPrivate);
1990	1954	if (!statement_node) {
1991	1955	statement_node = ast_parse_defer_expr(pc, token_index);
1992	1956	}
...	...	@@ -2023,25 +1987,35 @@ static AstNode ast_parse_block(ParseContext pc, size_t *token_index, bool mand
2023	1987	}
2024	1988
2025	1989	/*
2026		FnProto = "fn" option("Symbol") ParamDeclList option("->" TypeExpr)
	1990	FnProto = option("coldcc" \| "nakedcc") "fn" option(Symbol) ParamDeclList option("->" TypeExpr)
2027	1991	*/
2028		static AstNode ast_parse_fn_proto(ParseContext pc, size_t *token_index, bool mandatory,
2029		ZigList<AstNode> directives, VisibMod visib_mod)
2030		{
	1992	static AstNode ast_parse_fn_proto(ParseContext pc, size_t *token_index, bool mandatory, VisibMod visib_mod) {
2031	1993	Token first_token = &pc->tokens->at(token_index);
	1994	Token *fn_token;
2032	1995
2033		if (first_token->id != TokenIdKeywordFn) {
2034		if (mandatory) {
2035		ast_expect_token(pc, first_token, TokenIdKeywordFn);
2036		} else {
2037		return nullptr;
2038		}
	1996	bool is_coldcc = false;
	1997	bool is_nakedcc = false;
	1998	if (first_token->id == TokenIdKeywordColdCC) {
	1999	*token_index += 1;
	2000	fn_token = ast_eat_token(pc, token_index, TokenIdKeywordFn);
	2001	is_coldcc = true;
	2002	} else if (first_token->id == TokenIdKeywordNakedCC) {
	2003	*token_index += 1;
	2004	fn_token = ast_eat_token(pc, token_index, TokenIdKeywordFn);
	2005	is_nakedcc = true;
	2006	} else if (first_token->id == TokenIdKeywordFn) {
	2007	fn_token = first_token;
	2008	*token_index += 1;
	2009	} else if (mandatory) {
	2010	ast_expect_token(pc, first_token, TokenIdKeywordFn);
	2011	} else {
	2012	return nullptr;
2039	2013	}
2040		*token_index += 1;
2041	2014
2042		AstNode *node = ast_create_node(pc, NodeTypeFnProto, first_token);
	2015	AstNode *node = ast_create_node(pc, NodeTypeFnProto, fn_token);
2043	2016	node->data.fn_proto.top_level_decl.visib_mod = visib_mod;
2044		node->data.fn_proto.top_level_decl.directives = directives;
	2017	node->data.fn_proto.is_coldcc = is_coldcc;
	2018	node->data.fn_proto.is_nakedcc = is_nakedcc;
2045	2019
2046	2020	Token fn_name = &pc->tokens->at(token_index);
2047	2021	if (fn_name->id == TokenIdSymbol) {
...	...	@@ -2068,9 +2042,7 @@ static AstNode ast_parse_fn_proto(ParseContext pc, size_t *token_index, bool m
2068	2042	/*
2069	2043	FnDef = option("inline" \| "extern") FnProto Block
2070	2044	*/
2071		static AstNode ast_parse_fn_def(ParseContext pc, size_t *token_index, bool mandatory,
2072		ZigList<AstNode> directives, VisibMod visib_mod)
2073		{
	2045	static AstNode ast_parse_fn_def(ParseContext pc, size_t *token_index, bool mandatory, VisibMod visib_mod) {
2074	2046	Token first_token = &pc->tokens->at(token_index);
2075	2047	bool is_inline;
2076	2048	bool is_extern;
...	...	@@ -2087,7 +2059,7 @@ static AstNode ast_parse_fn_def(ParseContext pc, size_t *token_index, bool man
2087	2059	is_extern = false;
2088	2060	}
2089	2061
2090		AstNode *fn_proto = ast_parse_fn_proto(pc, token_index, mandatory, directives, visib_mod);
	2062	AstNode *fn_proto = ast_parse_fn_proto(pc, token_index, mandatory, visib_mod);
2091	2063	if (!fn_proto) {
2092	2064	if (is_inline \|\| is_extern) {
2093	2065	*token_index -= 1;
...	...	@@ -2115,9 +2087,7 @@ static AstNode ast_parse_fn_def(ParseContext pc, size_t *token_index, bool man
2115	2087	/*
2116	2088	ExternDecl = "extern" (FnProto \| VariableDeclaration) ";"
2117	2089	*/
2118		static AstNode ast_parse_extern_decl(ParseContext pc, size_t *token_index, bool mandatory,
2119		ZigList<AstNode > directives, VisibMod visib_mod)
2120		{
	2090	static AstNode ast_parse_extern_decl(ParseContext pc, size_t *token_index, bool mandatory, VisibMod visib_mod) {
2121	2091	Token extern_kw = &pc->tokens->at(token_index);
2122	2092	if (extern_kw->id != TokenIdKeywordExtern) {
2123	2093	if (mandatory) {
...	...	@@ -2128,7 +2098,7 @@ static AstNode ast_parse_extern_decl(ParseContext pc, size_t *token_index, boo
2128	2098	}
2129	2099	*token_index += 1;
2130	2100
2131		AstNode *fn_proto_node = ast_parse_fn_proto(pc, token_index, false, directives, visib_mod);
	2101	AstNode *fn_proto_node = ast_parse_fn_proto(pc, token_index, false, visib_mod);
2132	2102	if (fn_proto_node) {
2133	2103	ast_eat_token(pc, token_index, TokenIdSemicolon);
2134	2104
...	...	@@ -2138,7 +2108,7 @@ static AstNode ast_parse_extern_decl(ParseContext pc, size_t *token_index, boo
2138	2108	return fn_proto_node;
2139	2109	}
2140	2110
2141		AstNode *var_decl_node = ast_parse_variable_declaration_expr(pc, token_index, false, directives, visib_mod);
	2111	AstNode *var_decl_node = ast_parse_variable_declaration_expr(pc, token_index, false, visib_mod);
2142	2112	if (var_decl_node) {
2143	2113	ast_eat_token(pc, token_index, TokenIdSemicolon);
2144	2114
...	...	@@ -2155,9 +2125,7 @@ static AstNode ast_parse_extern_decl(ParseContext pc, size_t *token_index, boo
2155	2125	/*
2156	2126	UseDecl = "use" Expression ";"
2157	2127	*/
2158		static AstNode ast_parse_use(ParseContext pc, size_t *token_index,
2159		ZigList<AstNode> directives, VisibMod visib_mod)
2160		{
	2128	static AstNode ast_parse_use(ParseContext pc, size_t *token_index, VisibMod visib_mod) {
2161	2129	Token use_kw = &pc->tokens->at(token_index);
2162	2130	if (use_kw->id != TokenIdKeywordUse)
2163	2131	return nullptr;
...	...	@@ -2165,7 +2133,6 @@ static AstNode ast_parse_use(ParseContext pc, size_t *token_index,
2165	2133
2166	2134	AstNode *node = ast_create_node(pc, NodeTypeUse, use_kw);
2167	2135	node->data.use.top_level_decl.visib_mod = visib_mod;
2168		node->data.use.top_level_decl.directives = directives;
2169	2136	node->data.use.expr = ast_parse_expression(pc, token_index, true);
2170	2137
2171	2138	ast_eat_token(pc, token_index, TokenIdSemicolon);
...	...	@@ -2175,13 +2142,11 @@ static AstNode ast_parse_use(ParseContext pc, size_t *token_index,
2175	2142	}
2176	2143
2177	2144	/*
2178		ContainerDecl = ("struct" \| "enum" \| "union") "Symbol" option(ParamDeclList) "{" many(StructMember) "}"
2179		StructMember = many(Directive) option(VisibleMod) (StructField \| FnDef \| GlobalVarDecl \| ContainerDecl)
2180		StructField : "Symbol" option(":" Expression) ",")
	2145	ContainerDecl = ("struct" \| "enum" \| "union") Symbol option(ParamDeclList) "{" many(StructMember) "}"
	2146	StructMember = (StructField \| FnDef \| GlobalVarDecl \| ContainerDecl)
	2147	StructField = Symbol option(":" Expression) ",")
2181	2148	*/
2182		static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2183		ZigList<AstNode> directives, VisibMod visib_mod)
2184		{
	2149	static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index, VisibMod visib_mod) {
2185	2150	Token first_token = &pc->tokens->at(token_index);
2186	2151
2187	2152	ContainerKind kind;
...	...	@@ -2203,7 +2168,6 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2203	2168	node->data.struct_decl.kind = kind;
2204	2169	node->data.struct_decl.name = token_buf(struct_name);
2205	2170	node->data.struct_decl.top_level_decl.visib_mod = visib_mod;
2206		node->data.struct_decl.top_level_decl.directives = directives;
2207	2171
2208	2172	Token paren_or_brace = &pc->tokens->at(token_index);
2209	2173	if (paren_or_brace->id == TokenIdLParen) {
...	...	@@ -2217,10 +2181,6 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2217	2181	}
2218	2182
2219	2183	for (;;) {
2220		Token directive_token = &pc->tokens->at(token_index);
2221		ZigList<AstNode > directive_list = allocate<ZigList<AstNode*>>(1);
2222		ast_parse_directives(pc, token_index, directive_list);
2223
2224	2184	Token visib_tok = &pc->tokens->at(token_index);
2225	2185	VisibMod visib_mod;
2226	2186	if (visib_tok->id == TokenIdKeywordPub) {
...	...	@@ -2233,20 +2193,20 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2233	2193	visib_mod = VisibModPrivate;
2234	2194	}
2235	2195
2236		AstNode *fn_def_node = ast_parse_fn_def(pc, token_index, false, directive_list, visib_mod);
	2196	AstNode *fn_def_node = ast_parse_fn_def(pc, token_index, false, visib_mod);
2237	2197	if (fn_def_node) {
2238	2198	node->data.struct_decl.decls.append(fn_def_node);
2239	2199	continue;
2240	2200	}
2241	2201
2242		AstNode *var_decl_node = ast_parse_variable_declaration_expr(pc, token_index, false, directive_list, visib_mod);
	2202	AstNode *var_decl_node = ast_parse_variable_declaration_expr(pc, token_index, false, visib_mod);
2243	2203	if (var_decl_node) {
2244	2204	ast_eat_token(pc, token_index, TokenIdSemicolon);
2245	2205	node->data.struct_decl.decls.append(var_decl_node);
2246	2206	continue;
2247	2207	}
2248	2208
2249		AstNode *container_decl_node = ast_parse_container_decl(pc, token_index, directive_list, visib_mod);
	2209	AstNode *container_decl_node = ast_parse_container_decl(pc, token_index, visib_mod);
2250	2210	if (container_decl_node) {
2251	2211	node->data.struct_decl.decls.append(container_decl_node);
2252	2212	continue;
...	...	@@ -2255,10 +2215,6 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2255	2215	Token token = &pc->tokens->at(token_index);
2256	2216
2257	2217	if (token->id == TokenIdRBrace) {
2258		if (directive_list->length > 0) {
2259		ast_error(pc, directive_token, "invalid directive");
2260		}
2261
2262	2218	*token_index += 1;
2263	2219	break;
2264	2220	} else if (token->id == TokenIdSymbol) {
...	...	@@ -2266,7 +2222,6 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2266	2222	*token_index += 1;
2267	2223
2268	2224	field_node->data.struct_field.top_level_decl.visib_mod = visib_mod;
2269		field_node->data.struct_field.top_level_decl.directives = directive_list;
2270	2225	field_node->data.struct_field.name = token_buf(token);
2271	2226
2272	2227	Token expr_or_comma = &pc->tokens->at(token_index);
...	...	@@ -2293,9 +2248,7 @@ static AstNode ast_parse_container_decl(ParseContext pc, size_t *token_index,
2293	2248	/*
2294	2249	ErrorValueDecl : "error" "Symbol" ";"
2295	2250	*/
2296		static AstNode ast_parse_error_value_decl(ParseContext pc, size_t *token_index,
2297		ZigList<AstNode> directives, VisibMod visib_mod)
2298		{
	2251	static AstNode ast_parse_error_value_decl(ParseContext pc, size_t *token_index, VisibMod visib_mod) {
2299	2252	Token first_token = &pc->tokens->at(token_index);
2300	2253
2301	2254	if (first_token->id != TokenIdKeywordError) {
...	...	@@ -2308,7 +2261,6 @@ static AstNode ast_parse_error_value_decl(ParseContext pc, size_t *token_index
2308	2261
2309	2262	AstNode *node = ast_create_node(pc, NodeTypeErrorValueDecl, first_token);
2310	2263	node->data.error_value_decl.top_level_decl.visib_mod = visib_mod;
2311		node->data.error_value_decl.top_level_decl.directives = directives;
2312	2264	node->data.error_value_decl.name = token_buf(name_tok);
2313	2265
2314	2266	normalize_parent_ptrs(node);
...	...	@@ -2318,9 +2270,7 @@ static AstNode ast_parse_error_value_decl(ParseContext pc, size_t *token_index
2318	2270	/*
2319	2271	TypeDecl = "type" "Symbol" "=" TypeExpr ";"
2320	2272	*/
2321		static AstNode ast_parse_type_decl(ParseContext pc, size_t *token_index,
2322		ZigList<AstNode> directives, VisibMod visib_mod)
2323		{
	2273	static AstNode ast_parse_type_decl(ParseContext pc, size_t *token_index, VisibMod visib_mod) {
2324	2274	Token first_token = &pc->tokens->at(token_index);
2325	2275
2326	2276	if (first_token->id != TokenIdKeywordType) {
...	...	@@ -2338,21 +2288,17 @@ static AstNode ast_parse_type_decl(ParseContext pc, size_t *token_index,
2338	2288	ast_eat_token(pc, token_index, TokenIdSemicolon);
2339	2289
2340	2290	node->data.type_decl.top_level_decl.visib_mod = visib_mod;
2341		node->data.type_decl.top_level_decl.directives = directives;
2342	2291
2343	2292	normalize_parent_ptrs(node);
2344	2293	return node;
2345	2294	}
2346	2295
2347	2296	/*
2348		TopLevelDecl = many(Directive) option(VisibleMod) (FnDef \| ExternDecl \| Import \| ContainerDecl \| GlobalVarDecl \| ErrorValueDecl \| CImportDecl \| TypeDecl)
	2297	TopLevelItem = ErrorValueDecl \| Block \| TopLevelDecl
	2298	TopLevelDecl = option(VisibleMod) (FnDef \| ExternDecl \| ContainerDecl \| GlobalVarDecl \| TypeDecl \| UseDecl)
2349	2299	*/
2350	2300	static void ast_parse_top_level_decls(ParseContext pc, size_t token_index, ZigList<AstNode > top_level_decls) {
2351	2301	for (;;) {
2352		Token directive_token = &pc->tokens->at(token_index);
2353		ZigList<AstNode > directives = allocate<ZigList<AstNode*>>(1);
2354		ast_parse_directives(pc, token_index, directives);
2355
2356	2302	Token visib_tok = &pc->tokens->at(token_index);
2357	2303	VisibMod visib_mod;
2358	2304	if (visib_tok->id == TokenIdKeywordPub) {
...	...	@@ -2365,61 +2311,56 @@ static void ast_parse_top_level_decls(ParseContext pc, size_t token_index, Zig
2365	2311	visib_mod = VisibModPrivate;
2366	2312	}
2367	2313
2368		AstNode *fn_def_node = ast_parse_fn_def(pc, token_index, false, directives, visib_mod);
	2314	AstNode *fn_def_node = ast_parse_fn_def(pc, token_index, false, visib_mod);
2369	2315	if (fn_def_node) {
2370	2316	top_level_decls->append(fn_def_node);
2371	2317	continue;
2372	2318	}
2373	2319
2374		AstNode *fn_proto_node = ast_parse_extern_decl(pc, token_index, false, directives, visib_mod);
	2320	AstNode *fn_proto_node = ast_parse_extern_decl(pc, token_index, false, visib_mod);
2375	2321	if (fn_proto_node) {
2376	2322	top_level_decls->append(fn_proto_node);
2377	2323	continue;
2378	2324	}
2379	2325
2380		AstNode *use_node = ast_parse_use(pc, token_index, directives, visib_mod);
	2326	AstNode *use_node = ast_parse_use(pc, token_index, visib_mod);
2381	2327	if (use_node) {
2382	2328	top_level_decls->append(use_node);
2383	2329	continue;
2384	2330	}
2385	2331
2386		AstNode *struct_node = ast_parse_container_decl(pc, token_index, directives, visib_mod);
	2332	AstNode *struct_node = ast_parse_container_decl(pc, token_index, visib_mod);
2387	2333	if (struct_node) {
2388	2334	top_level_decls->append(struct_node);
2389	2335	continue;
2390	2336	}
2391	2337
2392		AstNode *var_decl_node = ast_parse_variable_declaration_expr(pc, token_index, false,
2393		directives, visib_mod);
	2338	AstNode *var_decl_node = ast_parse_variable_declaration_expr(pc, token_index, false, visib_mod);
2394	2339	if (var_decl_node) {
2395	2340	ast_eat_token(pc, token_index, TokenIdSemicolon);
2396	2341	top_level_decls->append(var_decl_node);
2397	2342	continue;
2398	2343	}
2399	2344
2400		AstNode *error_value_node = ast_parse_error_value_decl(pc, token_index, directives, visib_mod);
	2345	AstNode *error_value_node = ast_parse_error_value_decl(pc, token_index, visib_mod);
2401	2346	if (error_value_node) {
2402	2347	top_level_decls->append(error_value_node);
2403	2348	continue;
2404	2349	}
2405	2350
2406		AstNode *type_decl_node = ast_parse_type_decl(pc, token_index, directives, visib_mod);
	2351	AstNode *type_decl_node = ast_parse_type_decl(pc, token_index, visib_mod);
2407	2352	if (type_decl_node) {
2408	2353	top_level_decls->append(type_decl_node);
2409	2354	continue;
2410	2355	}
2411	2356
2412		if (directives->length > 0) {
2413		ast_error(pc, directive_token, "invalid directive");
2414		}
2415
2416	2357	return;
2417	2358	}
2418	2359	zig_unreachable();
2419	2360	}
2420	2361
2421	2362	/*
2422		Root : many(TopLevelDecl) token(EOF)
	2363	Root = many(TopLevelItem) "EOF"
2423	2364	*/
2424	2365	static AstNode ast_parse_root(ParseContext pc, size_t *token_index) {
2425	2366	AstNode node = ast_create_node(pc, NodeTypeRoot, &pc->tokens->at(token_index));
...	...	@@ -2471,7 +2412,6 @@ void ast_visit_node_children(AstNode node, void (visit)(AstNode *, void cont
2471	2412	break;
2472	2413	case NodeTypeFnProto:
2473	2414	visit_field(&node->data.fn_proto.return_type, visit, context);
2474		visit_node_list(node->data.fn_proto.top_level_decl.directives, visit, context);
2475	2415	visit_node_list(&node->data.fn_proto.params, visit, context);
2476	2416	break;
2477	2417	case NodeTypeFnDef:
...	...	@@ -2487,9 +2427,6 @@ void ast_visit_node_children(AstNode node, void (visit)(AstNode *, void cont
2487	2427	case NodeTypeBlock:
2488	2428	visit_node_list(&node->data.block.statements, visit, context);
2489	2429	break;
2490		case NodeTypeDirective:
2491		visit_field(&node->data.directive.expr, visit, context);
2492		break;
2493	2430	case NodeTypeReturnExpr:
2494	2431	visit_field(&node->data.return_expr.expr, visit, context);
2495	2432	break;
...	...	@@ -2497,12 +2434,10 @@ void ast_visit_node_children(AstNode node, void (visit)(AstNode *, void cont
2497	2434	visit_field(&node->data.defer.expr, visit, context);
2498	2435	break;
2499	2436	case NodeTypeVariableDeclaration:
2500		visit_node_list(node->data.variable_declaration.top_level_decl.directives, visit, context);
2501	2437	visit_field(&node->data.variable_declaration.type, visit, context);
2502	2438	visit_field(&node->data.variable_declaration.expr, visit, context);
2503	2439	break;
2504	2440	case NodeTypeTypeDecl:
2505		visit_node_list(node->data.type_decl.top_level_decl.directives, visit, context);
2506	2441	visit_field(&node->data.type_decl.child_type, visit, context);
2507	2442	break;
2508	2443	case NodeTypeErrorValueDecl:
...	...	@@ -2550,7 +2485,6 @@ void ast_visit_node_children(AstNode node, void (visit)(AstNode *, void cont
2550	2485	break;
2551	2486	case NodeTypeUse:
2552	2487	visit_field(&node->data.use.expr, visit, context);
2553		visit_node_list(node->data.use.top_level_decl.directives, visit, context);
2554	2488	break;
2555	2489	case NodeTypeBoolLiteral:
2556	2490	// none
...	...	@@ -2626,11 +2560,9 @@ void ast_visit_node_children(AstNode node, void (visit)(AstNode *, void cont
2626	2560	case NodeTypeContainerDecl:
2627	2561	visit_node_list(&node->data.struct_decl.fields, visit, context);
2628	2562	visit_node_list(&node->data.struct_decl.decls, visit, context);
2629		visit_node_list(node->data.struct_decl.top_level_decl.directives, visit, context);
2630	2563	break;
2631	2564	case NodeTypeStructField:
2632	2565	visit_field(&node->data.struct_field.type, visit, context);
2633		visit_node_list(node->data.struct_field.top_level_decl.directives, visit, context);
2634	2566	break;
2635	2567	case NodeTypeContainerInitExpr:
2636	2568	visit_field(&node->data.container_init_expr.type, visit, context);
...	...	@@ -2688,16 +2620,6 @@ static void clone_subtree_list_omit_inline_params(ZigList<AstNode > dest, ZigL
2688	2620	}
2689	2621	}
2690	2622
2691		static void clone_subtree_list_ptr(ZigList<AstNode > dest_ptr, ZigList<AstNode > *src,
2692		uint32_t *next_node_index)
2693		{
2694		if (src) {
2695		ZigList<AstNode > dest = allocate<ZigList<AstNode *>>(1);
2696		*dest_ptr = dest;
2697		clone_subtree_list(dest, src, next_node_index);
2698		}
2699		}
2700
2701	2623	static void clone_subtree_field_special(AstNode *dest, AstNode src, uint32_t *next_node_index,
2702	2624	enum AstCloneSpecial special)
2703	2625	{
...	...	@@ -2713,10 +2635,6 @@ static void clone_subtree_field(AstNode *dest, AstNode src, uint32_t *next_nod
2713	2635	return clone_subtree_field_special(dest, src, next_node_index, AstCloneSpecialNone);
2714	2636	}
2715	2637
2716		static void clone_subtree_tld(TopLevelDecl dest, TopLevelDecl src, uint32_t *next_node_index) {
2717		clone_subtree_list_ptr(&dest->directives, src->directives, next_node_index);
2718		}
2719
2720	2638	AstNode ast_clone_subtree_special(AstNode old_node, uint32_t *next_node_index, enum AstCloneSpecial special) {
2721	2639	AstNode *new_node = allocate_nonzero<AstNode>(1);
2722	2640	safe_memcpy(new_node, old_node, 1);
...	...	@@ -2730,8 +2648,6 @@ AstNode ast_clone_subtree_special(AstNode old_node, uint32_t *next_node_index,
2730	2648	&old_node->data.root.top_level_decls, next_node_index);
2731	2649	break;
2732	2650	case NodeTypeFnProto:
2733		clone_subtree_tld(&new_node->data.fn_proto.top_level_decl, &old_node->data.fn_proto.top_level_decl,
2734		next_node_index);
2735	2651	clone_subtree_field(&new_node->data.fn_proto.return_type, old_node->data.fn_proto.return_type,
2736	2652	next_node_index);
2737	2653
...	...	@@ -2761,9 +2677,6 @@ AstNode ast_clone_subtree_special(AstNode old_node, uint32_t *next_node_index,
2761	2677	clone_subtree_list(&new_node->data.block.statements, &old_node->data.block.statements,
2762	2678	next_node_index);
2763	2679	break;
2764		case NodeTypeDirective:
2765		clone_subtree_field(&new_node->data.directive.expr, old_node->data.directive.expr, next_node_index);
2766		break;
2767	2680	case NodeTypeReturnExpr:
2768	2681	clone_subtree_field(&new_node->data.return_expr.expr, old_node->data.return_expr.expr, next_node_index);
2769	2682	break;
...	...	@@ -2771,14 +2684,10 @@ AstNode ast_clone_subtree_special(AstNode old_node, uint32_t *next_node_index,
2771	2684	clone_subtree_field(&new_node->data.defer.expr, old_node->data.defer.expr, next_node_index);
2772	2685	break;
2773	2686	case NodeTypeVariableDeclaration:
2774		clone_subtree_list_ptr(&new_node->data.variable_declaration.top_level_decl.directives,
2775		old_node->data.variable_declaration.top_level_decl.directives, next_node_index);
2776	2687	clone_subtree_field(&new_node->data.variable_declaration.type, old_node->data.variable_declaration.type, next_node_index);
2777	2688	clone_subtree_field(&new_node->data.variable_declaration.expr, old_node->data.variable_declaration.expr, next_node_index);
2778	2689	break;
2779	2690	case NodeTypeTypeDecl:
2780		clone_subtree_list_ptr(&new_node->data.type_decl.top_level_decl.directives,
2781		old_node->data.type_decl.top_level_decl.directives, next_node_index);
2782	2691	clone_subtree_field(&new_node->data.type_decl.child_type, old_node->data.type_decl.child_type, next_node_index);
2783	2692	break;
2784	2693	case NodeTypeErrorValueDecl:
...	...	@@ -2832,8 +2741,6 @@ AstNode ast_clone_subtree_special(AstNode old_node, uint32_t *next_node_index,
2832	2741	break;
2833	2742	case NodeTypeUse:
2834	2743	clone_subtree_field(&new_node->data.use.expr, old_node->data.use.expr, next_node_index);
2835		clone_subtree_list_ptr(&new_node->data.use.top_level_decl.directives,
2836		old_node->data.use.top_level_decl.directives, next_node_index);
2837	2744	break;
2838	2745	case NodeTypeBoolLiteral:
2839	2746	// none
...	...	@@ -2908,13 +2815,9 @@ AstNode ast_clone_subtree_special(AstNode old_node, uint32_t *next_node_index,
2908	2815	next_node_index);
2909	2816	clone_subtree_list(&new_node->data.struct_decl.decls, &old_node->data.struct_decl.decls,
2910	2817	next_node_index);
2911		clone_subtree_list_ptr(&new_node->data.struct_decl.top_level_decl.directives,
2912		old_node->data.struct_decl.top_level_decl.directives, next_node_index);
2913	2818	break;
2914	2819	case NodeTypeStructField:
2915	2820	clone_subtree_field(&new_node->data.struct_field.type, old_node->data.struct_field.type, next_node_index);
2916		clone_subtree_list_ptr(&new_node->data.struct_field.top_level_decl.directives,
2917		old_node->data.struct_field.top_level_decl.directives, next_node_index);
2918	2821	break;
2919	2822	case NodeTypeContainerInitExpr:
2920	2823	clone_subtree_field(&new_node->data.container_init_expr.type, old_node->data.container_init_expr.type, next_node_index);

src/tokenizer.cpp+4

...	...	@@ -109,6 +109,7 @@ struct ZigKeyword {
109	109	static const struct ZigKeyword zig_keywords[] = {
110	110	{"asm", TokenIdKeywordAsm},
111	111	{"break", TokenIdKeywordBreak},
	112	{"coldcc", TokenIdKeywordColdCC},
112	113	{"const", TokenIdKeywordConst},
113	114	{"continue", TokenIdKeywordContinue},
114	115	{"defer", TokenIdKeywordDefer},
...	...	@@ -123,6 +124,7 @@ static const struct ZigKeyword zig_keywords[] = {
123	124	{"goto", TokenIdKeywordGoto},
124	125	{"if", TokenIdKeywordIf},
125	126	{"inline", TokenIdKeywordInline},
	127	{"nakedcc", TokenIdKeywordNakedCC},
126	128	{"noalias", TokenIdKeywordNoAlias},
127	129	{"null", TokenIdKeywordNull},
128	130	{"pub", TokenIdKeywordPub},
...	...	@@ -1476,6 +1478,8 @@ const char * token_name(TokenId id) {
1476	1478	case TokenIdKeywordType: return "type";
1477	1479	case TokenIdKeywordInline: return "inline";
1478	1480	case TokenIdKeywordDefer: return "defer";
	1481	case TokenIdKeywordColdCC: return "coldcc";
	1482	case TokenIdKeywordNakedCC: return "nakedcc";
1479	1483	case TokenIdLParen: return "(";
1480	1484	case TokenIdRParen: return ")";
1481	1485	case TokenIdComma: return ",";

src/tokenizer.hpp+2

...	...	@@ -46,6 +46,8 @@ enum TokenId {
46	46	TokenIdKeywordInline,
47	47	TokenIdKeywordDefer,
48	48	TokenIdKeywordThis,
	49	TokenIdKeywordColdCC,
	50	TokenIdKeywordNakedCC,
49	51	TokenIdLParen,
50	52	TokenIdRParen,
51	53	TokenIdComma,

std/bootstrap.zig+5-4

...	...	@@ -13,9 +13,9 @@ const want_main_symbol = !want_start_symbol;
13	13	var argc: usize = undefined;
14	14	var argv: &&u8 = undefined;
15	15
16		#attribute("naked")
17		#condition(want_start_symbol)
18		export fn _start() -> unreachable {
	16	export nakedcc fn _start() -> unreachable {
	17	@setFnVisible(this, want_start_symbol);
	18
19	19	switch (@compileVar("arch")) {
20	20	x86_64 => {
21	21	argc = asm("mov (%%rsp), %[argc]": [argc] "=r" (-> usize));
...	...	@@ -44,8 +44,9 @@ fn callMainAndExit() -> unreachable {
44	44	linux.exit(0);
45	45	}
46	46
47		#condition(want_main_symbol)
48	47	export fn main(c_argc: i32, c_argv: &&u8) -> i32 {
	48	@setFnVisible(this, want_main_symbol);
	49
49	50	argc = usize(c_argc);
50	51	argv = c_argv;
51	52	callMain() %% return 1;

std/builtin.zig+4-2

...	...	@@ -1,8 +1,9 @@
1	1	// These functions are provided when not linking against libc because LLVM
2	2	// sometimes generates code that calls them.
3	3
4		#debug_safety(false)
5	4	export fn memset(dest: &u8, c: u8, n: usize) -> &u8 {
	5	@setDebugSafety(this, false);
	6
6	7	var index: usize = 0;
7	8	while (index != n) {
8	9	dest[index] = c;
...	...	@@ -11,8 +12,9 @@ export fn memset(dest: &u8, c: u8, n: usize) -> &u8 {
11	12	return dest;
12	13	}
13	14
14		#debug_safety(false)
15	15	export fn memcpy(noalias dest: &u8, noalias src: &const u8, n: usize) -> &u8 {
	16	@setDebugSafety(this, false);
	17
16	18	var index: usize = 0;
17	19	while (index != n) {
18	20	dest[index] = src[index];

std/compiler_rt.zig+10-6

...	...	@@ -8,18 +8,19 @@ const udwords = [2]su_int;
8	8	const low = if (@compileVar("is_big_endian")) 1 else 0;
9	9	const high = 1 - low;
10	10
11		#debug_safety(false)
12	11	export fn __udivdi3(a: du_int, b: du_int) -> du_int {
	12	@setDebugSafety(this, false);
13	13	return __udivmoddi4(a, b, null);
14	14	}
15	15
16		#debug_safety(false)
17	16	fn du_int_to_udwords(x: du_int) -> udwords {
	17	@setDebugSafety(this, false);
18	18	return *(&udwords)(&x);
19	19	}
20	20
21		#debug_safety(false)
22	21	export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {
	22	@setDebugSafety(this, false);
	23
23	24	const n_uword_bits = @sizeOf(su_int) * CHAR_BIT;
24	25	const n_udword_bits = @sizeOf(du_int) * CHAR_BIT;
25	26	var n = du_int_to_udwords(a);
...	...	@@ -203,15 +204,17 @@ export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {
203	204	return *(&du_int)(&q[0]);
204	205	}
205	206
206		#debug_safety(false)
207	207	export fn __umoddi3(a: du_int, b: du_int) -> du_int {
	208	@setDebugSafety(this, false);
	209
208	210	var r: du_int = undefined;
209	211	__udivmoddi4(a, b, &r);
210	212	return r;
211	213	}
212	214
213		#attribute("test")
214	215	fn test_umoddi3() {
	216	@setFnTest(this, true);
	217
215	218	test_one_umoddi3(0, 1, 0);
216	219	test_one_umoddi3(2, 1, 0);
217	220	test_one_umoddi3(0x8000000000000000, 1, 0x0);
...	...	@@ -224,8 +227,9 @@ fn test_one_umoddi3(a: du_int, b: du_int, expected_r: du_int) {
224	227	assert(r == expected_r);
225	228	}
226	229
227		#attribute("test")
228	230	fn test_udivmoddi4() {
	231	@setFnTest(this, true);
	232
229	233	const cases = [][4]du_int {
230	234	[]du_int{0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000},
231	235	[]du_int{0x0000000080000000, 0x0000000100000001, 0x0000000000000000, 0x0000000080000000},

std/cstr.zig+6-3

...	...	@@ -126,8 +126,9 @@ pub struct CBuf {
126	126	}
127	127	}
128	128
129		#attribute("test")
130	129	fn testSimpleCBuf() {
	130	@setFnTest(this, true);
	131
131	132	var buf = %%CBuf.initEmpty(&debug.global_allocator);
132	133	assert(buf.len() == 0);
133	134	%%buf.appendCStr(c"hello");
...	...	@@ -146,12 +147,14 @@ fn testSimpleCBuf() {
146	147	assert(buf.startsWithCBuf(&buf2));
147	148	}
148	149
149		#attribute("test")
150	150	fn testCompileTimeStrCmp() {
	151	@setFnTest(this, true);
	152
151	153	assert(@constEval(cmp(c"aoeu", c"aoez") == -1));
152	154	}
153	155
154		#attribute("test")
155	156	fn testCompileTimeStrLen() {
	157	@setFnTest(this, true);
	158
156	159	assert(@constEval(len(c"123456789") == 9));
157	160	}

std/hash_map.zig+2-1

...	...	@@ -230,8 +230,9 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
230	230	}
231	231	}
232	232
233		#attribute("test")
234	233	fn basicHashMapTest() {
	234	@setFnTest(this, true);
	235
235	236	var map: HashMap(i32, i32, hash_i32, eql_i32) = undefined;
236	237	map.init(&debug.global_allocator);
237	238	defer map.deinit();

std/io.zig+2-1

...	...	@@ -423,8 +423,9 @@ fn bufPrintUnsigned(inline T: type, out_buf: []u8, x: T) -> usize {
423	423	return len;
424	424	}
425	425
426		#attribute("test")
427	426	fn parseU64DigitTooBig() {
	427	@setFnTest(this, true);
	428
428	429	parseUnsigned(u64, "123a", 10) %% \|err\| {
429	430	if (err == error.InvalidChar) return;
430	431	@unreachable();

std/list.zig+2-1

...	...	@@ -49,8 +49,9 @@ pub struct List(T: type) {
49	49	}
50	50	}
51	51
52		#attribute("test")
53	52	fn basicListTest() {
	53	@setFnTest(this, true);
	54
54	55	var list = List(i32).init(&debug.global_allocator);
55	56	defer list.deinit();
56	57

std/mem.zig+1-1

...	...	@@ -77,8 +77,8 @@ pub fn sliceAsInt(buf: []u8, is_be: bool, inline T: type) -> T {
77	77	return result;
78	78	}
79	79
80		#attribute("test")
81	80	fn testSliceAsInt() {
	81	@setFnTest(this, true);
82	82	{
83	83	const buf = []u8{0x00, 0x00, 0x12, 0x34};
84	84	const answer = sliceAsInt(buf[0...], true, u64);

std/net.zig+8-4

...	...	@@ -180,8 +180,9 @@ error Overflow;
180	180	error JunkAtEnd;
181	181	error Incomplete;
182	182
183		#static_eval_enable(false)
184	183	fn parseIp6(buf: []const u8) -> %Address {
	184	@setFnStaticEval(this, false);
	185
185	186	var result: Address = undefined;
186	187	result.family = linux.AF_INET6;
187	188	result.scope_id = 0;
...	...	@@ -318,8 +319,9 @@ fn parseIp4(buf: []const u8) -> %u32 {
318	319	}
319	320
320	321
321		#attribute("test")
322	322	fn testParseIp4() {
	323	@setFnTest(this, true);
	324
323	325	assert(%%parseIp4("127.0.0.1") == endian.swapIfLe(u32, 0x7f000001));
324	326	switch (parseIp4("256.0.0.1")) { Overflow => {}, else => @unreachable(), }
325	327	switch (parseIp4("x.0.0.1")) { InvalidChar => {}, else => @unreachable(), }
...	...	@@ -328,8 +330,9 @@ fn testParseIp4() {
328	330	switch (parseIp4("100..0.1")) { InvalidChar => {}, else => @unreachable(), }
329	331	}
330	332
331		#attribute("test")
332	333	fn testParseIp6() {
	334	@setFnTest(this, true);
	335
333	336	{
334	337	const addr = %%parseIp6("FF01:0:0:0:0:0:0:FB");
335	338	assert(addr.addr[0] == 0xff);
...	...	@@ -338,8 +341,9 @@ fn testParseIp6() {
338	341	}
339	342	}
340	343
341		#attribute("test")
342	344	fn testLookupSimpleIp() {
	345	@setFnTest(this, true);
	346
343	347	{
344	348	var addrs_buf: [5]Address = undefined;
345	349	const addrs = %%lookup("192.168.1.1", addrs_buf);

std/os.zig+1-2

...	...	@@ -27,8 +27,7 @@ pub fn getRandomBytes(buf: []u8) -> %void {
27	27	}
28	28	}
29	29
30		#attribute("cold")
31		pub fn abort() -> unreachable {
	30	pub coldcc fn abort() -> unreachable {
32	31	switch (@compileVar("os")) {
33	32	linux, darwin => {
34	33	system.raise(system.SIGABRT);

std/rand.zig+6-3

...	...	@@ -153,8 +153,9 @@ struct MersenneTwister(
153	153	}
154	154	}
155	155
156		#attribute("test")
157	156	fn testFloat32() {
	157	@setFnTest(this, true);
	158
158	159	var r: Rand = undefined;
159	160	r.init(42);
160	161
...	...	@@ -165,8 +166,9 @@ fn testFloat32() {
165	166	}}
166	167	}
167	168
168		#attribute("test")
169	169	fn testMT19937_64() {
	170	@setFnTest(this, true);
	171
170	172	var rng: MT19937_64 = undefined;
171	173	rng.init(rand_test.mt64_seed);
172	174	for (rand_test.mt64_data) \|value\| {
...	...	@@ -174,8 +176,9 @@ fn testMT19937_64() {
174	176	}
175	177	}
176	178
177		#attribute("test")
178	179	fn testMT19937_32() {
	180	@setFnTest(this, true);
	181
179	182	var rng: MT19937_32 = undefined;
180	183	rng.init(rand_test.mt32_seed);
181	184	for (rand_test.mt32_data) \|value\| {

std/str.zig+3-2

...	...	@@ -12,8 +12,9 @@ pub fn sliceEql(inline T: type, a: []const T, b: []const T) -> bool {
12	12	return true;
13	13	}
14	14
15		#attribute("test")
16		fn stringEquality() {
	15	fn testStringEquality() {
	16	@setFnTest(this, true);
	17
17	18	assert(eql("abcd", "abcd"));
18	19	assert(!eql("abcdef", "abZdef"));
19	20	assert(!eql("abcdefg", "abcdef"));

test/cases/const_slice_child.zig+10-5

...	...	@@ -2,8 +2,9 @@ const assert = @import("std").debug.assert;
2	2
3	3	var argv: &&const u8 = undefined;
4	4
5		#attribute("test")
6	5	fn constSliceChild() {
	6	@setFnTest(this, true);
	7
7	8	const strs = ([]&const u8) {
8	9	c"one",
9	10	c"two",
...	...	@@ -13,16 +14,18 @@ fn constSliceChild() {
13	14	bar(strs.len);
14	15	}
15	16
16		#static_eval_enable(false)
17	17	fn foo(args: [][]const u8) {
	18	@setFnStaticEval(this, false);
	19
18	20	assert(args.len == 3);
19	21	assert(streql(args[0], "one"));
20	22	assert(streql(args[1], "two"));
21	23	assert(streql(args[2], "three"));
22	24	}
23	25
24		#static_eval_enable(false)
25	26	fn bar(argc: usize) {
	27	@setFnStaticEval(this, false);
	28
26	29	var args: [argc][]u8 = undefined;
27	30	for (args) \|_, i\| {
28	31	const ptr = argv[i];
...	...	@@ -31,15 +34,17 @@ fn bar(argc: usize) {
31	34	foo(args);
32	35	}
33	36
34		#static_eval_enable(false)
35	37	fn strlen(ptr: &const u8) -> usize {
	38	@setFnStaticEval(this, false);
	39
36	40	var count: usize = 0;
37	41	while (ptr[count] != 0; count += 1) {}
38	42	return count;
39	43	}
40	44
41		#static_eval_enable(false)
42	45	fn streql(a: []const u8, b: []const u8) -> bool {
	46	@setFnStaticEval(this, false);
	47
43	48	if (a.len != b.len) return false;
44	49	for (a) \|item, index\| {
45	50	if (b[index] != item) return false;

test/cases/enum_to_int.zig+16-9

...	...	@@ -8,17 +8,24 @@ enum Number {
8	8	Four,
9	9	}
10	10
11		#attribute("test")
12	11	fn enumToInt() {
13		shouldEqual(Number.Zero, 0);
14		shouldEqual(Number.One, 1);
15		shouldEqual(Number.Two, 2);
16		shouldEqual(Number.Three, 3);
17		shouldEqual(Number.Four, 4);
	12	@setFnTest(this, true);
	13
	14	shouldEqual(false, Number.Zero, 0);
	15	shouldEqual(false, Number.One, 1);
	16	shouldEqual(false, Number.Two, 2);
	17	shouldEqual(false, Number.Three, 3);
	18	shouldEqual(false, Number.Four, 4);
	19
	20	shouldEqual(true, Number.Zero, 0);
	21	shouldEqual(true, Number.One, 1);
	22	shouldEqual(true, Number.Two, 2);
	23	shouldEqual(true, Number.Three, 3);
	24	shouldEqual(true, Number.Four, 4);
18	25	}
19	26
20		// TODO add test with this disabled
21		#static_eval_enable(false)
22		fn shouldEqual(n: Number, expected: usize) {
	27	fn shouldEqual(inline static_eval: bool, n: Number, expected: usize) {
	28	@setFnStaticEval(this, static_eval);
	29
23	30	assert(usize(n) == expected);
24	31	}

test/cases/enum_with_members.zig+2-1

...	...	@@ -15,8 +15,9 @@ enum ET {
15	15	}
16	16	}
17	17
18		#attribute("test")
19	18	fn enumWithMembers() {
	19	@setFnTest(this, true);
	20
20	21	const a = ET.SINT { -42 };
21	22	const b = ET.UINT { 42 };
22	23	var buf: [20]u8 = undefined;

test/cases/max_value_type.zig+2-1

...	...	@@ -1,7 +1,8 @@
1	1	const assert = @import("std").debug.assert;
2	2
3		#attribute("test")
4	3	fn maxValueType() {
	4	@setFnTest(this, true);
	5
5	6	// If the type of @maxValue(i32) was i32 then this implicit cast to
6	7	// u32 would not work. But since the value is a number literal,
7	8	// it works fine.

test/cases/maybe_return.zig+5-3

...	...	@@ -1,15 +1,17 @@
1	1	const assert = @import("std").debug.assert;
2	2
3		#attribute("test")
4	3	fn maybeReturn() {
	4	@setFnTest(this, true);
	5
5	6	assert(??foo(1235));
6	7	assert(if (const _ ?= foo(null)) false else true);
7	8	assert(!??foo(1234));
8	9	}
9	10
10		// TODO add another function with static_eval_enable(true)
11		#static_eval_enable(false)
	11	// TODO test static eval maybe return
12	12	fn foo(x: ?i32) -> ?bool {
	13	@setFnStaticEval(this, false);
	14
13	15	const value = ?return x;
14	16	return value > 1234;
15	17	}

test/cases/namespace_depends_on_compile_var/index.zig+2-1

...	...	@@ -1,7 +1,8 @@
1	1	const assert = @import("std").debug.assert;
2	2
3		#attribute("test")
4	3	fn namespaceDependsOnCompileVar() {
	4	@setFnTest(this, true);
	5
5	6	if (some_namespace.a_bool) {
6	7	assert(some_namespace.a_bool);
7	8	} else {

test/cases/pub_enum/index.zig+4-2

...	...	@@ -1,16 +1,18 @@
1	1	const assert = @import("std").debug.assert;
2	2	const other = @import("other.zig");
3	3
4		#attribute("test")
5	4	fn pubEnum() {
	5	@setFnTest(this, true);
	6
6	7	pubEnumTest(other.APubEnum.Two);
7	8	}
8	9	fn pubEnumTest(foo: other.APubEnum) {
9	10	assert(foo == other.APubEnum.Two);
10	11	}
11	12
12		#attribute("test")
13	13	fn castWithImportedSymbol() {
	14	@setFnTest(this, true);
	15
14	16	assert(other.size_t(42) == 42);
15	17	}
16	18

test/cases/return_type_type.zig+2-1

...	...	@@ -10,8 +10,9 @@ pub struct SmallList(inline T: type, inline STATIC_SIZE: usize) {
10	10	prealloc_items: [STATIC_SIZE]T,
11	11	}
12	12
13		#attribute("test")
14	13	fn functionWithReturnTypeType() {
	14	@setFnTest(this, true);
	15
15	16	var list: List(i32) = undefined;
16	17	var list2: List(i32) = undefined;
17	18	list.length = 10;

test/cases/sizeof_and_typeof.zig+2-1

...	...	@@ -1,7 +1,8 @@
1	1	const assert = @import("std").debug.assert;
2	2
3		#attribute("test")
4	3	fn sizeofAndTypeOf() {
	4	@setFnTest(this, true);
	5
5	6	const y: @typeOf(x) = 120;
6	7	assert(@sizeOf(@typeOf(y)) == 2);
7	8	}

test/cases/struct_contains_slice_of_itself.zig+2-1

...	...	@@ -5,8 +5,9 @@ struct Node {
5	5	children: []Node,
6	6	}
7	7
8		#attribute("test")
9	8	fn structContainsSliceOfItself() {
	9	@setFnTest(this, true);
	10
10	11	var nodes = []Node {
11	12	Node {
12	13	.payload = 1,

test/cases/switch_prong_err_enum.zig+4-2

...	...	@@ -14,16 +14,18 @@ enum FormValue {
14	14	Other: bool,
15	15	}
16	16
17		#static_eval_enable(false)
18	17	fn doThing(form_id: u64) -> %FormValue {
	18	@setFnStaticEval(this, false);
	19
19	20	return switch (form_id) {
20	21	17 => FormValue.Address { %return readOnce() },
21	22	else => error.InvalidDebugInfo,
22	23	}
23	24	}
24	25
25		#attribute("test")
26	26	fn switchProngReturnsErrorEnum() {
	27	@setFnTest(this, true);
	28
27	29	%%doThing(17);
28	30	assert(read_count == 1);
29	31	}

test/cases/switch_prong_implicit_cast.zig+4-2

...	...	@@ -7,8 +7,9 @@ enum FormValue {
7	7
8	8	error Whatever;
9	9
10		#static_eval_enable(false)
11	10	fn foo(id: u64) -> %FormValue {
	11	@setFnStaticEval(this, false);
	12
12	13	switch (id) {
13	14	2 => FormValue.Two { true },
14	15	1 => FormValue.One,
...	...	@@ -16,8 +17,9 @@ fn foo(id: u64) -> %FormValue {
16	17	}
17	18	}
18	19
19		#attribute("test")
20	20	fn switchProngImplicitCast() {
	21	@setFnTest(this, true);
	22
21	23	const result = switch (%%foo(2)) {
22	24	One => false,
23	25	Two => \|x\| x,

test/cases/this.zig+6-3

...	...	@@ -25,13 +25,15 @@ fn factorial(x: i32) -> i32 {
25	25	}
26	26	}
27	27
28		#attribute("test")
29	28	fn thisReferToModuleCallPrivateFn() {
	29	@setFnTest(this, true);
	30
30	31	assert(module.add(1, 2) == 3);
31	32	}
32	33
33		#attribute("test")
34	34	fn thisReferToContainer() {
	35	@setFnTest(this, true);
	36
35	37	var pt = Point(i32) {
36	38	.x = 12,
37	39	.y = 34,
...	...	@@ -41,7 +43,8 @@ fn thisReferToContainer() {
41	43	assert(pt.y == 35);
42	44	}
43	45
44		#attribute("test")
45	46	fn thisReferToFn() {
	47	@setFnTest(this, true);
	48
46	49	assert(factorial(5) == 120);
47	50	}

test/cases/var_params.zig+6-3

...	...	@@ -1,7 +1,8 @@
1	1	const assert = @import("std").debug.assert;
2	2
3		#attribute("test")
4	3	fn varParams() {
	4	@setFnTest(this, true);
	5
5	6	assert(max_i32(12, 34) == 34);
6	7	assert(max_f64(1.2, 3.4) == 3.4);
7	8
...	...	@@ -21,12 +22,14 @@ fn max_f64(a: f64, b: f64) -> f64 {
21	22	max(a, b)
22	23	}
23	24
24		#static_eval_enable(false)
25	25	fn max_i32_noeval(a: i32, b: i32) -> i32 {
	26	@setFnStaticEval(this, false);
	27
26	28	max(a, b)
27	29	}
28	30
29		#static_eval_enable(false)
30	31	fn max_f64_noeval(a: f64, b: f64) -> f64 {
	32	@setFnStaticEval(this, false);
	33
31	34	max(a, b)
32	35	}

test/cases/zeroes.zig+2-1

...	...	@@ -7,8 +7,9 @@ struct Foo {
7	7	d: ?i32,
8	8	}
9	9
10		#attribute("test")
11	10	fn initializing_a_struct_with_zeroes() {
	11	@setFnTest(this, true);
	12
12	13	const foo: Foo = zeroes;
13	14	assert(foo.a == 0.0);
14	15	assert(foo.b == 0);

test/run_tests.cpp+40-28

...	...	@@ -279,8 +279,9 @@ pub fn bar_function() {
279	279	)SOURCE");
280	280
281	281	add_source_file(tc, "other.zig", R"SOURCE(
282		#static_eval_enable(false)
283	282	pub fn foo_function() -> bool {
	283	@setFnStaticEval(this, false);
	284
284	285	// this one conflicts with the one from foo
285	286	return true;
286	287	}
...	...	@@ -686,14 +687,6 @@ fn a() {}
686	687	fn a() {}
687	688	)SOURCE", 1, ".tmp_source.zig:3:1: error: redefinition of 'a'");
688	689
689		add_compile_fail_case("bad directive", R"SOURCE(
690		#bogus1("")
691		extern fn b();
692		#bogus2("")
693		fn a() {}
694		)SOURCE", 2, ".tmp_source.zig:2:1: error: invalid directive: 'bogus1'",
695		".tmp_source.zig:4:1: error: invalid directive: 'bogus2'");
696
697	690	add_compile_fail_case("unreachable with return", R"SOURCE(
698	691	fn a() -> unreachable {return;}
699	692	)SOURCE", 1, ".tmp_source.zig:2:24: error: expected type 'unreachable', got 'void'");
...	...	@@ -1280,8 +1273,11 @@ struct Foo {
1280	1273	x: i32,
1281	1274	}
1282	1275	const a = get_it();
1283		#static_eval_enable(false)
1284		fn get_it() -> Foo { Foo {.x = 13} }
	1276	fn get_it() -> Foo {
	1277	@setFnStaticEval(this, false);
	1278	Foo {.x = 13}
	1279	}
	1280
1285	1281	)SOURCE", 1, ".tmp_source.zig:5:17: error: unable to evaluate constant expression");
1286	1282
1287	1283	add_compile_fail_case("undeclared identifier error should mark fn as impure", R"SOURCE(
...	...	@@ -1316,8 +1312,11 @@ fn foo() {
1316	1312	else => 3,
1317	1313	};
1318	1314	}
1319		#static_eval_enable(false)
1320		fn bar() -> i32 { 2 }
	1315	fn bar() -> i32 {
	1316	@setFnStaticEval(this, false);
	1317	2
	1318	}
	1319
1321	1320	)SOURCE", 1, ".tmp_source.zig:3:15: error: unable to infer expression type");
1322	1321
1323	1322	add_compile_fail_case("atomic orderings of cmpxchg", R"SOURCE(
...	...	@@ -1458,7 +1457,6 @@ pub struct SmallList(inline T: type, inline STATIC_SIZE: usize) {
1458	1457	prealloc_items: [STATIC_SIZE]T,
1459	1458	}
1460	1459
1461		#attribute("test")
1462	1460	fn function_with_return_type_type() {
1463	1461	var list: List(i32) = undefined;
1464	1462	list.length = 10;
...	...	@@ -1623,12 +1621,15 @@ pub fn main(args: [][]u8) -> %void {
1623	1621	const a = []i32{1, 2, 3, 4};
1624	1622	baz(bar(a));
1625	1623	}
1626		#static_eval_enable(false)
1627	1624	fn bar(a: []i32) -> i32 {
	1625	@setFnStaticEval(this, false);
	1626
1628	1627	a[4]
1629	1628	}
1630		#static_eval_enable(false)
1631		fn baz(a: i32) {}
	1629	fn baz(a: i32) {
	1630	@setFnStaticEval(this, false);
	1631	}
	1632
1632	1633	)SOURCE");
1633	1634
1634	1635	add_debug_safety_case("integer addition overflow", R"SOURCE(
...	...	@@ -1637,8 +1638,9 @@ pub fn main(args: [][]u8) -> %void {
1637	1638	const x = add(65530, 10);
1638	1639	if (x == 0) return error.Whatever;
1639	1640	}
1640		#static_eval_enable(false)
1641	1641	fn add(a: u16, b: u16) -> u16 {
	1642	@setFnStaticEval(this, false);
	1643
1642	1644	a + b
1643	1645	}
1644	1646	)SOURCE");
...	...	@@ -1649,8 +1651,9 @@ pub fn main(args: [][]u8) -> %void {
1649	1651	const x = sub(10, 20);
1650	1652	if (x == 0) return error.Whatever;
1651	1653	}
1652		#static_eval_enable(false)
1653	1654	fn sub(a: u16, b: u16) -> u16 {
	1655	@setFnStaticEval(this, false);
	1656
1654	1657	a - b
1655	1658	}
1656	1659	)SOURCE");
...	...	@@ -1661,8 +1664,9 @@ pub fn main(args: [][]u8) -> %void {
1661	1664	const x = mul(300, 6000);
1662	1665	if (x == 0) return error.Whatever;
1663	1666	}
1664		#static_eval_enable(false)
1665	1667	fn mul(a: u16, b: u16) -> u16 {
	1668	@setFnStaticEval(this, false);
	1669
1666	1670	a * b
1667	1671	}
1668	1672	)SOURCE");
...	...	@@ -1673,8 +1677,9 @@ pub fn main(args: [][]u8) -> %void {
1673	1677	const x = neg(-32768);
1674	1678	if (x == 0) return error.Whatever;
1675	1679	}
1676		#static_eval_enable(false)
1677	1680	fn neg(a: i16) -> i16 {
	1681	@setFnStaticEval(this, false);
	1682
1678	1683	-a
1679	1684	}
1680	1685	)SOURCE");
...	...	@@ -1685,8 +1690,9 @@ pub fn main(args: [][]u8) -> %void {
1685	1690	const x = shl(-16385, 1);
1686	1691	if (x == 0) return error.Whatever;
1687	1692	}
1688		#static_eval_enable(false)
1689	1693	fn shl(a: i16, b: i16) -> i16 {
	1694	@setFnStaticEval(this, false);
	1695
1690	1696	a << b
1691	1697	}
1692	1698	)SOURCE");
...	...	@@ -1697,8 +1703,9 @@ pub fn main(args: [][]u8) -> %void {
1697	1703	const x = shl(0b0010111111111111, 3);
1698	1704	if (x == 0) return error.Whatever;
1699	1705	}
1700		#static_eval_enable(false)
1701	1706	fn shl(a: u16, b: u16) -> u16 {
	1707	@setFnStaticEval(this, false);
	1708
1702	1709	a << b
1703	1710	}
1704	1711	)SOURCE");
...	...	@@ -1708,8 +1715,9 @@ error Whatever;
1708	1715	pub fn main(args: [][]u8) -> %void {
1709	1716	const x = div0(999, 0);
1710	1717	}
1711		#static_eval_enable(false)
1712	1718	fn div0(a: i32, b: i32) -> i32 {
	1719	@setFnStaticEval(this, false);
	1720
1713	1721	a / b
1714	1722	}
1715	1723	)SOURCE");
...	...	@@ -1720,8 +1728,9 @@ pub fn main(args: [][]u8) -> %void {
1720	1728	const x = divExact(10, 3);
1721	1729	if (x == 0) return error.Whatever;
1722	1730	}
1723		#static_eval_enable(false)
1724	1731	fn divExact(a: i32, b: i32) -> i32 {
	1732	@setFnStaticEval(this, false);
	1733
1725	1734	@divExact(a, b)
1726	1735	}
1727	1736	)SOURCE");
...	...	@@ -1732,8 +1741,9 @@ pub fn main(args: [][]u8) -> %void {
1732	1741	const x = widenSlice([]u8{1, 2, 3, 4, 5});
1733	1742	if (x.len == 0) return error.Whatever;
1734	1743	}
1735		#static_eval_enable(false)
1736	1744	fn widenSlice(slice: []u8) -> []i32 {
	1745	@setFnStaticEval(this, false);
	1746
1737	1747	([]i32)(slice)
1738	1748	}
1739	1749	)SOURCE");
...	...	@@ -1744,8 +1754,9 @@ pub fn main(args: [][]u8) -> %void {
1744	1754	const x = shorten_cast(200);
1745	1755	if (x == 0) return error.Whatever;
1746	1756	}
1747		#static_eval_enable(false)
1748	1757	fn shorten_cast(x: i32) -> i8 {
	1758	@setFnStaticEval(this, false);
	1759
1749	1760	i8(x)
1750	1761	}
1751	1762	)SOURCE");
...	...	@@ -1756,8 +1767,9 @@ pub fn main(args: [][]u8) -> %void {
1756	1767	const x = unsigned_cast(-10);
1757	1768	if (x == 0) return error.Whatever;
1758	1769	}
1759		#static_eval_enable(false)
1760	1770	fn unsigned_cast(x: i32) -> u32 {
	1771	@setFnStaticEval(this, false);
	1772
1761	1773	u32(x)
1762	1774	}
1763	1775	)SOURCE");

test/self_hosted.zig+312-154

...	...	@@ -19,12 +19,15 @@ const test_this = @import("cases/this.zig");
19	19	// normal comment
20	20	/// this is a documentation comment
21	21	/// doc comment line 2
22		#attribute("test")
23		fn emptyFunctionWithComments() {}
	22	fn emptyFunctionWithComments() {
	23	@setFnTest(this, true);
	24	}
	25
24	26
25	27
26		#attribute("test")
27	28	fn ifStatements() {
	29	@setFnTest(this, true);
	30
28	31	shouldBeEqual(1, 1);
29	32	firstEqlThird(2, 1, 2);
30	33	}
...	...	@@ -48,8 +51,9 @@ fn firstEqlThird(a: i32, b: i32, c: i32) {
48	51	}
49	52
50	53
51		#attribute("test")
52	54	fn params() {
	55	@setFnTest(this, true);
	56
53	57	assert(testParamsAdd(22, 11) == 33);
54	58	}
55	59	fn testParamsAdd(a: i32, b: i32) -> i32 {
...	...	@@ -57,8 +61,9 @@ fn testParamsAdd(a: i32, b: i32) -> i32 {
57	61	}
58	62
59	63
60		#attribute("test")
61	64	fn localVariables() {
	65	@setFnTest(this, true);
	66
62	67	testLocVars(2);
63	68	}
64	69	fn testLocVars(b: i32) {
...	...	@@ -66,14 +71,16 @@ fn testLocVars(b: i32) {
66	71	if (a + b != 3) @unreachable();
67	72	}
68	73
69		#attribute("test")
70	74	fn boolLiterals() {
	75	@setFnTest(this, true);
	76
71	77	assert(true);
72	78	assert(!false);
73	79	}
74	80
75		#attribute("test")
76	81	fn voidParameters() {
	82	@setFnTest(this, true);
	83
77	84	voidFun(1, void{}, 2, {});
78	85	}
79	86	fn voidFun(a : i32, b : void, c : i32, d : void) {
...	...	@@ -83,8 +90,9 @@ fn voidFun(a : i32, b : void, c : i32, d : void) {
83	90	return vv;
84	91	}
85	92
86		#attribute("test")
87	93	fn mutableLocalVariables() {
	94	@setFnTest(this, true);
	95
88	96	var zero : i32 = 0;
89	97	assert(zero == 0);
90	98
...	...	@@ -95,8 +103,9 @@ fn mutableLocalVariables() {
95	103	assert(i == 3);
96	104	}
97	105
98		#attribute("test")
99	106	fn arrays() {
	107	@setFnTest(this, true);
	108
100	109	var array : [5]u32 = undefined;
101	110
102	111	var i : u32 = 0;
...	...	@@ -120,8 +129,9 @@ fn getArrayLen(a: []u32) -> usize {
120	129	a.len
121	130	}
122	131
123		#attribute("test")
124	132	fn shortCircuit() {
	133	@setFnTest(this, true);
	134
125	135	var hit_1 = false;
126	136	var hit_2 = false;
127	137	var hit_3 = false;
...	...	@@ -148,13 +158,15 @@ fn shortCircuit() {
148	158	assert(hit_4);
149	159	}
150	160
151		#static_eval_enable(false)
152	161	fn assertRuntime(b: bool) {
	162	@setFnStaticEval(this, false);
	163
153	164	if (!b) @unreachable()
154	165	}
155	166
156		#attribute("test")
157	167	fn modifyOperators() {
	168	@setFnTest(this, true);
	169
158	170	var i : i32 = 0;
159	171	i += 5; assert(i == 5);
160	172	i -= 2; assert(i == 3);
...	...	@@ -171,8 +183,9 @@ fn modifyOperators() {
171	183	}
172	184
173	185
174		#attribute("test")
175	186	fn separateBlockScopes() {
	187	@setFnTest(this, true);
	188
176	189	{
177	190	const no_conflict : i32 = 5;
178	191	assert(no_conflict == 5);
...	...	@@ -186,8 +199,9 @@ fn separateBlockScopes() {
186	199	}
187	200
188	201
189		#attribute("test")
190	202	fn voidStructFields() {
	203	@setFnTest(this, true);
	204
191	205	const foo = VoidStructFieldsFoo {
192	206	.a = void{},
193	207	.b = 1,
...	...	@@ -204,8 +218,9 @@ struct VoidStructFieldsFoo {
204	218
205	219
206	220
207		#attribute("test")
208	221	pub fn structs() {
	222	@setFnTest(this, true);
	223
209	224	var foo : StructFoo = undefined;
210	225	@memset(&foo, 0, @sizeOf(StructFoo));
211	226	foo.a += 1;
...	...	@@ -234,8 +249,9 @@ struct Val {
234	249	x: i32,
235	250	}
236	251
237		#attribute("test")
238	252	fn structPointToSelf() {
	253	@setFnTest(this, true);
	254
239	255	var root : Node = undefined;
240	256	root.val.x = 1;
241	257
...	...	@@ -248,8 +264,9 @@ fn structPointToSelf() {
248	264	assert(node.next.next.next.val.x == 1);
249	265	}
250	266
251		#attribute("test")
252	267	fn structByvalAssign() {
	268	@setFnTest(this, true);
	269
253	270	var foo1 : StructFoo = undefined;
254	271	var foo2 : StructFoo = undefined;
255	272
...	...	@@ -269,16 +286,18 @@ fn structInitializer() {
269	286	const g1 : i32 = 1233 + 1;
270	287	var g2 : i32 = 0;
271	288
272		#attribute("test")
273	289	fn globalVariables() {
	290	@setFnTest(this, true);
	291
274	292	assert(g2 == 0);
275	293	g2 = g1;
276	294	assert(g2 == 1234);
277	295	}
278	296
279	297
280		#attribute("test")
281	298	fn whileLoop() {
	299	@setFnTest(this, true);
	300
282	301	var i : i32 = 0;
283	302	while (i < 4) {
284	303	i += 1;
...	...	@@ -295,8 +314,9 @@ fn whileLoop2() -> i32 {
295	314	}
296	315	}
297	316
298		#attribute("test")
299	317	fn voidArrays() {
	318	@setFnTest(this, true);
	319
300	320	var array: [4]void = undefined;
301	321	array[0] = void{};
302	322	array[1] = array[2];
...	...	@@ -305,8 +325,9 @@ fn voidArrays() {
305	325	}
306	326
307	327
308		#attribute("test")
309	328	fn threeExprInARow() {
	329	@setFnTest(this, true);
	330
310	331	assertFalse(false \|\| false \|\| false);
311	332	assertFalse(true && true && false);
312	333	assertFalse(1 \| 2 \| 4 != 7);
...	...	@@ -325,8 +346,9 @@ fn assertFalse(b: bool) {
325	346	}
326	347
327	348
328		#attribute("test")
329	349	fn maybeType() {
	350	@setFnTest(this, true);
	351
330	352	const x : ?bool = true;
331	353
332	354	if (const y ?= x) {
...	...	@@ -353,8 +375,9 @@ fn maybeType() {
353	375	}
354	376
355	377
356		#attribute("test")
357	378	fn enumType() {
	379	@setFnTest(this, true);
	380
358	381	const foo1 = EnumTypeFoo.One {13};
359	382	const foo2 = EnumTypeFoo.Two {EnumType { .x = 1234, .y = 5678, }};
360	383	const bar = EnumTypeBar.B;
...	...	@@ -387,8 +410,9 @@ enum EnumTypeBar {
387	410	}
388	411
389	412
390		#attribute("test")
391	413	fn arrayLiteral() {
	414	@setFnTest(this, true);
	415
392	416	const hex_mult = []u16{4096, 256, 16, 1};
393	417
394	418	assert(hex_mult.len == 4);
...	...	@@ -396,8 +420,9 @@ fn arrayLiteral() {
396	420	}
397	421
398	422
399		#attribute("test")
400	423	fn constNumberLiteral() {
	424	@setFnTest(this, true);
	425
401	426	const one = 1;
402	427	const eleven = ten + one;
403	428
...	...	@@ -406,8 +431,9 @@ fn constNumberLiteral() {
406	431	const ten = 10;
407	432
408	433
409		#attribute("test")
410	434	fn errorValues() {
	435	@setFnTest(this, true);
	436
411	437	const a = i32(error.err1);
412	438	const b = i32(error.err2);
413	439	assert(a != b);
...	...	@@ -417,8 +443,9 @@ error err2;
417	443
418	444
419	445
420		#attribute("test")
421	446	fn fnCallOfStructField() {
	447	@setFnTest(this, true);
	448
422	449	assert(callStructField(Foo {.ptr = aFunc,}) == 13);
423	450	}
424	451
...	...	@@ -434,8 +461,9 @@ fn callStructField(foo: Foo) -> i32 {
434	461
435	462
436	463
437		#attribute("test")
438	464	fn redefinitionOfErrorValuesAllowed() {
	465	@setFnTest(this, true);
	466
439	467	shouldBeNotEqual(error.AnError, error.SecondError);
440	468	}
441	469	error AnError;
...	...	@@ -448,8 +476,9 @@ fn shouldBeNotEqual(a: error, b: error) {
448	476
449	477
450	478
451		#attribute("test")
452	479	fn constantEnumWithPayload() {
	480	@setFnTest(this, true);
	481
453	482	var empty = AnEnumWithPayload.Empty;
454	483	var full = AnEnumWithPayload.Full {13};
455	484	shouldBeEmpty(empty);
...	...	@@ -476,8 +505,9 @@ enum AnEnumWithPayload {
476	505	}
477	506
478	507
479		#attribute("test")
480	508	fn continueInForLoop() {
	509	@setFnTest(this, true);
	510
481	511	const array = []i32 {1, 2, 3, 4, 5};
482	512	var sum : i32 = 0;
483	513	for (array) \|x\| {
...	...	@@ -491,8 +521,9 @@ fn continueInForLoop() {
491	521	}
492	522
493	523
494		#attribute("test")
495	524	fn castBoolToInt() {
	525	@setFnTest(this, true);
	526
496	527	const t = true;
497	528	const f = false;
498	529	assert(i32(t) == i32(1));
...	...	@@ -506,8 +537,9 @@ fn nonConstCastBoolToInt(t: bool, f: bool) {
506	537	}
507	538
508	539
509		#attribute("test")
510	540	fn switchOnEnum() {
	541	@setFnTest(this, true);
	542
511	543	const fruit = Fruit.Orange;
512	544	nonConstSwitchOnEnum(fruit);
513	545	}
...	...	@@ -516,8 +548,9 @@ enum Fruit {
516	548	Orange,
517	549	Banana,
518	550	}
519		#static_eval_enable(false)
520	551	fn nonConstSwitchOnEnum(fruit: Fruit) {
	552	@setFnStaticEval(this, false);
	553
521	554	switch (fruit) {
522	555	Apple => @unreachable(),
523	556	Orange => {},
...	...	@@ -525,12 +558,14 @@ fn nonConstSwitchOnEnum(fruit: Fruit) {
525	558	}
526	559	}
527	560
528		#attribute("test")
529	561	fn switchStatement() {
	562	@setFnTest(this, true);
	563
530	564	nonConstSwitch(SwitchStatmentFoo.C);
531	565	}
532		#static_eval_enable(false)
533	566	fn nonConstSwitch(foo: SwitchStatmentFoo) {
	567	@setFnStaticEval(this, false);
	568
534	569	const val: i32 = switch (foo) {
535	570	A => 1,
536	571	B => 2,
...	...	@@ -547,8 +582,9 @@ enum SwitchStatmentFoo {
547	582	}
548	583
549	584
550		#attribute("test")
551	585	fn switchProngWithVar() {
	586	@setFnTest(this, true);
	587
552	588	switchProngWithVarFn(SwitchProngWithVarEnum.One {13});
553	589	switchProngWithVarFn(SwitchProngWithVarEnum.Two {13.0});
554	590	switchProngWithVarFn(SwitchProngWithVarEnum.Meh);
...	...	@@ -558,8 +594,9 @@ enum SwitchProngWithVarEnum {
558	594	Two: f32,
559	595	Meh,
560	596	}
561		#static_eval_enable(false)
562	597	fn switchProngWithVarFn(a: SwitchProngWithVarEnum) {
	598	@setFnStaticEval(this, false);
	599
563	600	switch(a) {
564	601	One => \|x\| {
565	602	if (x != 13) @unreachable();
...	...	@@ -574,13 +611,15 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) {
574	611	}
575	612
576	613
577		#attribute("test")
578	614	fn errReturnInAssignment() {
	615	@setFnTest(this, true);
	616
579	617	%%doErrReturnInAssignment();
580	618	}
581	619
582		#static_eval_enable(false)
583	620	fn doErrReturnInAssignment() -> %void {
	621	@setFnStaticEval(this, false);
	622
584	623	var x : i32 = undefined;
585	624	x = %return makeANonErr();
586	625	}
...	...	@@ -591,15 +630,17 @@ fn makeANonErr() -> %i32 {
591	630
592	631
593	632
594		#attribute("test")
595	633	fn rhsMaybeUnwrapReturn() {
	634	@setFnTest(this, true);
	635
596	636	const x = ?true;
597	637	const y = x ?? return;
598	638	}
599	639
600	640
601		#attribute("test")
602	641	fn implicitCastFnUnreachableReturn() {
	642	@setFnTest(this, true);
	643
603	644	wantsFnWithVoid(fnWithUnreachable);
604	645	}
605	646
...	...	@@ -610,15 +651,17 @@ fn fnWithUnreachable() -> unreachable {
610	651	}
611	652
612	653
613		#attribute("test")
614	654	fn explicitCastMaybePointers() {
	655	@setFnTest(this, true);
	656
615	657	const a: ?&i32 = undefined;
616	658	const b: ?&f32 = (?&f32)(a);
617	659	}
618	660
619	661
620		#attribute("test")
621	662	fn constExprEvalOnSingleExprBlocks() {
	663	@setFnTest(this, true);
	664
622	665	assert(constExprEvalOnSingleExprBlocksFn(1, true) == 3);
623	666	}
624	667
...	...	@@ -635,14 +678,16 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) -> i32 {
635	678	}
636	679
637	680
638		#attribute("test")
639	681	fn builtinConstEval() {
	682	@setFnTest(this, true);
	683
640	684	const x : i32 = @constEval(1 + 2 + 3);
641	685	assert(x == @constEval(6));
642	686	}
643	687
644		#attribute("test")
645	688	fn slicing() {
	689	@setFnTest(this, true);
	690
646	691	var array : [20]i32 = undefined;
647	692
648	693	array[5] = 1234;
...	...	@@ -659,8 +704,9 @@ fn slicing() {
659	704	}
660	705
661	706
662		#attribute("test")
663	707	fn memcpyAndMemsetIntrinsics() {
	708	@setFnTest(this, true);
	709
664	710	var foo : [20]u8 = undefined;
665	711	var bar : [20]u8 = undefined;
666	712
...	...	@@ -671,31 +717,36 @@ fn memcpyAndMemsetIntrinsics() {
671	717	}
672	718
673	719
674		#attribute("test")
675		fn arrayDotLenConstExpr() { }
	720	fn arrayDotLenConstExpr() {
	721	@setFnTest(this, true);
	722	}
	723
676	724	struct ArrayDotLenConstExpr {
677	725	y: [@constEval(some_array.len)]u8,
678	726	}
679	727	const some_array = []u8 {0, 1, 2, 3};
680	728
681	729
682		#attribute("test")
683	730	fn countLeadingZeroes() {
	731	@setFnTest(this, true);
	732
684	733	assert(@clz(u8, 0b00001010) == 4);
685	734	assert(@clz(u8, 0b10001010) == 0);
686	735	assert(@clz(u8, 0b00000000) == 8);
687	736	}
688	737
689		#attribute("test")
690	738	fn countTrailingZeroes() {
	739	@setFnTest(this, true);
	740
691	741	assert(@ctz(u8, 0b10100000) == 5);
692	742	assert(@ctz(u8, 0b10001010) == 1);
693	743	assert(@ctz(u8, 0b00000000) == 8);
694	744	}
695	745
696	746
697		#attribute("test")
698	747	fn multilineString() {
	748	@setFnTest(this, true);
	749
699	750	const s1 =
700	751	\\one
701	752	\\two)
...	...	@@ -705,8 +756,9 @@ fn multilineString() {
705	756	assert(str.eql(s1, s2));
706	757	}
707	758
708		#attribute("test")
709	759	fn multilineCString() {
	760	@setFnTest(this, true);
	761
710	762	const s1 =
711	763	c\\one
712	764	c\\two)
...	...	@@ -718,8 +770,9 @@ fn multilineCString() {
718	770
719	771
720	772
721		#attribute("test")
722	773	fn simpleGenericFn() {
	774	@setFnTest(this, true);
	775
723	776	assert(max(i32, 3, -1) == 3);
724	777	assert(max(f32, 0.123, 0.456) == 0.456);
725	778	assert(add(2, 3) == 5);
...	...	@@ -734,8 +787,9 @@ fn add(inline a: i32, b: i32) -> i32 {
734	787	}
735	788
736	789
737		#attribute("test")
738	790	fn constantEqualFunctionPointers() {
	791	@setFnTest(this, true);
	792
739	793	const alias = emptyFn;
740	794	assert(@constEval(emptyFn == alias));
741	795	}
...	...	@@ -743,44 +797,50 @@ fn constantEqualFunctionPointers() {
743	797	fn emptyFn() {}
744	798
745	799
746		#attribute("test")
747	800	fn genericMallocFree() {
	801	@setFnTest(this, true);
	802
748	803	const a = %%memAlloc(u8, 10);
749	804	memFree(u8, a);
750	805	}
751	806	const some_mem : [100]u8 = undefined;
752		#static_eval_enable(false)
753	807	fn memAlloc(inline T: type, n: usize) -> %[]T {
	808	@setFnStaticEval(this, false);
	809
754	810	return (&T)(&some_mem[0])[0...n];
755	811	}
756	812	fn memFree(inline T: type, mem: []T) { }
757	813
758	814
759		#attribute("test")
760	815	fn callFnWithEmptyString() {
	816	@setFnTest(this, true);
	817
761	818	acceptsString("");
762	819	}
763	820
764	821	fn acceptsString(foo: []u8) { }
765	822
766	823
767		#attribute("test")
768	824	fn hexEscape() {
	825	@setFnTest(this, true);
	826
769	827	assert(str.eql("\x68\x65\x6c\x6c\x6f", "hello"));
770	828	}
771	829
772	830
773	831	error AnError;
774	832	error ALongerErrorName;
775		#attribute("test")
776	833	fn errorNameString() {
	834	@setFnTest(this, true);
	835
777	836	assert(str.eql(@errorName(error.AnError), "AnError"));
778	837	assert(str.eql(@errorName(error.ALongerErrorName), "ALongerErrorName"));
779	838	}
780	839
781	840
782		#attribute("test")
783	841	fn gotoAndLabels() {
	842	@setFnTest(this, true);
	843
784	844	gotoLoop();
785	845	assert(goto_counter == 10);
786	846	}
...	...	@@ -799,12 +859,14 @@ var goto_counter: i32 = 0;
799	859
800	860
801	861
802		#attribute("test")
803	862	fn gotoLeaveDeferScope() {
	863	@setFnTest(this, true);
	864
804	865	testGotoLeaveDeferScope(true);
805	866	}
806		#static_eval_enable(false)
807	867	fn testGotoLeaveDeferScope(b: bool) {
	868	@setFnStaticEval(this, false);
	869
808	870	var it_worked = false;
809	871
810	872	goto entry;
...	...	@@ -819,8 +881,9 @@ entry:
819	881	}
820	882
821	883
822		#attribute("test")
823	884	fn castUndefined() {
	885	@setFnTest(this, true);
	886
824	887	const array: [100]u8 = undefined;
825	888	const slice = ([]u8)(array);
826	889	testCastUndefined(slice);
...	...	@@ -828,8 +891,9 @@ fn castUndefined() {
828	891	fn testCastUndefined(x: []u8) {}
829	892
830	893
831		#attribute("test")
832	894	fn castSmallUnsignedToLargerSigned() {
	895	@setFnTest(this, true);
	896
833	897	assert(castSmallUnsignedToLargerSigned1(200) == i16(200));
834	898	assert(castSmallUnsignedToLargerSigned2(9999) == i64(9999));
835	899	}
...	...	@@ -837,8 +901,9 @@ fn castSmallUnsignedToLargerSigned1(x: u8) -> i16 { x }
837	901	fn castSmallUnsignedToLargerSigned2(x: u16) -> i64 { x }
838	902
839	903
840		#attribute("test")
841	904	fn implicitCastAfterUnreachable() {
	905	@setFnTest(this, true);
	906
842	907	assert(outer() == 1234);
843	908	}
844	909	fn inner() -> i32 { 1234 }
...	...	@@ -847,8 +912,9 @@ fn outer() -> i64 {
847	912	}
848	913
849	914
850		#attribute("test")
851	915	fn elseIfExpression() {
	916	@setFnTest(this, true);
	917
852	918	assert(elseIfExpressionF(1) == 1);
853	919	}
854	920	fn elseIfExpressionF(c: u8) -> u8 {
...	...	@@ -861,8 +927,9 @@ fn elseIfExpressionF(c: u8) -> u8 {
861	927	}
862	928	}
863	929
864		#attribute("test")
865	930	fn errBinaryOperator() {
	931	@setFnTest(this, true);
	932
866	933	const a = errBinaryOperatorG(true) %% 3;
867	934	const b = errBinaryOperatorG(false) %% 3;
868	935	assert(a == 3);
...	...	@@ -877,16 +944,18 @@ fn errBinaryOperatorG(x: bool) -> %isize {
877	944	}
878	945	}
879	946
880		#attribute("test")
881	947	fn unwrapSimpleValueFromError() {
	948	@setFnTest(this, true);
	949
882	950	const i = %%unwrapSimpleValueFromErrorDo();
883	951	assert(i == 13);
884	952	}
885	953	fn unwrapSimpleValueFromErrorDo() -> %isize { 13 }
886	954
887	955
888		#attribute("test")
889	956	fn storeMemberFunctionInVariable() {
	957	@setFnTest(this, true);
	958
890	959	const instance = MemberFnTestFoo { .x = 1234, };
891	960	const memberFn = MemberFnTestFoo.member;
892	961	const result = memberFn(instance);
...	...	@@ -897,15 +966,17 @@ struct MemberFnTestFoo {
897	966	fn member(foo: MemberFnTestFoo) -> i32 { foo.x }
898	967	}
899	968
900		#attribute("test")
901	969	fn callMemberFunctionDirectly() {
	970	@setFnTest(this, true);
	971
902	972	const instance = MemberFnTestFoo { .x = 1234, };
903	973	const result = MemberFnTestFoo.member(instance);
904	974	assert(result == 1234);
905	975	}
906	976
907		#attribute("test")
908	977	fn memberFunctions() {
	978	@setFnTest(this, true);
	979
909	980	const r = MemberFnRand {.seed = 1234};
910	981	assert(r.getSeed() == 1234);
911	982	}
...	...	@@ -916,16 +987,18 @@ struct MemberFnRand {
916	987	}
917	988	}
918	989
919		#attribute("test")
920	990	fn staticFunctionEvaluation() {
	991	@setFnTest(this, true);
	992
921	993	assert(statically_added_number == 3);
922	994	}
923	995	const statically_added_number = staticAdd(1, 2);
924	996	fn staticAdd(a: i32, b: i32) -> i32 { a + b }
925	997
926	998
927		#attribute("test")
928	999	fn staticallyInitalizedList() {
	1000	@setFnTest(this, true);
	1001
929	1002	assert(static_point_list[0].x == 1);
930	1003	assert(static_point_list[0].y == 2);
931	1004	assert(static_point_list[1].x == 3);
...	...	@@ -944,8 +1017,9 @@ fn makePoint(x: i32, y: i32) -> Point {
944	1017	}
945	1018
946	1019
947		#attribute("test")
948	1020	fn staticEvalRecursive() {
	1021	@setFnTest(this, true);
	1022
949	1023	assert(some_data.len == 21);
950	1024	}
951	1025	var some_data: [usize(fibbonaci(7))]u8 = undefined;
...	...	@@ -954,8 +1028,9 @@ fn fibbonaci(x: i32) -> i32 {
954	1028	return fibbonaci(x - 1) + fibbonaci(x - 2);
955	1029	}
956	1030
957		#attribute("test")
958	1031	fn staticEvalWhile() {
	1032	@setFnTest(this, true);
	1033
959	1034	assert(static_eval_while_number == 1);
960	1035	}
961	1036	const static_eval_while_number = staticWhileLoop1();
...	...	@@ -968,8 +1043,9 @@ fn staticWhileLoop2() -> i32 {
968	1043	}
969	1044	}
970	1045
971		#attribute("test")
972	1046	fn staticEvalListInit() {
	1047	@setFnTest(this, true);
	1048
973	1049	assert(static_vec3.data[2] == 1.0);
974	1050	}
975	1051	const static_vec3 = vec3(0.0, 0.0, 1.0);
...	...	@@ -983,8 +1059,9 @@ pub fn vec3(x: f32, y: f32, z: f32) -> Vec3 {
983	1059	}
984	1060
985	1061
986		#attribute("test")
987	1062	fn genericFnWithImplicitCast() {
	1063	@setFnTest(this, true);
	1064
988	1065	assert(getFirstByte(u8, []u8 {13}) == 13);
989	1066	assert(getFirstByte(u16, []u16 {0, 13}) == 0);
990	1067	}
...	...	@@ -993,8 +1070,9 @@ fn getFirstByte(inline T: type, mem: []T) -> u8 {
993	1070	getByte((&u8)(&mem[0]))
994	1071	}
995	1072
996		#attribute("test")
997	1073	fn continueAndBreak() {
	1074	@setFnTest(this, true);
	1075
998	1076	runContinueAndBreakTest();
999	1077	assert(continue_and_break_counter == 8);
1000	1078	}
...	...	@@ -1013,8 +1091,9 @@ fn runContinueAndBreakTest() {
1013	1091	}
1014	1092
1015	1093
1016		#attribute("test")
1017	1094	fn pointerDereferencing() {
	1095	@setFnTest(this, true);
	1096
1018	1097	var x = i32(3);
1019	1098	const y = &x;
1020	1099
...	...	@@ -1024,16 +1103,18 @@ fn pointerDereferencing() {
1024	1103	assert(*y == 4);
1025	1104	}
1026	1105
1027		#attribute("test")
1028	1106	fn constantExpressions() {
	1107	@setFnTest(this, true);
	1108
1029	1109	var array : [array_size]u8 = undefined;
1030	1110	assert(@sizeOf(@typeOf(array)) == 20);
1031	1111	}
1032	1112	const array_size : u8 = 20;
1033	1113
1034	1114
1035		#attribute("test")
1036	1115	fn minValueAndMaxValue() {
	1116	@setFnTest(this, true);
	1117
1037	1118	assert(@maxValue(u8) == 255);
1038	1119	assert(@maxValue(u16) == 65535);
1039	1120	assert(@maxValue(u32) == 4294967295);
...	...	@@ -1055,8 +1136,9 @@ fn minValueAndMaxValue() {
1055	1136	assert(@minValue(i64) == -9223372036854775808);
1056	1137	}
1057	1138
1058		#attribute("test")
1059	1139	fn overflowIntrinsics() {
	1140	@setFnTest(this, true);
	1141
1060	1142	var result: u8 = undefined;
1061	1143	assert(@addWithOverflow(u8, 250, 100, &result));
1062	1144	assert(!@addWithOverflow(u8, 100, 150, &result));
...	...	@@ -1064,8 +1146,9 @@ fn overflowIntrinsics() {
1064	1146	}
1065	1147
1066	1148
1067		#attribute("test")
1068	1149	fn nestedArrays() {
	1150	@setFnTest(this, true);
	1151
1069	1152	const array_of_strings = [][]u8 {"hello", "this", "is", "my", "thing"};
1070	1153	for (array_of_strings) \|s, i\| {
1071	1154	if (i == 0) assert(str.eql(s, "hello"));
...	...	@@ -1076,21 +1159,24 @@ fn nestedArrays() {
1076	1159	}
1077	1160	}
1078	1161
1079		#attribute("test")
1080	1162	fn intToPtrCast() {
	1163	@setFnTest(this, true);
	1164
1081	1165	const x = isize(13);
1082	1166	const y = (&u8)(x);
1083	1167	const z = usize(y);
1084	1168	assert(z == 13);
1085	1169	}
1086	1170
1087		#attribute("test")
1088	1171	fn stringConcatenation() {
	1172	@setFnTest(this, true);
	1173
1089	1174	assert(str.eql("OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
1090	1175	}
1091	1176
1092		#attribute("test")
1093	1177	fn constantStructWithNegation() {
	1178	@setFnTest(this, true);
	1179
1094	1180	assert(vertices[0].x == -0.6);
1095	1181	}
1096	1182	struct Vertex {
...	...	@@ -1107,8 +1193,9 @@ const vertices = []Vertex {
1107	1193	};
1108	1194
1109	1195
1110		#attribute("test")
1111	1196	fn returnWithImplicitCastFromWhileLoop() {
	1197	@setFnTest(this, true);
	1198
1112	1199	%%returnWithImplicitCastFromWhileLoopTest();
1113	1200	}
1114	1201	fn returnWithImplicitCastFromWhileLoopTest() -> %void {
...	...	@@ -1117,8 +1204,9 @@ fn returnWithImplicitCastFromWhileLoopTest() -> %void {
1117	1204	}
1118	1205	}
1119	1206
1120		#attribute("test")
1121	1207	fn returnStructByvalFromFunction() {
	1208	@setFnTest(this, true);
	1209
1122	1210	const bar = makeBar(1234, 5678);
1123	1211	assert(bar.y == 5678);
1124	1212	}
...	...	@@ -1133,8 +1221,9 @@ fn makeBar(x: i32, y: i32) -> Bar {
1133	1221	}
1134	1222	}
1135	1223
1136		#attribute("test")
1137	1224	fn functionPointers() {
	1225	@setFnTest(this, true);
	1226
1138	1227	const fns = []@typeOf(fn1) { fn1, fn2, fn3, fn4, };
1139	1228	for (fns) \|f, i\| {
1140	1229	assert(f() == u32(i) + 5);
...	...	@@ -1147,8 +1236,9 @@ fn fn4() -> u32 {8}
1147	1236
1148	1237
1149	1238
1150		#attribute("test")
1151	1239	fn staticallyInitalizedStruct() {
	1240	@setFnTest(this, true);
	1241
1152	1242	st_init_str_foo.x += 1;
1153	1243	assert(st_init_str_foo.x == 14);
1154	1244	}
...	...	@@ -1158,8 +1248,9 @@ struct StInitStrFoo {
1158	1248	}
1159	1249	var st_init_str_foo = StInitStrFoo { .x = 13, .y = true, };
1160	1250
1161		#attribute("test")
1162	1251	fn staticallyInitializedArrayLiteral() {
	1252	@setFnTest(this, true);
	1253
1163	1254	const y : [4]u8 = st_init_arr_lit_x;
1164	1255	assert(y[3] == 4);
1165	1256	}
...	...	@@ -1167,8 +1258,9 @@ const st_init_arr_lit_x = []u8{1,2,3,4};
1167	1258
1168	1259
1169	1260
1170		#attribute("test")
1171	1261	fn pointerToVoidReturnType() {
	1262	@setFnTest(this, true);
	1263
1172	1264	%%testPointerToVoidReturnType();
1173	1265	}
1174	1266	fn testPointerToVoidReturnType() -> %void {
...	...	@@ -1181,8 +1273,9 @@ fn testPointerToVoidReturnType2() -> &void {
1181	1273	}
1182	1274
1183	1275
1184		#attribute("test")
1185	1276	fn callResultOfIfElseExpression() {
	1277	@setFnTest(this, true);
	1278
1186	1279	assert(str.eql(f2(true), "a"));
1187	1280	assert(str.eql(f2(false), "b"));
1188	1281	}
...	...	@@ -1193,8 +1286,9 @@ fn fA() -> []u8 { "a" }
1193	1286	fn fB() -> []u8 { "b" }
1194	1287
1195	1288
1196		#attribute("test")
1197	1289	fn constExpressionEvalHandlingOfVariables() {
	1290	@setFnTest(this, true);
	1291
1198	1292	var x = true;
1199	1293	while (x) {
1200	1294	x = false;
...	...	@@ -1203,8 +1297,9 @@ fn constExpressionEvalHandlingOfVariables() {
1203	1297
1204	1298
1205	1299
1206		#attribute("test")
1207	1300	fn constantEnumInitializationWithDifferingSizes() {
	1301	@setFnTest(this, true);
	1302
1208	1303	test3_1(test3_foo);
1209	1304	test3_2(test3_bar);
1210	1305	}
...	...	@@ -1219,8 +1314,9 @@ struct Test3Point {
1219	1314	}
1220	1315	const test3_foo = Test3Foo.Three{Test3Point {.x = 3, .y = 4}};
1221	1316	const test3_bar = Test3Foo.Two{13};
1222		#static_eval_enable(false)
1223	1317	fn test3_1(f: Test3Foo) {
	1318	@setFnStaticEval(this, false);
	1319
1224	1320	switch (f) {
1225	1321	Three => \|pt\| {
1226	1322	assert(pt.x == 3);
...	...	@@ -1229,8 +1325,9 @@ fn test3_1(f: Test3Foo) {
1229	1325	else => @unreachable(),
1230	1326	}
1231	1327	}
1232		#static_eval_enable(false)
1233	1328	fn test3_2(f: Test3Foo) {
	1329	@setFnStaticEval(this, false);
	1330
1234	1331	switch (f) {
1235	1332	Two => \|x\| {
1236	1333	assert(x == 13);
...	...	@@ -1241,8 +1338,9 @@ fn test3_2(f: Test3Foo) {
1241	1338
1242	1339
1243	1340
1244		#attribute("test")
1245	1341	fn whileWithContinueExpr() {
	1342	@setFnTest(this, true);
	1343
1246	1344	var sum: i32 = 0;
1247	1345	{var i: i32 = 0; while (i < 10; i += 1) {
1248	1346	if (i == 5) continue;
...	...	@@ -1252,38 +1350,47 @@ fn whileWithContinueExpr() {
1252	1350	}
1253	1351
1254	1352
1255		#attribute("test")
1256	1353	fn forLoopWithPointerElemVar() {
	1354	@setFnTest(this, true);
	1355
1257	1356	const source = "abcdefg";
1258	1357	var target: [source.len]u8 = undefined;
1259	1358	@memcpy(&target[0], &source[0], source.len);
1260	1359	mangleString(target);
1261	1360	assert(str.eql(target, "bcdefgh"));
1262	1361	}
1263		#static_eval_enable(false)
1264	1362	fn mangleString(s: []u8) {
	1363	@setFnStaticEval(this, false);
	1364
1265	1365	for (s) \|*c\| {
1266	1366	*c += 1;
1267	1367	}
1268	1368	}
1269	1369
1270		#attribute("test")
1271	1370	fn emptyStructMethodCall() {
	1371	@setFnTest(this, true);
	1372
1272	1373	const es = EmptyStruct{};
1273	1374	assert(es.method() == 1234);
1274	1375	}
1275	1376	struct EmptyStruct {
1276		#static_eval_enable(false)
1277		fn method(es: EmptyStruct) -> i32 { 1234 }
	1377	fn method(es: EmptyStruct) -> i32 {
	1378	@setFnStaticEval(this, false);
	1379	1234
	1380	}
	1381
1278	1382	}
1279	1383
1280	1384
1281		#attribute("test")
1282		fn @"weird function name"() { }
	1385	fn @"weird function name"() {
	1386	@setFnTest(this, true);
	1387	}
	1388
1283	1389
1284	1390
1285		#attribute("test")
1286	1391	fn returnEmptyStructFromFn() {
	1392	@setFnTest(this, true);
	1393
1287	1394	testReturnEmptyStructFromFn();
1288	1395	testReturnEmptyStructFromFnNoeval();
1289	1396	}
...	...	@@ -1291,13 +1398,15 @@ struct EmptyStruct2 {}
1291	1398	fn testReturnEmptyStructFromFn() -> EmptyStruct2 {
1292	1399	EmptyStruct2 {}
1293	1400	}
1294		#static_eval_enable(false)
1295	1401	fn testReturnEmptyStructFromFnNoeval() -> EmptyStruct2 {
	1402	@setFnStaticEval(this, false);
	1403
1296	1404	EmptyStruct2 {}
1297	1405	}
1298	1406
1299		#attribute("test")
1300	1407	fn passSliceOfEmptyStructToFn() {
	1408	@setFnTest(this, true);
	1409
1301	1410	assert(testPassSliceOfEmptyStructToFn([]EmptyStruct2{ EmptyStruct2{} }) == 1);
1302	1411	}
1303	1412	fn testPassSliceOfEmptyStructToFn(slice: []EmptyStruct2) -> usize {
...	...	@@ -1305,8 +1414,9 @@ fn testPassSliceOfEmptyStructToFn(slice: []EmptyStruct2) -> usize {
1305	1414	}
1306	1415
1307	1416
1308		#attribute("test")
1309	1417	fn pointerComparison() {
	1418	@setFnTest(this, true);
	1419
1310	1420	const a = ([]u8)("a");
1311	1421	const b = &a;
1312	1422	assert(ptrEql(b, b));
...	...	@@ -1315,15 +1425,17 @@ fn ptrEql(a: &[]u8, b: &[]u8) -> bool {
1315	1425	a == b
1316	1426	}
1317	1427
1318		#attribute("test")
1319	1428	fn characterLiterals() {
	1429	@setFnTest(this, true);
	1430
1320	1431	assert('\'' == single_quote);
1321	1432	}
1322	1433	const single_quote = '\'';
1323	1434
1324	1435
1325		#attribute("test")
1326	1436	fn switchWithMultipleExpressions() {
	1437	@setFnTest(this, true);
	1438
1327	1439	const x: i32 = switch (returnsFive()) {
1328	1440	1, 2, 3 => 1,
1329	1441	4, 5, 6 => 2,
...	...	@@ -1331,12 +1443,16 @@ fn switchWithMultipleExpressions() {
1331	1443	};
1332	1444	assert(x == 2);
1333	1445	}
1334		#static_eval_enable(false)
1335		fn returnsFive() -> i32 { 5 }
	1446	fn returnsFive() -> i32 {
	1447	@setFnStaticEval(this, false);
	1448	5
	1449	}
	1450
1336	1451
1337	1452
1338		#attribute("test")
1339	1453	fn switchOnErrorUnion() {
	1454	@setFnTest(this, true);
	1455
1340	1456	const x = switch (returnsTen()) {
1341	1457	Ok => \|val\| val + 1,
1342	1458	ItBroke, NoMem => 1,
...	...	@@ -1347,20 +1463,28 @@ fn switchOnErrorUnion() {
1347	1463	error ItBroke;
1348	1464	error NoMem;
1349	1465	error CrappedOut;
1350		#static_eval_enable(false)
1351		fn returnsTen() -> %i32 { 10 }
	1466	fn returnsTen() -> %i32 {
	1467	@setFnStaticEval(this, false);
	1468	10
	1469	}
	1470
1352	1471
1353	1472
1354		#attribute("test")
1355	1473	fn boolCmp() {
	1474	@setFnTest(this, true);
	1475
1356	1476	assert(testBoolCmp(true, false) == false);
1357	1477	}
1358		#static_eval_enable(false)
1359		fn testBoolCmp(a: bool, b: bool) -> bool { a == b }
	1478	fn testBoolCmp(a: bool, b: bool) -> bool {
	1479	@setFnStaticEval(this, false);
	1480	a == b
	1481	}
	1482
1360	1483
1361	1484
1362		#attribute("test")
1363	1485	fn takeAddressOfParameter() {
	1486	@setFnTest(this, true);
	1487
1364	1488	testTakeAddressOfParameter(12.34);
1365	1489	testTakeAddressOfParameterNoeval(12.34);
1366	1490	}
...	...	@@ -1368,20 +1492,23 @@ fn testTakeAddressOfParameter(f: f32) {
1368	1492	const f_ptr = &f;
1369	1493	assert(*f_ptr == 12.34);
1370	1494	}
1371		#static_eval_enable(false)
1372	1495	fn testTakeAddressOfParameterNoeval(f: f32) {
	1496	@setFnStaticEval(this, false);
	1497
1373	1498	const f_ptr = &f;
1374	1499	assert(*f_ptr == 12.34);
1375	1500	}
1376	1501
1377	1502
1378		#attribute("test")
1379	1503	fn arrayMultOperator() {
	1504	@setFnTest(this, true);
	1505
1380	1506	assert(str.eql("ab" ** 5, "ababababab"));
1381	1507	}
1382	1508
1383		#attribute("test")
1384	1509	fn stringEscapes() {
	1510	@setFnTest(this, true);
	1511
1385	1512	assert(str.eql("\"", "\x22"));
1386	1513	assert(str.eql("\'", "\x27"));
1387	1514	assert(str.eql("\n", "\x0a"));
...	...	@@ -1391,12 +1518,14 @@ fn stringEscapes() {
1391	1518	assert(str.eql("\u1234\u0069", "\xe1\x88\xb4\x69"));
1392	1519	}
1393	1520
1394		#attribute("test")
1395	1521	fn ifVarMaybePointer() {
	1522	@setFnTest(this, true);
	1523
1396	1524	assert(shouldBeAPlus1(Particle {.a = 14, .b = 1, .c = 1, .d = 1}) == 15);
1397	1525	}
1398		#static_eval_enable(false)
1399	1526	fn shouldBeAPlus1(p: Particle) -> u64 {
	1527	@setFnStaticEval(this, false);
	1528
1400	1529	var maybe_particle: ?Particle = p;
1401	1530	if (const *particle ?= maybe_particle) {
1402	1531	particle.a += 1;
...	...	@@ -1413,8 +1542,9 @@ struct Particle {
1413	1542	d: u64,
1414	1543	}
1415	1544
1416		#attribute("test")
1417	1545	fn assignToIfVarPtr() {
	1546	@setFnTest(this, true);
	1547
1418	1548	var maybe_bool: ?bool = true;
1419	1549
1420	1550	if (const *b ?= maybe_bool) {
...	...	@@ -1424,22 +1554,25 @@ fn assignToIfVarPtr() {
1424	1554	assert(??maybe_bool == false);
1425	1555	}
1426	1556
1427		#attribute("test")
1428	1557	fn cmpxchg() {
	1558	@setFnTest(this, true);
	1559
1429	1560	var x: i32 = 1234;
1430	1561	while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
1431	1562	assert(x == 5678);
1432	1563	}
1433	1564
1434		#attribute("test")
1435	1565	fn fence() {
	1566	@setFnTest(this, true);
	1567
1436	1568	var x: i32 = 1234;
1437	1569	@fence(AtomicOrder.SeqCst);
1438	1570	x = 5678;
1439	1571	}
1440	1572
1441		#attribute("test")
1442	1573	fn unsignedWrapping() {
	1574	@setFnTest(this, true);
	1575
1443	1576	testUnsignedWrappingEval(@maxValue(u32));
1444	1577	testUnsignedWrappingNoeval(@maxValue(u32));
1445	1578	}
...	...	@@ -1449,16 +1582,18 @@ fn testUnsignedWrappingEval(x: u32) {
1449	1582	const orig = zero -% 1;
1450	1583	assert(orig == @maxValue(u32));
1451	1584	}
1452		#static_eval_enable(false)
1453	1585	fn testUnsignedWrappingNoeval(x: u32) {
	1586	@setFnStaticEval(this, false);
	1587
1454	1588	const zero = x +% 1;
1455	1589	assert(zero == 0);
1456	1590	const orig = zero -% 1;
1457	1591	assert(orig == @maxValue(u32));
1458	1592	}
1459	1593
1460		#attribute("test")
1461	1594	fn signedWrapping() {
	1595	@setFnTest(this, true);
	1596
1462	1597	testSignedWrappingEval(@maxValue(i32));
1463	1598	testSignedWrappingNoeval(@maxValue(i32));
1464	1599	}
...	...	@@ -1468,16 +1603,18 @@ fn testSignedWrappingEval(x: i32) {
1468	1603	const max_val = min_val -% 1;
1469	1604	assert(max_val == @maxValue(i32));
1470	1605	}
1471		#static_eval_enable(false)
1472	1606	fn testSignedWrappingNoeval(x: i32) {
	1607	@setFnStaticEval(this, false);
	1608
1473	1609	const min_val = x +% 1;
1474	1610	assert(min_val == @minValue(i32));
1475	1611	const max_val = min_val -% 1;
1476	1612	assert(max_val == @maxValue(i32));
1477	1613	}
1478	1614
1479		#attribute("test")
1480	1615	fn negationWrapping() {
	1616	@setFnTest(this, true);
	1617
1481	1618	testNegationWrappingEval(@minValue(i16));
1482	1619	testNegationWrappingNoeval(@minValue(i16));
1483	1620	}
...	...	@@ -1486,15 +1623,17 @@ fn testNegationWrappingEval(x: i16) {
1486	1623	const neg = -%x;
1487	1624	assert(neg == -32768);
1488	1625	}
1489		#static_eval_enable(false)
1490	1626	fn testNegationWrappingNoeval(x: i16) {
	1627	@setFnStaticEval(this, false);
	1628
1491	1629	assert(x == -32768);
1492	1630	const neg = -%x;
1493	1631	assert(neg == -32768);
1494	1632	}
1495	1633
1496		#attribute("test")
1497	1634	fn shlWrapping() {
	1635	@setFnTest(this, true);
	1636
1498	1637	testShlWrappingEval(@maxValue(u16));
1499	1638	testShlWrappingNoeval(@maxValue(u16));
1500	1639	}
...	...	@@ -1502,22 +1641,25 @@ fn testShlWrappingEval(x: u16) {
1502	1641	const shifted = x <<% 1;
1503	1642	assert(shifted == 65534);
1504	1643	}
1505		#static_eval_enable(false)
1506	1644	fn testShlWrappingNoeval(x: u16) {
	1645	@setFnStaticEval(this, false);
	1646
1507	1647	const shifted = x <<% 1;
1508	1648	assert(shifted == 65534);
1509	1649	}
1510	1650
1511		#attribute("test")
1512	1651	fn shlWithOverflow() {
	1652	@setFnTest(this, true);
	1653
1513	1654	var result: u16 = undefined;
1514	1655	assert(@shlWithOverflow(u16, 0b0010111111111111, 3, &result));
1515	1656	assert(!@shlWithOverflow(u16, 0b0010111111111111, 2, &result));
1516	1657	assert(result == 0b1011111111111100);
1517	1658	}
1518	1659
1519		#attribute("test")
1520	1660	fn cStringConcatenation() {
	1661	@setFnTest(this, true);
	1662
1521	1663	const a = c"OK" ++ c" IT " ++ c"WORKED";
1522	1664	const b = c"OK IT WORKED";
1523	1665
...	...	@@ -1530,8 +1672,9 @@ fn cStringConcatenation() {
1530	1672	assert(b[len] == 0);
1531	1673	}
1532	1674
1533		#attribute("test")
1534	1675	fn genericStruct() {
	1676	@setFnTest(this, true);
	1677
1535	1678	var a1 = GenNode(i32) {.value = 13, .next = null,};
1536	1679	var b1 = GenNode(bool) {.value = true, .next = null,};
1537	1680	assert(a1.value == 13);
...	...	@@ -1544,8 +1687,9 @@ struct GenNode(T: type) {
1544	1687	fn getVal(n: &const GenNode(T)) -> T { n.value }
1545	1688	}
1546	1689
1547		#attribute("test")
1548	1690	fn castSliceToU8Slice() {
	1691	@setFnTest(this, true);
	1692
1549	1693	assert(@sizeOf(i32) == 4);
1550	1694	var big_thing_array = []i32{1, 2, 3, 4};
1551	1695	const big_thing_slice: []i32 = big_thing_array;
...	...	@@ -1565,26 +1709,31 @@ fn castSliceToU8Slice() {
1565	1709	assert(bytes[11] == @maxValue(u8));
1566	1710	}
1567	1711
1568		#attribute("test")
1569	1712	fn floatDivision() {
	1713	@setFnTest(this, true);
	1714
1570	1715	assert(fdiv32(12.0, 3.0) == 4.0);
1571	1716	}
1572		#static_eval_enable(false)
1573	1717	fn fdiv32(a: f32, b: f32) -> f32 {
	1718	@setFnStaticEval(this, false);
	1719
1574	1720	a / b
1575	1721	}
1576	1722
1577		#attribute("test")
1578	1723	fn exactDivision() {
	1724	@setFnTest(this, true);
	1725
1579	1726	assert(divExact(55, 11) == 5);
1580	1727	}
1581		#static_eval_enable(false)
1582	1728	fn divExact(a: u32, b: u32) -> u32 {
	1729	@setFnStaticEval(this, false);
	1730
1583	1731	@divExact(a, b)
1584	1732	}
1585	1733
1586		#attribute("test")
1587	1734	fn nullLiteralOutsideFunction() {
	1735	@setFnTest(this, true);
	1736
1588	1737	const is_null = if (const _ ?= here_is_a_null_literal.context) false else true;
1589	1738	assert(is_null);
1590	1739	}
...	...	@@ -1595,25 +1744,29 @@ const here_is_a_null_literal = SillyStruct {
1595	1744	.context = null,
1596	1745	};
1597	1746
1598		#attribute("test")
1599	1747	fn truncate() {
	1748	@setFnTest(this, true);
	1749
1600	1750	assert(testTruncate(0x10fd) == 0xfd);
1601	1751	}
1602		#static_eval_enable(false)
1603	1752	fn testTruncate(x: u32) -> u8 {
	1753	@setFnStaticEval(this, false);
	1754
1604	1755	@truncate(u8, x)
1605	1756	}
1606	1757
1607		#attribute("test")
1608	1758	fn constDeclsInStruct() {
	1759	@setFnTest(this, true);
	1760
1609	1761	assert(GenericDataThing(3).count_plus_one == 4);
1610	1762	}
1611	1763	struct GenericDataThing(count: isize) {
1612	1764	const count_plus_one = count + 1;
1613	1765	}
1614	1766
1615		#attribute("test")
1616	1767	fn useGenericParamInGenericParam() {
	1768	@setFnTest(this, true);
	1769
1617	1770	assert(aGenericFn(i32, 3, 4) == 7);
1618	1771	}
1619	1772	fn aGenericFn(inline T: type, inline a: T, b: T) -> T {
...	...	@@ -1621,14 +1774,16 @@ fn aGenericFn(inline T: type, inline a: T, b: T) -> T {
1621	1774	}
1622	1775
1623	1776
1624		#attribute("test")
1625	1777	fn unsigned64BitDivision() {
	1778	@setFnTest(this, true);
	1779
1626	1780	const result = div(1152921504606846976, 34359738365);
1627	1781	assert(result.quotient == 33554432);
1628	1782	assert(result.remainder == 100663296);
1629	1783	}
1630		#static_eval_enable(false)
1631	1784	fn div(a: u64, b: u64) -> DivResult {
	1785	@setFnStaticEval(this, false);
	1786
1632	1787	DivResult {
1633	1788	.quotient = a / b,
1634	1789	.remainder = a % b,
...	...	@@ -1639,8 +1794,9 @@ struct DivResult {
1639	1794	remainder: u64,
1640	1795	}
1641	1796
1642		#attribute("test")
1643	1797	fn intTypeBuiltin() {
	1798	@setFnTest(this, true);
	1799
1644	1800	assert(@intType(true, 8) == i8);
1645	1801	assert(@intType(true, 16) == i16);
1646	1802	assert(@intType(true, 32) == i32);
...	...	@@ -1670,16 +1826,18 @@ fn intTypeBuiltin() {
1670	1826
1671	1827	}
1672	1828
1673		#attribute("test")
1674	1829	fn intToEnum() {
	1830	@setFnTest(this, true);
	1831
1675	1832	testIntToEnumEval(3);
1676	1833	testIntToEnumNoeval(3);
1677	1834	}
1678	1835	fn testIntToEnumEval(x: i32) {
1679	1836	assert(IntToEnumNumber(x) == IntToEnumNumber.Three);
1680	1837	}
1681		#static_eval_enable(false)
1682	1838	fn testIntToEnumNoeval(x: i32) {
	1839	@setFnStaticEval(this, false);
	1840
1683	1841	assert(IntToEnumNumber(x) == IntToEnumNumber.Three);
1684	1842	}
1685	1843	enum IntToEnumNumber {