Only allow Void in return types

src/typing/typeload.ml

@@ -416,34 +416,50 @@ and load_instance' ctx ptp get_params mode =
 	with Not_found ->
 		let mt = load_type_def ctx (if ptp.pos_path == null_pos then ptp.pos_full else ptp.pos_path) t in
 		let info = ctx.g.get_build_info ctx mt ptp.pos_full in
-		if info.build_path = ([],"Dynamic") then match t.tparams with
-			| [] -> t_dynamic
-			| [TPType t] -> TDynamic (Some (load_complex_type ctx true LoadNormal t))
-			| _ -> raise_typing_error "Too many parameters for Dynamic" ptp.pos_full
-		else if info.build_params = [] then begin match t.tparams with
-			| [] ->
-				info.build_apply []
-			|  tp :: _ ->
-				let pt = match tp with
-					| TPType(_,p) | TPExpr(_,p) -> p
-				in
-				display_error ctx.com ("Too many type parameters for " ^ s_type_path info.build_path) pt;
-				info.build_apply []
-		end else begin
-			(* TODO: this is currently duplicated, but it seems suspcious anyway... *)
-			let is_rest = info.build_kind = BuildGenericBuild && (match info.build_params with [{ttp_name="Rest"}] -> true | _ -> false) in
-			let tl = if t.tparams = [] && not is_rest then begin match get_params with
-				| ParamNormal ->
+		begin match info.build_path with
+		| ([],"Dynamic") ->
+			begin match t.tparams with
+				| [] -> t_dynamic
+				| [TPType t] -> TDynamic (Some (load_complex_type ctx true LoadNormal t))
+				| _ -> raise_typing_error "Too many parameters for Dynamic" ptp.pos_full
+			end
+		| ([],"Void") ->
+			begin match mode with
+				| LoadReturn | LoadAny ->
+					ctx.t.tvoid
+				| _ ->
+					(* VOIDTODO: I don't think we actually want this, but let's try to get green CI *)
+					if has_class_flag ctx.c.curclass CExtern then
+						ctx.t.tvoid
+					else
+						raise_typing_error "Cannot use Void here" ptp.pos_full
+			end
+		| _ ->
+			if info.build_params = [] then begin match t.tparams with
+				| [] ->
+					info.build_apply []
+				|  tp :: _ ->
+					let pt = match tp with
+						| TPType(_,p) | TPExpr(_,p) -> p
+					in
+					display_error ctx.com ("Too many type parameters for " ^ s_type_path info.build_path) pt;
+					info.build_apply []
+			end else begin
+				(* TODO: this is currently duplicated, but it seems suspcious anyway... *)
+				let is_rest = info.build_kind = BuildGenericBuild && (match info.build_params with [{ttp_name="Rest"}] -> true | _ -> false) in
+				let tl = if t.tparams = [] && not is_rest then begin match get_params with
+					| ParamNormal ->
+						load_params ctx info t.tparams ptp.pos_full
+					| ParamSpawnMonos ->
+						Monomorph.spawn_constrained_monos (fun t -> t) info.build_params
+					| ParamCustom f ->
+						f info None
+				end else
 					load_params ctx info t.tparams ptp.pos_full
-				| ParamSpawnMonos ->
-					Monomorph.spawn_constrained_monos (fun t -> t) info.build_params
-				| ParamCustom f ->
-					f info None
-			end else
-				load_params ctx info t.tparams ptp.pos_full
-			in
-			let t = info.build_apply tl in
-			maybe_build_instance ctx t get_params ptp.pos_full
+				in
+				let t = info.build_apply tl in
+				maybe_build_instance ctx t get_params ptp.pos_full
+			end
 		end
 
 and load_instance ctx ?(allow_display=false) ptp get_params mode =
@@ -629,7 +645,7 @@ and load_complex_type' ctx allow_display mode (t,p) =
 	| CTFunction (args,r) ->
 		match args with
 		| [CTPath { path = {tpackage = []; tparams = []; tname = "Void" }},_] ->
