test: add tests, cleanup project, add warnings

Author: Joanna May

Chickensoft.Introspection.Generator.Tests/test_cases/Bad.cs

@@ -0,0 +1,29 @@
+namespace Chickensoft.LogicBlocks.Generator.Tests.TestCases;
+
+// using Chickensoft.Introspection;
+
+// [Introspective("bad_because_identical")]
+// public partial class BadBecauseIdentical;
+
+// [Introspective("bad_because_identical")]
+// public partial class BadBecauseAlsoIdentical;
+//
+// [Introspective("bad_because_generic")]
+// public partial class BadBecauseGeneric<T> {
+//   [Introspective("bad_because_nested_in_generic")]
+//   public partial class BadBecauseNestedInGeneric {
+//     [Introspective("bad_because_deeply_nested_in_generic")]
+//     public partial class BadBecauseDeeplyNestedInGeneric;
+//   }
+// }
+
+// public partial class Visible {
+//   [Introspective("bad_because_not_public")]
+//   private partial class BadBecauseNotPublic {
+//     [Introspective("bad_because_nested_in_not_public")]
+//     public partial class BadBecauseNestedInNotPublic {
+//       [Introspective("bad_because_deeply_nested_in_not_public")]
+//       public partial class BadBecauseDeeplyNestedInNotPublic;
+//     }
+//   }
+// }

Chickensoft.Introspection.Generator/src/TypeGenerator.cs

@@ -1,4 +1,4 @@
-namespace Chickensoft.LogicBlocks.Generator;
+namespace Chickensoft.Introspection.Generator;
 
 using System;
 using System.CodeDom.Compiler;
@@ -7,8 +7,8 @@ namespace Chickensoft.LogicBlocks.Generator;
 using System.IO;
 using System.Linq;
 using System.Threading;
-using Chickensoft.LogicBlocks.Generator.Types.Models;
-using Chickensoft.LogicBlocks.Generator.Utils;
+using Chickensoft.Introspection.Generator.Types.Models;
+using Chickensoft.Introspection.Generator.Utils;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -50,7 +50,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context) {
 
     // --------------------------------------------------------------------- //
     // while (!System.Diagnostics.Debugger.IsAttached) {
-    //   Thread.Sleep(500);
+    //   Thread.Sleep(100);
     // }
     // System.Diagnostics.Debugger.Break();
     // --------------------------------------------------------------------- //
@@ -110,7 +110,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context) {
           concreteVisibleTypesBuilder.Add(type.FullName, type);
         }
 
-        if (type.CanGenerateMetatypeInfo) {
+        if (type.HasIntrospectiveAttribute) {
           metatypesBuilder.Add(type.FullName, type);
         }
 
@@ -120,6 +120,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context) {
       }
 
       return new GenerationData(
+        AllTypes: uniqueTypes.ToImmutableDictionary(),
         Metatypes: metatypesBuilder.ToImmutable(),
         VisibleTypes: visibleTypesBuilder.ToImmutable(),
         ConcreteVisibleTypes: concreteVisibleTypesBuilder.ToImmutable(),
@@ -133,24 +134,90 @@ public void Initialize(IncrementalGeneratorInitializationContext context) {
         SourceProductionContext context,
         GenerationData data
       ) => {
-        GenerateTypeRegistry(context, data);
-        OutputMetatypesAndReportDiagnostics(context, data);
+        if (OutputMetatypesAndReportDiagnostics(context, data)) {
+          GenerateTypeRegistry(context, data);
+        }
       }
     );
   }
 
