Fix #17 and #18. Add OnUxmlTraitsInitialized partial method.

Author: ChebanovDD

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

@@ -20,14 +20,6 @@ internal static class DiagnosticDescriptors
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true);
 
-    public static readonly DiagnosticDescriptor PropertyAndDefaultValueTypesMismatchError = new(
-        id: "UXMLG003",
-        title: "Types mismatch",
-        messageFormat: "UxmlAttribute for '{0}' property was not created. The default property and attribute value must be of the same type.",
-        category: typeof(UxmlGenerator).FullName,
-        defaultSeverity: DiagnosticSeverity.Error,
-        isEnabledByDefault: true);
-
     public static readonly DiagnosticDescriptor PropertyTypeIsNotSupportedError = new(
         id: "UXMLG004",
         title: "Property type is not supported",

src/UnityUxmlGenerator/Diagnostics/DiagnosticDescriptors.cs

@@ -1,5 +1,4 @@
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using UnityUxmlGenerator.Captures;
 using UnityUxmlGenerator.Extensions;
@@ -27,16 +26,6 @@ public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)
             return;
         }
 
-        if (attribute!.ArgumentList is not null && attribute.ArgumentList.Arguments.Any())
-        {
-            if (HasSameType(property, attribute.ArgumentList.Arguments.First()) == false)
-            {
-                RegisterDiagnostic(PropertyAndDefaultValueTypesMismatchError, property.GetLocation(),
-                    property.GetName());
-                return;
-            }
-        }
-
         var @class = property.GetParent<ClassDeclarationSyntax>();
         if (@class.InheritsFromAnyType() == false)
         {
@@ -60,52 +49,4 @@ public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)
 
         uxmlTraits.Properties.Add((property, attribute));
     }
-
-    private static bool HasSameType(BasePropertyDeclarationSyntax property, AttributeArgumentSyntax attributeArgument)
-    {
-        var parameter = attributeArgument.Expression;
-
-        if (parameter.IsKind(SyntaxKind.DefaultLiteralExpression))
-        {
-            return true;
-        }
-
-        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;
-            }
-        }
-
-        SyntaxToken? propertyTypeIdentifier = property.Type switch
-        {
-            IdentifierNameSyntax identifierName => identifierName.Identifier,
-            QualifiedNameSyntax qualifiedNameSyntax => qualifiedNameSyntax.Right.Identifier,
-            _ => null
-        };
-
-        if (propertyTypeIdentifier is null)
-        {
-            return false;
-        }
-
-        return propertyTypeIdentifier.Value.IsKind(SyntaxKind.IdentifierToken) &&
-               (parameter.IsKind(SyntaxKind.InvocationExpression) ||
-                parameter.IsKind(SyntaxKind.SimpleMemberAccessExpression));
-    }
 }

src/UnityUxmlGenerator/SyntaxReceivers/UxmlTraitsReceiver.cs

@@ -64,7 +64,7 @@ private static IEnumerable<MemberDeclarationSyntax> GetUxmlAttributeMembers()
                 parameter: ParameterWidget(
                     identifier: "defaultValue",
                     type: NullableType(PredefinedType(Token(SyntaxKind.ObjectKeyword))),
-                    addDefaultKeyword: true),
+                    defaultValueKeyword: SyntaxKind.DefaultKeyword),
                 bodyStatement: AssignmentStatementWidget(
                     left: IdentifierName("DefaultValue"),
                     right: IdentifierName("defaultValue")),

src/UnityUxmlGenerator/UxmlGenerator.Attributes.cs

@@ -23,13 +23,23 @@ private static SourceText GenerateUxmlTraits(GeneratorExecutionContext context,
                 member: ClassWidget(
                     identifier: capture.ClassName,
                     modifier: SyntaxKind.PartialKeyword,
-                    member: ClassWidget(
-                        identifier: "UxmlTraits",
-                        modifiers: new[] { SyntaxKind.PublicKeyword, SyntaxKind.NewKeyword },
-                        baseType: SimpleBaseType(IdentifierName($"{GetBaseClassName(context, capture)}.UxmlTraits")),
-                        members: GetTraitsClassMembers(context, capture),
-                        addGeneratedCodeAttributes: true
-                    )),
+                    members: new MemberDeclarationSyntax[]
+                    {
+                        ClassWidget(
+                            identifier: "UxmlTraits",
+                            modifiers: new[] { SyntaxKind.PublicKeyword, SyntaxKind.NewKeyword },
+                            baseType: SimpleBaseType(IdentifierName($"{GetBaseClassName(context, capture)}.UxmlTraits")),
+                            members: GetTraitsClassMembers(context, capture),
+                            addGeneratedCodeAttributes: true),
+                        MethodWidget(
+                            identifier: "OnUxmlTraitsInitialized",
+                            type: PredefinedType(Token(SyntaxKind.VoidKeyword)),
+                            modifier: SyntaxKind.PartialKeyword,
+                            parameter: ParameterWidget(
+                                identifier: "uxmlAttributes",
+                                type: IdentifierName(string.Format(UnityUiElementsFullName, "IUxmlAttributes"))),
+                            addGeneratedCodeAttributes: true)
+                    }),
                 normalizeWhitespace: true)
             .GetText(Encoding.UTF8);
     }
