Latest staging changes

Cecilifier.Core.Tests/Cecilifier.Core.Tests.csproj

@@ -4,16 +4,15 @@
       <LangVersion>10</LangVersion>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="3.0.3">
+    <PackageReference Include="coverlet.collector" Version="3.1.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0-preview-20211109-03" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0-1.final" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0-preview-20220131-20" />
     <PackageReference Include="Mono.Cecil" Version="0.11.4" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
-    <PackageReference Include="ReportGenerator" Version="4.8.9" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Cecilifier.Core\Cecilifier.Core.csproj" />

Cecilifier.Core.Tests/TestResources/Integration/Expressions/Stackalloc/WithSpan.cs.txt

@@ -13,6 +13,12 @@ class StackAllocWithSpan
 	    Dummy(s);
 	}
 
+    private void SpanOfIntWithConstantRank()
+	{
+	    Span<int> s = stackalloc int[3];
+	    DummyInt(s);
+	}
+
     private void PassingAsParameterToStaticMethodSizeFromLocal(int n)
 	{
 	    int length = 42 * n;
@@ -30,6 +36,7 @@ class StackAllocWithSpan
 	*/
 
 	private void Dummy(Span<byte> span) {}
+	private void DummyInt(Span<int> span) {}
 	private static void StaticDummy(Span<byte> span) {}
 	private int Size() => 42;
 }

Cecilifier.Core.Tests/TestResources/Integration/Members/Methods/Overloads.cs.txt

@@ -0,0 +1,20 @@
+class C<T>
+{
+    public void M(string name, C<int> ci) {}
+    public void M(string name, C<string> cs) {}
+
+    public void Call()
+    {
+        M("int", new C<int>());
+        M("string", new C<string>());
+    }
+}
+
+class Overloads
+{
+    static void Main() 
+    {
+        var c = new C<int>(); 
+        c.Call(); 
+    } 
+}

Cecilifier.Core.Tests/TestResources/Integration/Members/Methods/RefProperties.cs.txt

@@ -0,0 +1,10 @@
+class RefProperties
+{
+    private int field;
+	ref int Property
+	{
+		get => ref field;
+	}
+
+	public ref int UseRefProperty() => ref Property;
+}

Cecilifier.Core.Tests/TestResources/Integration/Types/ArraySmoke.cs.txt

@@ -0,0 +1,13 @@
+class ArraySmokeTests
+{
+    int[] intArrayField = new int[1];
+
+    void M(int []intArrayParameter, char [][]charJaggedArrayParameter)
+    {
+        var intArrayLocal = new int[2];
+        System.Console.WriteLine(intArrayLocal[0]);
+        M(new [] { 3 }, new char [4][]); 
+
+        charJaggedArrayParameter[42][24] = 'B';
+    }
+}

Cecilifier.Core.Tests/Tests/Integration/MethodTestCase.cs

@@ -163,6 +163,18 @@ public void TestRefLocals()
         {
             AssertResourceTest("Members/Methods/RefLocals");
         }
