[flash/cs] Added list of operations types that can be performed with UInt. Closes #2990

gencommon.ml

@@ -10591,9 +10591,9 @@ struct
 						e
 				| TCast( ({ eexpr = TBinop((Ast.OpDiv as op), e1, e2) } as ebinop ), _ )
 				| TCast( ({ eexpr = TBinop(( (Ast.OpAssignOp Ast.OpDiv) as op), e1, e2) } as ebinop ), _ ) when catch_int_div && is_int e1.etype && is_int e2.etype && is_int e.etype ->
-					let e = { ebinop with eexpr = TBinop(op, run e1, run e2); etype = basic.tint } in
+					let ret = { ebinop with eexpr = TBinop(op, run e1, run e2); etype = e.etype } in
 					if not (is_exactly_int e1.etype && is_exactly_int e2.etype) then
-						mk_cast basic.tint e
+						mk_cast e.etype ret
 					else
 						e
 				| _ -> Type.map_expr run e

std/UInt.hx

@@ -29,7 +29,58 @@
 @:notNull
 @:runtimeValue
 @:analyzer(no_const_propagation)
-abstract UInt to Int from Int { }
+abstract UInt to Int from Int
+{
+	@:commutative @:op(A+B) private static function addI(lhs:UInt, rhs:Int):UInt;
+	@:commutative @:op(A+B) private static function addF(lhs:UInt, rhs:Float):Float;
+	@:op(A+B) private static function add(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A*B) private static function mulI(lhs:UInt, rhs:Int):UInt;
+	@:commutative @:op(A*B) private static function mulF(lhs:UInt, rhs:Float):Float;
+	@:op(A*B) private static function mul(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A%B) private static function modI(lhs:UInt, rhs:Int):UInt;
+	@:commutative @:op(A%B) private static function modF(lhs:UInt, rhs:Float):Float;
+	@:op(A%B) private static function mod(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A-B) private static function subI(lhs:UInt, rhs:Int):UInt;
+	@:commutative @:op(A-B) private static function subF(lhs:UInt, rhs:Float):Float;
+	@:op(A-B) private static function sub(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A/B) private static function divI(lhs:UInt, rhs:Int):Float;
+	@:commutative @:op(A/B) private static function divF(lhs:UInt, rhs:Float):Float;
+	@:op(A/B) private static function div(lhs:UInt, rhs:UInt):Float;
+	@:commutative @:op(A|B) private static function orI(lhs:UInt, rhs:Int):UInt;
+	@:op(A|B) private static function or(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A^B) private static function xorI(lhs:UInt, rhs:Int):UInt;
+	@:op(A^B) private static function xor(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A&B) private static function andI(lhs:UInt, rhs:Int):UInt;
+	@:op(A&B) private static function and(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A<<B) private static function shlI(lhs:UInt, rhs:Int):UInt;
+	@:op(A<<B) private static function shl(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A>>B) private static function shrI(lhs:UInt, rhs:Int):UInt;
+	@:op(A>>B) private static function shr(lhs:UInt, rhs:UInt):UInt;
+	@:commutative @:op(A>>>B) private static function ushrI(lhs:UInt, rhs:Int):UInt;
+	@:op(A>>>B) private static function ushr(lhs:UInt, rhs:UInt):UInt;
+
+	@:op(A>B) private static function gt(lhs:UInt, rhs:UInt):Bool;
+	@:op(A>=B) private static function gte(lhs:UInt, rhs:UInt):Bool;
+	@:op(A<B) private static function lt(lhs:UInt, rhs:UInt):Bool;
+	@:op(A<=B) private static function lte(lhs:UInt, rhs:UInt):Bool;
+
+	@:commutative @:op(A>B) private static function gtf(lhs:UInt, rhs:Float):Bool;
+	@:commutative @:op(A>=B) private static function gtef(lhs:UInt, rhs:Float):Bool;
+	@:commutative @:op(A<B) private static function ltf(lhs:UInt, rhs:Float):Bool;
+	@:commutative @:op(A<=B) private static function ltef(lhs:UInt, rhs:Float):Bool;
+
+	@:op(~A) private static function bneg(t:UInt):UInt;
+
+	@:commutative @:op(A == B) private static function equalsInt<T:Int>(a:UInt, b:T):Bool;
+	@:commutative @:op(A != B) private static function notEqualsInt<T:Int>(a:UInt, b:T):Bool;
+	@:commutative @:op(A == B) private static function equalsFloat<T:Float>(a:UInt, b:T):Bool;
+	@:commutative @:op(A != B) private static function notEqualsFloat<T:Float>(a:UInt, b:T):Bool;
+
+	@:op(++A) private function prefixIncrement():UInt;
+	@:op(A++) private function postfixIncrement():UInt;
+	@:op(--A) private function prefixDecrement():UInt;
+	@:op(A--) private function postfixDecrement():UInt;
+}
 #else
 /**
 	The unsigned Int type is only defined for Flash9 and C#.

tests/unit/compile-cs.hxml

@@ -4,6 +4,7 @@
 --next
 
 compile-each.hxml
+-D dump
 -main unit.Test
 -cs bin/cs
 -net-lib native_cs/bin/native_cs.dll

tests/unit/src/unit/issues/Issue2990.hx

@@ -0,0 +1,49 @@
+package unit.issues;
+import unit.Test;
+
+class Issue2990 extends Test
+{
+	function test()
+	{
+		var u:UInt = 11;
+		eq(typeof(u << 1), 'TAbstract(UInt,[])');
+		eq(typeof(~u), 'TAbstract(UInt,[])');
+		eq(typeof(u >> 1), 'TAbstract(UInt,[])');
+		eq(typeof(u >>> 1), 'TAbstract(UInt,[])');
+		eq(typeof(u + 1), 'TAbstract(UInt,[])');
+		eq(typeof(u - 1), 'TAbstract(UInt,[])');
+		eq(typeof(u / 2), 'TAbstract(Float,[])');
+		eq(typeof(u * 2), 'TAbstract(UInt,[])');
+		eq(typeof(u % 2), 'TAbstract(UInt,[])');
+		eq(typeof(u % 2.1), 'TAbstract(Float,[])');
+		eq(typeof(u * 2.1), 'TAbstract(Float,[])');
+		eq(typeof(u / 2.1), 'TAbstract(Float,[])');
+		eq(typeof(u - 2.1), 'TAbstract(Float,[])');
+		eq(typeof(u + 2.1), 'TAbstract(Float,[])');
+
+		eq(typeof(u > 2.1), 'TAbstract(Bool,[])');
+		eq(typeof(u > 2), 'TAbstract(Bool,[])');
+		eq(typeof(u > u), 'TAbstract(Bool,[])');
+		eq(typeof(u >= 2.1), 'TAbstract(Bool,[])');
+		eq(typeof(u >= 2), 'TAbstract(Bool,[])');
+		eq(typeof(u < 2.1), 'TAbstract(Bool,[])');
+		eq(typeof(u < 2), 'TAbstract(Bool,[])');
+		eq(typeof(u < u), 'TAbstract(Bool,[])');
+		eq(typeof(u <= 2.1), 'TAbstract(Bool,[])');
+		eq(typeof(u <= 2), 'TAbstract(Bool,[])');
+
+		eq(typeof(u == 2), 'TAbstract(Bool,[])');
+		eq(typeof(u == 2.1), 'TAbstract(Bool,[])');
+		eq(typeof(u == u), 'TAbstract(Bool,[])');
+		eq(typeof(u != 2), 'TAbstract(Bool,[])');
+		eq(typeof(u != 2.1), 'TAbstract(Bool,[])');
+		eq(typeof(u != u), 'TAbstract(Bool,[])');
+
+		eq(5.5, 11 / 2);
+	}
+
+	macro public static function typeof(expr:haxe.macro.Expr):haxe.macro.Expr
+	{
+		return haxe.macro.Context.makeExpr( haxe.macro.Context.typeof(expr) + '', expr.pos );
+	}
+}