-			TFun ([],load_complex_type ctx allow_display  LoadReturn r)
+			TFun ([],load_complex_type ctx allow_display LoadReturn r)
 		| _ ->
 			TFun (List.map (fun t ->
 				let t, opt = (match fst t with CTOptional t | CTParent((CTOptional t,_)) -> t, true | _ -> t,false) in

std/haxe/NoValue.hx

@@ -0,0 +1,3 @@
+package haxe;
+
+enum NoValue {}

std/haxe/display/Diagnostic.hx

@@ -1,9 +1,9 @@
 // from vshaxe
 package haxe.display;
 
+import haxe.display.JsonModuleTypes;
 import haxe.display.Position.Location;
 import haxe.display.Position.Range;
-import haxe.display.JsonModuleTypes;
 
 enum abstract UnresolvedIdentifierSuggestion(Int) {
 	var UISImport;
@@ -53,13 +53,13 @@ typedef ReplacableCode = {
 }
 
 enum abstract DiagnosticKind<T>(Int) from Int to Int {
-	final DKUnusedImport:DiagnosticKind<Void>;
+	final DKUnusedImport:DiagnosticKind<haxe.NoValue>;
 	final DKUnresolvedIdentifier:DiagnosticKind<Array<{kind:UnresolvedIdentifierSuggestion, name:String}>>;
 	final DKCompilerError:DiagnosticKind<String>;
 	final ReplacableCode:DiagnosticKind<ReplacableCode>;
 	final DKParserError:DiagnosticKind<String>;
 	final DeprecationWarning:DiagnosticKind<String>;
-	final InactiveBlock:DiagnosticKind<Void>;
+	final InactiveBlock:DiagnosticKind<haxe.NoValue>;
 	final MissingFields:DiagnosticKind<MissingFieldDiagnostics>;
 }
 

tests/misc/compiler_loops/projects/Issue9428/TypedefAbstract.hx

@@ -10,6 +10,6 @@ typedef Rec2Struct<T> = {
 
 class TypedefAbstract {
 	static function main() {
-		var r:Rec2<Void> = (null:Rec1<Void>);
+		var r:Rec2<haxe.NoValue> = (null:Rec1<haxe.NoValue>);
 	}
 }

tests/misc/compiler_loops/projects/Issue9428/TypedefTypedef.hx

@@ -8,6 +8,6 @@ typedef Rec2<T> = {
 
 class TypedefTypedef {
 	static function main() {
-		var r:Rec1<Void> = (null:Rec2<Void>);
+		var r:Rec1<haxe.NoValue> = (null:Rec2<haxe.NoValue>);
 	}
 }

tests/misc/projects/Issue10959/TestClass.hx

@@ -1,5 +1,5 @@
 package;
 
 @:keep
-class TestClass<T, U, V = Void> {
+class TestClass<T, U, V = haxe.NoValue> {
 }

tests/misc/projects/Issue10959/build.hxml.stdout

@@ -1,10 +1,10 @@
 On Generate
 -- Too Few Params --
 Before: TestClass
-After:  TestClass<TestClass.T, TestClass.U, Void>
+After:  TestClass<TestClass.T, TestClass.U, haxe.NoValue>
 
 Before: TestClass<Void>
-After:  TestClass<Void, TestClass.U, Void>
+After:  TestClass<Void, TestClass.U, haxe.NoValue>
 
 -- Too Many Params --
 Before: TestClass<Void, Int, Float, String>
@@ -15,15 +15,15 @@ Before: TestClass<Void, Int, Float>
 After:  TestClass<Void, Int, Float>
 
 Before: TestClass<Void, Int>
-After:  TestClass<Void, Int, Void>
+After:  TestClass<Void, Int, haxe.NoValue>
 
 -- Shouldn't Have Params --
 Before: Void<Int, Float>
 After:  Void
 
 -- Recursive Test --
 Before: TestClass<TestClass, TestClass<Void, Int, Float, String>>
-After:  TestClass<TestClass<TestClass.T, TestClass.U, Void>, TestClass<Void, Int, Float>, Void>
+After:  TestClass<TestClass<TestClass.T, TestClass.U, haxe.NoValue>, TestClass<Void, Int, Float>, haxe.NoValue>
 
 -- Fill With Specific Type --
 Before: TestClass

tests/misc/projects/Issue6201/compile2-fail.hxml.stderr

@@ -1 +1 @@
-Main2.hx:3: characters 7-8 : Variables of type Void are not allowed
+Main2.hx:3: characters 9-13 : Cannot use Void here

tests/nullsafety/src/cases/TestStrict.hx

@@ -842,7 +842,7 @@ class TestStrict {
 		}
 	}
 
-	static function recursiveTypedef_shouldNotCrashTheCompiler(a:Recursive<Void>, b:Recursive<Void>) {
+	static function recursiveTypedef_shouldNotCrashTheCompiler(a:Recursive<haxe.NoValue>, b:Recursive<haxe.NoValue>) {
 		a = b;
 	}
 

tests/unit/src/unit/issues/Issue9678.hx

@@ -11,13 +11,20 @@ class Issue9678 extends unit.Test {
 		eq(2, called);
 	}
 
-	@:keep static function explicitVoidArg(arg:Void) {}
+	@:keep static function explicitVoidArg(arg:haxe.NoValue) {}
 	#end
 }
 
 private class C<T> {
 	final v:T;
-	public function new(v:T) this.v = v;
-	public function next<S>(f:()->S):C<S> return new C(f());
-	public function handle(cb:T->Void) {cb(v);}
+
+	public function new(v:T)
+		this.v = v;
+
+	public function next<S>(f:() -> S):C<S>
+		return new C(f());
+
+	public function handle(cb:T->Void) {
+		cb(v);
+	}
 }