Fix generation for nested types that are not classes

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/Models/HierarchyInfo.Syntax.cs

@@ -30,28 +30,26 @@ public CompilationUnitSyntax GetCompilationUnit(
         // Create the partial type declaration with the given member declarations.
         // This code produces a class declaration as follows:
         //
-        // partial class <TYPE_NAME>
+        // partial <TYPE_KIND> TYPE_NAME>
         // {
         //     <MEMBERS>
         // }
-        ClassDeclarationSyntax classDeclarationSyntax =
-            ClassDeclaration(Names[0])
+        TypeDeclarationSyntax typeDeclarationSyntax =
+            Hierarchy[0].GetSyntax()
             .AddModifiers(Token(SyntaxKind.PartialKeyword))
             .AddMembers(memberDeclarations.ToArray());
 
         // Add the base list, if present
         if (baseList is not null)
         {
-            classDeclarationSyntax = classDeclarationSyntax.WithBaseList(baseList);
+            typeDeclarationSyntax = typeDeclarationSyntax.WithBaseList(baseList);
         }
 
-        TypeDeclarationSyntax typeDeclarationSyntax = classDeclarationSyntax;
-
         // Add all parent types in ascending order, if any
-        foreach (string parentType in Names.AsSpan().Slice(1))
+        foreach (TypeInfo parentType in Hierarchy.AsSpan().Slice(1))
         {
             typeDeclarationSyntax =
-                ClassDeclaration(parentType)
+                parentType.GetSyntax()
                 .AddModifiers(Token(SyntaxKind.PartialKeyword))
                 .AddMembers(typeDeclarationSyntax);
         }

CommunityToolkit.Mvvm.SourceGenerators/Models/HierarchyInfo.cs

@@ -22,8 +22,8 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.Models;
 /// <param name="FilenameHint">The filename hint for the current type.</param>
 /// <param name="MetadataName">The metadata name for the current type.</param>
 /// <param name="Namespace">Gets the namespace for the current type.</param>
-/// <param name="Names">Gets the sequence of type definitions containing the current type.</param>
-internal sealed partial record HierarchyInfo(string FilenameHint, string MetadataName, string Namespace, ImmutableArray<string> Names)
+/// <param name="Hierarchy">Gets the sequence of type definitions containing the current type.</param>
+internal sealed partial record HierarchyInfo(string FilenameHint, string MetadataName, string Namespace, ImmutableArray<TypeInfo> Hierarchy)
 {
     /// <summary>
     /// Creates a new <see cref="HierarchyInfo"/> instance from a given <see cref="INamedTypeSymbol"/>.
@@ -32,20 +32,22 @@ internal sealed partial record HierarchyInfo(string FilenameHint, string Metadat
     /// <returns>A <see cref="HierarchyInfo"/> instance describing <paramref name="typeSymbol"/>.</returns>
     public static HierarchyInfo From(INamedTypeSymbol typeSymbol)
     {
-        ImmutableArray<string>.Builder names = ImmutableArray.CreateBuilder<string>();
+        ImmutableArray<TypeInfo>.Builder hierarchy = ImmutableArray.CreateBuilder<TypeInfo>();
 
         for (INamedTypeSymbol? parent = typeSymbol;
              parent is not null;
              parent = parent.ContainingType)
         {
-            names.Add(parent.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat));
+            hierarchy.Add(new TypeInfo(
+                parent.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
+                parent.TypeKind));
         }
 
         return new(
             typeSymbol.GetFullMetadataNameForFileName(),
             typeSymbol.MetadataName,
             typeSymbol.ContainingNamespace.ToDisplayString(new(typeQualificationStyle: NameAndContainingTypesAndNamespaces)),
-            names.ToImmutable());
+            hierarchy.ToImmutable());
     }
 
     /// <summary>
@@ -59,7 +61,7 @@ protected override void AddToHashCode(ref HashCode hashCode, HierarchyInfo obj)
             hashCode.Add(obj.FilenameHint);
             hashCode.Add(obj.MetadataName);
             hashCode.Add(obj.Namespace);
-            hashCode.AddRange(obj.Names);
+            hashCode.AddRange(obj.Hierarchy);
         }
 
         /// <inheritdoc/>
@@ -69,7 +71,7 @@ protected override bool AreEqual(HierarchyInfo x, HierarchyInfo y)
                 x.FilenameHint == y.FilenameHint &&
                 x.MetadataName == y.MetadataName &&
                 x.Namespace == y.Namespace &&
-                x.Names.SequenceEqual(y.Names);
+                x.Hierarchy.SequenceEqual(y.Hierarchy);
         }
     }
 }

CommunityToolkit.Mvvm.SourceGenerators/Models/TypeInfo.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace CommunityToolkit.Mvvm.SourceGenerators.Models;
+
+/// <summary>
+/// A model describing a type info in a type hierarchy.
+/// </summary>
+/// <param name="QualifiedName">The qualified name for the type.</param>
+/// <param name="Kind">The type of the type in the hierarchy.</param>
+internal sealed record TypeInfo(string QualifiedName, TypeKind Kind)
+{
+    /// <summary>
+    /// Creates a <see cref="TypeDeclarationSyntax"/> instance for the current info.
+    /// </summary>
+    /// <returns>A <see cref="TypeDeclarationSyntax"/> instance for the current info.</returns>
+    public TypeDeclarationSyntax GetSyntax()
+    {
+        // Create the partial type declaration with the kind.
+        // This code produces a class declaration as follows:
+        //
+        // <TYPE_KIND> <TYPE_NAME>
+        // {
+        // }
+        return Kind switch
+        {
+            TypeKind.Struct => StructDeclaration(QualifiedName),
+            TypeKind.Interface => InterfaceDeclaration(QualifiedName),
+            _ => ClassDeclaration(QualifiedName)
+        };
+    }
+}