🐛 do not remove attribute from qualified name

Author: rsking

src/Patterns.Builder.Generator/SymbolExtensions.cs

@@ -21,41 +21,6 @@ namespace Microsoft.CodeAnalysis;
 /// </summary>
 internal static class SymbolExtensions
 {
-    /// <content>
-    /// The <see cref="Type"/> extensions.
-    /// </content>
-    /// <param name="type">The type.</param>
-    extension(Type type)
-    {
-        /// <summary>
-        /// Converts the type to the <see cref="TypeSyntax"/>.
-        /// </summary>
-        /// <param name="parameters">The type parameters.</param>
-        /// <returns>The type syntax.</returns>
-        /// <exception cref="ArgumentOutOfRangeException">The parameters are the wrong length.</exception>
-        public NameSyntax ToTypeSyntax(IEnumerable<TypeSyntax> parameters)
-        {
-            if (!type.IsGenericTypeDefinition)
-            {
-                return SyntaxFactory.QualifiedName(type.FullName);
-            }
-
-            var index = type.Name.IndexOf('`');
-            var name = type.Name[..index];
-            var count = int.Parse(type.Name[(index + 1)..], System.Globalization.CultureInfo.InvariantCulture);
-
-            var parameterList = SeparatedList(parameters);
-            if (count != parameterList.Count)
-            {
-                throw new ArgumentOutOfRangeException(nameof(parameters));
-            }
-
-            return QualifiedName(
-                SyntaxFactory.QualifiedName(type.Namespace),
-                GenericName(Identifier(name), TypeArgumentList(parameterList)));
-        }
-    }
-
     /// <content>
     /// The <see cref="ITypeSymbol"/> extensions.
     /// </content>
@@ -211,7 +176,7 @@ static SeparatedSyntaxList<TypeSyntax> GetTypeArguments(INamedTypeSymbol type)
         {
             { SpecialType: SpecialType.System_Collections_Generic_ICollection_T } => true,
             { OriginalDefinition: { } originalDefinition } when SymbolEqualityComparer.Default.Equals(originalDefinition, collectionType) => true,
-            { AllInterfaces: { } interfaces } when interfaces.Select(i => i.OriginalDefinition).Contains(collectionType, SymbolEqualityComparer.Default) => true,
+            { AllInterfaces: var interfaces } when interfaces.Select(i => i.OriginalDefinition).Contains(collectionType, SymbolEqualityComparer.Default) => true,
             _ => false,
         };
 
@@ -221,49 +186,46 @@ static SeparatedSyntaxList<TypeSyntax> GetTypeArguments(INamedTypeSymbol type)
         public bool IsDictionary(ITypeSymbol? dictionaryType) => type switch
         {
             { OriginalDefinition: { } originalDefinition } when SymbolEqualityComparer.Default.Equals(originalDefinition, dictionaryType) => true,
-            { AllInterfaces: { } interfaces } when interfaces.Select(i => i.OriginalDefinition).Contains(dictionaryType, SymbolEqualityComparer.Default) => true,
+            { AllInterfaces: var interfaces } when interfaces.Select(i => i.OriginalDefinition).Contains(dictionaryType, SymbolEqualityComparer.Default) => true,
             _ => false,
         };
     }
 
