Added some more tests that verify analyzer behavior.

Author: MeltyPlayer

GenerateReadOnly Tests/BinarySchemaTestUtil.cs

@@ -11,6 +11,12 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="NewFolder\**" />
+    <EmbeddedResource Remove="NewFolder\**" />
+    <None Remove="NewFolder\**" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="coverlet.msbuild" Version="6.0.2">
       <PrivateAssets>all</PrivateAssets>

GenerateReadOnly Tests/GenerateReadOnly Tests.csproj

@@ -0,0 +1,37 @@
+using NUnit.Framework;
+
+using readOnly.generator;
+
+namespace readOnly.analyzer;
+
+internal class PartialTests {
+  [Test]
+  public void TestReportsDiagnosticForTypeWithoutPartial() {
+    ReadOnlyGeneratorTestUtil.AssertDiagnostics(
+        """
+        using readOnly;
+
+        namespace foo.bar;
+
+        [GenerateReadOnly]
+        public class Foo;
+        """,
+        Rules.TypeMustBePartial);
+  }
+
+  [Test]
+  public void TestReportsDiagnosticForParentWithoutPartial() {
+    ReadOnlyGeneratorTestUtil.AssertDiagnostics(
+        """
+        using readOnly;
+
+        namespace foo.bar;
+
+        public class Parent {
+          [GenerateReadOnly]
+          public partial class Child;
+        }
+        """,
+        Rules.ParentTypeMustBePartial);
+  }
+}

GenerateReadOnly Tests/analyzer/PartialTests.cs

@@ -1,14 +1,19 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 
 using NUnit.Framework;
 
+using readOnly.analyzer;
 using readOnly.util.asserts;
+using readOnly.util.diagnostics;
 
 #pragma warning disable CS8604
 
@@ -25,44 +30,75 @@ internal static class ReadOnlyGeneratorTestUtil {
               .Select(path => MetadataReference.CreateFromFile(path)));
 
   public static void AssertGenerated(string src, params string[] expected) {
+    var actual = ParseReadOnlyTypeCandidates(src, out var semanticModel)
+        .Select(symbolAndSyntax
+                    => ReadOnlyTypeGenerator
+                       .GenerateSourceForNamedType(
+                           symbolAndSyntax.namedTypeSymbol,
+                           semanticModel,
+                           symbolAndSyntax.declarationSyntax)
+                       .ReplaceLineEndings());
+
+    CollectionAssert.AreEqual(expected, actual);
+  }
+
+  public static void AssertDiagnostics(
+      string src,
+      params DiagnosticDescriptor[] expected) {
+    var actual = new List<DiagnosticDescriptor>();
+
+    foreach (var (namedTypeSymbol, declarationSyntax) in
+             ParseReadOnlyTypeCandidates(src, out var semanticModel)) {
+      var context = new SyntaxNodeAnalysisContext(
+          declarationSyntax,
+          semanticModel,
+          new AnalyzerOptions([]),
+          diagnostic => actual.Add(diagnostic.Descriptor),
+          _ => true,
+          CancellationToken.None);
+
+      GenerateReadOnlyAnalyzer.CheckType(
+          context,
+          declarationSyntax,
+          namedTypeSymbol);
+    }
+
+    CollectionAssert.AreEqual(expected, actual);
+  }
+
+  private static IEnumerable<(INamedTypeSymbol namedTypeSymbol,
+          TypeDeclarationSyntax declarationSyntax)>
+      ParseReadOnlyTypeCandidates(string src, out SemanticModel semanticModel) {
     var syntaxTree = CSharpSyntaxTree.ParseText(src);
     var compilation = Compilation.Clone()
                                  .AddSyntaxTrees(syntaxTree);
 
-    var semanticModel = compilation.GetSemanticModel(syntaxTree);
-
-    var actual = syntaxTree
-                 .GetRoot()
-                 .DescendantTokens()
-                 .Where(t => t is {
-                     Text: "GenerateReadOnly",
-                     Parent.Parent: AttributeSyntax
-                 })
-                 .Select(t => t.Parent?.Parent as AttributeSyntax)
-                 .Select(attributeSyntax => {
-                           var attributeListSyntax
-                               = Asserts.AsA<AttributeListSyntax>(
-                                   attributeSyntax.Parent);
-                           var declarationSyntax
-                               = Asserts.AsA<TypeDeclarationSyntax>(
-                                   attributeListSyntax.Parent);
-
-                           var symbol
-                               = semanticModel
-                                   .GetDeclaredSymbol(declarationSyntax);
-                           var namedTypeSymbol
-                               = symbol as INamedTypeSymbol;
-
-                           return (namedTypeSymbol, declarationSyntax);
-                         })
-                 .Select(symbolAndSyntax
-                             => new ReadOnlyTypeGenerator()
-                                .GenerateSourceForNamedType(
-                                    symbolAndSyntax.namedTypeSymbol,
-                                    semanticModel,
-                                    symbolAndSyntax.declarationSyntax)
-                                .ReplaceLineEndings());
+    semanticModel = compilation.GetSemanticModel(syntaxTree);
+    var localSemanticModel = semanticModel;
 
-    CollectionAssert.AreEqual(expected, actual);
+    return syntaxTree
+           .GetRoot()
+           .DescendantTokens()
+           .Where(t => t is {
+               Text: "GenerateReadOnly",
+               Parent.Parent: AttributeSyntax
+           })
+           .Select(t => t.Parent?.Parent as AttributeSyntax)
+           .Select(attributeSyntax => {
+                     var attributeListSyntax
+                         = Asserts.AsA<AttributeListSyntax>(
+                             attributeSyntax.Parent);
+                     var declarationSyntax
+                         = Asserts.AsA<TypeDeclarationSyntax>(
+                             attributeListSyntax.Parent);
+
+                     var symbol
+                         = localSemanticModel.GetDeclaredSymbol(
+                             declarationSyntax);
+                     var namedTypeSymbol
+                         = symbol as INamedTypeSymbol;
+
+                     return (namedTypeSymbol, declarationSyntax);
+                   });
   }
 }

