HaxeFoundation
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎src-json/meta.json‎
Lines changed: 12 additions & 0 deletions b/‎src-json/meta.json‎
Lines changed: 12 additions & 0 deletions
diff --git a/‎src/codegen/fixOverrides.ml‎
Lines changed: 10 additions & 2 deletions b/‎src/codegen/fixOverrides.ml‎
Lines changed: 10 additions & 2 deletions
diff --git a/‎src/context/common.ml‎
Lines changed: 20 additions & 0 deletions b/‎src/context/common.ml‎
Lines changed: 20 additions & 0 deletions
diff --git a/‎src/context/typecore.ml‎
Lines changed: 6 additions & 1 deletion b/‎src/context/typecore.ml‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎src/core/tFunctions.ml‎
Lines changed: 15 additions & 0 deletions b/‎src/core/tFunctions.ml‎
Lines changed: 15 additions & 0 deletions
diff --git a/‎src/core/tType.ml‎
Lines changed: 11 additions & 1 deletion b/‎src/core/tType.ml‎
Lines changed: 11 additions & 1 deletion
diff --git a/‎src/core/texpr.ml‎
Lines changed: 18 additions & 0 deletions b/‎src/core/texpr.ml‎
Lines changed: 18 additions & 0 deletions
diff --git a/‎src/coro/contTypes.ml‎
Lines changed: 37 additions & 0 deletions b/‎src/coro/contTypes.ml‎
Lines changed: 37 additions & 0 deletions
@@ -133,3 +133,4 @@ lib.sexp
 src/compiler/version.ml
 tests/party
 tests/misc/projects/Issue10863/error.log
+tests/misc/coroutines/dump
@@ -142,6 +142,18 @@
 		"targets": ["TAbstract"],
 		"links": ["https://haxe.org/manual/types-abstract-core-type.html"]
 	},
+	{
+		"name": "Coroutine",
+		"metadata": ":coroutine",
+		"doc": "Transform function into a coroutine",
+		"targets": ["TClassField"]
+	},
+	{
+		"name": "CoroutineTransformed",
+		"metadata": ":coroutine.transformed",
+		"doc": "Marks a field as being a coroutine that has already been transformed",
+		"targets": ["TClassField"]
+	},
 	{
 		"name": "CppFileCode",
 		"metadata": ":cppFileCode",
 
@@ -41,7 +41,11 @@ let fix_override com c f fd =
 	let f2 = (try Some (find_field com c f) with Not_found -> None) in
 	match f2,fd with
 		| Some (f2), Some(fd) ->
-			let targs, tret = (match follow f2.cf_type with TFun (args,ret) -> args, ret | _ -> die "" __LOC__) in
+			let targs, tret = 
+				match follow_with_coro f2.cf_type with
+				| Coro (args,ret) -> Common.expand_coro_type com.basic args ret
+				| NotCoro (TFun(args, ret)) -> args, ret
+				| _ -> die "" __LOC__ in
 			let changed_args = ref [] in
 			let prefix = "_tmp_" in
 			let nargs = List.map2 (fun ((v,ct) as cur) (_,_,t2) ->
@@ -86,7 +90,11 @@ let fix_override com c f fd =
 			f.cf_expr <- Some { fde with eexpr = TFunction fd2 };
 			f.cf_type <- TFun(targs,tret);
 		| Some(f2), None when (has_class_flag c CInterface) ->
-			let targs, tret = (match follow f2.cf_type with TFun (args,ret) -> args, ret | _ -> die "" __LOC__) in
+			let targs, tret = 
+				match follow_with_coro f2.cf_type with
+				| Coro (args,ret) -> Common.expand_coro_type com.basic args ret
+				| NotCoro (TFun(args, ret)) -> args, ret
+				| _ -> die "" __LOC__ in
 			f.cf_type <- TFun(targs,tret)
 		| _ ->
 			()
 
@@ -795,9 +795,16 @@ let create timer_ctx compilation_step cs version args display_mode =
 			tfloat = mk_mono();
 			tbool = mk_mono();
 			tstring = mk_mono();
+			texception = mk_mono();
 			tnull = (fun _ -> die "Could use locate abstract Null<T> (was it redefined?)" __LOC__);
 			tarray = (fun _ -> die "Could not locate class Array<T> (was it redefined?)" __LOC__);
 			titerator = (fun _ -> die "Could not locate typedef Iterator<T> (was it redefined?)" __LOC__);
+			tunit = mk_mono();
+			tcoro = {
+				tcoro = lazy (fun _ -> die "Could not locate abstract Coroutine<T> (was it redefined?)" __LOC__);
+				continuation = lazy (mk_mono());
+				suspension_result_class = lazy null_class;
+			}
 		};
 		std = null_class;
 		file_keys = new file_keys;
@@ -929,6 +936,13 @@ let clone com is_macro_context =
 			tnull = (fun _ -> die "Could use locate abstract Null<T> (was it redefined?)" __LOC__);
 			tarray = (fun _ -> die "Could not locate class Array<T> (was it redefined?)" __LOC__);
 			titerator = (fun _ -> die "Could not locate typedef Iterator<T> (was it redefined?)" __LOC__);
+			texception = mk_mono();
+			tunit = mk_mono();
+			tcoro = {
+				tcoro = lazy (fun _ -> die "Could not locate abstract Coroutine<T> (was it redefined?)" __LOC__);
+				continuation = lazy (mk_mono());
+				suspension_result_class = lazy null_class;
+			};
 		};
 		local_wrapper = LocalWrapper.null_wrapper;
 		std = null_class;
