Merge pull request #28 from codecentric/issue-26

Fix Issue 26
codecentric · Jan 31, 2024 · de3e4d5 · de3e4d5
2 parents bb6eec4 + 23f0cc0
commit de3e4d5
Show file tree

Hide file tree

Showing 6 changed files with 294 additions and 10 deletions.
diff --git a/AutomaticInterface/AutomaticInterface.sln b/AutomaticInterface/AutomaticInterface.sln
@@ -15,6 +15,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		Directory.Build.targets = Directory.Build.targets
 		..\.github\workflows\action.yml = ..\.github\workflows\action.yml
+		..\README.md = ..\README.md
 	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestNuget", "TestNuget\TestNuget.csproj", "{E7CF6623-54D8-4A40-A1B1-CE078551EFE1}"

diff --git a/AutomaticInterface/AutomaticInterface/AutomaticInterface.csproj b/AutomaticInterface/AutomaticInterface/AutomaticInterface.csproj
@@ -25,7 +25,7 @@
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <EnableNETAnalyzers>True</EnableNETAnalyzers>
         <AnalysisLevel>latest-Recommended</AnalysisLevel>
-        <Version>2.1.0</Version>
+        <Version>2.1.1</Version>
         <PackageReadmeFile>README.md</PackageReadmeFile>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
         <NoWarn>1701;1702;NU5128</NoWarn>

diff --git a/AutomaticInterface/AutomaticInterface/Builder.cs b/AutomaticInterface/AutomaticInterface/Builder.cs
@@ -84,22 +84,15 @@ private static void AddMethod(InterfaceBuilder codeGenerator, IMethodSymbol meth
         var returnType = method.ReturnType;
         var name = method.Name;
 
-        var hasNullableParameter = method.Parameters.Any(x =>
-            x.NullableAnnotation == NullableAnnotation.Annotated
-        );
-        var hasNullableReturn =
-            method.ReturnType.NullableAnnotation == NullableAnnotation.Annotated;
-        if (hasNullableParameter || hasNullableReturn)
-        {
-            codeGenerator.HasNullable = true;
-        }
+        ActivateNullableIfNeeded(codeGenerator, method);
 
         var paramResult = new HashSet<string>();
         method.Parameters.Select(GetMethodSignature).ToList().ForEach(x => paramResult.Add(x));
 
         var typedArgs = method
             .TypeParameters.Select(arg => (arg.ToDisplayString(), arg.GetWhereStatement()))
             .ToList();
+
         codeGenerator.AddMethodToInterface(
             name,
             returnType.ToDisplayString(),
@@ -109,6 +102,55 @@ private static void AddMethod(InterfaceBuilder codeGenerator, IMethodSymbol meth
         );
     }
 
+    private static void ActivateNullableIfNeeded(
+        InterfaceBuilder codeGenerator,
+        ITypeSymbol typeSymbol
+    )
+    {
+        if (IsNullable(typeSymbol))
+        {
+            codeGenerator.HasNullable = true;
+        }
+    }
+
+    private static void ActivateNullableIfNeeded(
+        InterfaceBuilder codeGenerator,
+        IMethodSymbol method
+    )
+    {
+        var hasNullableParameter = method.Parameters.Any(x => IsNullable(x.Type));
+
+        var hasNullableReturn = IsNullable(method.ReturnType);
+
+        if (hasNullableParameter || hasNullableReturn)
+        {
+            codeGenerator.HasNullable = true;
+        }
+    }
+
+    private static bool IsNullable(ITypeSymbol typeSymbol)
+    {
+        if (typeSymbol.NullableAnnotation == NullableAnnotation.Annotated)
+        {
+            return true;
+        }
+
+        if (typeSymbol is not INamedTypeSymbol named)
+        {
+            return false;
+        }
+
+        foreach (var param in named.TypeArguments)
+        {
+            if (IsNullable(param))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     private static void AddEventsToInterface(
         ITypeSymbol classSymbol,
         InterfaceBuilder codeGenerator
@@ -126,6 +168,8 @@ InterfaceBuilder codeGenerator
                 var type = evt.Type;
                 var name = evt.Name;
 
+                ActivateNullableIfNeeded(codeGenerator, type);
+
                 codeGenerator.AddEventToInterface(name, type.ToDisplayString(), InheritDoc);
             });
     }
@@ -169,6 +213,8 @@ InterfaceBuilder interfaceGenerator
                 var hasGet = prop.GetMethod?.DeclaredAccessibility == Accessibility.Public;
                 var hasSet = prop.SetMethod?.DeclaredAccessibility == Accessibility.Public;
 
+                ActivateNullableIfNeeded(interfaceGenerator, type);
+
                 interfaceGenerator.AddPropertyToInterface(
                     name,
                     type.ToDisplayString(),

diff --git a/AutomaticInterface/AutomaticInterfaceExample/DemoClass.cs b/AutomaticInterface/AutomaticInterfaceExample/DemoClass.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using AutomaticInterfaceAttribute;
 
 namespace AutomaticInterfaceExample
@@ -45,6 +46,11 @@ public class DemoClass : IDemoClass // Generics, including constraints are allow
             return "Ok";
         }
 
+        public Task<string?> ASync(string x, string y)
+        {
+            return Task.FromResult("");
+        }
+
         public static string StaticProperty => "abc"; // static property, ignored
 
         public static string StaticMethod() // static method, ignored
@@ -67,6 +73,8 @@ public class DemoClass : IDemoClass // Generics, including constraints are allow
 
         public event EventHandler? ShapeChangedNullable; // included
 
+        public event EventHandler<string?> ShapeChangedNullable2; // included
+
         private readonly int[] arr = new int[100];
 
         public int this[int index] // currently ignored

diff --git a/AutomaticInterface/Tests/GeneratorTests.cs b/AutomaticInterface/Tests/GeneratorTests.cs
@@ -1648,6 +1648,65 @@ public partial interface IDemoClass
         GenerateCode(code).Should().Be(expected);
     }
 