GenerateReadOnly Tests/generator/ReadOnlyGeneratorTestUtil.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Immutable;
+using System.Diagnostics;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+using readOnly.generator;
+using readOnly.util.symbols;
+using readOnly.util.syntax;
+
+namespace readOnly.analyzer;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class GenerateReadOnlyAnalyzer : DiagnosticAnalyzer {
+  public override ImmutableArray<DiagnosticDescriptor>
+      SupportedDiagnostics { get; } =
+    ImmutableArray.Create(
+        Rules.TypeMustBePartial,
+        Rules.ParentTypeMustBePartial,
+        Rules.Exception
+    );
+
+  public override void Initialize(AnalysisContext context) {
+    context.RegisterSyntaxNodeAction(
+        syntaxNodeContext => {
+          var syntax = syntaxNodeContext.Node as ClassDeclarationSyntax;
+
+          var symbol =
+              syntaxNodeContext.SemanticModel.GetDeclaredSymbol(syntax!);
+          if (symbol is not INamedTypeSymbol namedTypeSymbol) {
+            return;
+          }
+
+          CheckType(syntaxNodeContext, syntax!, namedTypeSymbol);
+        },
+        SyntaxKind.ClassDeclaration);
+
+    context.RegisterSyntaxNodeAction(
+        syntaxNodeContext => {
+          var syntax = syntaxNodeContext.Node as StructDeclarationSyntax;
+
+          var symbol =
+              syntaxNodeContext.SemanticModel.GetDeclaredSymbol(syntax!);
+          if (symbol is not INamedTypeSymbol namedTypeSymbol) {
+            return;
+          }
+
+          CheckType(syntaxNodeContext, syntax!, namedTypeSymbol);
+        },
+        SyntaxKind.StructDeclaration);
+  }
+
+  public static void CheckType(
+      SyntaxNodeAnalysisContext context,
+      TypeDeclarationSyntax syntax,
+      INamedTypeSymbol symbol) {
+    try {
+      if (!symbol.HasAttribute<GenerateReadOnlyAttribute>()) {
+        return;
+      }
+
+      if (!syntax.IsPartial()) {
+        Rules.ReportDiagnostic(
+            context,
+            symbol,
+            Rules.TypeMustBePartial);
+        return;
+      }
+
+      var containingType = symbol.ContainingType;
+      while (containingType != null) {
+        var typeDeclarationSyntax =
+            containingType.DeclaringSyntaxReferences[0].GetSyntax() as
+                TypeDeclarationSyntax;
+
+        if (!typeDeclarationSyntax!.IsPartial()) {
+          Rules.ReportDiagnostic(
+              context,
+              symbol,
+              Rules.ParentTypeMustBePartial);
+        }
+
+        containingType = containingType.ContainingType;
+      }
+
+      ReadOnlyTypeGenerator.GenerateSourceForNamedType(
+          symbol,
+          context.SemanticModel,
+          syntax);
+    } catch (Exception exception) {
+      if (Debugger.IsAttached) {
+        throw;
+      }
+
+      Rules.ReportExceptionDiagnostic(context, symbol, exception);
+    }
+  }
+}

