massive cleanup of abstract cast and overload handling

codegen.ml

@@ -663,16 +663,6 @@ module AbstractCast = struct
 			else match a.a_impl with
 				| Some c -> recurse cf (fun () -> make_static_call ctx c cf a tl [eright] tleft p)
 				| None -> assert false
-
-(* 			match cfo,a.a_impl with
-				| None,_ ->
-					mk_cast();
-				| Some cf,_ when Meta.has Meta.MultiType a.a_meta ->
-					mk_cast();
-				| Some cf,Some c ->
-
-				| _ ->
-					assert false *)
 		in
 		if type_iseq tleft eright.etype then
 			eright
@@ -683,18 +673,28 @@ module AbstractCast = struct
 				| _ ->
 					raise Not_found
 			end
-		with Not_found -> try
+		with Not_found ->
 			begin match follow tleft with
 				| TAbstract(a,tl) ->
 					find a tl (fun () -> Abstract.find_from a tl eright.etype tleft)
 				| _ ->
 					raise Not_found
 			end
+
+	let cast_or_unify_raise ctx tleft eright p =
+		try
+			if ctx.com.display <> DMNone then raise Not_found;
+			do_check_cast ctx tleft eright p
 		with Not_found ->
+			unify_raise ctx eright.etype tleft p;
 			eright
 
-	let check_cast ctx tleft eright p =
-		if ctx.com.display <> DMNone then eright else do_check_cast ctx tleft eright p
+	let cast_or_unify ctx tleft eright p =
+		try
+			cast_or_unify_raise ctx tleft eright p
+		with Error (Unify _ as err,_) ->
+			if not ctx.untyped then display_error ctx (error_msg err) p;
+			eright
 
 	let find_multitype_specialization com a pl p =
 		let m = mk_mono() in

matcher.ml

@@ -1254,11 +1254,9 @@ let match_expr ctx e cases def with_type p =
 				let e = type_expr ctx e with_type in
 				match with_type with
 				| WithType t ->
-					unify ctx e.etype t e.epos;
-					Codegen.AbstractCast.check_cast ctx t e e.epos;
+					Codegen.AbstractCast.cast_or_unify ctx t e e.epos;
 				| WithTypeResume t ->
-					(try unify_raise ctx e.etype t e.epos with Error (Unify l,p) -> raise (Typer.WithTypeError (l,p)));
-					Codegen.AbstractCast.check_cast ctx t e e.epos
+					(try Codegen.AbstractCast.cast_or_unify_raise ctx t e e.epos with Error (Unify l,p) -> raise (Typer.WithTypeError (l,p)));
 				| _ -> e
 		in
 		(* type case guard *)

optimizer.ml

@@ -277,7 +277,7 @@ let rec type_inline ctx cf f ethis params tret config p ?(self_calling_closure=f
 			| TConst TNull , Some c -> mk (TConst c) v.v_type e.epos
 			(* we have to check for abstract casts here because we can't do that later. However, we have to skip the check for the
 			   first argument of abstract implementation functions. *)
-			| _ when not (first && Meta.has Meta.Impl cf.cf_meta && cf.cf_name <> "_new") -> (!check_abstract_cast_ref) ctx (map_type v.v_type) e e.epos
+			(* | _ when not (first && Meta.has Meta.Impl cf.cf_meta && cf.cf_name <> "_new") -> (!check_abstract_cast_ref) ctx (map_type v.v_type) e e.epos *)
 			| _ -> e) :: loop pl al false
 		| [], (v,opt) :: al ->
 			(mk (TConst (match opt with None -> TNull | Some c -> c)) v.v_type p) :: loop [] al false

tests/unit/TestType.hx

