Commit debcc79d56a40f77b92e243b4e344fc9385bd405 | zig

author	Alexandros Naskos <alex_naskos@hotmail.com> 2020-03-05 19:23:06+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-03-05 15:48:03-05:00
log	debcc79d56a40f77b92e243b4e344fc9385bd405
tree	3ad6df0c9b40bd9a1142d8774595467ba2dfe045
parent	c92957da0ed6f74e328fd0414c56f885cdcff30b

Allow constant struct val to reallocate its fields when resolving an inferred struct field with a comptime value.

2 files changed, 63 insertions(+), 9 deletions(-)

src
- ir.cpp
test
- stage1
  - behavior
    tuple.zig

src/ir.cpp+24-9

 @@ -18477,6 +18477,15 @@ static IrInstGen *ir_resolve_result(IrAnalyze *ira, IrInst *suspend_source_instr
         IrInstGen *casted_ptr;
         if (isf->already_resolved) {
             field = find_struct_type_field(isf->inferred_struct_type, isf->field_name);
+            // If the value originates from another node than the original value's we overwrite the inferred struct's
+            // type so that the new result can be written successfully.
+            // The duplicate field will be detected and reported in 'ir_analyze_container_init_fields'
+            AstNode *decl_node = value ? value->base.source_node : suspend_source_instr->source_node;
+            if (decl_node != field->decl_node) {
+                field->type_entry = value_type;
+                field->type_val = create_const_type(ira->codegen, field->type_entry);
+            }
             casted_ptr = result_loc;
         } else {
             isf->already_resolved = true;
 @@ -18493,15 +18502,6 @@ static IrInstGen *ir_resolve_result(IrAnalyze *ira, IrInst *suspend_source_instr
             field->type_val = create_const_type(ira->codegen, field->type_entry);
             field->src_index = old_field_count;
             field->decl_node = value ? value->base.source_node : suspend_source_instr->source_node;
-            if (value && instr_is_comptime(value)) {
-                ZigValue *val = ir_resolve_const(ira, value, UndefOk);
-                if (!val)
-                    return ira->codegen->invalid_inst_gen;
-                field->is_comptime = true;
-                field->init_val = ira->codegen->pass1_arena->create<ZigValue>();
-                copy_const_val(ira->codegen, field->init_val, val);
-                return result_loc;
-            }
             ZigType *struct_ptr_type = get_pointer_to_type(ira->codegen, isf->inferred_struct_type, false);
             if (instr_is_comptime(result_loc)) {
 @@ -18532,6 +18532,16 @@ static IrInstGen *ir_resolve_result(IrAnalyze *ira, IrInst *suspend_source_instr
             }
         }
+        if (value && instr_is_comptime(value)) {
+            ZigValue *val = ir_resolve_const(ira, value, UndefOk);
+            if (!val)
+                return ira->codegen->invalid_inst_gen;
+            field->is_comptime = true;
+            field->init_val = ira->codegen->pass1_arena->create<ZigValue>();
+            copy_const_val(ira->codegen, field->init_val, val);
+            return result_loc;
+        }
         result_loc = ir_analyze_struct_field_ptr(ira, suspend_source_instr, field, casted_ptr,
                 isf->inferred_struct_type, true);
         result_loc_pass1->resolved_loc = result_loc;
 @@ -22957,6 +22967,9 @@ static IrInstGen *ir_analyze_container_init_fields(IrAnalyze *ira, IrInst *sourc
             first_non_const_instruction = result_loc;
         }
     }
+    heap::c_allocator.deallocate(field_assign_nodes, actual_field_count);
     if (any_missing)
         return ira->codegen->invalid_inst_gen;
 @@ -22972,6 +22985,8 @@ static IrInstGen *ir_analyze_container_init_fields(IrAnalyze *ira, IrInst *sourc
         }
     }
+    const_ptrs.deinit();
     IrInstGen *result = ir_get_deref(ira, source_instr, result_loc, nullptr);
     if (is_comptime && !instr_is_comptime(result)) {

test/stage1/behavior/tuple.zig+39

...	@@ -54,3 +54,42 @@ test "tuple concatenation" {	...	@@ -54,3 +54,42 @@ test "tuple concatenation" {
54	T.doTheTest();	54	T.doTheTest();
55	comptime T.doTheTest();	55	comptime T.doTheTest();
56	}	56	}
		57
		58	test "tuple initialization with structure initializer and constant expression" {
		59	const TestStruct = struct {
		60	state: u8,
		61	};
		62
		63	const S = struct {
		64	fn doTheTest() void {
		65	const tuple_with_struct = .{ TestStruct{ .state = 42 }, 0 };
		66	expect(tuple_with_struct.len == 2);
		67	expect(tuple_with_struct[0].state == 42);
		68	expect(tuple_with_struct[1] == 0);
		69	}
		70	};
		71	S.doTheTest();
		72	comptime S.doTheTest();
		73	}
		74
		75	test "passing tuples as comptime generic parameters" {
		76	const S = struct {
		77	fn expect_len(comptime pack: var, comptime len: usize) void {
		78	expect(pack.len == len);
		79	}
		80
		81	fn expect_first_element(comptime pack: var, comptime elem: var) void {
		82	expect(pack[0] == elem);
		83	}
		84
		85	fn doTheTest() void {
		86	expect_len(.{}, 0);
		87	expect_len(.{ 0 }, 1);
		88	expect_first_element(.{ 0 }, 0);
		89	expect_len(.{ u8, 1, "literal" }, 3);
		90	expect_first_element(.{ u8, 1, "literal" }, u8);
		91	}
		92	};
		93	S.doTheTest();
		94	comptime S.doTheTest();
		95	}