Commit 57b90d2d98154e382c58f1b385de2bcef132f7d9 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-08-17 17:22:20-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-08-17 17:22:20-04:00
log	57b90d2d98154e382c58f1b385de2bcef132f7d9
tree	f2f5e504f39ca670ff5860a56be7145c8db1c024
parent	66a490c27c01c958d8d20dbc289c6b2b934a724e
signature	Commit is signed but in an unrecognized format.

allow implicit cast of fn to async fn

it forces the fn to be async. closes #3079

2 files changed, 51 insertions(+), 5 deletions(-)

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

src/ir.cpp+24-5

 @@ -9485,10 +9485,6 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
             result.id = ConstCastResultIdFnAlign;
             return result;
         }
-        if (wanted_type->data.fn.fn_type_id.cc != actual_type->data.fn.fn_type_id.cc) {
-            result.id = ConstCastResultIdFnCC;
-            return result;
-        }
         if (wanted_type->data.fn.fn_type_id.is_var_args != actual_type->data.fn.fn_type_id.is_var_args) {
             result.id = ConstCastResultIdFnVarArgs;
             return result;
 @@ -9546,6 +9542,11 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
                 return result;
             }
         }
+        if (wanted_type->data.fn.fn_type_id.cc != actual_type->data.fn.fn_type_id.cc) {
+            // ConstCastResultIdFnCC is guaranteed to be the last one reported, meaning everything else is ok.
+            result.id = ConstCastResultIdFnCC;
+            return result;
+        }
         return result;
     }
 @@ -11780,8 +11781,11 @@ static void report_recursive_error(IrAnalyze *ira, AstNode *source_node, ConstCa
             add_error_note(ira->codegen, parent_msg, source_node,
                     buf_sprintf("only one of the functions is generic"));
             break;
+        case ConstCastResultIdFnCC:
+            add_error_note(ira->codegen, parent_msg, source_node,
+                    buf_sprintf("calling convention mismatch"));
+            break;
         case ConstCastResultIdFnAlign: // TODO
-        case ConstCastResultIdFnCC: // TODO
         case ConstCastResultIdFnVarArgs: // TODO
         case ConstCastResultIdFnReturnType: // TODO
         case ConstCastResultIdFnArgCount: // TODO
 @@ -11891,6 +11895,21 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop);
     }
+    if (const_cast_result.id == ConstCastResultIdFnCC) {
+        ir_assert(value->value.type->id == ZigTypeIdFn, source_instr);
+        // ConstCastResultIdFnCC is guaranteed to be the last one reported, meaning everything else is ok.
+        if (wanted_type->data.fn.fn_type_id.cc == CallingConventionAsync &&
+            actual_type->data.fn.fn_type_id.cc == CallingConventionUnspecified)
+        {
+            ir_assert(value->value.data.x_ptr.special == ConstPtrSpecialFunction, source_instr);
+            ZigFn *fn = value->value.data.x_ptr.data.fn.fn_entry;
+            if (fn->inferred_async_node == nullptr) {
+                fn->inferred_async_node = source_instr->source_node;
+            }
+            return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop);
+        }
+    }
     // cast from T to ?T
     // note that the *T to ?*T case is handled via the "ConstCastOnly" mechanism
     if (wanted_type->id == ZigTypeIdOptional) {

test/stage1/behavior/async_fn.zig+27

...	@@ -817,3 +817,30 @@ test "struct parameter to async function is copied to the frame" {	...	@@ -817,3 +817,30 @@ test "struct parameter to async function is copied to the frame" {
817	};	817	};
818	S.doTheTest();	818	S.doTheTest();
819	}	819	}
		820
		821	test "cast fn to async fn when it is inferred to be async" {
		822	const S = struct {
		823	var frame: anyframe = undefined;
		824	var ok = false;
		825
		826	fn doTheTest() void {
		827	var ptr: async fn () i32 = undefined;
		828	ptr = func;
		829	var buf: [100]u8 align(16) = undefined;
		830	var result: i32 = undefined;
		831	_ = await @asyncCall(&buf, &result, ptr);
		832	expect(result == 1234);
		833	ok = true;
		834	}
		835
		836	fn func() i32 {
		837	suspend {
		838	frame = @frame();
		839	}
		840	return 1234;
		841	}
		842	};
		843	_ = async S.doTheTest();
		844	resume S.frame;
		845	expect(S.ok);
		846	}