Commit 2045b4d93240cd95eee7143f2cfc360eb63c5802 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-09-05 14:50:27-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-09-05 14:56:52-04:00
log	2045b4d93240cd95eee7143f2cfc360eb63c5802
tree	5ae5a1a453ecb8a82535b1be89822029606a9283
parent	8f0df86937e140c11a1efc9f94c8ac0bd1b02e2c
signature	Commit is signed but in an unrecognized format.

prefer result type casting to peer type resolution

See #2749

4 files changed, 96 insertions(+), 15 deletions(-)

src
- all_types.hpp
- ir.cpp
test
- stage1
  - behavior
    if.zig
    struct.zig

src/all_types.hpp+4

...	@@ -47,6 +47,7 @@ struct ResultLoc;	...	@@ -47,6 +47,7 @@ struct ResultLoc;
47	struct ResultLocPeer;	47	struct ResultLocPeer;
48	struct ResultLocPeerParent;	48	struct ResultLocPeerParent;
49	struct ResultLocBitCast;	49	struct ResultLocBitCast;
		50	struct ResultLocReturn;
50		51
51	enum PtrLen {	52	enum PtrLen {
52	PtrLenUnknown,	53	PtrLenUnknown,
...	@@ -3584,6 +3585,7 @@ struct IrInstructionAddImplicitReturnType {	...	@@ -3584,6 +3585,7 @@ struct IrInstructionAddImplicitReturnType {
3584	IrInstruction base;	3585	IrInstruction base;
3585		3586
3586	IrInstruction *value;	3587	IrInstruction *value;
		3588	ResultLocReturn *result_loc_ret;
3587	};	3589	};
3588		3590
3589	// For float ops which take a single argument	3591	// For float ops which take a single argument
...	@@ -3810,6 +3812,8 @@ struct ResultLocVar {	...	@@ -3810,6 +3812,8 @@ struct ResultLocVar {
3810		3812
3811	struct ResultLocReturn {	3813	struct ResultLocReturn {
3812	ResultLoc base;	3814	ResultLoc base;
		3815
		3816	bool implicit_return_type_done;
3813	};	3817	};
3814		3818
3815	struct IrSuspendPosition {	3819	struct IrSuspendPosition {

src/ir.cpp+62-15

 @@ -197,6 +197,7 @@ static IrInstruction *ir_analyze_store_ptr(IrAnalyze *ira, IrInstruction *source
 static IrInstruction *ir_gen_union_init_expr(IrBuilder *irb, Scope *scope, AstNode *source_node,
     IrInstruction *union_type, IrInstruction *field_name, AstNode *expr_node,
     LVal lval, ResultLoc *parent_result_loc);
+static void ir_reset_result(ResultLoc *result_loc);
 static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *const_val) {
     assert(get_src_ptr_type(const_val->type) != nullptr);
 @@ -3085,10 +3086,11 @@ static IrInstruction *ir_build_save_err_ret_addr(IrBuilder *irb, Scope *scope, A
 }
 static IrInstruction *ir_build_add_implicit_return_type(IrBuilder *irb, Scope *scope, AstNode *source_node,
-        IrInstruction *value)
+        IrInstruction *value, ResultLocReturn *result_loc_ret)
 {
     IrInstructionAddImplicitReturnType *instruction = ir_build_instruction<IrInstructionAddImplicitReturnType>(irb, scope, source_node);
     instruction->value = value;
+    instruction->result_loc_ret = result_loc_ret;
     ir_ref_instruction(value, irb->current_basic_block);
 @@ -3505,7 +3507,7 @@ static IrInstruction *ir_gen_return(IrBuilder *irb, Scope *scope, AstNode *node,
                     return_value = ir_build_const_void(irb, scope, node);
                 }
-                ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, node, return_value));
+                ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, node, return_value, result_loc_ret));
                 size_t defer_counts[2];
                 ir_count_defers(irb, scope, outer_scope, defer_counts);
 @@ -3580,7 +3582,7 @@ static IrInstruction *ir_gen_return(IrBuilder *irb, Scope *scope, AstNode *node,
                 ir_set_cursor_at_end_and_append_block(irb, return_block);
                 IrInstruction *err_val_ptr = ir_build_unwrap_err_code(irb, scope, node, err_union_ptr);
                 IrInstruction *err_val = ir_build_load_ptr(irb, scope, node, err_val_ptr);
-                ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, node, err_val));
+                ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, node, err_val, nullptr));
                 IrInstructionSpillBegin *spill_begin = ir_build_spill_begin(irb, scope, node, err_val,
                         SpillIdRetErrCode);
                 ResultLocReturn *result_loc_ret = allocate<ResultLocReturn>(1);
 @@ -3690,6 +3692,7 @@ static ResultLocPeer *create_peer_result(ResultLocPeerParent *peer_parent) {
     result->base.id = ResultLocIdPeer;
     result->base.source_instruction = peer_parent->base.source_instruction;
     result->parent = peer_parent;
+    result->base.allow_write_through_const = peer_parent->parent->allow_write_through_const;
     return result;
 }
 @@ -3812,7 +3815,7 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode
     // no need for save_err_ret_addr because this cannot return error
     // only generate unconditional defers
