Add support for parameter attributes (#48)

* 1

* 2

* 3

* .

* x

src/ProxyInterfaceSourceGenerator/Builders/MethodParameterBuilder.cs

@@ -0,0 +1,25 @@
+using System.Text;
+using Microsoft.CodeAnalysis;
+using ProxyInterfaceSourceGenerator.Extensions;
+
+namespace ProxyInterfaceSourceGenerator.Builders;
+
+internal static class MethodParameterBuilder
+{
+    public static string Build(IParameterSymbol parameterSymbol, string? type)
+    {
+        var stringBuilder = new StringBuilder();
+        if (type is { })
+        {
+            stringBuilder.Append(parameterSymbol.GetAttributesPrefix()); // "" or [NotNullWhen(true)]
+            stringBuilder.Append(parameterSymbol.GetParamsPrefix()); // "" or "params "
+            stringBuilder.Append(parameterSymbol.GetRefPrefix()); // "" or "out "
+            stringBuilder.AppendFormat("{0} ", type); // string or another type
+        }
+        
+        stringBuilder.Append(parameterSymbol.GetSanitizedName()); // "s" or "i" or ...
+        stringBuilder.Append(parameterSymbol.GetDefaultValue()); // "" or the value
+
+        return stringBuilder.ToString();
+    }
+}

src/ProxyInterfaceSourceGenerator/Compatibility/IsExternalInit.cs

@@ -1,7 +0,0 @@
-// https://bartwullems.blogspot.com/2021/01/c-9use-record-types-in-net-standard-20.html
-#if NETSTANDARD2_0
-namespace System.Runtime.CompilerServices
-{
-    public class IsExternalInit { }
-}
-#endif

src/ProxyInterfaceSourceGenerator/Compatibility/NullableAttributes.cs

@@ -1,17 +0,0 @@
-// https://stackoverflow.com/questions/61573959/how-to-resolve-error-notnullwhen-attribute-is-inaccessible-due-to-its-protectio
-
-namespace System.Diagnostics.CodeAnalysis;
-
-/// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
-[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-internal sealed class NotNullWhenAttribute : Attribute
-{
-    /// <summary>Initializes the attribute with the specified return value condition.</summary>
-    /// <param name="returnValue">
-    /// The return value condition. If the method returns this value, the associated parameter will not be null.
-    /// </param>
-    public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
-
-    /// <summary>Gets the return value condition.</summary>
-    public bool ReturnValue { get; }
-}

src/ProxyInterfaceSourceGenerator/Constants/InternalClassNames.cs

@@ -0,0 +1,6 @@
+namespace ProxyInterfaceSourceGenerator.Constants;
+
+internal static class InternalClassNames
+{
+    public const string NullableAttribute = "System.Runtime.CompilerServices.NullableAttribute";
+}

src/ProxyInterfaceSourceGenerator/Extensions/ParameterSymbolExtensions.cs

@@ -1,5 +1,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using ProxyInterfaceSourceGenerator.Constants;
 using ProxyInterfaceSourceGenerator.Enums;
 
 namespace ProxyInterfaceSourceGenerator.Extensions;
@@ -8,6 +9,16 @@ internal static class ParameterSymbolExtensions
 {
     private const string ParameterValueNull = "null";
 
+    public static string GetAttributesPrefix(this IParameterSymbol ps)
+    {
+        var attributes = ps.GetAttributes()
+            .Where(a => !string.Equals(a.AttributeClass?.GetFullType(), InternalClassNames.NullableAttribute, StringComparison.OrdinalIgnoreCase))
+            .Select(a => $"[{a}]")
+            .ToArray();
+
+        return attributes.Any() ? $"{string.Join(" ", attributes)} " : string.Empty;
+    }
+
     public static string GetRefPrefix(this IParameterSymbol ps)
     {
         return ps.RefKind switch

src/ProxyInterfaceSourceGenerator/FileGenerators/BaseGenerator.cs

@@ -2,6 +2,7 @@ using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using Microsoft.CodeAnalysis;
+using ProxyInterfaceSourceGenerator.Builders;
 using ProxyInterfaceSourceGenerator.Enums;
 using ProxyInterfaceSourceGenerator.Extensions;
 using ProxyInterfaceSourceGenerator.Models;
@@ -203,18 +204,18 @@ internal abstract class BaseGenerator
         return false;
     }
 
-    protected IList<string> GetMethodParameters(ImmutableArray<IParameterSymbol> parameters, bool includeType)
+    protected IReadOnlyList<string> GetMethodParameters(ImmutableArray<IParameterSymbol> parameterSymbols, bool includeType)
     {
         var methodParameters = new List<string>();
-        foreach (var ps in parameters)
+        foreach (var parameterSymbol in parameterSymbols)
         {
-            string t = string.Empty;
+            string? type = null;
             if (includeType)
             {
-                var type = ps.GetTypeEnum() == TypeEnum.Complex ? GetParameterType(ps, out _) : ps.Type.ToString();
-                t = $"{ps.GetParamsPrefix()}{ps.GetRefPrefix()}{type} ";
+                type = parameterSymbol.GetTypeEnum() == TypeEnum.Complex ? GetParameterType(parameterSymbol, out _) : parameterSymbol.Type.ToString();
             }
-            methodParameters.Add($"{t}{ps.GetSanitizedName()}{ps.GetDefaultValue()}");
+
+            methodParameters.Add(MethodParameterBuilder.Build(parameterSymbol, type));
         }
 
         return methodParameters;

src/ProxyInterfaceSourceGenerator/FileGenerators/PartialInterfacesGenerator.cs

@@ -123,13 +123,6 @@ using System;
         foreach (var method in MemberHelper.GetPublicMethods(targetClassSymbol, proxyBaseClasses))
         {
             var methodParameters = GetMethodParameters(method.Parameters, true);
-            //var methodParameters = new List<string>();
-            //foreach (var ps in method.Parameters)
-            //{
-            //    var type = ps.GetTypeEnum() == TypeEnum.Complex ? GetParameterType(ps, out _) : ps.Type.ToString();
-            //    methodParameters.Add($"{ps.GetParamsPrefix()}{ps.GetRefPrefix()}{type} {ps.GetSanitizedName()}{ps.GetDefaultValue()}");
-            //}
-
             var whereStatement = GetWhereStatementFromMethod(method);
 
             str.AppendLine($"        {GetReplacedType(method.ReturnType, out _)} {method.GetMethodNameWithOptionalTypeParameters()}({string.Join(", ", methodParameters)}){whereStatement};");

src/ProxyInterfaceSourceGenerator/FileGenerators/ProxyClassesGenerator.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using Microsoft.CodeAnalysis;
+using ProxyInterfaceSourceGenerator.Builders;
 using ProxyInterfaceSourceGenerator.Enums;
 using ProxyInterfaceSourceGenerator.Extensions;
 using ProxyInterfaceSourceGenerator.Models;
@@ -188,15 +189,20 @@ using System;
         var str = new StringBuilder();
         foreach (var method in MemberHelper.GetPublicMethods(targetClassSymbol, proxyBaseClasses))
         {
+            if (method.Name == "TryParse")
+            {
+                int y = 0;
+            }
+
             var methodParameters = new List<string>();
             var invokeParameters = new List<string>();
 
-            foreach (var ps in method.Parameters)
+            foreach (var parameterSymbol in method.Parameters)
             {
-                var type = GetParameterType(ps, out _);
+                var type = GetParameterType(parameterSymbol, out _);
 
-                methodParameters.Add($"{ps.GetParamsPrefix()}{ps.GetRefPrefix()}{type} {ps.GetSanitizedName()}{ps.GetDefaultValue()}");
-                invokeParameters.Add($"{ps.GetRefPrefix()}{ps.GetSanitizedName()}_");
+                methodParameters.Add(MethodParameterBuilder.Build(parameterSymbol, type));
+                invokeParameters.Add($"{parameterSymbol.GetRefPrefix()}{parameterSymbol.GetSanitizedName()}_");
             }
 
             string overrideOrVirtual = string.Empty;

src/ProxyInterfaceSourceGenerator/Models/ProxyData.cs

@@ -3,11 +3,18 @@ namespace ProxyInterfaceSourceGenerator.Models;
 internal class ProxyData
 {
     public string Namespace { get; init; }
+
     public string ShortInterfaceName { get; init; }
+
     public string FullInterfaceName { get; init; }
+
     public string FullRawTypeName { get; set; }
+
     public string ShortTypeName { get; init; }
+
     public string FullTypeName { get; init; }
+
     public List<string> Usings { get; init; }
+
     public bool ProxyBaseClasses { get; init; }
 }

src/ProxyInterfaceSourceGenerator/ProxyInterfaceCodeGenerator.cs

@@ -9,7 +9,12 @@ using ProxyInterfaceSourceGenerator.SyntaxReceiver;
 namespace ProxyInterfaceSourceGenerator;
 
 [Generator]
-internal class ProxyInterfaceCodeGenerator : ISourceGenerator
+#if DEBUG
+public
+#else
+internal
+#endif
+class ProxyInterfaceCodeGenerator : ISourceGenerator
 {
     private readonly ProxyAttributeGenerator _proxyAttributeGenerator = new ();
 

src/ProxyInterfaceSourceGenerator/ProxyInterfaceSourceGenerator.csproj

@@ -42,6 +42,10 @@
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
         <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.1.0" PrivateAssets="all" />
+        <PackageReference Include="Polyfill.NET" Version="1.0.12">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
     </ItemGroup>
 
     <!--<ItemGroup>
@@ -55,9 +59,9 @@
         </Compile>
     </ItemGroup>
 
-    <ItemGroup>
-        <None Remove="bin\Release\netstandard2.0\\ProxyInterfaceSourceGenerator.dll" />
-    </ItemGroup>
+    <!--<ItemGroup>
+      <None Remove="bin\Debug\netstandard2.0\ProxyInterfaceSourceGenerator.dll" />
+    </ItemGroup>-->
 
     <ItemGroup>
         <None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
@@ -65,9 +69,9 @@
 
     <!-- https://www.meziantou.net/declaring-internalsvisibleto-in-the-csproj.htm -->
     <ItemGroup>
-        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+        <!--<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
             <_Parameter1>ProxyInterfaceSourceGeneratorTests</_Parameter1>
-        </AssemblyAttribute>
+        </AssemblyAttribute>-->
         <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
             <_Parameter1>DynamicProxyGenAssembly2</_Parameter1>
         </AssemblyAttribute>

src/ProxyInterfaceSourceGenerator/Utils/MemberHelper.cs

@@ -7,7 +7,7 @@ internal static class MemberHelper
 {
     private static readonly string[] ExcludedMethods = { "ToString", "GetHashCode" };
 
-    public static IEnumerable<IPropertySymbol> GetPublicProperties(
+    public static IReadOnlyList<IPropertySymbol> GetPublicProperties(
         ClassSymbol classSymbol,
         bool proxyBaseClasses,
         params Func<IPropertySymbol, bool>[] filters)
@@ -17,25 +17,28 @@ internal static class MemberHelper
             p => p.Kind == SymbolKind.Property
         };
 
-        return GetPublicMembers(classSymbol, proxyBaseClasses, allFilters.ToArray());
+        return GetPublicMembers(classSymbol, proxyBaseClasses, allFilters.ToArray()).ToArray();
     }
 
-    public static IEnumerable<IMethodSymbol> GetPublicMethods(
+    public static IReadOnlyList<IMethodSymbol> GetPublicMethods(
         ClassSymbol classSymbol,
         bool proxyBaseClasses,
         Func<IMethodSymbol, bool>? filter = null)
     {
         filter ??= _ => true;
 
-        return GetPublicMembers(classSymbol,
-            proxyBaseClasses,
-            m => m.Kind == SymbolKind.Method,
-            m => m.MethodKind == MethodKind.Ordinary,
-            m => !ExcludedMethods.Contains(m.Name),
-            filter);
+        return
+            GetPublicMembers(
+                classSymbol,
+                proxyBaseClasses,
+                m => m.Kind == SymbolKind.Method,
+                m => m.MethodKind == MethodKind.Ordinary,
+                m => !ExcludedMethods.Contains(m.Name),
+                filter)
+            .ToArray();
     }
 
-    public static IEnumerable<IGrouping<ISymbol, IMethodSymbol>> GetPublicEvents(
+    public static IReadOnlyList<IGrouping<ISymbol, IMethodSymbol>> GetPublicEvents(
         ClassSymbol classSymbol,
         bool proxyBaseClasses,
         Func<IMethodSymbol, bool>? filter = null)
@@ -48,13 +51,14 @@ internal static class MemberHelper
                 proxyBaseClasses,
                 m => m.MethodKind is MethodKind.EventAdd or MethodKind.EventRemove/* || m.MethodKind == MethodKind.EventRaise*/,
                 filter)
-            .GroupBy(e => e.AssociatedSymbol);
+            .GroupBy(e => e.AssociatedSymbol)
+            .ToArray();
 #pragma warning restore RS1024 // Compare symbols correctly
 #pragma warning restore CS8619 // Nullability of reference types in value doesn't match target type.
     }
 
     // TODO : do we need also to check for "SanitizedName()" here?
-    private static IEnumerable<T> GetPublicMembers<T>(
+    private static IReadOnlyList<T> GetPublicMembers<T>(
         ClassSymbol classSymbol,
         bool proxyBaseClasses,
         params Func<T, bool>[] filters