Fix attribute named argument issue. Add capture validation. Optimize widgets.

ChebanovDD · ChebanovDD · commit b0e815eda4ea · 2023-05-24T19:50:53.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/Captures/UxmlFactoryCapture.cs b/src/UnityUxmlGenerator/Captures/UxmlFactoryCapture.cs
@@ -4,9 +4,12 @@ namespace UnityUxmlGenerator.Captures;
 
 internal sealed class UxmlFactoryCapture : BaseCapture
 {
-    public UxmlFactoryCapture(ClassDeclarationSyntax @class) : base(@class)
+    public UxmlFactoryCapture(ClassDeclarationSyntax @class, AttributeSyntax attribute) : base(@class)
     {
+        Attribute = attribute;
     }
 
     public override string ClassTag => "UxmlFactory";
+
+    public AttributeSyntax Attribute { get; }
 }
diff --git a/src/UnityUxmlGenerator/Captures/UxmlTraitsCapture.cs b/src/UnityUxmlGenerator/Captures/UxmlTraitsCapture.cs
@@ -7,13 +7,13 @@ internal sealed class UxmlTraitsCapture : BaseCapture
     public UxmlTraitsCapture(ClassDeclarationSyntax @class, TypeSyntax baseClassType) : base(@class)
     {
         BaseClassType = baseClassType;
-        Properties = new List<(PropertyDeclarationSyntax property, string? DefaultValue)>();
+        Properties = new List<(PropertyDeclarationSyntax, AttributeSyntax)>();
     }
 
     public override string ClassTag => "UxmlTraits";
 
     public TypeSyntax BaseClassType { get; }