@@ -39,7 +49,8 @@ private static IEnumerable<MemberDeclarationSyntax> GetTraitsClassMembers(Genera
     {
         var initMethodBody = new List<StatementSyntax>
         {
-            MethodBaseCallWidget(
+            MethodCallWidget(
+                expression: BaseExpression(),
                 identifier: "Init",
                 arguments: new[]
                 {
@@ -73,6 +84,12 @@ private static IEnumerable<MemberDeclarationSyntax> GetTraitsClassMembers(Genera
             traitsClassMembers.Add(GetAttributeFieldDeclaration(uxmlAttributeInfo));
         }
 
+        initMethodBody.Add(MethodCallWidget(
+            expression: IdentifierName("control"),
+            identifier: "OnUxmlTraitsInitialized",
+            argument: Argument(IdentifierName("bag")))
+        );
+
         var initMethod = MethodWidget(
             identifier: "Init",
             type: PredefinedType(Token(SyntaxKind.VoidKeyword)),
@@ -267,13 +284,22 @@ private static void ConfigureAttributeInfoAsPredefinedType(PredefinedTypeSyntax
 
         return attribute.ArgumentList.Arguments.First().Expression switch
         {
+            IdentifierNameSyntax identifierName => identifierName.Identifier.Text,
+            PrefixUnaryExpressionSyntax unary => GetUnaryExpressionValue(unary),
             LiteralExpressionSyntax literal => GetLiteralExpressionValue(literal),
             InvocationExpressionSyntax invocation => GetInvocationExpressionValue(invocation),
             MemberAccessExpressionSyntax member => GetMemberAccessExpressionValue(member),
             _ => null
         };
     }
 
+    private static string GetUnaryExpressionValue(PrefixUnaryExpressionSyntax unary)
+    {
+        var value = unary.Operand.GetText().ToString();
+
+        return unary.IsKind(SyntaxKind.UnaryMinusExpression) ? $"-{value}" : value;
+    }
+
     private static string? GetLiteralExpressionValue(LiteralExpressionSyntax literal)
     {
         if (literal.Token.IsKind(SyntaxKind.DefaultKeyword))

src/UnityUxmlGenerator/UxmlGenerator.Traits.cs

@@ -272,6 +272,11 @@ private static MethodDeclarationSyntax MethodWidget(
             methodDeclaration = methodDeclaration.WithBody(Block(bodyStatements));
         }
 
+        if (bodyStatement is null && bodyStatements is null)
+        {
+            methodDeclaration = methodDeclaration.WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
+        }
+
         return BaseWidgetDecoration(
             widget: methodDeclaration,
             modifier: modifier,
@@ -284,41 +289,47 @@ private static MethodDeclarationSyntax MethodWidget(
     private static ParameterSyntax ParameterWidget(
         string identifier,
         TypeSyntax type,
-        bool addDefaultKeyword = false)
+        SyntaxKind defaultValueKeyword = SyntaxKind.None)
     {
         var parameterSyntax = Parameter(Identifier(identifier))
             .WithType(type);
 
-        if (addDefaultKeyword)
-        {
-            parameterSyntax = parameterSyntax.WithDefault(EqualsValueClause(
-                LiteralExpression(SyntaxKind.DefaultLiteralExpression, Token(SyntaxKind.DefaultKeyword))));
-        }
-
-        return parameterSyntax;
+        return defaultValueKeyword switch
+        {
+            SyntaxKind.NullKeyword => parameterSyntax.WithDefault(EqualsValueClause(
+                LiteralExpression(SyntaxKind.NullLiteralExpression, Token(SyntaxKind.NullKeyword)))),
+            SyntaxKind.TrueKeyword => parameterSyntax.WithDefault(EqualsValueClause(
+                LiteralExpression(SyntaxKind.TrueLiteralExpression, Token(SyntaxKind.TrueKeyword)))),
+            SyntaxKind.FalseKeyword => parameterSyntax.WithDefault(EqualsValueClause(
+                LiteralExpression(SyntaxKind.FalseLiteralExpression, Token(SyntaxKind.FalseKeyword)))),
+            SyntaxKind.DefaultKeyword => parameterSyntax.WithDefault(EqualsValueClause(
+                LiteralExpression(SyntaxKind.DefaultLiteralExpression, Token(SyntaxKind.DefaultKeyword)))),
+            _ => parameterSyntax
+        };
     }
 
-    private static StatementSyntax MethodBaseCallWidget(
+    private static StatementSyntax MethodCallWidget(
+        ExpressionSyntax expression,
         string identifier,
         ArgumentSyntax? argument = null,
         IEnumerable<ArgumentSyntax>? arguments = null)
     {
-        var baseExpression = InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
-            BaseExpression(), IdentifierName(identifier)));
+        var invocationExpression = InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
+            expression, IdentifierName(identifier)));
 
         if (argument is not null)
         {
-            baseExpression = baseExpression.WithArgumentList(baseExpression.ArgumentList
-                .WithArguments(baseExpression.ArgumentList.Arguments.Add(argument)));
+            invocationExpression = invocationExpression.WithArgumentList(invocationExpression.ArgumentList
+                .WithArguments(invocationExpression.ArgumentList.Arguments.Add(argument)));
         }
 
         if (arguments is not null)
         {
-            baseExpression = baseExpression.WithArgumentList(baseExpression.ArgumentList
-                .WithArguments(baseExpression.ArgumentList.Arguments.AddRange(arguments)));
+            invocationExpression = invocationExpression.WithArgumentList(invocationExpression.ArgumentList
+                .WithArguments(invocationExpression.ArgumentList.Arguments.AddRange(arguments)));
         }
 
-        return ExpressionStatement(baseExpression);
+        return ExpressionStatement(invocationExpression);
     }
 
     private static StatementSyntax LocalVariableWidget(