Added components for handling generic parameters

Author: PawelGerr

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/DelegateMethodState.cs

@@ -55,50 +55,4 @@ public override int GetHashCode()
          return hashCode;
       }
    }
-
-   public sealed class ParameterState : IEquatable<ParameterState>, IHashCodeComputable
-   {
-      public string Name { get; }
-      public string Type { get; }
-      public RefKind RefKind { get; }
-
-      public ParameterState(
-         string name,
-         string type,
-         RefKind refKind)
-      {
-         Name = name;
-         Type = type;
-         RefKind = refKind;
-      }
-
-      public override bool Equals(object? obj)
-      {
-         return obj is ParameterState other && Equals(other);
-      }
-
-      public bool Equals(ParameterState? other)
-      {
-         if (other is null)
-            return false;
-
-         if (ReferenceEquals(this, other))
-            return true;
-
-         return Name == other.Name
-                && Type == other.Type
-                && RefKind == other.RefKind;
-      }
-
-      public override int GetHashCode()
-      {
-         unchecked
-         {
-            var hashCode = Name.GetHashCode();
-            hashCode = (hashCode * 397) ^ Type.GetHashCode();
-            hashCode = (hashCode * 397) ^ (int)RefKind;
-            return hashCode;
-         }
-      }
-   }
 }

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/GenericTypeParameterState.cs

@@ -0,0 +1,42 @@
+namespace Thinktecture.CodeAnalysis;
+
+public sealed class GenericTypeParameterState : IEquatable<GenericTypeParameterState>, IHashCodeComputable
+{
+   public string Name { get; }
+   public IReadOnlyList<string> Constraints { get; }
+
+   public GenericTypeParameterState(
+      string name,
+      IReadOnlyList<string> constraints)
+   {
+      Name = name;
+      Constraints = constraints;
+   }
+
+   public override bool Equals(object? obj)
+   {
+      return obj is GenericTypeParameterState other && Equals(other);
+   }
+
+   public bool Equals(GenericTypeParameterState? other)
+   {
+      if (other is null)
+         return false;
+
+      if (ReferenceEquals(this, other))
+         return true;
+
+      return Name == other.Name
+             && Constraints.SequenceEqual(other.Constraints);
+   }
+
+   public override int GetHashCode()
+   {
+      unchecked
+      {
+         var hashCode = Name.GetHashCode();
+         hashCode = (hashCode * 397) ^ Constraints.ComputeHashCode();
+         return hashCode;
+      }
+   }
+}

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ParameterState.cs

@@ -0,0 +1,47 @@
+namespace Thinktecture.CodeAnalysis;
+
+public sealed class ParameterState : IEquatable<ParameterState>, IHashCodeComputable
+{
+   public string Name { get; }
+   public string Type { get; }
+   public RefKind RefKind { get; }
+
+   public ParameterState(
+      string name,
+      string type,
+      RefKind refKind)
+   {
+      Name = name;
+      Type = type;
+      RefKind = refKind;
+   }
+
+   public override bool Equals(object? obj)
+   {
+      return obj is ParameterState other && Equals(other);
+   }
+
+   public bool Equals(ParameterState? other)
+   {
+      if (other is null)
+         return false;
+
+      if (ReferenceEquals(this, other))
+         return true;
+
+      return Name == other.Name
+             && Type == other.Type
+             && RefKind == other.RefKind;
+   }
+
+   public override int GetHashCode()
+   {
+      unchecked
+      {
+         var hashCode = Name.GetHashCode();
+         hashCode = (hashCode * 397) ^ Type.GetHashCode();
+         hashCode = (hashCode * 397) ^ (int)RefKind;
+         return hashCode;
+      }
+   }
+}

src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/DelegateMethodStateExtensions.cs

@@ -6,6 +6,7 @@ public static class DelegateMethodStateExtensions
 {
    public static bool NeedsCustomDelegate(this DelegateMethodState method)
    {
-      return method.DelegateName != null || method.Parameters.Any(p => p.RefKind != RefKind.None);
+      return method.DelegateName != null
+             || method.Parameters.Any(p => p.RefKind != RefKind.None);
    }
 }

src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/MethodSymbolExtensions.cs

@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Thinktecture.CodeAnalysis;
 
 namespace Thinktecture;
 
@@ -25,4 +26,24 @@ public static bool IsArithmeticOperator(this IMethodSymbol method, ITypeSymbol t
              && SymbolEqualityComparer.IncludeNullability.Equals(method.Parameters[0].Type, type)
              && SymbolEqualityComparer.IncludeNullability.Equals(method.Parameters[1].Type, type);
    }
+
+   public static IReadOnlyList<GenericTypeParameterState> GetGenericTypeParameters(this IMethodSymbol method)
+   {
+      if (method.TypeParameters.Length <= 0)
+         return [];
+
+      var genericTypeParameters = new List<GenericTypeParameterState>(method.TypeParameters.Length);
+
+      for (var i = 0; i < method.TypeParameters.Length; i++)
+      {
+         var typeParam = method.TypeParameters[i];
+         var constraints = typeParam.GetConstraints();
+
+         genericTypeParameters.Add(new GenericTypeParameterState(
+                                      typeParam.Name,
+                                      constraints));
+      }
+
+      return genericTypeParameters ?? [];
+   }
 }

src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/StringBuilderExtensions.cs

@@ -402,4 +402,42 @@ public static StringBuilder AppendDelegateType(
 
       return sb.Append(">");
    }
+
+   public static StringBuilder AppendGenericTypeParameters(
+      this StringBuilder sb,
+      IReadOnlyList<GenericTypeParameterState> typeParameters)
+   {
+      if (typeParameters.Count <= 0)
+         return sb;
+
+      sb.Append("<");
+
+      for (var i = 0; i < typeParameters.Count; i++)
+      {
+         if (i > 0)
+            sb.Append(", ");
+
+         sb.Append(typeParameters[i].Name);
+      }
+
+      return sb.Append(">");
+   }
+
+   public static StringBuilder AppendGenericConstraints(
+      this StringBuilder sb,
+      IReadOnlyList<string> constraints)
+   {
+      if (constraints.Count <= 0)
+         return sb;
+
+      for (var i = 0; i < constraints.Count; i++)
+      {
+         if (i > 0)
+            sb.Append(", ");
+
+         sb.Append(constraints[i]);
+      }
+
+      return sb;
+   }
 }

src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeParameterExtensions.cs

@@ -0,0 +1,28 @@
+namespace Thinktecture;
+
+public static class TypeParameterExtensions
+{
+   public static IReadOnlyList<string> GetConstraints(this ITypeParameterSymbol typeParam)
+   {
+      List<string>? constraints = null;
+
+      if (typeParam.HasReferenceTypeConstraint)
+      {
+         (constraints ??= []).Add("class");
+      }
+      else if (typeParam.HasValueTypeConstraint)
+      {
+         (constraints ??= []).Add("struct");
+      }
+
+      foreach (var constraintType in typeParam.ConstraintTypes)
+      {
+         (constraints ??= []).Add(constraintType.ToFullyQualifiedDisplayString());
+      }
+
+      if (typeParam.HasConstructorConstraint)
+         (constraints ??= []).Add("new()");
+
+      return constraints ?? [];
+   }
+}