Add for-loop tests & baselines

Author: brianrourkeboll

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoop.fs

@@ -217,3 +217,99 @@ module ForLoop =
         compilation
         |> getCompilation
         |> verifyCompilation
+
+    // SOURCE=ForLoopSByte.fs SCFLAGS="--optimize+"	# ForLoopSByte.fs --optimize+
+    [<Theory; FileInlineData("ForLoopSByte.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopSByte_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopByte.fs SCFLAGS="--optimize+"	# ForLoopByte.fs --optimize+
+    [<Theory; FileInlineData("ForLoopByte.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopByte_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopChar.fs SCFLAGS="--optimize+"	# ForLoopChar.fs --optimize+
+    [<Theory; FileInlineData("ForLoopChar.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopChar_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopInt16.fs SCFLAGS="--optimize+"	# ForLoopInt16.fs --optimize+
+    [<Theory; FileInlineData("ForLoopInt16.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopInt16_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopUInt16.fs SCFLAGS="--optimize+"	# ForLoopUInt16.fs --optimize+
+    [<Theory; FileInlineData("ForLoopUInt16.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopUInt16_`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopInt32.fs SCFLAGS="--optimize+"	# ForLoopInt32.fs --optimize+
+    [<Theory; FileInlineData("ForLoopInt32.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopInt32_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopUInt32.fs SCFLAGS="--optimize+"	# ForLoopUInt32.fs --optimize+
+    [<Theory; FileInlineData("ForLoopUInt32.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopUInt32_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopInt64.fs SCFLAGS="--optimize+"	# ForLoopInt64.fs --optimize+
+    [<Theory; FileInlineData("ForLoopInt64.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopInt64_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopUInt64.fs SCFLAGS="--optimize+"	# ForLoopUInt64.fs --optimize+
+    [<Theory; FileInlineData("ForLoopUInt64.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopUInt64_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopIntPtr.fs SCFLAGS="--optimize+"	# ForLoopIntPtr.fs --optimize+
+    [<Theory; FileInlineData("ForLoopIntPtr.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopIntPtr_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopUIntPtr.fs SCFLAGS="--optimize+"	# ForLoopUIntPtr.fs --optimize+
+    [<Theory; FileInlineData("ForLoopUIntPtr.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopUIntPtr_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation
+
+    // SOURCE=ForLoopBigInt.fs SCFLAGS="--optimize+"	# ForLoopBigInt.fs --optimize+
+    [<Theory; FileInlineData("ForLoopBigInt.fs", Realsig=BooleanOptions.True, Optimize=BooleanOptions.True)>]
+    let ``ForLoopBigInt_fs`` compilation =
+        compilation
+        |> getCompilation
+        |> withLangVersionPreview
+        |> verifyCompilation

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopBigInt.fs

@@ -0,0 +1,59 @@
+let mutable c = 0I
+
+module Up =
+    let constEmpty () =
+        for n = 10I to 1I do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1I to 10I do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10I do
+            c <- n
+
+    let constStart finish =
+        for n = 1I to finish do
+            c <- n
+
+    let annotatedStart (start: bigint) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: bigint) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1I downto 10I do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10I downto 1I do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1I do
+            c <- n
+
+    let constStart finish =
+        for n = 10I downto finish do
+            c <- n
+
+    let annotatedStart (start: bigint) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: bigint) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopBigInt.fs.RealInternalSignatureOn.OptimizeOn.il.bsl

@@ -0,0 +1,30 @@
+let mutable c = 0uy
+
+module Up =
+    let constEmpty () =
+        for n = 10uy to 1uy do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1uy to 10uy do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10uy do
+            c <- n
+
+    let constStart finish =
+        for n = 1uy to finish do
+            c <- n
+
+    let annotatedStart (start: byte) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: byte) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopByte.fs

@@ -0,0 +1,30 @@
+let mutable c = '\000'
+
+module Up =
+    let constEmpty () =
+        for n = 'z' to 'a' do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 'a' to 'z' do
+            c <- n
+
+    let constFinish start =
+        for n = start to 'z' do
+            c <- n
+
+    let constStart finish =
+        for n = 'a' to finish do
+            c <- n
+
+    let annotatedStart (start: char) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: char) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopByte.fs.RealInternalSignatureOn.OptimizeOn.il.bsl

@@ -0,0 +1,59 @@
+let mutable c = 0.0m
+
+module Up =
+    let constEmpty () =
+        for n = 10.0m to 1.0m do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1.0m to 10.0m do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10.0m do
+            c <- n
+
+    let constStart finish =
+        for n = 1.0m to finish do
+            c <- n
+
+    let annotatedStart (start: decimal) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: decimal) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1.0m downto 10.0m do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10.0m downto 1.0m do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1.0m do
+            c <- n
+
+    let constStart finish =
+        for n = 10.0m downto finish do
+            c <- n
+
+    let annotatedStart (start: decimal) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: decimal) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopChar.fs

@@ -0,0 +1,59 @@
+let mutable c = 0.0f
+
+module Up =
+    let constEmpty () =
+        for n = 10.0f to 1.0f do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1.0f to 10.0f do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10.0f do
+            c <- n
+
+    let constStart finish =
+        for n = 1.0f to finish do
+            c <- n
+
+    let annotatedStart (start: float32) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: float32) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1.0f downto 10.0f do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10.0f downto 1.0f do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1.0f do
+            c <- n
+
+    let constStart finish =
+        for n = 10.0f downto finish do
+            c <- n
+
+    let annotatedStart (start: float32) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: float32) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopChar.fs.RealInternalSignatureOn.OptimizeOn.il.bsl

@@ -0,0 +1,59 @@
+let mutable c = 0.0
+
+module Up =
+    let constEmpty () =
+        for n = 10.0 to 1.0 do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1.0 to 10.0 do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10.0 do
+            c <- n
+
+    let constStart finish =
+        for n = 1.0 to finish do
+            c <- n
+
+    let annotatedStart (start: float) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: float) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1.0 downto 10.0 do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10.0 downto 1.0 do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1.0 do
+            c <- n
+
+    let constStart finish =
+        for n = 10.0 downto finish do
+            c <- n
+
+    let annotatedStart (start: float) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: float) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopDecimal.fs

@@ -0,0 +1,59 @@
+let mutable c = 0s
+
+module Up =
+    let constEmpty () =
+        for n = 10s to 1s do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1s to 10s do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10s do
+            c <- n
+
+    let constStart finish =
+        for n = 1s to finish do
+            c <- n
+
+    let annotatedStart (start: int16) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: int16) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1s downto 10s do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10s downto 1s do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1s do
+            c <- n
+
+    let constStart finish =
+        for n = 10s downto finish do
+            c <- n
+
+    let annotatedStart (start: int16) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: int16) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopDecimal.fs.RealInternalSignatureOn.OptimizeOn.il.bsl

@@ -0,0 +1,83 @@
+open System.Runtime.CompilerServices
+
+let mutable c = 0
+
+[<MethodImpl(MethodImplOptions.NoInlining)>]
+let f<'a> (x: 'a) = ignore x
+
+[<MethodImpl(MethodImplOptions.NoInlining)>]
+let forceBoxing (x: obj) = ignore x
+
+module Up =
+    let constEmpty () =
+        for n = 10 to 1 do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1 to 10 do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10 do
+            c <- n
+
+    let constStart finish =
+        for n = 1 to finish do
+            c <- n
+
+    let annotatedStart (start: int) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: int) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+    let unconstrainedStartAndFinish start finish =
+        for n = start to finish do
+            f n
+
+    let boxedLoopVar start finish =
+        for n = start to finish do
+            forceBoxing n
+
+module Down =
+    let constEmpty () =
+        for n = 1 downto 10 do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10 downto 1 do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1 do
+            c <- n
+
+    let constStart finish =
+        for n = 10 downto finish do
+            c <- n
+
+    let annotatedStart (start: int) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: int) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n
+
+    let unconstrainedStartAndFinish start finish =
+        for n = start downto finish do
+            f n
+
+    let boxedLoopVar start finish =
+        for n = start downto finish do
+            forceBoxing n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopFloat32.fs

@@ -0,0 +1,59 @@
+let mutable c = 0L
+
+module Up =
+    let constEmpty () =
+        for n = 10L to 1L do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1L to 10L do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10L do
+            c <- n
+
+    let constStart finish =
+        for n = 1L to finish do
+            c <- n
+
+    let annotatedStart (start: int64) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: int64) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1L downto 10L do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10L downto 1L do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1L do
+            c <- n
+
+    let constStart finish =
+        for n = 10L downto finish do
+            c <- n
+
+    let annotatedStart (start: int64) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: int64) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopFloat32.fs.RealInternalSignatureOn.OptimizeOn.il.bsl

@@ -0,0 +1,59 @@
+let mutable c = 0n
+
+module Up =
+    let constEmpty () =
+        for n = 10n to 1n do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1n to 10n do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10n do
+            c <- n
+
+    let constStart finish =
+        for n = 1n to finish do
+            c <- n
+
+    let annotatedStart (start: nativeint) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: nativeint) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1n downto 10n do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10n downto 1n do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1n do
+            c <- n
+
+    let constStart finish =
+        for n = 10n downto finish do
+            c <- n
+
+    let annotatedStart (start: nativeint) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: nativeint) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopFloat64.fs

@@ -0,0 +1,59 @@
+let mutable c = 0y
+
+module Up =
+    let constEmpty () =
+        for n = 10y to 1y do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1y to 10y do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10y do
+            c <- n
+
+    let constStart finish =
+        for n = 1y to finish do
+            c <- n
+
+    let annotatedStart (start: sbyte) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: sbyte) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n
+
+module Down =
+    let constEmpty () =
+        for n = 1y downto 10y do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 10y downto 1y do
+            c <- n
+
+    let constFinish start =
+        for n = start downto 1y do
+            c <- n
+
+    let constStart finish =
+        for n = 10y downto finish do
+            c <- n
+
+    let annotatedStart (start: sbyte) finish =
+        for n = start downto finish do
+            c <- n
+
+    let annotatedFinish start (finish: sbyte) =
+        for n = start downto finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start downto finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopFloat64.fs.RealInternalSignatureOn.OptimizeOn.il.bsl

@@ -0,0 +1,30 @@
+let mutable c = 0us
+
+module Up =
+    let constEmpty () =
+        for n = 10us to 1us do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1us to 10us do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10us do
+            c <- n
+
+    let constStart finish =
+        for n = 1us to finish do
+            c <- n
+
+    let annotatedStart (start: uint16) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: uint16) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopInt16.fs

@@ -0,0 +1,30 @@
+let mutable c = 0u
+
+module Up =
+    let constEmpty () =
+        for n = 10u to 1u do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1u to 10u do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10u do
+            c <- n
+
+    let constStart finish =
+        for n = 1u to finish do
+            c <- n
+
+    let annotatedStart (start: uint) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: uint) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopInt16.fs.RealInternalSignatureOn.OptimizeOn.il.bsl

@@ -0,0 +1,30 @@
+let mutable c = 0UL
+
+module Up =
+    let constEmpty () =
+        for n = 10UL to 1UL do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1UL to 10UL do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10UL do
+            c <- n
+
+    let constStart finish =
+        for n = 1UL to finish do
+            c <- n
+
+    let annotatedStart (start: uint64) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: uint64) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n

tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoopInt32.fs

@@ -0,0 +1,30 @@
+let mutable c = 0un
+
+module Up =
+    let constEmpty () =
+        for n = 10un to 1un do
+            c <- n
+
+    let constNonEmpty () =
+        for n = 1un to 10un do
+            c <- n
+
+    let constFinish start =
+        for n = start to 10un do
+            c <- n
+
+    let constStart finish =
+        for n = 1un to finish do
+            c <- n
+
+    let annotatedStart (start: unativeint) finish =
+        for n = start to finish do
+            c <- n
+
+    let annotatedFinish start (finish: unativeint) =
+        for n = start to finish do
+            c <- n
+
+    let inferredStartAndFinish start finish =
+        for n = start to finish do
+            c <- n