-    ir_mark_gen(ir_build_add_implicit_return_type(irb, child_scope, block_node, result));
+    ir_mark_gen(ir_build_add_implicit_return_type(irb, child_scope, block_node, result, nullptr));
     ir_gen_defers_for_block(irb, child_scope, outer_block_scope, false);
     return ir_mark_gen(ir_build_return(irb, child_scope, result->source_node, result));
 }
 @@ -8207,7 +8210,7 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutable *ir_exec
     }
     if (!instr_is_unreachable(result)) {
-        ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, result->source_node, result));
+        ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, result->source_node, result, nullptr));
         // no need for save_err_ret_addr because this cannot return error
         ir_mark_gen(ir_build_return(irb, scope, result->source_node, result));
     }
 @@ -12939,7 +12942,9 @@ static IrInstruction *ir_analyze_instruction_add_implicit_return_type(IrAnalyze
     if (type_is_invalid(value->value.type))
         return ir_unreach_error(ira);
-    ira->src_implicit_return_type_list.append(value);
+    if (instruction->result_loc_ret == nullptr || !instruction->result_loc_ret->implicit_return_type_done) {
+        ira->src_implicit_return_type_list.append(value);
+    }
     return ir_const_void(ira, &instruction->base);
 }
 @@ -14976,6 +14981,24 @@ static void set_up_result_loc_for_inferred_comptime(IrInstruction *ptr) {
     ptr->value.data.x_ptr.data.ref.pointee = undef_child;
 }
