[Analyzer] Value objects and smart enums must not be inside a generic class

Author: PawelGerr

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

@@ -5,15 +5,18 @@ public sealed class ContainingTypeState : IEquatable<ContainingTypeState>, IHash
    public string Name { get; }
    public bool IsReferenceType { get; }
    public bool IsRecord { get; }
+   public IReadOnlyList<GenericTypeParameterState> GenericParameters { get; }
 
    public ContainingTypeState(
       string name,
       bool isReferenceType,
-      bool isRecord)
+      bool isRecord,
+      IReadOnlyList<GenericTypeParameterState> genericParameters)
    {
       Name = name;
       IsReferenceType = isReferenceType;
       IsRecord = isRecord;
+      GenericParameters = genericParameters;
    }
 
    public bool Equals(ContainingTypeState? other)
@@ -26,7 +29,8 @@ public bool Equals(ContainingTypeState? other)
 
       return Name == other.Name
              && IsReferenceType == other.IsReferenceType
-             && IsRecord == other.IsRecord;
+             && IsRecord == other.IsRecord
+             && GenericParameters.SequenceEqual(other.GenericParameters);
    }
 
    public override bool Equals(object? obj)
@@ -41,6 +45,7 @@ public override int GetHashCode()
          var hashCode = Name.GetHashCode();
          hashCode = (hashCode * 397) ^ IsReferenceType.GetHashCode();
          hashCode = (hashCode * 397) ^ IsRecord.GetHashCode();
+         hashCode = (hashCode * 397) ^ GenericParameters.ComputeHashCode();
 
          return hashCode;
       }

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Diagnostics/ThinktectureRuntimeExtensionsAnalyzer.cs

@@ -49,7 +49,8 @@ public sealed class ThinktectureRuntimeExtensionsAnalyzer : DiagnosticAnalyzer
       DiagnosticsDescriptors.ExplicitComparerWithoutEqualityComparer,
       DiagnosticsDescriptors.ExplicitEqualityComparerWithoutComparer,
       DiagnosticsDescriptors.MethodWithUseDelegateFromConstructorMustBePartial,
-      DiagnosticsDescriptors.MethodWithUseDelegateFromConstructorMustNotHaveGenerics
+      DiagnosticsDescriptors.MethodWithUseDelegateFromConstructorMustNotHaveGenerics,
+      DiagnosticsDescriptors.TypeMustNotBeInsideGenericType
    ];
 
    /// <inheritdoc />