-  public static void OutputMetatypesAndReportDiagnostics(
+  public static bool OutputMetatypesAndReportDiagnostics(
     SourceProductionContext context,
     GenerationData data
   ) {
+    var diagnostics = new List<Diagnostic>();
+    var seenMetatypeIds = new Dictionary<string, DeclaredType>();
+
     // A metatype is a class generated by the source generator that contains
     // information about the class it is generated inside of.
-    foreach (var type in data.VisibleTypes.Values) {
-      foreach (var diagnostic in type.Diagnostics) {
-        context.ReportDiagnostic(diagnostic);
+    foreach (var type in data.AllTypes.Values) {
+      if (!type.HasIntrospectiveAttribute) {
+        continue;
+      }
+
+      if (seenMetatypeIds.TryGetValue(type.Id, out var existingType)) {
+        // Metatype id's must be unique across all assemblies.
+
+        diagnostics.Add(
+          Diagnostics.TypeDoesNotHaveUniqueId(
+            type.SyntaxLocation,
+            type.FullName,
+            existingType
+          )
+        );
+
+        continue;
+      }
+
+      seenMetatypeIds.Add(type.Id, type);
+
+      var invisibleTypes = type.ValidateTypeAndContainingTypes(
+        data.AllTypes, (t) => t.IsTopLevelAccessible
+      ).ToArray();
+
+      if (invisibleTypes.Length > 0) {
+        diagnostics.Add(
+          Diagnostics.TypeNotVisible(
+            type.SyntaxLocation,
+            type.FullName,
+            invisibleTypes
+          )
+        );
+      }
+
+      var nonPartialTypes = type.ValidateTypeAndContainingTypes(
+        data.AllTypes, (t) => t.Reference.IsPartial
+      ).ToArray();
+
+      if (nonPartialTypes.Length > 0) {
+        diagnostics.Add(
+          Diagnostics.TypeNotFullyPartial(
+            type.SyntaxLocation,
+            type.FullName,
+            nonPartialTypes
+          )
+        );
       }
 
-      if (!type.CanGenerateMetatypeInfo) {
+      var genericTypes = type.ValidateTypeAndContainingTypes(
+        data.AllTypes, (t) => t.Reference.TypeParameters.Length == 0
+      ).ToArray();
+
+      if (genericTypes.Length > 0) {
+        diagnostics.Add(
+          Diagnostics.TypeIsGeneric(
+            type.SyntaxLocation,
+            type.FullName,
+            genericTypes
+          )
+        );
+      }
+
+      if (diagnostics.Count > 0 || !type.CanGenerateMetatypeInfo) {
+        // For one or more of the above reasons, we can't proceed with
+        // generating metatype information, even though the developer wants us
+        // to. They will get one or more of the diagnostics above, allowing
+        // them to fix the issue and repent of their sins.
         continue;
       }
 
@@ -194,7 +261,7 @@ GenerationData data
 
       // Add a mixin state bucket to the type itself.
       code.WriteLine(
-        $"public {Constants.DATA_TABLE} MixinState {{ get; }} = new();"
+        $"public {Constants.MIXIN_BLACKBOARD} MixinState {{ get; }} = new();"
       );
       code.WriteLine();
 
@@ -225,6 +292,12 @@ GenerationData data
         source: code.InnerWriter.ToString()
       );
     }
+
+    foreach (var diagnostic in diagnostics) {
+      context.ReportDiagnostic(diagnostic);
+    }
+
+    return diagnostics.Count == 0;
   }
 
   private static void WriteFileStart(IndentedTextWriter code) {
@@ -479,28 +552,14 @@ public static DeclaredType ResolveDeclaredTypeInfo(
 
     var diagnostics = new HashSet<Diagnostic>();
 
-    if (
-      hasIntrospectiveAttribute && (
-        !isTopLevelAccessible || // Must be top-level accessible
-        !isPartial || // Must be partial
-        typeParameters.Length > 0 // Must be non-generic
-      )
-    ) {
-      diagnostics.Add(
-        Diagnostics.InvalidIntrospectiveType(
-          typeDecl,
-          name
-        )
-      );
-    }
-
     var usings = GetUsings(typeDecl);
     var properties = GetProperties(typeDecl);
     var attributes = GetAttributes(typeDecl.AttributeLists);
     var mixins = GetMixins(typeDecl);
 
     return new DeclaredType(
       Reference: reference,
+      SyntaxLocation: typeDecl.GetLocation(),
       Location: location,
       Usings: usings,
       Kind: kind,
@@ -509,8 +568,7 @@ public static DeclaredType ResolveDeclaredTypeInfo(
       IsTopLevelAccessible: isTopLevelAccessible,
       Properties: properties,
       Attributes: attributes,
-      Mixins: mixins,
-      Diagnostics: diagnostics.ToImmutableHashSet()
+      Mixins: mixins
     );
   }
 
@@ -731,7 +789,10 @@ var namespacePart in @namespace.Name.ToString().Split('.').Reverse()
       }
     }
 
-    return new TypeLocation(namespaces, types);
+    return new TypeLocation(
+      namespaces.ToImmutableArray(),
+      types.ToImmutableArray()
+    );
   }
 
   public static ImmutableHashSet<UsingDirective> GetUsings(

Chickensoft.Introspection.Generator/src/models/Construction.cs

@@ -1,5 +1,4 @@
-
-namespace Chickensoft.LogicBlocks.Generator.Types.Models;
+namespace Chickensoft.Introspection.Generator.Types.Models;
 
 public enum Construction {
   StaticClass,

Chickensoft.Introspection.Generator/src/models/DeclaredAttribute.cs

@@ -1,4 +1,4 @@
-namespace Chickensoft.LogicBlocks.Generator.Types.Models;
+namespace Chickensoft.Introspection.Generator.Types.Models;
 
 using System.Collections.Immutable;
 

Chickensoft.Introspection.Generator/src/models/DeclaredProperty.cs

@@ -1,4 +1,4 @@
-namespace Chickensoft.LogicBlocks.Generator.Types.Models;
+namespace Chickensoft.Introspection.Generator.Types.Models;
 
 using System.Collections.Immutable;
 

Chickensoft.Introspection.Generator/src/models/DeclaredType.cs

@@ -1,6 +1,8 @@
 
-namespace Chickensoft.LogicBlocks.Generator.Types.Models;
+namespace Chickensoft.Introspection.Generator.Types.Models;
 
+using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
@@ -10,6 +12,8 @@ namespace Chickensoft.LogicBlocks.Generator.Types.Models;
 /// </summary>
 /// <param name="Reference">Type reference, including the name, construction,
 /// type parameters, and whether or not the type is partial.</param>
+/// <param name="SyntaxLocation">Syntax node location (used for diagnostics).
+/// </param>
 /// <param name="Location">Location of the type in the source code, including
 /// namespaces and containing types.</param>
 /// <param name="Usings">Using directives that are in scope for the type.
@@ -24,10 +28,9 @@ namespace Chickensoft.LogicBlocks.Generator.Types.Models;
 /// <param name="Properties">Properties declared on the type.</param>
 /// <param name="Attributes">Attributes declared on the type.</param>
 /// <param name="Mixins">Mixins that are applied to the type.</param>
-/// <param name="Diagnostics">Diagnostics that were generated during generator
-/// transformation.</param>
 public record DeclaredType(
   TypeReference Reference,
+  Location SyntaxLocation,
   TypeLocation Location,
   ImmutableHashSet<UsingDirective> Usings,
   DeclaredTypeKind Kind,
@@ -36,8 +39,7 @@ public record DeclaredType(
   bool IsTopLevelAccessible,
   ImmutableArray<DeclaredProperty> Properties,
   ImmutableArray<DeclaredAttribute> Attributes,
-  ImmutableArray<string> Mixins,
-  ImmutableHashSet<Diagnostic> Diagnostics
+  ImmutableArray<string> Mixins
 ) {
   /// <summary>Output filename (only works for non-generic types).</summary>
   public string Filename => FullName.Replace('.', '_');
@@ -70,6 +72,41 @@ ImmutableHashSet<Diagnostic> Diagnostics
   public string Id => IntrospectiveAttribute?.ConstructorArgs.FirstOrDefault()
     ?? $"nameof({Reference.NameWithOpenGenerics})";
 
+  /// <summary>
+  /// Validates that the DeclaredType of this type and its containing types
+  /// satisfy the given predicate. Returns a list of types that do not satisfy
+  /// the predicate.
+  /// </summary>
+  /// <param name="allTypes">Table of type full names with open generics to
+  /// the declared type they represent.</param>
+  /// <param name="predicate">Predicate each type must satisfy.</param>
+  /// <returns>Enumerable of types that do not satisfy the predicate.</returns>
+  public IEnumerable<DeclaredType> ValidateTypeAndContainingTypes(
+    IDictionary<string, DeclaredType> allTypes,
+    Func<DeclaredType, bool> predicate
+  ) {
+    // Have to reconstruct the full names of the containing types from our
+    // type reference and location information.
+    var fullName = Location.Namespace;
+    var containingTypeFullNames = new Dictionary<TypeReference, string>();
+
+    foreach (var containingType in Location.ContainingTypes) {
+      fullName +=
+        (fullName.Length == 0 ? "" : ".") +
+        containingType.NameWithOpenGenerics;
+
+      containingTypeFullNames[containingType] = fullName;
+    }
+
+    var typesToValidate =
+      new[] { this }.Concat(Location.ContainingTypes.Select(
+        (typeRef) => allTypes[containingTypeFullNames[typeRef]]
+      )
+    );
+
+    return typesToValidate.Where((type) => !predicate(type));
+  }
+
   private DeclaredAttribute? IntrospectiveAttribute => Attributes
     .FirstOrDefault(
       (attr) => attr.Name == Constants.INTROSPECTIVE_ATTRIBUTE_NAME
@@ -86,6 +123,7 @@ public DeclaredType MergePartialDefinition(
     DeclaredType declaredType
   ) => new(
     Reference.MergePartialDefinition(declaredType.Reference),
+    HasIntrospectiveAttribute ? SyntaxLocation : declaredType.SyntaxLocation,
     Location,
     Usings.Union(declaredType.Usings),
     Kind,
@@ -97,7 +135,6 @@ DeclaredType declaredType
       .Union(declaredType.Properties)
       .ToImmutableArray(),
     Attributes.Concat(declaredType.Attributes).ToImmutableArray(),
-    Mixins.Concat(declaredType.Mixins).ToImmutableArray(),
-    Diagnostics.Union(declaredType.Diagnostics)
+    Mixins.Concat(declaredType.Mixins).ToImmutableArray()
   );
 }

Chickensoft.Introspection.Generator/src/models/DeclaredTypeKind.cs

@@ -1,4 +1,4 @@
-namespace Chickensoft.LogicBlocks.Generator.Types.Models;
+namespace Chickensoft.Introspection.Generator.Types.Models;
 
 public enum DeclaredTypeKind {
   StaticClass,

Chickensoft.Introspection.Generator/src/models/GenerationData.cs

@@ -1,11 +1,12 @@
-namespace Chickensoft.LogicBlocks.Generator.Types.Models;
+namespace Chickensoft.Introspection.Generator.Types.Models;
 
 using System.Collections.Immutable;
 
 /// <summary>
 /// Data used to generate source output. Represents the finished work of the
 /// generator before it is converted into source code output.
 /// </summary>
+/// <param name="AllTypes">All identified types.</param>
 /// <param name="Metatypes">Valid metatypes that were found in the project's
 /// source code.</param>
 /// <param name="VisibleTypes">Declared types that are visible at the top-level
@@ -16,6 +17,7 @@ namespace Chickensoft.LogicBlocks.Generator.Types.Models;
 /// <param name="Mixins">Map of declared types that are marked with the mixin
 /// attribute by their type name.</param>
 public record GenerationData(
+  ImmutableDictionary<string, DeclaredType> AllTypes,
   ImmutableDictionary<string, DeclaredType> Metatypes,
   ImmutableDictionary<string, DeclaredType> VisibleTypes,
   ImmutableDictionary<string, DeclaredType> ConcreteVisibleTypes,