+
+        [Test]
+        public void TestRefProperties()
+        {
+            AssertResourceTest("Members/Methods/RefProperties");
+        }
+
+        [Test]
+        public void TestOverloads()
+        {
+            AssertResourceTest("Members/Methods/Overloads");
+        }
 
         private void AssertCecilifiedCodeContainsSnippet(string code, string expectedSnippet)
         {

Cecilifier.Core.Tests/Tests/Integration/Types/ArraySmokeTestCase.cs

@@ -0,0 +1,14 @@
+using NUnit.Framework;
+
+namespace Cecilifier.Core.Tests.Integration.Types
+{
+    [TestFixture]
+    internal class ArraySmokeTests : IntegrationResourceBasedTest
+    {
+        [Test]
+        public void Test()
+        {
+            AssertResourceTest(@"Types/ArraySmoke");
+        }
+    }
+}

Cecilifier.Core.Tests/Tests/Unit/ArrayTests.cs

@@ -1,22 +1,112 @@
+using Mono.Cecil.Cil;
 using NUnit.Framework;
 
 namespace Cecilifier.Core.Tests.Tests.Unit;
 
 [TestFixture]
 public class ArrayTests : CecilifierUnitTestBase
 {
-    [TestCase("string")]
-    [TestCase("C")]
-    public void TestAccessStringArray(string elementType)
+    [TestCase("string", Code.Ldelem_Ref)]
+    [TestCase("C", Code.Ldelem_Ref)]
+    [TestCase("S", Code.Ldelem_Any, ", st_S_\\d+")]
+    [TestCase("byte", Code.Ldelem_I1)]
+    [TestCase("char", Code.Ldelem_I2)]
+    [TestCase("short", Code.Ldelem_I2)]
+    [TestCase("int", Code.Ldelem_I4)]
+    [TestCase("long", Code.Ldelem_I8)]
+    [TestCase("float", Code.Ldelem_R4)]
+    [TestCase("double", Code.Ldelem_R8)]
+    [TestCase("System.DateTime", Code.Ldelem_Any, ", assembly.MainModule.TypeSystem.DateTime")]
+    public void TestAccessStringArray(string elementType, Code code, string operand="")
     {
-        var result = RunCecilifier($@"class C {{ {elementType} M({elementType} []a) => a[2]; }}");
+        var result = RunCecilifier($@"struct S {{}} class C {{ {elementType} M({elementType} []a) => a[2]; }}");
         var cecilifiedCode = result.GeneratedCode.ReadToEnd();
 
         Assert.That(
             cecilifiedCode, 
             Does.Match(
                 @"(.+\.Emit\(OpCodes\.)Ldarg_1\);\s+" +
                 @"\1Ldc_I4, 2\);\s+" +
-                @"\1Ldelem_Ref\);"));
+                $@"\1{code}{operand}\);"));
+    }    
+
+    [TestCase("string", Code.Stelem_Ref)]
+    [TestCase("C", Code.Stelem_Ref)]
+    [TestCase("byte", Code.Stelem_I1)]
+    [TestCase("char", Code.Stelem_I2)]
+    [TestCase("short", Code.Stelem_I2)]
+    [TestCase("int", Code.Stelem_I4)]
+    [TestCase("long", Code.Stelem_I8)]
+    [TestCase("float", Code.Stelem_R4)]
+    [TestCase("double", Code.Stelem_R8)]
+    [TestCase("System.DateTime", Code.Stelem_Any, ", assembly.MainModule.TypeSystem.DateTime")]
+    [TestCase("S", Code.Stelem_Any, @", st_S_\d+")]
+    public void TestArrayCreation(string elementType, Code code, string operand="")
+    {
+        var result = RunCecilifier($@"struct S {{}} class C {{ void M({elementType} value) {{ var data = new[] {{ value }}; }} }}");
+        var cecilifiedCode = result.GeneratedCode.ReadToEnd();
+
+        Assert.That(
+            cecilifiedCode, 
+            Does.Match(
+                @"(.+\.Emit\(OpCodes\.)Dup\);\s+" +
+                @"\1Ldc_I4, 0\);\s+" +
+                @"\1Ldarg_1.+\s+" +
+                $@"\1{code}{operand}\);\s+"));
+    }
+
+    [TestCase("System.String")]
+    [TestCase("C", @"cls_C_\d+")]
+    [TestCase("System.Byte")]
+    [TestCase("System.Char")]
+    [TestCase("System.Int16")]
+    [TestCase("System.Int32")]
+    [TestCase("System.Int64")]
+    [TestCase("System.Single")]
+    [TestCase("System.Double")]
+    [TestCase("System.DateTime")]
+    [TestCase("S", @"st_S_\d+")]
+    public void TestJaggedArrayCreation(string elementType, string operand=null)
+    {
+        var result = RunCecilifier($@"struct S {{}} class C {{ void M({elementType} value) {{ var data = new {elementType}[42][]; }} }}");
+        var cecilifiedCode = result.GeneratedCode.ReadToEnd();
+
+        var operandTypeMatch = operand ?? $"assembly.MainModule.Type{elementType}";
+
+        Assert.That(cecilifiedCode, Does.Match($@"new VariableDefinition\({operandTypeMatch}.MakeArrayType\(\).MakeArrayType\(\)\);\s+"));
+
+        Assert.That(
+            cecilifiedCode, 
+            Does.Match(
+                @"(.+\.Emit\(OpCodes\.)Ldc_I4, 42\);\s+" +
+                $@"\1Newarr, {operandTypeMatch}.MakeArrayType\(\)\);\s+"));
+    }
+
+    [TestCase("string", Code.Stelem_Ref)]
+    [TestCase("C", Code.Stelem_Ref)]
+    [TestCase("byte", Code.Stelem_I1)]
+    [TestCase("char", Code.Stelem_I2)]
+    [TestCase("short", Code.Stelem_I2)]
+    [TestCase("int", Code.Stelem_I4)]
+    [TestCase("long", Code.Stelem_I8)]
+    [TestCase("float", Code.Stelem_R4)]
+    [TestCase("double", Code.Stelem_R8)]
+    [TestCase("System.DateTime", Code.Stelem_Any, ", assembly.MainModule.TypeSystem.DateTime")]
+    [TestCase("S", Code.Stelem_Any, @", st_S_\d+")]
+    public void TestJaggedArrayAssignment(string elementType, Code code, string operand="")
+    {
+        var result = RunCecilifier($@"struct S {{}} class C {{ void M({elementType} [][]array, {elementType} value) {{ array[0][1] = value; }} }}");
+        var cecilifiedCode = result.GeneratedCode.ReadToEnd();
+
+        Assert.That(
+            cecilifiedCode, 
+            Does.Match(
+                @"//array\[0\]\[1\] = value;\s+" + 
+                @"(.+Emit\(OpCodes\.)Ldarg_1\);\s+" + 
+                @"\1Ldc_I4, 0.+\s+" + 
+                @"\1Ldelem_Ref.+\s+" + 
+                @"\1Ldc_I4, 1.+\s+" + 
+                @"\1Ldarg_2.+\s+" + 
+                $@"\1{code}{operand}.+;"));
     }
 }

