some UInt love (fix commutativity, use only Int as right-side for shifts) closes #3852

std/UInt.hx

@@ -34,40 +34,49 @@ 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 modI(lhs:UInt, rhs:Int):UInt;
+	@: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 subI(lhs:UInt, rhs:Int):UInt;
+	@: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 divI(lhs:UInt, rhs:Int):Float;
+	@: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 shl(lhs:UInt, rhs:Int):UInt;
+	@:op(A>>B) private static function shr(lhs:UInt, rhs:Int):UInt;
+	@:op(A>>>B) private static function ushr(lhs:UInt, rhs:Int):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>B) private static function gtf(lhs:UInt, rhs:Float):Bool;
+	@:op(A>B) private static function gtf(lhs:Float, rhs:UInt):Bool;
+	@:op(A>=B) private static function gtef(lhs:UInt, rhs:Float):Bool;
+	@:op(A>=B) private static function gtef(lhs:Float, rhs:UInt):Bool;
+	@:op(A<B) private static function ltf(lhs:UInt, rhs:Float):Bool;
+	@:op(A<B) private static function ltf(lhs:Float, rhs:UInt):Bool;
+	@:op(A<=B) private static function ltef(lhs:UInt, rhs:Float):Bool;
+	@:op(A<=B) private static function ltef(lhs:Float, rhs:UInt):Bool;
 
 	@:op(~A) private static function bneg(t:UInt):UInt;
 
@@ -144,12 +153,12 @@ abstract UInt(Int) from Int to Int {
 		return a.toInt() << b;
 	}
 
-	@:op(A >> B) private static inline function shr(a:UInt, b:UInt):UInt {
-		return a.toInt() >> b.toInt();
+	@:op(A >> B) private static inline function shr(a:UInt, b:Int):UInt {
+		return a.toInt() >> b;
 	}
 
-	@:op(A >>> B) private static inline function ushr(a:UInt, b:UInt):UInt {
-		return a.toInt() >>> b.toInt();
+	@:op(A >>> B) private static inline function ushr(a:UInt, b:Int):UInt {
+		return a.toInt() >>> b;
 	}
 
 	@:op(A % B) private static inline function mod(a:UInt, b:UInt):UInt {

tests/unit/src/unit/issues/Issue3852.hx

@@ -0,0 +1,64 @@
+package unit.issues;
+
+class Issue3852 extends Test {
+    @:analyzer(no_const_propagation)
+    function test() {
+        var u:UInt = 4;
+        var i:Int = 3;
+        var d:Float = 3;
+
+        eq(u + i, 7);
+        eq(u + d, 7);
+        eq(i + u, 7);
+        eq(d + u, 7);
+
+        eq(u * i, 12);
+        eq(u * d, 12);
+        eq(i * u, 12);
+        eq(d * u, 12);
+
+        eq(u % i, 1);
+        eq(u % d, 1);
+        eq(i % u, 3);
+        eq(d % u, 3);
+
+        eq(u - i, 1);
+        eq(u - d, 1);
+        eq(i - u, (-1 : UInt));
+        eq(d - u, -1);
+
+        #if !flash // flash generator errors on these
+        t(u > i);
+        t(u > d);
+        f(i > u);
+        f(d > u);
+        t(u >= i);
+        t(u >= d);
+        f(i >= u);
+        f(d >= u);
+
+        f(u < i);
+        f(u < d);
+        t(i < u);
+        t(d < u);
+        f(u <= i);
+        f(u <= d);
+        t(i <= u);
+        t(d <= u);
+        #end
+
+        i = 5;
+        d = 5;
+        eq(u / i, 0.8);
+        eq(u / d, 0.8);
+        eq(i / u, 1.25);
+        eq(d / u, 1.25);
+
+        u = 8;
+        i = 2;
+        eq(u << i, 32);
+        eq(i << u, 512);
+        eq(u >> i, 2);
+        eq(i >> u, 0);
+    }
+}