Add more right-shift tests

Author: ncave

src/Fable.Transforms/Rust/Fable2Rust.fs

@@ -5360,14 +5360,15 @@ module Compiler =
                 |> Seq.toList
 
             member _.ClearAllImports(ctx) =
-                for import in imports do
+                let importsList = imports |> Seq.toList
+
+                for import in importsList do
                     import.Value.Depths <-
                         // remove all import depths at this module level or deeper
                         import.Value.Depths |> List.filter (fun d -> d < ctx.ModuleDepth)
 
                     if import.Value.Depths.Length = 0 then
                         imports.Remove(import.Key) |> ignore
-
                         ctx.UsedNames.RootScope.Remove(import.Value.LocalIdent) |> ignore
 
             member _.GetAllModules() = importModules.Keys |> Seq.toList

tests/Beam/ArithmeticTests.fs

@@ -703,7 +703,23 @@ let ``test Bitwise XOR on large unsigned integer works`` () =
 let ``test Zero fill shift right for unsigned`` () =
     0x80000000 >>> 1 |> equal -1073741824
     0x80000000u >>> 1 |> equal 1073741824u
-    0x80000000UL>>> 1 |> equal 1073741824UL
+    0x80000000UL >>> 1 |> equal 1073741824UL
+
+[<Fact>]
+let ``Zero fill right shift is logical for unsigned integer types`` () =
+    // For unsigned types, >>> is zero-fill (logical) - the high bit is NOT sign-extended
+    0xFFuy >>> 1 |> equal 127uy                      // uint8:  0x7F
+    0xFFFFus >>> 1 |> equal 32767us                  // uint16: 0x7FFF
+    0xFFFFFFFFu >>> 1 |> equal 2147483647u           // uint32: 0x7FFFFFFF
+    0xFFFFFFFFFFFFFFFFUL >>> 1 |> equal 9223372036854775807UL  // uint64: 0x7FFFFFFFFFFFFFFF
+
+[<Fact>]
+let ``Arithmetic right shift preserves sign for signed integer types`` () =
+    // For signed types, >>> is arithmetic (sign-propagating) - the sign bit IS extended
+    -2y >>> 1 |> equal -1y   // int8:  0xFF = -1
+    -2s >>> 1 |> equal -1s   // int16: 0xFFFF = -1
+    -2 >>> 1 |> equal -1     // int32: 0xFFFFFFFF = -1
+    -2L >>> 1 |> equal -1L   // int64: 0xFFFFFFFFFFFFFFFF = -1
 
 // TODO: ~~~ on unsigned integers uses LogicalNotDynamic which is not supported by Fable
 // [<Fact>]

tests/Js/Main/ArithmeticTests.fs

@@ -127,6 +127,20 @@ let tests =
         0x80000000u >>> 1 |> equal 1073741824u
         0x80000000UL >>> 1 |> equal 1073741824UL
 
+    testCase "Zero fill right shift is logical for unsigned integer types" <| fun () ->
+        // For unsigned types, >>> is zero-fill (logical) - the high bit is NOT sign-extended
+        0xFFuy >>> 1 |> equal 127uy                      // uint8:  0x7F
+        0xFFFFus >>> 1 |> equal 32767us                  // uint16: 0x7FFF
+        0xFFFFFFFFu >>> 1 |> equal 2147483647u           // uint32: 0x7FFFFFFF
+        0xFFFFFFFFFFFFFFFFUL >>> 1 |> equal 9223372036854775807UL  // uint64: 0x7FFFFFFFFFFFFFFF
+
+    testCase "Arithmetic right shift preserves sign for signed integer types" <| fun () ->
+        // For signed types, >>> is arithmetic (sign-propagating) - the sign bit IS extended
+        -2y >>> 1 |> equal -1y   // int8:  0xFF = -1
+        -2s >>> 1 |> equal -1s   // int16: 0xFFFF = -1
+        -2 >>> 1 |> equal -1     // int32: 0xFFFFFFFF = -1
+        -2L >>> 1 |> equal -1L   // int64: 0xFFFFFFFFFFFFFFFF = -1
+
     testCase "UInt64 multiplication with 0 returns uint" <| fun () -> // See #1480
         0x0UL * 0x1UL |> equal 0x0UL
 

