Commit d291d3c8c00450e31b7cce15eae43db265361186 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-09-02 13:07:44-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-09-02 13:07:44-04:00
log	d291d3c8c00450e31b7cce15eae43db265361186
tree	d9d14cfba1083a7fbea4bfb204b1c44fb2629199
parent	0fe28855c5a32b16dc092ab1d70efde38ef89a7b
signature	Commit is signed but in an unrecognized format.

fix using @typeOf on a generic function call

2 files changed, 58 insertions(+), 25 deletions(-)

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

src/ir.cpp+33-25

 @@ -15648,6 +15648,31 @@ static IrInstruction *ir_analyze_store_ptr(IrAnalyze *ira, IrInstruction *source
     return &store_ptr->base;
 }
+static IrInstruction *analyze_casted_new_stack(IrAnalyze *ira, IrInstructionCallSrc *call_instruction,
+        ZigFn *fn_entry)
+{
+    if (call_instruction->new_stack == nullptr)
+        return nullptr;
+    IrInstruction *new_stack = call_instruction->new_stack->child;
+    if (type_is_invalid(new_stack->value.type))
+        return ira->codegen->invalid_instruction;
+    if (call_instruction->is_async_call_builtin &&
+        fn_entry != nullptr && new_stack->value.type->id == ZigTypeIdPointer &&
+        new_stack->value.type->data.pointer.child_type->id == ZigTypeIdFnFrame)
+    {
+        ZigType *needed_frame_type = get_pointer_to_type(ira->codegen,
+                get_fn_frame_type(ira->codegen, fn_entry), false);
+        return ir_implicit_cast(ira, new_stack, needed_frame_type);
+    } else {
+        ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
+                false, false, PtrLenUnknown, target_fn_align(ira->codegen->zig_target), 0, 0, false);
+        ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
+        return ir_implicit_cast(ira, new_stack, u8_slice);
+    }
+}
 static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *call_instruction,
     ZigFn *fn_entry, ZigType *fn_type, IrInstruction *fn_ref,
     IrInstruction *first_arg_ptr, bool comptime_fn_call, FnInline fn_inline)
 @@ -15826,31 +15851,6 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *c
         return ir_finish_anal(ira, new_instruction);
     }
-    IrInstruction *casted_new_stack = nullptr;
-    if (call_instruction->new_stack != nullptr) {
-        IrInstruction *new_stack = call_instruction->new_stack->child;
-        if (type_is_invalid(new_stack->value.type))
-            return ira->codegen->invalid_instruction;
-        if (call_instruction->is_async_call_builtin &&
-            fn_entry != nullptr && new_stack->value.type->id == ZigTypeIdPointer &&
-            new_stack->value.type->data.pointer.child_type->id == ZigTypeIdFnFrame)
-        {
-            ZigType *needed_frame_type = get_pointer_to_type(ira->codegen,
-                    get_fn_frame_type(ira->codegen, fn_entry), false);
-            casted_new_stack = ir_implicit_cast(ira, new_stack, needed_frame_type);
-            if (type_is_invalid(casted_new_stack->value.type))
-                return ira->codegen->invalid_instruction;
-        } else {
-            ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
-                    false, false, PtrLenUnknown, target_fn_align(ira->codegen->zig_target), 0, 0, false);
-            ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
-            casted_new_stack = ir_implicit_cast(ira, new_stack, u8_slice);
-            if (type_is_invalid(casted_new_stack->value.type))
-                return ira->codegen->invalid_instruction;
-        }
-    }
     if (fn_type->data.fn.is_generic) {
         if (!fn_entry) {
             ir_add_error(ira, call_instruction->fn_ref,
 @@ -16063,6 +16063,10 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *c
             parent_fn_entry->calls_or_awaits_errorable_fn = true;
         }
+        IrInstruction *casted_new_stack = analyze_casted_new_stack(ira, call_instruction, impl_fn);
+        if (casted_new_stack != nullptr && type_is_invalid(casted_new_stack->value.type))
+            return ira->codegen->invalid_instruction;
         size_t impl_param_count = impl_fn_type_id->param_count;
         if (call_instruction->is_async) {
             IrInstruction *result = ir_analyze_async_call(ira, call_instruction, impl_fn, impl_fn->type_entry,
 @@ -16211,6 +16215,10 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *c
         return ira->codegen->invalid_instruction;
     }
+    IrInstruction *casted_new_stack = analyze_casted_new_stack(ira, call_instruction, fn_entry);
+    if (casted_new_stack != nullptr && type_is_invalid(casted_new_stack->value.type))
+        return ira->codegen->invalid_instruction;
     if (call_instruction->is_async) {
         IrInstruction *result = ir_analyze_async_call(ira, call_instruction, fn_entry, fn_type, fn_ref,
                 casted_args, call_param_count, casted_new_stack);

test/stage1/behavior/async_fn.zig+25

...	@@ -1031,3 +1031,28 @@ test "@typeOf an async function call of generic fn with error union type" {	...	@@ -1031,3 +1031,28 @@ test "@typeOf an async function call of generic fn with error union type" {
1031	};	1031	};
1032	_ = async S.func(i32);	1032	_ = async S.func(i32);
1033	}	1033	}
		1034
		1035	test "using @typeOf on a generic function call" {
		1036	const S = struct {
		1037	var global_frame: anyframe = undefined;
		1038	var global_ok = false;
		1039
		1040	var buf: [100]u8 align(16) = undefined;
		1041
		1042	fn amain(x: var) void {
		1043	if (x == 0) {
		1044	global_ok = true;
		1045	return;
		1046	}
		1047	suspend {
		1048	global_frame = @frame();
		1049	}
		1050	const F = @typeOf(async amain(x - 1));
		1051	const frame = @intToPtr(*F, @ptrToInt(&buf));
		1052	return await @asyncCall(frame, {}, amain, x - 1);
		1053	}
		1054	};
		1055	_ = async S.amain(u32(1));
		1056	resume S.global_frame;
		1057	expect(S.global_ok);
		1058	}