+static bool ir_result_has_type(ResultLoc *result_loc) {
+    switch (result_loc->id) {
+        case ResultLocIdInvalid:
+        case ResultLocIdPeerParent:
+            zig_unreachable();
+        case ResultLocIdNone:
+        case ResultLocIdPeer:
+            return false;
+        case ResultLocIdReturn:
+        case ResultLocIdInstruction:
+        case ResultLocIdBitCast:
+            return true;
+        case ResultLocIdVar:
+            return reinterpret_cast<ResultLocVar *>(result_loc)->var->decl_node->data.variable_declaration.type != nullptr;
+    }
+    zig_unreachable();
+}
 // when calling this function, at the callsite must check for result type noreturn and propagate it up
 static IrInstruction *ir_resolve_result_raw(IrAnalyze *ira, IrInstruction *suspend_source_instr,
         ResultLoc *result_loc, ZigType *value_type, IrInstruction *value, bool force_runtime, bool non_null_comptime)
 @@ -15105,14 +15128,23 @@ static IrInstruction *ir_resolve_result_raw(IrAnalyze *ira, IrInstruction *suspe
             bool is_comptime;
             if (!ir_resolve_comptime(ira, peer_parent->is_comptime->child, &is_comptime))
                 return ira->codegen->invalid_instruction;
-            peer_parent->skipped = is_comptime;
+            if (is_comptime) {
-            if (peer_parent->skipped) {
+                peer_parent->skipped = true;
                 if (non_null_comptime) {
                     return ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
                             value_type, value, force_runtime, non_null_comptime, true);
                 }
                 return nullptr;
             }
+            if (ir_result_has_type(peer_parent->parent)) {
+                if (peer_parent->parent->id == ResultLocIdReturn && value != nullptr) {
+                    reinterpret_cast<ResultLocReturn *>(peer_parent->parent)->implicit_return_type_done = true;
+                    ira->src_implicit_return_type_list.append(value);
+                }
+                peer_parent->skipped = true;
+                return ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
+                        value_type, value, force_runtime, true, true);
+            }
             if (peer_parent->resolved_type == nullptr) {
                 if (peer_parent->end_bb->suspend_instruction_ref == nullptr) {
 @@ -15322,9 +15354,11 @@ static void ir_reset_result(ResultLoc *result_loc) {
             alloca_src->base.child = nullptr;
             break;
         }
+        case ResultLocIdReturn:
+            reinterpret_cast<ResultLocReturn *>(result_loc)->implicit_return_type_done = false;
+            break;
         case ResultLocIdPeer:
         case ResultLocIdNone:
-        case ResultLocIdReturn:
         case ResultLocIdInstruction:
         case ResultLocIdBitCast:
             break;
 @@ -16880,10 +16914,21 @@ static IrInstruction *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPh
         return new_incoming_values.at(0);
     }
-    ZigType *resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
+    ZigType *resolved_type;
-            new_incoming_values.items, new_incoming_values.length);
+    if (peer_parent != nullptr && ir_result_has_type(peer_parent->parent)) {
-    if (type_is_invalid(resolved_type))
+        if (peer_parent->parent->id == ResultLocIdReturn) {
-        return ira->codegen->invalid_instruction;
+            resolved_type = ira->explicit_return_type;
+        } else {
+            ZigType *resolved_loc_ptr_type = peer_parent->parent->resolved_loc->value.type;
+            ir_assert(resolved_loc_ptr_type->id == ZigTypeIdPointer, &phi_instruction->base);
+            resolved_type = resolved_loc_ptr_type->data.pointer.child_type;
+        }
+    } else {
+        resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
+                new_incoming_values.items, new_incoming_values.length);
+        if (type_is_invalid(resolved_type))
+            return ira->codegen->invalid_instruction;
+    }
     switch (type_has_one_possible_value(ira->codegen, resolved_type)) {
     case OnePossibleValueInvalid:
 @@ -25055,7 +25100,7 @@ static IrInstruction *ir_analyze_instruction_end_expr(IrAnalyze *ira, IrInstruct
         if (result_loc->value.type->id == ZigTypeIdUnreachable)
             return result_loc;
-        if (!was_written) {
+        if (!was_written || instruction->result_loc->id == ResultLocIdPeer) {
             IrInstruction *store_ptr = ir_analyze_store_ptr(ira, &instruction->base, result_loc, value,
                     instruction->result_loc->allow_write_through_const);
             if (type_is_invalid(store_ptr->value.type)) {
 @@ -25063,7 +25108,9 @@ static IrInstruction *ir_analyze_instruction_end_expr(IrAnalyze *ira, IrInstruct
             }
         }
-        if (result_loc->value.data.x_ptr.mut == ConstPtrMutInfer) {
+        if (result_loc->value.data.x_ptr.mut == ConstPtrMutInfer &&
+            instruction->result_loc->id != ResultLocIdPeer)
+        {
             if (instr_is_comptime(value)) {
                 result_loc->value.data.x_ptr.mut = ConstPtrMutComptimeConst;
             } else {

test/stage1/behavior/if.zig+12

...	@@ -74,3 +74,15 @@ test "const result loc, runtime if cond, else unreachable" {	...	@@ -74,3 +74,15 @@ test "const result loc, runtime if cond, else unreachable" {
74	const x = if (t) Num.Two else unreachable;	74	const x = if (t) Num.Two else unreachable;
75	if (x != .Two) @compileError("bad");	75	if (x != .Two) @compileError("bad");
76	}	76	}
		77
		78	test "if prongs cast to expected type instead of peer type resolution" {
		79	const S = struct {
		80	fn doTheTest(f: bool) void {
		81	var x: i32 = 0;
		82	x = if (f) 1 else 2;
		83	expect(x == 2);
		84	}
		85	};
		86	S.doTheTest(false);
		87	comptime S.doTheTest(false);
		88	}

test/stage1/behavior/struct.zig+18

...	@@ -640,3 +640,21 @@ test "zero-bit field in packed struct" {	...	@@ -640,3 +640,21 @@ test "zero-bit field in packed struct" {
640	};	640	};
641	var x: S = undefined;	641	var x: S = undefined;
642	}	642	}
		643
		644	test "struct field init with catch" {
		645	const S = struct {
		646	fn doTheTest() void {
		647	var x: anyerror!isize = 1;
		648	var req = Foo{
		649	.field = x catch undefined,
		650	};
		651	expect(req.field == 1);
		652	}
		653
		654	pub const Foo = extern struct {
		655	field: isize,
		656	};
		657	};
		658	S.doTheTest();
		659	comptime S.doTheTest();
		660	}