tests/Python/TestArithmetic.fs

@@ -139,7 +139,23 @@ let ``test Bitwise shift right can be generated`` () = // See #1530
 let ``test Zero fill shift right for unsigned`` () = // See #646
     0x80000000 >>> 1 |> equal -1073741824
     0x80000000u >>> 1 |> equal 1073741824u
-    0x80000000UL>>> 1 |> equal 1073741824UL
+    0x80000000UL >>> 1 |> equal 1073741824UL
+
+[<Fact>]
+let ``test Zero fill right shift is logical for unsigned integer types`` () =
+    // For unsigned types, >>> is zero-fill (logical) - the high bit is NOT sign-extended
+    0xFFuy >>> 1 |> equal 127uy                      // uint8:  0x7F
+    0xFFFFus >>> 1 |> equal 32767us                  // uint16: 0x7FFF
+    0xFFFFFFFFu >>> 1 |> equal 2147483647u           // uint32: 0x7FFFFFFF
+    0xFFFFFFFFFFFFFFFFUL >>> 1 |> equal 9223372036854775807UL  // uint64: 0x7FFFFFFFFFFFFFFF
+
+[<Fact>]
+let ``test Arithmetic right shift preserves sign for signed integer types`` () =
+    // For signed types, >>> is arithmetic (sign-propagating) - the sign bit IS extended
+    -2y >>> 1 |> equal -1y   // int8:  0xFF = -1
+    -2s >>> 1 |> equal -1s   // int16: 0xFFFF = -1
+    -2 >>> 1 |> equal -1     // int32: 0xFFFFFFFF = -1
+    -2L >>> 1 |> equal -1L   // int64: 0xFFFFFFFFFFFFFFFF = -1
 
 [<Fact>]
 let ``test UInt64 multiplication with 0 returns uint`` () = // See #1480

tests/Rust/tests/src/ArithmeticTests.fs

@@ -136,7 +136,23 @@ let ``Bitwise shift right can be generated`` () = // See #1530
 let ``Zero fill shift right for unsigned`` () = // See #646
     0x80000000 >>> 1 |> equal -1073741824
     0x80000000u >>> 1 |> equal 1073741824u
-    0x80000000UL>>> 1 |> equal 1073741824UL
+    0x80000000UL >>> 1 |> equal 1073741824UL
+
+[<Fact>]
+let ``Zero fill right shift is logical for unsigned integer types`` () =
+    // For unsigned types, >>> is zero-fill (logical) - the high bit is NOT sign-extended
+    0xFFuy >>> 1 |> equal 127uy                      // uint8:  0x7F
+    0xFFFFus >>> 1 |> equal 32767us                  // uint16: 0x7FFF
+    0xFFFFFFFFu >>> 1 |> equal 2147483647u           // uint32: 0x7FFFFFFF
+    0xFFFFFFFFFFFFFFFFUL >>> 1 |> equal 9223372036854775807UL  // uint64: 0x7FFFFFFFFFFFFFFF
+
+[<Fact>]
+let ``Arithmetic right shift preserves sign for signed integer types`` () =
+    // For signed types, >>> is arithmetic (sign-propagating) - the sign bit IS extended
+    -2y >>> 1 |> equal -1y   // int8:  0xFF = -1
+    -2s >>> 1 |> equal -1s   // int16: 0xFFFF = -1
+    -2 >>> 1 |> equal -1     // int32: 0xFFFFFFFF = -1
+    -2L >>> 1 |> equal -1L   // int64: 0xFFFFFFFFFFFFFFFF = -1
 
 [<Fact>]
 let ``UInt64 multiplication with 0 returns uint`` () = // See #1480