@@ -1140,6 +1154,12 @@ let get_entry_point com =
 		(snd path, c, e)
 	) com.main.main_path
 
+let expand_coro_type basic args ret =
+	let args = ("_hx_continuation",false,Lazy.force basic.tcoro.continuation) :: args in
+	let ret = if ExtType.is_void (follow ret) then basic.tunit else ret in
+	let c = Lazy.force basic.tcoro.suspension_result_class in
+	(args,TInst(c,[ret]))
+
 let make_unforced_lazy t_proc f where =
 	let r = ref (lazy_available t_dynamic) in
 	r := lazy_wait (fun() ->
 
@@ -92,6 +92,7 @@ type typer_pass_tasks = {
 
 type function_mode =
 	| FunFunction
+	| FunCoroutine
 	| FunNotFunction
 
 type typer_globals = {
@@ -113,6 +114,7 @@ type typer_globals = {
 	mutable delayed_display : DisplayTypes.display_exception_kind option;
 	root_typer : typer;
 	(* api *)
+	mutable continuation_api : ContTypes.continuation_api option;
 	do_macro : typer -> macro_mode -> path -> string -> expr list -> pos -> macro_result;
 	do_load_macro : typer -> bool -> path -> string -> pos -> ((string * bool * t) list * t * tclass * Type.tclass_field);
 	do_load_module : ?origin:module_dep_origin -> typer -> path -> pos -> module_def;
@@ -288,8 +290,11 @@ module TyperManager = struct
 		let e = create_ctx_e ctx.e.curfun FunNotFunction in
 		create ctx ctx.m ctx.c f e PTypeField ctx.type_params
 
+	let is_coroutine_context ctx =
+		ctx.e.function_mode = FunCoroutine
+
 	let is_function_context ctx = match ctx.e.function_mode with
-		| FunFunction ->
+		| FunFunction | FunCoroutine ->
 			true
 		| FunNotFunction ->
 			false
 
@@ -649,6 +649,21 @@ let rec follow_lazy_and_mono t = match t with
 	| _ ->
 		t
 
+type maybe_coro =
+	| Coro of tsignature
+	| NotCoro of t
+
+let follow_with_coro t = match follow t with
+	| TAbstract({a_path = (["haxe";"coro"],"Coroutine")},[t]) ->
+		begin match follow t with
+			| TFun(args,ret) ->
+				Coro (args,ret)
+			| t ->
+				NotCoro t
+		end
+	| t ->
+		NotCoro t
+
 let rec ambiguate_funs t =
 	match follow t with
 	| TFun _ -> TFun ([], t_dynamic)
 
@@ -482,6 +482,12 @@ and build_state =
 
 exception Type_exception of t
 
+type coro_types = {
+	mutable tcoro : ((string * bool * t) list -> t -> t) Lazy.t;
+	mutable continuation : t Lazy.t;
+	mutable suspension_result_class : tclass Lazy.t;
+}
+
 type basic_types = {
 	mutable tvoid : t;
 	mutable tany : t;
@@ -491,7 +497,10 @@ type basic_types = {
 	mutable tnull : t -> t;
 	mutable tstring : t;
 	mutable tarray : t -> t;
-	mutable titerator : t -> t
+	mutable texception : t;
+	mutable titerator : t -> t;
+	mutable tunit : t;
+	mutable tcoro : coro_types;
 }
 
 type class_field_scope =
@@ -549,6 +558,7 @@ type flag_tvar =
 	| VStatic
 	| VUsedByTyper (* Set if the typer looked up this variable *)
 	| VHxb (* Flag used by hxb *)
+	| VCoroCaptured
 
 let flag_tvar_names = [
 	"VCaptured";"VFinal";"VAnalyzed";"VAssigned";"VCaught";"VStatic";"VUsedByTyper"
 
@@ -639,6 +639,24 @@ let for_remap basic v etype e1 e2 p =
 		mk (TWhile((mk (TParenthesis ehasnext) ehasnext.etype ehasnext.epos),ebody,NormalWhile)) basic.tvoid e1.epos;
 	]) basic.tvoid p
 
+let not_while_true_to_while_true basic e1 e2 flag t p =
+	let e_break = mk TBreak t_dynamic p in
+	let e_not = mk (TUnop(Not,Prefix,Builder.mk_parent e1)) e1.etype e1.epos in
+	let e_if eo = mk (TIf(e_not,e_break,eo)) basic.tvoid p in
+	let rec map_continue e = match e.eexpr with
+		| TContinue ->
+			duplicate_tvars e_identity (e_if (Some e))
+		| TWhile _ ->
+			e
+		| _ ->
+			map_expr map_continue e
+	in
+	let e2 = if flag = NormalWhile then e2 else map_continue e2 in
+	let e_if = e_if None in
+	let e_block = if flag = NormalWhile then concat e_if e2 else concat e2 e_if in
+	let e_true = mk (TConst (TBool true)) basic.tbool p in
+	mk (TWhile(e_true,e_block,NormalWhile)) t p
+
 (* -------------------------------------------------------------------------- *)
 (* BUILD META DATA OBJECT *)
 
 
@@ -0,0 +1,37 @@
+open Type
+
+type continuation_api = {
+	base_continuation_class : tclass;
+	immediate_suspension_result_class : tclass;
+	suspension_state : Type.t;
+	suspension_result : t -> t;
+	suspension_result_class : tclass;
+	continuation : Type.t;
+	state : tclass_field;
+	result : tclass_field;
+	error : tclass_field;
+	completion : tclass_field;
+	context : tclass_field;
+	goto_label : tclass_field;
+	recursing : tclass_field;
+	immediate_result : texpr -> texpr;
+	immediate_error : texpr -> Type.t -> texpr;
+}
+
+let create_continuation_api base_continuation_class immediate_suspension_result_class suspension_state suspension_result_class continuation immediate_result immediate_error state result error completion context goto_label recursing = {
+	base_continuation_class;
+	immediate_suspension_result_class;
+	suspension_state;
+	suspension_result = (fun t -> TInst(suspension_result_class,[t]));
+	suspension_result_class;
+	continuation;
+	immediate_result;
+	immediate_error;
+	state;
+	result;
+	error;
+	completion;
+	context;
+	goto_label;
+	recursing;
+}