From cdabe6c5b99fc7edd7575b928e899e86ee02c733 Mon Sep 17 00:00:00 2001 From: Kevin Ransom Date: Fri, 1 Mar 2024 12:41:47 -0800 Subject: [PATCH 1/2] correct realsignature test cases for seqexpr tests --- .../SeqExpressionStepping.fs | 29 +- ...gTest01.fs.RealInternalSignatureOff.il.bsl | 225 +++++ ...gTest01.fs.RealInternalSignatureOn.il.bsl} | 0 ...est02.fs.RealInternalSignatureOff.il..bsl} | 0 ...gTest02.fs.RealInternalSignatureOff.il.bsl | 253 ++++++ ...ngTest02.fs.RealInternalSignatureOn.il.bsl | 291 +++++++ ...gTest03.fs.RealInternalSignatureOff.il.bsl | 261 ++++++ ...gTest03.fs.RealInternalSignatureOn.il.bsl} | 0 ...gTest04.fs.RealInternalSignatureOff.il.bsl | 304 +++++++ ...gTest04.fs.RealInternalSignatureOn.il.bsl} | 0 ...gTest05.fs.RealInternalSignatureOff.il.bsl | 411 +++++++++ ...gTest05.fs.RealInternalSignatureOn.il.bsl} | 0 ...gTest06.fs.RealInternalSignatureOff.il.bsl | 477 ++++++++++ ...gTest06.fs.RealInternalSignatureOn.il.bsl} | 0 ...alInternalSignatureOff.il.net472.debug.bsl | 811 +++++++++++++++++ ...InternalSignatureOff.il.net472.release.bsl | 811 +++++++++++++++++ ...lInternalSignatureOff.il.netcore.debug.bsl | 812 ++++++++++++++++++ ...nternalSignatureOff.il.netcore.release.bsl | 812 ++++++++++++++++++ ...alInternalSignatureOn.il.net472.debug.bsl} | 0 ...InternalSignatureOn.il.net472.release.bsl} | 0 ...lInternalSignatureOn.il.netcore.debug.bsl} | 0 ...nternalSignatureOn.il.netcore.release.bsl} | 0 .../SeqExpressionTailCalls.fs | 3 +- 23 files changed, 5484 insertions(+), 16 deletions(-) create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOff.il.bsl rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest01.fs.il.bsl => SeqExpressionSteppingTest01.fs.RealInternalSignatureOn.il.bsl} (100%) rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest02.fs.il.bsl => SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il..bsl} (100%) create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il.bsl create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOn.il.bsl create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOff.il.bsl rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest03.fs.il.bsl => SeqExpressionSteppingTest03.fs.RealInternalSignatureOn.il.bsl} (100%) create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOff.il.bsl rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest04.fs.il.bsl => SeqExpressionSteppingTest04.fs.RealInternalSignatureOn.il.bsl} (100%) create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOff.il.bsl rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest05.fs.il.bsl => SeqExpressionSteppingTest05.fs.RealInternalSignatureOn.il.bsl} (100%) create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOff.il.bsl rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest06.fs.il.bsl => SeqExpressionSteppingTest06.fs.RealInternalSignatureOn.il.bsl} (100%) create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.debug.bsl create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.release.bsl create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.debug.bsl create mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.release.bsl rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest07.fs.il.net472.debug.bsl => SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.debug.bsl} (100%) rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest07.fs.il.net472.release.bsl => SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.release.bsl} (100%) rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest07.fs.il.netcore.debug.bsl => SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.debug.bsl} (100%) rename tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/{SeqExpressionSteppingTest07.fs.il.netcore.release.bsl => SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.release.bsl} (100%) diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs index 6d8d2f0a5af..3b748e2be23 100644 --- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs @@ -14,103 +14,102 @@ module SeqExpressionStepping = |> withNoOptimize |> withEmbeddedPdb |> withEmbedAllSource - |> withRealInternalSignatureOn |> ignoreWarnings |> verifyILBaseline //Retry SOURCE=SeqExpressionSteppingTest01.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest1.exe" # SeqExpressionSteppingTest1.fs - - [] + [] let ``SeqExpressionSteppingTest01_RealInternalSignatureOn_fs`` compilation = compilation |> withRealInternalSignatureOn |> verifyCompilation //Retry SOURCE=SeqExpressionSteppingTest01.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest1.exe" # SeqExpressionSteppingTest1.fs - - [] + [] let ``SeqExpressionSteppingTest01_RealInternalSignatureOff_fs`` compilation = compilation |> withRealInternalSignatureOff |> verifyCompilation // SOURCE=SeqExpressionSteppingTest02.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest2.exe" # SeqExpressionSteppingTest2.fs - - [] + [] let ``SeqExpressionSteppingTest02_RealInternalSignatureOn_fs`` compilation = compilation |> withRealInternalSignatureOn |> verifyCompilation // SOURCE=SeqExpressionSteppingTest02.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest2.exe" # SeqExpressionSteppingTest2.fs - - [] + [] let ``SeqExpressionSteppingTest02_RealInternalSignatureOff_fs`` compilation = compilation |> withRealInternalSignatureOff |> verifyCompilation //SOURCE=SeqExpressionSteppingTest03.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest3.exe" # SeqExpressionSteppingTest3.fs - - [] + [] let ``SeqExpressionSteppingTest03_RealInternalSignatureOn_fs`` compilation = compilation |> withRealInternalSignatureOn |> verifyCompilation //SOURCE=SeqExpressionSteppingTest03.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest3.exe" # SeqExpressionSteppingTest3.fs - - [] + [] let ``SeqExpressionSteppingTest03_RealInternalSignatureOff_fs`` compilation = compilation |> withRealInternalSignatureOff |> verifyCompilation // SOURCE=SeqExpressionSteppingTest04.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest4.exe" # SeqExpressionSteppingTest4.fs - - [] + [] let ``SeqExpressionSteppingTest04_RealInternalSignatureOn_fs`` compilation = compilation |> withRealInternalSignatureOn |> verifyCompilation // SOURCE=SeqExpressionSteppingTest04.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest4.exe" # SeqExpressionSteppingTest4.fs - - [] + [] let ``SeqExpressionSteppingTest04_RealInternalSignatureOff_fs`` compilation = compilation |> withRealInternalSignatureOff |> verifyCompilation // SOURCE=SeqExpressionSteppingTest05.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest5.exe" # SeqExpressionSteppingTest5.fs - - [] + [] let ``SeqExpressionSteppingTest05_RealInternalSignatureOn_fs`` compilation = compilation |> withRealInternalSignatureOn |> verifyCompilation // SOURCE=SeqExpressionSteppingTest05.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest5.exe" # SeqExpressionSteppingTest5.fs - - [] + [] let ``SeqExpressionSteppingTest05_RealInternalSignatureOff_fs`` compilation = compilation |> withRealInternalSignatureOff |> verifyCompilation // SOURCE=SeqExpressionSteppingTest06.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest6.exe" # SeqExpressionSteppingTest6.fs - - [] + [] let ``SeqExpressionSteppingTest06_RealInternalSignatureOn_fs`` compilation = compilation |> withRealInternalSignatureOn |> verifyCompilation // SOURCE=SeqExpressionSteppingTest06.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest6.exe" # SeqExpressionSteppingTest6.fs - - [] + [] let ``SeqExpressionSteppingTest06_RealInternalSignatureOff_fs`` compilation = compilation |> withRealInternalSignatureOff |> verifyCompilation // SOURCE=SeqExpressionSteppingTest07.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest7.exe" # SeqExpressionSteppingTest7.fs - - [] + [] let ``SeqExpressionSteppingTest07_RealInternalSignatureOn_fs`` compilation = compilation |> withRealInternalSignatureOn |> verifyCompilation // SOURCE=SeqExpressionSteppingTest07.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest7.exe" # SeqExpressionSteppingTest7.fs - - [] + [] let ``SeqExpressionSteppingTest07_RealInternalSignatureOff_fs`` compilation = compilation |> withRealInternalSignatureOff diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOff.il.bsl new file mode 100644 index 00000000000..36ec2d96a52 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOff.il.bsl @@ -0,0 +1,225 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest1 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class abstract auto ansi sealed nested public SeqExpressionSteppingTest1 + extends [runtime]System.Object + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class auto autochar serializable sealed nested assembly beforefieldinit specialname f0@6 + extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) + .field public int32 pc + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 current + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public specialname rtspecialname + instance void .ctor(int32 pc, + int32 current) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current + IL_000e: ldarg.0 + IL_000f: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0014: ret + } + + .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch ( + IL_0017, + IL_001a) + IL_0015: br.s IL_001d + + IL_0017: nop + IL_0018: br.s IL_002e + + IL_001a: nop + IL_001b: br.s IL_0035 + + IL_001d: nop + IL_001e: ldarg.0 + IL_001f: ldc.i4.1 + IL_0020: stfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc + IL_0025: ldarg.0 + IL_0026: ldc.i4.1 + IL_0027: stfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current + IL_002c: ldc.i4.1 + IL_002d: ret + + IL_002e: ldarg.0 + IL_002f: ldc.i4.2 + IL_0030: stfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc + IL_0035: ldarg.0 + IL_0036: ldc.i4.0 + IL_0037: stfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current + IL_003c: ldc.i4.0 + IL_003d: ret + } + + .method public strict virtual instance void Close() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldc.i4.2 + IL_0002: stfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc + IL_0007: ret + } + + .method public strict virtual instance bool get_CheckClose() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc + IL_0006: switch ( + IL_0019, + IL_001c, + IL_001f) + IL_0017: br.s IL_0022 + + IL_0019: nop + IL_001a: br.s IL_0025 + + IL_001c: nop + IL_001d: br.s IL_0023 + + IL_001f: nop + IL_0020: br.s IL_0025 + + IL_0022: nop + IL_0023: ldc.i4.0 + IL_0024: ret + + IL_0025: ldc.i4.0 + IL_0026: ret + } + + .method public strict virtual instance int32 get_LastGenerated() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current + IL_0006: ret + } + + .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::.ctor(int32, + int32) + IL_0007: ret + } + + } + + .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f0() cil managed + { + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::.ctor(int32, + int32) + IL_0007: ret + } + + } + +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest1 + extends [runtime]System.Object +{ + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 3 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0) + IL_0000: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1::f0() + IL_0005: stloc.0 + IL_0006: ldloc.0 + IL_0007: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_000c: pop + IL_000d: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOn.il.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.il.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOn.il.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il..bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.il.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il..bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il.bsl new file mode 100644 index 00000000000..4400ae53886 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il.bsl @@ -0,0 +1,253 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest2 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class abstract auto ansi sealed nested public SeqExpressionSteppingTest2 + extends [runtime]System.Object + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class auto autochar serializable sealed nested assembly beforefieldinit specialname f1@5 + extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) + .field public int32 pc + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 current + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public specialname rtspecialname + instance void .ctor(int32 pc, + int32 current) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_000e: ldarg.0 + IL_000f: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0014: ret + } + + .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed + { + + .maxstack 6 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch ( + IL_001b, + IL_001e, + IL_0021) + IL_0019: br.s IL_0024 + + IL_001b: nop + IL_001c: br.s IL_0045 + + IL_001e: nop + IL_001f: br.s IL_0065 + + IL_0021: nop + IL_0022: br.s IL_006c + + IL_0024: nop + IL_0025: ldstr "hello" + IL_002a: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_002f: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0034: pop + IL_0035: ldarg.0 + IL_0036: ldc.i4.1 + IL_0037: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_003c: ldarg.0 + IL_003d: ldc.i4.1 + IL_003e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0043: ldc.i4.1 + IL_0044: ret + + IL_0045: ldstr "goodbye" + IL_004a: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_004f: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0054: pop + IL_0055: ldarg.0 + IL_0056: ldc.i4.2 + IL_0057: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_005c: ldarg.0 + IL_005d: ldc.i4.2 + IL_005e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0063: ldc.i4.1 + IL_0064: ret + + IL_0065: ldarg.0 + IL_0066: ldc.i4.3 + IL_0067: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_006c: ldarg.0 + IL_006d: ldc.i4.0 + IL_006e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0073: ldc.i4.0 + IL_0074: ret + } + + .method public strict virtual instance void Close() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldc.i4.3 + IL_0002: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0007: ret + } + + .method public strict virtual instance bool get_CheckClose() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0006: switch ( + IL_001d, + IL_0020, + IL_0023, + IL_0026) + IL_001b: br.s IL_0029 + + IL_001d: nop + IL_001e: br.s IL_002e + + IL_0020: nop + IL_0021: br.s IL_002c + + IL_0023: nop + IL_0024: br.s IL_002a + + IL_0026: nop + IL_0027: br.s IL_002e + + IL_0029: nop + IL_002a: ldc.i4.0 + IL_002b: ret + + IL_002c: ldc.i4.0 + IL_002d: ret + + IL_002e: ldc.i4.0 + IL_002f: ret + } + + .method public strict virtual instance int32 get_LastGenerated() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0006: ret + } + + .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32, + int32) + IL_0007: ret + } + + } + + .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f1() cil managed + { + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32, + int32) + IL_0007: ret + } + + } + +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest2 + extends [runtime]System.Object +{ + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 3 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0) + IL_0000: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2::f1() + IL_0005: stloc.0 + IL_0006: ldloc.0 + IL_0007: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_000c: pop + IL_000d: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOn.il.bsl new file mode 100644 index 00000000000..c667f5ac064 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOn.il.bsl @@ -0,0 +1,291 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest2 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class abstract auto ansi sealed nested public SeqExpressionSteppingTest2 + extends [runtime]System.Object + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class auto autochar serializable sealed nested assembly beforefieldinit specialname f1@5 + extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) + .field public int32 pc + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 current + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public specialname rtspecialname + instance void .ctor(int32 pc, + int32 current) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_000e: ldarg.0 + IL_000f: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0014: ret + } + + .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed + { + + .maxstack 6 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch ( + IL_001b, + IL_001e, + IL_0021) + IL_0019: br.s IL_0024 + + IL_001b: nop + IL_001c: br.s IL_0045 + + IL_001e: nop + IL_001f: br.s IL_0065 + + IL_0021: nop + IL_0022: br.s IL_006c + + IL_0024: nop + IL_0025: ldstr "hello" + IL_002a: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_002f: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0034: pop + IL_0035: ldarg.0 + IL_0036: ldc.i4.1 + IL_0037: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_003c: ldarg.0 + IL_003d: ldc.i4.1 + IL_003e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0043: ldc.i4.1 + IL_0044: ret + + IL_0045: ldstr "goodbye" + IL_004a: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_004f: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0054: pop + IL_0055: ldarg.0 + IL_0056: ldc.i4.2 + IL_0057: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_005c: ldarg.0 + IL_005d: ldc.i4.2 + IL_005e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0063: ldc.i4.1 + IL_0064: ret + + IL_0065: ldarg.0 + IL_0066: ldc.i4.3 + IL_0067: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_006c: ldarg.0 + IL_006d: ldc.i4.0 + IL_006e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0073: ldc.i4.0 + IL_0074: ret + } + + .method public strict virtual instance void Close() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldc.i4.3 + IL_0002: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0007: ret + } + + .method public strict virtual instance bool get_CheckClose() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc + IL_0006: switch ( + IL_001d, + IL_0020, + IL_0023, + IL_0026) + IL_001b: br.s IL_0029 + + IL_001d: nop + IL_001e: br.s IL_002e + + IL_0020: nop + IL_0021: br.s IL_002c + + IL_0023: nop + IL_0024: br.s IL_002a + + IL_0026: nop + IL_0027: br.s IL_002e + + IL_0029: nop + IL_002a: ldc.i4.0 + IL_002b: ret + + IL_002c: ldc.i4.0 + IL_002d: ret + + IL_002e: ldc.i4.0 + IL_002f: ret + } + + .method public strict virtual instance int32 get_LastGenerated() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current + IL_0006: ret + } + + .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32, + int32) + IL_0007: ret + } + + } + + .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f1() cil managed + { + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32, + int32) + IL_0007: ret + } + + .method private specialname rtspecialname static void .cctor() cil managed + { + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest2::init@ + IL_0006: ldsfld int32 ''.$SeqExpressionSteppingTest2::init@ + IL_000b: pop + IL_000c: ret + } + + .method assembly specialname static void staticInitialization@() cil managed + { + + .maxstack 3 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0) + IL_0000: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2::f1() + IL_0005: stloc.0 + IL_0006: ldloc.0 + IL_0007: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_000c: pop + IL_000d: ret + } + + } + + .method private specialname rtspecialname static void .cctor() cil managed + { + + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest2::init@ + IL_0006: ldsfld int32 ''.$SeqExpressionSteppingTest2::init@ + IL_000b: pop + IL_000c: ret + } + + .method assembly specialname static void staticInitialization@() cil managed + { + + .maxstack 8 + IL_0000: call void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2::staticInitialization@() + IL_0005: ret + } + +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest2 + extends [runtime]System.Object +{ + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 8 + IL_0000: call void SeqExpressionSteppingTest2::staticInitialization@() + IL_0005: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOff.il.bsl new file mode 100644 index 00000000000..61bdc63be2d --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOff.il.bsl @@ -0,0 +1,261 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest3 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class abstract auto ansi sealed nested public SeqExpressionSteppingTest3 + extends [runtime]System.Object + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class auto autochar serializable sealed nested assembly beforefieldinit specialname f2@7 + extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) + .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 x + .field public int32 pc + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 current + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public specialname rtspecialname + instance void .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 x, + int32 pc, + int32 current) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc + IL_000e: ldarg.0 + IL_000f: ldarg.3 + IL_0010: stfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current + IL_0015: ldarg.0 + IL_0016: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_001b: ret + } + + .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed + { + + .maxstack 7 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch ( + IL_0017, + IL_001a) + IL_0015: br.s IL_001d + + IL_0017: nop + IL_0018: br.s IL_0062 + + IL_001a: nop + IL_001b: br.s IL_0077 + + IL_001d: nop + IL_001e: br.s IL_0062 + + IL_0020: ldarg.0 + IL_0021: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x + IL_0026: ldarg.0 + IL_0027: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x + IL_002c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: call instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::set_contents(!0) + IL_0038: ldstr "hello" + IL_003d: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_0042: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0047: pop + IL_0048: ldarg.0 + IL_0049: ldc.i4.1 + IL_004a: stfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc + IL_004f: ldarg.0 + IL_0050: ldarg.0 + IL_0051: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x + IL_0056: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_005b: stfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current + IL_0060: ldc.i4.1 + IL_0061: ret + + IL_0062: ldarg.0 + IL_0063: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x + IL_0068: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_006d: ldc.i4.4 + IL_006e: blt.s IL_0020 + + IL_0070: ldarg.0 + IL_0071: ldc.i4.2 + IL_0072: stfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc + IL_0077: ldarg.0 + IL_0078: ldc.i4.0 + IL_0079: stfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current + IL_007e: ldc.i4.0 + IL_007f: ret + } + + .method public strict virtual instance void Close() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldc.i4.2 + IL_0002: stfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc + IL_0007: ret + } + + .method public strict virtual instance bool get_CheckClose() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc + IL_0006: switch ( + IL_0019, + IL_001c, + IL_001f) + IL_0017: br.s IL_0022 + + IL_0019: nop + IL_001a: br.s IL_0025 + + IL_001c: nop + IL_001d: br.s IL_0023 + + IL_001f: nop + IL_0020: br.s IL_0025 + + IL_0022: nop + IL_0023: ldc.i4.0 + IL_0024: ret + + IL_0025: ldc.i4.0 + IL_0026: ret + } + + .method public strict virtual instance int32 get_LastGenerated() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current + IL_0006: ret + } + + .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x + IL_0006: ldc.i4.0 + IL_0007: ldc.i4.0 + IL_0008: newobj instance void SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + int32, + int32) + IL_000d: ret + } + + } + + .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f2() cil managed + { + + .maxstack 5 + .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 V_0) + IL_0000: ldc.i4.0 + IL_0001: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::.ctor(!0) + IL_0006: stloc.0 + IL_0007: ldloc.0 + IL_0008: ldc.i4.0 + IL_0009: ldc.i4.0 + IL_000a: newobj instance void SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + int32, + int32) + IL_000f: ret + } + + } + +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest3 + extends [runtime]System.Object +{ + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 3 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0) + IL_0000: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3::f2() + IL_0005: stloc.0 + IL_0006: ldloc.0 + IL_0007: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_000c: pop + IL_000d: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOn.il.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.il.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOn.il.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOff.il.bsl new file mode 100644 index 00000000000..7a56bcf3e94 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOff.il.bsl @@ -0,0 +1,304 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest4 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class abstract auto ansi sealed nested public SeqExpressionSteppingTest4 + extends [runtime]System.Object + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class auto autochar serializable sealed nested assembly beforefieldinit specialname f3@6 + extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) + .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 x + .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 y + .field public int32 pc + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 current + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public specialname rtspecialname + instance void .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 x, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 y, + int32 pc, + int32 current) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y + IL_000e: ldarg.0 + IL_000f: ldarg.3 + IL_0010: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc + IL_0015: ldarg.0 + IL_0016: ldarg.s current + IL_0018: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current + IL_001d: ldarg.0 + IL_001e: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0023: ret + } + + .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed + { + + .maxstack 7 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch ( + IL_001b, + IL_001e, + IL_0024) + IL_0019: br.s IL_002a + + IL_001b: nop + IL_001c: br.s IL_008d + + IL_001e: nop + IL_001f: br IL_00b5 + + IL_0024: nop + IL_0025: br IL_00ca + + IL_002a: nop + IL_002b: ldarg.0 + IL_002c: ldc.i4.0 + IL_002d: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::.ctor(!0) + IL_0032: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x + IL_0037: ldarg.0 + IL_0038: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x + IL_003d: ldarg.0 + IL_003e: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x + IL_0043: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_0048: ldc.i4.1 + IL_0049: add + IL_004a: call instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::set_contents(!0) + IL_004f: ldarg.0 + IL_0050: ldc.i4.0 + IL_0051: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::.ctor(!0) + IL_0056: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y + IL_005b: ldarg.0 + IL_005c: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y + IL_0061: ldarg.0 + IL_0062: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y + IL_0067: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_006c: ldc.i4.1 + IL_006d: add + IL_006e: call instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::set_contents(!0) + IL_0073: ldarg.0 + IL_0074: ldc.i4.1 + IL_0075: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc + IL_007a: ldarg.0 + IL_007b: ldarg.0 + IL_007c: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x + IL_0081: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_0086: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current + IL_008b: ldc.i4.1 + IL_008c: ret + + IL_008d: ldarg.0 + IL_008e: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x + IL_0093: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_0098: ldarg.0 + IL_0099: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y + IL_009e: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_00a3: add + IL_00a4: stloc.0 + IL_00a5: ldarg.0 + IL_00a6: ldc.i4.2 + IL_00a7: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc + IL_00ac: ldarg.0 + IL_00ad: ldloc.0 + IL_00ae: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current + IL_00b3: ldc.i4.1 + IL_00b4: ret + + IL_00b5: ldarg.0 + IL_00b6: ldnull + IL_00b7: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y + IL_00bc: ldarg.0 + IL_00bd: ldnull + IL_00be: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x + IL_00c3: ldarg.0 + IL_00c4: ldc.i4.3 + IL_00c5: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc + IL_00ca: ldarg.0 + IL_00cb: ldc.i4.0 + IL_00cc: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current + IL_00d1: ldc.i4.0 + IL_00d2: ret + } + + .method public strict virtual instance void Close() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldc.i4.3 + IL_0002: stfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc + IL_0007: ret + } + + .method public strict virtual instance bool get_CheckClose() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc + IL_0006: switch ( + IL_001d, + IL_0020, + IL_0023, + IL_0026) + IL_001b: br.s IL_0029 + + IL_001d: nop + IL_001e: br.s IL_002e + + IL_0020: nop + IL_0021: br.s IL_002c + + IL_0023: nop + IL_0024: br.s IL_002a + + IL_0026: nop + IL_0027: br.s IL_002e + + IL_0029: nop + IL_002a: ldc.i4.0 + IL_002b: ret + + IL_002c: ldc.i4.0 + IL_002d: ret + + IL_002e: ldc.i4.0 + IL_002f: ret + } + + .method public strict virtual instance int32 get_LastGenerated() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current + IL_0006: ret + } + + .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldnull + IL_0001: ldnull + IL_0002: ldc.i4.0 + IL_0003: ldc.i4.0 + IL_0004: newobj instance void SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + int32, + int32) + IL_0009: ret + } + + } + + .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f3() cil managed + { + + .maxstack 8 + IL_0000: ldnull + IL_0001: ldnull + IL_0002: ldc.i4.0 + IL_0003: ldc.i4.0 + IL_0004: newobj instance void SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + int32, + int32) + IL_0009: ret + } + + } + +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest4 + extends [runtime]System.Object +{ + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 3 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0) + IL_0000: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4::f3() + IL_0005: stloc.0 + IL_0006: ldloc.0 + IL_0007: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_000c: pop + IL_000d: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOn.il.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.il.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOn.il.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOff.il.bsl new file mode 100644 index 00000000000..dcf9a44b123 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOff.il.bsl @@ -0,0 +1,411 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest5 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class abstract auto ansi sealed nested public SeqExpressionSteppingTest5 + extends [runtime]System.Object + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class auto autochar serializable sealed nested assembly beforefieldinit specialname f4@6 + extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) + .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 x + .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 y + .field public int32 pc + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 current + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public specialname rtspecialname + instance void .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 x, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 y, + int32 pc, + int32 current) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y + IL_000e: ldarg.0 + IL_000f: ldarg.3 + IL_0010: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0015: ldarg.0 + IL_0016: ldarg.s current + IL_0018: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current + IL_001d: ldarg.0 + IL_001e: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0023: ret + } + + .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed + { + + .maxstack 7 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch ( + IL_001f, + IL_0025, + IL_0028, + IL_002e) + IL_001d: br.s IL_0034 + + IL_001f: nop + IL_0020: br IL_00b5 + + IL_0025: nop + IL_0026: br.s IL_0086 + + IL_0028: nop + IL_0029: br IL_00ae + + IL_002e: nop + IL_002f: br IL_00f2 + + IL_0034: nop + IL_0035: ldarg.0 + IL_0036: ldc.i4.0 + IL_0037: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::.ctor(!0) + IL_003c: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_0041: ldarg.0 + IL_0042: ldc.i4.1 + IL_0043: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0048: ldarg.0 + IL_0049: ldc.i4.0 + IL_004a: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::.ctor(!0) + IL_004f: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y + IL_0054: ldarg.0 + IL_0055: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y + IL_005a: ldarg.0 + IL_005b: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y + IL_0060: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_0065: ldc.i4.1 + IL_0066: add + IL_0067: call instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::set_contents(!0) + IL_006c: ldarg.0 + IL_006d: ldc.i4.2 + IL_006e: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0073: ldarg.0 + IL_0074: ldarg.0 + IL_0075: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_007a: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_007f: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current + IL_0084: ldc.i4.1 + IL_0085: ret + + IL_0086: ldarg.0 + IL_0087: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_008c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_0091: ldarg.0 + IL_0092: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y + IL_0097: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_009c: add + IL_009d: stloc.0 + IL_009e: ldarg.0 + IL_009f: ldc.i4.3 + IL_00a0: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_00a5: ldarg.0 + IL_00a6: ldloc.0 + IL_00a7: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current + IL_00ac: ldc.i4.1 + IL_00ad: ret + + IL_00ae: ldarg.0 + IL_00af: ldnull + IL_00b0: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y + IL_00b5: ldarg.0 + IL_00b6: ldc.i4.4 + IL_00b7: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_00bc: ldarg.0 + IL_00bd: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_00c2: ldarg.0 + IL_00c3: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_00c8: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_00cd: ldc.i4.1 + IL_00ce: add + IL_00cf: call instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::set_contents(!0) + IL_00d4: ldstr "done" + IL_00d9: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_00de: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_00e3: pop + IL_00e4: ldarg.0 + IL_00e5: ldnull + IL_00e6: stfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_00eb: ldarg.0 + IL_00ec: ldc.i4.4 + IL_00ed: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_00f2: ldarg.0 + IL_00f3: ldc.i4.0 + IL_00f4: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current + IL_00f9: ldc.i4.0 + IL_00fa: ret + } + + .method public strict virtual instance void Close() cil managed + { + + .maxstack 7 + .locals init (class [runtime]System.Exception V_0, + class [runtime]System.Exception V_1) + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0006: ldc.i4.4 + IL_0007: sub + IL_0008: switch ( + IL_0013) + IL_0011: br.s IL_0019 + + IL_0013: nop + IL_0014: br IL_009f + + IL_0019: nop + .try + { + IL_001a: ldarg.0 + IL_001b: ldfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0020: switch ( + IL_003b, + IL_003e, + IL_0041, + IL_0044, + IL_0047) + IL_0039: br.s IL_004a + + IL_003b: nop + IL_003c: br.s IL_007f + + IL_003e: nop + IL_003f: br.s IL_004f + + IL_0041: nop + IL_0042: br.s IL_004e + + IL_0044: nop + IL_0045: br.s IL_004b + + IL_0047: nop + IL_0048: br.s IL_007f + + IL_004a: nop + IL_004b: nop + IL_004c: br.s IL_004f + + IL_004e: nop + IL_004f: ldarg.0 + IL_0050: ldc.i4.4 + IL_0051: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0056: ldarg.0 + IL_0057: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_005c: ldarg.0 + IL_005d: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x + IL_0062: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::get_contents() + IL_0067: ldc.i4.1 + IL_0068: add + IL_0069: call instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1::set_contents(!0) + IL_006e: ldstr "done" + IL_0073: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_0078: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_007d: pop + IL_007e: nop + IL_007f: ldarg.0 + IL_0080: ldc.i4.4 + IL_0081: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0086: ldarg.0 + IL_0087: ldc.i4.0 + IL_0088: stfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current + IL_008d: leave.s IL_0099 + + } + catch [runtime]System.Object + { + IL_008f: castclass [runtime]System.Exception + IL_0094: stloc.1 + IL_0095: ldloc.1 + IL_0096: stloc.0 + IL_0097: leave.s IL_0099 + + } + IL_0099: nop + IL_009a: br IL_0000 + + IL_009f: ldloc.0 + IL_00a0: brfalse.s IL_00a4 + + IL_00a2: ldloc.0 + IL_00a3: throw + + IL_00a4: ret + } + + .method public strict virtual instance bool get_CheckClose() cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc + IL_0006: switch ( + IL_0021, + IL_0024, + IL_0027, + IL_002a, + IL_002d) + IL_001f: br.s IL_0030 + + IL_0021: nop + IL_0022: br.s IL_0037 + + IL_0024: nop + IL_0025: br.s IL_0035 + + IL_0027: nop + IL_0028: br.s IL_0033 + + IL_002a: nop + IL_002b: br.s IL_0031 + + IL_002d: nop + IL_002e: br.s IL_0037 + + IL_0030: nop + IL_0031: ldc.i4.1 + IL_0032: ret + + IL_0033: ldc.i4.1 + IL_0034: ret + + IL_0035: ldc.i4.1 + IL_0036: ret + + IL_0037: ldc.i4.0 + IL_0038: ret + } + + .method public strict virtual instance int32 get_LastGenerated() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current + IL_0006: ret + } + + .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldnull + IL_0001: ldnull + IL_0002: ldc.i4.0 + IL_0003: ldc.i4.0 + IL_0004: newobj instance void SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + int32, + int32) + IL_0009: ret + } + + } + + .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f4() cil managed + { + + .maxstack 8 + IL_0000: ldnull + IL_0001: ldnull + IL_0002: ldc.i4.0 + IL_0003: ldc.i4.0 + IL_0004: newobj instance void SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1, + int32, + int32) + IL_0009: ret + } + + } + +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest5 + extends [runtime]System.Object +{ + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 3 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0) + IL_0000: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5::f4() + IL_0005: stloc.0 + IL_0006: ldloc.0 + IL_0007: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_000c: pop + IL_000d: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOn.il.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.il.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOn.il.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOff.il.bsl new file mode 100644 index 00000000000..e7288a13fd6 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOff.il.bsl @@ -0,0 +1,477 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest6 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class abstract auto ansi sealed nested public SeqExpressionSteppingTest6 + extends [runtime]System.Object + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .class auto autochar serializable sealed nested assembly beforefieldinit specialname f7@6 + extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) + .field public class [runtime]System.Collections.Generic.IEnumerator`1 'enum' + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public class [runtime]System.Collections.Generic.IEnumerator`1 enum0 + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 pc + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .field public int32 current + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public specialname rtspecialname + instance void .ctor(class [runtime]System.Collections.Generic.IEnumerator`1 'enum', + class [runtime]System.Collections.Generic.IEnumerator`1 enum0, + int32 pc, + int32 current) cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum' + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0 + IL_000e: ldarg.0 + IL_000f: ldarg.3 + IL_0010: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0015: ldarg.0 + IL_0016: ldarg.s current + IL_0018: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current + IL_001d: ldarg.0 + IL_001e: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0023: ret + } + + .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed + { + + .maxstack 6 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch ( + IL_0023, + IL_0026, + IL_0029, + IL_002f, + IL_0035) + IL_0021: br.s IL_003b + + IL_0023: nop + IL_0024: br.s IL_008e + + IL_0026: nop + IL_0027: br.s IL_0081 + + IL_0029: nop + IL_002a: br IL_00fa + + IL_002f: nop + IL_0030: br IL_00ed + + IL_0035: nop + IL_0036: br IL_011b + + IL_003b: nop + IL_003c: ldarg.0 + IL_003d: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::get_es() + IL_0042: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0047: stfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum' + IL_004c: ldarg.0 + IL_004d: ldc.i4.1 + IL_004e: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0053: br.s IL_0081 + + IL_0055: ldarg.0 + IL_0056: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum' + IL_005b: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0060: stloc.0 + IL_0061: ldstr "hello" + IL_0066: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_006b: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0070: pop + IL_0071: ldarg.0 + IL_0072: ldc.i4.2 + IL_0073: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0078: ldarg.0 + IL_0079: ldloc.0 + IL_007a: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current + IL_007f: ldc.i4.1 + IL_0080: ret + + IL_0081: ldarg.0 + IL_0082: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum' + IL_0087: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_008c: brtrue.s IL_0055 + + IL_008e: ldarg.0 + IL_008f: ldc.i4.5 + IL_0090: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0095: ldarg.0 + IL_0096: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum' + IL_009b: call void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose>(!!0) + IL_00a0: nop + IL_00a1: ldarg.0 + IL_00a2: ldnull + IL_00a3: stfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum' + IL_00a8: ldarg.0 + IL_00a9: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::get_es() + IL_00ae: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_00b3: stfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0 + IL_00b8: ldarg.0 + IL_00b9: ldc.i4.3 + IL_00ba: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_00bf: br.s IL_00ed + + IL_00c1: ldarg.0 + IL_00c2: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0 + IL_00c7: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_00cc: stloc.1 + IL_00cd: ldstr "goodbye" + IL_00d2: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_00d7: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_00dc: pop + IL_00dd: ldarg.0 + IL_00de: ldc.i4.4 + IL_00df: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_00e4: ldarg.0 + IL_00e5: ldloc.1 + IL_00e6: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current + IL_00eb: ldc.i4.1 + IL_00ec: ret + + IL_00ed: ldarg.0 + IL_00ee: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0 + IL_00f3: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_00f8: brtrue.s IL_00c1 + + IL_00fa: ldarg.0 + IL_00fb: ldc.i4.5 + IL_00fc: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0101: ldarg.0 + IL_0102: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0 + IL_0107: call void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose>(!!0) + IL_010c: nop + IL_010d: ldarg.0 + IL_010e: ldnull + IL_010f: stfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0 + IL_0114: ldarg.0 + IL_0115: ldc.i4.5 + IL_0116: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_011b: ldarg.0 + IL_011c: ldc.i4.0 + IL_011d: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current + IL_0122: ldc.i4.0 + IL_0123: ret + } + + .method public strict virtual instance void Close() cil managed + { + + .maxstack 6 + .locals init (class [runtime]System.Exception V_0, + class [runtime]System.Exception V_1) + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: switch ( + IL_0013) + IL_0011: br.s IL_0019 + + IL_0013: nop + IL_0014: br IL_009e + + IL_0019: nop + .try + { + IL_001a: ldarg.0 + IL_001b: ldfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0020: switch ( + IL_003f, + IL_0042, + IL_0045, + IL_0048, + IL_004b, + IL_004e) + IL_003d: br.s IL_0051 + + IL_003f: nop + IL_0040: br.s IL_007e + + IL_0042: nop + IL_0043: br.s IL_006a + + IL_0045: nop + IL_0046: br.s IL_0069 + + IL_0048: nop + IL_0049: br.s IL_0053 + + IL_004b: nop + IL_004c: br.s IL_0052 + + IL_004e: nop + IL_004f: br.s IL_007e + + IL_0051: nop + IL_0052: nop + IL_0053: ldarg.0 + IL_0054: ldc.i4.5 + IL_0055: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_005a: ldarg.0 + IL_005b: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0 + IL_0060: call void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose>(!!0) + IL_0065: nop + IL_0066: nop + IL_0067: br.s IL_007e + + IL_0069: nop + IL_006a: ldarg.0 + IL_006b: ldc.i4.5 + IL_006c: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0071: ldarg.0 + IL_0072: ldfld class [runtime]System.Collections.Generic.IEnumerator`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum' + IL_0077: call void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose>(!!0) + IL_007c: nop + IL_007d: nop + IL_007e: ldarg.0 + IL_007f: ldc.i4.5 + IL_0080: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0085: ldarg.0 + IL_0086: ldc.i4.0 + IL_0087: stfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current + IL_008c: leave.s IL_0098 + + } + catch [runtime]System.Object + { + IL_008e: castclass [runtime]System.Exception + IL_0093: stloc.1 + IL_0094: ldloc.1 + IL_0095: stloc.0 + IL_0096: leave.s IL_0098 + + } + IL_0098: nop + IL_0099: br IL_0000 + + IL_009e: ldloc.0 + IL_009f: brfalse.s IL_00a3 + + IL_00a1: ldloc.0 + IL_00a2: throw + + IL_00a3: ret + } + + .method public strict virtual instance bool get_CheckClose() cil managed + { + + .maxstack 5 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc + IL_0006: switch ( + IL_0025, + IL_0028, + IL_002b, + IL_002e, + IL_0031, + IL_0034) + IL_0023: br.s IL_0037 + + IL_0025: nop + IL_0026: br.s IL_0040 + + IL_0028: nop + IL_0029: br.s IL_003e + + IL_002b: nop + IL_002c: br.s IL_003c + + IL_002e: nop + IL_002f: br.s IL_003a + + IL_0031: nop + IL_0032: br.s IL_0038 + + IL_0034: nop + IL_0035: br.s IL_0040 + + IL_0037: nop + IL_0038: ldc.i4.1 + IL_0039: ret + + IL_003a: ldc.i4.1 + IL_003b: ret + + IL_003c: ldc.i4.1 + IL_003d: ret + + IL_003e: ldc.i4.1 + IL_003f: ret + + IL_0040: ldc.i4.0 + IL_0041: ret + } + + .method public strict virtual instance int32 get_LastGenerated() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current + IL_0006: ret + } + + .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed + { + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + + .maxstack 8 + IL_0000: ldnull + IL_0001: ldnull + IL_0002: ldc.i4.0 + IL_0003: ldc.i4.0 + IL_0004: newobj instance void SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1, + class [runtime]System.Collections.Generic.IEnumerator`1, + int32, + int32) + IL_0009: ret + } + + } + + .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 get_es() cil managed + { + + .maxstack 8 + IL_0000: ldsfld class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 ''.$SeqExpressionSteppingTest6::es@4 + IL_0005: ret + } + + .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f7() cil managed + { + + .maxstack 8 + IL_0000: ldnull + IL_0001: ldnull + IL_0002: ldc.i4.0 + IL_0003: ldc.i4.0 + IL_0004: newobj instance void SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1, + class [runtime]System.Collections.Generic.IEnumerator`1, + int32, + int32) + IL_0009: ret + } + + .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 + es() + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) + .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::get_es() + } + } + +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest6 + extends [runtime]System.Object +{ + .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 es@4 + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 6 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [runtime]System.Collections.Generic.IEnumerable`1 V_1) + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: ldc.i4.3 + IL_0003: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_0008: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::Cons(!0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1) + IL_000d: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::Cons(!0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1) + IL_0012: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::Cons(!0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1) + IL_0017: dup + IL_0018: stsfld class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 ''.$SeqExpressionSteppingTest6::es@4 + IL_001d: stloc.0 + IL_001e: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::f7() + IL_0023: stloc.1 + IL_0024: ldloc.1 + IL_0025: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_002a: pop + IL_002b: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOn.il.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.il.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOn.il.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.debug.bsl new file mode 100644 index 00000000000..86cc7e04485 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.debug.bsl @@ -0,0 +1,811 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .method public specialname static int32 get_r() cil managed + { + + .maxstack 8 + IL_0000: ldsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0005: ret + } + + .method public specialname static void set_r(int32 'value') cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 f() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + string V_1) + IL_0000: nop + IL_0001: nop + IL_0002: call int32 SeqExpressionSteppingTest7::get_r() + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: call void SeqExpressionSteppingTest7::set_r(int32) + IL_000e: ldc.i4.1 + IL_000f: brfalse.s IL_0034 + + IL_0011: ldstr "" + IL_0016: stloc.1 + IL_0017: ldloca.s V_0 + IL_0019: ldc.i4.0 + IL_001a: brfalse.s IL_0024 + + IL_001c: ldnull + IL_001d: unbox.any class [runtime]System.Collections.Generic.IEnumerable`1 + IL_0022: br.s IL_002b + + IL_0024: ldloc.1 + IL_0025: call class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string) + IL_002a: throw + + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_0030: nop + IL_0031: nop + IL_0032: br.s IL_0035 + + IL_0034: nop + IL_0035: ldloca.s V_0 + IL_0037: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_003c: ret + } + + .method public static void testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_001d + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldloc.1 + IL_001e: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0023: brtrue.s IL_000b + + IL_0025: leave.s IL_0039 + + } + finally + { + IL_0027: ldloc.1 + IL_0028: isinst [runtime]System.IDisposable + IL_002d: stloc.3 + IL_002e: ldloc.3 + IL_002f: brfalse.s IL_0038 + + IL_0031: ldloc.3 + IL_0032: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0037: endfinally + IL_0038: endfinally + } + IL_0039: ret + } + + .method public static void testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_0028 + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldstr "{0}" + IL_0022: ldloc.2 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_0028: ldloc.1 + IL_0029: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002e: brtrue.s IL_000b + + IL_0030: leave.s IL_0044 + + } + finally + { + IL_0032: ldloc.1 + IL_0033: isinst [runtime]System.IDisposable + IL_0038: stloc.3 + IL_0039: ldloc.3 + IL_003a: brfalse.s IL_0043 + + IL_003c: ldloc.3 + IL_003d: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0042: endfinally + IL_0043: endfinally + } + IL_0044: ret + } + + .method public static void testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0022 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldloc.1 + IL_001f: ldc.i4.1 + IL_0020: add + IL_0021: stloc.1 + IL_0022: ldloc.1 + IL_0023: ldloc.0 + IL_0024: ldlen + IL_0025: conv.i4 + IL_0026: blt.s IL_0006 + + IL_0028: ret + } + + .method public static void testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0032 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldstr "{0}" + IL_0023: ldloc.2 + IL_0024: box [runtime]System.Int32 + IL_0029: call void [runtime]System.Console::WriteLine(string, + object) + IL_002e: ldloc.1 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: stloc.1 + IL_0032: ldloc.1 + IL_0033: ldloc.0 + IL_0034: ldlen + IL_0035: conv.i4 + IL_0036: blt.s IL_0006 + + IL_0038: ret + } + + .method public static void testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_002b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldloc.1 + IL_0023: stloc.0 + IL_0024: ldloc.0 + IL_0025: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_002a: stloc.1 + IL_002b: ldloc.1 + IL_002c: brtrue.s IL_000b + + IL_002e: ret + } + + .method public static void testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_003b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldstr "{0}" + IL_0027: ldloc.2 + IL_0028: box [runtime]System.Int32 + IL_002d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0032: ldloc.1 + IL_0033: stloc.0 + IL_0034: ldloc.0 + IL_0035: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_003a: stloc.1 + IL_003b: ldloc.1 + IL_003c: brtrue.s IL_000b + + IL_003e: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0029 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldloc.1 + IL_002a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002f: brtrue.s IL_0012 + + IL_0031: leave.s IL_0045 + + } + finally + { + IL_0033: ldloc.1 + IL_0034: isinst [runtime]System.IDisposable + IL_0039: stloc.3 + IL_003a: ldloc.3 + IL_003b: brfalse.s IL_0044 + + IL_003d: ldloc.3 + IL_003e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0043: endfinally + IL_0044: endfinally + } + IL_0045: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0039 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldstr "{0}" + IL_002e: ldloc.2 + IL_002f: box [runtime]System.Int32 + IL_0034: call void [runtime]System.Console::WriteLine(string, + object) + IL_0039: ldloc.1 + IL_003a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_003f: brtrue.s IL_0012 + + IL_0041: leave.s IL_0055 + + } + finally + { + IL_0043: ldloc.1 + IL_0044: isinst [runtime]System.IDisposable + IL_0049: stloc.3 + IL_004a: ldloc.3 + IL_004b: brfalse.s IL_0054 + + IL_004d: ldloc.3 + IL_004e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0053: endfinally + IL_0054: endfinally + } + IL_0055: ret + } + + .method public static void testSimpleForEachIntLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: sub + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: sub + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: sub + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 ListExpressionSteppingTest7() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + class [runtime]System.Collections.Generic.IEnumerable`1 V_2, + int32 V_3, + class [runtime]System.IDisposable V_4) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: ldc.i4.1 + IL_0003: ldc.i4.4 + IL_0004: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0009: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000e: stloc.1 + .try + { + IL_000f: br.s IL_0031 + + IL_0011: ldloc.1 + IL_0012: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0017: stloc.3 + IL_0018: ldstr "hello" + IL_001d: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_0022: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0027: pop + IL_0028: ldloca.s V_0 + IL_002a: ldloc.3 + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Add(!0) + IL_0030: nop + IL_0031: ldloc.1 + IL_0032: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0037: brtrue.s IL_0011 + + IL_0039: ldnull + IL_003a: stloc.2 + IL_003b: leave.s IL_0052 + + } + finally + { + IL_003d: ldloc.1 + IL_003e: isinst [runtime]System.IDisposable + IL_0043: stloc.s V_4 + IL_0045: ldloc.s V_4 + IL_0047: brfalse.s IL_0051 + + IL_0049: ldloc.s V_4 + IL_004b: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0050: endfinally + IL_0051: endfinally + } + IL_0052: ldloc.2 + IL_0053: pop + IL_0054: ldloca.s V_0 + IL_0056: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_005b: ret + } + + .property int32 r() + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) + .set void SeqExpressionSteppingTest7::set_r(int32) + .get int32 SeqExpressionSteppingTest7::get_r() + } +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .field static assembly int32 r@4 + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + class [runtime]System.Exception V_2, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 V_3) + IL_0000: ldc.i4.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ldstr "res = %A" + IL_000b: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1>::.ctor(string) + IL_0010: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0015: stloc.0 + .try + { + IL_0016: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 SeqExpressionSteppingTest7::f() + IL_001b: stloc.1 + IL_001c: leave.s IL_004b + + } + catch [runtime]System.Object + { + IL_001e: castclass [runtime]System.Exception + IL_0023: stloc.2 + IL_0024: ldloc.2 + IL_0025: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception) + IL_002a: stloc.3 + IL_002b: ldloc.3 + IL_002c: brfalse.s IL_0040 + + IL_002e: call int32 SeqExpressionSteppingTest7::get_r() + IL_0033: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_0038: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::Cons(!0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1) + IL_003d: stloc.1 + IL_003e: leave.s IL_004b + + IL_0040: rethrow + IL_0042: ldnull + IL_0043: unbox.any class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 + IL_0048: stloc.1 + IL_0049: leave.s IL_004b + + } + IL_004b: ldloc.0 + IL_004c: ldloc.1 + IL_004d: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0) + IL_0052: pop + IL_0053: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.release.bsl new file mode 100644 index 00000000000..86cc7e04485 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.release.bsl @@ -0,0 +1,811 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .method public specialname static int32 get_r() cil managed + { + + .maxstack 8 + IL_0000: ldsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0005: ret + } + + .method public specialname static void set_r(int32 'value') cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 f() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + string V_1) + IL_0000: nop + IL_0001: nop + IL_0002: call int32 SeqExpressionSteppingTest7::get_r() + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: call void SeqExpressionSteppingTest7::set_r(int32) + IL_000e: ldc.i4.1 + IL_000f: brfalse.s IL_0034 + + IL_0011: ldstr "" + IL_0016: stloc.1 + IL_0017: ldloca.s V_0 + IL_0019: ldc.i4.0 + IL_001a: brfalse.s IL_0024 + + IL_001c: ldnull + IL_001d: unbox.any class [runtime]System.Collections.Generic.IEnumerable`1 + IL_0022: br.s IL_002b + + IL_0024: ldloc.1 + IL_0025: call class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string) + IL_002a: throw + + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_0030: nop + IL_0031: nop + IL_0032: br.s IL_0035 + + IL_0034: nop + IL_0035: ldloca.s V_0 + IL_0037: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_003c: ret + } + + .method public static void testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_001d + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldloc.1 + IL_001e: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0023: brtrue.s IL_000b + + IL_0025: leave.s IL_0039 + + } + finally + { + IL_0027: ldloc.1 + IL_0028: isinst [runtime]System.IDisposable + IL_002d: stloc.3 + IL_002e: ldloc.3 + IL_002f: brfalse.s IL_0038 + + IL_0031: ldloc.3 + IL_0032: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0037: endfinally + IL_0038: endfinally + } + IL_0039: ret + } + + .method public static void testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_0028 + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldstr "{0}" + IL_0022: ldloc.2 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_0028: ldloc.1 + IL_0029: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002e: brtrue.s IL_000b + + IL_0030: leave.s IL_0044 + + } + finally + { + IL_0032: ldloc.1 + IL_0033: isinst [runtime]System.IDisposable + IL_0038: stloc.3 + IL_0039: ldloc.3 + IL_003a: brfalse.s IL_0043 + + IL_003c: ldloc.3 + IL_003d: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0042: endfinally + IL_0043: endfinally + } + IL_0044: ret + } + + .method public static void testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0022 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldloc.1 + IL_001f: ldc.i4.1 + IL_0020: add + IL_0021: stloc.1 + IL_0022: ldloc.1 + IL_0023: ldloc.0 + IL_0024: ldlen + IL_0025: conv.i4 + IL_0026: blt.s IL_0006 + + IL_0028: ret + } + + .method public static void testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0032 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldstr "{0}" + IL_0023: ldloc.2 + IL_0024: box [runtime]System.Int32 + IL_0029: call void [runtime]System.Console::WriteLine(string, + object) + IL_002e: ldloc.1 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: stloc.1 + IL_0032: ldloc.1 + IL_0033: ldloc.0 + IL_0034: ldlen + IL_0035: conv.i4 + IL_0036: blt.s IL_0006 + + IL_0038: ret + } + + .method public static void testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_002b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldloc.1 + IL_0023: stloc.0 + IL_0024: ldloc.0 + IL_0025: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_002a: stloc.1 + IL_002b: ldloc.1 + IL_002c: brtrue.s IL_000b + + IL_002e: ret + } + + .method public static void testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_003b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldstr "{0}" + IL_0027: ldloc.2 + IL_0028: box [runtime]System.Int32 + IL_002d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0032: ldloc.1 + IL_0033: stloc.0 + IL_0034: ldloc.0 + IL_0035: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_003a: stloc.1 + IL_003b: ldloc.1 + IL_003c: brtrue.s IL_000b + + IL_003e: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0029 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldloc.1 + IL_002a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002f: brtrue.s IL_0012 + + IL_0031: leave.s IL_0045 + + } + finally + { + IL_0033: ldloc.1 + IL_0034: isinst [runtime]System.IDisposable + IL_0039: stloc.3 + IL_003a: ldloc.3 + IL_003b: brfalse.s IL_0044 + + IL_003d: ldloc.3 + IL_003e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0043: endfinally + IL_0044: endfinally + } + IL_0045: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0039 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldstr "{0}" + IL_002e: ldloc.2 + IL_002f: box [runtime]System.Int32 + IL_0034: call void [runtime]System.Console::WriteLine(string, + object) + IL_0039: ldloc.1 + IL_003a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_003f: brtrue.s IL_0012 + + IL_0041: leave.s IL_0055 + + } + finally + { + IL_0043: ldloc.1 + IL_0044: isinst [runtime]System.IDisposable + IL_0049: stloc.3 + IL_004a: ldloc.3 + IL_004b: brfalse.s IL_0054 + + IL_004d: ldloc.3 + IL_004e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0053: endfinally + IL_0054: endfinally + } + IL_0055: ret + } + + .method public static void testSimpleForEachIntLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: sub + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: sub + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: sub + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 ListExpressionSteppingTest7() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + class [runtime]System.Collections.Generic.IEnumerable`1 V_2, + int32 V_3, + class [runtime]System.IDisposable V_4) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: ldc.i4.1 + IL_0003: ldc.i4.4 + IL_0004: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0009: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000e: stloc.1 + .try + { + IL_000f: br.s IL_0031 + + IL_0011: ldloc.1 + IL_0012: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0017: stloc.3 + IL_0018: ldstr "hello" + IL_001d: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_0022: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0027: pop + IL_0028: ldloca.s V_0 + IL_002a: ldloc.3 + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Add(!0) + IL_0030: nop + IL_0031: ldloc.1 + IL_0032: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0037: brtrue.s IL_0011 + + IL_0039: ldnull + IL_003a: stloc.2 + IL_003b: leave.s IL_0052 + + } + finally + { + IL_003d: ldloc.1 + IL_003e: isinst [runtime]System.IDisposable + IL_0043: stloc.s V_4 + IL_0045: ldloc.s V_4 + IL_0047: brfalse.s IL_0051 + + IL_0049: ldloc.s V_4 + IL_004b: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0050: endfinally + IL_0051: endfinally + } + IL_0052: ldloc.2 + IL_0053: pop + IL_0054: ldloca.s V_0 + IL_0056: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_005b: ret + } + + .property int32 r() + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) + .set void SeqExpressionSteppingTest7::set_r(int32) + .get int32 SeqExpressionSteppingTest7::get_r() + } +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .field static assembly int32 r@4 + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + class [runtime]System.Exception V_2, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 V_3) + IL_0000: ldc.i4.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ldstr "res = %A" + IL_000b: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1>::.ctor(string) + IL_0010: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0015: stloc.0 + .try + { + IL_0016: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 SeqExpressionSteppingTest7::f() + IL_001b: stloc.1 + IL_001c: leave.s IL_004b + + } + catch [runtime]System.Object + { + IL_001e: castclass [runtime]System.Exception + IL_0023: stloc.2 + IL_0024: ldloc.2 + IL_0025: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception) + IL_002a: stloc.3 + IL_002b: ldloc.3 + IL_002c: brfalse.s IL_0040 + + IL_002e: call int32 SeqExpressionSteppingTest7::get_r() + IL_0033: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_0038: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::Cons(!0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1) + IL_003d: stloc.1 + IL_003e: leave.s IL_004b + + IL_0040: rethrow + IL_0042: ldnull + IL_0043: unbox.any class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 + IL_0048: stloc.1 + IL_0049: leave.s IL_004b + + } + IL_004b: ldloc.0 + IL_004c: ldloc.1 + IL_004d: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0) + IL_0052: pop + IL_0053: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.debug.bsl new file mode 100644 index 00000000000..bb5909fc008 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.debug.bsl @@ -0,0 +1,812 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly extern runtime { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .method public specialname static int32 get_r() cil managed + { + + .maxstack 8 + IL_0000: ldsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0005: ret + } + + .method public specialname static void set_r(int32 'value') cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 f() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + string V_1) + IL_0000: nop + IL_0001: nop + IL_0002: call int32 SeqExpressionSteppingTest7::get_r() + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: call void SeqExpressionSteppingTest7::set_r(int32) + IL_000e: ldc.i4.1 + IL_000f: brfalse.s IL_0034 + + IL_0011: ldstr "" + IL_0016: stloc.1 + IL_0017: ldloca.s V_0 + IL_0019: ldc.i4.0 + IL_001a: brfalse.s IL_0024 + + IL_001c: ldnull + IL_001d: unbox.any class [runtime]System.Collections.Generic.IEnumerable`1 + IL_0022: br.s IL_002b + + IL_0024: ldloc.1 + IL_0025: call class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string) + IL_002a: throw + + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_0030: nop + IL_0031: nop + IL_0032: br.s IL_0035 + + IL_0034: nop + IL_0035: ldloca.s V_0 + IL_0037: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_003c: ret + } + + .method public static void testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_001d + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldloc.1 + IL_001e: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0023: brtrue.s IL_000b + + IL_0025: leave.s IL_0039 + + } + finally + { + IL_0027: ldloc.1 + IL_0028: isinst [runtime]System.IDisposable + IL_002d: stloc.3 + IL_002e: ldloc.3 + IL_002f: brfalse.s IL_0038 + + IL_0031: ldloc.3 + IL_0032: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0037: endfinally + IL_0038: endfinally + } + IL_0039: ret + } + + .method public static void testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_0028 + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldstr "{0}" + IL_0022: ldloc.2 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_0028: ldloc.1 + IL_0029: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002e: brtrue.s IL_000b + + IL_0030: leave.s IL_0044 + + } + finally + { + IL_0032: ldloc.1 + IL_0033: isinst [runtime]System.IDisposable + IL_0038: stloc.3 + IL_0039: ldloc.3 + IL_003a: brfalse.s IL_0043 + + IL_003c: ldloc.3 + IL_003d: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0042: endfinally + IL_0043: endfinally + } + IL_0044: ret + } + + .method public static void testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0022 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldloc.1 + IL_001f: ldc.i4.1 + IL_0020: add + IL_0021: stloc.1 + IL_0022: ldloc.1 + IL_0023: ldloc.0 + IL_0024: ldlen + IL_0025: conv.i4 + IL_0026: blt.s IL_0006 + + IL_0028: ret + } + + .method public static void testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0032 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldstr "{0}" + IL_0023: ldloc.2 + IL_0024: box [runtime]System.Int32 + IL_0029: call void [runtime]System.Console::WriteLine(string, + object) + IL_002e: ldloc.1 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: stloc.1 + IL_0032: ldloc.1 + IL_0033: ldloc.0 + IL_0034: ldlen + IL_0035: conv.i4 + IL_0036: blt.s IL_0006 + + IL_0038: ret + } + + .method public static void testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_002b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldloc.1 + IL_0023: stloc.0 + IL_0024: ldloc.0 + IL_0025: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_002a: stloc.1 + IL_002b: ldloc.1 + IL_002c: brtrue.s IL_000b + + IL_002e: ret + } + + .method public static void testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_003b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldstr "{0}" + IL_0027: ldloc.2 + IL_0028: box [runtime]System.Int32 + IL_002d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0032: ldloc.1 + IL_0033: stloc.0 + IL_0034: ldloc.0 + IL_0035: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_003a: stloc.1 + IL_003b: ldloc.1 + IL_003c: brtrue.s IL_000b + + IL_003e: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0029 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldloc.1 + IL_002a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002f: brtrue.s IL_0012 + + IL_0031: leave.s IL_0045 + + } + finally + { + IL_0033: ldloc.1 + IL_0034: isinst [runtime]System.IDisposable + IL_0039: stloc.3 + IL_003a: ldloc.3 + IL_003b: brfalse.s IL_0044 + + IL_003d: ldloc.3 + IL_003e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0043: endfinally + IL_0044: endfinally + } + IL_0045: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0039 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldstr "{0}" + IL_002e: ldloc.2 + IL_002f: box [runtime]System.Int32 + IL_0034: call void [runtime]System.Console::WriteLine(string, + object) + IL_0039: ldloc.1 + IL_003a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_003f: brtrue.s IL_0012 + + IL_0041: leave.s IL_0055 + + } + finally + { + IL_0043: ldloc.1 + IL_0044: isinst [runtime]System.IDisposable + IL_0049: stloc.3 + IL_004a: ldloc.3 + IL_004b: brfalse.s IL_0054 + + IL_004d: ldloc.3 + IL_004e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0053: endfinally + IL_0054: endfinally + } + IL_0055: ret + } + + .method public static void testSimpleForEachIntLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: sub + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: sub + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: sub + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 ListExpressionSteppingTest7() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + class [runtime]System.Collections.Generic.IEnumerable`1 V_2, + int32 V_3, + class [runtime]System.IDisposable V_4) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: ldc.i4.1 + IL_0003: ldc.i4.4 + IL_0004: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0009: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000e: stloc.1 + .try + { + IL_000f: br.s IL_0031 + + IL_0011: ldloc.1 + IL_0012: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0017: stloc.3 + IL_0018: ldstr "hello" + IL_001d: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_0022: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0027: pop + IL_0028: ldloca.s V_0 + IL_002a: ldloc.3 + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Add(!0) + IL_0030: nop + IL_0031: ldloc.1 + IL_0032: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0037: brtrue.s IL_0011 + + IL_0039: ldnull + IL_003a: stloc.2 + IL_003b: leave.s IL_0052 + + } + finally + { + IL_003d: ldloc.1 + IL_003e: isinst [runtime]System.IDisposable + IL_0043: stloc.s V_4 + IL_0045: ldloc.s V_4 + IL_0047: brfalse.s IL_0051 + + IL_0049: ldloc.s V_4 + IL_004b: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0050: endfinally + IL_0051: endfinally + } + IL_0052: ldloc.2 + IL_0053: pop + IL_0054: ldloca.s V_0 + IL_0056: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_005b: ret + } + + .property int32 r() + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) + .set void SeqExpressionSteppingTest7::set_r(int32) + .get int32 SeqExpressionSteppingTest7::get_r() + } +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .field static assembly int32 r@4 + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + class [runtime]System.Exception V_2, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 V_3) + IL_0000: ldc.i4.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ldstr "res = %A" + IL_000b: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1>::.ctor(string) + IL_0010: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0015: stloc.0 + .try + { + IL_0016: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 SeqExpressionSteppingTest7::f() + IL_001b: stloc.1 + IL_001c: leave.s IL_004b + + } + catch [runtime]System.Object + { + IL_001e: castclass [runtime]System.Exception + IL_0023: stloc.2 + IL_0024: ldloc.2 + IL_0025: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception) + IL_002a: stloc.3 + IL_002b: ldloc.3 + IL_002c: brfalse.s IL_0040 + + IL_002e: call int32 SeqExpressionSteppingTest7::get_r() + IL_0033: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_0038: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::Cons(!0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1) + IL_003d: stloc.1 + IL_003e: leave.s IL_004b + + IL_0040: rethrow + IL_0042: ldnull + IL_0043: unbox.any class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 + IL_0048: stloc.1 + IL_0049: leave.s IL_004b + + } + IL_004b: ldloc.0 + IL_004c: ldloc.1 + IL_004d: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0) + IL_0052: pop + IL_0053: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.release.bsl new file mode 100644 index 00000000000..bb5909fc008 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.release.bsl @@ -0,0 +1,812 @@ + + + + + +.assembly extern runtime { } +.assembly extern FSharp.Core { } +.assembly extern runtime { } +.assembly assembly +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, + int32, + int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) + + + + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.mresource public FSharpSignatureData.assembly +{ + + +} +.mresource public FSharpOptimizationData.assembly +{ + + +} +.module assembly.exe + +.imagebase {value} +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 +.corflags 0x00000001 + + + + + +.class public abstract auto ansi sealed SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) + .method public specialname static int32 get_r() cil managed + { + + .maxstack 8 + IL_0000: ldsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0005: ret + } + + .method public specialname static void set_r(int32 'value') cil managed + { + + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 f() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + string V_1) + IL_0000: nop + IL_0001: nop + IL_0002: call int32 SeqExpressionSteppingTest7::get_r() + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: call void SeqExpressionSteppingTest7::set_r(int32) + IL_000e: ldc.i4.1 + IL_000f: brfalse.s IL_0034 + + IL_0011: ldstr "" + IL_0016: stloc.1 + IL_0017: ldloca.s V_0 + IL_0019: ldc.i4.0 + IL_001a: brfalse.s IL_0024 + + IL_001c: ldnull + IL_001d: unbox.any class [runtime]System.Collections.Generic.IEnumerable`1 + IL_0022: br.s IL_002b + + IL_0024: ldloc.1 + IL_0025: call class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string) + IL_002a: throw + + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1) + IL_0030: nop + IL_0031: nop + IL_0032: br.s IL_0035 + + IL_0034: nop + IL_0035: ldloca.s V_0 + IL_0037: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_003c: ret + } + + .method public static void testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_001d + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldloc.1 + IL_001e: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0023: brtrue.s IL_000b + + IL_0025: leave.s IL_0039 + + } + finally + { + IL_0027: ldloc.1 + IL_0028: isinst [runtime]System.IDisposable + IL_002d: stloc.3 + IL_002e: ldloc.3 + IL_002f: brfalse.s IL_0038 + + IL_0031: ldloc.3 + IL_0032: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0037: endfinally + IL_0038: endfinally + } + IL_0039: ret + } + + .method public static void testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + object[] V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0008: stloc.1 + .try + { + IL_0009: br.s IL_0028 + + IL_000b: ldloc.1 + IL_000c: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_001d: ldstr "{0}" + IL_0022: ldloc.2 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object[]) + IL_0028: ldloc.1 + IL_0029: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002e: brtrue.s IL_000b + + IL_0030: leave.s IL_0044 + + } + finally + { + IL_0032: ldloc.1 + IL_0033: isinst [runtime]System.IDisposable + IL_0038: stloc.3 + IL_0039: ldloc.3 + IL_003a: brfalse.s IL_0043 + + IL_003c: ldloc.3 + IL_003d: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0042: endfinally + IL_0043: endfinally + } + IL_0044: ret + } + + .method public static void testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0022 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldloc.1 + IL_001f: ldc.i4.1 + IL_0020: add + IL_0021: stloc.1 + IL_0022: ldloc.1 + IL_0023: ldloc.0 + IL_0024: ldlen + IL_0025: conv.i4 + IL_0026: blt.s IL_0006 + + IL_0028: ret + } + + .method public static void testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed + { + + .maxstack 4 + .locals init (int32[] V_0, + int32 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldc.i4.0 + IL_0003: stloc.1 + IL_0004: br.s IL_0032 + + IL_0006: ldloc.0 + IL_0007: ldloc.1 + IL_0008: ldelem [runtime]System.Int32 + IL_000d: stloc.2 + IL_000e: ldstr "{0}" + IL_0013: ldloc.2 + IL_0014: box [runtime]System.Int32 + IL_0019: call void [runtime]System.Console::WriteLine(string, + object) + IL_001e: ldstr "{0}" + IL_0023: ldloc.2 + IL_0024: box [runtime]System.Int32 + IL_0029: call void [runtime]System.Console::WriteLine(string, + object) + IL_002e: ldloc.1 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: stloc.1 + IL_0032: ldloc.1 + IL_0033: ldloc.0 + IL_0034: ldlen + IL_0035: conv.i4 + IL_0036: blt.s IL_0006 + + IL_0038: ret + } + + .method public static void testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_002b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldloc.1 + IL_0023: stloc.0 + IL_0024: ldloc.0 + IL_0025: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_002a: stloc.1 + IL_002b: ldloc.1 + IL_002c: brtrue.s IL_000b + + IL_002e: ret + } + + .method public static void testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 inp) cil managed + { + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + int32 V_2) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0008: stloc.1 + IL_0009: br.s IL_003b + + IL_000b: ldloc.0 + IL_000c: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_0011: stloc.2 + IL_0012: ldstr "{0}" + IL_0017: ldloc.2 + IL_0018: box [runtime]System.Int32 + IL_001d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0022: ldstr "{0}" + IL_0027: ldloc.2 + IL_0028: box [runtime]System.Int32 + IL_002d: call void [runtime]System.Console::WriteLine(string, + object) + IL_0032: ldloc.1 + IL_0033: stloc.0 + IL_0034: ldloc.0 + IL_0035: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_003a: stloc.1 + IL_003b: ldloc.1 + IL_003c: brtrue.s IL_000b + + IL_003e: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntRangeLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0029 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldloc.1 + IL_002a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_002f: brtrue.s IL_0012 + + IL_0031: leave.s IL_0045 + + } + finally + { + IL_0033: ldloc.1 + IL_0034: isinst [runtime]System.IDisposable + IL_0039: stloc.3 + IL_003a: ldloc.3 + IL_003b: brfalse.s IL_0044 + + IL_003d: ldloc.3 + IL_003e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0043: endfinally + IL_0044: endfinally + } + IL_0045: ret + } + + .method public static void testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + int32 V_2, + class [runtime]System.IDisposable V_3) + IL_0000: ldarg.0 + IL_0001: ldc.i4.m1 + IL_0002: ldarg.1 + IL_0003: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000f: stloc.1 + .try + { + IL_0010: br.s IL_0039 + + IL_0012: ldloc.1 + IL_0013: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0018: stloc.2 + IL_0019: ldstr "{0}" + IL_001e: ldloc.2 + IL_001f: box [runtime]System.Int32 + IL_0024: call void [runtime]System.Console::WriteLine(string, + object) + IL_0029: ldstr "{0}" + IL_002e: ldloc.2 + IL_002f: box [runtime]System.Int32 + IL_0034: call void [runtime]System.Console::WriteLine(string, + object) + IL_0039: ldloc.1 + IL_003a: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_003f: brtrue.s IL_0012 + + IL_0041: leave.s IL_0055 + + } + finally + { + IL_0043: ldloc.1 + IL_0044: isinst [runtime]System.IDisposable + IL_0049: stloc.3 + IL_004a: ldloc.3 + IL_004b: brfalse.s IL_0054 + + IL_004d: ldloc.3 + IL_004e: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0053: endfinally + IL_0054: endfinally + } + IL_0055: ret + } + + .method public static void testSimpleForEachIntLoopWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: add + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: stloc.1 + IL_0002: ldarg.1 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: blt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static void testSimpleForEachIntLoopDownWithOneStatement(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0022 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldloc.1 + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: stloc.1 + IL_001c: ldloc.1 + IL_001d: ldloc.0 + IL_001e: ldc.i4.1 + IL_001f: sub + IL_0020: bne.un.s IL_0008 + + IL_0022: ret + } + + .method public static void testSimpleForEachIntLoopDownWithTwoStatements(int32 start, + int32 stop) cil managed + { + + .maxstack 5 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.1 + IL_0001: stloc.1 + IL_0002: ldarg.0 + IL_0003: stloc.0 + IL_0004: ldloc.0 + IL_0005: ldloc.1 + IL_0006: bgt.s IL_0032 + + IL_0008: ldstr "{0}" + IL_000d: ldloc.1 + IL_000e: box [runtime]System.Int32 + IL_0013: call void [runtime]System.Console::WriteLine(string, + object) + IL_0018: ldstr "{0}" + IL_001d: ldloc.1 + IL_001e: box [runtime]System.Int32 + IL_0023: call void [runtime]System.Console::WriteLine(string, + object) + IL_0028: ldloc.1 + IL_0029: ldc.i4.1 + IL_002a: sub + IL_002b: stloc.1 + IL_002c: ldloc.1 + IL_002d: ldloc.0 + IL_002e: ldc.i4.1 + IL_002f: sub + IL_0030: bne.un.s IL_0008 + + IL_0032: ret + } + + .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 ListExpressionSteppingTest7() cil managed + { + + .maxstack 5 + .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1 V_0, + class [runtime]System.Collections.Generic.IEnumerator`1 V_1, + class [runtime]System.Collections.Generic.IEnumerable`1 V_2, + int32 V_3, + class [runtime]System.IDisposable V_4) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: ldc.i4.1 + IL_0003: ldc.i4.4 + IL_0004: call class [runtime]System.Collections.Generic.IEnumerable`1 [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32, + int32, + int32) + IL_0009: callvirt instance class [runtime]System.Collections.Generic.IEnumerator`1 class [runtime]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_000e: stloc.1 + .try + { + IL_000f: br.s IL_0031 + + IL_0011: ldloc.1 + IL_0012: callvirt instance !0 class [runtime]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0017: stloc.3 + IL_0018: ldstr "hello" + IL_001d: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) + IL_0022: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0027: pop + IL_0028: ldloca.s V_0 + IL_002a: ldloc.3 + IL_002b: call instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Add(!0) + IL_0030: nop + IL_0031: ldloc.1 + IL_0032: callvirt instance bool [runtime]System.Collections.IEnumerator::MoveNext() + IL_0037: brtrue.s IL_0011 + + IL_0039: ldnull + IL_003a: stloc.2 + IL_003b: leave.s IL_0052 + + } + finally + { + IL_003d: ldloc.1 + IL_003e: isinst [runtime]System.IDisposable + IL_0043: stloc.s V_4 + IL_0045: ldloc.s V_4 + IL_0047: brfalse.s IL_0051 + + IL_0049: ldloc.s V_4 + IL_004b: callvirt instance void [runtime]System.IDisposable::Dispose() + IL_0050: endfinally + IL_0051: endfinally + } + IL_0052: ldloc.2 + IL_0053: pop + IL_0054: ldloca.s V_0 + IL_0056: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1::Close() + IL_005b: ret + } + + .property int32 r() + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) + .set void SeqExpressionSteppingTest7::set_r(int32) + .get int32 SeqExpressionSteppingTest7::get_r() + } +} + +.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest7 + extends [runtime]System.Object +{ + .field static assembly int32 r@4 + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field static assembly int32 init@ + .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) + .method public static void main@() cil managed + { + .entrypoint + + .maxstack 4 + .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 V_1, + class [runtime]System.Exception V_2, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 V_3) + IL_0000: ldc.i4.0 + IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest7::r@4 + IL_0006: ldstr "res = %A" + IL_000b: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1>::.ctor(string) + IL_0010: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) + IL_0015: stloc.0 + .try + { + IL_0016: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 SeqExpressionSteppingTest7::f() + IL_001b: stloc.1 + IL_001c: leave.s IL_004b + + } + catch [runtime]System.Object + { + IL_001e: castclass [runtime]System.Exception + IL_0023: stloc.2 + IL_0024: ldloc.2 + IL_0025: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1 [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception) + IL_002a: stloc.3 + IL_002b: ldloc.3 + IL_002c: brfalse.s IL_0040 + + IL_002e: call int32 SeqExpressionSteppingTest7::get_r() + IL_0033: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_0038: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::Cons(!0, + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1) + IL_003d: stloc.1 + IL_003e: leave.s IL_004b + + IL_0040: rethrow + IL_0042: ldnull + IL_0043: unbox.any class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 + IL_0048: stloc.1 + IL_0049: leave.s IL_004b + + } + IL_004b: ldloc.0 + IL_004c: ldloc.1 + IL_004d: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0) + IL_0052: pop + IL_0053: ret + } + +} + + + + + + diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.debug.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.debug.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.debug.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.release.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.release.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.release.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.debug.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.debug.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.debug.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.release.bsl similarity index 100% rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.release.bsl rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.release.bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs index 1d6244f9f7b..55245346fa0 100644 --- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs +++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs @@ -7,6 +7,7 @@ open FSharp.Test.Compiler module SeqExpressionTailCalls = + // Note: no realsignature variations are performed because these test cases do not involve any static initialization let verifyCompilation compilation = compilation |> withOptions [ "--test:EmitFeeFeeAs100001" ] @@ -25,6 +26,6 @@ module SeqExpressionTailCalls = // SOURCE=SeqExpressionTailCalls02.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionTailCalls02.exe" # SeqExpressionTailCalls02.fs - [] - let ``SeqExpressionSteppingTest02_fs`` compilation = + let ``SeqExpressionTailCalls02_fs`` compilation = compilation |> verifyCompilation From 4b4697f952f4696cb0bec90fd59559d58c6674e9 Mon Sep 17 00:00:00 2001 From: Kevin Ransom Date: Fri, 1 Mar 2024 12:56:27 -0800 Subject: [PATCH 2/2] rename typo --- ...Test02.fs.RealInternalSignatureOff.il..bsl | 291 ------------------ 1 file changed, 291 deletions(-) delete mode 100644 tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il..bsl diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il..bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il..bsl deleted file mode 100644 index c667f5ac064..00000000000 --- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il..bsl +++ /dev/null @@ -1,291 +0,0 @@ - - - - - -.assembly extern runtime { } -.assembly extern FSharp.Core { } -.assembly assembly -{ - .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32, - int32, - int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) - - - - - .hash algorithm 0x00008004 - .ver 0:0:0:0 -} -.mresource public FSharpSignatureData.assembly -{ - - -} -.mresource public FSharpOptimizationData.assembly -{ - - -} -.module assembly.exe - -.imagebase {value} -.file alignment 0x00000200 -.stackreserve 0x00100000 -.subsystem 0x0003 -.corflags 0x00000001 - - - - - -.class public abstract auto ansi sealed SeqExpressionSteppingTest2 - extends [runtime]System.Object -{ - .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) - .class abstract auto ansi sealed nested public SeqExpressionSteppingTest2 - extends [runtime]System.Object - { - .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) - .class auto autochar serializable sealed nested assembly beforefieldinit specialname f1@5 - extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1 - { - .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) - .field public int32 pc - .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) - .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) - .field public int32 current - .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) - .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) - .method public specialname rtspecialname - instance void .ctor(int32 pc, - int32 current) cil managed - { - - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldarg.1 - IL_0002: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc - IL_0007: ldarg.0 - IL_0008: ldarg.2 - IL_0009: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current - IL_000e: ldarg.0 - IL_000f: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() - IL_0014: ret - } - - .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1& next) cil managed - { - - .maxstack 6 - IL_0000: ldarg.0 - IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc - IL_0006: ldc.i4.1 - IL_0007: sub - IL_0008: switch ( - IL_001b, - IL_001e, - IL_0021) - IL_0019: br.s IL_0024 - - IL_001b: nop - IL_001c: br.s IL_0045 - - IL_001e: nop - IL_001f: br.s IL_0065 - - IL_0021: nop - IL_0022: br.s IL_006c - - IL_0024: nop - IL_0025: ldstr "hello" - IL_002a: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) - IL_002f: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) - IL_0034: pop - IL_0035: ldarg.0 - IL_0036: ldc.i4.1 - IL_0037: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc - IL_003c: ldarg.0 - IL_003d: ldc.i4.1 - IL_003e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current - IL_0043: ldc.i4.1 - IL_0044: ret - - IL_0045: ldstr "goodbye" - IL_004a: newobj instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5::.ctor(string) - IL_004f: call !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4) - IL_0054: pop - IL_0055: ldarg.0 - IL_0056: ldc.i4.2 - IL_0057: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc - IL_005c: ldarg.0 - IL_005d: ldc.i4.2 - IL_005e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current - IL_0063: ldc.i4.1 - IL_0064: ret - - IL_0065: ldarg.0 - IL_0066: ldc.i4.3 - IL_0067: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc - IL_006c: ldarg.0 - IL_006d: ldc.i4.0 - IL_006e: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current - IL_0073: ldc.i4.0 - IL_0074: ret - } - - .method public strict virtual instance void Close() cil managed - { - - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldc.i4.3 - IL_0002: stfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc - IL_0007: ret - } - - .method public strict virtual instance bool get_CheckClose() cil managed - { - - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc - IL_0006: switch ( - IL_001d, - IL_0020, - IL_0023, - IL_0026) - IL_001b: br.s IL_0029 - - IL_001d: nop - IL_001e: br.s IL_002e - - IL_0020: nop - IL_0021: br.s IL_002c - - IL_0023: nop - IL_0024: br.s IL_002a - - IL_0026: nop - IL_0027: br.s IL_002e - - IL_0029: nop - IL_002a: ldc.i4.0 - IL_002b: ret - - IL_002c: ldc.i4.0 - IL_002d: ret - - IL_002e: ldc.i4.0 - IL_002f: ret - } - - .method public strict virtual instance int32 get_LastGenerated() cil managed - { - .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) - - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldfld int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current - IL_0006: ret - } - - .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator() cil managed - { - .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) - - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: ldc.i4.0 - IL_0002: newobj instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32, - int32) - IL_0007: ret - } - - } - - .method public static class [runtime]System.Collections.Generic.IEnumerable`1 f1() cil managed - { - - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: ldc.i4.0 - IL_0002: newobj instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32, - int32) - IL_0007: ret - } - - .method private specialname rtspecialname static void .cctor() cil managed - { - - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest2::init@ - IL_0006: ldsfld int32 ''.$SeqExpressionSteppingTest2::init@ - IL_000b: pop - IL_000c: ret - } - - .method assembly specialname static void staticInitialization@() cil managed - { - - .maxstack 3 - .locals init (class [runtime]System.Collections.Generic.IEnumerable`1 V_0) - IL_0000: call class [runtime]System.Collections.Generic.IEnumerable`1 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2::f1() - IL_0005: stloc.0 - IL_0006: ldloc.0 - IL_0007: call int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length(class [runtime]System.Collections.Generic.IEnumerable`1) - IL_000c: pop - IL_000d: ret - } - - } - - .method private specialname rtspecialname static void .cctor() cil managed - { - - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 ''.$SeqExpressionSteppingTest2::init@ - IL_0006: ldsfld int32 ''.$SeqExpressionSteppingTest2::init@ - IL_000b: pop - IL_000c: ret - } - - .method assembly specialname static void staticInitialization@() cil managed - { - - .maxstack 8 - IL_0000: call void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2::staticInitialization@() - IL_0005: ret - } - -} - -.class private abstract auto ansi sealed ''.$SeqExpressionSteppingTest2 - extends [runtime]System.Object -{ - .field static assembly int32 init@ - .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) - .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) - .method public static void main@() cil managed - { - .entrypoint - - .maxstack 8 - IL_0000: call void SeqExpressionSteppingTest2::staticInitialization@() - IL_0005: ret - } - -} - - - - - -