+    [Fact]
+    public void NullableEvent2()
+    {
+        const string code = """
+
+            using AutomaticInterfaceAttribute;
+            using System;
+
+            namespace AutomaticInterfaceExample
+            {
+                    /// <summary>
+                    /// Bla bla
+                    /// </summary>
+                [GenerateAutomaticInterface]
+                class DemoClass
+                {
+
+                    /// <summary>
+                    /// Bla bla
+                    /// </summary>
+                    public event EventHandler<string?> ShapeChangedNullable;
+                }
+            }
+
+            """;
+
+        const string expected = """
+            //--------------------------------------------------------------------------------------------------
+            // <auto-generated>
+            //     This code was generated by a tool.
+            //
+            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+            // </auto-generated>
+            //--------------------------------------------------------------------------------------------------
+
+            #nullable enable
+            using System.CodeDom.Compiler;
+            using AutomaticInterfaceAttribute;
+            using System;
+
+            namespace AutomaticInterfaceExample
+            {
+                /// <summary>
+                /// Bla bla
+                /// </summary>
+                [GeneratedCode("AutomaticInterface", "")]
+                public partial interface IDemoClass
+                {
+                    /// <inheritdoc />
+                    event System.EventHandler<string?> ShapeChangedNullable;
+
+                }
+            }
+            #nullable restore
+
+            """;
+        GenerateCode(code).Should().Be(expected);
+    }
+
     [Fact]
     public void NullableProperty()
     {
@@ -1705,6 +1764,67 @@ public partial interface IDemoClass
         GenerateCode(code).Should().Be(expected);
     }
 