@@ -418,7 +419,7 @@ private static void ValidateAdHocUnion(
 
       CheckConstructors(context, type, mustBePrivate: false, canHavePrimaryConstructor: false);
       TypeMustBePartial(context, type);
-      TypeMustNotBeGeneric(context, type, locationOfFirstDeclaration, "Union");
+      TypeMustNotBeGeneric(context, type, locationOfFirstDeclaration);
    }
 
    private static void ValidateUnion(
@@ -581,7 +582,8 @@ private static void ValidateCustomKeyMemberImplementation(
 
       CheckConstructors(context, type, mustBePrivate: false, canHavePrimaryConstructor: false);
       TypeMustBePartial(context, type);
-      TypeMustNotBeGeneric(context, type, locationOfFirstDeclaration, "Value Object");
+      TypeMustNotBeGeneric(context, type, locationOfFirstDeclaration);
+      TypeMustNotBeInsideGenericType(context, type, locationOfFirstDeclaration);
 
       var assignableMembers = type.GetAssignableFieldsAndPropertiesAndCheckForReadOnly(factory, false, true, context.CancellationToken, context)
                                   .Where(m => !m.IsStatic)
@@ -678,7 +680,8 @@ private static void ValidateEnum(
 
       CheckConstructors(context, enumType, mustBePrivate: true, canHavePrimaryConstructor: false);
       TypeMustBePartial(context, enumType);
-      TypeMustNotBeGeneric(context, enumType, locationOfFirstDeclaration, "Enumeration");
+      TypeMustNotBeGeneric(context, enumType, locationOfFirstDeclaration);
+      TypeMustNotBeInsideGenericType(context, enumType, locationOfFirstDeclaration);
 
       var items = enumType.GetEnumItems();
 
@@ -741,10 +744,16 @@ private static void ValidateKeyedSmartEnum(
       ValidateKeyMemberComparers(context, enumType, keyType, attribute, locationOfFirstDeclaration, factory, false);
    }
 
-   private static void TypeMustNotBeGeneric(OperationAnalysisContext context, INamedTypeSymbol type, Location locationOfFirstDeclaration, string typeKind)
+   private static void TypeMustNotBeGeneric(OperationAnalysisContext context, INamedTypeSymbol type, Location locationOfFirstDeclaration)
    {
       if (!type.TypeParameters.IsDefaultOrEmpty)
-         ReportDiagnostic(context, DiagnosticsDescriptors.EnumsValueObjectsAndAdHocUnionsMustNotBeGeneric, locationOfFirstDeclaration, typeKind, BuildTypeName(type));
+         ReportDiagnostic(context, DiagnosticsDescriptors.EnumsValueObjectsAndAdHocUnionsMustNotBeGeneric, locationOfFirstDeclaration, BuildTypeName(type));
+   }
+
+   private static void TypeMustNotBeInsideGenericType(OperationAnalysisContext context, INamedTypeSymbol type, Location locationOfFirstDeclaration)
+   {
+      if (type.IsNestedInGenericClass())
+         ReportDiagnostic(context, DiagnosticsDescriptors.TypeMustNotBeInsideGenericType, locationOfFirstDeclaration, BuildTypeName(type));
    }
 
    private static void Check_ItemLike_StaticProperties(

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

@@ -17,7 +17,7 @@ internal static class DiagnosticsDescriptors
    public static readonly DiagnosticDescriptor InnerEnumOnFirstLevelMustBePrivate = new("TTRESG014", "First-level inner enumerations must be private", "Derived inner enumeration '{0}' on first-level must be private", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor InnerEnumOnNonFirstLevelMustBePublic = new("TTRESG015", "Non-first-level inner enumerations must be public", "Derived inner enumeration '{0}' on non-first-level must be public", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor KeyMemberShouldNotBeNullable = new("TTRESG017", "The key member must not be nullable", "A key member must not be nullable", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
-   public static readonly DiagnosticDescriptor EnumsValueObjectsAndAdHocUnionsMustNotBeGeneric = new("TTRESG033", "Enumerations, value objects and ad hoc unions must not be generic", "{0} '{1}' must not be generic", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
+   public static readonly DiagnosticDescriptor EnumsValueObjectsAndAdHocUnionsMustNotBeGeneric = new("TTRESG033", "Enumerations, value objects and ad hoc unions must not be generic", "Type '{1}' must not be generic", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor BaseClassFieldMustBeReadOnly = new("TTRESG034", "Field of the base class must be read-only", "The field '{0}' of the base class '{1}' must be read-only", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor BaseClassPropertyMustBeReadOnly = new("TTRESG035", "Property of the base class must be read-only", "The property '{0}' of the base class '{1}' must be read-only", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor EnumKeyShouldNotBeNullable = new("TTRESG036", "The key must not be nullable", "The generic type T of SmartEnumAttribute<T> must not be nullable", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
@@ -33,6 +33,7 @@ internal static class DiagnosticsDescriptors
    public static readonly DiagnosticDescriptor ComplexValueObjectWithStringMembersNeedsDefaultEqualityComparer = new("TTRESG049", "Complex Value Object with string members needs equality comparer", "Complex Value Object with string members needs equality comparer. Use ValueObjectKeyMemberEqualityComparerAttribute<TAccessor, TKey> to defined the equality comparer. Example: [ValueObjectKeyMemberEqualityComparer<ComparerAccessors.StringOrdinalIgnoreCase, string>].", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Warning, true);
    public static readonly DiagnosticDescriptor MethodWithUseDelegateFromConstructorMustBePartial = new("TTRESG050", $"Method with '{Constants.Attributes.UseDelegateFromConstructorAttribute.NAME}' must be partial", $"The method '{{0}}' with '{Constants.Attributes.UseDelegateFromConstructorAttribute.NAME}' must be marked as partial", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
    public static readonly DiagnosticDescriptor MethodWithUseDelegateFromConstructorMustNotHaveGenerics = new("TTRESG051", $"Method with '{Constants.Attributes.UseDelegateFromConstructorAttribute.NAME}' must not have generics", $"The method '{{0}}' with '{Constants.Attributes.UseDelegateFromConstructorAttribute.NAME}' must not have generic type parameters. Use inheritance approach instead.", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
+   public static readonly DiagnosticDescriptor TypeMustNotBeInsideGenericType = new("TTRESG052", "The type must not be inside generic type", "Type '{0}' must not be inside a generic type", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);
 
    public static readonly DiagnosticDescriptor ErrorDuringCodeAnalysis = new("TTRESG098", "Error during code analysis", "Error during code analysis of '{0}': '{1}'", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Warning, true);
    public static readonly DiagnosticDescriptor ErrorDuringGeneration = new("TTRESG099", "Error during code generation", "Error during code generation for '{0}': '{1}'", nameof(ThinktectureRuntimeExtensionsAnalyzer), DiagnosticSeverity.Error, true);

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/SmartEnums/SmartEnumSourceGenerator.cs

@@ -344,6 +344,12 @@ private bool IsEnumCandidate(TypeDeclarationSyntax typeDeclaration)
             return null;
          }
 
+         if (type.IsNestedInGenericClass())
+         {
+            Logger.LogDebug("Type must not be inside a generic class", tds);
+            return null;
+         }
+
          ITypeSymbol? keyMemberType = null;
 
          if (isKeyed)

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Unions/UnionSourceGenerator.cs

@@ -99,6 +99,12 @@ private bool IsCandidate(SyntaxNode syntaxNode, CancellationToken cancellationTo
                                 .Select(i => new UnionTypeMemberState(i.Type))
                                 .ToList();
 
+         if (derivedTypes.Count == 0)
+         {
+            Logger.LogDebug("Union has no derived types", tds);
+            return null;
+         }
+
          var settings = new UnionSettings(context.Attributes[0]);
 
          var unionState = new UnionSourceGenState(type,

src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/ValueObjects/ValueObjectSourceGenerator.cs

@@ -458,6 +458,12 @@ private bool IsValueObjectCandidate(TypeDeclarationSyntax typeDeclaration)
             return null;
          }
 
+         if (type.IsNestedInGenericClass())
+         {
+            Logger.LogDebug("Type must not be inside a generic class", tds);
+            return null;
+         }
+
          var factory = TypedMemberStateFactoryProvider.GetFactoryOrNull(context.SemanticModel.Compilation, Logger);
 
          if (factory is null)
@@ -503,6 +509,12 @@ private bool IsValueObjectCandidate(TypeDeclarationSyntax typeDeclaration)
          if (!TryGetType(context, tds, out var type))
             return null;
 
+         if (type.IsNestedInGenericClass())
+         {
+            Logger.LogDebug("Type must not be inside a generic class", tds);
+            return null;
+         }
+
          var factory = TypedMemberStateFactoryProvider.GetFactoryOrNull(context.SemanticModel.Compilation, Logger);
 
          if (factory is null)

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

@@ -29,21 +29,6 @@ public static bool IsArithmeticOperator(this IMethodSymbol method, ITypeSymbol t
 
    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 ?? [];
+      return method.TypeParameters.GetGenericTypeParameters();
    }
 }

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

@@ -53,6 +53,11 @@ private static IReadOnlyList<ConstructorState> GetConstructors(
       return ctorStates ?? (IReadOnlyList<ConstructorState>)Array.Empty<ConstructorState>();
    }
 
+   public static IReadOnlyList<GenericTypeParameterState> GetGenericTypeParameters(this INamedTypeSymbol type)
+   {
+      return type.TypeParameters.GetGenericTypeParameters();
+   }
+
    public static IReadOnlyList<ContainingTypeState> GetContainingTypes(
       this INamedTypeSymbol type)
    {
@@ -64,12 +69,32 @@ public static IReadOnlyList<ContainingTypeState> GetContainingTypes(
 
       while (containingType != null)
       {
-         types.Add(new ContainingTypeState(containingType.Name, containingType.IsReferenceType, containingType.IsRecord));
+         var typeState = new ContainingTypeState(
+            containingType.Name,
+            containingType.IsReferenceType,
+            containingType.IsRecord,
+            containingType.GetGenericTypeParameters());
+         types.Add(typeState);
          containingType = containingType.ContainingType;
       }
 
       types.Reverse();
 
       return types;
    }
+
+   public static bool IsNestedInGenericClass(this INamedTypeSymbol type)
+   {
+      var containingType = type.ContainingType;
+
+      while (containingType != null)
+      {
+         if (!containingType.TypeParameters.IsDefaultOrEmpty)
+            return true;
+
+         containingType = containingType.ContainingType;
+      }
+
+      return false;
+   }
 }

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

@@ -305,7 +305,7 @@ public static StringBuilder RenderContainingTypesStart(
                            : containingType.IsReferenceType ? "class " : "struct ";
 
          sb.Append(@"
-partial ").Append(typeKind).Append(containingType.Name).Append(@"
+partial ").Append(typeKind).Append(containingType.Name).AppendGenericTypeParameters(containingType.GenericParameters).Append(@"
 {");
       }
 

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

@@ -0,0 +1,26 @@
+using Thinktecture.CodeAnalysis;
+
+namespace Thinktecture;
+
+public static class TypeParameterSymbolExtensions
+{
+   public static IReadOnlyList<GenericTypeParameterState> GetGenericTypeParameters(this ImmutableArray<ITypeParameterSymbol> generics)
+   {
+      if (generics.IsDefaultOrEmpty)
+         return [];
+
+      var genericTypeParameters = new List<GenericTypeParameterState>(generics.Length);
+
+      for (var i = 0; i < generics.Length; i++)
+      {
+         var typeParam = generics[i];
+         var constraints = typeParam.GetConstraints();
+
+         genericTypeParameters.Add(new GenericTypeParameterState(
+                                      typeParam.Name,
+                                      constraints));
+      }
+
+      return genericTypeParameters;
+   }
+}