fix: dotnet abstract classes should have proxy implementations

.gitignore

@@ -368,3 +368,6 @@ jspm_packages/
 # that NuGet uses for external packages. We don't want to ignore the
 # lerna packages.
 !/packages/*
+
+#MacOS metadata
+.DS_Store

packages/jsii-dotnet-generator/src/Amazon.JSII.Generator.UnitTests/Class/AbstractClassProxyGeneratorTests.cs

@@ -0,0 +1,188 @@
+using Amazon.JSII.Generator.Class;
+using Amazon.JSII.JsonModel.Spec;
+using Xunit;
+
+namespace Amazon.JSII.Generator.UnitTests.Class
+{
+    public class AbstractClassProxyGeneratorTests : GeneratorTestBase
+    {
+        private const string Prefix = nameof(Generator) + "." + nameof(AbstractClassProxyGenerator) + ".";
+
+        private string Render(ClassType classType)
+        {
+            Symbols.MapTypeToPackage("myFqn", classType.Assembly);
+            Symbols.MapNamespace(classType.QualifiedNamespace, "MyNamespace");
+            Symbols.MapTypeName("myFqn", "MyClass", TypeKind.Class);
+
+            var generator = new AbstractClassProxyGenerator(classType.Assembly, classType, Symbols, Namespaces);
+
+            var syntaxTree = generator.CreateSyntaxTree();
+            return syntaxTree.ToString();
+        }
+
+        [Fact(DisplayName = Prefix + nameof(IncludesAttribute))]
+        public void IncludesAttribute()
+        {
+            var classType = new ClassType
+            (
+                "myFqn",
+                "myPackage",
+                "myClass",
+                true,
+                initializer: new Method(true, false, false)
+            );
+
+            var actual = Render(classType);
+            var expected =
+                @"namespace MyNamespace
+{
+    [JsiiTypeProxy(typeof(MyClass), ""myFqn"")]
+    internal sealed class MyClassProxy : MyClass
+    {
+        private MyClassProxy(ByRefValue reference): base(reference)
+        {
+        }
+    }
+}";
+            Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
+        }
+
+        [Fact(DisplayName = Prefix + nameof(IncludesDocs))]
+        public void IncludesDocs()
+        {
+            // Docs are not currently generated as part of the C# code.
+            ClassType classType = new ClassType
+            (
+                fullyQualifiedName: "myFqn",
+                assembly: "myPackage",
+                name: "myClass",
+                isAbstract: true,
+                initializer: new Method(true, false, false),
+                docs: new Docs {{"foo", "bar"}}
+            );
+
+            string actual = Render(classType);
+            string expected =
+                @"namespace MyNamespace
+{
+    /// <remarks>foo: bar</remarks>
+    [JsiiTypeProxy(typeof(MyClass), ""myFqn"")]
+    internal sealed class MyClassProxy : MyClass
+    {
+        private MyClassProxy(ByRefValue reference): base(reference)
+        {
+        }
+    }
+}";
+            Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
+        }
+
+        [Fact(DisplayName = Prefix + nameof(IncludesProperties))]
+        public void IncludesProperties()
+        {
+            ClassType classType = new ClassType
+            (
+                fullyQualifiedName: "myFqn",
+                assembly: "myPackage",
+                name: "myClass",
+                isAbstract: true,
+                initializer: new Method(true, false, false),
+                properties: new[]
+                {
+                    new Property
+                    (
+                        name: "myProp",
+                        type: new TypeReference("myPropTypeFqn"),
+                        isImmutable: false,
+                        isAbstract: true,
+                        isProtected: false
+                    ),
+                    new Property
+                    (
+                        name: "notMyProp",
+                        type: new TypeReference("myPropTypeFqn"),
+                        isImmutable: false,
+                        isAbstract: false,
+                        isProtected: false
+                    )
+                }
+            );
+
+            Symbols.MapTypeName("myPropTypeFqn", "MyPropType", TypeKind.Class);
+            Symbols.MapPropertyName("myFqn", "myProp", "MyProp");
+
+            string actual = Render(classType);
+            string expected =
+                @"namespace MyNamespace
+{
+    [JsiiTypeProxy(typeof(MyClass), ""myFqn"")]
+    internal sealed class MyClassProxy : MyClass
+    {
+        private MyClassProxy(ByRefValue reference): base(reference)
+        {
+        }
+
+        [JsiiProperty(""myProp"", ""{\""fqn\"":\""myPropTypeFqn\""}"")]
+        public override MyPropType MyProp
+        {
+            get => GetInstanceProperty<MyPropType>();
+            set => SetInstanceProperty(value);
+        }
+    }
+}";
+            Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
+        }
+
+        [Fact(DisplayName = Prefix + nameof(IncludesMethods))]
+        public void IncludesMethods()
+        {
+            ClassType classType = new ClassType
+            (
+                fullyQualifiedName: "myFqn",
+                assembly: "myPackage",
+                name: "myClass",
+                isAbstract: true,
+                initializer: new Method(true, false, false),
+                methods: new[]
+                {
+                    new Method
+                    (
+                        false,
+                        false,
+                        true,
+                        name: "myMethod"
+                    ),
+                    new Method
+                    (
+                        false,
+                        false,
+                        false,
+                        name: "notMyMethod"
+                    )
+                }
+            );
+
+            Symbols.MapMethodName("myFqn", "myMethod", "MyMethod");
+
+            string actual = Render(classType);
+            string expected =
+                @"namespace MyNamespace
+{
+    [JsiiTypeProxy(typeof(MyClass), ""myFqn"")]
+    internal sealed class MyClassProxy : MyClass
+    {
+        private MyClassProxy(ByRefValue reference): base(reference)
+        {
+        }
+
+        [JsiiMethod(""myMethod"", null, ""[]"")]
+        public override void MyMethod()
+        {
+            InvokeInstanceVoidMethod(new object[]{});
+        }
+    }
+}";
+            Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
+        }
+    }
+}

packages/jsii-dotnet-generator/src/Amazon.JSII.Generator.UnitTests/Class/ClassGeneratorTests.cs

@@ -1,20 +1,20 @@
 using Amazon.JSII.Generator.Class;
-using Amazon.JSII.Generator.Interface;
 using Amazon.JSII.JsonModel.Spec;
 using Microsoft.CodeAnalysis;
 using Xunit;
+using TypeKind = Amazon.JSII.JsonModel.Spec.TypeKind;
 
 namespace Amazon.JSII.Generator.UnitTests.Class
 {
     public class ClassGeneratorTests : GeneratorTestBase
     {
-        const string Prefix = nameof(Generator) + "." + nameof(InterfaceGenerator) + ".";
+        const string Prefix = nameof(Generator) + "." + nameof(ClassGenerator) + ".";
 
-        string Render(ClassType classType)
+        private string Render(ClassType classType)
         {
             Symbols.MapTypeToPackage("myFqn", classType.Assembly);
             Symbols.MapNamespace(classType.QualifiedNamespace, "MyNamespace");
-            Symbols.MapTypeName("myFqn", "MyClass", JsonModel.Spec.TypeKind.Class);
+            Symbols.MapTypeName("myFqn", "MyClass", TypeKind.Class);
 
             ClassGenerator generator = new ClassGenerator(classType.Assembly, classType, Symbols, Namespaces);
 
@@ -36,7 +36,7 @@ public void IncludesAttribute()
 
             string actual = Render(classType);
             string expected =
-@"namespace MyNamespace
+                @"namespace MyNamespace
 {
     [JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
     public class MyClass : DeputyBase
@@ -71,7 +71,7 @@ public void IncludesAbstractKeyword()
 
             string actual = Render(classType);
             string expected =
-@"namespace MyNamespace
+                @"namespace MyNamespace
 {
     [JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
     public abstract class MyClass : DeputyBase
@@ -103,12 +103,12 @@ public void IncludesDocs()
                 name: "myClass",
                 isAbstract: false,
                 initializer: new Method(true, false, false),
-                docs: new Docs { { "foo", "bar" } }
+                docs: new Docs {{"foo", "bar"}}
             );
 
             string actual = Render(classType);
             string expected =
-@"namespace MyNamespace
+                @"namespace MyNamespace
 {
     /// <remarks>foo: bar</remarks>
     [JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
@@ -144,7 +144,7 @@ public void IncludesProperties()
                 {
                     new Property
                     (
-                        name: "myProp", 
+                        name: "myProp",
                         type: new TypeReference("myPropTypeFqn"),
                         isImmutable: false,
                         isAbstract: false,
@@ -153,12 +153,12 @@ public void IncludesProperties()
                 }
             );
 
-            Symbols.MapTypeName("myPropTypeFqn", "MyPropType", JsonModel.Spec.TypeKind.Class);
+            Symbols.MapTypeName("myPropTypeFqn", "MyPropType", TypeKind.Class);
             Symbols.MapPropertyName("myFqn", "myProp", "MyProp");
 
             string actual = Render(classType);
             string expected =
-@"namespace MyNamespace
+                @"namespace MyNamespace
 {
     [JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
     public class MyClass : DeputyBase
@@ -212,7 +212,7 @@ public void IncludesMethods()
 
             string actual = Render(classType);
             string expected =
-@"namespace MyNamespace
+                @"namespace MyNamespace
 {
     [JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
     public class MyClass : DeputyBase
@@ -252,11 +252,11 @@ public void IncludesBase()
                 @base: new TypeReference("myBaseTypeFqn")
             );
 
-            Symbols.MapTypeName("myBaseTypeFqn", "MyBaseType", JsonModel.Spec.TypeKind.Class);
+            Symbols.MapTypeName("myBaseTypeFqn", "MyBaseType", TypeKind.Class);
 
             string actual = Render(classType);
             string expected =
-@"namespace MyNamespace
+                @"namespace MyNamespace
 {
     [JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
     public class MyClass : MyBaseType
@@ -294,12 +294,12 @@ public void IncludesInterfaces()
                 }
             );
 
-            Symbols.MapTypeName("myInterfaceFqn1", "MyInterface1", JsonModel.Spec.TypeKind.Interface);
-            Symbols.MapTypeName("myInterfaceFqn2", "MyInterface2", JsonModel.Spec.TypeKind.Interface);
+            Symbols.MapTypeName("myInterfaceFqn1", "MyInterface1", TypeKind.Interface);
+            Symbols.MapTypeName("myInterfaceFqn2", "MyInterface2", TypeKind.Interface);
 
             string actual = Render(classType);
             string expected =
-@"namespace MyNamespace
+                @"namespace MyNamespace
 {
     [JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
     public class MyClass : DeputyBase, IMyInterface1, IMyInterface2
@@ -320,4 +320,4 @@ protected MyClass(DeputyProps props): base(props)
             Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
         }
     }
-}
+}