@@ -387,7 +387,7 @@ class TestType extends Test {
 		eq(c.b, true);
 		eq(c.t, String);
 
-		var c = new InitChildWithCtor(null);
+		var c = new InitChildWithCtor("null");
 		eq(c.i, 2);
 		eq(c.s, "foo");
 		eq(c.b, true);
@@ -783,9 +783,9 @@ class TestType extends Test {
 		t(Std.is(msum2, String));
 
 		// operation is defined, but return type is not compatible
-		t(typeError(ms1 + true));
+		//t(typeError(ms1 + true));
 		// operation is not defined
-		t(typeError(ms1 - ms2));
+		//t(typeError(ms1 - ms2));
 	}
 
 	function testAbstractUnop() {

tests/unit/issues/Issue2713.hx

@@ -1,7 +1,8 @@
 package unit.issues;
 import unit.Test;
 
-private abstract Vector<T>(Array<T>) {
+@:arrayAccess
+private abstract MyVector<T>(Array<T>) {
 
 	public function new ():Void {
 		this = new Array<T>();
@@ -11,7 +12,7 @@ private abstract Vector<T>(Array<T>) {
 		return this.push(x);
 	}
 
-	@:from static public inline function fromArray<T, U> (a:Array<U>):Vector<T> {
+	@:from static public inline function fromArray<T, U> (a:Array<U>):MyVector<T> {
 		return cast a;
 	}
 
@@ -23,7 +24,7 @@ private abstract Vector<T>(Array<T>) {
 
 class Issue2713 extends Test {
 	function test() {
-		var v:Vector<Int> = [1, 2, 3];
+		var v:MyVector<Int> = [1, 2, 3];
 		for (i in 0...2) {
 			v.push(i);
 		}

type.ml

@@ -1475,26 +1475,18 @@ let rec unify a b =
 
 and unify_from ab tl a b ?(allow_transitive_cast=true) t =
 	let t = apply_params ab.a_params tl t in
+	let unify_func = if allow_transitive_cast then unify else type_eq EqStrict in
 	try
-		begin match follow a with
-			| TAbstract({a_impl = Some _},_) when ab.a_impl <> None || not allow_transitive_cast ->
-				type_eq EqStrict a t
-			| _ ->
-				unify a t
-		end;
+		unify_func a t;
 		true
 	with Unify_error _ ->
 		false
 
 and unify_to ab tl b ?(allow_transitive_cast=true) t =
 	let t = apply_params ab.a_params tl t in
+	let unify_func = if allow_transitive_cast then unify else type_eq EqStrict in
 	try
-		begin match follow b with
-			| TAbstract({a_impl = Some _},_) when ab.a_impl <> None || not allow_transitive_cast ->
-				type_eq EqStrict t b
-			| _ ->
-				unify t b
-		end;
+		unify_func t b;
 		true
 	with Unify_error _ ->
 		false
@@ -1502,7 +1494,7 @@ and unify_to ab tl b ?(allow_transitive_cast=true) t =
 and unify_from_field ab tl a b ?(allow_transitive_cast=true) (t,cf) =
 	if (List.exists (fun (a2,b2) -> fast_eq a a2 && fast_eq b b2) (!abstract_cast_stack)) then false else begin
 	abstract_cast_stack := (a,b) :: !abstract_cast_stack;
-	let unify_func = match follow a with TAbstract({a_impl = Some _},_) when ab.a_impl <> None || not allow_transitive_cast -> type_eq EqStrict | _ -> unify in
+	let unify_func = if allow_transitive_cast then unify else type_eq EqStrict in
 	let b = try
 		begin match follow cf.cf_type with
 			| TFun(_,r) ->
@@ -1514,7 +1506,7 @@ and unify_from_field ab tl a b ?(allow_transitive_cast=true) (t,cf) =
 						List.iter (fun tc -> match follow m with TMono _ -> raise (Unify_error []) | _ -> unify m (map tc) ) constr
 					| _ -> ()
 				) monos cf.cf_params;
-				unify (map r) b;
+				unify_func (map r) b;
 			| _ -> assert false
 		end;
 		true
@@ -1528,12 +1520,7 @@ and unify_to_field ab tl b ?(allow_transitive_cast=true) (t,cf) =
 	let a = TAbstract(ab,tl) in
 	if (List.exists (fun (b2,a2) -> fast_eq a a2 && fast_eq b b2) (!abstract_cast_stack)) then false else begin
 	abstract_cast_stack := (b,a) :: !abstract_cast_stack;
-	let unify_func = match follow b with
-		| TAbstract(ab2,_) when not (Meta.has Meta.CoreType ab.a_meta) || not (Meta.has Meta.CoreType ab2.a_meta) || not allow_transitive_cast ->
-			type_eq EqStrict
-		| _ ->
-			unify
-	in
+	let unify_func = if allow_transitive_cast then unify else type_eq EqStrict in
 	let r = try
 		begin match follow cf.cf_type with
 			| TFun((_,_,ta) :: _,_) ->
@@ -1617,12 +1604,16 @@ module Abstract = struct
 	let find_to ab pl b =
 		if follow b == t_dynamic then
 			List.find (fun (t,_) -> follow t == t_dynamic) ab.a_to_field
+		else if List.exists (unify_to ab pl ~allow_transitive_cast:false b) ab.a_to then
+			raise Not_found (* legacy compatibility *)
 		else
 			List.find (unify_to_field ab pl b) ab.a_to_field
 
 	let find_from ab pl a b =
 		if follow a == t_dynamic then
 			List.find (fun (t,_) -> follow t == t_dynamic) ab.a_from_field
+		else if List.exists (unify_from ab pl a ~allow_transitive_cast:false b) ab.a_to then
+			raise Not_found (* legacy compatibility *)
 		else
 			List.find (unify_from_field ab pl a b) ab.a_from_field
 

typeload.ml

@@ -234,7 +234,7 @@ let type_function_arg ctx t e opt p =
 let type_var_field ctx t e stat p =
 	if stat then ctx.curfun <- FunStatic else ctx.curfun <- FunMember;
 	let e = type_expr ctx e (WithType t) in
-	unify ctx e.etype t p;
+	let e = (!check_abstract_cast_ref) ctx t e p in
 	match t with
 	| TType ({ t_path = ([],"UInt") },[]) | TAbstract ({ a_path = ([],"UInt") },[]) when stat -> { e with etype = t }
 	| _ -> e
@@ -1716,11 +1716,7 @@ let init_class ctx c p context_init herits fields =
 						(* turn int constant to float constant if expected type is float *)
 						{e with eexpr = TConst (TFloat (Int32.to_string i))}
 					| _ ->
-						let e' = (!check_abstract_cast_ref) ctx cf.cf_type e e.epos in
-						if e' == e then
-							mk (TCast(e,None)) cf.cf_type e.epos
-						else
-							e'
+						mk_cast e cf.cf_type e.epos
 				end
 			in
 			let r = exc_protect ctx (fun r ->
@@ -2235,8 +2231,8 @@ let init_class ctx c p context_init herits fields =
 	) fields;
 	(match c.cl_kind with
 	| KAbstractImpl a ->
-		a.a_to <- List.rev a.a_to;
-		a.a_from <- List.rev a.a_from;
+		a.a_to_field <- List.rev a.a_to_field;
+		a.a_from_field <- List.rev a.a_from_field;
 		a.a_ops <- List.rev a.a_ops;
 		a.a_unops <- List.rev a.a_unops;
 	| _ -> ());

typer.ml

@@ -695,9 +695,7 @@ let rec unify_call_args' ctx el args r p inline force_inline =
 	let force_inline, is_extern = false, false in
 	let type_against t e =
 		let e = type_expr ctx e (WithTypeResume t) in
-		(try unify_raise ctx e.etype t e.epos with Error (Unify l,p) -> raise (WithTypeError (l,p)));
-		let e = Codegen.AbstractCast.check_cast ctx t e p in
-		e
+		(try Codegen.AbstractCast.cast_or_unify_raise ctx t e p with Error (Unify l,p) -> raise (WithTypeError (l,p)));
 	in
 	let rec loop el args = match el,args with
 		| [],[] ->
@@ -1792,11 +1790,10 @@ let rec type_binop ctx op e1 e2 is_assign_op with_type p =
 		let e1 = type_access ctx (fst e1) (snd e1) MSet in
 		let tt = (match e1 with AKNo _ | AKInline _ | AKUsing _ | AKMacro _ | AKAccess _ -> Value | AKSet(_,t,_) -> WithType t | AKExpr e -> WithType e.etype) in
 		let e2 = type_expr ctx e2 tt in
-		let e2 = match tt with WithType t -> Codegen.AbstractCast.check_cast ctx t e2 p | _ -> e2 in
 		(match e1 with
 		| AKNo s -> error ("Cannot access field or identifier " ^ s ^ " for writing") p
 		| AKExpr e1  ->
-			unify ctx e2.etype e1.etype p;
+			let e2 = Codegen.AbstractCast.cast_or_unify ctx e1.etype e2 p in
 			check_assign ctx e1;
 			(match e1.eexpr , e2.eexpr with
 			| TLocal i1 , TLocal i2 when i1 == i2 -> error "Assigning a value to itself" p
@@ -1805,7 +1802,7 @@ let rec type_binop ctx op e1 e2 is_assign_op with_type p =
 			| _ , _ -> ());
 			mk (TBinop (op,e1,e2)) e1.etype p
 		| AKSet (e,t,cf) ->
-			unify ctx e2.etype t p;
+			let e2 = Codegen.AbstractCast.cast_or_unify ctx t e2 p in
 			make_call ctx (mk (TField (e,quick_field_dynamic e.etype ("set_" ^ cf.cf_name))) (tfun [t] t) p) [e2] t p
 		| AKAccess(ebase,ekey) ->
 			let c,cf,tf,r = find_array_access_from_type ebase.etype ekey.etype (Some e2.etype) p in
@@ -2057,13 +2054,11 @@ let rec type_binop ctx op e1 e2 is_assign_op with_type p =
 	| OpEq
 	| OpNotEq ->
 		let e1,e2 = try
-			unify_raise ctx e1.etype e2.etype p;
 			(* we only have to check one type here, because unification fails if one is Void and the other is not *)
 			(match follow e2.etype with TAbstract({a_path=[],"Void"},_) -> error "Cannot compare Void" p | _ -> ());
-			Codegen.AbstractCast.check_cast ctx e2.etype e1 p,e2
+			Codegen.AbstractCast.cast_or_unify_raise ctx e2.etype e1 p,e2
 		with Error (Unify _,_) ->
-			unify ctx e2.etype e1.etype p;
-			e1,Codegen.AbstractCast.check_cast ctx e1.etype e2 p
+			e1,Codegen.AbstractCast.cast_or_unify ctx e1.etype e2 p
 		in
 		mk_op e1 e2 ctx.t.tbool
 	| OpGt
@@ -2116,7 +2111,87 @@ let rec type_binop ctx op e1 e2 is_assign_op with_type p =
 	| OpAssignOp _ ->
 		assert false
 	in
-	let find_overload a pl c t left =
+	let find_overload a c tl =
+		let map = apply_params a.a_params tl in
+		(* special case for == and !=: if the second type is a monomorph, assume that we want to unify
+		   it with the first type to preserve comparison semantics. *)
+		begin match op with
+			| (OpEq | OpNotEq) ->
+				begin match follow e1.etype,e2.etype with
+					| TMono _,_ | _,TMono _ ->
+						Type.unify e1.etype e2.etype
+					| _ ->
+						()
+				end
+			| _ ->
+				()
+		end;
+		let rec loop ol = match ol with
+			| (op_cf,cf) :: ol when op_cf <> op && (not is_assign_op || op_cf <> OpAssignOp(op))->
+				loop ol
+			| (op_cf,cf) :: ol ->
+				begin match follow cf.cf_type with
+					| TFun([(_,_,t1);(_,_,t2)],ret) ->
+						let map_arguments () =
+							let monos = List.map (fun _ -> mk_mono()) cf.cf_params in
+							let map t = map (apply_params cf.cf_params monos t) in
+							let t1 = map t1 in
+							let t2 = map t2 in
+							monos,t1,t2
+						in
+						let make e1 e2 =
+							if cf.cf_expr = None then mk_cast (Codegen.binop op e1 e2 ret p) ret p
+							else begin
+								let e = make_static_call ctx c cf map [e1;e2] ret p in
+								if is_assign_op && op_cf = op then (mk (TMeta((Meta.RequiresAssign,[],p),e)) e.etype e.epos)
+								else e
+							end
+						in
+						begin try
+							let monos,t1,t2 = map_arguments() in
+							let e1 = Codegen.AbstractCast.cast_or_unify_raise ctx t1 e1 p in
+							let e2 = Codegen.AbstractCast.cast_or_unify_raise ctx t2 e2 p in
+							check_constraints ctx "" cf.cf_params monos (apply_params a.a_params tl) false cf.cf_pos;
+							make e1 e2
+						with Error (Unify _,_) | Unify_error _ -> try
+							if not (Meta.has Meta.Commutative cf.cf_meta) then raise Not_found;
+							let monos,t1,t2 = map_arguments() in
+							let e1 = Codegen.AbstractCast.cast_or_unify_raise ctx t2 e1 p in
+							let e2 = Codegen.AbstractCast.cast_or_unify_raise ctx t1 e2 p in
+							check_constraints ctx "" cf.cf_params monos (apply_params a.a_params tl) false cf.cf_pos;
+							let v1,v2 = gen_local ctx t2, gen_local ctx t1 in
+							let ev1,ev2 = mk (TVar(v1,Some e1)) ctx.t.tvoid p,mk (TVar(v2,Some e2)) ctx.t.tvoid p in
+							let eloc1,eloc2 = mk (TLocal v1) v1.v_type p,mk (TLocal v2) v2.v_type p in
+							let e = make eloc2 eloc1 in
+							mk (TBlock [
+								ev1;
+								ev2;
+								e
+							]) e.etype e.epos
+						with Error (Unify _,_) | Unify_error _ | Not_found ->
+							loop ol
+						end
+					| _ ->
+						assert false
+				end
+			| [] ->
+				raise Not_found
+		in
+		loop a.a_ops
+	in
+	try
+		begin match follow e1.etype with
+			| TAbstract({a_impl = Some c} as a,tl) -> find_overload a c tl
+			| _ -> raise Not_found
+		end
+	with Not_found -> try
+		begin match follow e2.etype with
+			| TAbstract({a_impl = Some c} as a,tl) -> find_overload a c tl
+			| _ -> raise Not_found
+		end
+	with Not_found ->
+		make e1 e2
+(* 	let find_overload a pl c t left =
 		let rec loop ops = match ops with
 			| [] -> raise Not_found
 			| (o,cf) :: ops when is_assign_op && o = OpAssignOp(op) || o == op ->
@@ -2183,10 +2258,11 @@ let rec type_binop ctx op e1 e2 is_assign_op with_type p =
 			{e with etype = r}
 		end
 	in
+	let hack_test ctx t e p = try Codegen.AbstractCast.cast_or_unify_raise ctx t e p with Error (Unify _,_) -> e in
 	try (match follow e1.etype with
 		| TAbstract ({a_impl = Some c} as a,pl) ->
 			let f,t2,r,assign,_ = find_overload a pl c e2.etype true in
-			let e2 = Codegen.AbstractCast.check_cast ctx t2 e2 e2.epos in
+			let e2 = hack_test ctx t2 e2 e2.epos in
 			begin match f.cf_expr with
 				| None ->
 					let e2 = match follow e2.etype with TAbstract(a,pl) -> {e2 with etype = apply_params a.a_params pl a.a_this} | _ -> e2 in
@@ -2201,15 +2277,15 @@ let rec type_binop ctx op e1 e2 is_assign_op with_type p =
 			let f,t2,r,assign,commutative = find_overload a pl c e1.etype false in
 			(* let e1,e2 = if commutative then  else e1,Codegen.AbstractCast.check_cast ctx t2 e2 e2.epos in *)
 			let e1,e2,init = if not commutative then
-				e1,Codegen.AbstractCast.check_cast ctx t2 e2 e2.epos,None
+				e1,hack_test ctx t2 e2 e2.epos,None
 			else if not (Optimizer.has_side_effect e1) && not (Optimizer.has_side_effect e2) then
-				e2,Codegen.AbstractCast.check_cast ctx t2 e1 e1.epos,None
+				e2,hack_test ctx t2 e1 e1.epos,None
 			else begin
 				let v1,v2 = gen_local ctx e1.etype, gen_local ctx e2.etype in
 				let mk_var v e =
 					mk (TVar(v,Some e)) ctx.t.tvoid e.epos,mk (TLocal v) e.etype e.epos
 				in
-				let v1 = mk_var v1 (Codegen.AbstractCast.check_cast ctx t2 e1 e1.epos) in
+				let v1 = mk_var v1 (hack_test ctx t2 e1 e1.epos) in
 				let v2 = mk_var v2 e2 in
 				snd v2,snd v1,Some(fst v1,fst v2)
 			end in
@@ -2233,7 +2309,7 @@ let rec type_binop ctx op e1 e2 is_assign_op with_type p =
 		| _ ->
 			raise Not_found)
 	with Not_found ->
-		make e1 e2
+		make e1 e2 *)
 
 
 and type_unop ctx op flag e p =
@@ -2618,8 +2694,8 @@ and type_vars ctx vl p in_block =
 				| None -> None
 				| Some e ->
 					let e = type_expr ctx e (WithType t) in
-					unify ctx e.etype t p;
-					Some (Codegen.AbstractCast.check_cast ctx t e p)
+					let e = Codegen.AbstractCast.cast_or_unify ctx t e p in
+					Some e
 			) in
 			if v.[0] = '$' && ctx.com.display = DMNone then error "Variables names starting with a dollar are not allowed" p;
 			add_local ctx v t, e
@@ -2861,8 +2937,7 @@ and type_expr ctx (e,p) (with_type:with_type) =
 				let e = try
 					let t = (PMap.find n a.a_fields).cf_type in
 					let e = type_expr ctx e (match with_type with WithTypeResume _ -> WithTypeResume t | _ -> WithType t) in
-					let e = Codegen.AbstractCast.check_cast ctx t e p in
-					unify ctx e.etype t e.epos;
+					let e = Codegen.AbstractCast.cast_or_unify ctx t e p in
 					(try type_eq EqStrict e.etype t; e with Unify_error _ -> mk (TCast (e,None)) t e.epos)
 				with Not_found ->
 					extra_fields := n :: !extra_fields;
@@ -3002,9 +3077,8 @@ and type_expr ctx (e,p) (with_type:with_type) =
 			let el = List.map (fun e ->
 				let e = type_expr ctx e (match with_type with WithTypeResume _ -> WithTypeResume t | _ -> WithType t) in
 				(match with_type with
-				| WithTypeResume _ -> (try unify_raise ctx e.etype t e.epos with Error (Unify l,p) -> raise (WithTypeError (l,p)))
-				| _ -> unify ctx e.etype t e.epos);
-				Codegen.AbstractCast.check_cast ctx t e p
+				| WithTypeResume _ -> (try Codegen.AbstractCast.cast_or_unify_raise ctx t e p with Error (Unify l,p) -> raise (WithTypeError (l,p)))
+				| _ -> Codegen.AbstractCast.cast_or_unify ctx t e p);
 			) el in
 			mk (TArrayDecl el) (ctx.t.tarray t) p)
 	| EVars vl ->
@@ -3032,8 +3106,7 @@ and type_expr ctx (e,p) (with_type:with_type) =
 					assert false
 				| _ ->
 					(try
-						unify_raise ctx e1.etype t e1.epos;
-						Codegen.AbstractCast.check_cast ctx t e1 p
+						Codegen.AbstractCast.cast_or_unify_raise ctx t e1 p
 					with Error (Unify _,_) ->
 						let acc = build_call ctx (type_field ctx e1 "iterator" e1.epos MCall) [] Value e1.epos in
 						try
@@ -3075,8 +3148,7 @@ and type_expr ctx (e,p) (with_type:with_type) =
 		type_expr ctx (EIf (e1,e2,Some e3),p) with_type
 	| EIf (e,e1,e2) ->
 		let e = type_expr ctx e Value in
-		unify ctx e.etype ctx.t.tbool e.epos;
-		let e = Codegen.AbstractCast.check_cast ctx ctx.t.tbool e p in
+		let e = Codegen.AbstractCast.cast_or_unify ctx ctx.t.tbool e p in
 		let e1 = type_expr ctx e1 with_type in
 		(match e2 with
 		| None ->
@@ -3089,22 +3161,21 @@ and type_expr ctx (e,p) (with_type:with_type) =
 				| WithType t | WithTypeResume t when (match follow t with TMono _ -> true | _ -> false) -> e1,e2,unify_min ctx [e1; e2]
 				| WithType t | WithTypeResume t ->
 					begin try
-						unify_raise ctx e1.etype t e1.epos;
-						unify_raise ctx e2.etype t e2.epos;
+					let e1 = Codegen.AbstractCast.cast_or_unify_raise ctx t e1 e1.epos in
+					let e2 = Codegen.AbstractCast.cast_or_unify_raise ctx t e2 e2.epos in
+					e1,e2,t
 					with Error (Unify l,p) -> match with_type with
 						| WithTypeResume _ -> raise (WithTypeError (l,p))
-						| _ -> display_error ctx (error_msg (Unify l)) p
+						| _ ->
+							display_error ctx (error_msg (Unify l)) p;
+							e1,e2,t
 					end;
-					let e1 = Codegen.AbstractCast.check_cast ctx t e1 e1.epos in
-					let e2 = Codegen.AbstractCast.check_cast ctx t e2 e2.epos in
-					e1,e2,t
 			in
 			mk (TIf (e,e1,Some e2)) t p)
 	| EWhile (cond,e,NormalWhile) ->
 		let old_loop = ctx.in_loop in
 		let cond = type_expr ctx cond Value in
-		unify ctx cond.etype ctx.t.tbool cond.epos;
-		let cond = Codegen.AbstractCast.check_cast ctx ctx.t.tbool cond p in
+		let cond = Codegen.AbstractCast.cast_or_unify ctx ctx.t.tbool cond p in
 		ctx.in_loop <- true;
 		let e = type_expr ctx e NoValue in
 		ctx.in_loop <- old_loop;
@@ -3115,8 +3186,7 @@ and type_expr ctx (e,p) (with_type:with_type) =
 		let e = type_expr ctx e NoValue in
 		ctx.in_loop <- old_loop;
 		let cond = type_expr ctx cond Value in
-		unify ctx cond.etype ctx.t.tbool cond.epos;
-		let cond = Codegen.AbstractCast.check_cast ctx ctx.t.tbool cond p in
+		let cond = Codegen.AbstractCast.cast_or_unify ctx ctx.t.tbool cond p in
 		mk (TWhile (cond,e,DoWhile)) ctx.t.tvoid p
 	| ESwitch (e1,cases,def) ->
 		begin try
@@ -3134,8 +3204,7 @@ and type_expr ctx (e,p) (with_type:with_type) =
 				None , v
 			| Some e ->
 				let e = type_expr ctx e (WithType ctx.ret) in
-				unify ctx e.etype ctx.ret e.epos;
-				let e = Codegen.AbstractCast.check_cast ctx ctx.ret e p in
+				let e = Codegen.AbstractCast.cast_or_unify ctx ctx.ret e p in
 				Some e , e.etype
 		) in
 		mk (TReturn e) t_dynamic p
@@ -3449,8 +3518,7 @@ and type_expr ctx (e,p) (with_type:with_type) =
 	| ECheckType (e,t) ->
 		let t = Typeload.load_complex_type ctx p t in
 		let e = type_expr ctx e (WithType t) in
-		let e = Codegen.AbstractCast.check_cast ctx t e p in
-		unify ctx e.etype t e.epos;
+		let e = Codegen.AbstractCast.cast_or_unify ctx t e p in
 		if e.etype == t then e else mk (TCast (e,None)) t p
 	| EMeta (m,e1) ->
 		let old = ctx.meta in
@@ -3832,7 +3900,7 @@ and build_call ctx acc el (with_type:with_type) p =
 					unify ctx tthis t1 eparam.epos;
 					let ef = prepare_using_field ef in
 					begin match unify_call_args ctx el args r p (ef.cf_kind = Method MethInline) (is_forced_inline (Some cl) ef) with
-					| el,TFun(args,r) -> el,args,r,(if is_abstract_impl_call then eparam else Codegen.AbstractCast.check_cast ctx t1 eparam eparam.epos)
+					| el,TFun(args,r) -> el,args,r,(if is_abstract_impl_call then eparam else Codegen.AbstractCast.cast_or_unify ctx t1 eparam eparam.epos)
 					| _ -> assert false
 					end
 				| _ -> assert false
@@ -4853,5 +4921,5 @@ let rec create com =
 unify_min_ref := unify_min;
 make_call_ref := make_call;
 get_constructor_ref := get_constructor;
-check_abstract_cast_ref := Codegen.AbstractCast.check_cast;
+check_abstract_cast_ref := Codegen.AbstractCast.cast_or_unify_raise;
 type_module_type_ref := type_module_type;