+    [Fact]
+    public void NullableProperty2()
+    {
+        const string code = """
+
+            using AutomaticInterfaceAttribute;
+            using System;
+            using System.Threading.Tasks;
+
+            namespace AutomaticInterfaceExample
+            {
+                    /// <summary>
+                    /// Bla bla
+                    /// </summary>
+                [GenerateAutomaticInterface]
+                class DemoClass
+                {
+
+                    /// <summary>
+                    /// Bla bla
+                    /// </summary>
+                    public Task<string?> NullableProperty { get; set; }
+                }
+            }
+
+            """;
+
+        const string expected = """
+            //--------------------------------------------------------------------------------------------------
+            // <auto-generated>
+            //     This code was generated by a tool.
+            //
+            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+            // </auto-generated>
+            //--------------------------------------------------------------------------------------------------
+
+            #nullable enable
+            using System.CodeDom.Compiler;
+            using AutomaticInterfaceAttribute;
+            using System;
+            using System.Threading.Tasks;
+
+            namespace AutomaticInterfaceExample
+            {
+                /// <summary>
+                /// Bla bla
+                /// </summary>
+                [GeneratedCode("AutomaticInterface", "")]
+                public partial interface IDemoClass
+                {
+                    /// <inheritdoc />
+                    System.Threading.Tasks.Task<string?> NullableProperty { get; set; }
+
+                }
+            }
+            #nullable restore
+
+            """;
+        GenerateCode(code).Should().Be(expected);
+    }
+
     [Fact]
     public void BooleanWithNonNull()
     {
@@ -1842,4 +1962,104 @@ public partial interface IDemoClass
             """;
         GenerateCode(code).Should().Be(expected);
     }
+
+    [Fact]
+    public void WorksWithNullableGeneric()
+    {
+        const string code = """
+
+            using AutomaticInterfaceAttribute;
+            using System.Threading.Tasks;
+
+            namespace AutomaticInterfaceExample;
+            [GenerateAutomaticInterface]
+            public class DemoClass
+            {
+                public Task<string?> AMethodAsync(DemoClass x, string y)
+                {
+                    return "Ok";
+                }
+            }
+
+            """;
+
+        const string expected = """
+            //--------------------------------------------------------------------------------------------------
+            // <auto-generated>
+            //     This code was generated by a tool.
+            //
+            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+            // </auto-generated>
+            //--------------------------------------------------------------------------------------------------
+
+            #nullable enable
+            using System.CodeDom.Compiler;
+            using AutomaticInterfaceAttribute;
+            using System.Threading.Tasks;
+
+            namespace AutomaticInterfaceExample
+            {
+                [GeneratedCode("AutomaticInterface", "")]
+                public partial interface IDemoClass
+                {
+                    /// <inheritdoc />
+                    System.Threading.Tasks.Task<string?> AMethodAsync(AutomaticInterfaceExample.DemoClass x, string y);
+
+                }
+            }
+            #nullable restore
+
+            """;
+        GenerateCode(code).Should().Be(expected);
+    }
+
+    [Fact]
+    public void WorksWithNullableGeneric2()
+    {
+        const string code = """
+
+            using AutomaticInterfaceAttribute;
+            using System.Threading.Tasks;
+
+            namespace AutomaticInterfaceExample;
+            [GenerateAutomaticInterface]
+            public class DemoClass
+            {
+                public string AMethod(Task<DemoClass?> x, string y)
+                {
+                    return "Ok";
+                }
+            }
+
+            """;
+
+        const string expected = """
+            //--------------------------------------------------------------------------------------------------
+            // <auto-generated>
+            //     This code was generated by a tool.
+            //
+            //     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+            // </auto-generated>
+            //--------------------------------------------------------------------------------------------------
+
+            #nullable enable
+            using System.CodeDom.Compiler;
+            using AutomaticInterfaceAttribute;
+            using System.Threading.Tasks;
+
+            namespace AutomaticInterfaceExample
+            {
+                [GeneratedCode("AutomaticInterface", "")]
+                public partial interface IDemoClass
+                {
+                    /// <inheritdoc />
+                    string AMethod(System.Threading.Tasks.Task<AutomaticInterfaceExample.DemoClass?> x, string y);
+
+                }
+            }
+            #nullable restore
+
+            """;
+        GenerateCode(code).Should().Be(expected);
+    }
 }