-    extension(IMethodSymbol methodSymbol)
+    /// <content>
+    /// The <see cref="IMethodSymbol"/> extensions.
+    /// </content>
+    /// <param name="method">The method symbol.</param>
+    extension(IMethodSymbol method)
     {
         /// <summary>
         /// Gets the parameter list.
         /// </summary>
         /// <returns>The parameter list.</returns>
-        public ParameterListSyntax GetParameterList()
-        {
-            return ParameterList(SeparatedList(GetParameters(methodSymbol)));
-
-            static IEnumerable<ParameterSyntax> GetParameters(IMethodSymbol methodSymbol)
-            {
-                return methodSymbol.Parameters.Select(parameter =>
-                    Parameter(
-                            Identifier(parameter.Name))
-                        .WithType(parameter.Type.ToType()));
-            }
-        }
+        public ParameterListSyntax GetParameterList() =>
+            ParameterList(
+                SeparatedList(
+                    method.Parameters.Select(parameter =>
+                        Parameter(
+                                Identifier(parameter.Name))
+                            .WithType(parameter.Type.ToType()))));
 
         /// <summary>
         /// Gets the object creation.
         /// </summary>
         /// <returns>The object creation list.</returns>
         public ObjectCreationExpressionSyntax GetObjectCreation()
         {
-            if (methodSymbol is { MethodKind: MethodKind.Constructor, ReceiverType: { } receiverType })
+            if (method is { MethodKind: MethodKind.Constructor, ReceiverType: { } receiverType })
             {
                 return ObjectCreationExpression(
                         SyntaxFactory.QualifiedName(receiverType.ToString()))
-                    .WithArgumentList(ArgumentList(SeparatedList(GetArguments(methodSymbol))));
+                    .WithArgumentList(
+                        ArgumentList(
+                            SeparatedList(
+                                method.Parameters.Select(static parameter => Argument(IdentifierName(parameter.Name))))));
             }
 
             throw new InvalidOperationException();
-
-            static IEnumerable<ArgumentSyntax> GetArguments(IMethodSymbol methodSymbol)
-            {
-                return Enumerable.Select(methodSymbol.Parameters, parameter => Argument(IdentifierName(parameter.Name)));
-            }
         }
     }
 }

src/Patterns.Builder.Generator/SyntaxExtensions.cs

@@ -8,11 +8,54 @@
 namespace Microsoft.CodeAnalysis.CSharp;
 #pragma warning restore IDE0130, CheckNamespace
 
+#pragma warning disable RCS1263, SA1101
+
 /// <summary>
 /// The syntax extensions.
 /// </summary>
 internal static class SyntaxExtensions
 {
+    /// <content>
+    /// The <see cref="Type"/> extensions.
+    /// </content>
+    /// <param name="type">The type.</param>
+    extension(Type type)
+    {
+        /// <summary>
+        /// Converts the type to the <see cref="Syntax.TypeSyntax"/>.
+        /// </summary>
+        /// <param name="parameters">The type parameters.</param>
+        /// <returns>The type syntax.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The parameters are the wrong length.</exception>
+        public Syntax.NameSyntax ToTypeSyntax(IEnumerable<Syntax.TypeSyntax> parameters)
+        {
+            if (!type.IsGenericTypeDefinition)
+            {
+                return type.FullName is { } fullName
+                    ? SyntaxFactory.QualifiedName(fullName)
+                    : throw new InvalidOperationException();
+            }
+
+            var index = type.Name.IndexOf('`');
+            var name = type.Name[..index];
+            var count = int.Parse(type.Name[(index + 1)..], System.Globalization.CultureInfo.InvariantCulture);
+
+            var parameterList = SyntaxFactory.SeparatedList(parameters);
+            if (count != parameterList.Count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(parameters));
+            }
+
+            var @namespace = type.Namespace is { } n
+                ? SyntaxFactory.QualifiedName(n)
+                : throw new InvalidOperationException();
+
+            return SyntaxFactory.QualifiedName(
+                @namespace,
+                SyntaxFactory.GenericName(SyntaxFactory.Identifier(name), SyntaxFactory.TypeArgumentList(parameterList)));
+        }
+    }
+
     /// <summary>
     /// Converts the simple names to a qualified name.
     /// </summary>

src/Patterns.Builder.Generator/SyntaxFactoryExtensions.cs

@@ -20,25 +20,6 @@ internal static class SyntaxFactoryExtensions
         /// </summary>
         /// <param name="fullName">The full name.</param>
         /// <returns><see cref="Syntax.NameSyntax"/>.</returns>
-        public static Syntax.NameSyntax QualifiedName(string? fullName)
-        {
-            return GetNames(fullName).ToQualifiedName();
-
-            static IEnumerable<Syntax.IdentifierNameSyntax> GetNames(string? fullName)
-            {
-                return fullName switch
-                {
-                    not null => fullName.Split('.').Select(RemoveAttribute).Select(SyntaxFactory.IdentifierName),
-                    _ => [],
-                };
-
-                static string RemoveAttribute(string name)
-                {
-                    return name.EndsWith(nameof(Attribute), StringComparison.Ordinal)
-                        ? name[..^nameof(Attribute).Length]
-                        : name;
-                }
-            }
-        }
+        public static Syntax.NameSyntax QualifiedName(string fullName) => fullName.Split('.').Select(SyntaxFactory.IdentifierName).ToQualifiedName();
     }
 }