Commit e621ad014e919521268d3e2c94afadbdadadb59f | zig

author	Andrew Kelley <andrew@ziglang.org> 2017-01-05 18:50:36-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2017-01-05 18:50:36-05:00
log	e621ad014e919521268d3e2c94afadbdadadb59f
tree	a038e0051b6d8c9b220cb2faa2918eb3f42fa909
parent	97e105489085fcf4530b3944499531d76848bbd1

pass cannot assign to constant test

8 files changed, 70 insertions(+), 36 deletions(-)

example
- cat
  - main.zig
src
- ir.cpp
std
- cstr.zig
- list.zig
test
- cases
- run_tests.cpp

example/cat/main.zig+4-4

...	...	@@ -10,7 +10,7 @@ pub fn main(args: [][]u8) -> %void {
10	10	for (args[1...]) \|arg\| {
11	11	if (str.eql(arg, "-")) {
12	12	catted_anything = true;
13		cat_stream(io.stdin) %% \|err\| return err;
	13	cat_stream(&io.stdin) %% \|err\| return err;
14	14	} else if (arg[0] == '-') {
15	15	return usage(exe);
16	16	} else {
...	...	@@ -24,11 +24,11 @@ pub fn main(args: [][]u8) -> %void {
24	24	defer %%is.close();
25	25
26	26	catted_anything = true;
27		cat_stream(is) %% \|err\| return err;
	27	cat_stream(&is) %% \|err\| return err;
28	28	}
29	29	}
30	30	if (!catted_anything) {
31		cat_stream(io.stdin) %% \|err\| return err;
	31	cat_stream(&io.stdin) %% \|err\| return err;
32	32	}
33	33	io.stdout.flush() %% \|err\| return err;
34	34	}
...	...	@@ -40,7 +40,7 @@ fn usage(exe: []u8) -> %void {
40	40	return error.Invalid;
41	41	}
42	42
43		fn cat_stream(is: io.InStream) -> %void {
	43	fn cat_stream(is: &io.InStream) -> %void {
44	44	var buf: [1024 * 4]u8 = undefined;
45	45
46	46	while (true) {

src/ir.cpp+48-21

...	...	@@ -721,17 +721,23 @@ static IrInstruction ir_build_bin_op_from(IrBuilder irb, IrInstruction *old_in
721	721	return new_instruction;
722	722	}
723	723
724		static IrInstruction ir_build_var_ptr(IrBuilder irb, Scope scope, AstNode source_node, VariableTableEntry *var) {
	724	static IrInstruction ir_build_var_ptr(IrBuilder irb, Scope scope, AstNode source_node,
	725	VariableTableEntry *var, bool is_const)
	726	{
725	727	IrInstructionVarPtr *instruction = ir_build_instruction<IrInstructionVarPtr>(irb, scope, source_node);
726	728	instruction->var = var;
	729	instruction->is_const = is_const;
727	730
728	731	ir_ref_var(var);
729	732
730	733	return &instruction->base;
731	734	}
732	735
733		static IrInstruction ir_build_var_ptr_from(IrBuilder irb, IrInstruction old_instruction, VariableTableEntry var) {
734		IrInstruction *new_instruction = ir_build_var_ptr(irb, old_instruction->scope, old_instruction->source_node, var);
	736	static IrInstruction ir_build_var_ptr_from(IrBuilder irb, IrInstruction *old_instruction,
	737	VariableTableEntry *var, bool is_const)
	738	{
	739	IrInstruction *new_instruction = ir_build_var_ptr(irb, old_instruction->scope,
	740	old_instruction->source_node, var, is_const);
735	741	ir_link_new_instruction(new_instruction, old_instruction);
736	742	return new_instruction;
737	743
...	...	@@ -3401,7 +3407,7 @@ static IrInstruction ir_gen_decl_ref(IrBuilder irb, AstNode *source_node, Tld
3401	3407	{
3402	3408	TldVar tld_var = (TldVar )tld;
3403	3409	VariableTableEntry *var = tld_var->var;
3404		IrInstruction *var_ptr = ir_build_var_ptr(irb, scope, source_node, var);
	3410	IrInstruction *var_ptr = ir_build_var_ptr(irb, scope, source_node, var, false);
3405	3411	if (lval != LValPurposeNone)
3406	3412	return var_ptr;
3407	3413	else
...	...	@@ -3449,7 +3455,7 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node,
3449	3455
3450	3456	VariableTableEntry *var = find_variable(irb->codegen, scope, variable_name);
3451	3457	if (var) {
3452		IrInstruction *var_ptr = ir_build_var_ptr(irb, scope, node, var);
	3458	IrInstruction *var_ptr = ir_build_var_ptr(irb, scope, node, var, lval == LValPurposeAddressOfConst);
3453	3459	if (lval != LValPurposeNone)
3454	3460	return var_ptr;
3455	3461	else
...	...	@@ -4309,7 +4315,7 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
4309	4315
4310	4316	IrInstruction *undefined_value = ir_build_const_undefined(irb, child_scope, elem_node);
4311	4317	ir_build_var_decl(irb, child_scope, elem_node, elem_var, elem_var_type, undefined_value);
4312		IrInstruction *elem_var_ptr = ir_build_var_ptr(irb, child_scope, node, elem_var);
	4318	IrInstruction *elem_var_ptr = ir_build_var_ptr(irb, child_scope, node, elem_var, false);
4313	4319
4314	4320	AstNode *index_var_source_node;
4315	4321	VariableTableEntry *index_var;
...	...	@@ -4327,7 +4333,7 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
4327	4333	IrInstruction *zero = ir_build_const_usize(irb, child_scope, node, 0);
4328	4334	IrInstruction *one = ir_build_const_usize(irb, child_scope, node, 1);
4329	4335	ir_build_var_decl(irb, child_scope, index_var_source_node, index_var, usize, zero);
4330		IrInstruction *index_ptr = ir_build_var_ptr(irb, child_scope, node, index_var);
	4336	IrInstruction *index_ptr = ir_build_var_ptr(irb, child_scope, node, index_var, false);
4331	4337
4332	4338
4333	4339	IrBasicBlock *cond_block = ir_build_basic_block(irb, child_scope, "ForCond");
...	...	@@ -4351,7 +4357,7 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
4351	4357	} else {
4352	4358	elem_val = ir_build_load_ptr(irb, child_scope, node, elem_ptr);
4353	4359	}
4354		ir_build_store_ptr(irb, child_scope, node, elem_var_ptr, elem_val);
	4360	ir_mark_gen(ir_build_store_ptr(irb, child_scope, node, elem_var_ptr, elem_val));
4355	4361
4356	4362	LoopStackItem *loop_stack_item = irb->loop_stack.add_one();
4357	4363	loop_stack_item->break_block = end_block;
...	...	@@ -4365,7 +4371,7 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
4365	4371
4366	4372	ir_set_cursor_at_end(irb, continue_block);
4367	4373	IrInstruction *new_index_val = ir_build_bin_op(irb, child_scope, node, IrBinOpAdd, index_val, one, false);
4368		ir_build_store_ptr(irb, child_scope, node, index_ptr, new_index_val);
	4374	ir_mark_gen(ir_build_store_ptr(irb, child_scope, node, index_ptr, new_index_val));
4369	4375	ir_build_br(irb, child_scope, node, cond_block, is_comptime);
4370	4376
4371	4377	ir_set_cursor_at_end(irb, end_block);
...	...	@@ -7545,9 +7551,15 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
7545	7551	size_t next_proto_i = 0;
7546	7552
7547	7553	if (first_arg_ptr) {
7548		IrInstruction *first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
7549		if (first_arg->value.type->id == TypeTableEntryIdInvalid)
7550		return ira->codegen->builtin_types.entry_invalid;
	7554	IrInstruction *first_arg;
	7555	assert(first_arg_ptr->value.type->id == TypeTableEntryIdPointer);
	7556	if (handle_is_ptr(first_arg_ptr->value.type->data.pointer.child_type)) {
	7557	first_arg = first_arg_ptr;
	7558	} else {
	7559	first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
	7560	if (first_arg->value.type->id == TypeTableEntryIdInvalid)
	7561	return ira->codegen->builtin_types.entry_invalid;
	7562	}
7551	7563
7552	7564	if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, first_arg, &impl_fn->child_scope,
7553	7565	&next_proto_i, generic_id, &fn_type_id, casted_args, impl_fn))
...	...	@@ -7612,9 +7624,15 @@ static TypeTableEntry ir_analyze_fn_call(IrAnalyze ira, IrInstructionCall *cal
7612	7624	IrInstruction *casted_args = allocate<IrInstruction >(call_param_count);
7613	7625	size_t next_arg_index = 0;
7614	7626	if (first_arg_ptr) {
7615		IrInstruction *first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
7616		if (first_arg->value.type->id == TypeTableEntryIdInvalid)
7617		return ira->codegen->builtin_types.entry_invalid;
	7627	IrInstruction *first_arg;
	7628	assert(first_arg_ptr->value.type->id == TypeTableEntryIdPointer);
	7629	if (handle_is_ptr(first_arg_ptr->value.type->data.pointer.child_type)) {
	7630	first_arg = first_arg_ptr;
	7631	} else {
	7632	first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
	7633	if (first_arg->value.type->id == TypeTableEntryIdInvalid)
	7634	return ira->codegen->builtin_types.entry_invalid;
	7635	}
7618	7636
7619	7637	TypeTableEntry *param_type = fn_type_id->param_info[next_arg_index].type;
7620	7638	if (param_type->id == TypeTableEntryIdInvalid)
...	...	@@ -8090,7 +8108,9 @@ static TypeTableEntry ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionP
8090	8108	return resolved_type;
8091	8109	}
8092	8110
8093		static TypeTableEntry ir_analyze_var_ptr(IrAnalyze ira, IrInstruction instruction, VariableTableEntry var) {
	8111	static TypeTableEntry ir_analyze_var_ptr(IrAnalyze ira, IrInstruction *instruction,
	8112	VariableTableEntry *var, bool is_const_ptr)
	8113	{
8094	8114	assert(var->value.type);
8095	8115	if (var->value.type->id == TypeTableEntryIdInvalid)
8096	8116	return var->value.type;
...	...	@@ -8110,9 +8130,10 @@ static TypeTableEntry ir_analyze_var_ptr(IrAnalyze ira, IrInstruction *instruc
8110	8130
8111	8131	if (mem_slot && mem_slot->special != ConstValSpecialRuntime) {
8112	8132	ConstPtrSpecial ptr_special = is_comptime ? ConstPtrSpecialInline : ConstPtrSpecialNone;
8113		return ir_analyze_const_ptr(ira, instruction, mem_slot, var->value.type, false, ptr_special, var->src_is_const);
	8133	bool is_const = (var->value.type->id == TypeTableEntryIdMetaType) ? is_const_ptr : var->src_is_const;
	8134	return ir_analyze_const_ptr(ira, instruction, mem_slot, var->value.type, false, ptr_special, is_const);
8114	8135	} else {
8115		ir_build_var_ptr_from(&ira->new_irb, instruction, var);
	8136	ir_build_var_ptr_from(&ira->new_irb, instruction, var, false);
8116	8137	type_ensure_zero_bits_known(ira->codegen, var->value.type);
8117	8138	return get_pointer_to_type(ira->codegen, var->value.type, var->src_is_const);
8118	8139	}
...	...	@@ -8120,7 +8141,7 @@ static TypeTableEntry ir_analyze_var_ptr(IrAnalyze ira, IrInstruction *instruc
8120	8141
8121	8142	static TypeTableEntry ir_analyze_instruction_var_ptr(IrAnalyze ira, IrInstructionVarPtr *var_ptr_instruction) {
8122	8143	VariableTableEntry *var = var_ptr_instruction->var;
8123		return ir_analyze_var_ptr(ira, &var_ptr_instruction->base, var);
	8144	return ir_analyze_var_ptr(ira, &var_ptr_instruction->base, var, var_ptr_instruction->is_const);
8124	8145	}
8125	8146
8126	8147	static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionElemPtr *elem_ptr_instruction) {
...	...	@@ -8313,7 +8334,7 @@ static TypeTableEntry ir_analyze_decl_ref(IrAnalyze ira, IrInstruction *source
8313	8334	{
8314	8335	TldVar tld_var = (TldVar )tld;
8315	8336	VariableTableEntry *var = tld_var->var;
8316		return ir_analyze_var_ptr(ira, source_instruction, var);
	8337	return ir_analyze_var_ptr(ira, source_instruction, var, false);
8317	8338	}
8318	8339	case TldIdFn:
8319	8340	{
...	...	@@ -8549,6 +8570,12 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
8549	8570	if (value->value.type->id == TypeTableEntryIdInvalid)
8550	8571	return value->value.type;
8551	8572
	8573	assert(ptr->value.type->id == TypeTableEntryIdPointer);
	8574	if (ptr->value.type->data.pointer.is_const && !store_ptr_instruction->base.is_gen) {
	8575	ir_add_error(ira, &store_ptr_instruction->base, buf_sprintf("cannot assign to constant"));
	8576	return ira->codegen->builtin_types.entry_invalid;
	8577	}
	8578
8552	8579	TypeTableEntry *child_type = ptr->value.type->data.pointer.child_type;
8553	8580	IrInstruction *casted_value = ir_implicit_cast(ira, value, child_type);
8554	8581	if (casted_value == ira->codegen->invalid_instruction)
...	...	@@ -8580,7 +8607,7 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
8580	8607	IrInstructionVarPtr var_ptr_inst = (IrInstructionVarPtr )ptr;
8581	8608	VariableTableEntry *var = var_ptr_inst->var;
8582	8609	new_ptr_inst = ir_build_var_ptr(&ira->new_irb, store_ptr_instruction->base.scope,
8583		store_ptr_instruction->base.source_node, var);
	8610	store_ptr_instruction->base.source_node, var, false);
8584	8611	assert(var->mem_slot_index != SIZE_MAX);
8585	8612	ConstExprValue *mem_slot = &ira->exec_context.mem_slot_list[var->mem_slot_index];
8586	8613	mem_slot->special = ConstValSpecialRuntime;

std/cstr.zig+2-2

...	...	@@ -39,7 +39,7 @@ pub const CBuf = struct {
39	39
40	40	/// Must deinitialize with deinit.
41	41	pub fn initEmpty(allocator: &Allocator) -> %CBuf {
42		const self = CBuf {
	42	var self = CBuf {
43	43	.list = List(u8).init(allocator),
44	44	};
45	45	%return self.resize(0);
...	...	@@ -48,7 +48,7 @@ pub const CBuf = struct {
48	48
49	49	/// Must deinitialize with deinit.
50	50	pub fn initFromMem(allocator: &Allocator, m: []const u8) -> %CBuf {
51		const self = CBuf {
	51	var self = CBuf {
52	52	.list = List(u8).init(allocator),
53	53	};
54	54	%return self.resize(m.len);

std/list.zig+1-1

...	...	@@ -23,7 +23,7 @@ pub fn List(inline T: type) -> type{
23	23	l.allocator.free(T, l.items);
24	24	}
25	25
26		pub fn toSlice(l: &Self) -> []T {
	26	pub fn toSlice(l: &const Self) -> []const T {
27	27	return l.items[0...l.len];
28	28	}
29	29

test/cases/enum_with_members.zig+1-1

...	...	@@ -6,7 +6,7 @@ const ET = enum {
6	6	SINT: i32,
7	7	UINT: u32,
8	8
9		pub fn print(a: &ET, buf: []u8) -> %usize {
	9	pub fn print(a: &const ET, buf: []u8) -> %usize {
10	10	return switch (*a) {
11	11	ET.SINT => \|x\| { io.bufPrintInt(i32, buf, x) },
12	12	ET.UINT => \|x\| { io.bufPrintInt(u32, buf, x) },

test/cases/misc.zig+7

...	...	@@ -490,3 +490,10 @@ const test_pointer_to_void_return_type_x = void{};
490	490	fn testPointerToVoidReturnType2() -> &const void {
491	491	return &test_pointer_to_void_return_type_x;
492	492	}
	493
	494
	495	fn nonConstPtrToAliasedType() {
	496	@setFnTest(this);
	497	const int = i32;
	498	assert(?&int == ?&i32);
	499	}

test/cases/struct.zig+2-2

...	...	@@ -155,7 +155,7 @@ fn memberFunctions() {
155	155	}
156	156	const MemberFnRand = struct {
157	157	seed: u32,
158		pub fn getSeed(r: MemberFnRand) -> u32 {
	158	pub fn getSeed(r: &const MemberFnRand) -> u32 {
159	159	r.seed
160	160	}
161	161	};
...	...	@@ -184,7 +184,7 @@ fn emptyStructMethodCall() {
184	184	assert(es.method() == 1234);
185	185	}
186	186	const EmptyStruct = struct {
187		fn method(es: EmptyStruct) -> i32 {
	187	fn method(es: &const EmptyStruct) -> i32 {
188	188	1234
189	189	}
190	190	};

test/run_tests.cpp+5-5

...	...	@@ -548,7 +548,7 @@ const B = struct {
548	548	const C = struct {
549	549	x: i32,
550	550
551		fn d(c: C) {
	551	fn d(c: &const C) {
552	552	%%io.stdout.printf("OK\n");
553	553	}
554	554	};
...	...	@@ -577,13 +577,13 @@ const io = @import("std").io;
577	577	const Foo = struct {
578	578	field1: Bar,
579	579
580		fn method(a: &Foo) -> bool { true }
	580	fn method(a: &const Foo) -> bool { true }
581	581	};
582	582
583	583	const Bar = struct {
584	584	field2: i32,
585	585
586		fn method(b: &Bar) -> bool { true }
	586	fn method(b: &const Bar) -> bool { true }
587	587	};
588	588
589	589	pub fn main(args: [][]u8) -> %void {
...	...	@@ -787,14 +787,14 @@ fn f(a : unreachable) {}
787	787	fn f() {
788	788	3 = 3;
789	789	}
790		)SOURCE", 1, ".tmp_source.zig:3:5: error: invalid assignment target");
	790	)SOURCE", 1, ".tmp_source.zig:3:7: error: cannot assign to constant");
791	791
792	792	add_compile_fail_case("assign to constant variable", R"SOURCE(
793	793	fn f() {
794	794	const a = 3;
795	795	a = 4;
796	796	}
797		)SOURCE", 1, ".tmp_source.zig:4:5: error: cannot assign to constant");
	797	)SOURCE", 1, ".tmp_source.zig:4:7: error: cannot assign to constant");
798	798
799	799	add_compile_fail_case("use of undeclared identifier", R"SOURCE(
800	800	fn f() {