pimhwang
/
ILSpy
mirror of https://github.com/icsharpcode/ILSpy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add basic support for C# 4 optional arguments.

pull/1218/merge
Siegfried Pammer 7 years ago
parent
4b5ee09603
commit
f956e16f58
9 changed files with 1457 additions and 18 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
  2. 6
      ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
  3. 95
      ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.cs
  4. 333
      ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.il
  5. 304
      ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.opt.il
  6. 302
      ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.opt.roslyn.il
  7. 334
      ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.roslyn.il
  8. 98
      ICSharpCode.Decompiler/CSharp/CallBuilder.cs
  9. 2
      ILSpy/Properties/AssemblyInfo.template.cs

1
ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
Unescape View File

@ -68,6 +68,7 @@
<Compile Include="Semantics\OverloadResolutionTests.cs" /> <Compile Include="Semantics\OverloadResolutionTests.cs" />
<Compile Include="DataFlowTest.cs" /> <Compile Include="DataFlowTest.cs" />
<Compile Include="TestCases\Correctness\RefLocalsAndReturns.cs" /> <Compile Include="TestCases\Correctness\RefLocalsAndReturns.cs" />
<Compile Include="TestCases\Pretty\OptionalArguments.cs" />
<Compile Include="TestCases\Pretty\TypeTests.cs" /> <Compile Include="TestCases\Pretty\TypeTests.cs" />
<None Include="TestCases\Disassembler\Pretty\SecurityDeclarations.il" /> <None Include="TestCases\Disassembler\Pretty\SecurityDeclarations.il" />
<Compile Include="TestCases\Pretty\CustomAttributeConflicts.cs" /> <Compile Include="TestCases\Pretty\CustomAttributeConflicts.cs" />

6
ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
Unescape View File

