Add all uxml attributes support.

ChebanovDD · ChebanovDD · commit 7e8a058f8adc · 2023-05-19T23:19:18.000+08:00
diff --git a/src/UnityUxmlGenerator.UnityPackage/Assets/Plugins/UnityUxmlGenerator/Runtime/UnityUxmlGenerator.dll b/src/UnityUxmlGenerator.UnityPackage/Assets/Plugins/UnityUxmlGenerator/Runtime/UnityUxmlGenerator.dll
diff --git a/src/UnityUxmlGenerator/Extensions/StringExtensions.cs b/src/UnityUxmlGenerator/Extensions/StringExtensions.cs
@@ -4,6 +4,11 @@ namespace UnityUxmlGenerator.Extensions;
 
 internal static class StringExtensions
 {
+    public static string FirstCharToUpper(this string str)
+    {
+        return $"{char.ToUpper(str[0])}{str.Substring(1)}";
+    }
+
     public static string ToPrivateFieldName(this string propertyName)
     {
         return string.Concat("_", char.ToLower(propertyName[0]), propertyName.Substring(1));
diff --git a/src/UnityUxmlGenerator/Extensions/TypeSyntaxExtensions.cs b/src/UnityUxmlGenerator/Extensions/TypeSyntaxExtensions.cs
@@ -0,0 +1,70 @@
+﻿using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace UnityUxmlGenerator.Extensions;
+
+internal static class TypeSyntaxExtensions
+{
+    public static bool IsBoolType(this TypeSyntax typeSyntax)
+    {
+        if (typeSyntax is PredefinedTypeSyntax predefinedTypeSyntax)
+        {
+            return IsBoolType(predefinedTypeSyntax);
+        }
+
+        return IsBoolKind(typeSyntax.RawKind);
+    }
+
+    public static bool IsBoolType(this PredefinedTypeSyntax typeSyntax)
+    {
+        return IsBoolKind(typeSyntax.Keyword.RawKind);
+    }
+
+    public static bool IsStringType(this TypeSyntax typeSyntax)
+    {
+        if (typeSyntax is PredefinedTypeSyntax predefinedTypeSyntax)
+        {
+            return IsStringType(predefinedTypeSyntax);
+        }
+
+        return IsStringKind(typeSyntax.RawKind);
+    }
+
+    public static bool IsStringType(this PredefinedTypeSyntax typeSyntax)
+    {
+        return IsStringKind(typeSyntax.Keyword.RawKind);
+    }
+
+    public static bool IsNumericType(this TypeSyntax typeSyntax)
+    {
+        if (typeSyntax is PredefinedTypeSyntax predefinedTypeSyntax)
+        {
+            return IsNumericType(predefinedTypeSyntax);
+        }
+
+        return IsNumericKind(typeSyntax.RawKind);
+    }
+
+    public static bool IsNumericType(this PredefinedTypeSyntax typeSyntax)
+    {
+        return IsNumericKind(typeSyntax.Keyword.RawKind);
+    }
+
+    private static bool IsBoolKind(int rawKind)
+    {
+        return rawKind == (int) SyntaxKind.BoolKeyword;
+    }
+
+    private static bool IsStringKind(int rawKind)
+    {
+        return rawKind == (int) SyntaxKind.StringKeyword;
+    }
+
+    private static bool IsNumericKind(int rawKind)
+    {
+        return rawKind == (int) SyntaxKind.IntKeyword ||
+               rawKind == (int) SyntaxKind.LongKeyword ||
+               rawKind == (int) SyntaxKind.FloatKeyword ||
+               rawKind == (int) SyntaxKind.DoubleKeyword;
+    }
+}
diff --git a/src/UnityUxmlGenerator/Structs/UxmlAttributeInfo.cs b/src/UnityUxmlGenerator/Structs/UxmlAttributeInfo.cs
@@ -0,0 +1,11 @@
+﻿using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace UnityUxmlGenerator.Structs;
+
+public ref struct UxmlAttributeInfo
+{
+    public string TypeIdentifier { get; set; }
+    public string PrivateFieldName { get; set; }
+    public string AttributeUxmlName { get; set; }
+    public ExpressionSyntax DefaultValueAssignmentExpression { get; set; }
+}
diff --git a/src/UnityUxmlGenerator/SyntaxReceivers/UxmlTraitsReceiver.cs b/src/UnityUxmlGenerator/SyntaxReceivers/UxmlTraitsReceiver.cs
@@ -1,4 +1,5 @@
 ﻿using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using UnityUxmlGenerator.Captures;
 using UnityUxmlGenerator.Extensions;
@@ -24,9 +25,20 @@ public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
         }
 
         var property = attribute.GetParent<PropertyDeclarationSyntax>();
+        if (property is null)
+        {
+            return;
+        }
 
-        var @class = property?.GetParent<ClassDeclarationSyntax>();
+        if (attribute.ArgumentList is not null && attribute.ArgumentList.Arguments.Any())
+        {
+            if (HasSameType(property, attribute) == false)
+            {
+                return;
+            }
+        }
 
+        var @class = property.GetParent<ClassDeclarationSyntax>();
         if (@class?.BaseList is null || @class.BaseList.Types.Count == 0)
         {
             return;
@@ -38,15 +50,57 @@ public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
             _captures.Add(@class.Identifier.Text, uxmlTraits);
         }
 
-        uxmlTraits.Properties.Add((property!, GetAttributeArgumentValue(attribute)));
+        uxmlTraits.Properties.Add((property, GetAttributeArgumentValue(attribute)));
+    }
+
+    private static bool HasSameType(BasePropertyDeclarationSyntax property, AttributeSyntax attribute)
+    {
+        var parameter = attribute.ArgumentList!.Arguments.First().Expression;
+
+        if (property.Type is PredefinedTypeSyntax predefinedType)
+        {
+            if (predefinedType.IsBoolType() &&
+                (parameter.IsKind(SyntaxKind.TrueLiteralExpression) ||
+                 parameter.IsKind(SyntaxKind.FalseLiteralExpression)))
+            {
+                return true;
+            }
+
+            if (predefinedType.IsStringType() &&
+                parameter.IsKind(SyntaxKind.StringLiteralExpression))
+            {
+                return true;
+            }
+
+            if (predefinedType.IsNumericType() &&
+                parameter.IsKind(SyntaxKind.NumericLiteralExpression))
+            {
+                return true;
+            }
+        }
+
+        if (property.Type is IdentifierNameSyntax identifierName)
+        {
+            if (identifierName.Identifier.IsKind(SyntaxKind.IdentifierToken) &&
+                (parameter.IsKind(SyntaxKind.InvocationExpression) ||
+                 parameter.IsKind(SyntaxKind.SimpleMemberAccessExpression)))
+            {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     private static string? GetAttributeArgumentValue(AttributeSyntax attribute)
     {
         return attribute.ArgumentList?.Arguments.Single().Expression switch
         {
-            LiteralExpressionSyntax literal => literal.Token.ValueText,
+            LiteralExpressionSyntax literal => literal.Token.IsKind(SyntaxKind.StringLiteralToken)
+                ? literal.Token.ValueText
+                : literal.Token.Text,
             InvocationExpressionSyntax invocation => invocation.ArgumentList.Arguments.Single().Expression.GetText().ToString(),
+            MemberAccessExpressionSyntax member => member.Parent?.ToString(),
             _ => null
         };
     }
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.Attributes.cs b/src/UnityUxmlGenerator/UxmlGenerator.Attributes.cs
@@ -37,12 +37,12 @@ namespace {{AssemblyName.Name}}
     [global::System.AttributeUsageAttribute(global::System.AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
     internal sealed class UxmlAttributeAttribute : global::System.Attribute
     {
-        public UxmlAttributeAttribute(string defaultValue = "")
+        public UxmlAttributeAttribute(object? defaultValue = default)
         {
-            DefaultValue = defaultValue ?? string.Empty;
+            DefaultValue = defaultValue;
         }
 
-        public string DefaultValue { get; }
+        public object? DefaultValue { get; }
     }
 }
 """;
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.Traits.cs b/src/UnityUxmlGenerator/UxmlGenerator.Traits.cs
@@ -5,11 +5,16 @@
 using Microsoft.CodeAnalysis.Text;
 using UnityUxmlGenerator.Captures;
 using UnityUxmlGenerator.Extensions;
+using UnityUxmlGenerator.Structs;
 
 namespace UnityUxmlGenerator;
 
 internal sealed partial class UxmlGenerator
 {
+    private const string UnityColorTypeFullName = "global::UnityEngine.Color";
+    private const string UnityUiElementsFullName = "global::UnityEngine.UIElements.{0}";
+    private const string UxmlColorAttributeDescription = "UxmlColorAttributeDescription";
+
     private static SourceText GenerateUxmlTraits(GeneratorExecutionContext context, UxmlTraitsCapture capture)
     {
         var @class = ClassDeclaration(capture.ClassName).AddModifiers(Token(SyntaxKind.PartialKeyword));
@@ -27,7 +32,7 @@ private static MemberDeclarationSyntax GetTraitsClass(GeneratorExecutionContext
             ClassDeclaration("UxmlTraits")
                 .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.NewKeyword)))
                 .WithBaseList(BaseList(SingletonSeparatedList<BaseTypeSyntax>(uxmlTraitsBaseList)))
-                .WithMembers(List(GetTraitsClassMembers(capture)));
+                .WithMembers(List(GetTraitsClassMembers(context, capture)));
     }
 
     private static string GetBaseClassName(GeneratorExecutionContext context, UxmlTraitsCapture capture)
@@ -56,9 +61,10 @@ private static string GetBaseClassName(GeneratorExecutionContext context, UxmlTr
         return string.Empty;
     }
 
-    private static IEnumerable<MemberDeclarationSyntax> GetTraitsClassMembers(UxmlTraitsCapture capture)
+    private static IEnumerable<MemberDeclarationSyntax> GetTraitsClassMembers(GeneratorExecutionContext context, 
+        UxmlTraitsCapture capture)
     {
-        var members = new List<MemberDeclarationSyntax>(GetAttributeFields(capture));
+        var members = new List<MemberDeclarationSyntax>(GetAttributeFields(context, capture));
 
         var initMethodBody = new List<StatementSyntax>
         {
@@ -88,13 +94,13 @@ private static IEnumerable<MemberDeclarationSyntax> GetTraitsClassMembers(UxmlTr
                 .WithParameterList(ParameterList(SeparatedList<ParameterSyntax>(new SyntaxNodeOrToken[]
                 {
                     Parameter(Identifier("visualElement"))
-                        .WithType(IdentifierName("global::UnityEngine.UIElements.VisualElement")),
+                        .WithType(IdentifierName(string.Format(UnityUiElementsFullName, "VisualElement"))),
                     Token(SyntaxKind.CommaToken),
                     Parameter(Identifier("bag"))
-                        .WithType(IdentifierName("global::UnityEngine.UIElements.IUxmlAttributes")),
+                        .WithType(IdentifierName(string.Format(UnityUiElementsFullName, "IUxmlAttributes"))),
                     Token(SyntaxKind.CommaToken),
                     Parameter(Identifier("context"))
-                        .WithType(IdentifierName("global::UnityEngine.UIElements.CreationContext"))
+                        .WithType(IdentifierName(string.Format(UnityUiElementsFullName, "CreationContext")))
                 })))
                 .WithBody(Block(initMethodBody));
 
@@ -103,44 +109,118 @@ private static IEnumerable<MemberDeclarationSyntax> GetTraitsClassMembers(UxmlTr
         return ProcessMemberDeclarations(members);
     }
 
-    private static IEnumerable<MemberDeclarationSyntax> GetAttributeFields(UxmlTraitsCapture capture)
+    private static IEnumerable<MemberDeclarationSyntax> GetAttributeFields(GeneratorExecutionContext context,
+        UxmlTraitsCapture capture)
     {
         var fields = new List<MemberDeclarationSyntax>();
 
         foreach (var (property, uxmlAttributeDefaultValue) in capture.Properties)
         {
-            var propertyName = property.GetName();
+            fields.Add(GetAttributeFieldDeclaration(GetAttributeInfo(context, property, uxmlAttributeDefaultValue)));
+        }
 
-            var fieldName = propertyName.ToPrivateFieldName();
+        return fields;
+    }
 
-            var attributeType = "UxmlStringAttributeDescription";
-            var attributeUxmlName = propertyName.ToDashCase();
-            var attributeDefaultValue = uxmlAttributeDefaultValue ?? string.Empty;
+    private static UxmlAttributeInfo GetAttributeInfo(GeneratorExecutionContext context,
+        PropertyDeclarationSyntax property, string? uxmlAttributeDefaultValue)
+    {
+        var propertyName = property.GetName();
+        
+        var info = new UxmlAttributeInfo
+        {
+            TypeIdentifier = GetPropertyTypeIdentifier(context, property, out var typeSyntax),
+            PrivateFieldName = propertyName.ToPrivateFieldName(),
+            AttributeUxmlName = propertyName.ToDashCase()
+        };
 
-            fields.Add(GetAttributeFieldDeclaration(attributeType, fieldName, attributeUxmlName,
-                attributeDefaultValue));
+        if (uxmlAttributeDefaultValue is null || typeSyntax is null)
+        {
+            info.DefaultValueAssignmentExpression =
+                LiteralExpression(SyntaxKind.DefaultLiteralExpression, Token(SyntaxKind.DefaultKeyword));
+            return info;
         }
 
-        return fields;
+        if (typeSyntax.IsBoolType())
+        {
+            info.DefaultValueAssignmentExpression = IdentifierName(uxmlAttributeDefaultValue);
+            return info;
+        }
+
+        if (typeSyntax.IsStringType())
+        {
+            info.DefaultValueAssignmentExpression = LiteralExpression(SyntaxKind.StringLiteralExpression,
+                Literal(uxmlAttributeDefaultValue));
+            return info;
+        }
+
+        if (typeSyntax.IsNumericType())
+        {
+            info.DefaultValueAssignmentExpression = LiteralExpression(SyntaxKind.NumericLiteralExpression,
+                Literal(uxmlAttributeDefaultValue, uxmlAttributeDefaultValue));
+            return info;
+        }
+
+        if (info.TypeIdentifier == UxmlColorAttributeDescription)
+        {
+            info.DefaultValueAssignmentExpression = IdentifierName($"global::UnityEngine.{uxmlAttributeDefaultValue}");
+            return info;
+        }
+
+        info.DefaultValueAssignmentExpression = IdentifierName(uxmlAttributeDefaultValue);
+        return info;
+    }
+
+    private static string GetPropertyTypeIdentifier(GeneratorExecutionContext context,
+        BasePropertyDeclarationSyntax property, out TypeSyntax? typeSyntax)
+    {
+        switch (property.Type)
+        {
+            case PredefinedTypeSyntax predefinedType:
+            {
+                var propertyTypeIdentifier = predefinedType.Keyword.Text.FirstCharToUpper();
+
+                typeSyntax = predefinedType;
+
+                return $"Uxml{propertyTypeIdentifier}AttributeDescription";
+            }
+
+            case IdentifierNameSyntax customTypeSyntax:
+            {
+                var type = customTypeSyntax.Identifier.Text;
+                var typeNamespace = customTypeSyntax.GetTypeNamespace(context);
+                var propertyTypeText = $"global::{typeNamespace}.{type}";
+
+                typeSyntax = customTypeSyntax;
+
+                return propertyTypeText == UnityColorTypeFullName
+                    ? UxmlColorAttributeDescription
+                    : $"UxmlEnumAttributeDescription<{propertyTypeText}>";
+            }
+
+            default:
+                typeSyntax = default;
+                return property.Type.GetText().ToString().Trim();
+        }
     }
 
-    private static FieldDeclarationSyntax GetAttributeFieldDeclaration(string attributeType, string fieldName,
-        string attributeName, string attributeDefaultValue)
+    private static FieldDeclarationSyntax GetAttributeFieldDeclaration(UxmlAttributeInfo attributeInfo)
     {
         return
-            FieldDeclaration(VariableDeclaration(IdentifierName($"global::UnityEngine.UIElements.{attributeType}"))
-                    .WithVariables(SingletonSeparatedList(VariableDeclarator(Identifier(fieldName))
+            FieldDeclaration(VariableDeclaration(
+                        IdentifierName(string.Format(UnityUiElementsFullName, attributeInfo.TypeIdentifier)))
+                    .WithVariables(SingletonSeparatedList(VariableDeclarator(Identifier(attributeInfo.PrivateFieldName))
                         .WithInitializer(EqualsValueClause(ImplicitObjectCreationExpression()
                             .WithInitializer(InitializerExpression(SyntaxKind.ObjectInitializerExpression,
                                 SeparatedList<ExpressionSyntax>(new SyntaxNodeOrToken[]
                                 {
                                     AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
-                                        IdentifierName("name"),
-                                        LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(attributeName))),
+                                        IdentifierName("name"), 
+                                        LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(attributeInfo.AttributeUxmlName))),
                                     Token(SyntaxKind.CommaToken),
                                     AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
-                                        IdentifierName("defaultValue"),
-                                        LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(attributeDefaultValue)))
+                                        IdentifierName("defaultValue"), 
+                                        attributeInfo.DefaultValueAssignmentExpression)
                                 }))))))))
                 .WithModifiers(TokenList(Token(SyntaxKind.PrivateKeyword), Token(SyntaxKind.ReadOnlyKeyword)));
     }

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,11 @@ namespace UnityUxmlGenerator.Extensions;`
`4`	`4`
`5`	`5`	`internal static class StringExtensions`
`6`	`6`	`{`
	`7`	`+ public static string FirstCharToUpper(this string str)`
	`8`	`+ {`
	`9`	`+ return $"{char.ToUpper(str[0])}{str.Substring(1)}";`
	`10`	`+ }`
	`11`	`+`
`7`	`12`	`public static string ToPrivateFieldName(this string propertyName)`
`8`	`13`	`{`
`9`	`14`	`return string.Concat("_", char.ToLower(propertyName[0]), propertyName.Substring(1));`
Original file line number	Diff line number	Diff line change
`@@ -37,12 +37,12 @@ namespace {{AssemblyName.Name}}`
`37`	`37`	`[global::System.AttributeUsageAttribute(global::System.AttributeTargets.Property, AllowMultiple = false, Inherited = false)]`
`38`	`38`	`internal sealed class UxmlAttributeAttribute : global::System.Attribute`
`39`	`39`	`{`
`40`		`- public UxmlAttributeAttribute(string defaultValue = "")`
	`40`	`+ public UxmlAttributeAttribute(object? defaultValue = default)`
`41`	`41`	`{`
`42`		`- DefaultValue = defaultValue ?? string.Empty;`
	`42`	`+ DefaultValue = defaultValue;`
`43`	`43`	`}`
`44`	`44`
`45`		`- public string DefaultValue { get; }`
	`45`	`+ public object? DefaultValue { get; }`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`""";`