Cecilifier.Core.Tests/Tests/Unit/EventsTests.cs

@@ -0,0 +1,78 @@
+using NUnit.Framework;
+
+namespace Cecilifier.Core.Tests.Tests.Unit;
+
+[TestFixture]
+public class EventsTests : CecilifierUnitTestBase
+{
+    [Test]
+    public void EventDeclaration()
+    {
+        var code = @"using System; 
+                    class C 
+                    { 
+                        event Action E	
+                        { 
+                            add { Console.WriteLine(""add""); } 
+                            remove { Console.WriteLine(""remove""); } 
+                        }
+                    }";
+
+        var result = RunCecilifier(code);
+
+        var cecilified = result.GeneratedCode.ReadToEnd();
+
+        Assert.That(cecilified, Does.Match(@"cls_C_0.Events.Add\(evt_E_\d+\);"));
+        Assert.That(cecilified, Does.Match(@"var m_add_\d+ = new MethodDefinition\(""add_E"", .+, assembly.MainModule.TypeSystem.Void\);"));
+        Assert.That(cecilified, Does.Match(@"m_add_\d+.Parameters.Add\(.*Action.*\);"));
+        Assert.That(cecilified, Does.Match(@"var il_add_\d+ = m_add_\d+.Body.GetILProcessor\(\);"));
+
+        Assert.That(cecilified, Does.Match(@"var m_remove_\d+ = new MethodDefinition\(""remove_E"", .+, assembly.MainModule.TypeSystem.Void\);"));
+        Assert.That(cecilified, Does.Match(@"m_remove_\d+.Parameters.Add\(.*Action.*\);"));
+        Assert.That(cecilified, Does.Match(@"var il_remove_\d+ = m_remove_\d+.Body.GetILProcessor\(\);"));
+
+        Assert.That(cecilified, Does.Match(@"cls_C_\d+.Methods.Add\(m_add_\d+\);"));
+        Assert.That(cecilified, Does.Match(@"cls_C_\d+.Methods.Add\(m_remove_\d+\);"));
+    }
+
+    [Test]
+    public void EventSubscription()
+    {
+        var code = @"using System; 
+                    class C 
+                    { 
+                        event Action E { add { Console.WriteLine(""add""); } remove { Console.WriteLine(""remove""); } }
+                        void Sub(Action a) 
+                        { 
+                            E += a; 
+                            E -= a; 
+                        }
+                    }";
+
+        var result = RunCecilifier(code);
+
+        var cecilified = result.GeneratedCode.ReadToEnd();
+
+        Assert.That(cecilified, Does.Match(@"Call, m_add_\d+"));
+        Assert.That(cecilified, Does.Match(@"Call, m_remove_\d+"));
+    }
+
+    [Test]
+    public void ForwardMethodReferenceTest()
+    {
+        var code = @"using System; 
+                    class C 
+                    { 
+                        event Action E;
+                        void Sub() { E += M;  }
+
+                        void M() {}
+                    }";
+
+        var result = RunCecilifier(code);
+
+        var cecilified = result.GeneratedCode.ReadToEnd();
+
+        Assert.That(cecilified, Does.Match(@"Call, m_add_\d+"));
+    }
+}