GenerateReadOnly/src/analyzer/GenerateReadOnlyAnalyzer.cs

@@ -4,7 +4,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace readOnly.generator.rules;
+namespace readOnly.analyzer;
 
 public static partial class Rules {
   private static int diagnosticId_ = 0;
@@ -20,7 +20,7 @@ private static DiagnosticDescriptor CreateDiagnosticDescriptor_(
     => new(Rules.GetNextDiagnosticId_(),
            title,
            messageFormat,
-           "BinarySchemaAnalyzer",
+           "GenerateReadOnlyAnalyzer",
            DiagnosticSeverity.Error,
            true);
 
@@ -30,7 +30,7 @@ private static DiagnosticDescriptor CreateDiagnosticDescriptor_(
         "GenerateReadOnly type must be partial",
         $"Type '{{0}}' was annotated with {nameof(GenerateReadOnlyAttribute)}, so it must be partial to accept automatically generated read/write code.");
 
-  public static DiagnosticDescriptor ContainerTypeMustBePartial {
+  public static DiagnosticDescriptor ParentTypeMustBePartial {
     get;
   } = Rules.CreateDiagnosticDescriptor_(
       "Container of GenerateReadOnly type must be partial",
@@ -39,12 +39,7 @@ public static DiagnosticDescriptor ContainerTypeMustBePartial {
   public static DiagnosticDescriptor Exception { get; }
     = Rules.CreateDiagnosticDescriptor_(
         "Exception",
-        "Ran into an exception while generating source ({0}),{1}");
-
-  public static DiagnosticDescriptor SymbolException { get; }
-    = Rules.CreateDiagnosticDescriptor_(
-        "Exception",
-        "Ran into an exception while parsing ({0}),{1}");
+        "Ran into an exception while processing symbol '{0}',{1}");
 
 
   public static Diagnostic CreateDiagnostic(
@@ -65,21 +60,12 @@ public static void ReportDiagnostic(
   public static Diagnostic CreateExceptionDiagnostic(
       ISymbol symbol,
       Exception exception)
-    => Diagnostic.Create(
-        Rules.SymbolException,
-        symbol.Locations.First(),
-        exception.Message,
-        exception.StackTrace.Replace("\r\n", "").Replace("\n", ""));
-
-  public static Diagnostic CreateExceptionDiagnostic(
-      Exception exception)
     => Diagnostic.Create(
         Rules.Exception,
-        null,
+        symbol.Locations.First(),
         exception.Message,
         exception.StackTrace.Replace("\r\n", "").Replace("\n", ""));
 
-
   public static void ReportExceptionDiagnostic(
       SyntaxNodeAnalysisContext? context,
       ISymbol symbol,

…ateReadOnly/src/generator/rules/Rules.cs GenerateReadOnly/src/analyzer/Rules.csGenerateReadOnly/src/generator/rules/Rules.cs renamed to GenerateReadOnly/src/analyzer/Rules.cs GenerateReadOnly/src/generator/rules/Rules.cs renamed to GenerateReadOnly/src/analyzer/Rules.cs

@@ -27,15 +27,16 @@ internal override bool FilterNamedTypesBeforeGenerating(
                                   SemanticModel semanticModel,
                                   TypeDeclarationSyntax syntax) {
     yield return ($"{symbol.GetUniqueNameForGenerator()}_readOnly.g",
-                  this.GenerateSourceForNamedType(
+                  GenerateSourceForNamedType(
                       symbol,
                       semanticModel,
                       syntax));
   }
 
-  public string GenerateSourceForNamedType(INamedTypeSymbol typeSymbol,
-                                           SemanticModel semanticModel,
-                                           TypeDeclarationSyntax syntax) {
+  public static string GenerateSourceForNamedType(
+      INamedTypeSymbol typeSymbol,
+      SemanticModel semanticModel,
+      TypeDeclarationSyntax syntax) {
     var sb = new StringBuilder();
     using var sw = new SourceWriter(new StringWriter(sb));