Commit 5f9ecb8566645f16ff9bf8527c92c7db9baf9719 | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-01-14 02:52:33-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-01-14 02:52:33-07:00
log	5f9ecb8566645f16ff9bf8527c92c7db9baf9719
tree	539e1d309e50a96ee243623e0788fb5cca4a5efe
parent	d121ed961ac9fa58a5a6e2695dc62dbb01c60523

instead of 'as' to cast, call type as function

14 files changed, 533 insertions(+), 392 deletions(-)

README.md
doc
- langref.md
- vim
  - syntax
    zig.vim
example
- guess_number
  - main.zig
src
std
test
- run_tests.cpp

README.md+6

...	...	@@ -41,6 +41,12 @@ compromises backward compatibility.
41	41	provide a tag or sha1).
42	42	* Include documentation generator.
43	43	* Shebang line OK so language can be used for "scripting" as well.
	44	* Have the compiler run continuously, watching the file system for source
	45	changes and automatically perform multithreaded compilation to build projects
	46	quickly.
	47	* Hot code swapping. When integrated with the previous feature, you could
	48	press "save" in your editor and see the change immediately in your running
	49	software.
44	50
45	51	### Current Status
46	52

doc/langref.md+1-3

...	...	@@ -126,12 +126,10 @@ AdditionExpression : MultiplyExpression AdditionOperator AdditionExpression \| Mu
126	126
127	127	AdditionOperator : token(Plus) \| token(Minus)
128	128
129		MultiplyExpression : CastExpression MultiplyOperator MultiplyExpression \| CastExpression
	129	MultiplyExpression : PrefixOpExpression MultiplyOperator MultiplyExpression \| PrefixOpExpression
130	130
131	131	MultiplyOperator : token(Star) \| token(Slash) \| token(Percent)
132	132
133		CastExpression : CastExpression token(as) PrimaryExpression \| PrefixOpExpression
134
135	133	PrefixOpExpression : PrefixOp PrefixOpExpression \| SuffixOpExpression
136	134
137	135	SuffixOpExpression : PrimaryExpression option(FnCallExpression \| ArrayAccessExpression \| FieldAccessExpression \| SliceExpression \| ContainerInitExpression)

doc/vim/syntax/zig.vim-1

...	...	@@ -7,7 +7,6 @@ if exists("b:current_syntax")
7	7	finish
8	8	endif
9	9
10		syn keyword zigOperator as
11	10	syn keyword zigStorage const var extern volatile export pub noalias
12	11	syn keyword zigStructure struct enum type
13	12	syn keyword zigStatement goto break return continue asm

example/guess_number/main.zig+1-1

...	...	@@ -7,7 +7,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
7	7	print_str("Welcome to the Guess Number Game in Zig.\n");
8	8
9	9	var seed : u32;
10		const err = os_get_random_bytes(&seed as (&u8), @sizeof(u32));
	10	const err = os_get_random_bytes((&u8)(&seed), @sizeof(u32));
