diff --git a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj index cd71918fa..e3c10b410 100644 --- a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj +++ b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj @@ -45,6 +45,9 @@ + + + @@ -55,6 +58,8 @@ + + diff --git a/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs index 799ea3924..4afafa3b4 100644 --- a/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs +++ b/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs @@ -41,7 +41,7 @@ namespace ICSharpCode.Decompiler.Tests { Run(); } - + [Test] public void FSharpUsing_Debug() { @@ -54,6 +54,18 @@ namespace ICSharpCode.Decompiler.Tests Run(); } + [Test, Ignore] + public void FSharpLoops_Debug() + { + Run(); + } + + [Test, Ignore] + public void FSharpLoops_Release() + { + Run(); + } + void Run([CallerMemberName] string testName = null) { var ilFile = Path.Combine(TestCasePath, testName + ".il"); diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops.fs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops.fs new file mode 100644 index 000000000..ddb285561 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops.fs @@ -0,0 +1,30 @@ +open System + +let disposable() = { new IDisposable with member x.Dispose() = () } + +let getSeq() = seq { yield 1; } +let getList() = [ 1 ] +let getArray() = [| 1 |] + +[] +let main argv = + + // nested using scopes? + use disp1 = + use disp2 = disposable() + Console.WriteLine "Hello 1" + disposable() + + // for loop over seq + for i in getSeq() do + Console.WriteLine i + + // for loop over list + for i in getList() do + Console.WriteLine i + + // for loop over array + for i in getArray() do + Console.WriteLine i + + 0 // return an integer exit code \ No newline at end of file diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Debug.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Debug.cs new file mode 100644 index 000000000..72393a233 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Debug.cs @@ -0,0 +1,209 @@ + +// C:\Users\Siegfried\Documents\Visual Studio 2017\Projects\ConsoleApp13\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe +// ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null +// Global type: +// Entry point: Program.main +// Architecture: AnyCPU (32-bit preferred) +// Runtime: .NET 4.0 + +using Microsoft.FSharp.Collections; +using Microsoft.FSharp.Core; +using Microsoft.FSharp.Core.CompilerServices; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Versioning; + +[assembly: FSharpInterfaceDataVersion(2, 0, 0)] +[assembly: TargetFramework(".NETFramework,Version=v4.6.1", FrameworkDisplayName = ".NET Framework 4.6.1")] +[assembly: AssemblyTitle("ConsoleApplication1")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ConsoleApplication1")] +[assembly: AssemblyCopyright("Copyright © 2017")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: ComVisible(false)] +[assembly: Guid("e0674ff5-5e8f-4d4e-a88f-e447192454c7")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations)] +[assembly: AssemblyVersion("1.0.0.0")] +[CompilationMapping(SourceConstructFlags.Module)] +public static class Program +{ + [Serializable] + [StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)] + [CompilationMapping(SourceConstructFlags.Closure)] + internal sealed class disposable@3 : IDisposable + { + public disposable@3() + { + ((object)this)..ctor(); + } + + private void System-IDisposable-Dispose() + { + } + + void IDisposable.Dispose() + { + //ILSpy generated this explicit interface implementation from .override directive in System-IDisposable-Dispose + this.System-IDisposable-Dispose(); + } + } + + [Serializable] + [StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)] + [CompilationMapping(SourceConstructFlags.Closure)] + internal sealed class getSeq@5 : GeneratedSequenceBase + { + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [CompilerGenerated] + [DebuggerNonUserCode] + public int pc = pc; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [CompilerGenerated] + [DebuggerNonUserCode] + public int current = current; + + public getSeq@5(int pc, int current) + { + } + + public override int GenerateNext(ref IEnumerable next) + { + switch (this.pc) + { + default: + this.pc = 1; + this.current = 1; + return 1; + case 1: + this.pc = 2; + break; + case 2: + break; + } + this.current = 0; + return 0; + } + + public override void Close() + { + this.pc = 2; + } + + public override bool get_CheckClose() + { + switch (this.pc) + { + default: + return false; + case 0: + case 2: + return false; + } + } + + [CompilerGenerated] + [DebuggerNonUserCode] + public override int get_LastGenerated() + { + return this.current; + } + + [CompilerGenerated] + [DebuggerNonUserCode] + public override IEnumerator GetFreshEnumerator() + { + return new getSeq@5(0, 0); + } + } + + public static IDisposable disposable() + { + return new disposable@3(); + } + + public static IEnumerable getSeq() + { + return new getSeq@5(0, 0); + } + + public static FSharpList getList() + { + return FSharpList.Cons(1, FSharpList.Empty); + } + + public static int[] getArray() + { + return new int[1] + { + 1 + }; + } + + [EntryPoint] + public static int main(string[] argv) + { + IDisposable disposable = default(IDisposable); + using (Program.disposable()) + { + Console.WriteLine("Hello 1"); + disposable = Program.disposable(); + } + using (disposable) + { + IEnumerable seq = Program.getSeq(); + using (IEnumerator enumerator = seq.GetEnumerator()) + { + while (true) + { + if (!enumerator.MoveNext()) + break; + int k = enumerator.Current; + Console.WriteLine(k); + } + } + FSharpList fSharpList = Program.getList(); + FSharpList tailOrNull = fSharpList.TailOrNull; + while (true) + { + if (tailOrNull == null) + break; + int j = fSharpList.HeadOrDefault; + Console.WriteLine(j); + fSharpList = tailOrNull; + tailOrNull = fSharpList.TailOrNull; + } + int[] array = Program.getArray(); + for (int l = 0; l < array.Length; l++) + { + int i = array[l]; + Console.WriteLine(i); + } + return 0; + } + } +} +namespace +{ + internal static class $Program + { + } + internal static class $AssemblyInfo + { + } +} +namespace .$.NETFramework,Version=v4.6.1 +{ + internal static class AssemblyAttributes + { + } +} diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Debug.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Debug.il new file mode 100644 index 000000000..a3980aa4f --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Debug.il @@ -0,0 +1,586 @@ +// C:\Users\Siegfried\Documents\Visual Studio 2017\Projects\ConsoleApp13\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe + +.assembly extern mscorlib +{ + .publickeytoken = ( + b7 7a 5c 56 19 34 e0 89 + ) + .ver 4:0:0:0 +} +.assembly extern FSharp.Core +{ + .publickeytoken = ( + b0 3f 5f 7f 11 d5 0a 3a + ) + .ver 4:4:1:0 +} +.assembly ConsoleApplication1 +{ + .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 + ) + .custom instance void [mscorlib]System.Runtime.Versioning.TargetFrameworkAttribute::.ctor(string) = ( + 01 00 1c 2e 4e 45 54 46 72 61 6d 65 77 6f 72 6b + 2c 56 65 72 73 69 6f 6e 3d 76 34 2e 36 2e 31 01 + 00 54 0e 14 46 72 61 6d 65 77 6f 72 6b 44 69 73 + 70 6c 61 79 4e 61 6d 65 14 2e 4e 45 54 20 46 72 + 61 6d 65 77 6f 72 6b 20 34 2e 36 2e 31 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyTitleAttribute::.ctor(string) = ( + 01 00 13 43 6f 6e 73 6f 6c 65 41 70 70 6c 69 63 + 61 74 69 6f 6e 31 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyDescriptionAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyConfigurationAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyCompanyAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyProductAttribute::.ctor(string) = ( + 01 00 13 43 6f 6e 73 6f 6c 65 41 70 70 6c 69 63 + 61 74 69 6f 6e 31 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyCopyrightAttribute::.ctor(string) = ( + 01 00 12 43 6f 70 79 72 69 67 68 74 20 c2 a9 20 + 20 32 30 31 37 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyTrademarkAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyCultureAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.InteropServices.ComVisibleAttribute::.ctor(bool) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.InteropServices.GuidAttribute::.ctor(string) = ( + 01 00 24 65 30 36 37 34 66 66 35 2d 35 65 38 66 + 2d 34 64 34 65 2d 61 38 38 66 2d 65 34 34 37 31 + 39 32 34 35 34 63 37 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyVersionAttribute::.ctor(string) = ( + 01 00 07 31 2e 30 2e 30 2e 30 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = ( + 01 00 07 31 2e 30 2e 30 2e 30 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( + 01 00 01 01 00 00 00 00 + ) + .hash algorithm 0x00008004 // SHA1 + .ver 1:0:0:0 +} + +.module ConsoleApplication1.exe +// MVID: {59F64D20-6A1F-D4CE-A745-0383204DF659} +.corflags 0x00020003 // ILOnly, Required32Bit, Preferred32Bit + + +.class private auto ansi '' + extends [mscorlib]System.Object +{ +} // end of class + +.class public auto ansi abstract sealed Program + extends [mscorlib]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 + ) + // Nested Types + .class nested assembly auto auto sealed specialname serializable beforefieldinit disposable@3 + extends [mscorlib]System.Object + implements [mscorlib]System.IDisposable + { + .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 + ) + // Methods + .method public specialname rtspecialname + instance void .ctor () cil managed + { + // Method begins at RVA 0x21c8 + // Code size 9 (0x9) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: callvirt instance void [mscorlib]System.Object::.ctor() + IL_0006: ldarg.0 + IL_0007: pop + IL_0008: ret + } // end of method disposable@3::.ctor + + .method private final hidebysig newslot virtual + instance void 'System-IDisposable-Dispose' () cil managed + { + .override method instance void [mscorlib]System.IDisposable::Dispose() + // Method begins at RVA 0x21d4 + // Code size 1 (0x1) + .maxstack 8 + + IL_0000: ret + } // end of method disposable@3::'System-IDisposable-Dispose' + + } // end of class disposable@3 + + .class nested assembly auto auto sealed specialname serializable beforefieldinit getSeq@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 + ) + // Fields + .field public int32 pc + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( + 01 00 00 00 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + .field public int32 current + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( + 01 00 00 00 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + + // Methods + .method public specialname rtspecialname + instance void .ctor ( + int32 pc, + int32 current + ) cil managed + { + // Method begins at RVA 0x21d8 + // Code size 21 (0x15) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 Program/getSeq@5::pc + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld int32 Program/getSeq@5::current + IL_000e: ldarg.0 + IL_000f: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0014: ret + } // end of method getSeq@5::.ctor + + .method public strict virtual + instance int32 GenerateNext ( + class [mscorlib]System.Collections.Generic.IEnumerable`1& next + ) cil managed + { + // Method begins at RVA 0x21f0 + // Code size 66 (0x42) + .maxstack 6 + + IL_0000: ldarg.0 + IL_0001: ldfld int32 Program/getSeq@5::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch (IL_0017, IL_0019) + + IL_0015: br.s IL_0021 + + IL_0017: br.s IL_001b + + IL_0019: br.s IL_001e + + IL_001b: nop + IL_001c: br.s IL_0032 + + IL_001e: nop + IL_001f: br.s IL_0039 + + IL_0021: nop + IL_0022: ldarg.0 + IL_0023: ldc.i4.1 + IL_0024: stfld int32 Program/getSeq@5::pc + IL_0029: ldarg.0 + IL_002a: ldc.i4.1 + IL_002b: stfld int32 Program/getSeq@5::current + IL_0030: ldc.i4.1 + IL_0031: ret + + IL_0032: ldarg.0 + IL_0033: ldc.i4.2 + IL_0034: stfld int32 Program/getSeq@5::pc + + IL_0039: ldarg.0 + IL_003a: ldc.i4.0 + IL_003b: stfld int32 Program/getSeq@5::current + IL_0040: ldc.i4.0 + IL_0041: ret + } // end of method getSeq@5::GenerateNext + + .method public strict virtual + instance void Close () cil managed + { + // Method begins at RVA 0x2240 + // Code size 8 (0x8) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldc.i4.2 + IL_0002: stfld int32 Program/getSeq@5::pc + IL_0007: ret + } // end of method getSeq@5::Close + + .method public strict virtual + instance bool get_CheckClose () cil managed + { + // Method begins at RVA 0x224c + // Code size 45 (0x2d) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldfld int32 Program/getSeq@5::pc + IL_0006: switch (IL_0019, IL_001b, IL_001d) + + IL_0017: br.s IL_0028 + + IL_0019: br.s IL_001f + + IL_001b: br.s IL_0022 + + IL_001d: br.s IL_0025 + + IL_001f: nop + IL_0020: br.s IL_002b + + IL_0022: nop + IL_0023: br.s IL_0029 + + IL_0025: nop + IL_0026: br.s IL_002b + + IL_0028: nop + + IL_0029: ldc.i4.0 + IL_002a: ret + + IL_002b: ldc.i4.0 + IL_002c: ret + } // end of method getSeq@5::get_CheckClose + + .method public strict virtual + instance int32 get_LastGenerated () cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + // Method begins at RVA 0x227c + // Code size 7 (0x7) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldfld int32 Program/getSeq@5::current + IL_0006: ret + } // end of method getSeq@5::get_LastGenerated + + .method public strict virtual + instance class [mscorlib]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator () cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + // Method begins at RVA 0x2284 + // Code size 8 (0x8) + .maxstack 8 + + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void Program/getSeq@5::.ctor(int32, int32) + IL_0007: ret + } // end of method getSeq@5::GetFreshEnumerator + + } // end of class getSeq@5 + + + // Methods + .method public static + class [mscorlib]System.IDisposable disposable () cil managed + { + // Method begins at RVA 0x2050 + // Code size 6 (0x6) + .maxstack 8 + + IL_0000: newobj instance void Program/disposable@3::.ctor() + IL_0005: ret + } // end of method Program::disposable + + .method public static + class [mscorlib]System.Collections.Generic.IEnumerable`1 getSeq () cil managed + { + // Method begins at RVA 0x2058 + // Code size 8 (0x8) + .maxstack 8 + + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void Program/getSeq@5::.ctor(int32, int32) + IL_0007: ret + } // end of method Program::getSeq + + .method public static + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 getList () cil managed + { + // Method begins at RVA 0x2064 + // Code size 12 (0xc) + .maxstack 8 + + IL_0000: ldc.i4.1 + IL_0001: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_0006: 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_000b: ret + } // end of method Program::getList + + .method public static + int32[] getArray () cil managed + { + // Method begins at RVA 0x2074 + // Code size 15 (0xf) + .maxstack 8 + + IL_0000: ldc.i4.1 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: dup + IL_0007: ldc.i4.0 + IL_0008: ldc.i4.1 + IL_0009: stelem.any [mscorlib]System.Int32 + IL_000e: ret + } // end of method Program::getArray + + .method public static + int32 main ( + string[] argv + ) cil managed + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.EntryPointAttribute::.ctor() = ( + 01 00 00 00 + ) + // Method begins at RVA 0x2084 + // Code size 270 (0x10e) + .maxstack 4 + .entrypoint + .locals init ( + [0] class [mscorlib]System.IDisposable, + [1] class [mscorlib]System.IDisposable, + [2] class [mscorlib]System.IDisposable, + [3] class [mscorlib]System.IDisposable, + [4] int32, + [5] class [mscorlib]System.Collections.Generic.IEnumerable`1, + [6] class [mscorlib]System.Collections.Generic.IEnumerator`1, + [7] class [FSharp.Core]Microsoft.FSharp.Core.Unit, + [8] int32, + [9] class [mscorlib]System.IDisposable, + [10] class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1, + [11] class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1, + [12] int32, + [13] int32[], + [14] int32, + [15] int32, + [16] class [mscorlib]System.IDisposable + ) + + IL_0000: call class [mscorlib]System.IDisposable Program::disposable() + IL_0005: stloc.1 + .try + { + IL_0006: ldstr "Hello 1" + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: call class [mscorlib]System.IDisposable Program::disposable() + IL_0015: stloc.2 + IL_0016: leave.s IL_0032 + } // end .try + finally + { + IL_0018: ldloc.1 + IL_0019: isinst [mscorlib]System.IDisposable + IL_001e: stloc.3 + IL_001f: ldloc.3 + IL_0020: brfalse.s IL_0024 + + IL_0022: br.s IL_0026 + + IL_0024: br.s IL_002f + + IL_0026: ldloc.3 + IL_0027: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_002c: ldnull + IL_002d: pop + IL_002e: endfinally + + IL_002f: ldnull + IL_0030: pop + IL_0031: endfinally + } // end handler + + IL_0032: ldloc.2 + IL_0033: stloc.0 + .try + { + IL_0034: call class [mscorlib]System.Collections.Generic.IEnumerable`1 Program::getSeq() + IL_0039: stloc.s 5 + IL_003b: ldloc.s 5 + IL_003d: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1 class [mscorlib]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_0042: stloc.s 6 + .try + { + // loop start (head: IL_0044) + IL_0044: ldloc.s 6 + IL_0046: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext() + IL_004b: brfalse.s IL_0060 + + IL_004d: ldloc.s 6 + IL_004f: callvirt instance !0 class [mscorlib]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0054: stloc.s 8 + IL_0056: ldloc.s 8 + IL_0058: call void [mscorlib]System.Console::WriteLine(int32) + IL_005d: nop + IL_005e: br.s IL_0044 + // end loop + + IL_0060: ldnull + IL_0061: stloc.s 7 + IL_0063: leave.s IL_0083 + } // end .try + finally + { + IL_0065: ldloc.s 6 + IL_0067: isinst [mscorlib]System.IDisposable + IL_006c: stloc.s 9 + IL_006e: ldloc.s 9 + IL_0070: brfalse.s IL_0074 + + IL_0072: br.s IL_0076 + + IL_0074: br.s IL_0080 + + IL_0076: ldloc.s 9 + IL_0078: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_007d: ldnull + IL_007e: pop + IL_007f: endfinally + + IL_0080: ldnull + IL_0081: pop + IL_0082: endfinally + } // end handler + + IL_0083: ldloc.s 7 + IL_0085: pop + IL_0086: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 Program::getList() + IL_008b: stloc.s 10 + IL_008d: ldloc.s 10 + IL_008f: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_0094: stloc.s 11 + // loop start (head: IL_0096) + IL_0096: ldloc.s 11 + IL_0098: ldnull + IL_0099: cgt.un + IL_009b: brfalse.s IL_00bd + + IL_009d: ldloc.s 10 + IL_009f: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_00a4: stloc.s 12 + IL_00a6: ldloc.s 12 + IL_00a8: call void [mscorlib]System.Console::WriteLine(int32) + IL_00ad: ldloc.s 11 + IL_00af: stloc.s 10 + IL_00b1: ldloc.s 10 + IL_00b3: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_00b8: stloc.s 11 + IL_00ba: nop + IL_00bb: br.s IL_0096 + // end loop + + IL_00bd: call int32[] Program::getArray() + IL_00c2: stloc.s 13 + IL_00c4: ldc.i4.0 + IL_00c5: stloc.s 14 + IL_00c7: br.s IL_00e1 + // loop start (head: IL_00e1) + IL_00c9: ldloc.s 13 + IL_00cb: ldloc.s 14 + IL_00cd: ldelem.any [mscorlib]System.Int32 + IL_00d2: stloc.s 15 + IL_00d4: ldloc.s 15 + IL_00d6: call void [mscorlib]System.Console::WriteLine(int32) + IL_00db: ldloc.s 14 + IL_00dd: ldc.i4.1 + IL_00de: add + IL_00df: stloc.s 14 + + IL_00e1: ldloc.s 14 + IL_00e3: ldloc.s 13 + IL_00e5: ldlen + IL_00e6: conv.i4 + IL_00e7: blt.s IL_00c9 + // end loop + + IL_00e9: ldc.i4.0 + IL_00ea: stloc.s 4 + IL_00ec: leave.s IL_010b + } // end .try + finally + { + IL_00ee: ldloc.0 + IL_00ef: isinst [mscorlib]System.IDisposable + IL_00f4: stloc.s 16 + IL_00f6: ldloc.s 16 + IL_00f8: brfalse.s IL_00fc + + IL_00fa: br.s IL_00fe + + IL_00fc: br.s IL_0108 + + IL_00fe: ldloc.s 16 + IL_0100: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_0105: ldnull + IL_0106: pop + IL_0107: endfinally + + IL_0108: ldnull + IL_0109: pop + IL_010a: endfinally + } // end handler + + IL_010b: ldloc.s 4 + IL_010d: ret + } // end of method Program::main + +} // end of class Program + +.class private auto ansi abstract sealed '.$Program' + extends [mscorlib]System.Object +{ +} // end of class .$Program + +.class private auto ansi abstract sealed '.$AssemblyInfo' + extends [mscorlib]System.Object +{ +} // end of class .$AssemblyInfo + +.class private auto ansi abstract sealed '.$.NETFramework,Version=v4.6.1.AssemblyAttributes' + extends [mscorlib]System.Object +{ +} // end of class .$.NETFramework,Version=v4.6.1.AssemblyAttributes + diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Release.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Release.cs new file mode 100644 index 000000000..d64bda08b --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Release.cs @@ -0,0 +1,210 @@ + +// C:\Users\Siegfried\Documents\Visual Studio 2017\Projects\ConsoleApp13\ConsoleApplication1\bin\Release\ConsoleApplication1.exe +// ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null +// Global type: +// Entry point: Program.main +// Architecture: AnyCPU (32-bit preferred) +// Runtime: .NET 4.0 + +using Microsoft.FSharp.Collections; +using Microsoft.FSharp.Core; +using Microsoft.FSharp.Core.CompilerServices; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Versioning; + +[assembly: FSharpInterfaceDataVersion(2, 0, 0)] +[assembly: TargetFramework(".NETFramework,Version=v4.6.1", FrameworkDisplayName = ".NET Framework 4.6.1")] +[assembly: AssemblyTitle("ConsoleApplication1")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ConsoleApplication1")] +[assembly: AssemblyCopyright("Copyright © 2017")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: ComVisible(false)] +[assembly: Guid("e0674ff5-5e8f-4d4e-a88f-e447192454c7")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: Debuggable(DebuggableAttribute.DebuggingModes.None)] +[assembly: AssemblyVersion("1.0.0.0")] +[CompilationMapping(SourceConstructFlags.Module)] +public static class Program +{ + [Serializable] + [StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)] + [CompilationMapping(SourceConstructFlags.Closure)] + internal sealed class disposable@3 : IDisposable + { + public disposable@3() + { + ((object)this)..ctor(); + } + + private void System-IDisposable-Dispose() + { + } + + void IDisposable.Dispose() + { + //ILSpy generated this explicit interface implementation from .override directive in System-IDisposable-Dispose + this.System-IDisposable-Dispose(); + } + } + + [Serializable] + [StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)] + [CompilationMapping(SourceConstructFlags.Closure)] + internal sealed class getSeq@5 : GeneratedSequenceBase + { + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [CompilerGenerated] + [DebuggerNonUserCode] + public int pc = pc; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [CompilerGenerated] + [DebuggerNonUserCode] + public int current = current; + + public getSeq@5(int pc, int current) + { + } + + public override int GenerateNext(ref IEnumerable next) + { + switch (this.pc) + { + default: + this.pc = 1; + this.current = 1; + return 1; + case 1: + this.pc = 2; + break; + case 2: + break; + } + this.current = 0; + return 0; + } + + public override void Close() + { + this.pc = 2; + } + + public override bool get_CheckClose() + { + switch (this.pc) + { + default: + return false; + case 0: + case 2: + return false; + } + } + + [CompilerGenerated] + [DebuggerNonUserCode] + public override int get_LastGenerated() + { + return this.current; + } + + [CompilerGenerated] + [DebuggerNonUserCode] + public override IEnumerator GetFreshEnumerator() + { + return new getSeq@5(0, 0); + } + } + + public static IDisposable disposable() + { + return new disposable@3(); + } + + public static IEnumerable getSeq() + { + return new getSeq@5(0, 0); + } + + public static FSharpList getList() + { + return FSharpList.Cons(1, FSharpList.Empty); + } + + public static int[] getArray() + { + return new int[1] + { + 1 + }; + } + + [EntryPoint] + public static int main(string[] argv) + { + IDisposable disposable = default(IDisposable); + using (Program.disposable()) + { + Console.WriteLine("Hello 1"); + disposable = Program.disposable(); + } + using (disposable) + { + IEnumerable seq = Program.getSeq(); + using (IEnumerator enumerator = seq.GetEnumerator()) + { + while (true) + { + if (!enumerator.MoveNext()) + break; + Console.WriteLine(enumerator.Current); + } + } + FSharpList fSharpList = FSharpList.Cons(1, FSharpList.Empty); + FSharpList tailOrNull = fSharpList.TailOrNull; + while (true) + { + if (tailOrNull == null) + break; + int j = fSharpList.HeadOrDefault; + Console.WriteLine(j); + fSharpList = tailOrNull; + tailOrNull = fSharpList.TailOrNull; + } + int[] array = new int[1] + { + 1 + }; + for (int j = 0; j < array.Length; j++) + { + Console.WriteLine(array[j]); + } + return 0; + } + } +} +namespace +{ + internal static class $Program + { + } + internal static class $AssemblyInfo + { + } +} +namespace .$.NETFramework,Version=v4.6.1 +{ + internal static class AssemblyAttributes + { + } +} diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Release.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Release.il new file mode 100644 index 000000000..5df4fe852 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/FSharpLoops_Release.il @@ -0,0 +1,561 @@ +// C:\Users\Siegfried\Documents\Visual Studio 2017\Projects\ConsoleApp13\ConsoleApplication1\bin\Release\ConsoleApplication1.exe + +.assembly extern mscorlib +{ + .publickeytoken = ( + b7 7a 5c 56 19 34 e0 89 + ) + .ver 4:0:0:0 +} +.assembly extern FSharp.Core +{ + .publickeytoken = ( + b0 3f 5f 7f 11 d5 0a 3a + ) + .ver 4:4:1:0 +} +.assembly ConsoleApplication1 +{ + .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 + ) + .custom instance void [mscorlib]System.Runtime.Versioning.TargetFrameworkAttribute::.ctor(string) = ( + 01 00 1c 2e 4e 45 54 46 72 61 6d 65 77 6f 72 6b + 2c 56 65 72 73 69 6f 6e 3d 76 34 2e 36 2e 31 01 + 00 54 0e 14 46 72 61 6d 65 77 6f 72 6b 44 69 73 + 70 6c 61 79 4e 61 6d 65 14 2e 4e 45 54 20 46 72 + 61 6d 65 77 6f 72 6b 20 34 2e 36 2e 31 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyTitleAttribute::.ctor(string) = ( + 01 00 13 43 6f 6e 73 6f 6c 65 41 70 70 6c 69 63 + 61 74 69 6f 6e 31 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyDescriptionAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyConfigurationAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyCompanyAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyProductAttribute::.ctor(string) = ( + 01 00 13 43 6f 6e 73 6f 6c 65 41 70 70 6c 69 63 + 61 74 69 6f 6e 31 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyCopyrightAttribute::.ctor(string) = ( + 01 00 12 43 6f 70 79 72 69 67 68 74 20 c2 a9 20 + 20 32 30 31 37 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyTrademarkAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyCultureAttribute::.ctor(string) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.InteropServices.ComVisibleAttribute::.ctor(bool) = ( + 01 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.InteropServices.GuidAttribute::.ctor(string) = ( + 01 00 24 65 30 36 37 34 66 66 35 2d 35 65 38 66 + 2d 34 64 34 65 2d 61 38 38 66 2d 65 34 34 37 31 + 39 32 34 35 34 63 37 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyVersionAttribute::.ctor(string) = ( + 01 00 07 31 2e 30 2e 30 2e 30 00 00 + ) + .custom instance void [mscorlib]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = ( + 01 00 07 31 2e 30 2e 30 2e 30 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( + 01 00 00 00 00 00 00 00 + ) + .hash algorithm 0x00008004 // SHA1 + .ver 1:0:0:0 +} + +.module ConsoleApplication1.exe +// MVID: {59F64D28-6A1F-D4CE-A745-0383284DF659} +.corflags 0x00020003 // ILOnly, Required32Bit, Preferred32Bit + + +.class private auto ansi '' + extends [mscorlib]System.Object +{ +} // end of class + +.class public auto ansi abstract sealed Program + extends [mscorlib]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 + ) + // Nested Types + .class nested assembly auto auto sealed specialname serializable beforefieldinit disposable@3 + extends [mscorlib]System.Object + implements [mscorlib]System.IDisposable + { + .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 + ) + // Methods + .method public specialname rtspecialname + instance void .ctor () cil managed + { + // Method begins at RVA 0x21bc + // Code size 9 (0x9) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: callvirt instance void [mscorlib]System.Object::.ctor() + IL_0006: ldarg.0 + IL_0007: pop + IL_0008: ret + } // end of method disposable@3::.ctor + + .method private final hidebysig newslot virtual + instance void 'System-IDisposable-Dispose' () cil managed + { + .override method instance void [mscorlib]System.IDisposable::Dispose() + // Method begins at RVA 0x21c8 + // Code size 1 (0x1) + .maxstack 8 + + IL_0000: ret + } // end of method disposable@3::'System-IDisposable-Dispose' + + } // end of class disposable@3 + + .class nested assembly auto auto sealed specialname serializable beforefieldinit getSeq@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 + ) + // Fields + .field public int32 pc + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( + 01 00 00 00 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + .field public int32 current + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( + 01 00 00 00 00 00 00 00 + ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + + // Methods + .method public specialname rtspecialname + instance void .ctor ( + int32 pc, + int32 current + ) cil managed + { + // Method begins at RVA 0x21cc + // Code size 21 (0x15) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 Program/getSeq@5::pc + IL_0007: ldarg.0 + IL_0008: ldarg.2 + IL_0009: stfld int32 Program/getSeq@5::current + IL_000e: ldarg.0 + IL_000f: call instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1::.ctor() + IL_0014: ret + } // end of method getSeq@5::.ctor + + .method public strict virtual + instance int32 GenerateNext ( + class [mscorlib]System.Collections.Generic.IEnumerable`1& next + ) cil managed + { + // Method begins at RVA 0x21e4 + // Code size 62 (0x3e) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldfld int32 Program/getSeq@5::pc + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: switch (IL_0018, IL_001b) + + IL_0015: nop + IL_0016: br.s IL_001e + + IL_0018: nop + IL_0019: br.s IL_002e + + IL_001b: nop + IL_001c: br.s IL_0035 + + IL_001e: ldarg.0 + IL_001f: ldc.i4.1 + IL_0020: stfld int32 Program/getSeq@5::pc + IL_0025: ldarg.0 + IL_0026: ldc.i4.1 + IL_0027: stfld int32 Program/getSeq@5::current + IL_002c: ldc.i4.1 + IL_002d: ret + + IL_002e: ldarg.0 + IL_002f: ldc.i4.2 + IL_0030: stfld int32 Program/getSeq@5::pc + + IL_0035: ldarg.0 + IL_0036: ldc.i4.0 + IL_0037: stfld int32 Program/getSeq@5::current + IL_003c: ldc.i4.0 + IL_003d: ret + } // end of method getSeq@5::GenerateNext + + .method public strict virtual + instance void Close () cil managed + { + // Method begins at RVA 0x2224 + // Code size 8 (0x8) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldc.i4.2 + IL_0002: stfld int32 Program/getSeq@5::pc + IL_0007: ret + } // end of method getSeq@5::Close + + .method public strict virtual + instance bool get_CheckClose () cil managed + { + // Method begins at RVA 0x2230 + // Code size 39 (0x27) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldfld int32 Program/getSeq@5::pc + IL_0006: switch (IL_001a, IL_001d, IL_0020) + + IL_0017: nop + IL_0018: br.s IL_0023 + + IL_001a: nop + IL_001b: br.s IL_0025 + + IL_001d: nop + IL_001e: br.s IL_0023 + + IL_0020: nop + IL_0021: br.s IL_0025 + + IL_0023: ldc.i4.0 + IL_0024: ret + + IL_0025: ldc.i4.0 + IL_0026: ret + } // end of method getSeq@5::get_CheckClose + + .method public strict virtual + instance int32 get_LastGenerated () cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + // Method begins at RVA 0x2258 + // Code size 7 (0x7) + .maxstack 8 + + IL_0000: ldarg.0 + IL_0001: ldfld int32 Program/getSeq@5::current + IL_0006: ret + } // end of method getSeq@5::get_LastGenerated + + .method public strict virtual + instance class [mscorlib]System.Collections.Generic.IEnumerator`1 GetFreshEnumerator () cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( + 01 00 00 00 + ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( + 01 00 00 00 + ) + // Method begins at RVA 0x2260 + // Code size 8 (0x8) + .maxstack 8 + + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void Program/getSeq@5::.ctor(int32, int32) + IL_0007: ret + } // end of method getSeq@5::GetFreshEnumerator + + } // end of class getSeq@5 + + + // Methods + .method public static + class [mscorlib]System.IDisposable disposable () cil managed + { + // Method begins at RVA 0x2050 + // Code size 6 (0x6) + .maxstack 8 + + IL_0000: newobj instance void Program/disposable@3::.ctor() + IL_0005: ret + } // end of method Program::disposable + + .method public static + class [mscorlib]System.Collections.Generic.IEnumerable`1 getSeq () cil managed + { + // Method begins at RVA 0x2058 + // Code size 8 (0x8) + .maxstack 8 + + IL_0000: ldc.i4.0 + IL_0001: ldc.i4.0 + IL_0002: newobj instance void Program/getSeq@5::.ctor(int32, int32) + IL_0007: ret + } // end of method Program::getSeq + + .method public static + class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 getList () cil managed + { + // Method begins at RVA 0x2064 + // Code size 12 (0xc) + .maxstack 8 + + IL_0000: ldc.i4.1 + IL_0001: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_0006: 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_000b: ret + } // end of method Program::getList + + .method public static + int32[] getArray () cil managed + { + // Method begins at RVA 0x2074 + // Code size 15 (0xf) + .maxstack 8 + + IL_0000: ldc.i4.1 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: dup + IL_0007: ldc.i4.0 + IL_0008: ldc.i4.1 + IL_0009: stelem.any [mscorlib]System.Int32 + IL_000e: ret + } // end of method Program::getArray + + .method public static + int32 main ( + string[] argv + ) cil managed + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.EntryPointAttribute::.ctor() = ( + 01 00 00 00 + ) + // Method begins at RVA 0x2084 + // Code size 259 (0x103) + .maxstack 6 + .entrypoint + .locals init ( + [0] class [mscorlib]System.IDisposable, + [1] class [mscorlib]System.IDisposable, + [2] class [mscorlib]System.IDisposable, + [3] class [mscorlib]System.IDisposable, + [4] int32, + [5] class [mscorlib]System.Collections.Generic.IEnumerable`1, + [6] class [mscorlib]System.Collections.Generic.IEnumerator`1, + [7] class [FSharp.Core]Microsoft.FSharp.Core.Unit, + [8] class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1, + [9] class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1, + [10] int32, + [11] int32[] + ) + + IL_0000: call class [mscorlib]System.IDisposable Program::disposable() + IL_0005: stloc.1 + .try + { + IL_0006: ldstr "Hello 1" + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: call class [mscorlib]System.IDisposable Program::disposable() + IL_0015: stloc.2 + IL_0016: leave.s IL_002e + } // end .try + finally + { + IL_0018: ldloc.1 + IL_0019: isinst [mscorlib]System.IDisposable + IL_001e: stloc.3 + IL_001f: ldloc.3 + IL_0020: brfalse.s IL_002b + + IL_0022: ldloc.3 + IL_0023: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_0028: ldnull + IL_0029: pop + IL_002a: endfinally + + IL_002b: ldnull + IL_002c: pop + IL_002d: endfinally + } // end handler + + IL_002e: ldloc.2 + IL_002f: stloc.0 + .try + { + IL_0030: call class [mscorlib]System.Collections.Generic.IEnumerable`1 Program::getSeq() + IL_0035: stloc.s 5 + IL_0037: ldloc.s 5 + IL_0039: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1 class [mscorlib]System.Collections.Generic.IEnumerable`1::GetEnumerator() + IL_003e: stloc.s 6 + .try + { + // loop start (head: IL_0040) + IL_0040: ldloc.s 6 + IL_0042: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext() + IL_0047: brfalse.s IL_0058 + + IL_0049: ldloc.s 6 + IL_004b: callvirt instance !0 class [mscorlib]System.Collections.Generic.IEnumerator`1::get_Current() + IL_0050: call void [mscorlib]System.Console::WriteLine(int32) + IL_0055: nop + IL_0056: br.s IL_0040 + // end loop + + IL_0058: ldnull + IL_0059: stloc.s 7 + IL_005b: leave.s IL_0074 + } // end .try + finally + { + IL_005d: ldloc.s 6 + IL_005f: isinst [mscorlib]System.IDisposable + IL_0064: stloc.1 + IL_0065: ldloc.1 + IL_0066: brfalse.s IL_0071 + + IL_0068: ldloc.1 + IL_0069: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_006e: ldnull + IL_006f: pop + IL_0070: endfinally + + IL_0071: ldnull + IL_0072: pop + IL_0073: endfinally + } // end handler + + IL_0074: ldloc.s 7 + IL_0076: pop + IL_0077: ldc.i4.1 + IL_0078: call class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_Empty() + IL_007d: 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_0082: stloc.s 8 + IL_0084: ldloc.s 8 + IL_0086: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_008b: stloc.s 9 + // loop start (head: IL_008d) + IL_008d: ldloc.s 9 + IL_008f: ldnull + IL_0090: cgt.un + IL_0092: brfalse.s IL_00b4 + + IL_0094: ldloc.s 8 + IL_0096: call instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_HeadOrDefault() + IL_009b: stloc.s 10 + IL_009d: ldloc.s 10 + IL_009f: call void [mscorlib]System.Console::WriteLine(int32) + IL_00a4: ldloc.s 9 + IL_00a6: stloc.s 8 + IL_00a8: ldloc.s 8 + IL_00aa: call instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1::get_TailOrNull() + IL_00af: stloc.s 9 + IL_00b1: nop + IL_00b2: br.s IL_008d + // end loop + + IL_00b4: ldc.i4.1 + IL_00b5: newarr [mscorlib]System.Int32 + IL_00ba: dup + IL_00bb: ldc.i4.0 + IL_00bc: ldc.i4.1 + IL_00bd: stelem.any [mscorlib]System.Int32 + IL_00c2: stloc.s 11 + IL_00c4: ldc.i4.0 + IL_00c5: stloc.s 10 + IL_00c7: br.s IL_00dd + // loop start (head: IL_00dd) + IL_00c9: ldloc.s 11 + IL_00cb: ldloc.s 10 + IL_00cd: ldelem.any [mscorlib]System.Int32 + IL_00d2: call void [mscorlib]System.Console::WriteLine(int32) + IL_00d7: ldloc.s 10 + IL_00d9: ldc.i4.1 + IL_00da: add + IL_00db: stloc.s 10 + + IL_00dd: ldloc.s 10 + IL_00df: ldloc.s 11 + IL_00e1: ldlen + IL_00e2: conv.i4 + IL_00e3: blt.s IL_00c9 + // end loop + + IL_00e5: ldc.i4.0 + IL_00e6: stloc.s 4 + IL_00e8: leave.s IL_0100 + } // end .try + finally + { + IL_00ea: ldloc.0 + IL_00eb: isinst [mscorlib]System.IDisposable + IL_00f0: stloc.1 + IL_00f1: ldloc.1 + IL_00f2: brfalse.s IL_00fd + + IL_00f4: ldloc.1 + IL_00f5: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_00fa: ldnull + IL_00fb: pop + IL_00fc: endfinally + + IL_00fd: ldnull + IL_00fe: pop + IL_00ff: endfinally + } // end handler + + IL_0100: ldloc.s 4 + IL_0102: ret + } // end of method Program::main + +} // end of class Program + +.class private auto ansi abstract sealed '.$Program' + extends [mscorlib]System.Object +{ +} // end of class .$Program + +.class private auto ansi abstract sealed '.$AssemblyInfo' + extends [mscorlib]System.Object +{ +} // end of class .$AssemblyInfo + +.class private auto ansi abstract sealed '.$.NETFramework,Version=v4.6.1.AssemblyAttributes' + extends [mscorlib]System.Object +{ +} // end of class .$.NETFramework,Version=v4.6.1.AssemblyAttributes +