-    public List<(PropertyDeclarationSyntax property, string? DefaultValue)> Properties { get; }
+    public List<(PropertyDeclarationSyntax Property, AttributeSyntax Attribute)> Properties { get; }
 
     public string GetBaseClassName(out TypeSyntax? genericTypeSyntax)
     {
diff --git a/src/UnityUxmlGenerator/Diagnostics/DiagnosticDescriptors.cs b/src/UnityUxmlGenerator/Diagnostics/DiagnosticDescriptors.cs
@@ -27,4 +27,20 @@ internal static class DiagnosticDescriptors
         category: typeof(UxmlGenerator).FullName,
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true);
+
+    public static readonly DiagnosticDescriptor PropertyTypeIsNotSupportedError = new(
+        id: "UXMLG004",
+        title: "Property type is not supported",
+        messageFormat: "Property type '{0}' can not be used as an attribute.",
+        category: typeof(UxmlGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
+    public static readonly DiagnosticDescriptor IncorrectEnumDefaultValueTypeError = new(
+        id: "UXMLG005",
+        title: "Type cannot be the default value for an enum",
+        messageFormat: "Type '{0}' cannot be the default value for an enum.",
+        category: typeof(UxmlGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
 }
diff --git a/src/UnityUxmlGenerator/Diagnostics/DiagnosticExtensions.cs b/src/UnityUxmlGenerator/Diagnostics/DiagnosticExtensions.cs
@@ -4,7 +4,7 @@ namespace UnityUxmlGenerator.Diagnostics;
 
 internal static class DiagnosticExtensions
 {
-    public static Diagnostic CreateDiagnostic(this DiagnosticDescriptor descriptor, Location location, params object[] args)
+    public static Diagnostic CreateDiagnostic(this DiagnosticDescriptor descriptor, Location location, params object?[]? args)
     {
         return Diagnostic.Create(descriptor, location, args);
     }
diff --git a/src/UnityUxmlGenerator/Extensions/SyntaxNodeExtensions.cs b/src/UnityUxmlGenerator/Extensions/SyntaxNodeExtensions.cs
@@ -5,6 +5,29 @@ namespace UnityUxmlGenerator.Extensions;
 
 internal static class SyntaxNodeExtensions
 {
+    public static bool IsAttributeWithName(this SyntaxNode syntaxNode, string attributeName,
+        out AttributeSyntax? attribute)
+    {
+        if (syntaxNode is not AttributeSyntax attributeSyntax)
+        {
+            attribute = default;
+            return false;
+        }
+
+        attribute = attributeSyntax;
+
+        switch (attributeSyntax.Name)
+        {
+            case IdentifierNameSyntax identifierNameSyntax
+                when identifierNameSyntax.Identifier.Text.Contains(attributeName):
+            case QualifiedNameSyntax qualifiedNameSyntax
+                when qualifiedNameSyntax.Right.Identifier.Text.Contains(attributeName):
+                return true;
+        }
+
+        return false;
+    }
+
     public static T? GetParent<T>(this SyntaxNode syntaxNode)
     {
         var parent = syntaxNode.Parent;
@@ -22,10 +45,13 @@ internal static class SyntaxNodeExtensions
         return default;
     }
 
-    public static string? GetTypeNamespace(this TypeSyntax typeSyntax, GeneratorExecutionContext context)
+    public static ITypeSymbol? GetTypeSymbol(this SyntaxNode syntaxNode, GeneratorExecutionContext context)
+    {
+        return context.Compilation.GetSemanticModel(syntaxNode.SyntaxTree).GetTypeInfo(syntaxNode).Type;
+    }
+
+    public static string? GetTypeNamespace(this SyntaxNode syntaxNode, GeneratorExecutionContext context)
     {
-        return context.Compilation
-            .GetSemanticModel(typeSyntax.SyntaxTree)
-            .GetTypeInfo(typeSyntax).Type?.ContainingNamespace.ToString();
+        return GetTypeSymbol(syntaxNode, context)?.ContainingNamespace.ToString();
     }
 }
diff --git a/src/UnityUxmlGenerator/Structs/UxmlAttributeInfo.cs b/src/UnityUxmlGenerator/Structs/UxmlAttributeInfo.cs
@@ -4,8 +4,10 @@ namespace UnityUxmlGenerator.Structs;
 
 public ref struct UxmlAttributeInfo
 {
+    public string PropertyName { get; init; }
+    public string PrivateFieldName { get; init; }
+    public string AttributeUxmlName { get; init; }
+
     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/BaseReceiver.cs b/src/UnityUxmlGenerator/SyntaxReceivers/BaseReceiver.cs
@@ -12,7 +12,7 @@ internal abstract class BaseReceiver : ISyntaxReceiver
     public abstract void OnVisitSyntaxNode(SyntaxNode syntaxNode);
 
     protected void RegisterDiagnostic(DiagnosticDescriptor diagnosticDescriptor, Location location,
-        params object[] args)
+        params object?[]? args)
     {
         _diagnostics.Add(diagnosticDescriptor.CreateDiagnostic(location, args));
     }
diff --git a/src/UnityUxmlGenerator/SyntaxReceivers/UxmlFactoryReceiver.cs b/src/UnityUxmlGenerator/SyntaxReceivers/UxmlFactoryReceiver.cs
@@ -15,19 +15,16 @@ internal sealed class UxmlFactoryReceiver : BaseReceiver
 
     public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)
     {
-        if (syntaxNode is not AttributeSyntax
-            {
-                Name: IdentifierNameSyntax { Identifier.Text: AttributeName }
-            } attribute)
+        if (syntaxNode.IsAttributeWithName(AttributeName, out var attribute) == false)
         {
             return;
         }
 
-        var @class = attribute.GetParent<ClassDeclarationSyntax>();
+        var @class = attribute!.GetParent<ClassDeclarationSyntax>();
 
         if (@class.InheritsFromAnyType())
         {
-            _captures.Add(new UxmlFactoryCapture(@class!));
+            _captures.Add(new UxmlFactoryCapture(@class!, attribute!));
         }
         else if (@class is not null)
         {
diff --git a/src/UnityUxmlGenerator/SyntaxReceivers/UxmlTraitsReceiver.cs b/src/UnityUxmlGenerator/SyntaxReceivers/UxmlTraitsReceiver.cs
@@ -16,23 +16,20 @@ internal sealed class UxmlTraitsReceiver : BaseReceiver
 
     public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)
     {
-        if (syntaxNode is not AttributeSyntax
-            {
-                Name: IdentifierNameSyntax { Identifier.Text: AttributeName }
-            } attribute)
+        if (syntaxNode.IsAttributeWithName(AttributeName, out var attribute) == false)
         {
             return;
         }
 
-        var property = attribute.GetParent<PropertyDeclarationSyntax>();
+        var property = attribute!.GetParent<PropertyDeclarationSyntax>();
         if (property is null)
         {
             return;
         }
 
-        if (attribute.ArgumentList is not null && attribute.ArgumentList.Arguments.Any())
+        if (attribute!.ArgumentList is not null && attribute.ArgumentList.Arguments.Any())
         {
-            if (HasSameType(property, attribute) == false)
+            if (HasSameType(property, attribute.ArgumentList.Arguments.First()) == false)
             {
                 RegisterDiagnostic(PropertyAndDefaultValueTypesMismatchError, property.GetLocation(),
                     property.GetName());
@@ -61,12 +58,12 @@ public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)
             _captures.Add(uxmlTraits.ClassName, uxmlTraits);
         }
 
-        uxmlTraits.Properties.Add((property, GetAttributeArgumentValue(attribute)));
+        uxmlTraits.Properties.Add((property, attribute));
     }
 
-    private static bool HasSameType(BasePropertyDeclarationSyntax property, AttributeSyntax attribute)
+    private static bool HasSameType(BasePropertyDeclarationSyntax property, AttributeArgumentSyntax attributeArgument)
     {
-        var parameter = attribute.ArgumentList!.Arguments.First().Expression;
+        var parameter = attributeArgument.Expression;
 
         if (parameter.IsKind(SyntaxKind.DefaultLiteralExpression))
         {
@@ -95,42 +92,20 @@ private static bool HasSameType(BasePropertyDeclarationSyntax property, Attribut
             }
         }
 
-        if (property.Type is IdentifierNameSyntax identifierName)
+        SyntaxToken? propertyTypeIdentifier = property.Type switch
         {
-            if (identifierName.Identifier.IsKind(SyntaxKind.IdentifierToken) &&
-                (parameter.IsKind(SyntaxKind.InvocationExpression) ||
-                 parameter.IsKind(SyntaxKind.SimpleMemberAccessExpression)))
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    private static string? GetAttributeArgumentValue(AttributeSyntax attribute)
-    {
-        if (attribute.ArgumentList is null || attribute.ArgumentList.Arguments.Any() == false)
-        {
-            return null;
-        }
-
-        return attribute.ArgumentList.Arguments.Single().Expression switch
-        {
-            LiteralExpressionSyntax literal => GetLiteralExpressionValue(literal),
-            InvocationExpressionSyntax invocation => invocation.ArgumentList.Arguments.Single().Expression.GetText().ToString(),
-            MemberAccessExpressionSyntax member => member.Parent?.ToString(),
+            IdentifierNameSyntax identifierName => identifierName.Identifier,
+            QualifiedNameSyntax qualifiedNameSyntax => qualifiedNameSyntax.Right.Identifier,
             _ => null
         };
-    }
 
-    private static string? GetLiteralExpressionValue(LiteralExpressionSyntax literal)
-    {
-        if (literal.Token.IsKind(SyntaxKind.DefaultKeyword))
+        if (propertyTypeIdentifier is null)
         {
-            return null;
+            return false;
         }
 
-        return literal.Token.IsKind(SyntaxKind.StringLiteralToken) ? literal.Token.ValueText : literal.Token.Text;
+        return propertyTypeIdentifier.Value.IsKind(SyntaxKind.IdentifierToken) &&
+               (parameter.IsKind(SyntaxKind.InvocationExpression) ||
+                parameter.IsKind(SyntaxKind.SimpleMemberAccessExpression));
     }
 }
diff --git a/src/UnityUxmlGenerator/System.Runtime.CompilerServices/IsExternalInit.cs b/src/UnityUxmlGenerator/System.Runtime.CompilerServices/IsExternalInit.cs
@@ -0,0 +1,11 @@
+﻿using System.ComponentModel;
+
+// ReSharper disable CheckNamespace
+// ReSharper disable UnusedType.Global
+
+namespace System.Runtime.CompilerServices;
+
+[EditorBrowsable(EditorBrowsableState.Never)]
+internal static class IsExternalInit
+{
+}
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.Attributes.cs b/src/UnityUxmlGenerator/UxmlGenerator.Attributes.cs
@@ -23,11 +23,11 @@ private static SourceText GenerateUxmlAttributeAttribute()
     }
 
     private static SourceText GenerateAttributeClass(string attributeClassIdentifier,
-        MemberDeclarationSyntax[]? members = null)
+        IEnumerable<MemberDeclarationSyntax>? members = null)
     {
         return CompilationUnitWidget(
                 namespaceIdentifier: AssemblyName.Name,
-                members: ClassWidget(
+                member: ClassWidget(
                     identifier: attributeClassIdentifier,
                     modifiers: new[] { SyntaxKind.InternalKeyword, SyntaxKind.SealedKeyword },
                     baseType: SimpleBaseType(IdentifierName(AttributeBaseType)),
@@ -37,7 +37,7 @@ private static SourceText GenerateAttributeClass(string attributeClassIdentifier
             .GetText(Encoding.UTF8);
     }
 
-    private static MemberDeclarationSyntax[] GetUxmlAttributeMembers()
+    private static IEnumerable<MemberDeclarationSyntax> GetUxmlAttributeMembers()
     {
         return new MemberDeclarationSyntax[]
         {
@@ -48,7 +48,7 @@ private static MemberDeclarationSyntax[] GetUxmlAttributeMembers()
                     identifier: "defaultValue",
                     type: NullableType(PredefinedType(Token(SyntaxKind.ObjectKeyword))),
                     addDefaultKeyword: true),
-                bodyStatements: AssignmentStatementWidget(
+                bodyStatement: AssignmentStatementWidget(
                     left: IdentifierName("DefaultValue"),
                     right: IdentifierName("defaultValue")),
                 addGeneratedCodeAttributes: true
@@ -57,7 +57,7 @@ private static MemberDeclarationSyntax[] GetUxmlAttributeMembers()
                 identifier: "DefaultValue",
                 type: NullableType(PredefinedType(Token(SyntaxKind.ObjectKeyword))),
                 modifier: SyntaxKind.PublicKeyword,
-                accessors: SyntaxKind.GetAccessorDeclaration,
+                accessor: SyntaxKind.GetAccessorDeclaration,
                 addGeneratedCodeAttributes: true
             )
         };
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.Factory.cs b/src/UnityUxmlGenerator/UxmlGenerator.Factory.cs
@@ -13,7 +13,7 @@ private static SourceText GenerateUxmlFactory(UxmlFactoryCapture capture)
     {
         return CompilationUnitWidget(
                 namespaceIdentifier: capture.ClassNamespace,
-                members: ClassWidget(
+                member: ClassWidget(
                     identifier: capture.ClassName,
                     modifier: SyntaxKind.PartialKeyword,
                     member: ClassWidget(
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.Traits.cs b/src/UnityUxmlGenerator/UxmlGenerator.Traits.cs
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.Widgets.cs b/src/UnityUxmlGenerator/UxmlGenerator.Widgets.cs
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.cs b/src/UnityUxmlGenerator/UxmlGenerator.cs

Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,12 @@ namespace UnityUxmlGenerator.Captures;`
`4`	`4`
`5`	`5`	`internal sealed class UxmlFactoryCapture : BaseCapture`
`6`	`6`	`{`
`7`		`- public UxmlFactoryCapture(ClassDeclarationSyntax @class) : base(@class)`
	`7`	`+ public UxmlFactoryCapture(ClassDeclarationSyntax @class, AttributeSyntax attribute) : base(@class)`
`8`	`8`	`{`
	`9`	`+ Attribute = attribute;`
`9`	`10`	`}`
`10`	`11`
`11`	`12`	`public override string ClassTag => "UxmlFactory";`
	`13`	`+`
	`14`	`+ public AttributeSyntax Attribute { get; }`
`12`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,13 @@ internal sealed class UxmlTraitsCapture : BaseCapture`
`7`	`7`	`public UxmlTraitsCapture(ClassDeclarationSyntax @class, TypeSyntax baseClassType) : base(@class)`
`8`	`8`	`{`
`9`	`9`	`BaseClassType = baseClassType;`
`10`		`- Properties = new List<(PropertyDeclarationSyntax property, string? DefaultValue)>();`
	`10`	`+ Properties = new List<(PropertyDeclarationSyntax, AttributeSyntax)>();`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`public override string ClassTag => "UxmlTraits";`
`14`	`14`
`15`	`15`	`public TypeSyntax BaseClassType { get; }`
`16`		`- public List<(PropertyDeclarationSyntax property, string? DefaultValue)> Properties { get; }`
	`16`	`+ public List<(PropertyDeclarationSyntax Property, AttributeSyntax Attribute)> Properties { get; }`
`17`	`17`
`18`	`18`	`public string GetBaseClassName(out TypeSyntax? genericTypeSyntax)`
`19`	`19`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace UnityUxmlGenerator.Diagnostics;`
`4`	`4`
`5`	`5`	`internal static class DiagnosticExtensions`
`6`	`6`	`{`
`7`		`- public static Diagnostic CreateDiagnostic(this DiagnosticDescriptor descriptor, Location location, params object[] args)`
	`7`	`+ public static Diagnostic CreateDiagnostic(this DiagnosticDescriptor descriptor, Location location, params object?[]? args)`
`8`	`8`	`{`
`9`	`9`	`return Diagnostic.Create(descriptor, location, args);`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,10 @@ namespace UnityUxmlGenerator.Structs;`
`4`	`4`
`5`	`5`	`public ref struct UxmlAttributeInfo`
`6`	`6`	`{`
	`7`	`+ public string PropertyName { get; init; }`
	`8`	`+ public string PrivateFieldName { get; init; }`
	`9`	`+ public string AttributeUxmlName { get; init; }`
	`10`	`+`
`7`	`11`	`public string TypeIdentifier { get; set; }`
`8`		`- public string PrivateFieldName { get; set; }`
`9`		`- public string AttributeUxmlName { get; set; }`
`10`	`12`	`public ExpressionSyntax DefaultValueAssignmentExpression { get; set; }`
`11`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal abstract class BaseReceiver : ISyntaxReceiver`
`12`	`12`	`public abstract void OnVisitSyntaxNode(SyntaxNode syntaxNode);`
`13`	`13`
`14`	`14`	`protected void RegisterDiagnostic(DiagnosticDescriptor diagnosticDescriptor, Location location,`
`15`		`- params object[] args)`
	`15`	`+ params object?[]? args)`
`16`	`16`	`{`
`17`	`17`	`_diagnostics.Add(diagnosticDescriptor.CreateDiagnostic(location, args));`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,19 +15,16 @@ internal sealed class UxmlFactoryReceiver : BaseReceiver`
`15`	`15`
`16`	`16`	`public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`17`	`17`	`{`
`18`		`- if (syntaxNode is not AttributeSyntax`
`19`		`- {`
`20`		`- Name: IdentifierNameSyntax { Identifier.Text: AttributeName }`
`21`		`- } attribute)`
	`18`	`+ if (syntaxNode.IsAttributeWithName(AttributeName, out var attribute) == false)`
`22`	`19`	`{`
`23`	`20`	`return;`
`24`	`21`	`}`
`25`	`22`
`26`		`- var @class = attribute.GetParent<ClassDeclarationSyntax>();`
	`23`	`+ var @class = attribute!.GetParent<ClassDeclarationSyntax>();`
`27`	`24`
`28`	`25`	`if (@class.InheritsFromAnyType())`
`29`	`26`	`{`
`30`		`- _captures.Add(new UxmlFactoryCapture(@class!));`
	`27`	`+ _captures.Add(new UxmlFactoryCapture(@class!, attribute!));`
`31`	`28`	`}`
`32`	`29`	`else if (@class is not null)`
`33`	`30`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,23 +16,20 @@ internal sealed class UxmlTraitsReceiver : BaseReceiver`
`16`	`16`
`17`	`17`	`public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`18`	`18`	`{`
`19`		`- if (syntaxNode is not AttributeSyntax`
`20`		`- {`
`21`		`- Name: IdentifierNameSyntax { Identifier.Text: AttributeName }`
`22`		`- } attribute)`
	`19`	`+ if (syntaxNode.IsAttributeWithName(AttributeName, out var attribute) == false)`
`23`	`20`	`{`
`24`	`21`	`return;`
`25`	`22`	`}`
`26`	`23`
`27`		`- var property = attribute.GetParent<PropertyDeclarationSyntax>();`
	`24`	`+ var property = attribute!.GetParent<PropertyDeclarationSyntax>();`
`28`	`25`	`if (property is null)`
`29`	`26`	`{`
`30`	`27`	`return;`
`31`	`28`	`}`
`32`	`29`
`33`		`- if (attribute.ArgumentList is not null && attribute.ArgumentList.Arguments.Any())`
	`30`	`+ if (attribute!.ArgumentList is not null && attribute.ArgumentList.Arguments.Any())`
`34`	`31`	`{`
`35`		`- if (HasSameType(property, attribute) == false)`
	`32`	`+ if (HasSameType(property, attribute.ArgumentList.Arguments.First()) == false)`
`36`	`33`	`{`
`37`	`34`	`RegisterDiagnostic(PropertyAndDefaultValueTypesMismatchError, property.GetLocation(),`
`38`	`35`	`property.GetName());`
`@@ -61,12 +58,12 @@ public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`61`	`58`	`_captures.Add(uxmlTraits.ClassName, uxmlTraits);`
`62`	`59`	`}`
`63`	`60`
`64`		`- uxmlTraits.Properties.Add((property, GetAttributeArgumentValue(attribute)));`
	`61`	`+ uxmlTraits.Properties.Add((property, attribute));`
`65`	`62`	`}`
`66`	`63`
`67`		`- private static bool HasSameType(BasePropertyDeclarationSyntax property, AttributeSyntax attribute)`
	`64`	`+ private static bool HasSameType(BasePropertyDeclarationSyntax property, AttributeArgumentSyntax attributeArgument)`
`68`	`65`	`{`
`69`		`- var parameter = attribute.ArgumentList!.Arguments.First().Expression;`
	`66`	`+ var parameter = attributeArgument.Expression;`
`70`	`67`
`71`	`68`	`if (parameter.IsKind(SyntaxKind.DefaultLiteralExpression))`
`72`	`69`	`{`
`@@ -95,42 +92,20 @@ private static bool HasSameType(BasePropertyDeclarationSyntax property, Attribut`
`95`	`92`	`}`
`96`	`93`	`}`
`97`	`94`
`98`		`- if (property.Type is IdentifierNameSyntax identifierName)`
	`95`	`+ SyntaxToken? propertyTypeIdentifier = property.Type switch`
`99`	`96`	`{`
`100`		`- if (identifierName.Identifier.IsKind(SyntaxKind.IdentifierToken) &&`
`101`		`- (parameter.IsKind(SyntaxKind.InvocationExpression) \|\|`
`102`		`- parameter.IsKind(SyntaxKind.SimpleMemberAccessExpression)))`
`103`		`- {`
`104`		`- return true;`
`105`		`- }`
`106`		`- }`
`107`		`-`
`108`		`- return false;`
`109`		`- }`
`110`		`-`
`111`		`- private static string? GetAttributeArgumentValue(AttributeSyntax attribute)`
`112`		`- {`
`113`		`- if (attribute.ArgumentList is null \|\| attribute.ArgumentList.Arguments.Any() == false)`
`114`		`- {`
`115`		`- return null;`
`116`		`- }`
`117`		`-`
`118`		`- return attribute.ArgumentList.Arguments.Single().Expression switch`
`119`		`- {`
`120`		`- LiteralExpressionSyntax literal => GetLiteralExpressionValue(literal),`
`121`		`- InvocationExpressionSyntax invocation => invocation.ArgumentList.Arguments.Single().Expression.GetText().ToString(),`
`122`		`- MemberAccessExpressionSyntax member => member.Parent?.ToString(),`
	`97`	`+ IdentifierNameSyntax identifierName => identifierName.Identifier,`
	`98`	`+ QualifiedNameSyntax qualifiedNameSyntax => qualifiedNameSyntax.Right.Identifier,`
`123`	`99`	`_ => null`
`124`	`100`	`};`
`125`		`- }`
`126`	`101`
`127`		`- private static string? GetLiteralExpressionValue(LiteralExpressionSyntax literal)`
`128`		`- {`
`129`		`- if (literal.Token.IsKind(SyntaxKind.DefaultKeyword))`
	`102`	`+ if (propertyTypeIdentifier is null)`
`130`	`103`	`{`
`131`		`- return null;`
	`104`	`+ return false;`
`132`	`105`	`}`
`133`	`106`
`134`		`- return literal.Token.IsKind(SyntaxKind.StringLiteralToken) ? literal.Token.ValueText : literal.Token.Text;`
	`107`	`+ return propertyTypeIdentifier.Value.IsKind(SyntaxKind.IdentifierToken) &&`
	`108`	`+ (parameter.IsKind(SyntaxKind.InvocationExpression) \|\|`
	`109`	`+ parameter.IsKind(SyntaxKind.SimpleMemberAccessExpression));`
`135`	`110`	`}`
`136`	`111`	`}`