11	11	if (err != @sizeof(u32)) {
12	12	// TODO full error message
13	13	fprint_str(stderr_fileno, "unable to get random bytes\n");

src/all_types.hpp+32-11

...	...	@@ -106,7 +106,6 @@ enum NodeType {
106	106	NodeTypeReturnExpr,
107	107	NodeTypeVariableDeclaration,
108	108	NodeTypeBinOpExpr,
109		NodeTypeCastExpr,
110	109	NodeTypeNumberLiteral,
111	110	NodeTypeStringLiteral,
112	111	NodeTypeCharLiteral,
...	...	@@ -272,6 +271,8 @@ struct AstNodeFnCallExpr {
272	271	BuiltinFnEntry *builtin_fn;
273	272	Expr resolved_expr;
274	273	NumLitCodeGen resolved_num_lit;
	274	Cast cast;
	275	FnTableEntry *fn_entry;
275	276	};
276	277
277	278	struct AstNodeArrayAccessExpr {
...	...	@@ -320,15 +321,6 @@ struct AstNodeRootExportDecl {
320	321	ZigList<AstNode > directives;
321	322	};
322	323
323		struct AstNodeCastExpr {
324		AstNode *expr;
325		AstNode *type;
326
327		// populated by semantic analyzer
328		Cast cast;
329		Expr resolved_expr;
330		};
331
332	324	enum PrefixOp {
333	325	PrefixOpInvalid,
334	326	PrefixOpBoolNot,
...	...	@@ -541,6 +533,9 @@ struct AstNodeSymbolExpr {
541	533
542	534	// populated by semantic analyzer
543	535	Expr resolved_expr;
	536	VariableTableEntry *variable;
	537	TypeTableEntry *meta_type;
	538	FnTableEntry *fn_entry;
544	539	};
545	540
546	541	struct AstNodeBoolLiteral {
...	...	@@ -588,7 +583,6 @@ struct AstNode {
588	583	AstNodeBinOpExpr bin_op_expr;
589	584	AstNodeExternBlock extern_block;
590	585	AstNodeDirective directive;
591		AstNodeCastExpr cast_expr;
592	586	AstNodePrefixOpExpr prefix_op_expr;
593	587	AstNodeFnCallExpr fn_call_expr;
594	588	AstNodeArrayAccessExpr array_access_expr;
...	...	@@ -693,6 +687,12 @@ struct TypeTableEntryEnum {
693	687	bool reported_infinite_err;
694	688	};
695	689
	690	struct TypeTableEntryFn {
	691	TypeTableEntry *return_type;
	692	TypeTableEntry **param_types;
	693	int param_count;
	694	};
	695
696	696	enum TypeTableEntryId {
697	697	TypeTableEntryIdInvalid,
698	698	TypeTableEntryIdMetaType,
...	...	@@ -707,6 +707,7 @@ enum TypeTableEntryId {
707	707	TypeTableEntryIdNumberLiteral,
708	708	TypeTableEntryIdMaybe,
709	709	TypeTableEntryIdEnum,
	710	TypeTableEntryIdFn,
710	711	};
711	712
712	713	struct TypeTableEntry {
...	...	@@ -728,6 +729,7 @@ struct TypeTableEntry {
728	729	TypeTableEntryMaybe maybe;
729	730	TypeTableEntryEnum enumeration;
730	731	TypeTableEntryMetaType meta_type;
	732	TypeTableEntryFn fn;
731	733	} data;
732	734
733	735	// use these fields to make sure we don't duplicate type table entries for the same type
...	...	@@ -781,6 +783,7 @@ struct FnTableEntry {
781	783	ZigList<BlockContext *> all_block_contexts;
782	784	TypeTableEntry *member_of_struct;
783	785	Buf symbol_name;
	786	TypeTableEntry *type_entry; // function type
784	787
785	788	// reminder: hash tables must be initialized before use
786	789	HashMap<Buf , LabelTableEntry , buf_hash, buf_eql_buf> label_table;
...	...	@@ -913,4 +916,22 @@ struct BlockContext {
913	916	LLVMZigDIScope *di_scope;
914	917	};
915	918
	919	struct ConstExprValue {
	920	bool ok; // true if constant expression evalution worked
	921	bool depends_on_compile_var;
	922
	923	union {
	924	uint64_t x_uint;
	925	int64_t x_int;
	926	double x_float;
	927	bool x_bool;
	928	FnTableEntry *x_fn;
	929	TypeTableEntry *x_type;
	930	struct {
	931	bool is_null;
	932	ConstExprValue *child_val;
	933	} x_maybe;
	934	} data;
	935	};
	936
916	937	#endif

src/analyze.cpp+405-242

...	...	@@ -13,8 +13,8 @@
13	13
14	14	static TypeTableEntry * analyze_expression(CodeGen g, ImportTableEntry import, BlockContext *context,
15	15	TypeTableEntry expected_type, AstNode node);
16		static TypeTableEntry eval_const_expr(CodeGen g, BlockContext *context,
17		AstNode node, AstNodeNumberLiteral out_number_literal);
	16	static void eval_const_expr(CodeGen g, BlockContext context,
	17	AstNode node, ConstExprValue out_val);
18	18	static VariableTableEntry analyze_variable_declaration(CodeGen g, ImportTableEntry *import,
19	19	BlockContext context, TypeTableEntry expected_type, AstNode *node);
20	20	static void resolve_struct_type(CodeGen g, ImportTableEntry import, TypeTableEntry *struct_type);
...	...	@@ -32,8 +32,6 @@ static AstNode first_executing_node(AstNode node) {
32	32	return first_executing_node(node->data.slice_expr.array_ref_expr);
33	33	case NodeTypeFieldAccessExpr:
34	34	return first_executing_node(node->data.field_access_expr.struct_expr);
35		case NodeTypeCastExpr:
36		return first_executing_node(node->data.cast_expr.expr);
37	35	case NodeTypeRoot:
38	36	case NodeTypeRootExportDecl:
39	37	case NodeTypeFnProto:
...	...	@@ -125,6 +123,7 @@ TypeTableEntry *new_type_table_entry(TypeTableEntryId id) {
125	123	case TypeTableEntryIdArray:
126	124	case TypeTableEntryIdNumberLiteral:
127	125	case TypeTableEntryIdMaybe:
	126	case TypeTableEntryIdFn:
128	127	// nothing to init
129	128	break;
130	129	case TypeTableEntryIdStruct:
...	...	@@ -357,63 +356,74 @@ static TypeTableEntry analyze_type_expr(CodeGen g, ImportTableEntry *import, B
357	356	}
358	357	}
359	358
360
361		static TypeTableEntry eval_const_expr_bin_op(CodeGen g, BlockContext *context,
362		AstNode node, AstNodeNumberLiteral out_number_literal)
	359	static void eval_const_expr_bin_op(CodeGen g, BlockContext context,
	360	AstNode node, ConstExprValue out_val)
363	361	{
364		AstNodeNumberLiteral op1_lit;
365		AstNodeNumberLiteral op2_lit;
366		TypeTableEntry *op1_type = eval_const_expr(g, context, node->data.bin_op_expr.op1, &op1_lit);
367		TypeTableEntry *op2_type = eval_const_expr(g, context, node->data.bin_op_expr.op1, &op2_lit);
368
369		if (op1_type->id == TypeTableEntryIdInvalid \|\|
370		op2_type->id == TypeTableEntryIdInvalid)
371		{
372		return g->builtin_types.entry_invalid;
	362	AstNode *op1_node = node->data.bin_op_expr.op1;
	363	AstNode *op2_node = node->data.bin_op_expr.op2;
	364	ConstExprValue op1_val = {0};
	365	ConstExprValue op2_val = {0};
	366	eval_const_expr(g, context, op1_node, &op1_val);
	367	eval_const_expr(g, context, op2_node, &op2_val);
	368
	369	if (!op1_val.ok \|\| !op2_val.ok) {
	370	return;
373	371	}
374	372
	373	TypeTableEntry *op1_type = get_resolved_expr(op1_node)->type_entry;
	374	TypeTableEntry *op2_type = get_resolved_expr(op2_node)->type_entry;
	375
375	376	// TODO complete more of this function instead of returning invalid
376	377	// returning invalid makes the "unable to evaluate constant expression" error
377	378
378	379	switch (node->data.bin_op_expr.bin_op) {
379	380	case BinOpTypeCmpNotEq:
380	381	{
381		if (is_num_lit_unsigned(op1_lit.kind) &&
382		is_num_lit_unsigned(op2_lit.kind))
	382	if (op1_type->id == TypeTableEntryIdInt &&
	383	op2_type->id == TypeTableEntryIdInt)
383	384	{
384		out_number_literal->kind = NumLitU8;
385		out_number_literal->overflow = false;
386		out_number_literal->data.x_uint = (op1_lit.data.x_uint != op2_lit.data.x_uint);
387		return get_resolved_expr(node)->type_entry;
388		} else {
389		return g->builtin_types.entry_invalid;
	385	out_val->data.x_bool = (op1_val.data.x_uint == op2_val.data.x_uint);
	386	out_val->ok = true;
390	387	}
	388	break;
391	389	}
392	390	case BinOpTypeCmpLessThan:
393	391	{
394		if (is_num_lit_unsigned(op1_lit.kind) &&
395		is_num_lit_unsigned(op2_lit.kind))
	392	if (op1_type->id == TypeTableEntryIdInt &&
	393	op2_type->id == TypeTableEntryIdInt)
396	394	{
397		out_number_literal->kind = NumLitU8;
398		out_number_literal->overflow = false;
399		out_number_literal->data.x_uint = (op1_lit.data.x_uint < op2_lit.data.x_uint);
400		return get_resolved_expr(node)->type_entry;
401		} else {
402		return g->builtin_types.entry_invalid;
	395	if (op1_type->data.integral.is_signed &&
	396	op2_type->data.integral.is_signed)
	397	{
	398	out_val->data.x_bool = (op1_val.data.x_int < op2_val.data.x_int);
	399	out_val->ok = true;
	400	} else if (!op1_type->data.integral.is_signed &&
	401	!op2_type->data.integral.is_signed)
	402	{
	403	out_val->data.x_bool = (op1_val.data.x_uint < op2_val.data.x_uint);
	404	out_val->ok = true;
	405	}
403	406	}
	407	break;
404	408	}
405	409	case BinOpTypeMod:
406	410	{
407		if (is_num_lit_unsigned(op1_lit.kind) &&
408		is_num_lit_unsigned(op2_lit.kind))
	411	if (op1_type->id == TypeTableEntryIdInt &&
	412	op2_type->id == TypeTableEntryIdInt)
409	413	{
410		out_number_literal->kind = NumLitU64;
411		out_number_literal->overflow = false;
412		out_number_literal->data.x_uint = (op1_lit.data.x_uint % op2_lit.data.x_uint);
413		return get_resolved_expr(node)->type_entry;
414		} else {
415		return g->builtin_types.entry_invalid;
	414	if (op1_type->data.integral.is_signed &&
	415	op2_type->data.integral.is_signed)
	416	{
	417	out_val->data.x_int = op1_val.data.x_int % op2_val.data.x_int;
	418	out_val->ok = true;
	419	} else if (!op1_type->data.integral.is_signed &&
	420	!op2_type->data.integral.is_signed)
	421	{
	422	out_val->data.x_uint = op1_val.data.x_uint % op2_val.data.x_uint;
	423	out_val->ok = true;
	424	}
416	425	}
	426	break;
417	427	}
418	428	case BinOpTypeBoolOr:
419	429	case BinOpTypeBoolAnd:
...	...	@@ -431,7 +441,7 @@ static TypeTableEntry eval_const_expr_bin_op(CodeGen g, BlockContext *context,
431	441	case BinOpTypeMult:
432	442	case BinOpTypeDiv:
433	443	case BinOpTypeUnwrapMaybe:
434		return g->builtin_types.entry_invalid;
	444	break;
435	445	case BinOpTypeInvalid:
436	446	case BinOpTypeAssign:
437	447	case BinOpTypeAssignTimes:
...	...	@@ -448,31 +458,23 @@ static TypeTableEntry eval_const_expr_bin_op(CodeGen g, BlockContext *context,
448	458	case BinOpTypeAssignBoolOr:
449	459	zig_unreachable();
450	460	}
451		zig_unreachable();
452	461	}
453	462
454		static TypeTableEntry eval_const_expr_fn_call(CodeGen g, BlockContext *context,
455		AstNode node, AstNodeNumberLiteral out_number_literal)
456		{
457		if (!node->data.fn_call_expr.is_builtin) {
458		return g->builtin_types.entry_invalid;
459		}
460
	463	static void eval_const_expr_builtin(CodeGen g, BlockContext context, AstNode node, ConstExprValue out_val) {
461	464	switch (node->data.fn_call_expr.builtin_fn->id) {
462	465	case BuiltinFnIdInvalid:
463	466	zig_unreachable();
464	467	case BuiltinFnIdArithmeticWithOverflow:
465	468	case BuiltinFnIdMemcpy:
466	469	case BuiltinFnIdMemset:
467		return g->builtin_types.entry_invalid;
	470	break;
468	471	case BuiltinFnIdSizeof:
469	472	{
470	473	AstNode *type_node = node->data.fn_call_expr.params.at(0);
471	474	TypeTableEntry *target_type = unwrapped_node_type(type_node);
472		out_number_literal->overflow = false;
473		out_number_literal->data.x_uint = target_type->size_in_bits / 8;
474		out_number_literal->kind = get_number_literal_kind_unsigned(out_number_literal->data.x_uint);
475		return get_resolved_expr(node)->type_entry;
	475	out_val->data.x_uint = target_type->size_in_bits / 8;
	476	out_val->ok = true;
	477	break;
476	478	}
477	479	case BuiltinFnIdMaxValue:
478	480	case BuiltinFnIdMinValue:
...	...	@@ -480,43 +482,154 @@ static TypeTableEntry eval_const_expr_fn_call(CodeGen g, BlockContext *context
480	482	case BuiltinFnIdValueCount:
481	483	zig_panic("TODO eval_const_expr_fn_call value_count");
482	484	case BuiltinFnIdTypeof:
483		return get_resolved_expr(node)->type_entry;
	485	// TODO
	486	out_val->ok = true;
	487	break;
484	488	}
485		zig_unreachable();
486	489	}
487	490
488		static TypeTableEntry eval_const_expr(CodeGen g, BlockContext *context,
489		AstNode node, AstNodeNumberLiteral out_number_literal)
	491	static void eval_const_expr_fn_call_known(CodeGen g, BlockContext context,
	492	AstNode node, ConstExprValue out_val)
	493	{
	494	// currently no functions can be constant expression evaluated,
	495	// so we do nothing
	496	}
	497
	498	static void eval_const_expr_fn_call_cast(CodeGen g, BlockContext context,
	499	AstNode node, ConstExprValue out_val)
	500	{
	501	assert(node->type == NodeTypeFnCallExpr);
	502	AstNode *expr_node = node->data.fn_call_expr.params.at(0);
	503	Cast *cast = &node->data.fn_call_expr.cast;
	504	switch (cast->op) {
	505	case CastOpNothing:
	506	case CastOpPtrToInt:
	507	case CastOpPointerReinterpret:
	508	case CastOpIntWidenOrShorten:
	509	{
	510	eval_const_expr(g, context, expr_node, out_val);
	511	break;
	512	}
	513	case CastOpMaybeWrap:
	514	{
	515	ConstExprValue *child_val = allocate<ConstExprValue>(1);
	516	eval_const_expr(g, context, expr_node, child_val);
	517	if (!child_val->ok) {
	518	return;
	519	}
	520	out_val->data.x_maybe.child_val = child_val;
	521	out_val->data.x_maybe.is_null = false;
	522	out_val->ok = true;
	523	break;
	524	}
	525	case CastOpToUnknownSizeArray:
	526	zig_panic("TODO eval_const_expr CastOpToUnknownSizeArray");
	527	}
	528	}
	529
	530	static void eval_const_expr_fn_call(CodeGen g, BlockContext context,
	531	AstNode node, ConstExprValue out_val)
	532	{
	533	if (node->data.fn_call_expr.is_builtin) {
	534	return eval_const_expr_builtin(g, context, node, out_val);
	535	}
	536	if (node->data.fn_call_expr.fn_entry) {
	537	return eval_const_expr_fn_call_known(g, context, node, out_val);
	538	}
	539	return eval_const_expr_fn_call_cast(g, context, node, out_val);
	540	}
	541
	542	static void eval_const_expr_prefix_op_expr(CodeGen g, BlockContext context, AstNode *node,
	543	ConstExprValue *out_val)
490	544	{
	545	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
	546	switch (node->data.prefix_op_expr.prefix_op) {
	547	case PrefixOpInvalid:
	548	zig_unreachable();
	549	case PrefixOpBoolNot:
	550	{
	551	eval_const_expr(g, context, expr_node, out_val);
	552	if (out_val->ok) {
	553	out_val->data.x_bool = !out_val->data.x_bool;
	554	}
	555	break;
	556	}
	557	case PrefixOpBinNot:
	558	break;
	559	case PrefixOpNegation:
	560	break;
	561	case PrefixOpAddressOf:
	562	{
	563	if (get_resolved_expr(node)->type_entry->id == TypeTableEntryIdMetaType) {
	564	eval_const_expr(g, context, expr_node, out_val);
	565	}
	566	break;
	567	}
	568	case PrefixOpConstAddressOf:
	569	break;
	570	case PrefixOpDereference:
	571	break;
	572	case PrefixOpMaybe:
	573	break;
	574	}
	575	}
	576
	577	static void eval_const_expr(CodeGen g, BlockContext context, AstNode node, ConstExprValue out_val) {
491	578	switch (node->type) {
492	579	case NodeTypeNumberLiteral:
493		*out_number_literal = node->data.number_literal;
494		return get_resolved_expr(node)->type_entry;
	580	{
	581	if (is_num_lit_unsigned(node->data.number_literal.kind)) {
	582	out_val->data.x_uint = node->data.number_literal.data.x_uint;
	583	out_val->ok = true;
	584	} else if (is_num_lit_float(node->data.number_literal.kind)) {
	585	out_val->data.x_uint = node->data.number_literal.data.x_float;
	586	out_val->ok = true;
	587	}
	588	break;
	589	}
495	590	case NodeTypeBoolLiteral:
496		out_number_literal->data.x_uint = node->data.bool_literal.value ? 1 : 0;
497		return get_resolved_expr(node)->type_entry;
	591	out_val->data.x_uint = node->data.bool_literal.value ? 1 : 0;
	592	out_val->ok = true;
	593	break;
498	594	case NodeTypeNullLiteral:
499		return get_resolved_expr(node)->type_entry;
	595	out_val->data.x_maybe.is_null = true;
	596	out_val->ok = true;
	597	break;
500	598	case NodeTypeBinOpExpr:
501		return eval_const_expr_bin_op(g, context, node, out_number_literal);
	599	eval_const_expr_bin_op(g, context, node, out_val);
	600	break;
502	601	case NodeTypeSymbol:
503	602	{
504		VariableTableEntry *var = find_variable(context, &node->data.symbol_expr.symbol);
505		assert(var);
506		AstNode *decl_node = var->decl_node;
507		AstNode *expr_node = decl_node->data.variable_declaration.expr;
508		if (expr_node) {
509		BlockContext *next_context = get_resolved_expr(expr_node)->block_context;
510		return eval_const_expr(g, next_context, expr_node, out_number_literal);
	603	VariableTableEntry *var = node->data.symbol_expr.variable;
	604	if (var) {
	605	if (var->is_const) {
	606	AstNode *decl_node = var->decl_node;
	607	if (decl_node->type == NodeTypeVariableDeclaration) {
	608	AstNode *expr_node = decl_node->data.variable_declaration.expr;
	609	if (expr_node) {
	610	BlockContext *next_context = get_resolved_expr(expr_node)->block_context;
	611	eval_const_expr(g, next_context, expr_node, out_val);
	612	}
	613	}
	614	}
	615	} else if (node->data.symbol_expr.meta_type) {
	616	out_val->ok = true;
	617	} else if (node->data.symbol_expr.fn_entry) {
	618	out_val->ok = true;
	619	out_val->data.x_fn = node->data.symbol_expr.fn_entry;
511	620	} else {
512		// can't eval it
513		return g->builtin_types.entry_invalid;
	621	zig_unreachable();
514	622	}
	623	break;
515	624	}
516	625	case NodeTypeFnCallExpr:
517		return eval_const_expr_fn_call(g, context, node, out_number_literal);
	626	eval_const_expr_fn_call(g, context, node, out_val);
	627	break;
	628	case NodeTypePrefixOpExpr:
	629	eval_const_expr_prefix_op_expr(g, context, node, out_val);
	630	break;
518	631	default:
519		return g->builtin_types.entry_invalid;
	632	break;
520	633	}
521	634	}
522	635
...	...	@@ -550,11 +663,30 @@ static void resolve_function_proto(CodeGen g, AstNode node, FnTableEntry *fn_t
550	663	}
551	664	}
552	665
553		for (int i = 0; i < node->data.fn_proto.params.length; i += 1) {
	666	int param_count = node->data.fn_proto.params.length;
	667
	668	TypeTableEntry *fn_type = new_type_table_entry(TypeTableEntryIdFn);
	669	fn_type->data.fn.param_count = param_count;
	670	fn_type->data.fn.param_types = allocate<TypeTableEntry*>(param_count);
	671
	672	fn_table_entry->type_entry = fn_type;
	673
	674	Buf *name = &node->data.fn_proto.name;
	675	buf_resize(&fn_type->name, 0);
	676	buf_appendf(&fn_type->name, "fn %s(", buf_ptr(name));
	677	for (int i = 0; i < param_count; i += 1) {
554	678	AstNode *child = node->data.fn_proto.params.at(i);
555	679	assert(child->type == NodeTypeParamDecl);
556	680	TypeTableEntry *type_entry = analyze_type_expr(g, import, import->block_context,
557	681	child->data.param_decl.type);
	682	fn_table_entry->type_entry->data.fn.param_types[i] = type_entry;
	683
	684	buf_appendf(&fn_type->name, "%s : %s",
	685	buf_ptr(&child->data.param_decl.name), buf_ptr(&type_entry->name));
	686
	687	if (i + 1 < param_count) {
	688	buf_appendf(&fn_type->name, ", ");
	689	}
558	690
559	691	if (type_entry->id == TypeTableEntryIdUnreachable) {
560	692	add_node_error(g, child->data.param_decl.type,
...	...	@@ -567,7 +699,14 @@ static void resolve_function_proto(CodeGen g, AstNode node, FnTableEntry *fn_t
567	699	}
568	700	}
569	701
570		analyze_type_expr(g, import, import->block_context, node->data.fn_proto.return_type);
	702	TypeTableEntry *return_type = analyze_type_expr(g, import, import->block_context,
	703	node->data.fn_proto.return_type);
	704	fn_table_entry->type_entry->data.fn.return_type = return_type;
	705
	706	buf_appendf(&fn_type->name, ")");
	707	if (return_type->id != TypeTableEntryIdVoid) {
	708	buf_appendf(&fn_type->name, " %s", buf_ptr(&return_type->name));
	709	}
571	710	}
572	711
573	712	static void preview_function_labels(CodeGen g, AstNode node, FnTableEntry *fn_table_entry) {
...	...	@@ -1058,7 +1197,6 @@ static void resolve_top_level_decl(CodeGen g, ImportTableEntry import, AstNode
1058	1197	case NodeTypeBoolLiteral:
1059	1198	case NodeTypeNullLiteral:
1060	1199	case NodeTypeSymbol:
1061		case NodeTypeCastExpr:
1062	1200	case NodeTypePrefixOpExpr:
1063	1201	case NodeTypeIfBoolExpr:
1064	1202	case NodeTypeIfVarExpr:
...	...	@@ -1116,6 +1254,7 @@ static bool num_lit_fits_in_other_type(CodeGen g, TypeTableEntry literal_type,
1116	1254	case TypeTableEntryIdStruct:
1117	1255	case TypeTableEntryIdEnum:
1118	1256	case TypeTableEntryIdMetaType:
	1257	case TypeTableEntryIdFn:
1119	1258	return false;
1120	1259	case TypeTableEntryIdInt:
1121	1260	if (is_num_lit_unsigned(num_lit)) {
...	...	@@ -1703,17 +1842,28 @@ static TypeTableEntry analyze_symbol_expr(CodeGen g, ImportTableEntry *import,
1703	1842
1704	1843	auto primitive_table_entry = g->primitive_type_table.maybe_get(variable_name);
1705	1844	if (primitive_table_entry) {
1706		return get_meta_type(g, primitive_table_entry->value);
	1845	TypeTableEntry *meta_type = get_meta_type(g, primitive_table_entry->value);
	1846	node->data.symbol_expr.meta_type = meta_type;
	1847	return meta_type;
1707	1848	}
1708	1849
1709	1850	VariableTableEntry *var = find_variable(context, variable_name);
1710	1851	if (var) {
	1852	node->data.symbol_expr.variable = var;
1711	1853	return var->type;
1712	1854	}
1713	1855
1714	1856	TypeTableEntry *container_type = find_container(context, variable_name);
1715	1857	if (container_type) {
1716		return get_meta_type(g, container_type);
	1858	TypeTableEntry *meta_type = get_meta_type(g, container_type);
	1859	node->data.symbol_expr.meta_type = meta_type;
	1860	return meta_type;
	1861	}
	1862
	1863	auto fn_table_entry = import->fn_table.maybe_get(variable_name);
	1864	if (fn_table_entry) {
	1865	node->data.symbol_expr.fn_entry = fn_table_entry->value;
	1866	return node->data.symbol_expr.fn_entry->type_entry;
1717	1867	}
1718	1868
1719	1869	add_node_error(g, node, buf_sprintf("use of undeclared identifier '%s'", buf_ptr(variable_name)));
...	...	@@ -1781,65 +1931,6 @@ static bool is_op_allowed(TypeTableEntry *type, BinOpType op) {
1781	1931	zig_unreachable();
1782	1932	}
1783	1933
1784		static TypeTableEntry analyze_cast_expr(CodeGen g, ImportTableEntry import, BlockContext context,
1785		TypeTableEntry expected_type, AstNode node)
1786		{
1787		assert(node->type == NodeTypeCastExpr);
1788
1789		TypeTableEntry *wanted_type = analyze_type_expr(g, import, context, node->data.cast_expr.type);
1790		TypeTableEntry *actual_type = analyze_expression(g, import, context, nullptr, node->data.cast_expr.expr);
1791
1792		if (wanted_type->id == TypeTableEntryIdInvalid \|\|
1793		actual_type->id == TypeTableEntryIdInvalid)
1794		{
1795		return g->builtin_types.entry_invalid;
1796		}
1797
1798		Cast *cast = &node->data.cast_expr.cast;
1799		cast->source_node = node;
1800		cast->after_type = wanted_type;
1801
1802		if ((wanted_type == g->builtin_types.entry_isize \|\| wanted_type == g->builtin_types.entry_usize) &&
1803		actual_type->id == TypeTableEntryIdPointer)
1804		{
1805		cast->op = CastOpPtrToInt;
1806		return wanted_type;
1807		} else if (wanted_type->id == TypeTableEntryIdInt &&
1808		actual_type->id == TypeTableEntryIdInt)
1809		{
1810		cast->op = CastOpIntWidenOrShorten;
1811		return wanted_type;
1812		} else if (wanted_type->id == TypeTableEntryIdStruct &&
1813		wanted_type->data.structure.is_unknown_size_array &&
1814		actual_type->id == TypeTableEntryIdArray &&
1815		actual_type->data.array.child_type == wanted_type->data.structure.fields[0].type_entry)
1816		{
1817		cast->op = CastOpToUnknownSizeArray;
1818		context->cast_expr_alloca_list.append(cast);
1819		return wanted_type;
1820		} else if (actual_type->id == TypeTableEntryIdNumberLiteral &&
1821		num_lit_fits_in_other_type(g, actual_type, wanted_type))
1822		{
1823		AstNode *literal_node = node->data.cast_expr.expr;
1824		NumLitCodeGen *codegen_num_lit = get_resolved_num_lit(literal_node);
1825		assert(!codegen_num_lit->resolved_type);
1826		codegen_num_lit->resolved_type = wanted_type;
1827		cast->op = CastOpNothing;
1828		return wanted_type;
1829		} else if (actual_type->id == TypeTableEntryIdPointer &&
1830		wanted_type->id == TypeTableEntryIdPointer)
1831		{
1832		cast->op = CastOpPointerReinterpret;
1833		return wanted_type;
1834		} else {
1835		add_node_error(g, node,
1836		buf_sprintf("invalid cast from type '%s' to '%s'",
1837		buf_ptr(&actual_type->name),
1838		buf_ptr(&wanted_type->name)));
1839		return g->builtin_types.entry_invalid;
1840		}
1841		}
1842
1843	1934	enum LValPurpose {
1844	1935	LValPurposeAssign,
1845	1936	LValPurposeAddressOf,
...	...	@@ -2153,17 +2244,11 @@ static TypeTableEntry analyze_array_type(CodeGen g, ImportTableEntry *import,
2153	2244	return g->builtin_types.entry_invalid;
2154	2245	}
2155	2246
2156		AstNodeNumberLiteral number_literal;
2157		TypeTableEntry *resolved_type = eval_const_expr(g, context, size_node, &number_literal);
	2247	ConstExprValue const_val = {0};
	2248	eval_const_expr(g, context, size_node, &const_val);
2158	2249
2159		if (resolved_type->id == TypeTableEntryIdInt) {
2160		if (resolved_type->data.integral.is_signed) {
2161		add_node_error(g, size_node,
2162		buf_create_from_str("array size must be unsigned integer"));
2163		return g->builtin_types.entry_invalid;
2164		} else {
2165		return get_meta_type(g, get_array_type(g, import, child_type, number_literal.data.x_uint));
2166		}
	2250	if (const_val.ok) {
	2251	return get_meta_type(g, get_array_type(g, import, child_type, const_val.data.x_uint));
2167	2252	} else {
2168	2253	add_node_error(g, size_node,
2169	2254	buf_create_from_str("unable to resolve constant expression"));
...	...	@@ -2195,12 +2280,11 @@ static TypeTableEntry analyze_while_expr(CodeGen g, ImportTableEntry *import,
2195	2280	} else {
2196	2281	// if the condition is a simple constant expression and there are no break statements
2197	2282	// then the return type is unreachable
2198		AstNodeNumberLiteral number_literal;
2199		TypeTableEntry *resolved_type = eval_const_expr(g, context, condition_node, &number_literal);
2200		if (resolved_type->id != TypeTableEntryIdInvalid) {
2201		assert(resolved_type->id == TypeTableEntryIdBool);
2202		bool constant_cond_value = number_literal.data.x_uint;
2203		if (constant_cond_value) {
	2283	ConstExprValue const_val = {0};
	2284	eval_const_expr(g, context, condition_node, &const_val);
	2285
	2286	if (const_val.ok) {
	2287	if (const_val.data.x_bool) {
2204	2288	node->data.while_expr.condition_always_true = true;
2205	2289	if (!node->data.while_expr.contains_break) {
2206	2290	expr_return_type = g->builtin_types.entry_unreachable;
...	...	@@ -2305,6 +2389,73 @@ static TypeTableEntry analyze_min_max_value(CodeGen g, ImportTableEntry *impor
2305	2389	}
2306	2390	}
2307	2391
	2392	static TypeTableEntry analyze_cast_expr(CodeGen g, ImportTableEntry import, BlockContext context,
	2393	AstNode node, TypeTableEntry invoke_type_entry)
	2394	{
	2395	assert(node->type == NodeTypeFnCallExpr);
	2396
	2397	AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
	2398	int actual_param_count = node->data.fn_call_expr.params.length;
	2399
	2400	if (actual_param_count != 1) {
	2401	add_node_error(g, fn_ref_expr, buf_sprintf("cast expression expects exactly one parameter"));
	2402	return g->builtin_types.entry_invalid;
	2403	}
	2404
	2405	AstNode *expr_node = node->data.fn_call_expr.params.at(0);
	2406	TypeTableEntry *wanted_type = invoke_type_entry->data.meta_type.child_type;
	2407	TypeTableEntry *actual_type = analyze_expression(g, import, context, nullptr, expr_node);
	2408
	2409	if (wanted_type->id == TypeTableEntryIdInvalid \|\|
	2410	actual_type->id == TypeTableEntryIdInvalid)
	2411	{
	2412	return g->builtin_types.entry_invalid;
	2413	}
	2414
	2415	Cast *cast = &node->data.fn_call_expr.cast;
	2416	cast->source_node = node;
	2417	cast->after_type = wanted_type;
	2418
	2419	if ((wanted_type == g->builtin_types.entry_isize \|\| wanted_type == g->builtin_types.entry_usize) &&
	2420	actual_type->id == TypeTableEntryIdPointer)
	2421	{
	2422	cast->op = CastOpPtrToInt;
	2423	return wanted_type;
	2424	} else if (wanted_type->id == TypeTableEntryIdInt &&
	2425	actual_type->id == TypeTableEntryIdInt)
	2426	{
	2427	cast->op = CastOpIntWidenOrShorten;
	2428	return wanted_type;
	2429	} else if (wanted_type->id == TypeTableEntryIdStruct &&
	2430	wanted_type->data.structure.is_unknown_size_array &&
	2431	actual_type->id == TypeTableEntryIdArray &&
	2432	actual_type->data.array.child_type == wanted_type->data.structure.fields[0].type_entry)
	2433	{
	2434	cast->op = CastOpToUnknownSizeArray;
	2435	context->cast_expr_alloca_list.append(cast);
	2436	return wanted_type;
	2437	} else if (actual_type->id == TypeTableEntryIdNumberLiteral &&
	2438	num_lit_fits_in_other_type(g, actual_type, wanted_type))
	2439	{
	2440	NumLitCodeGen *codegen_num_lit = get_resolved_num_lit(expr_node);
	2441	assert(!codegen_num_lit->resolved_type);
	2442	codegen_num_lit->resolved_type = wanted_type;
	2443	cast->op = CastOpNothing;
	2444	return wanted_type;
	2445	} else if (actual_type->id == TypeTableEntryIdPointer &&
	2446	wanted_type->id == TypeTableEntryIdPointer)
	2447	{
	2448	cast->op = CastOpPointerReinterpret;
	2449	return wanted_type;
	2450	} else {
	2451	add_node_error(g, node,
	2452	buf_sprintf("invalid cast from type '%s' to '%s'",
	2453	buf_ptr(&actual_type->name),
	2454	buf_ptr(&wanted_type->name)));
	2455	return g->builtin_types.entry_invalid;
	2456	}
	2457	}
	2458
2308	2459	static TypeTableEntry analyze_builtin_fn_call_expr(CodeGen g, ImportTableEntry import, BlockContext context,
2309	2460	TypeTableEntry expected_type, AstNode node)
2310	2461	{
...	...	@@ -2458,25 +2609,93 @@ static TypeTableEntry analyze_builtin_fn_call_expr(CodeGen g, ImportTableEntry
2458	2609	}
2459	2610	}
2460	2611
	2612	static TypeTableEntry analyze_fn_call_raw(CodeGen g, ImportTableEntry import, BlockContext context,
	2613	TypeTableEntry expected_type, AstNode node, FnTableEntry fn_table_entry, TypeTableEntry struct_type)
	2614	{
	2615	assert(node->type == NodeTypeFnCallExpr);
	2616
	2617	node->data.fn_call_expr.fn_entry = fn_table_entry;
	2618	assert(fn_table_entry->proto_node->type == NodeTypeFnProto);
	2619	AstNodeFnProto *fn_proto = &fn_table_entry->proto_node->data.fn_proto;
	2620
	2621	// count parameters
	2622	int expected_param_count = fn_proto->params.length;
	2623	int actual_param_count = node->data.fn_call_expr.params.length;
	2624
	2625	if (struct_type) {
	2626	actual_param_count += 1;
	2627	}
	2628
	2629	if (fn_proto->is_var_args) {
	2630	if (actual_param_count < expected_param_count) {
	2631	add_node_error(g, node,
	2632	buf_sprintf("expected at least %d arguments, got %d",
	2633	expected_param_count, actual_param_count));
	2634	}
	2635	} else if (expected_param_count != actual_param_count) {
	2636	add_node_error(g, node,
	2637	buf_sprintf("expected %d arguments, got %d",
	2638	expected_param_count, actual_param_count));
	2639	}
	2640
	2641	// analyze each parameter. in the case of a method, we already analyzed the
	2642	// first parameter in order to figure out which struct we were calling a method on.
	2643	for (int i = 0; i < node->data.fn_call_expr.params.length; i += 1) {
	2644	AstNode *child = node->data.fn_call_expr.params.at(i);
	2645	// determine the expected type for each parameter
	2646	TypeTableEntry *expected_param_type = nullptr;
	2647	int fn_proto_i = i + (struct_type ? 1 : 0);
	2648	if (fn_proto_i < fn_proto->params.length) {
	2649	AstNode *param_decl_node = fn_proto->params.at(fn_proto_i);
	2650	assert(param_decl_node->type == NodeTypeParamDecl);
	2651	AstNode *param_type_node = param_decl_node->data.param_decl.type;
	2652	TypeTableEntry *param_type_entry = get_resolved_expr(param_type_node)->type_entry;
	2653	if (param_type_entry) {
	2654	expected_param_type = unwrapped_node_type(param_type_node);
	2655	}
	2656	}
	2657	analyze_expression(g, import, context, expected_param_type, child);
	2658	}
	2659
	2660	return unwrapped_node_type(fn_proto->return_type);
	2661	}
	2662
2461	2663	static TypeTableEntry analyze_fn_call_expr(CodeGen g, ImportTableEntry import, BlockContext context,
2462	2664	TypeTableEntry expected_type, AstNode node)
2463	2665	{
2464	2666	AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
2465		TypeTableEntry *struct_type = nullptr;
2466		HashMap<Buf , FnTableEntry , buf_hash, buf_eql_buf> *fn_table = &import->fn_table;
2467		AstNode *first_param_expr = nullptr;
2468		Buf *name;
	2667
	2668	if (node->data.fn_call_expr.is_builtin) {
	2669	return analyze_builtin_fn_call_expr(g, import, context, expected_type, node);
	2670	}
2469	2671
2470	2672	if (fn_ref_expr->type == NodeTypeFieldAccessExpr) {
2471		first_param_expr = fn_ref_expr->data.field_access_expr.struct_expr;
2472		struct_type = analyze_expression(g, import, context, nullptr, first_param_expr);
2473		name = &fn_ref_expr->data.field_access_expr.field_name;
2474		if (struct_type->id == TypeTableEntryIdStruct) {
2475		fn_table = &struct_type->data.structure.fn_table;
2476		} else if (struct_type->id == TypeTableEntryIdPointer &&
2477		struct_type->data.pointer.child_type->id == TypeTableEntryIdStruct)
	2673	AstNode *first_param_expr = fn_ref_expr->data.field_access_expr.struct_expr;
	2674	TypeTableEntry *struct_type = analyze_expression(g, import, context, nullptr, first_param_expr);
	2675	Buf *name = &fn_ref_expr->data.field_access_expr.field_name;
	2676	if (struct_type->id == TypeTableEntryIdStruct \|\|
	2677	(struct_type->id == TypeTableEntryIdPointer &&
	2678	struct_type->data.pointer.child_type->id == TypeTableEntryIdStruct))
2478	2679	{
2479		fn_table = &struct_type->data.pointer.child_type->data.structure.fn_table;
	2680	TypeTableEntry *bare_struct_type = (struct_type->id == TypeTableEntryIdStruct) ?
	2681	struct_type : struct_type->data.pointer.child_type;
	2682
	2683	auto table_entry = bare_struct_type->data.structure.fn_table.maybe_get(name);
	2684	if (table_entry) {
	2685	return analyze_fn_call_raw(g, import, context, expected_type, node,
	2686	table_entry->value, bare_struct_type);
	2687	} else {
	2688	add_node_error(g, fn_ref_expr,
	2689	buf_sprintf("no function named '%s' in '%s'",
	2690	buf_ptr(name), buf_ptr(&bare_struct_type->name)));
	2691	// still analyze the parameters, even though we don't know what to expect
	2692	for (int i = 0; i < node->data.fn_call_expr.params.length; i += 1) {
	2693	AstNode *child = node->data.fn_call_expr.params.at(i);
	2694	analyze_expression(g, import, context, nullptr, child);
	2695	}
	2696
	2697	return g->builtin_types.entry_invalid;
	2698	}
2480	2699	} else if (struct_type->id == TypeTableEntryIdInvalid) {
2481	2700	return struct_type;
2482	2701	} else if (struct_type->id == TypeTableEntryIdMetaType &&
...	...	@@ -2505,74 +2724,31 @@ static TypeTableEntry analyze_fn_call_expr(CodeGen g, ImportTableEntry *import
2505	2724	buf_sprintf("member reference base type not struct or enum"));
2506	2725	return g->builtin_types.entry_invalid;
2507	2726	}
2508		} else if (fn_ref_expr->type == NodeTypeSymbol) {
2509		if (node->data.fn_call_expr.is_builtin) {
2510		return analyze_builtin_fn_call_expr(g, import, context, expected_type, node);
2511		}
2512		name = &fn_ref_expr->data.symbol_expr.symbol;
2513		} else {
2514		add_node_error(g, node,
2515		buf_sprintf("function pointers not yet supported"));
2516		return g->builtin_types.entry_invalid;
2517	2727	}
2518	2728
2519		auto entry = fn_table->maybe_get(name);
2520
2521		if (!entry) {
2522		add_node_error(g, fn_ref_expr,
2523		buf_sprintf("undefined function: '%s'", buf_ptr(name)));
2524		// still analyze the parameters, even though we don't know what to expect
2525		for (int i = 0; i < node->data.fn_call_expr.params.length; i += 1) {
2526		AstNode *child = node->data.fn_call_expr.params.at(i);
2527		analyze_expression(g, import, context, nullptr, child);
2528		}
2529
	2729	TypeTableEntry *invoke_type_entry = analyze_expression(g, import, context, nullptr, fn_ref_expr);
	2730	if (invoke_type_entry->id == TypeTableEntryIdInvalid) {
2530	2731	return g->builtin_types.entry_invalid;
2531		} else {
2532		FnTableEntry *fn_table_entry = entry->value;
2533		assert(fn_table_entry->proto_node->type == NodeTypeFnProto);
2534		AstNodeFnProto *fn_proto = &fn_table_entry->proto_node->data.fn_proto;
2535
2536		// count parameters
2537		int expected_param_count = fn_proto->params.length;
2538		int actual_param_count = node->data.fn_call_expr.params.length;
2539
2540		if (struct_type) {
2541		actual_param_count += 1;
2542		}
	2732	}
2543	2733
2544		if (fn_proto->is_var_args) {
2545		if (actual_param_count < expected_param_count) {
2546		add_node_error(g, node,
2547		buf_sprintf("expected at least %d arguments, got %d",
2548		expected_param_count, actual_param_count));
2549		}
2550		} else if (expected_param_count != actual_param_count) {
2551		add_node_error(g, node,
2552		buf_sprintf("expected %d arguments, got %d",
2553		expected_param_count, actual_param_count));
2554		}
	2734	// use constant expression evaluator to figure out the function at compile time.
	2735	// otherwise we treat this as a function pointer.
	2736	ConstExprValue const_val = {0};
	2737	eval_const_expr(g, context, fn_ref_expr, &const_val);
2555	2738
2556		// analyze each parameter. in the case of a method, we already analyzed the
2557		// first parameter in order to figure out which struct we were calling a method on.
2558		for (int i = 0; i < node->data.fn_call_expr.params.length; i += 1) {
2559		AstNode *child = node->data.fn_call_expr.params.at(i);
2560		// determine the expected type for each parameter
2561		TypeTableEntry *expected_param_type = nullptr;
2562		int fn_proto_i = i + (struct_type ? 1 : 0);
2563		if (fn_proto_i < fn_proto->params.length) {
2564		AstNode *param_decl_node = fn_proto->params.at(fn_proto_i);
2565		assert(param_decl_node->type == NodeTypeParamDecl);
2566		AstNode *param_type_node = param_decl_node->data.param_decl.type;
2567		TypeTableEntry *param_type_entry = get_resolved_expr(param_type_node)->type_entry;
2568		if (param_type_entry) {
2569		expected_param_type = unwrapped_node_type(param_type_node);
2570		}
2571		}
2572		analyze_expression(g, import, context, expected_param_type, child);
2573		}
	2739	if (!const_val.ok) {
	2740	add_node_error(g, node, buf_sprintf("function pointers not yet supported"));
	2741	return g->builtin_types.entry_invalid;
	2742	}
2574	2743
2575		return unwrapped_node_type(fn_proto->return_type);
	2744	if (invoke_type_entry->id == TypeTableEntryIdMetaType) {
	2745	return analyze_cast_expr(g, import, context, node, invoke_type_entry);
	2746	} else if (invoke_type_entry->id == TypeTableEntryIdFn) {
	2747	return analyze_fn_call_raw(g, import, context, expected_type, node, const_val.data.x_fn, nullptr);
	2748	} else {
	2749	add_node_error(g, fn_ref_expr,
	2750	buf_sprintf("type '%s' not a function", buf_ptr(&invoke_type_entry->name)));
	2751	return g->builtin_types.entry_invalid;
2576	2752	}
2577	2753	}
2578	2754
...	...	@@ -2847,9 +3023,6 @@ static TypeTableEntry * analyze_expression(CodeGen g, ImportTableEntry import,
2847	3023	case NodeTypeSymbol:
2848	3024	return_type = analyze_symbol_expr(g, import, context, expected_type, node);
2849	3025	break;
2850		case NodeTypeCastExpr:
2851		return_type = analyze_cast_expr(g, import, context, expected_type, node);
2852		break;
2853	3026	case NodeTypePrefixOpExpr:
2854	3027	return_type = analyze_prefix_op_expr(g, import, context, expected_type, node);
2855	3028	break;
...	...	@@ -3008,7 +3181,6 @@ static void analyze_top_level_decl(CodeGen g, ImportTableEntry import, AstNode
3008	3181	case NodeTypeBoolLiteral:
3009	3182	case NodeTypeNullLiteral:
3010	3183	case NodeTypeSymbol:
3011		case NodeTypeCastExpr:
3012	3184	case NodeTypePrefixOpExpr:
3013	3185	case NodeTypeIfBoolExpr:
3014	3186	case NodeTypeIfVarExpr:
...	...	@@ -3060,10 +3232,6 @@ static void collect_expr_decl_deps(CodeGen g, ImportTableEntry import, AstNode
3060	3232	case NodeTypeReturnExpr:
3061	3233	collect_expr_decl_deps(g, import, node->data.return_expr.expr, decl_node);
3062	3234	break;
3063		case NodeTypeCastExpr:
3064		collect_expr_decl_deps(g, import, node->data.cast_expr.expr, decl_node);
3065		collect_expr_decl_deps(g, import, node->data.cast_expr.type, decl_node);
3066		break;
3067	3235	case NodeTypePrefixOpExpr:
3068	3236	collect_expr_decl_deps(g, import, node->data.prefix_op_expr.primary_expr, decl_node);
3069	3237	break;
...	...	@@ -3331,7 +3499,6 @@ static void detect_top_level_decl_deps(CodeGen g, ImportTableEntry import, Ast
3331	3499	case NodeTypeBoolLiteral:
3332	3500	case NodeTypeNullLiteral:
3333	3501	case NodeTypeSymbol:
3334		case NodeTypeCastExpr:
3335	3502	case NodeTypePrefixOpExpr:
3336	3503	case NodeTypeIfBoolExpr:
3337	3504	case NodeTypeIfVarExpr:
...	...	@@ -3504,8 +3671,6 @@ Expr get_resolved_expr(AstNode node) {
3504	3671	return &node->data.return_expr.resolved_expr;
3505	3672	case NodeTypeBinOpExpr:
3506	3673	return &node->data.bin_op_expr.resolved_expr;
3507		case NodeTypeCastExpr:
3508		return &node->data.cast_expr.resolved_expr;
3509	3674	case NodeTypePrefixOpExpr:
3510	3675	return &node->data.prefix_op_expr.resolved_expr;
3511	3676	case NodeTypeFnCallExpr:
...	...	@@ -3577,7 +3742,6 @@ NumLitCodeGen get_resolved_num_lit(AstNode node) {
3577	3742	return &node->data.fn_call_expr.resolved_num_lit;
3578	3743	case NodeTypeReturnExpr:
3579	3744	case NodeTypeBinOpExpr:
3580		case NodeTypeCastExpr:
3581	3745	case NodeTypePrefixOpExpr:
3582	3746	case NodeTypeArrayAccessExpr:
3583	3747	case NodeTypeSliceExpr:
...	...	@@ -3627,7 +3791,6 @@ TopLevelDecl get_resolved_top_level_decl(AstNode node) {
3627	3791	case NodeTypeNumberLiteral:
3628	3792	case NodeTypeReturnExpr:
3629	3793	case NodeTypeBinOpExpr:
3630		case NodeTypeCastExpr:
3631	3794	case NodeTypePrefixOpExpr:
3632	3795	case NodeTypeFnCallExpr:
3633	3796	case NodeTypeArrayAccessExpr:

src/codegen.cpp+28-38

...	...	@@ -71,6 +71,8 @@ static LLVMValueRef gen_var_decl_raw(CodeGen g, AstNode source_node, AstNodeVa
71	71	static LLVMValueRef gen_assign_raw(CodeGen g, AstNode source_node, BinOpType bin_op,
72	72	LLVMValueRef target_ref, LLVMValueRef value,
73	73	TypeTableEntry op1_type, TypeTableEntry op2_type);
	74	static LLVMValueRef gen_bare_cast(CodeGen g, AstNode node, LLVMValueRef expr_val,
	75	TypeTableEntry actual_type, TypeTableEntry wanted_type, Cast *cast_node);
74	76
75	77	static TypeTableEntry get_type_for_type_node(AstNode node) {
76	78	TypeTableEntry *meta_type_entry = get_resolved_expr(node)->type_entry;
...	...	@@ -381,23 +383,43 @@ static LLVMValueRef gen_enum_value_expr(CodeGen g, AstNode node, TypeTableEntr
381	383	}
382	384	}
383	385
	386	static LLVMValueRef gen_cast_expr(CodeGen g, AstNode node) {
	387	assert(node->type == NodeTypeFnCallExpr);
	388
	389	AstNode *expr_node = node->data.fn_call_expr.params.at(0);
	390
	391	LLVMValueRef expr_val = gen_expr(g, expr_node);
	392
	393	TypeTableEntry *actual_type = get_expr_type(expr_node);
	394	TypeTableEntry *wanted_type = get_expr_type(node);
	395
	396	Cast *cast_node = &node->data.fn_call_expr.cast;
	397
	398	return gen_bare_cast(g, node, expr_val, actual_type, wanted_type, cast_node);
	399
	400	}
384	401
385	402	static LLVMValueRef gen_fn_call_expr(CodeGen g, AstNode node) {
386	403	assert(node->type == NodeTypeFnCallExpr);
387	404
388		FnTableEntry *fn_table_entry;
	405	if (node->data.fn_call_expr.is_builtin) {
	406	return gen_builtin_fn_call_expr(g, node);
	407	} else if (node->data.fn_call_expr.cast.after_type) {
	408	return gen_cast_expr(g, node);
	409	}
	410
	411	FnTableEntry *fn_table_entry = node->data.fn_call_expr.fn_entry;
389	412	AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
390		TypeTableEntry *struct_type;
391		AstNode *first_param_expr;
	413	TypeTableEntry *struct_type = nullptr;
	414	AstNode *first_param_expr = nullptr;
392	415	if (fn_ref_expr->type == NodeTypeFieldAccessExpr) {
393		Buf *name = &fn_ref_expr->data.field_access_expr.field_name;
394	416	first_param_expr = fn_ref_expr->data.field_access_expr.struct_expr;
395	417	struct_type = get_expr_type(first_param_expr);
396	418	if (struct_type->id == TypeTableEntryIdStruct) {
397		fn_table_entry = struct_type->data.structure.fn_table.get(name);
	419	fn_table_entry = node->data.fn_call_expr.fn_entry;
398	420	} else if (struct_type->id == TypeTableEntryIdPointer) {
399	421	assert(struct_type->data.pointer.child_type->id == TypeTableEntryIdStruct);
400		fn_table_entry = struct_type->data.pointer.child_type->data.structure.fn_table.get(name);
	422	fn_table_entry = node->data.fn_call_expr.fn_entry;
401	423	} else if (struct_type->id == TypeTableEntryIdMetaType &&
402	424	struct_type->data.meta_type.child_type->id == TypeTableEntryIdEnum)
403	425	{
...	...	@@ -414,24 +436,8 @@ static LLVMValueRef gen_fn_call_expr(CodeGen g, AstNode node) {
414	436	} else {
415	437	zig_unreachable();
416	438	}
417		} else if (fn_ref_expr->type == NodeTypeSymbol) {
418		if (node->data.fn_call_expr.is_builtin) {
419		return gen_builtin_fn_call_expr(g, node);
420		}
421
422		// Assume that the expression evaluates to a simple name and return the buf
423		// TODO after we support function pointers we can make this generic
424		assert(fn_ref_expr->type == NodeTypeSymbol);
425		Buf *name = &fn_ref_expr->data.symbol_expr.symbol;
426
427		struct_type = nullptr;
428		first_param_expr = nullptr;
429		fn_table_entry = g->cur_fn->import_entry->fn_table.get(name);
430		} else {
431		zig_unreachable();
432	439	}
433	440
434
435	441	assert(fn_table_entry->proto_node->type == NodeTypeFnProto);
436	442	AstNodeFnProto *fn_proto_data = &fn_table_entry->proto_node->data.fn_proto;
437	443
...	...	@@ -863,20 +869,6 @@ static LLVMValueRef gen_bare_cast(CodeGen g, AstNode node, LLVMValueRef expr_v
863	869	zig_unreachable();
864	870	}
865	871
866		static LLVMValueRef gen_cast_expr(CodeGen g, AstNode node) {
867		assert(node->type == NodeTypeCastExpr);
868
869		LLVMValueRef expr_val = gen_expr(g, node->data.cast_expr.expr);
870
871		TypeTableEntry *actual_type = get_expr_type(node->data.cast_expr.expr);
872		TypeTableEntry *wanted_type = get_expr_type(node);
873
874		Cast *cast_node = &node->data.cast_expr.cast;
875
876		return gen_bare_cast(g, node, expr_val, actual_type, wanted_type, cast_node);
877
878		}
879
880	872	static LLVMValueRef gen_arithmetic_bin_op(CodeGen g, AstNode source_node,
881	873	LLVMValueRef val1, LLVMValueRef val2,
882	874	TypeTableEntry op1_type, TypeTableEntry op2_type,
...	...	@@ -1810,8 +1802,6 @@ static LLVMValueRef gen_expr_no_cast(CodeGen g, AstNode node) {
1810	1802	return gen_return_expr(g, node);
1811	1803	case NodeTypeVariableDeclaration:
1812	1804	return gen_var_decl_expr(g, node);
1813		case NodeTypeCastExpr:
1814		return gen_cast_expr(g, node);
1815	1805	case NodeTypePrefixOpExpr:
1816	1806	return gen_prefix_op_expr(g, node);
1817	1807	case NodeTypeFnCallExpr:

src/parser.cpp+3-34

...	...	@@ -99,8 +99,6 @@ const char *node_type_str(NodeType node_type) {
99	99	return "ReturnExpr";
100	100	case NodeTypeVariableDeclaration:
101	101	return "VariableDeclaration";
102		case NodeTypeCastExpr:
103		return "CastExpr";
104	102	case NodeTypeNumberLiteral:
105	103	return "NumberLiteral";
106	104	case NodeTypeStringLiteral:
...	...	@@ -265,12 +263,6 @@ void ast_print(AstNode *node, int indent) {
265	263	case NodeTypeDirective:
266	264	fprintf(stderr, "%s\n", node_type_str(node->type));
267	265	break;
268		case NodeTypeCastExpr:
269		fprintf(stderr, "%s\n", node_type_str(node->type));
270		ast_print(node->data.cast_expr.expr, indent + 2);
271		if (node->data.cast_expr.type)
272		ast_print(node->data.cast_expr.type, indent + 2);
273		break;
274	266	case NodeTypePrefixOpExpr:
275	267	fprintf(stderr, "%s %s\n", node_type_str(node->type),
276	268	prefix_op_str(node->data.prefix_op_expr.prefix_op));
...	...	@@ -1604,29 +1596,6 @@ static AstNode ast_parse_prefix_op_expr(ParseContext pc, int *token_index, boo
1604	1596	}
1605	1597
1606	1598
1607		/*
1608		CastExpression : CastExpression token(as) PrimaryExpression \| PrefixOpExpression
1609		*/
1610		static AstNode ast_parse_cast_expression(ParseContext pc, int *token_index, bool mandatory) {
1611		AstNode *operand_1 = ast_parse_prefix_op_expr(pc, token_index, mandatory);
1612		if (!operand_1)
1613		return nullptr;
1614
1615		while (true) {
1616		Token as_kw = &pc->tokens->at(token_index);
1617		if (as_kw->id != TokenIdKeywordAs)
1618		return operand_1;
1619		*token_index += 1;
1620
1621		AstNode *node = ast_create_node(pc, NodeTypeCastExpr, as_kw);
1622		node->data.cast_expr.expr = operand_1;
1623
1624		node->data.cast_expr.type = ast_parse_primary_expr(pc, token_index, true);
1625
1626		operand_1 = node;
1627		}
1628		}
1629
1630	1599	static BinOpType tok_to_mult_op(Token *token) {
1631	1600	switch (token->id) {
1632	1601	case TokenIdStar: return BinOpTypeMult;
...	...	@@ -1654,10 +1623,10 @@ static BinOpType ast_parse_mult_op(ParseContext pc, int token_index, bool mand
1654	1623	}
1655	1624
1656	1625	/*
1657		MultiplyExpression : CastExpression MultiplyOperator MultiplyExpression \| CastExpression
	1626	MultiplyExpression : PrefixOpExpression MultiplyOperator MultiplyExpression \| PrefixOpExpression
1658	1627	*/
1659	1628	static AstNode ast_parse_mult_expr(ParseContext pc, int *token_index, bool mandatory) {
1660		AstNode *operand_1 = ast_parse_cast_expression(pc, token_index, mandatory);
	1629	AstNode *operand_1 = ast_parse_prefix_op_expr(pc, token_index, mandatory);
1661	1630	if (!operand_1)
1662	1631	return nullptr;
1663	1632
...	...	@@ -1667,7 +1636,7 @@ static AstNode ast_parse_mult_expr(ParseContext pc, int *token_index, bool man
1667	1636	if (mult_op == BinOpTypeInvalid)
1668	1637	return operand_1;
1669	1638
1670		AstNode *operand_2 = ast_parse_cast_expression(pc, token_index, true);
	1639	AstNode *operand_2 = ast_parse_prefix_op_expr(pc, token_index, true);
1671	1640
1672	1641	AstNode *node = ast_create_node(pc, NodeTypeBinOpExpr, token);
1673	1642	node->data.bin_op_expr.op1 = operand_1;

src/tokenizer.cpp-3

...	...	@@ -211,8 +211,6 @@ static void end_token(Tokenize *t) {
211	211	t->cur_tok->id = TokenIdKeywordPub;
212	212	} else if (mem_eql_str(token_mem, token_len, "export")) {
213	213	t->cur_tok->id = TokenIdKeywordExport;
214		} else if (mem_eql_str(token_mem, token_len, "as")) {
215		t->cur_tok->id = TokenIdKeywordAs;
216	214	} else if (mem_eql_str(token_mem, token_len, "use")) {
217	215	t->cur_tok->id = TokenIdKeywordUse;
218	216	} else if (mem_eql_str(token_mem, token_len, "true")) {
...	...	@@ -1019,7 +1017,6 @@ const char * token_name(TokenId id) {
1019	1017	case TokenIdKeywordExtern: return "extern";
1020	1018	case TokenIdKeywordPub: return "pub";
1021	1019	case TokenIdKeywordExport: return "export";
1022		case TokenIdKeywordAs: return "as";
1023	1020	case TokenIdKeywordUse: return "use";
1024	1021	case TokenIdKeywordTrue: return "true";
1025	1022	case TokenIdKeywordFalse: return "false";

src/tokenizer.hpp-1

...	...	@@ -20,7 +20,6 @@ enum TokenId {
20	20	TokenIdKeywordExtern,
21	21	TokenIdKeywordPub,
22	22	TokenIdKeywordExport,
23		TokenIdKeywordAs,
24	23	TokenIdKeywordUse,
25	24	TokenIdKeywordTrue,
26	25	TokenIdKeywordFalse,

std/rand.zig+4-4

...	...	@@ -13,7 +13,7 @@ pub struct Rand {
13	13	var i : @typeof(ARRAY_SIZE) = 1;
14	14	while (i < ARRAY_SIZE) {
15	15	const prev_value : u64 = r.array[i - 1];
16		r.array[i] = ((prev_value ^ (prev_value << 30)) * 0x6c078965 + i) as u32;
	16	r.array[i] = u32((prev_value ^ (prev_value << 30)) * 0x6c078965 + i);
17	17	i += 1;
18	18	}
19	19	}
...	...	@@ -41,7 +41,7 @@ pub struct Rand {
41	41	var bytes_left = r.get_bytes_aligned(buf);
42	42	if (bytes_left > 0) {
43	43	var rand_val_array : [@sizeof(u32)]u8;
44		*(rand_val_array.ptr as (&u32)) = r.get_u32();
	44	*((&u32)(rand_val_array.ptr)) = r.get_u32();
45	45	while (bytes_left > 0) {
46	46	buf[buf.len - bytes_left] = rand_val_array[@sizeof(u32) - bytes_left];
47	47	bytes_left -= 1;
...	...	@@ -59,7 +59,7 @@ pub struct Rand {
59	59
60	60	while (true) {
61	61	r.get_bytes_aligned(rand_val_array);
62		const rand_val = *(rand_val_array.ptr as (&u64));
	62	const rand_val = *((&u64)(rand_val_array.ptr));
63	63	if (rand_val < upper_bound) {
64	64	return start + (rand_val % range);
65	65	}
...	...	@@ -85,7 +85,7 @@ pub struct Rand {
85	85	fn get_bytes_aligned(r: &Rand, buf: []u8) usize => {
86	86	var bytes_left = buf.len;
87	87	while (bytes_left >= 4) {
88		*(&buf[buf.len - bytes_left] as (&u32)) = r.get_u32();
	88	*((&u32)(&buf[buf.len - bytes_left])) = r.get_u32();
89	89	bytes_left -= @sizeof(u32);
90	90	}
91	91	return bytes_left;

std/std.zig+4-4

...	...	@@ -43,7 +43,7 @@ pub fn readline(buf: []u8, out_len: &usize) bool => {
43	43	if (amt_read < 0) {
44	44	return true;
45	45	}
46		*out_len = amt_read as usize;
	46	*out_len = usize(amt_read);
47	47	return false;
48	48	}
49	49
...	...	@@ -94,9 +94,9 @@ const max_u64_base10_digits: usize = 20;
94	94	fn buf_print_i64(out_buf: []u8, x: i64) usize => {
95	95	if (x < 0) {
96	96	out_buf[0] = '-';
97		return 1 + buf_print_u64(out_buf[1...], ((-(x + 1)) as u64) + 1);
	97	return 1 + buf_print_u64(out_buf[1...], u64(-(x + 1)) + 1);
98	98	} else {
99		return buf_print_u64(out_buf, x as u64);
	99	return buf_print_u64(out_buf, u64(x));
100	100	}
101	101	}
102	102
...	...	@@ -108,7 +108,7 @@ fn buf_print_u64(out_buf: []u8, x: u64) usize => {
108	108	while (true) {
109	109	const digit = a % 10;
110	110	index -= 1;
111		buf[index] = '0' + (digit as u8);
	111	buf[index] = '0' + u8(digit);
112	112	a /= 10;
113	113	if (a == 0)
114	114	break;

std/syscall.zig+4-5

...	...	@@ -18,19 +18,18 @@ fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize => {
18	18	}
19	19
20	20	pub fn read(fd: isize, buf: &u8, count: usize) isize => {
21		syscall3(SYS_read, fd as usize, buf as usize, count) as isize
	21	isize(syscall3(SYS_read, usize(fd), usize(buf), count))
22	22	}
23	23
24	24	pub fn write(fd: isize, buf: &const u8, count: usize) isize => {
25		syscall3(SYS_write, fd as usize, buf as usize, count) as isize
	25	isize(syscall3(SYS_write, usize(fd), usize(buf), count))
26	26	}
27	27
28	28	pub fn exit(status: i32) unreachable => {
29		syscall1(SYS_exit, status as usize);
	29	syscall1(SYS_exit, usize(status));
30	30	unreachable{}
31	31	}
32	32
33	33	pub fn getrandom(buf: &u8, count: usize, flags: u32) isize => {
34		syscall3(SYS_getrandom, buf as usize, count, flags as usize) as isize
	34	isize(syscall3(SYS_getrandom, usize(buf), count, usize(flags)))
35	35	}
36

test/run_tests.cpp+45-45

...	...	@@ -272,7 +272,7 @@ use "std.zig";
272	272
273	273	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
274	274	const a : i32 = 1;
275		const b = 2 as i32;
	275	const b = i32(2);
276	276	if (a + b == 3) {
277	277	print_str("OK\n");
278	278	}
...	...	@@ -302,7 +302,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
302	302	}
303	303
304	304	const c = {
305		const no_conflict = 10 as i32;
	305	const no_conflict = i32(10);
306	306	no_conflict
307	307	};
308	308	if (c == 10) { print_str("OK 2\n"); }
...	...	@@ -358,7 +358,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
358	358	var zero : i32 = 0;
359	359	if (zero == 0) { print_str("zero\n"); }
360	360
361		var i = 0 as i32;
	361	var i = i32(0);
362	362	loop_start:
363	363	if (i == 3) {
364	364	goto done;
...	...	@@ -384,7 +384,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
384	384	}
385	385
386	386	i = 0;
387		var accumulator = 0 as u32;
	387	var accumulator = u32(0);
388	388	while (i < 5) {
389	389	accumulator += array[i];
390	390
...	...	@@ -430,9 +430,9 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
430	430	if (90 >> 1 >> 2 != 90 >> 3) { print_str("BAD 7\n"); }
431	431	if (100 - 1 + 1000 != 1099) { print_str("BAD 8\n"); }
432	432	if (5 * 4 / 2 % 3 != 1) { print_str("BAD 9\n"); }
433		if (5 as i32 as i32 != 5) { print_str("BAD 10\n"); }
	433	if (i32(i32(5)) != 5) { print_str("BAD 10\n"); }
434	434	if (!!false) { print_str("BAD 11\n"); }
435		if (7 as i32 != --(7 as i32)) { print_str("BAD 12\n"); }
	435	if (i32(7) != --(i32(7))) { print_str("BAD 12\n"); }
436	436
437	437	print_str("OK\n");
438	438	return 0;
...	...	@@ -495,82 +495,82 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
495	495	printf(c"\n");
496	496
497	497	printf(c"0: %llu\n",
498		0 as u64);
	498	u64(0));
499	499	printf(c"320402575052271: %llu\n",
500		320402575052271 as u64);
	500	u64(320402575052271));
501	501	printf(c"0x01236789abcdef: %llu\n",
502		0x01236789abcdef as u64);
	502	u64(0x01236789abcdef));
503	503	printf(c"0xffffffffffffffff: %llu\n",
504		0xffffffffffffffff as u64);
	504	u64(0xffffffffffffffff));
505	505	printf(c"0x000000ffffffffffffffff: %llu\n",
506		0x000000ffffffffffffffff as u64);
	506	u64(0x000000ffffffffffffffff));
507	507	printf(c"0o1777777777777777777777: %llu\n",
508		0o1777777777777777777777 as u64);
	508	u64(0o1777777777777777777777));
509	509	printf(c"0o0000001777777777777777777777: %llu\n",
510		0o0000001777777777777777777777 as u64);
	510	u64(0o0000001777777777777777777777));
511	511	printf(c"0b1111111111111111111111111111111111111111111111111111111111111111: %llu\n",
512		0b1111111111111111111111111111111111111111111111111111111111111111 as u64);
	512	u64(0b1111111111111111111111111111111111111111111111111111111111111111));
513	513	printf(c"0b0000001111111111111111111111111111111111111111111111111111111111111111: %llu\n",
514		0b0000001111111111111111111111111111111111111111111111111111111111111111 as u64);
	514	u64(0b0000001111111111111111111111111111111111111111111111111111111111111111));
515	515
516	516	printf(c"\n");
517	517
518	518	printf(c"0.0: %a\n",
519		0.0 as f64);
	519	f64(0.0));
520	520	printf(c"0e0: %a\n",
521		0e0 as f64);
	521	f64(0e0));
522	522	printf(c"0.0e0: %a\n",
523		0.0e0 as f64);
	523	f64(0.0e0));
524	524	printf(c"000000000000000000000000000000000000000000000000000000000.0e0: %a\n",
525		000000000000000000000000000000000000000000000000000000000.0e0 as f64);
	525	f64(000000000000000000000000000000000000000000000000000000000.0e0));
526	526	printf(c"0.000000000000000000000000000000000000000000000000000000000e0: %a\n",
527		0.000000000000000000000000000000000000000000000000000000000e0 as f64);
	527	f64(0.000000000000000000000000000000000000000000000000000000000e0));
528	528	printf(c"0.0e000000000000000000000000000000000000000000000000000000000: %a\n",
529		0.0e000000000000000000000000000000000000000000000000000000000 as f64);
	529	f64(0.0e000000000000000000000000000000000000000000000000000000000));
530	530	printf(c"1.0: %a\n",
531		1.0 as f64);
	531	f64(1.0));
532	532	printf(c"10.0: %a\n",
533		10.0 as f64);
	533	f64(10.0));
534	534	printf(c"10.5: %a\n",
535		10.5 as f64);
	535	f64(10.5));
536	536	printf(c"10.5e5: %a\n",
537		10.5e5 as f64);
	537	f64(10.5e5));
538	538	printf(c"10.5e+5: %a\n",
539		10.5e+5 as f64);
	539	f64(10.5e+5));
540	540	printf(c"50.0e-2: %a\n",
541		50.0e-2 as f64);
	541	f64(50.0e-2));
542	542	printf(c"50e-2: %a\n",
543		50e-2 as f64);
	543	f64(50e-2));
544	544
545	545	printf(c"\n");
546	546
547	547	printf(c"0x1.0: %a\n",
548		0x1.0 as f64);
	548	f64(0x1.0));
549	549	printf(c"0x10.0: %a\n",
550		0x10.0 as f64);
	550	f64(0x10.0));
551	551	printf(c"0x100.0: %a\n",
552		0x100.0 as f64);
	552	f64(0x100.0));
553	553	printf(c"0x103.0: %a\n",
554		0x103.0 as f64);
	554	f64(0x103.0));
555	555	printf(c"0x103.7: %a\n",
556		0x103.7 as f64);
	556	f64(0x103.7));
557	557	printf(c"0x103.70: %a\n",
558		0x103.70 as f64);
	558	f64(0x103.70));
559	559	printf(c"0x103.70p4: %a\n",
560		0x103.70p4 as f64);
	560	f64(0x103.70p4));
561	561	printf(c"0x103.70p5: %a\n",
562		0x103.70p5 as f64);
	562	f64(0x103.70p5));
563	563	printf(c"0x103.70p+5: %a\n",
564		0x103.70p+5 as f64);
	564	f64(0x103.70p+5));
565	565	printf(c"0x103.70p-5: %a\n",
566		0x103.70p-5 as f64);
	566	f64(0x103.70p-5));
567	567
568	568	printf(c"\n");
569	569
570	570	printf(c"0b10100.00010e0: %a\n",
571		0b10100.00010e0 as f64);
	571	f64(0b10100.00010e0));
572	572	printf(c"0o10700.00010e0: %a\n",
573		0o10700.00010e0 as f64);
	573	f64(0o10700.00010e0));
574	574
575	575	return 0;
576	576	}
...	...	@@ -818,7 +818,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
818	818	use "std.zig";
819	819
820	820	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
821		var x = 3 as i32;
	821	var x = i32(3);
822	822	const y = &x;
823	823
824	824	*y += 1;
...	...	@@ -1116,7 +1116,7 @@ fn a() i32 => {}
1116	1116	fn a() => {
1117	1117	b();
1118	1118	}
1119		)SOURCE", 1, ".tmp_source.zig:3:5: error: undefined function: 'b'");
	1119	)SOURCE", 1, ".tmp_source.zig:3:5: error: use of undeclared identifier 'b'");
1120	1120
1121	1121	add_compile_fail_case("wrong number of arguments", R"SOURCE(
1122	1122	fn a() => {
...	...	@@ -1282,7 +1282,7 @@ fn f() => {
1282	1282	add_compile_fail_case("missing else clause", R"SOURCE(
1283	1283	fn f() => {
1284	1284	const x : i32 = if (true) { 1 };
1285		const y = if (true) { 1 as i32 };
	1285	const y = if (true) { i32(1) };
1286	1286	}
1287	1287	)SOURCE", 2, ".tmp_source.zig:3:21: error: expected type 'i32', got 'void'",
1288	1288	".tmp_source.zig:4:15: error: incompatible types: 'i32' and 'void'");
...	...	@@ -1383,9 +1383,9 @@ fn f() => {
1383	1383
1384	1384	add_compile_fail_case("cast unreachable", R"SOURCE(
1385	1385	fn f() i32 => {
1386		(return 1) as i32
	1386	i32(return 1)
1387	1387	}
1388		)SOURCE", 1, ".tmp_source.zig:3:16: error: invalid cast from type 'unreachable' to 'i32'");
	1388	)SOURCE", 1, ".tmp_source.zig:3:8: error: invalid cast from type 'unreachable' to 'i32'");
1389	1389
1390	1390	add_compile_fail_case("invalid builtin fn", R"SOURCE(
1391	1391	fn f() @bogus(foo) => {