Cecilifier.Core.Tests/Tests/Unit/FieldsTests.cs

@@ -54,13 +54,16 @@ public void TestFieldAsMemberReferences(string code, params string[] instruction
         Assert.That(cecilifiedCode, Does.Match(expectedSnippet));
     }
 
-    // [Test]
-    // public void TestExternalInstanceFields()
-    // {
-    //     const string code = "class ExternalInstanceFields { int Instance(System.ValueTuple<int> t) => t.Item1; }";
-    //     var result = RunCecilifier(code);
-    //     var cecilifiedCode = result.GeneratedCode.ReadToEnd();
-    //     
-    //     Assert.That(cecilifiedCode, Contains.Substring("XX FORCE IT TO FAIL XX;"));
-    // }
+    [Test]
+    public void TestReadOnlyField()
+    {
+        var result = RunCecilifier("class Foo { readonly int ro = 42; }");
+        var cecilifiedCode = result.GeneratedCode.ReadToEnd();
+
+        Assert.That(
+            cecilifiedCode, 
+            Does.Match(
+                @"var fld_ro_1 = new FieldDefinition\(""ro"", .+InitOnly.+Int32\);\s+" +
+                        @"cls_foo_0.Fields.Add\(fld_ro_1\);"));
+    }
 }

Cecilifier.Core.Tests/Tests/Unit/ForStatementTests.cs

@@ -0,0 +1,27 @@
+using NUnit.Framework;
+
+namespace Cecilifier.Core.Tests.Tests.Unit;
+
+[TestFixture]
+public class ForStatementTests : CecilifierUnitTestBase
+{
+    [TestCase ("parameter++", true)]
+    [TestCase("local++", true)]
+    [TestCase("field++", true)]
+    [TestCase("F()", true)]
+    [TestCase ("localDummy = parameter++", false)]
+    [TestCase("localDummy = local++", false)]
+    [TestCase("localDummy = field++", false)]
+    [TestCase("localDummy = F()", false)]
+    public void TestForIncrement_IsPopped_IfNotConsumed(string value, bool expectPop)
+    {
+        var result = RunCecilifier($@"class C {{ int F() => 0; int field; void M(int parameter) {{ int localDummy; int local = parameter; for(int x = 0; x < 1; {value}); }} }}");
+        var cecilifiedCode = result.GeneratedCode.ReadToEnd();
+
+        Assert.That(
+            cecilifiedCode, 
+            expectPop 
+                ? Does.Contain("Pop") 
+                : Does.Not.Contains("Pop"));
+    }
+}