Add diagnostics. Fix default keyword issue.

ChebanovDD · ChebanovDD · commit 817a0ea0c040 · 2023-05-20T12:18:39.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/Diagnostics/DiagnosticDescriptors.cs b/src/UnityUxmlGenerator/Diagnostics/DiagnosticDescriptors.cs
@@ -0,0 +1,30 @@
+﻿using Microsoft.CodeAnalysis;
+
+namespace UnityUxmlGenerator.Diagnostics;
+
+internal static class DiagnosticDescriptors
+{
+    public static readonly DiagnosticDescriptor ClassHasNoBaseClassError = new(
+        id: "UXMLG001",
+        title: "Class has no base class",
+        messageFormat: "Class '{0}' must be declared as a partial and be inherited from 'VisualElement' or one of its derived classes.",
+        category: typeof(UxmlGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
+    public static readonly DiagnosticDescriptor ClassDoesNotInheritFromVisualElementError = new(
+        id: "UXMLG002",
+        title: "Class does not inherit from VisualElement",
+        messageFormat: "Class '{0}' must be declared as a partial and be inherited from 'VisualElement' or one of its derived classes.",
+        category: typeof(UxmlGenerator).FullName,
+        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);
+}
diff --git a/src/UnityUxmlGenerator/Diagnostics/DiagnosticExtensions.cs b/src/UnityUxmlGenerator/Diagnostics/DiagnosticExtensions.cs
@@ -0,0 +1,11 @@
+﻿using Microsoft.CodeAnalysis;
+
+namespace UnityUxmlGenerator.Diagnostics;
+
+internal static class DiagnosticExtensions
+{
+    public static Diagnostic CreateDiagnostic(this DiagnosticDescriptor descriptor, Location location, params object[] args)
+    {
+        return Diagnostic.Create(descriptor, location, args);
+    }
+}
diff --git a/src/UnityUxmlGenerator/Extensions/BaseTypeDeclarationSyntaxExtensions.cs b/src/UnityUxmlGenerator/Extensions/BaseTypeDeclarationSyntaxExtensions.cs
@@ -6,6 +6,11 @@ namespace UnityUxmlGenerator.Extensions;
 
 internal static class BaseTypeDeclarationSyntaxExtensions
 {
+    public static bool InheritsFromAnyType(this BaseTypeDeclarationSyntax? @class)
+    {
+        return @class?.BaseList is not null && @class.BaseList.Types.Count != 0;
+    }
+
     public static bool InheritsFromFullyQualifiedName(this BaseTypeDeclarationSyntax @class,
         GeneratorExecutionContext context, string name)
     {
diff --git a/src/UnityUxmlGenerator/SyntaxReceivers/BaseReceiver.cs b/src/UnityUxmlGenerator/SyntaxReceivers/BaseReceiver.cs
@@ -0,0 +1,19 @@
+﻿using Microsoft.CodeAnalysis;
+using UnityUxmlGenerator.Diagnostics;
+
+namespace UnityUxmlGenerator.SyntaxReceivers;
+
+internal abstract class BaseReceiver : ISyntaxReceiver
+{
+    private readonly List<Diagnostic> _diagnostics = new();
+
+    public IEnumerable<Diagnostic> Diagnostics => _diagnostics;
+
+    public abstract void OnVisitSyntaxNode(SyntaxNode syntaxNode);
+
+    protected void RegisterDiagnostic(DiagnosticDescriptor diagnosticDescriptor, Location location,
+        params object[] args)
+    {
+        _diagnostics.Add(diagnosticDescriptor.CreateDiagnostic(location, args));
+    }
+}
diff --git a/src/UnityUxmlGenerator/SyntaxReceivers/UxmlFactoryReceiver.cs b/src/UnityUxmlGenerator/SyntaxReceivers/UxmlFactoryReceiver.cs
@@ -5,15 +5,15 @@
 
 namespace UnityUxmlGenerator.SyntaxReceivers;
 
-internal sealed class UxmlFactoryReceiver : ISyntaxReceiver
+internal sealed class UxmlFactoryReceiver : BaseReceiver
 {
     private const string AttributeName = "UxmlElement";
 
     private readonly List<UxmlFactoryCapture> _captures = new();
 
     public IEnumerable<UxmlFactoryCapture> Captures => _captures;
 
-    public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+    public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)
     {
         if (syntaxNode is not AttributeSyntax
             {
@@ -25,11 +25,13 @@ public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
 
         var @class = attribute.GetParent<ClassDeclarationSyntax>();
 
-        if (@class?.BaseList is null || @class.BaseList.Types.Count == 0)
+        if (@class.InheritsFromAnyType())
         {
-            return;
+            _captures.Add(new UxmlFactoryCapture(@class!));
+        }
+        else if (@class is not null)
+        {
+            RegisterDiagnostic(ClassHasNoBaseClassError, @class.GetLocation(), @class.Identifier.Text);
         }
-
-        _captures.Add(new UxmlFactoryCapture(@class));
     }
 }
diff --git a/src/UnityUxmlGenerator/SyntaxReceivers/UxmlTraitsReceiver.cs b/src/UnityUxmlGenerator/SyntaxReceivers/UxmlTraitsReceiver.cs
@@ -6,15 +6,15 @@
 
 namespace UnityUxmlGenerator.SyntaxReceivers;
 
-internal sealed class UxmlTraitsReceiver : ISyntaxReceiver
+internal sealed class UxmlTraitsReceiver : BaseReceiver
 {
     private const string AttributeName = "UxmlAttribute";
 
     private readonly Dictionary<string, UxmlTraitsCapture> _captures = new();
 
     public IReadOnlyDictionary<string, UxmlTraitsCapture> Captures => _captures;
 
-    public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+    public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)
     {
         if (syntaxNode is not AttributeSyntax
             {
@@ -34,19 +34,30 @@ public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
         {
             if (HasSameType(property, attribute) == false)
             {
+                RegisterDiagnostic(PropertyAndDefaultValueTypesMismatchError, property.GetLocation(),
+                    property.GetName());
                 return;
             }
         }
 
         var @class = property.GetParent<ClassDeclarationSyntax>();
-        if (@class?.BaseList is null || @class.BaseList.Types.Count == 0)
+        if (@class.InheritsFromAnyType() == false)
         {
+            if (@class is null)
+            {
+                RegisterDiagnostic(ClassHasNoBaseClassError, property.GetLocation());
+            }
+            else
+            {
+                RegisterDiagnostic(ClassHasNoBaseClassError, @class.GetLocation(), @class.Identifier.Text);
+            }
+
             return;
         }
 
-        if (_captures.TryGetValue(@class.Identifier.Text, out var uxmlTraits) == false)
+        if (_captures.TryGetValue(@class!.Identifier.Text, out var uxmlTraits) == false)
         {
-            uxmlTraits = new UxmlTraitsCapture(@class, @class.BaseList.Types.First().Type);
+            uxmlTraits = new UxmlTraitsCapture(@class, @class.BaseList!.Types.First().Type);
             _captures.Add(@class.Identifier.Text, uxmlTraits);
         }
 
@@ -57,6 +68,11 @@ private static bool HasSameType(BasePropertyDeclarationSyntax property, Attribut
     {
         var parameter = attribute.ArgumentList!.Arguments.First().Expression;
 
+        if (parameter.IsKind(SyntaxKind.DefaultLiteralExpression))
+        {
+            return true;
+        }
+
         if (property.Type is PredefinedTypeSyntax predefinedType)
         {
             if (predefinedType.IsBoolType() &&
@@ -94,14 +110,27 @@ private static bool HasSameType(BasePropertyDeclarationSyntax property, Attribut
 
     private static string? GetAttributeArgumentValue(AttributeSyntax attribute)
     {
-        return attribute.ArgumentList?.Arguments.Single().Expression switch
+        if (attribute.ArgumentList is null || attribute.ArgumentList.Arguments.Any() == false)
         {
-            LiteralExpressionSyntax literal => literal.Token.IsKind(SyntaxKind.StringLiteralToken)
-                ? literal.Token.ValueText
-                : literal.Token.Text,
+            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(),
             _ => null
         };
     }
+
+    private static string? GetLiteralExpressionValue(LiteralExpressionSyntax literal)
+    {
+        if (literal.Token.IsKind(SyntaxKind.DefaultKeyword))
+        {
+            return null;
+        }
+
+        return literal.Token.IsKind(SyntaxKind.StringLiteralToken) ? literal.Token.ValueText : literal.Token.Text;
+    }
 }
diff --git a/src/UnityUxmlGenerator/Usings.cs b/src/UnityUxmlGenerator/Usings.cs
@@ -1 +1,2 @@
-﻿global using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+﻿global using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+global using static UnityUxmlGenerator.Diagnostics.DiagnosticDescriptors;
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.Execute.cs b/src/UnityUxmlGenerator/UxmlGenerator.Execute.cs
@@ -33,7 +33,7 @@ private static CompilationUnitSyntax GetCompilationUnit(TypeDeclarationSyntax ty
         // <auto-generated/>
         // #pragma warning disable
         // #nullable enable
-        SyntaxTriviaList syntaxTriviaList = TriviaList(
+        var syntaxTriviaList = TriviaList(
             Comment("// <auto-generated/>"),
             Trivia(PragmaWarningDirectiveTrivia(Token(SyntaxKind.DisableKeyword), true)),
             Trivia(NullableDirectiveTrivia(Token(SyntaxKind.EnableKeyword), true)));
diff --git a/src/UnityUxmlGenerator/UxmlGenerator.cs b/src/UnityUxmlGenerator/UxmlGenerator.cs
@@ -1,4 +1,7 @@
 ﻿using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using UnityUxmlGenerator.Captures;
+using UnityUxmlGenerator.Diagnostics;
 using UnityUxmlGenerator.Extensions;
 using UnityUxmlGenerator.SyntaxReceivers;
 
@@ -30,6 +33,10 @@ public void Execute(GeneratorExecutionContext context)
             {
                 context.AddSource($"{uxmlElement.ClassName}.UxmlFactory.g.cs", GenerateUxmlFactory(uxmlElement));
             }
+            else
+            {
+                ReportClassDoesNotInheritFromVisualElementError(context, uxmlElement.Class);
+            }
         }
 
         foreach (var capture in receiver.UxmlTraitsReceiver.Captures)
@@ -40,6 +47,22 @@ public void Execute(GeneratorExecutionContext context)
             {
                 context.AddSource($"{traitsCapture.ClassName}.UxmlTraits.g.cs", GenerateUxmlTraits(context, traitsCapture));
             }
+            else
+            {
+                ReportClassDoesNotInheritFromVisualElementError(context, traitsCapture.Class);
+            }
+        }
+
+        foreach (var diagnostic in receiver.UxmlTraitsReceiver.Diagnostics)
+        {
+            context.ReportDiagnostic(diagnostic);
         }
     }
+
+    private static void ReportClassDoesNotInheritFromVisualElementError(GeneratorExecutionContext context,
+        BaseTypeDeclarationSyntax @class)
+    {
+        context.ReportDiagnostic(
+            ClassDoesNotInheritFromVisualElementError.CreateDiagnostic(@class.GetLocation(), @class.Identifier.Text));
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,11 @@ namespace UnityUxmlGenerator.Extensions;`
`6`	`6`
`7`	`7`	`internal static class BaseTypeDeclarationSyntaxExtensions`
`8`	`8`	`{`
	`9`	`+ public static bool InheritsFromAnyType(this BaseTypeDeclarationSyntax? @class)`
	`10`	`+ {`
	`11`	`+ return @class?.BaseList is not null && @class.BaseList.Types.Count != 0;`
	`12`	`+ }`
	`13`	`+`
`9`	`14`	`public static bool InheritsFromFullyQualifiedName(this BaseTypeDeclarationSyntax @class,`
`10`	`15`	`GeneratorExecutionContext context, string name)`
`11`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,15 @@`
`5`	`5`
`6`	`6`	`namespace UnityUxmlGenerator.SyntaxReceivers;`
`7`	`7`
`8`		`-internal sealed class UxmlFactoryReceiver : ISyntaxReceiver`
	`8`	`+internal sealed class UxmlFactoryReceiver : BaseReceiver`
`9`	`9`	`{`
`10`	`10`	`private const string AttributeName = "UxmlElement";`
`11`	`11`
`12`	`12`	`private readonly List<UxmlFactoryCapture> _captures = new();`
`13`	`13`
`14`	`14`	`public IEnumerable<UxmlFactoryCapture> Captures => _captures;`
`15`	`15`
`16`		`- public void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
	`16`	`+ public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`17`	`17`	`{`
`18`	`18`	`if (syntaxNode is not AttributeSyntax`
`19`	`19`	`{`
`@@ -25,11 +25,13 @@ public void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`25`	`25`
`26`	`26`	`var @class = attribute.GetParent<ClassDeclarationSyntax>();`
`27`	`27`
`28`		`- if (@class?.BaseList is null \|\| @class.BaseList.Types.Count == 0)`
	`28`	`+ if (@class.InheritsFromAnyType())`
`29`	`29`	`{`
`30`		`- return;`
	`30`	`+ _captures.Add(new UxmlFactoryCapture(@class!));`
	`31`	`+ }`
	`32`	`+ else if (@class is not null)`
	`33`	`+ {`
	`34`	`+ RegisterDiagnostic(ClassHasNoBaseClassError, @class.GetLocation(), @class.Identifier.Text);`
`31`	`35`	`}`
`32`		`-`
`33`		`- _captures.Add(new UxmlFactoryCapture(@class));`
`34`	`36`	`}`
`35`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,15 +6,15 @@`
`6`	`6`
`7`	`7`	`namespace UnityUxmlGenerator.SyntaxReceivers;`
`8`	`8`
`9`		`-internal sealed class UxmlTraitsReceiver : ISyntaxReceiver`
	`9`	`+internal sealed class UxmlTraitsReceiver : BaseReceiver`
`10`	`10`	`{`
`11`	`11`	`private const string AttributeName = "UxmlAttribute";`
`12`	`12`
`13`	`13`	`private readonly Dictionary<string, UxmlTraitsCapture> _captures = new();`
`14`	`14`
`15`	`15`	`public IReadOnlyDictionary<string, UxmlTraitsCapture> Captures => _captures;`
`16`	`16`
`17`		`- public void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
	`17`	`+ public override void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`18`	`18`	`{`
`19`	`19`	`if (syntaxNode is not AttributeSyntax`
`20`	`20`	`{`
`@@ -34,19 +34,30 @@ public void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`34`	`34`	`{`
`35`	`35`	`if (HasSameType(property, attribute) == false)`
`36`	`36`	`{`
	`37`	`+ RegisterDiagnostic(PropertyAndDefaultValueTypesMismatchError, property.GetLocation(),`
	`38`	`+ property.GetName());`
`37`	`39`	`return;`
`38`	`40`	`}`
`39`	`41`	`}`
`40`	`42`
`41`	`43`	`var @class = property.GetParent<ClassDeclarationSyntax>();`
`42`		`- if (@class?.BaseList is null \|\| @class.BaseList.Types.Count == 0)`
	`44`	`+ if (@class.InheritsFromAnyType() == false)`
`43`	`45`	`{`
	`46`	`+ if (@class is null)`
	`47`	`+ {`
	`48`	`+ RegisterDiagnostic(ClassHasNoBaseClassError, property.GetLocation());`
	`49`	`+ }`
	`50`	`+ else`
	`51`	`+ {`
	`52`	`+ RegisterDiagnostic(ClassHasNoBaseClassError, @class.GetLocation(), @class.Identifier.Text);`
	`53`	`+ }`
	`54`	`+`
`44`	`55`	`return;`
`45`	`56`	`}`
`46`	`57`
`47`		`- if (_captures.TryGetValue(@class.Identifier.Text, out var uxmlTraits) == false)`
	`58`	`+ if (_captures.TryGetValue(@class!.Identifier.Text, out var uxmlTraits) == false)`
`48`	`59`	`{`
`49`		`- uxmlTraits = new UxmlTraitsCapture(@class, @class.BaseList.Types.First().Type);`
	`60`	`+ uxmlTraits = new UxmlTraitsCapture(@class, @class.BaseList!.Types.First().Type);`
`50`	`61`	`_captures.Add(@class.Identifier.Text, uxmlTraits);`
`51`	`62`	`}`
`52`	`63`
`@@ -57,6 +68,11 @@ private static bool HasSameType(BasePropertyDeclarationSyntax property, Attribut`
`57`	`68`	`{`
`58`	`69`	`var parameter = attribute.ArgumentList!.Arguments.First().Expression;`
`59`	`70`
	`71`	`+ if (parameter.IsKind(SyntaxKind.DefaultLiteralExpression))`
	`72`	`+ {`
	`73`	`+ return true;`
	`74`	`+ }`
	`75`	`+`
`60`	`76`	`if (property.Type is PredefinedTypeSyntax predefinedType)`
`61`	`77`	`{`
`62`	`78`	`if (predefinedType.IsBoolType() &&`
`@@ -94,14 +110,27 @@ private static bool HasSameType(BasePropertyDeclarationSyntax property, Attribut`
`94`	`110`
`95`	`111`	`private static string? GetAttributeArgumentValue(AttributeSyntax attribute)`
`96`	`112`	`{`
`97`		`- return attribute.ArgumentList?.Arguments.Single().Expression switch`
	`113`	`+ if (attribute.ArgumentList is null \|\| attribute.ArgumentList.Arguments.Any() == false)`
`98`	`114`	`{`
`99`		`- LiteralExpressionSyntax literal => literal.Token.IsKind(SyntaxKind.StringLiteralToken)`
`100`		`- ? literal.Token.ValueText`
`101`		`- : literal.Token.Text,`
	`115`	`+ return null;`
	`116`	`+ }`
	`117`	`+`
	`118`	`+ return attribute.ArgumentList.Arguments.Single().Expression switch`
	`119`	`+ {`
	`120`	`+ LiteralExpressionSyntax literal => GetLiteralExpressionValue(literal),`
`102`	`121`	`InvocationExpressionSyntax invocation => invocation.ArgumentList.Arguments.Single().Expression.GetText().ToString(),`
`103`	`122`	`MemberAccessExpressionSyntax member => member.Parent?.ToString(),`
`104`	`123`	`_ => null`
`105`	`124`	`};`
`106`	`125`	`}`
	`126`	`+`
	`127`	`+ private static string? GetLiteralExpressionValue(LiteralExpressionSyntax literal)`
	`128`	`+ {`
	`129`	`+ if (literal.Token.IsKind(SyntaxKind.DefaultKeyword))`
	`130`	`+ {`
	`131`	`+ return null;`
	`132`	`+ }`
	`133`	`+`
	`134`	`+ return literal.Token.IsKind(SyntaxKind.StringLiteralToken) ? literal.Token.ValueText : literal.Token.Text;`
	`135`	`+ }`
`107`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`		`-global using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;`
	`1`	`+global using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;`
	`2`	`+global using static UnityUxmlGenerator.Diagnostics.DiagnosticDescriptors;`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,7 @@`
`1`	`1`	`using Microsoft.CodeAnalysis;`
	`2`	`+using Microsoft.CodeAnalysis.CSharp.Syntax;`
	`3`	`+using UnityUxmlGenerator.Captures;`
	`4`	`+using UnityUxmlGenerator.Diagnostics;`
`2`	`5`	`using UnityUxmlGenerator.Extensions;`
`3`	`6`	`using UnityUxmlGenerator.SyntaxReceivers;`
`4`	`7`
`@@ -30,6 +33,10 @@ public void Execute(GeneratorExecutionContext context)`
`30`	`33`	`{`
`31`	`34`	`context.AddSource($"{uxmlElement.ClassName}.UxmlFactory.g.cs", GenerateUxmlFactory(uxmlElement));`
`32`	`35`	`}`
	`36`	`+ else`
	`37`	`+ {`
	`38`	`+ ReportClassDoesNotInheritFromVisualElementError(context, uxmlElement.Class);`
	`39`	`+ }`
`33`	`40`	`}`
`34`	`41`
`35`	`42`	`foreach (var capture in receiver.UxmlTraitsReceiver.Captures)`
`@@ -40,6 +47,22 @@ public void Execute(GeneratorExecutionContext context)`
`40`	`47`	`{`
`41`	`48`	`context.AddSource($"{traitsCapture.ClassName}.UxmlTraits.g.cs", GenerateUxmlTraits(context, traitsCapture));`
`42`	`49`	`}`
	`50`	`+ else`
	`51`	`+ {`
	`52`	`+ ReportClassDoesNotInheritFromVisualElementError(context, traitsCapture.Class);`
	`53`	`+ }`
	`54`	`+ }`
	`55`	`+`
	`56`	`+ foreach (var diagnostic in receiver.UxmlTraitsReceiver.Diagnostics)`
	`57`	`+ {`
	`58`	`+ context.ReportDiagnostic(diagnostic);`
`43`	`59`	`}`
`44`	`60`	`}`
	`61`	`+`
	`62`	`+ private static void ReportClassDoesNotInheritFromVisualElementError(GeneratorExecutionContext context,`
	`63`	`+ BaseTypeDeclarationSyntax @class)`
	`64`	`+ {`
	`65`	`+ context.ReportDiagnostic(`
	`66`	`+ ClassDoesNotInheritFromVisualElementError.CreateDiagnostic(@class.GetLocation(), @class.Identifier.Text));`
	`67`	`+ }`
`45`	`68`	`}`