@ -302,6 +302,12 @@ namespace ICSharpCode.Decompiler.Tests
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test]
public void OptionalArguments([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test] [Test]
public void Issue1080([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions) public void Issue1080([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
{ {

95
ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.cs
Unescape View File

@ -0,0 +1,95 @@
// Copyright (c) 2018 Siegfried Pammer
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
// software and associated documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
{
internal class OptionalArguments
{
private void SimpleTests()
{
Test();
Test(5);
Test(10, "Hello World!");
}
private void Conflicts()
{
OnlyDifferenceIsLastArgument(5, 3, "Hello");
OnlyDifferenceIsLastArgument(5, 3, 3.141);
OnlyDifferenceIsLastArgument(5, 3, null);
OnlyDifferenceIsLastArgument(5, 3, double.NegativeInfinity);
OnlyDifferenceIsLastArgumentCastNecessary(10, "World", (string)null);
OnlyDifferenceIsLastArgumentCastNecessary(10, "Hello", (OptionalArguments)null);
DifferenceInArgumentCount();
DifferenceInArgumentCount("Hello");
DifferenceInArgumentCount("World");
}
private void ParamsTests()
{
ParamsMethod(5, 10, 9, 8);
ParamsMethod(null);
ParamsMethod(5);
ParamsMethod(10);
ParamsMethod(null, 1, 2, 3);
}
private void ParamsMethod(int a = 5, params int[] values)
{
}
private void ParamsMethod(string a = null, params int[] values)
{
}
private void DifferenceInArgumentCount()
{
}
private void DifferenceInArgumentCount(string a = "Hello")
{
}
private void Test(int a = 10, string b = "Test")
{
}
private void OnlyDifferenceIsLastArgument(int a, int b, string c = null)
{
}
private void OnlyDifferenceIsLastArgument(int a, int b, double d = double.NegativeInfinity)
{
}
private void OnlyDifferenceIsLastArgumentCastNecessary(int a, string b, string c = null)
{
}
private void OnlyDifferenceIsLastArgumentCastNecessary(int a, string b, OptionalArguments args = null)
{
}
private string Get(out int a)
{
throw null;
}
}
}

333
ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.il
Unescape View File

@ -0,0 +1,333 @@
// Metadata version: v4.0.30319
.assembly extern mscorlib
{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
.ver 4:0:0:0
}
.assembly OptionalArguments
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx
63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows.
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 )
.permissionset reqmin
= {[mscorlib]System.Security.Permissions.SecurityPermissionAttribute = {property bool 'SkipVerification' = bool(true)}}
.hash algorithm 0x00008004
.ver 0:0:0:0
}
.module OptionalArguments.dll
.custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 )
.imagebase 0x10000000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003 // WINDOWS_CUI
.corflags 0x00000001 // ILONLY
// =============== CLASS MEMBERS DECLARATION ===================
.class private auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
extends [mscorlib]System.Object
{
.method private hidebysig instance void
SimpleTests() cil managed
{
// Code size 43 (0x2b)
.maxstack 8
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldc.i4.s 10
IL_0004: ldstr "Test"
IL_0009: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_000e: nop
IL_000f: ldarg.0
IL_0010: ldc.i4.5
IL_0011: ldstr "Test"
IL_0016: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_001b: nop
IL_001c: ldarg.0
IL_001d: ldc.i4.s 10
IL_001f: ldstr "Hello World!"
IL_0024: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_0029: nop
IL_002a: ret
} // end of method OptionalArguments::SimpleTests
.method private hidebysig instance void
Conflicts() cil managed
{
// Code size 123 (0x7b)
.maxstack 4
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldc.i4.5
IL_0003: ldc.i4.3
IL_0004: ldstr "Hello"
IL_0009: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_000e: nop
IL_000f: ldarg.0
IL_0010: ldc.i4.5
IL_0011: ldc.i4.3
IL_0012: ldc.r8 3.141
IL_001b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_0020: nop
IL_0021: ldarg.0
IL_0022: ldc.i4.5
IL_0023: ldc.i4.3
IL_0024: ldnull
IL_0025: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_002a: nop
IL_002b: ldarg.0
IL_002c: ldc.i4.5
IL_002d: ldc.i4.3
IL_002e: ldc.r8 (00 00 00 00 00 00 F0 FF)
IL_0037: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_003c: nop
IL_003d: ldarg.0
IL_003e: ldc.i4.s 10
IL_0040: ldstr "World"
IL_0045: ldnull
IL_0046: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
string)
IL_004b: nop
IL_004c: ldarg.0
IL_004d: ldc.i4.s 10
IL_004f: ldstr "Hello"
IL_0054: ldnull
IL_0055: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments)
IL_005a: nop
IL_005b: ldarg.0
IL_005c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount()
IL_0061: nop
IL_0062: ldarg.0
IL_0063: ldstr "Hello"
IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_006d: nop
IL_006e: ldarg.0
IL_006f: ldstr "World"
IL_0074: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_0079: nop
IL_007a: ret
} // end of method OptionalArguments::Conflicts
.method private hidebysig instance void
ParamsTests() cil managed
{
// Code size 103 (0x67)
.maxstack 5
.locals init (int32[] V_0)
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldc.i4.5
IL_0003: ldc.i4.3
IL_0004: newarr [mscorlib]System.Int32
IL_0009: stloc.0
IL_000a: ldloc.0
IL_000b: ldc.i4.0
IL_000c: ldc.i4.s 10
IL_000e: stelem.i4
IL_000f: ldloc.0
IL_0010: ldc.i4.1
IL_0011: ldc.i4.s 9
IL_0013: stelem.i4
IL_0014: ldloc.0
IL_0015: ldc.i4.2
IL_0016: ldc.i4.8
IL_0017: stelem.i4
IL_0018: ldloc.0
IL_0019: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_001e: nop
IL_001f: ldarg.0
IL_0020: ldnull
IL_0021: ldc.i4.0
IL_0022: newarr [mscorlib]System.Int32
IL_0027: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_002c: nop
IL_002d: ldarg.0
IL_002e: ldc.i4.5
IL_002f: ldc.i4.0
IL_0030: newarr [mscorlib]System.Int32
IL_0035: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_003a: nop
IL_003b: ldarg.0
IL_003c: ldc.i4.s 10
IL_003e: ldc.i4.0
IL_003f: newarr [mscorlib]System.Int32
IL_0044: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0049: nop
IL_004a: ldarg.0
IL_004b: ldnull
IL_004c: ldc.i4.3
IL_004d: newarr [mscorlib]System.Int32
IL_0052: stloc.0
IL_0053: ldloc.0
IL_0054: ldc.i4.0
IL_0055: ldc.i4.1
IL_0056: stelem.i4
IL_0057: ldloc.0
IL_0058: ldc.i4.1
IL_0059: ldc.i4.2
IL_005a: stelem.i4
IL_005b: ldloc.0
IL_005c: ldc.i4.2
IL_005d: ldc.i4.3
IL_005e: stelem.i4
IL_005f: ldloc.0
IL_0060: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_0065: nop
IL_0066: ret
} // end of method OptionalArguments::ParamsTests
.method private hidebysig instance void
ParamsMethod([opt] int32 a,
int32[] values) cil managed
{
.param [1] = int32(0x00000005)
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
ParamsMethod([opt] string a,
int32[] values) cil managed
{
.param [1] = nullref
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
DifferenceInArgumentCount() cil managed
{
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
DifferenceInArgumentCount([opt] string a) cil managed
{
.param [1] = "Hello"
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
Test([opt] int32 a,
[opt] string b) cil managed
{
.param [1] = int32(0x0000000A)
.param [2] = "Test"
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::Test
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] float64 d) cil managed
{
.param [3] = float64(0xFFF0000000000000) // -1.#INF
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments args) cil managed
{
.param [3] = nullref
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance string
Get([out] int32& a) cil managed
{
// Code size 3 (0x3)
.maxstack 8
IL_0000: nop
IL_0001: ldnull
IL_0002: throw
} // end of method OptionalArguments::Get
.method public hidebysig specialname rtspecialname
instance void .ctor() cil managed
{
// Code size 7 (0x7)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: ret
} // end of method OptionalArguments::.ctor
} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
// =============================================================
// *********** DISASSEMBLY COMPLETE ***********************

304
ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.opt.il
Unescape View File

@ -0,0 +1,304 @@
// Metadata version: v4.0.30319
.assembly extern mscorlib
{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
.ver 4:0:0:0
}
.assembly OptionalArguments.opt
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx
63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows.
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 )
.permissionset reqmin
= {[mscorlib]System.Security.Permissions.SecurityPermissionAttribute = {property bool 'SkipVerification' = bool(true)}}
.hash algorithm 0x00008004
.ver 0:0:0:0
}
.module OptionalArguments.opt.dll
.custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 )
.imagebase 0x10000000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003 // WINDOWS_CUI
.corflags 0x00000001 // ILONLY
// =============== CLASS MEMBERS DECLARATION ===================
.class private auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
extends [mscorlib]System.Object
{
.method private hidebysig instance void
SimpleTests() cil managed
{
// Code size 39 (0x27)
.maxstack 8
IL_0000: ldarg.0
IL_0001: ldc.i4.s 10
IL_0003: ldstr "Test"
IL_0008: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_000d: ldarg.0
IL_000e: ldc.i4.5
IL_000f: ldstr "Test"
IL_0014: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_0019: ldarg.0
IL_001a: ldc.i4.s 10
IL_001c: ldstr "Hello World!"
IL_0021: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_0026: ret
} // end of method OptionalArguments::SimpleTests
.method private hidebysig instance void
Conflicts() cil managed
{
// Code size 113 (0x71)
.maxstack 4
IL_0000: ldarg.0
IL_0001: ldc.i4.5
IL_0002: ldc.i4.3
IL_0003: ldstr "Hello"
IL_0008: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_000d: ldarg.0
IL_000e: ldc.i4.5
IL_000f: ldc.i4.3
IL_0010: ldc.r8 3.141
IL_0019: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_001e: ldarg.0
IL_001f: ldc.i4.5
IL_0020: ldc.i4.3
IL_0021: ldnull
IL_0022: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_0027: ldarg.0
IL_0028: ldc.i4.5
IL_0029: ldc.i4.3
IL_002a: ldc.r8 (00 00 00 00 00 00 F0 FF)
IL_0033: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_0038: ldarg.0
IL_0039: ldc.i4.s 10
IL_003b: ldstr "World"
IL_0040: ldnull
IL_0041: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
string)
IL_0046: ldarg.0
IL_0047: ldc.i4.s 10
IL_0049: ldstr "Hello"
IL_004e: ldnull
IL_004f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments)
IL_0054: ldarg.0
IL_0055: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount()
IL_005a: ldarg.0
IL_005b: ldstr "Hello"
IL_0060: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_0065: ldarg.0
IL_0066: ldstr "World"
IL_006b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_0070: ret
} // end of method OptionalArguments::Conflicts
.method private hidebysig instance void
ParamsTests() cil managed
{
// Code size 97 (0x61)
.maxstack 5
.locals init (int32[] V_0,
int32[] V_1)
IL_0000: ldarg.0
IL_0001: ldc.i4.5
IL_0002: ldc.i4.3
IL_0003: newarr [mscorlib]System.Int32
IL_0008: stloc.0
IL_0009: ldloc.0
IL_000a: ldc.i4.0
IL_000b: ldc.i4.s 10
IL_000d: stelem.i4
IL_000e: ldloc.0
IL_000f: ldc.i4.1
IL_0010: ldc.i4.s 9
IL_0012: stelem.i4
IL_0013: ldloc.0
IL_0014: ldc.i4.2
IL_0015: ldc.i4.8
IL_0016: stelem.i4
IL_0017: ldloc.0
IL_0018: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_001d: ldarg.0
IL_001e: ldnull
IL_001f: ldc.i4.0
IL_0020: newarr [mscorlib]System.Int32
IL_0025: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_002a: ldarg.0
IL_002b: ldc.i4.5
IL_002c: ldc.i4.0
IL_002d: newarr [mscorlib]System.Int32
IL_0032: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0037: ldarg.0
IL_0038: ldc.i4.s 10
IL_003a: ldc.i4.0
IL_003b: newarr [mscorlib]System.Int32
IL_0040: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0045: ldarg.0
IL_0046: ldnull
IL_0047: ldc.i4.3
IL_0048: newarr [mscorlib]System.Int32
IL_004d: stloc.1
IL_004e: ldloc.1
IL_004f: ldc.i4.0
IL_0050: ldc.i4.1
IL_0051: stelem.i4
IL_0052: ldloc.1
IL_0053: ldc.i4.1
IL_0054: ldc.i4.2
IL_0055: stelem.i4
IL_0056: ldloc.1
IL_0057: ldc.i4.2
IL_0058: ldc.i4.3
IL_0059: stelem.i4
IL_005a: ldloc.1
IL_005b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_0060: ret
} // end of method OptionalArguments::ParamsTests
.method private hidebysig instance void
ParamsMethod([opt] int32 a,
int32[] values) cil managed
{
.param [1] = int32(0x00000005)
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
ParamsMethod([opt] string a,
int32[] values) cil managed
{
.param [1] = nullref
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
DifferenceInArgumentCount() cil managed
{
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
DifferenceInArgumentCount([opt] string a) cil managed
{
.param [1] = "Hello"
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
Test([opt] int32 a,
[opt] string b) cil managed
{
.param [1] = int32(0x0000000A)
.param [2] = "Test"
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::Test
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] float64 d) cil managed
{
.param [3] = float64(0xFFF0000000000000) // -1.#INF
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments args) cil managed
{
.param [3] = nullref
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance string
Get([out] int32& a) cil managed
{
// Code size 2 (0x2)
.maxstack 8
IL_0000: ldnull
IL_0001: throw
} // end of method OptionalArguments::Get
.method public hidebysig specialname rtspecialname
instance void .ctor() cil managed
{
// Code size 7 (0x7)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: ret
} // end of method OptionalArguments::.ctor
} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
// =============================================================
// *********** DISASSEMBLY COMPLETE ***********************

302
ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.opt.roslyn.il
Unescape View File

@ -0,0 +1,302 @@
// Metadata version: v4.0.30319
.assembly extern mscorlib
{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
.ver 4:0:0:0
}
.assembly OptionalArguments
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 )
.custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx
63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows.
// --- The following custom attribute is added automatically, do not uncomment -------
// .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 02 00 00 00 00 00 )
.permissionset reqmin
= {[mscorlib]System.Security.Permissions.SecurityPermissionAttribute = {property bool 'SkipVerification' = bool(true)}}
.hash algorithm 0x00008004
.ver 0:0:0:0
}
.module OptionalArguments.dll
.custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 )
.imagebase 0x10000000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003 // WINDOWS_CUI
.corflags 0x00000001 // ILONLY
// =============== CLASS MEMBERS DECLARATION ===================
.class private auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
extends [mscorlib]System.Object
{
.method private hidebysig instance void
SimpleTests() cil managed
{
// Code size 39 (0x27)
.maxstack 8
IL_0000: ldarg.0
IL_0001: ldc.i4.s 10
IL_0003: ldstr "Test"
IL_0008: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_000d: ldarg.0
IL_000e: ldc.i4.5
IL_000f: ldstr "Test"
IL_0014: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_0019: ldarg.0
IL_001a: ldc.i4.s 10
IL_001c: ldstr "Hello World!"
IL_0021: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_0026: ret
} // end of method OptionalArguments::SimpleTests
.method private hidebysig instance void
Conflicts() cil managed
{
// Code size 113 (0x71)
.maxstack 4
IL_0000: ldarg.0
IL_0001: ldc.i4.5
IL_0002: ldc.i4.3
IL_0003: ldstr "Hello"
IL_0008: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_000d: ldarg.0
IL_000e: ldc.i4.5
IL_000f: ldc.i4.3
IL_0010: ldc.r8 3.141
IL_0019: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_001e: ldarg.0
IL_001f: ldc.i4.5
IL_0020: ldc.i4.3
IL_0021: ldnull
IL_0022: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_0027: ldarg.0
IL_0028: ldc.i4.5
IL_0029: ldc.i4.3
IL_002a: ldc.r8 (00 00 00 00 00 00 F0 FF)
IL_0033: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_0038: ldarg.0
IL_0039: ldc.i4.s 10
IL_003b: ldstr "World"
IL_0040: ldnull
IL_0041: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
string)
IL_0046: ldarg.0
IL_0047: ldc.i4.s 10
IL_0049: ldstr "Hello"
IL_004e: ldnull
IL_004f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments)
IL_0054: ldarg.0
IL_0055: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount()
IL_005a: ldarg.0
IL_005b: ldstr "Hello"
IL_0060: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_0065: ldarg.0
IL_0066: ldstr "World"
IL_006b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_0070: ret
} // end of method OptionalArguments::Conflicts
.method private hidebysig instance void
ParamsTests() cil managed
{
// Code size 86 (0x56)
.maxstack 5
IL_0000: ldarg.0
IL_0001: ldc.i4.5
IL_0002: ldc.i4.3
IL_0003: newarr [mscorlib]System.Int32
IL_0008: dup
IL_0009: ldtoken field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' '<PrivateImplementationDetails>'::'0F3DD643C5167ACFC541F72809FFF828A6E41494'
IL_000e: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
valuetype [mscorlib]System.RuntimeFieldHandle)
IL_0013: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0018: ldarg.0
IL_0019: ldnull
IL_001a: call !!0[] [mscorlib]System.Array::Empty<int32>()
IL_001f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_0024: ldarg.0
IL_0025: ldc.i4.5
IL_0026: call !!0[] [mscorlib]System.Array::Empty<int32>()
IL_002b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0030: ldarg.0
IL_0031: ldc.i4.s 10
IL_0033: call !!0[] [mscorlib]System.Array::Empty<int32>()
IL_0038: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_003d: ldarg.0
IL_003e: ldnull
IL_003f: ldc.i4.3
IL_0040: newarr [mscorlib]System.Int32
IL_0045: dup
IL_0046: ldtoken field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' '<PrivateImplementationDetails>'::E429CCA3F703A39CC5954A6572FEC9086135B34E
IL_004b: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
valuetype [mscorlib]System.RuntimeFieldHandle)
IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_0055: ret
} // end of method OptionalArguments::ParamsTests
.method private hidebysig instance void
ParamsMethod([opt] int32 a,
int32[] values) cil managed
{
.param [1] = int32(0x00000005)
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
ParamsMethod([opt] string a,
int32[] values) cil managed
{
.param [1] = nullref
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
DifferenceInArgumentCount() cil managed
{
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
DifferenceInArgumentCount([opt] string a) cil managed
{
.param [1] = "Hello"
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
Test([opt] int32 a,
[opt] string b) cil managed
{
.param [1] = int32(0x0000000A)
.param [2] = "Test"
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::Test
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] float64 d) cil managed
{
.param [3] = float64(0xFFF0000000000000) // -1.#INF
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments args) cil managed
{
.param [3] = nullref
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance string
Get([out] int32& a) cil managed
{
// Code size 2 (0x2)
.maxstack 8
IL_0000: ldnull
IL_0001: throw
} // end of method OptionalArguments::Get
.method public hidebysig specialname rtspecialname
instance void .ctor() cil managed
{
// Code size 7 (0x7)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: ret
} // end of method OptionalArguments::.ctor
} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
.class private auto ansi sealed '<PrivateImplementationDetails>'
extends [mscorlib]System.Object
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
.class explicit ansi sealed nested private '__StaticArrayInitTypeSize=12'
extends [mscorlib]System.ValueType
{
.pack 1
.size 12
} // end of class '__StaticArrayInitTypeSize=12'
.field static assembly initonly valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' '0F3DD643C5167ACFC541F72809FFF828A6E41494' at I_00002A74
.field static assembly initonly valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' E429CCA3F703A39CC5954A6572FEC9086135B34E at I_00002A84
} // end of class '<PrivateImplementationDetails>'
// =============================================================
.data cil I_00002A74 = bytearray (
0A 00 00 00 09 00 00 00 08 00 00 00)
.data cil I_00002A84 = bytearray (
01 00 00 00 02 00 00 00 03 00 00 00)
// *********** DISASSEMBLY COMPLETE ***********************

334
ICSharpCode.Decompiler.Tests/TestCases/Pretty/OptionalArguments.roslyn.il
Unescape View File

@ -0,0 +1,334 @@
// Metadata version: v4.0.30319
.assembly extern mscorlib
{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
.ver 4:0:0:0
}
.assembly OptionalArguments
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 )
.custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx
63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows.
// --- The following custom attribute is added automatically, do not uncomment -------
// .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 07 01 00 00 00 00 )
.permissionset reqmin
= {[mscorlib]System.Security.Permissions.SecurityPermissionAttribute = {property bool 'SkipVerification' = bool(true)}}
.hash algorithm 0x00008004
.ver 0:0:0:0
}
.module OptionalArguments.dll
.custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 )
.imagebase 0x10000000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003 // WINDOWS_CUI
.corflags 0x00000001 // ILONLY
// =============== CLASS MEMBERS DECLARATION ===================
.class private auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
extends [mscorlib]System.Object
{
.method private hidebysig instance void
SimpleTests() cil managed
{
// Code size 43 (0x2b)
.maxstack 8
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldc.i4.s 10
IL_0004: ldstr "Test"
IL_0009: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_000e: nop
IL_000f: ldarg.0
IL_0010: ldc.i4.5
IL_0011: ldstr "Test"
IL_0016: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_001b: nop
IL_001c: ldarg.0
IL_001d: ldc.i4.s 10
IL_001f: ldstr "Hello World!"
IL_0024: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::Test(int32,
string)
IL_0029: nop
IL_002a: ret
} // end of method OptionalArguments::SimpleTests
.method private hidebysig instance void
Conflicts() cil managed
{
// Code size 123 (0x7b)
.maxstack 4
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldc.i4.5
IL_0003: ldc.i4.3
IL_0004: ldstr "Hello"
IL_0009: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_000e: nop
IL_000f: ldarg.0
IL_0010: ldc.i4.5
IL_0011: ldc.i4.3
IL_0012: ldc.r8 3.141
IL_001b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_0020: nop
IL_0021: ldarg.0
IL_0022: ldc.i4.5
IL_0023: ldc.i4.3
IL_0024: ldnull
IL_0025: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
string)
IL_002a: nop
IL_002b: ldarg.0
IL_002c: ldc.i4.5
IL_002d: ldc.i4.3
IL_002e: ldc.r8 (00 00 00 00 00 00 F0 FF)
IL_0037: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgument(int32,
int32,
float64)
IL_003c: nop
IL_003d: ldarg.0
IL_003e: ldc.i4.s 10
IL_0040: ldstr "World"
IL_0045: ldnull
IL_0046: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
string)
IL_004b: nop
IL_004c: ldarg.0
IL_004d: ldc.i4.s 10
IL_004f: ldstr "Hello"
IL_0054: ldnull
IL_0055: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary(int32,
string,
class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments)
IL_005a: nop
IL_005b: ldarg.0
IL_005c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount()
IL_0061: nop
IL_0062: ldarg.0
IL_0063: ldstr "Hello"
IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_006d: nop
IL_006e: ldarg.0
IL_006f: ldstr "World"
IL_0074: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::DifferenceInArgumentCount(string)
IL_0079: nop
IL_007a: ret
} // end of method OptionalArguments::Conflicts
.method private hidebysig instance void
ParamsTests() cil managed
{
// Code size 92 (0x5c)
.maxstack 5
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldc.i4.5
IL_0003: ldc.i4.3
IL_0004: newarr [mscorlib]System.Int32
IL_0009: dup
IL_000a: ldtoken field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' '<PrivateImplementationDetails>'::'0F3DD643C5167ACFC541F72809FFF828A6E41494'
IL_000f: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
valuetype [mscorlib]System.RuntimeFieldHandle)
IL_0014: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0019: nop
IL_001a: ldarg.0
IL_001b: ldnull
IL_001c: call !!0[] [mscorlib]System.Array::Empty<int32>()
IL_0021: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_0026: nop
IL_0027: ldarg.0
IL_0028: ldc.i4.5
IL_0029: call !!0[] [mscorlib]System.Array::Empty<int32>()
IL_002e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0033: nop
IL_0034: ldarg.0
IL_0035: ldc.i4.s 10
IL_0037: call !!0[] [mscorlib]System.Array::Empty<int32>()
IL_003c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(int32,
int32[])
IL_0041: nop
IL_0042: ldarg.0
IL_0043: ldnull
IL_0044: ldc.i4.3
IL_0045: newarr [mscorlib]System.Int32
IL_004a: dup
IL_004b: ldtoken field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' '<PrivateImplementationDetails>'::E429CCA3F703A39CC5954A6572FEC9086135B34E
IL_0050: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
valuetype [mscorlib]System.RuntimeFieldHandle)
IL_0055: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments::ParamsMethod(string,
int32[])
IL_005a: nop
IL_005b: ret
} // end of method OptionalArguments::ParamsTests
.method private hidebysig instance void
ParamsMethod([opt] int32 a,
int32[] values) cil managed
{
.param [1] = int32(0x00000005)
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
ParamsMethod([opt] string a,
int32[] values) cil managed
{
.param [1] = nullref
.param [2]
.custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::ParamsMethod
.method private hidebysig instance void
DifferenceInArgumentCount() cil managed
{
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
DifferenceInArgumentCount([opt] string a) cil managed
{
.param [1] = "Hello"
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::DifferenceInArgumentCount
.method private hidebysig instance void
Test([opt] int32 a,
[opt] string b) cil managed
{
.param [1] = int32(0x0000000A)
.param [2] = "Test"
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::Test
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgument(int32 a,
int32 b,
[opt] float64 d) cil managed
{
.param [3] = float64(0xFFF0000000000000) // -1.#INF
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgument
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] string c) cil managed
{
.param [3] = nullref
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance void
OnlyDifferenceIsLastArgumentCastNecessary(int32 a,
string b,
[opt] class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments args) cil managed
{
.param [3] = nullref
// Code size 2 (0x2)
.maxstack 8
IL_0000: nop
IL_0001: ret
} // end of method OptionalArguments::OnlyDifferenceIsLastArgumentCastNecessary
.method private hidebysig instance string
Get([out] int32& a) cil managed
{
// Code size 3 (0x3)
.maxstack 8
IL_0000: nop
IL_0001: ldnull
IL_0002: throw
} // end of method OptionalArguments::Get
.method public hidebysig specialname rtspecialname
instance void .ctor() cil managed
{
// Code size 8 (0x8)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: nop
IL_0007: ret
} // end of method OptionalArguments::.ctor
} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.OptionalArguments
.class private auto ansi sealed '<PrivateImplementationDetails>'
extends [mscorlib]System.Object
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
.class explicit ansi sealed nested private '__StaticArrayInitTypeSize=12'
extends [mscorlib]System.ValueType
{
.pack 1
.size 12
} // end of class '__StaticArrayInitTypeSize=12'
.field static assembly initonly valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' '0F3DD643C5167ACFC541F72809FFF828A6E41494' at I_00002A90
.field static assembly initonly valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12' E429CCA3F703A39CC5954A6572FEC9086135B34E at I_00002AA0
} // end of class '<PrivateImplementationDetails>'
// =============================================================
.data cil I_00002A90 = bytearray (
0A 00 00 00 09 00 00 00 08 00 00 00)
.data cil I_00002A9C = int8[4]
.data cil I_00002AA0 = bytearray (
01 00 00 00 02 00 00 00 03 00 00 00)
// *********** DISASSEMBLY COMPLETE ***********************

98
ICSharpCode.Decompiler/CSharp/CallBuilder.cs
Unescape View File

@ -120,9 +120,22 @@ namespace ICSharpCode.Decompiler.CSharp
Debug.Assert(callArguments.Count == firstParamIndex + method.Parameters.Count); Debug.Assert(callArguments.Count == firstParamIndex + method.Parameters.Count);
var expectedParameters = new List<IParameter>(arguments.Count); // parameters, but in argument order var expectedParameters = new List<IParameter>(arguments.Count); // parameters, but in argument order
bool isExpandedForm = false; bool isExpandedForm = false;
// Optional arguments:
// We only allow removing optional arguments in the following cases:
// - call arguments are not in expanded form
// - there are no named arguments
// This value has the following following values:
// -2 - there are no optional arguments
// -1 - optional arguments are forbidden
// >= 0 - the index of the first argument that can be removed, because it is optional
// and is the default value of the parameter.
int firstOptionalArgumentIndex = -2;
for (int i = firstParamIndex; i < callArguments.Count; i++) { for (int i = firstParamIndex; i < callArguments.Count; i++) {
IParameter parameter; IParameter parameter;
if (argumentToParameterMap != null) { if (argumentToParameterMap != null) {
// Don't use optional arguments, if we have to use named arguments.
firstOptionalArgumentIndex = -1;
if (argumentNames == null && argumentToParameterMap[i] != i - firstParamIndex) { if (argumentNames == null && argumentToParameterMap[i] != i - firstParamIndex) {
// Starting at the first argument that is out-of-place, // Starting at the first argument that is out-of-place,
// assign names to that argument and all following arguments: // assign names to that argument and all following arguments:
@ -136,6 +149,12 @@ namespace ICSharpCode.Decompiler.CSharp
parameter = method.Parameters[i - firstParamIndex]; parameter = method.Parameters[i - firstParamIndex];
} }
var arg = expressionBuilder.Translate(callArguments[i], parameter.Type); var arg = expressionBuilder.Translate(callArguments[i], parameter.Type);
if (IsOptionalArgument(parameter, arg)) {
if (firstOptionalArgumentIndex == -2)
firstOptionalArgumentIndex = i - firstParamIndex;
} else {
firstOptionalArgumentIndex = -2;
}
if (parameter.IsParams && i + 1 == callArguments.Count && argumentToParameterMap == null) { if (parameter.IsParams && i + 1 == callArguments.Count && argumentToParameterMap == null) {
// Parameter is marked params // Parameter is marked params
// If the argument is an array creation, inline all elements into the call and add missing default values. // If the argument is an array creation, inline all elements into the call and add missing default values.
@ -143,6 +162,7 @@ namespace ICSharpCode.Decompiler.CSharp
if (TransformParamsArgument(expectedTargetDetails, target.ResolveResult, method, parameter, if (TransformParamsArgument(expectedTargetDetails, target.ResolveResult, method, parameter,
arg, ref expectedParameters, ref arguments)) { arg, ref expectedParameters, ref arguments)) {
Debug.Assert(argumentNames == null); Debug.Assert(argumentNames == null);
firstOptionalArgumentIndex = -1;
isExpandedForm = true; isExpandedForm = true;
continue; continue;
} }
@ -166,6 +186,7 @@ namespace ICSharpCode.Decompiler.CSharp
} }
if (method is VarArgInstanceMethod) { if (method is VarArgInstanceMethod) {
firstOptionalArgumentIndex = -1;
int regularParameterCount = ((VarArgInstanceMethod)method).RegularParameterCount; int regularParameterCount = ((VarArgInstanceMethod)method).RegularParameterCount;
var argListArg = new UndocumentedExpression(); var argListArg = new UndocumentedExpression();
argListArg.UndocumentedExpressionType = UndocumentedExpressionType.ArgList; argListArg.UndocumentedExpressionType = UndocumentedExpressionType.ArgList;
@ -203,7 +224,7 @@ namespace ICSharpCode.Decompiler.CSharp
return atce return atce
.WithRR(rr); .WithRR(rr);
} else { } else {
if (IsUnambiguousCall(expectedTargetDetails, method, null, Empty<IType>.Array, arguments, argumentNames, out _) != OverloadResolutionErrors.None) { if (IsUnambiguousCall(expectedTargetDetails, method, null, Empty<IType>.Array, arguments, argumentNames, firstOptionalArgumentIndex, out _) != OverloadResolutionErrors.None) {
CastArguments(arguments, expectedParameters); CastArguments(arguments, expectedParameters);
} }
return new ObjectCreateExpression( return new ObjectCreateExpression(
@ -227,7 +248,7 @@ namespace ICSharpCode.Decompiler.CSharp
return HandleImplicitConversion(method, arguments[0]); return HandleImplicitConversion(method, arguments[0]);
} else { } else {
var transform = GetRequiredTransformationsForCall(expectedTargetDetails, method, ref target, var transform = GetRequiredTransformationsForCall(expectedTargetDetails, method, ref target,
arguments, argumentNames, expectedParameters, CallTransformation.All, out IParameterizedMember foundMethod); arguments, argumentNames, firstOptionalArgumentIndex, expectedParameters, CallTransformation.All, out IParameterizedMember foundMethod);
// Note: after this, 'method' and 'foundMethod' may differ, // Note: after this, 'method' and 'foundMethod' may differ,
// but as far as allowed by IsAppropriateCallTarget(). // but as far as allowed by IsAppropriateCallTarget().
@ -235,6 +256,9 @@ namespace ICSharpCode.Decompiler.CSharp
Expression targetExpr; Expression targetExpr;
string methodName = method.Name; string methodName = method.Name;
AstNodeCollection<AstType> typeArgumentList; AstNodeCollection<AstType> typeArgumentList;
if ((transform & CallTransformation.NoOptionalArgumentAllowed) != 0) {
firstOptionalArgumentIndex = -1;
}
if ((transform & CallTransformation.RequireTarget) != 0) { if ((transform & CallTransformation.RequireTarget) != 0) {
targetExpr = new MemberReferenceExpression(target.Expression, methodName); targetExpr = new MemberReferenceExpression(target.Expression, methodName);
typeArgumentList = ((MemberReferenceExpression)targetExpr).TypeArguments; typeArgumentList = ((MemberReferenceExpression)targetExpr).TypeArguments;
@ -256,8 +280,8 @@ namespace ICSharpCode.Decompiler.CSharp
if ((transform & CallTransformation.RequireTypeArguments) != 0 && (!settings.AnonymousTypes || !method.TypeArguments.Any(a => a.ContainsAnonymousType()))) if ((transform & CallTransformation.RequireTypeArguments) != 0 && (!settings.AnonymousTypes || !method.TypeArguments.Any(a => a.ContainsAnonymousType())))
typeArgumentList.AddRange(method.TypeArguments.Select(expressionBuilder.ConvertType)); typeArgumentList.AddRange(method.TypeArguments.Select(expressionBuilder.ConvertType));
var argumentExpressions = GetArgumentExpressions(arguments, argumentNames); var argumentExpressions = GetArgumentExpressions(arguments, argumentNames);
return new InvocationExpression(targetExpr, argumentExpressions) return new InvocationExpression(targetExpr, firstOptionalArgumentIndex < 0 ? argumentExpressions : argumentExpressions.Take(firstOptionalArgumentIndex).ToArray())
.WithRR(new CSharpInvocationResolveResult(target.ResolveResult, foundMethod, argumentResolveResults, isExpandedForm: isExpandedForm)); .WithRR(new CSharpInvocationResolveResult(target.ResolveResult, foundMethod, firstOptionalArgumentIndex < 0 ? argumentResolveResults : argumentResolveResults.Take(firstOptionalArgumentIndex).ToList(), isExpandedForm: isExpandedForm));
} }
} }
} }
@ -327,7 +351,7 @@ namespace ICSharpCode.Decompiler.CSharp
var unused = new IdentifierExpression("initializedObject").WithRR(target).WithoutILInstruction(); var unused = new IdentifierExpression("initializedObject").WithRR(target).WithoutILInstruction();
var transform = GetRequiredTransformationsForCall(expectedTargetDetails, method, ref unused, var transform = GetRequiredTransformationsForCall(expectedTargetDetails, method, ref unused,
arguments, null, expectedParameters, CallTransformation.None, out IParameterizedMember foundMethod); arguments, null, -1, expectedParameters, CallTransformation.None, out IParameterizedMember foundMethod);
Debug.Assert(transform == CallTransformation.None); Debug.Assert(transform == CallTransformation.None);
// Calls with only one argument do not need an array initializer expression to wrap them. // Calls with only one argument do not need an array initializer expression to wrap them.
@ -344,15 +368,11 @@ namespace ICSharpCode.Decompiler.CSharp
IMethod method, IParameter parameter, TranslatedExpression arg, ref List<IParameter> expectedParameters, IMethod method, IParameter parameter, TranslatedExpression arg, ref List<IParameter> expectedParameters,
ref List<TranslatedExpression> arguments) ref List<TranslatedExpression> arguments)
{ {
if (arg.ResolveResult is ArrayCreateResolveResult acrr && if (CheckArgument(out int length, out IType elementType)) {
acrr.SizeArguments.Count == 1 &&
acrr.SizeArguments[0].IsCompileTimeConstant &&
acrr.SizeArguments[0].ConstantValue is int length) {
var expandedParameters = new List<IParameter>(expectedParameters); var expandedParameters = new List<IParameter>(expectedParameters);
var expandedArguments = new List<TranslatedExpression>(arguments); var expandedArguments = new List<TranslatedExpression>(arguments);
if (length > 0) { if (length > 0) {
var arrayElements = ((ArrayCreateExpression)arg.Expression).Initializer.Elements.ToArray(); var arrayElements = ((ArrayCreateExpression)arg.Expression).Initializer.Elements.ToArray();
var elementType = ((ArrayType)acrr.Type).ElementType;
for (int j = 0; j < length; j++) { for (int j = 0; j < length; j++) {
expandedParameters.Add(new DefaultParameter(elementType, parameter.Name + j)); expandedParameters.Add(new DefaultParameter(elementType, parameter.Name + j));
if (j < arrayElements.Length) if (j < arrayElements.Length)
@ -361,13 +381,47 @@ namespace ICSharpCode.Decompiler.CSharp
expandedArguments.Add(expressionBuilder.GetDefaultValueExpression(elementType).WithoutILInstruction()); expandedArguments.Add(expressionBuilder.GetDefaultValueExpression(elementType).WithoutILInstruction());
} }
} }
if (IsUnambiguousCall(expectedTargetDetails, method, targetResolveResult, Empty<IType>.Array, expandedArguments, null, out _) == OverloadResolutionErrors.None) { if (IsUnambiguousCall(expectedTargetDetails, method, targetResolveResult, Empty<IType>.Array, expandedArguments, null, -1, out _) == OverloadResolutionErrors.None) {
expectedParameters = expandedParameters; expectedParameters = expandedParameters;
arguments = expandedArguments.SelectList(a => new TranslatedExpression(a.Expression.Detach())); arguments = expandedArguments.SelectList(a => new TranslatedExpression(a.Expression.Detach()));
return true; return true;
} }
} }
return false; return false;
bool CheckArgument(out int len, out IType t)
{
len = 0;
t = null;
if (arg.ResolveResult is CSharpInvocationResolveResult csirr &&
csirr.Arguments.Count == 0 && csirr.Member is IMethod emptyMethod &&
emptyMethod.IsStatic &&
"System.Array.Empty" == emptyMethod.FullName &&
emptyMethod.TypeArguments.Count == 1)
{
t = emptyMethod.TypeArguments[0];
return true;
}
if (arg.ResolveResult is ArrayCreateResolveResult acrr &&
acrr.SizeArguments.Count == 1 &&
acrr.SizeArguments[0].IsCompileTimeConstant &&
acrr.SizeArguments[0].ConstantValue is int l)
{
len = l;
t = ((ArrayType)acrr.Type).ElementType;
return true;
}
return false;
}
}
bool IsOptionalArgument(IParameter parameter, TranslatedExpression arg)
{
if (!parameter.IsOptional || !arg.ResolveResult.IsCompileTimeConstant)
return false;
return (parameter.ConstantValue == null && arg.ResolveResult.ConstantValue == null)
|| (parameter.ConstantValue != null && parameter.ConstantValue.Equals(arg.ResolveResult.ConstantValue));
} }
[Flags] [Flags]
@ -376,11 +430,12 @@ namespace ICSharpCode.Decompiler.CSharp
None = 0, None = 0,
RequireTarget = 1, RequireTarget = 1,
RequireTypeArguments = 2, RequireTypeArguments = 2,
All = 3 NoOptionalArgumentAllowed = 4,
All = 7
} }
private CallTransformation GetRequiredTransformationsForCall(ExpectedTargetDetails expectedTargetDetails, IMethod method, private CallTransformation GetRequiredTransformationsForCall(ExpectedTargetDetails expectedTargetDetails, IMethod method,
ref TranslatedExpression target, List<TranslatedExpression> arguments, string[] argumentNames, ref TranslatedExpression target, List<TranslatedExpression> arguments, string[] argumentNames, int firstOptionalArgumentIndex,
List<IParameter> expectedParameters, CallTransformation allowedTransforms, out IParameterizedMember foundMethod) List<IParameter> expectedParameters, CallTransformation allowedTransforms, out IParameterizedMember foundMethod)
{ {
CallTransformation transform = CallTransformation.None; CallTransformation transform = CallTransformation.None;
@ -437,7 +492,7 @@ namespace ICSharpCode.Decompiler.CSharp
bool targetCasted = false; bool targetCasted = false;
bool argumentsCasted = false; bool argumentsCasted = false;
OverloadResolutionErrors errors; OverloadResolutionErrors errors;
while ((errors = IsUnambiguousCall(expectedTargetDetails, method, targetResolveResult, typeArguments, arguments, argumentNames, out foundMethod)) != OverloadResolutionErrors.None) { while ((errors = IsUnambiguousCall(expectedTargetDetails, method, targetResolveResult, typeArguments, arguments, argumentNames, firstOptionalArgumentIndex, out foundMethod)) != OverloadResolutionErrors.None) {
switch (errors) { switch (errors) {
case OverloadResolutionErrors.TypeInferenceFailed: case OverloadResolutionErrors.TypeInferenceFailed:
if ((allowedTransforms & CallTransformation.RequireTypeArguments) != 0) { if ((allowedTransforms & CallTransformation.RequireTypeArguments) != 0) {
@ -450,10 +505,16 @@ namespace ICSharpCode.Decompiler.CSharp
requireTypeArguments = true; requireTypeArguments = true;
typeArguments = method.TypeArguments.ToArray(); typeArguments = method.TypeArguments.ToArray();
continue; continue;
case OverloadResolutionErrors.MissingArgumentForRequiredParameter:
if (firstOptionalArgumentIndex == -1) goto default;
firstOptionalArgumentIndex = -1;
continue;
default: default:
// TODO : implement some more intelligent algorithm that decides which of these fixes (cast args, add target, cast target, add type args) // TODO : implement some more intelligent algorithm that decides which of these fixes (cast args, add target, cast target, add type args)
// is best in this case. Additionally we should not cast all arguments at once, but step-by-step try to add only a minimal number of casts. // is best in this case. Additionally we should not cast all arguments at once, but step-by-step try to add only a minimal number of casts.
if (!argumentsCasted) { if (firstOptionalArgumentIndex >= 0) {
firstOptionalArgumentIndex = -1;
} else if (!argumentsCasted) {
// If we added type arguments beforehand, but that didn't make the code any better, // If we added type arguments beforehand, but that didn't make the code any better,
// undo that decision and add casts first. // undo that decision and add casts first.
if (appliedRequireTypeArgumentsShortcut) { if (appliedRequireTypeArgumentsShortcut) {
@ -486,6 +547,8 @@ namespace ICSharpCode.Decompiler.CSharp
transform |= CallTransformation.RequireTarget; transform |= CallTransformation.RequireTarget;
if ((allowedTransforms & CallTransformation.RequireTypeArguments) != 0 && requireTypeArguments) if ((allowedTransforms & CallTransformation.RequireTypeArguments) != 0 && requireTypeArguments)
transform |= CallTransformation.RequireTypeArguments; transform |= CallTransformation.RequireTypeArguments;
if (firstOptionalArgumentIndex < 0)
transform |= CallTransformation.NoOptionalArgumentAllowed;
return transform; return transform;
} }
@ -607,13 +670,14 @@ namespace ICSharpCode.Decompiler.CSharp
OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetDetails, IMethod method, OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetDetails, IMethod method,
ResolveResult target, IType[] typeArguments, IList<TranslatedExpression> arguments, ResolveResult target, IType[] typeArguments, IList<TranslatedExpression> arguments,
string[] argumentNames, string[] argumentNames, int firstOptionalArgumentIndex,
out IParameterizedMember foundMember) out IParameterizedMember foundMember)
{ {
Debug.Assert(firstOptionalArgumentIndex < 0 || argumentNames == null);
foundMember = null; foundMember = null;
var lookup = new MemberLookup(resolver.CurrentTypeDefinition, resolver.CurrentTypeDefinition.ParentModule); var lookup = new MemberLookup(resolver.CurrentTypeDefinition, resolver.CurrentTypeDefinition.ParentModule);
var or = new OverloadResolution(resolver.Compilation, var or = new OverloadResolution(resolver.Compilation,
arguments.SelectArray(a => a.ResolveResult), firstOptionalArgumentIndex < 0 ? arguments.SelectArray(a => a.ResolveResult) : arguments.Take(firstOptionalArgumentIndex).Select(a => a.ResolveResult).ToArray(),
argumentNames: argumentNames, argumentNames: argumentNames,
typeArguments: typeArguments, typeArguments: typeArguments,
conversions: expressionBuilder.resolver.conversions); conversions: expressionBuilder.resolver.conversions);

2
ILSpy/Properties/AssemblyInfo.template.cs
Unescape View File

@ -42,7 +42,7 @@ internal static class RevisionClass
public const string Minor = "0"; public const string Minor = "0";
public const string Build = "0"; public const string Build = "0";
public const string Revision = "$INSERTREVISION$"; public const string Revision = "$INSERTREVISION$";
public const string VersionName = "alpha1"; public const string VersionName = "beta1";
public const string FullVersion = Major + "." + Minor + "." + Build + ".$INSERTREVISION$$INSERTBRANCHPOSTFIX$$INSERTVERSIONNAMEPOSTFIX$"; public const string FullVersion = Major + "." + Minor + "." + Build + ".$INSERTREVISION$$INSERTBRANCHPOSTFIX$$INSERTVERSIONNAMEPOSTFIX$";
} }

Write Preview
Loading…
Cancel
Save