Add handling for default parameters, generics, in/out/ref and other cases when generating interfaces

Author: patrickklaeren

src/AutoRegisterInject.IntegrationTests/AutoRegisterInject.IntegrationTest.Project1/Class1.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -339,4 +340,23 @@ public class AutomaticInterfaceRegistrationTest : IAutomaticInterfaceRegistratio
     {
 
     }
+
+    [AutoInterface, RegisterScoped]
+    public class AutomaticInterfaceRegistrationWithParametersTest : IAutomaticInterfaceRegistrationWithParametersTest
+    {
+        public void One(bool isDefault = true)
+        {
+            
+        }
+        
+        public void Two<T>(T defaulted)
+        {
+            
+        }
+        
+        public void Three(params string[] args)
+        {
+            
+        }
+    }
 }

src/AutoRegisterInject.Tests/GenerationTests.AutoInterface.cs

@@ -197,4 +197,71 @@ await RunGenerator(
             EXPECTED_REGISTRATION,
             ("AutoRegisterInject.IFoo.g.cs", EXPECTED_INTERFACE));
     }
+
+    [Fact]
+    public async Task ShouldGenerateInterfaceWithMethodModifiersDefaultsAndGenerics()
+    {
+        const string INPUT = @"#nullable enable
+[AutoInterface]
+[RegisterTransient]
+public class Foo : IFoo
+{
+    public void Log(string message = ""hello"", int count = 3) { }
+    public void AddTags(params string[] tags) { }
+    public T? GetValue<T>(T? fallback = default) where T : class => fallback;
+}";
+
+        const string EXPECTED_REGISTRATION = @"// <auto-generated>
+//     Automatically generated by AutoRegisterInject.
+//     Changes made to this file may be lost and may cause undesirable behaviour.
+// </auto-generated>
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+/// <summary>
+/// AutoRegisterInject service collection extensions  
+/// </summary>
+public static class AutoRegisterInjectServiceCollectionExtension
+{
+    /// <summary>
+    /// Adds all types registered with AutoRegisterInject attributes to the given
+    /// service collection from the named assembly
+    /// </summary>
+    /// <param name=""serviceCollection"">Service collection to register types with</param>
+    /// <returns>Service collection with registered types</returns>
+    public static Microsoft.Extensions.DependencyInjection.IServiceCollection AutoRegisterFromTestProject(this Microsoft.Extensions.DependencyInjection.IServiceCollection serviceCollection)
+    {
+        return AutoRegister(serviceCollection);
+    }
+
+    /// <summary>
+    /// Adds all types registered with AutoRegisterInject attributes to the given
+    /// service collection
+    /// </summary>
+    /// <param name=""serviceCollection"">Service collection to register types with</param>
+    /// <returns>Service collection with registered types</returns>
+    internal static Microsoft.Extensions.DependencyInjection.IServiceCollection AutoRegister(this Microsoft.Extensions.DependencyInjection.IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddTransient<IFoo, Foo>();
+        return serviceCollection;
+    }
+}";
+
+        const string EXPECTED_INTERFACE = @"// <auto-generated>
+//     Automatically generated by AutoRegisterInject.
+//     Changes made to this file may be lost and may cause undesirable behaviour.
+// </auto-generated>
+#nullable enable
+public interface IFoo
+{
+    void Log(string message = ""hello"", int count = 3);
+    void AddTags(params string[] tags);
+    T? GetValue<T>(T? fallback = default) where T : class;
+}";
+
+        await RunGenerator(
+            INPUT,
+            EXPECTED_REGISTRATION,
+            ("AutoRegisterInject.IFoo.g.cs", EXPECTED_INTERFACE));
+    }
 }

src/AutoRegisterInject/AutoRegisterInject.csproj

@@ -18,7 +18,7 @@
 		<RepositoryUrl>https://github.com/patrickklaeren/AutoRegisterInject</RepositoryUrl>
 		<RepositoryType>git</RepositoryType>
 		<PackageTags>source generator;dependency injection;dependencies;registration;extensions;ioc</PackageTags>
-		<Version>2.0.1</Version>
+		<Version>2.0.2</Version>
 	</PropertyGroup>
 
 	<ItemGroup>

src/AutoRegisterInject/Generator.cs

@@ -6,6 +6,7 @@
 using System.Collections.Immutable;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 
 namespace AutoRegisterInject;
 
