serv5 (space-wizards#6496)

* Add source generator for DataDefinition validation

* Add source generator for reading

* Add source generator for writing

* Include prototypes and other meansdatadefinition types

* Target ISerializationGenerated in data definitions

* Murder

* Use array, struct, enum methods

* Source generate get field definitions

* serv5

* Fix and pray

* Fix release compile

* Tayrtahn review

* a

* Generator bugfix

---------

Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>

Author: DrSmugleaf

Robust.Analyzers.Tests/DataDefinitionAnalyzerTest.cs

@@ -94,29 +94,6 @@ await Verifier(code,
         );
     }
 
-    [Test]
-    public async Task ReadOnlyFieldTest()
-    {
-        const string code = """
-            using Robust.Shared.Serialization.Manager.Attributes;
-
-            [DataDefinition]
-            public sealed partial class Foo
-            {
-                [DataField]
-                public readonly int Bad;
-
-                [DataField]
-                public int Good;
-            }
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(7,12): error RA0019: Data field Bad in data definition Foo is readonly
-            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldWritableRule).WithSpan(7, 12, 7, 20).WithArguments("Bad", "Foo")
-        );
-    }
-
     [Test]
     public async Task PartialDataDefinitionTest()
     {

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -1,11 +1,13 @@
 #nullable enable
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Robust.Roslyn.Shared;
+using Robust.Roslyn.Shared.Helpers;
 using Robust.Shared.Serialization.Manager.Definition;
 using Robust.Shared.ViewVariables;
 
@@ -14,9 +16,6 @@ namespace Robust.Analyzers;
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
 {
-    private const string DataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataDefinitionAttribute";
-    private const string ImplicitDataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.ImplicitDataDefinitionForInheritorsAttribute";
-    private const string MeansDataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.MeansDataDefinitionAttribute";
     private const string DataFieldBaseNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataFieldBaseAttribute";
     private const string ViewVariablesNamespace = "Robust.Shared.ViewVariables.ViewVariablesAttribute";
     private const string NotYamlSerializableName = "Robust.Shared.Serialization.Manager.Attributes.NotYamlSerializableAttribute";
@@ -43,16 +42,6 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to mark any type containing a nested data definition as partial."
     );
 
-    public static readonly DiagnosticDescriptor DataFieldWritableRule = new(
-        Diagnostics.IdDataFieldWritable,
-        "Data field must not be readonly",
-        "Data field {0} in data definition {1} is readonly",
-        "Usage",
-        DiagnosticSeverity.Error,
-        true,
-        "Make sure to remove the readonly modifier."
-    );
-
     public static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
         Diagnostics.IdDataFieldPropertyWritable,
         "Data field property must have a setter",
@@ -93,9 +82,24 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to use a type that is YAML serializable."
     );
 
+    public static readonly DiagnosticDescriptor DataFieldOutsideDefinition = new(
+        Diagnostics.IdDataFieldOutsideDefinition,
+        "Data field defined in a type that is not marked as a data definition or data record",
+        "Data field {0} is defined in type {1} which is not a data definition or data record",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true,
+        "Make sure to add a data definition or data record attribute, or inherit a type or add an attribute that implicitly makes its inheritors data definitions or data records."
+    );
+
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
-        DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule,
-        DataFieldRedundantTagRule, DataFieldNoVVReadWriteRule, DataFieldYamlSerializableRule
+        DataDefinitionPartialRule,
+        NestedDataDefinitionPartialRule,
+        DataFieldPropertyWritableRule,
+        DataFieldRedundantTagRule,
+        DataFieldNoVVReadWriteRule,
+        DataFieldYamlSerializableRule,
+        DataFieldOutsideDefinition
     );
 
     public override void Initialize(AnalysisContext context)
@@ -108,6 +112,9 @@ public override void Initialize(AnalysisContext context)
             if (symbolContext.Symbol is not INamedTypeSymbol typeSymbol)
                 return;
 
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataField, SyntaxKind.FieldDeclaration);
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataFieldProperty, SyntaxKind.PropertyDeclaration);
+
             if (!IsDataDefinition(typeSymbol))
                 return;
 
@@ -116,9 +123,6 @@ public override void Initialize(AnalysisContext context)
             symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordDeclaration);
             symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordStructDeclaration);
             symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.InterfaceDeclaration);
-
-            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataField, SyntaxKind.FieldDeclaration);
-            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataFieldProperty, SyntaxKind.PropertyDeclaration);
         }, SymbolKind.NamedType);
     }
 
@@ -156,20 +160,21 @@ private static void AnalyzeDataField(SyntaxNodeAnalysisContext context)
         if (context.ContainingSymbol?.ContainingType is not INamedTypeSymbol type)
             return;
 
+        var isDataDefinition = DataDefinitionHelper.IsDataDefinition(type, out var isDataRecord);
         foreach (var variable in field.Declaration.Variables)
         {
             var fieldSymbol = context.SemanticModel.GetDeclaredSymbol(variable);
 
             if (fieldSymbol == null)
                 continue;
 
-            if (!IsDataField(fieldSymbol, out _, out var datafieldAttribute))
+            if (!DataDefinitionHelper.IsDataField(fieldSymbol, isDataRecord, out _, out var datafieldAttribute))
                 continue;
 
-            if (IsReadOnlyDataField(type, fieldSymbol))
+            if (!isDataDefinition)
             {
-                TryGetModifierLocation(field, SyntaxKind.ReadOnlyKeyword, out var location);
-                context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, location, fieldSymbol.Name, type.Name));
+                var location = type.DeclaringSyntaxReferences[0].GetSyntax().GetLocation();
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldOutsideDefinition, location, fieldSymbol.Name, type.Name));
             }
 
             if (HasRedundantTag(fieldSymbol, datafieldAttribute))
@@ -212,19 +217,30 @@ private static void AnalyzeDataFieldProperty(SyntaxNodeAnalysisContext context)
         if (propertySymbol.ContainingType is not INamedTypeSymbol type)
             return;
 
-        if (type.IsRecord || type.IsValueType)
+        if (propertySymbol == null)
             return;
 
-        if (propertySymbol == null)
+        var isDataDefinition = DataDefinitionHelper.IsDataDefinition(type, out var isDataRecord);
+        if (isDataDefinition &&
+            !isDataRecord &&
+            propertySymbol.SetMethod == null &&
+            HasDataFieldAttribute(propertySymbol))
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                DataFieldPropertyWritableRule,
+                property.AccessorList?.GetLocation() ?? property.GetLocation(),
+                propertySymbol.Name,
+                type.Name));
             return;
+        }
 
-        if (!IsDataField(propertySymbol, out _, out var datafieldAttribute))
+        if (!DataDefinitionHelper.IsDataField(propertySymbol, isDataRecord, out _, out var datafieldAttribute))
             return;
 
-        if (IsReadOnlyDataField(type, propertySymbol))
+        if (!isDataDefinition)
         {
-            var location = property.AccessorList != null ? property.AccessorList.GetLocation() : property.GetLocation();
-            context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, location, propertySymbol.Name, type.Name));
+            var location = type.DeclaringSyntaxReferences[0].GetSyntax().GetLocation();
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldOutsideDefinition, location, propertySymbol.Name, type.Name));
         }
 
         if (HasRedundantTag(propertySymbol, datafieldAttribute))
@@ -255,9 +271,16 @@ private static void AnalyzeDataFieldProperty(SyntaxNodeAnalysisContext context)
         }
     }
 
-    private static bool IsReadOnlyDataField(ITypeSymbol type, ISymbol field)
+    private static bool HasDataFieldAttribute(ISymbol symbol)
     {
-        return IsReadOnlyMember(type, field);
+        foreach (var attribute in symbol.GetAttributes())
+        {
+            if (attribute.AttributeClass is { } attributeClass &&
+                TypeSymbolHelper.Inherits(attributeClass, DataFieldBaseNamespace))
+                return true;
+        }
+
+        return false;
     }
 
     private static bool IsPartial(TypeDeclarationSyntax type)
@@ -270,53 +293,7 @@ private static bool IsDataDefinition(ITypeSymbol? type)
         if (type == null)
             return false;
 
-        return HasAttribute(type, DataDefinitionNamespace) ||
-               MeansDataDefinition(type) ||
-               IsImplicitDataDefinition(type);
-    }
-
-    private static bool IsDataField(ISymbol member, out ITypeSymbol type, out AttributeData attribute)
-    {
-        // TODO data records and other attributes
-        if (member is IFieldSymbol field)
-        {
-            foreach (var attr in field.GetAttributes())
-            {
-                if (attr.AttributeClass != null && Inherits(attr.AttributeClass, DataFieldBaseNamespace))
-                {
-                    type = field.Type;
-                    attribute = attr;
-                    return true;
-                }
-            }
-        }
-        else if (member is IPropertySymbol property)
-        {
-            foreach (var attr in property.GetAttributes())
-            {
-                if (attr.AttributeClass != null && Inherits(attr.AttributeClass, DataFieldBaseNamespace))
-                {
-                    type = property.Type;
-                    attribute = attr;
-                    return true;
-                }
-            }
-        }
-
-        type = null!;
-        attribute = null!;
-        return false;
-    }
-
-    private static bool Inherits(ITypeSymbol type, string parent)
-    {
-        foreach (var baseType in GetBaseTypes(type))
-        {
-            if (baseType.ToDisplayString() == parent)
-                return true;
-        }
-
-        return false;
+        return DataDefinitionHelper.IsDataDefinition(type, out _);
     }
 
     private static bool TryGetAttributeLocation(MemberDeclarationSyntax syntax, string attributeName, out Location location)
@@ -382,14 +359,14 @@ private static bool HasAttribute(ITypeSymbol type, string attributeName)
         return false;
     }
 
-    private static bool HasRedundantTag(ISymbol symbol, AttributeData datafieldAttribute)
+    private static bool HasRedundantTag(ISymbol symbol, DataFieldAttribute datafieldAttribute)
     {
         // No args, no problem
-        if (datafieldAttribute.ConstructorArguments.Length == 0)
+        if (datafieldAttribute.Data is not { ConstructorArguments.Length: > 0 })
             return false;
 
         // If a tag is explicitly specified, it will be the first argument...
-        var tagArgument = datafieldAttribute.ConstructorArguments[0];
+        var tagArgument = datafieldAttribute.Data.ConstructorArguments[0];
         // ...but the first arg could also something else, since tag is optional
         // so we make sure that it's a string
         if (tagArgument.Value is not string explicitName)
@@ -427,65 +404,8 @@ private static bool HasVVReadWrite(ISymbol symbol)
         return (VVAccess)accessByte == VVAccess.ReadWrite;
     }
 
-    private static bool MeansDataDefinition(ITypeSymbol type)
-    {
-        foreach (var attribute in type.GetAttributes())
-        {
-            if (attribute.AttributeClass is null)
-                continue;
-
-            if (HasAttribute(attribute.AttributeClass, MeansDataDefinitionNamespace))
-                return true;
-        }
-        return false;
-    }
-    
     private static bool IsNotYamlSerializable(ISymbol field, ITypeSymbol type)
     {
         return HasAttribute(type, NotYamlSerializableName);
     }
-
-    private static bool IsImplicitDataDefinition(ITypeSymbol type)
-    {
-        if (HasAttribute(type, ImplicitDataDefinitionNamespace))
-            return true;
-
-        foreach (var baseType in GetBaseTypes(type))
-        {
-            if (HasAttribute(baseType, ImplicitDataDefinitionNamespace))
-                return true;
-        }
-
-        foreach (var @interface in type.AllInterfaces)
-        {
-            if (IsImplicitDataDefinitionInterface(@interface))
-                return true;
-        }
-
-        return false;
-    }
-
-    private static bool IsImplicitDataDefinitionInterface(ITypeSymbol @interface)
-    {
-        if (HasAttribute(@interface, ImplicitDataDefinitionNamespace))
-            return true;
-
-        foreach (var subInterface in @interface.AllInterfaces)
-        {
-            if (HasAttribute(subInterface, ImplicitDataDefinitionNamespace))
-                return true;
-        }
-
-        return false;
-    }
-
-    private static IEnumerable<ITypeSymbol> GetBaseTypes(ITypeSymbol type)
-    {
-        var baseType = type.BaseType;
-        while (baseType != null)
-        {
-            yield return baseType;
-            baseType = baseType.BaseType;
-        }
-    }
 }

Robust.Analyzers/DataDefinitionFixer.cs

@@ -18,7 +18,7 @@ public sealed class DefinitionFixer : CodeFixProvider
     private const string ViewVariablesAttributeName = "ViewVariables";
 
     public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
-        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable,
+        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldPropertyWritable,
         IdDataFieldRedundantTag, IdDataFieldNoVVReadWrite
     );
 
@@ -32,8 +32,6 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
                     return RegisterPartialTypeFix(context, diagnostic);
                 case IdNestedDataDefinitionPartial:
                     return RegisterPartialTypeFix(context, diagnostic);
-                case IdDataFieldWritable:
-                    return RegisterDataFieldFix(context, diagnostic);
                 case IdDataFieldPropertyWritable:
                     return RegisterDataFieldPropertyFix(context, diagnostic);
                 case IdDataFieldRedundantTag:
@@ -182,22 +180,6 @@ private static async Task<Document> RemoveVVAttribute(Document document, MemberD
         return document.WithSyntaxRoot(root);
     }
 
-    private static async Task RegisterDataFieldFix(CodeFixContext context, Diagnostic diagnostic)
-    {
-        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
-        var span = diagnostic.Location.SourceSpan;
-        var field = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<FieldDeclarationSyntax>().FirstOrDefault();
-
-        if (field == null)
-            return;
-
-        context.RegisterCodeFix(CodeAction.Create(
-            "Make data field writable",
-            c => MakeFieldWritable(context.Document, field, c),
-            "Make data field writable"
-        ), diagnostic);
-    }
-
     private static async Task RegisterDataFieldPropertyFix(CodeFixContext context, Diagnostic diagnostic)
     {
         var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
@@ -214,17 +196,6 @@ private static async Task RegisterDataFieldPropertyFix(CodeFixContext context, D
         ), diagnostic);
     }
 
-    private static async Task<Document> MakeFieldWritable(Document document, FieldDeclarationSyntax declaration, CancellationToken cancellation)
-    {
-        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
-        var token = declaration.Modifiers.First(t => t.IsKind(ReadOnlyKeyword));
-        var newDeclaration = declaration.WithModifiers(declaration.Modifiers.Remove(token));
-
-        root = root!.ReplaceNode(declaration, newDeclaration);
-
-        return document.WithSyntaxRoot(root);
-    }
-
     private static async Task<Document> MakePropertyWritable(Document document, PropertyDeclarationSyntax declaration, CancellationToken cancellation)
     {
         var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);