Generate factory using syntax tree API.

Author: ChebanovDD

src/UnityUxmlGenerator.UnityPackage/Assets/Plugins/UnityUxmlGenerator/Runtime/UnityUxmlGenerator.dll

@@ -0,0 +1 @@
+global using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

src/UnityUxmlGenerator/Usings.cs

@@ -0,0 +1,98 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace UnityUxmlGenerator;
+
+internal sealed partial class UxmlGenerator
+{
+    private static CompilationUnitSyntax GetCompilationUnit(TypeDeclarationSyntax typeDeclarationSyntax,
+        IReadOnlyList<MemberDeclarationSyntax>? memberDeclarations = null, string? @namespace = null,
+        BaseListSyntax? baseList = null)
+    {
+        if (memberDeclarations is not null)
+        {
+            typeDeclarationSyntax = typeDeclarationSyntax.AddMembers(ProcessMemberDeclarations(memberDeclarations));
+        }
+
+        if (baseList is not null)
+        {
+            typeDeclarationSyntax = typeDeclarationSyntax.WithBaseList(baseList);
+        }
+
+        if (string.IsNullOrEmpty(@namespace))
+        {
+            // If there is no namespace, attach the pragma directly to the declared type,
+            // and skip the namespace declaration. This will produce code as follows:
+            //
+            // <SYNTAX_TRIVIA>
+            // <TYPE_HIERARCHY>
+            return
+                CompilationUnit()
+                    .AddMembers(typeDeclarationSyntax)
+                    .NormalizeWhitespace();
+        }
+
+        // Prepare the leading trivia for the generated compilation unit.
+        // This will produce code as follows:
+        //
+        // <auto-generated/>
+        // #pragma warning disable
+        // #nullable enable
+        SyntaxTriviaList syntaxTriviaList = TriviaList(
+            Comment("// <auto-generated/>"),
+            Trivia(PragmaWarningDirectiveTrivia(Token(SyntaxKind.DisableKeyword), true)),
+            Trivia(NullableDirectiveTrivia(Token(SyntaxKind.EnableKeyword), true)));
+
+        // Create the compilation unit with disabled warnings, target namespace and generated type.
+        // This will produce code as follows:
+        //
+        // <SYNTAX_TRIVIA>
+        // namespace <NAMESPACE>
+        // {
+        //     <TYPE_HIERARCHY>
+        // }
+        return
+            CompilationUnit()
+                .AddMembers(NamespaceDeclaration(IdentifierName(@namespace!))
+                    .WithLeadingTrivia(syntaxTriviaList)
+                    .AddMembers(typeDeclarationSyntax))
+                .NormalizeWhitespace();
+    }
+
+    private static MemberDeclarationSyntax[] ProcessMemberDeclarations(
+        IReadOnlyList<MemberDeclarationSyntax> memberDeclarations)
+    {
+        var annotatedMemberDeclarations = new MemberDeclarationSyntax[memberDeclarations.Count];
+
+        for (var i = 0; i < memberDeclarations.Count; i++)
+        {
+            annotatedMemberDeclarations[i] = ProcessMemberDeclaration(memberDeclarations[i]);
+        }
+
+        return annotatedMemberDeclarations;
+    }
+
+    private static MemberDeclarationSyntax ProcessMemberDeclaration(MemberDeclarationSyntax member)
+    {
+        // [GeneratedCode] is always present.
+        member = member
+            .WithoutLeadingTrivia()
+            .AddAttributeLists(AttributeList(SingletonSeparatedList(
+                Attribute(IdentifierName("global::System.CodeDom.Compiler.GeneratedCode"))
+                    .AddArgumentListArguments(
+                        AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(AssemblyName.Name))),
+                        AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(AssemblyName.Version.ToString())))))))
+            .WithLeadingTrivia(member.GetLeadingTrivia());
+
+        // [ExcludeFromCodeCoverage] is not supported on interfaces and fields.
+        if (member.Kind() is not SyntaxKind.InterfaceDeclaration and not SyntaxKind.FieldDeclaration)
+        {
+            member = member
+                .AddAttributeLists(AttributeList(SingletonSeparatedList(
+                    Attribute(IdentifierName("global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage")))));
+        }
+
+        return member;
+    }
+}

src/UnityUxmlGenerator/UxmlGenerator.Execute.cs

@@ -1,27 +1,34 @@
-using UnityUxmlGenerator.Captures;
+using System.Text;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using UnityUxmlGenerator.Captures;
 
 namespace UnityUxmlGenerator;
 
 internal sealed partial class UxmlGenerator
 {
-    private static string GenerateUxmlFactory(UxmlFactoryCapture capture)
+    private static SourceText GenerateUxmlFactory(UxmlFactoryCapture capture)
     {
-        return $$"""
-// <auto-generated/>
-#pragma warning disable
+        var @class = ClassDeclaration(capture.ClassName)
+            .AddModifiers(Token(SyntaxKind.PartialKeyword));
 
-#nullable enable
+        var classMembers = GetFactoryClassMembers(capture);
 
-namespace {{capture.ClassNamespace}}
-{
-    partial class {{capture.ClassName}}
-    {
-        {{GeneratedCodeAttribute}}
-        public new class UxmlFactory : global::UnityEngine.UIElements.UxmlFactory<{{capture.ClassName}}, UxmlTraits> 
-        {
-        }
+        return GetCompilationUnit(@class, classMembers, capture.ClassNamespace).GetText(Encoding.UTF8);
     }
-}
-""";
+
+    private static List<MemberDeclarationSyntax> GetFactoryClassMembers(UxmlFactoryCapture capture)
+    {
+        var uxmlFactoryBaseList =
+            SimpleBaseType(
+                IdentifierName($"global::UnityEngine.UIElements.UxmlFactory<{capture.ClassName}, UxmlTraits>"));
+
+        var uxmlFactoryClass =
+            ClassDeclaration("UxmlFactory")
+                .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.NewKeyword)))
+                .WithBaseList(BaseList(SingletonSeparatedList<BaseTypeSyntax>(uxmlFactoryBaseList)));
+
+        return new List<MemberDeclarationSyntax> { uxmlFactoryClass };
     }
 }