Update some type extensions

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/Extensions/INamedTypeSymbolExtensions.cs

@@ -2,9 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Generic;
-using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 using Microsoft.CodeAnalysis;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
@@ -14,55 +12,6 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
 /// </summary>
 internal static class INamedTypeSymbolExtensions
 {
-    /// <summary>
-    /// Gets a fully qualified metadata name for a given <see cref="INamedTypeSymbol"/> instance.
-    /// </summary>
-    /// <param name="symbol">The input <see cref="INamedTypeSymbol"/> instance.</param>
-    /// <returns>The fully qualified metadata name for <paramref name="symbol"/>.</returns>
-    public static string GetFullyQualifiedMetadataName(this INamedTypeSymbol symbol)
-    {
-        using ImmutableArrayBuilder<char> builder = ImmutableArrayBuilder<char>.Rent();
-
-        static void BuildFrom(ISymbol? symbol, in ImmutableArrayBuilder<char> builder)
-        {
-            switch (symbol)
-            {
-                // Namespaces that are nested also append a leading '.'
-                case INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: false }:
-                    BuildFrom(symbol.ContainingNamespace, in builder);
-                    builder.Add('.');
-                    builder.AddRange(symbol.MetadataName.AsSpan());
-                    break;
-                // Other namespaces (ie. the one right before global) skip the leading '.'
-                case INamespaceSymbol { IsGlobalNamespace: false }:
-                    builder.AddRange(symbol.MetadataName.AsSpan());
-                    break;
-                // Types with no namespace just have their metadata name directly written
-                case ITypeSymbol { ContainingSymbol: INamespaceSymbol { IsGlobalNamespace: true } }:
-                    builder.AddRange(symbol.MetadataName.AsSpan());
-                    break;
-                // Types with a containing non-global namespace also append a leading '.'
-                case ITypeSymbol { ContainingSymbol: INamespaceSymbol namespaceSymbol }:
-                    BuildFrom(namespaceSymbol, in builder);
-                    builder.Add('.');
-                    builder.AddRange(symbol.MetadataName.AsSpan());
-                    break;
-                // Nested types append a leading '+'
-                case ITypeSymbol { ContainingSymbol: ITypeSymbol typeSymbol }:
-                    BuildFrom(typeSymbol, in builder);
-                    builder.Add('+');
-                    builder.AddRange(symbol.MetadataName.AsSpan());
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        BuildFrom(symbol, in builder);
-
-        return builder.ToString();
-    }
-
     /// <summary>
     /// Gets all member symbols from a given <see cref="INamedTypeSymbol"/> instance, including inherited ones.
     /// </summary>

CommunityToolkit.Mvvm.SourceGenerators/Extensions/ITypeSymbolExtensions.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Linq;
+using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 using Microsoft.CodeAnalysis;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
@@ -128,4 +129,82 @@ public static bool InheritsAttributeWithFullyQualifiedName(this ITypeSymbol type
 
         return false;
     }
+
+    /// <summary>
+    /// Checks whether or not a given type symbol has a specified fully qualified metadata name.
+    /// </summary>
+    /// <param name="symbol">The input <see cref="ITypeSymbol"/> instance to check.</param>
+    /// <param name="name">The full name to check.</param>
+    /// <returns>Whether <paramref name="symbol"/> has a full name equals to <paramref name="name"/>.</returns>
+    public static bool HasFullyQualifiedMetadataName(this ITypeSymbol symbol, string name)
+    {
+        using ImmutableArrayBuilder<char> builder = ImmutableArrayBuilder<char>.Rent();
+
+        symbol.AppendFullyQualifiedMetadataName(in builder);
+
+        return builder.WrittenSpan.SequenceEqual(name.AsSpan());
+    }
+
+    /// <summary>
+    /// Gets the fully qualified metadata name for a given <see cref="ITypeSymbol"/> instance.
+    /// </summary>
+    /// <param name="symbol">The input <see cref="ITypeSymbol"/> instance.</param>
+    /// <returns>The fully qualified metadata name for <paramref name="symbol"/>.</returns>
+    public static string GetFullyQualifiedMetadataName(this ITypeSymbol symbol)
+    {
+        using ImmutableArrayBuilder<char> builder = ImmutableArrayBuilder<char>.Rent();
+
+        symbol.AppendFullyQualifiedMetadataName(in builder);
+
+        return builder.ToString();
+    }
+
+    /// <summary>
+    /// Appends the fully qualified metadata name for a given symbol to a target builder.
+    /// </summary>
+    /// <param name="symbol">The input <see cref="ITypeSymbol"/> instance.</param>
+    /// <param name="builder">The target <see cref="ImmutableArrayBuilder{T}"/> instance.</param>
+    public static void AppendFullyQualifiedMetadataName(this ITypeSymbol symbol, in ImmutableArrayBuilder<char> builder)
+    {
+        static void BuildFrom(ISymbol? symbol, in ImmutableArrayBuilder<char> builder)
+        {
+            switch (symbol)
+            {
+                // Namespaces that are nested also append a leading '.'
+                case INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: false }:
+                    BuildFrom(symbol.ContainingNamespace, in builder);
+                    builder.Add('.');
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+
+                // Other namespaces (ie. the one right before global) skip the leading '.'
+                case INamespaceSymbol { IsGlobalNamespace: false }:
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+
+                // Types with no namespace just have their metadata name directly written
+                case ITypeSymbol { ContainingSymbol: INamespaceSymbol { IsGlobalNamespace: true } }:
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+
+                // Types with a containing non-global namespace also append a leading '.'
+                case ITypeSymbol { ContainingSymbol: INamespaceSymbol namespaceSymbol }:
+                    BuildFrom(namespaceSymbol, in builder);
+                    builder.Add('.');
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+
+                // Nested types append a leading '+'
+                case ITypeSymbol { ContainingSymbol: ITypeSymbol typeSymbol }:
+                    BuildFrom(typeSymbol, in builder);
+                    builder.Add('+');
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        BuildFrom(symbol, in builder);
+    }
 }