@@ -271,9 +272,118 @@ private static string GetInterfaceMemberSource(ISymbol member)
     private static string GetMethodSource(IMethodSymbol method)
     {
         var returnType = method.ReturnType.ToDisplayString();
-        var parameters = string.Join(", ", method.Parameters.Select(static parameter => $"{parameter.Type.ToDisplayString()} {parameter.Name}"));
+        var typeParameters = method.TypeParameters.Length == 0
+            ? string.Empty
+            : $"<{string.Join(", ", method.TypeParameters.Select(static typeParameter => typeParameter.Name))}>";
+        var parameters = string.Join(", ", method.Parameters.Select(GetParameterSource));
+        var constraints = GetTypeParameterConstraintsSource(method.TypeParameters);
 
-        return $"    {returnType} {method.Name}({parameters});";
+        return $"    {returnType} {method.Name}{typeParameters}({parameters}){constraints};";
+    }
+
+    private static string GetParameterSource(IParameterSymbol parameter)
+    {
+        var modifiers = GetParameterModifiersSource(parameter);
+        var defaultValue = GetParameterDefaultValueSource(parameter);
+
+        return $"{modifiers}{parameter.Type.ToDisplayString()} {parameter.Name}{defaultValue}";
+    }
+
+    private static string GetParameterModifiersSource(IParameterSymbol parameter)
+    {
+        var paramsModifier = parameter.IsParams ? "params " : string.Empty;
+        var refModifier = parameter.RefKind switch
+        {
+            RefKind.Ref => "ref ",
+            RefKind.Out => "out ",
+            RefKind.In => "in ",
+            _ => string.Empty,
+        };
+
+        return paramsModifier + refModifier;
+    }
+
+    private static string GetParameterDefaultValueSource(IParameterSymbol parameter)
+    {
+        var syntax = parameter.DeclaringSyntaxReferences
+            .Select(static reference => reference.GetSyntax())
+            .OfType<ParameterSyntax>()
+            .FirstOrDefault();
+
+        if (syntax?.Default is not null)
+        {
+            return $" = {syntax.Default.Value}";
+        }
+
+        if (!parameter.HasExplicitDefaultValue)
+        {
+            return string.Empty;
+        }
+
+        return parameter.ExplicitDefaultValue is null
+            ? " = null"
+            : $" = {FormatDefaultValue(parameter.ExplicitDefaultValue)}";
+    }
+
+    private static string FormatDefaultValue(object value)
+    {
+        return value switch
+        {
+            bool boolValue => boolValue ? "true" : "false",
+            char charValue => $"'{charValue}'",
+            string stringValue => $"\"{stringValue.Replace("\\", "\\\\").Replace("\"", "\\\"")}\"",
+            float floatValue => $"{floatValue.ToString("R", CultureInfo.InvariantCulture)}F",
+            double doubleValue => $"{doubleValue.ToString("R", CultureInfo.InvariantCulture)}D",
+            decimal decimalValue => $"{decimalValue.ToString(CultureInfo.InvariantCulture)}M",
+            IFormattable formattable => formattable.ToString(null, CultureInfo.InvariantCulture),
+            _ => value.ToString(),
+        };
+    }
+
+    private static string GetTypeParameterConstraintsSource(ImmutableArray<ITypeParameterSymbol> typeParameters)
+    {
+        var constraints = typeParameters
+            .Select(GetTypeParameterConstraintSource)
+            .Where(static constraint => !string.IsNullOrWhiteSpace(constraint))
+            .ToArray();
+
+        return constraints.Length == 0
+            ? string.Empty
+            : " " + string.Join(" ", constraints);
+    }
+
+    private static string GetTypeParameterConstraintSource(ITypeParameterSymbol typeParameter)
+    {
+        var constraints = new List<string>();
+
+        if (typeParameter.HasUnmanagedTypeConstraint)
+        {
+            constraints.Add("unmanaged");
+        }
+        else if (typeParameter.HasValueTypeConstraint)
+        {
+            constraints.Add("struct");
+        }
+        else if (typeParameter.HasReferenceTypeConstraint)
+        {
+            constraints.Add("class");
+        }
+
+        if (typeParameter.HasNotNullConstraint)
+        {
+            constraints.Add("notnull");
+        }
+
+        constraints.AddRange(typeParameter.ConstraintTypes.Select(static type => type.ToDisplayString()));
+
+        if (typeParameter.HasConstructorConstraint)
+        {
+            constraints.Add("new()");
+        }
+
+        return constraints.Count == 0
+            ? string.Empty
+            : $"where {typeParameter.Name} : {string.Join(", ", constraints)}";
     }
 
     private static string GetPropertySource(IPropertySymbol property)