Commit 01c722c21cd4f0216a722fa698d704e23707a5ba | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-03-05 17:19:01-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-03-05 17:19:01-05:00
log	01c722c21cd4f0216a722fa698d704e23707a5ba
tree	32e0b49d824a1c99ef5d1911709e40ad669e42e0
parent	f5954dad8356c05c294630f19609c343d65ea544
signature	Commit is signed but in an unrecognized format.

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

This reverts commit debcc79d56a40f77b92e243b4e344fc9385bd405.

This caused a regression when building self-hosted

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

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

src/ir.cpp+9-24

 @@ -18477,15 +18477,6 @@ 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;
 @@ -18502,6 +18493,15 @@ 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,16 +18532,6 @@ 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;
 @@ -22967,9 +22957,6 @@ 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;
 @@ -22985,8 +22972,6 @@ 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,42 +54,3 @@ test "tuple concatenation" {	...	@@ -54,42 +54,3 @@ 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	}