Validate JsonColumn and use fully-qualified types

pwelter34 · pwelter34 · commit b51d2a0d6fba · 2026-05-29T00:53:15.000-05:00
diff --git a/src/FluentCommand.Generators/AnalyzerReleases.Unshipped.md b/src/FluentCommand.Generators/AnalyzerReleases.Unshipped.md
@@ -11,3 +11,5 @@ FLC003  | Usage    | Warning  | DataReaderFactoryAnalyzer
 FLC004  | Usage    | Info     | DataReaderFactoryAnalyzer
 FLC005  | Usage    | Error    | DataReaderFactoryAnalyzer
 FLC006  | Usage    | Warning  | DataReaderFactoryAnalyzer
+FLC007  | Usage    | Error    | DataReaderFactoryAnalyzer
+FLC008  | Usage    | Error    | DataReaderFactoryAnalyzer
diff --git a/src/FluentCommand.Generators/DataReaderFactoryAnalyzer.cs b/src/FluentCommand.Generators/DataReaderFactoryAnalyzer.cs
@@ -15,7 +15,9 @@ public sealed class DataReaderFactoryAnalyzer : DiagnosticAnalyzer
             DiagnosticDescriptors.NoMappableProperties,
             DiagnosticDescriptors.UnsupportedPropertyType,
             DiagnosticDescriptors.InvalidGenerateReaderArgument,
-            DiagnosticDescriptors.TableAttributeOnInvalidType
+            DiagnosticDescriptors.TableAttributeOnInvalidType,
+            DiagnosticDescriptors.InvalidJsonColumnOptionsProvider,
+            DiagnosticDescriptors.InvalidJsonColumnSerializerContext
         );
 
     public override void Initialize(AnalysisContext context)
@@ -95,8 +97,12 @@ private static void AnalyzeEntityType(SymbolAnalysisContext context, INamedTypeS
             if (classIgnored.Contains(prop.Name) || HasIgnorePropertyAttribute(propertyAttributes) || IsNotMapped(propertyAttributes))
                 continue;
 
-            if (HasJsonColumnAttribute(propertyAttributes))
+            var jsonColumn = GetJsonColumnAttribute(propertyAttributes);
+            if (jsonColumn != null)
+            {
+                AnalyzeJsonColumnAttribute(context, prop, jsonColumn);
                 continue;
+            }
 
             if (!IsSupportedType(prop.Type))
             {
@@ -155,6 +161,68 @@ private static void AnalyzeEntityType(SymbolAnalysisContext context, INamedTypeS
         }
     }
 
+    private static void AnalyzeJsonColumnAttribute(SymbolAnalysisContext context, IPropertySymbol propertySymbol, AttributeData jsonColumn)
+    {
+        var location = jsonColumn.ApplicationSyntaxReference?.GetSyntax(context.CancellationToken).GetLocation()
+            ?? propertySymbol.Locations.FirstOrDefault()
+            ?? Location.None;
+
+        if (jsonColumn.ConstructorArguments.Length == 1
+            && jsonColumn.ConstructorArguments[0].Value is INamedTypeSymbol optionsProviderType
+            && !HasJsonSerializerOptionsProperty(optionsProviderType))
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                DiagnosticDescriptors.InvalidJsonColumnOptionsProvider,
+                location,
+                optionsProviderType.ToDisplayString()));
+        }
+
+        if (jsonColumn.ConstructorArguments.Length == 2
+            && jsonColumn.ConstructorArguments[0].Value is INamedTypeSymbol serializerContextType
+            && jsonColumn.ConstructorArguments[1].Value is string typeInfoPropertyName
+            && (!DerivesFromJsonSerializerContext(serializerContextType) || !HasProperty(serializerContextType, typeInfoPropertyName)))
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                DiagnosticDescriptors.InvalidJsonColumnSerializerContext,
+                location,
+                serializerContextType.ToDisplayString(),
+                typeInfoPropertyName));
+        }
+    }
+
+    private static bool HasJsonSerializerOptionsProperty(INamedTypeSymbol typeSymbol)
+    {
+        return typeSymbol.GetMembers("Options")
+            .OfType<IPropertySymbol>()
+            .Any(p => p.IsStatic && IsJsonSerializerOptions(p.Type));
+    }
+
+    private static bool IsJsonSerializerOptions(ITypeSymbol typeSymbol)
+    {
+        return typeSymbol
+            .WithNullableAnnotation(NullableAnnotation.NotAnnotated)
+            .ToDisplayString() == "System.Text.Json.JsonSerializerOptions";
+    }
+
+    private static bool DerivesFromJsonSerializerContext(INamedTypeSymbol typeSymbol)
+    {
+        var current = typeSymbol;
+        while (current != null)
+        {
+            if (current.ToDisplayString() == "System.Text.Json.Serialization.JsonSerializerContext")
+                return true;
+
+            current = current.BaseType;
+        }
+
+        return false;
+    }
+
+    private static bool HasProperty(INamedTypeSymbol typeSymbol, string propertyName)
+    {
+        return typeSymbol.GetMembers(propertyName).OfType<IPropertySymbol>().Any();
+    }
+
     #region Attribute helpers (mirrors generator logic)
 
     private static bool IsGenerateReaderAttribute(AttributeData attr)
@@ -208,7 +276,12 @@ private static bool HasIgnorePropertyAttribute(ImmutableArray<AttributeData> att
 
     private static bool HasJsonColumnAttribute(ImmutableArray<AttributeData> attributes)
     {
-        return attributes.Any(a => a.AttributeClass is
+        return GetJsonColumnAttribute(attributes) != null;
+    }
+
+    private static AttributeData? GetJsonColumnAttribute(ImmutableArray<AttributeData> attributes)
+    {
+        return attributes.FirstOrDefault(a => a.AttributeClass is
         {
             Name: "JsonColumnAttribute",
             ContainingNamespace:
diff --git a/src/FluentCommand.Generators/DataReaderFactoryGenerator.cs b/src/FluentCommand.Generators/DataReaderFactoryGenerator.cs
@@ -11,6 +11,9 @@ namespace FluentCommand.Generators;
 [Generator(LanguageNames.CSharp)]
 public sealed class DataReaderFactoryGenerator : IIncrementalGenerator
 {
+    private static readonly SymbolDisplayFormat FullyQualifiedNullableFormat = SymbolDisplayFormat.FullyQualifiedFormat
+        .WithMiscellaneousOptions(SymbolDisplayFormat.FullyQualifiedFormat.MiscellaneousOptions | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
+
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         // Pipeline for [GenerateReader(typeof(T))] attribute
@@ -178,7 +181,12 @@ private static void WriteTypeAccessorSource(SourceProductionContext context, Ent
             if (parameter == null)
                 continue;
 
-            var property = CreateProperty(propertySymbol, parameter.Name, classIgnored: classIgnored);
+            var property = CreateProperty(
+                propertySymbol: propertySymbol,
+                parameterName: parameter.Name,
+                classIgnored: classIgnored,
+                parameterAttributes: parameter.GetAttributes());
+
             properties.Add(property);
         }
 
@@ -219,14 +227,24 @@ private static List<IPropertySymbol> GetProperties(INamedTypeSymbol targetSymbol
         return [.. properties.Values];
     }
 
-    private static EntityProperty CreateProperty(IPropertySymbol propertySymbol, string? parameterName = null, HashSet<string>? classIgnored = null)
+    private static EntityProperty CreateProperty(
+        IPropertySymbol propertySymbol,
+        string? parameterName = null,
+        HashSet<string>? classIgnored = null,
+        ImmutableArray<AttributeData> parameterAttributes = default)
     {
-        var propertyType = propertySymbol.Type.ToDisplayString();
-        var memberTypeName = propertySymbol.Type.WithNullableAnnotation(NullableAnnotation.NotAnnotated).ToDisplayString();
+        var propertyType = propertySymbol.Type.ToDisplayString(FullyQualifiedNullableFormat);
+        var memberTypeName = propertySymbol.Type.WithNullableAnnotation(NullableAnnotation.NotAnnotated).ToDisplayString(FullyQualifiedNullableFormat);
         var propertyName = propertySymbol.Name;
         var hasGetter = propertySymbol.GetMethod != null;
         var hasSetter = propertySymbol.SetMethod?.IsInitOnly == false;
-        var attributes = propertySymbol.GetAttributes();
+
+        // Merge property attributes with constructor parameter attributes (parameter attributes take precedence for converters)
+        var propertyAttributes = propertySymbol.GetAttributes();
+        var attributes = (!parameterAttributes.IsDefaultOrEmpty && !propertyAttributes.IsDefaultOrEmpty)
+            ? propertyAttributes.AddRange(parameterAttributes)
+            : !parameterAttributes.IsDefaultOrEmpty ? parameterAttributes : propertyAttributes;
+
         var jsonColumn = GetJsonColumn(attributes);
         var isJsonColumn = jsonColumn != null;
         var enumInfo = GetEnumInfo(propertySymbol.Type);
@@ -396,7 +414,7 @@ private static bool IsNullableType(ITypeSymbol type)
         // attribute constructor
         var converterType = converter.ConstructorArguments.FirstOrDefault();
         if (converterType.Value is INamedTypeSymbol converterSymbol)
-            return converterSymbol.ToDisplayString();
+            return converterSymbol.ToDisplayString(FullyQualifiedNullableFormat);
 
         // generic attribute
         var attributeClass = converter.AttributeClass;
diff --git a/src/FluentCommand.Generators/DataReaderFactoryWriter.cs b/src/FluentCommand.Generators/DataReaderFactoryWriter.cs
@@ -430,7 +430,7 @@ private static void WriteEnumColumnReader(IndentedStringBuilder codeBuilder, Ent
 
     private static string GetEnumReadExpression(EntityProperty entityProperty)
     {
-        var underlyingType = entityProperty.EnumUnderlyingType ?? "int";
+        var underlyingType = GetAliasMap(entityProperty.EnumUnderlyingType ?? "int");
 
         if (entityProperty.IsNullableEnum)
             return $"({entityProperty.PropertyType})dataRecord.GetValue<{underlyingType}?>(__index)";
@@ -506,6 +506,17 @@ private static string GetAliasMap(string type)
     {
         return type switch
         {
+            "global::System.Boolean" => "bool",
+            "global::System.Byte" => "byte",
+            "global::System.Byte[]" => "byte[]",
+            "global::System.Char" => "char",
+            "global::System.Decimal" => "decimal",
+            "global::System.Double" => "double",
+            "global::System.Single" => "float",
+            "global::System.Int16" => "short",
+            "global::System.Int32" => "int",
+            "global::System.Int64" => "long",
+            "global::System.String" => "string",
             "System.Boolean" => "bool",
             "System.Byte" => "byte",
             "System.Byte[]" => "byte[]",
@@ -534,6 +545,20 @@ private static string GetReaderName(string propertyType)
     {
         return propertyType switch
         {
+            "global::System.Boolean" => "GetBoolean",
+            "global::System.Byte" => "GetByte",
+            "global::System.Byte[]" => "GetBytes",
+            "global::System.Char" => "GetChar",
+            "global::System.DateTime" => "GetDateTime",
+            "global::System.DateTimeOffset" => "GetDateTimeOffset",
+            "global::System.Decimal" => "GetDecimal",
+            "global::System.Double" => "GetDouble",
+            "global::System.Guid" => "GetGuid",
+            "global::System.Single" => "GetFloat",
+            "global::System.Int16" => "GetInt16",
+            "global::System.Int32" => "GetInt32",
+            "global::System.Int64" => "GetInt64",
+            "global::System.String" => "GetString",
             "System.Boolean" => "GetBoolean",
             "System.Byte" => "GetByte",
             "System.Byte[]" => "GetBytes",
@@ -559,7 +584,10 @@ private static string GetReaderName(string propertyType)
             "int" => "GetInt32",
             "long" => "GetInt64",
             "string" => "GetString",
+            // special handling for ConcurrencyToken to use GetBytes
+            "global::FluentCommand.ConcurrencyToken" => "GetBytes",
             "FluentCommand.ConcurrencyToken" => "GetBytes",
+            // fallback to GetValue<T> for unsupported types
             _ => $"GetValue<{propertyType}>"
         };
     }
diff --git a/src/FluentCommand.Generators/DiagnosticDescriptors.cs b/src/FluentCommand.Generators/DiagnosticDescriptors.cs
@@ -86,4 +86,30 @@ internal static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "The source generator skips static and abstract types annotated with [Table]. Remove the attribute or make the type non-static and non-abstract."
     );
+
+    /// <summary>
+    /// FLC007: [JsonColumn] options provider type is invalid.
+    /// </summary>
+    public static readonly DiagnosticDescriptor InvalidJsonColumnOptionsProvider = new(
+        id: "FLC007",
+        title: "Invalid JsonColumn options provider",
+        messageFormat: "The [JsonColumn] options provider type '{0}' must expose a static Options property of type System.Text.Json.JsonSerializerOptions",
+        category: Category,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: "The [JsonColumn(typeof(TProvider))] attribute requires a provider type with a static Options property compatible with System.Text.Json.JsonSerializerOptions."
+    );
+
+    /// <summary>
+    /// FLC008: [JsonColumn] serializer context type or property is invalid.
+    /// </summary>
+    public static readonly DiagnosticDescriptor InvalidJsonColumnSerializerContext = new(
+        id: "FLC008",
+        title: "Invalid JsonColumn serializer context",
+        messageFormat: "The [JsonColumn] serializer context type '{0}' must derive from System.Text.Json.Serialization.JsonSerializerContext and expose a property named '{1}'",
+        category: Category,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: "The [JsonColumn(typeof(TContext), name)] attribute requires a serializer context type and a named type-info property that exists on the context."
+    );
 }
diff --git a/test/FluentCommand.Generators.Tests/DataReaderFactoryWriterTests.cs b/test/FluentCommand.Generators.Tests/DataReaderFactoryWriterTests.cs
@@ -15,11 +15,11 @@ public async Task Generate()
             EntityName = "Status",
             Properties = new EntityProperty[]
             {
-                new() { PropertyName = "Id", ColumnName = "Id", PropertyType = typeof(int).FullName!, MemberTypeName = typeof(int).FullName! },
-                new() { PropertyName = "Name", ColumnName = "Name", PropertyType = typeof(string).FullName!, MemberTypeName = typeof(string).FullName! },
-                new() { PropertyName = "IsActive", ColumnName = "IsActive", PropertyType = typeof(bool).FullName!, MemberTypeName = typeof(bool).FullName! },
-                new() { PropertyName = "Updated", ColumnName = "Updated", PropertyType = typeof(DateTimeOffset).FullName!, MemberTypeName = typeof(DateTimeOffset).FullName! },
-                new() { PropertyName = "RowVersion", ColumnName = "RowVersion", PropertyType = typeof(byte[]).FullName!, MemberTypeName = typeof(byte[]).FullName! },
+                new() { PropertyName = "Id", ColumnName = "Id", PropertyType = "global::System.Int32", MemberTypeName = "global::System.Int32" },
+                new() { PropertyName = "Name", ColumnName = "Name", PropertyType = "global::System.String", MemberTypeName = "global::System.String" },
+                new() { PropertyName = "IsActive", ColumnName = "IsActive", PropertyType = "global::System.Boolean", MemberTypeName = "global::System.Boolean" },
+                new() { PropertyName = "Updated", ColumnName = "Updated", PropertyType = "global::System.DateTimeOffset", MemberTypeName = "global::System.DateTimeOffset" },
+                new() { PropertyName = "RowVersion", ColumnName = "RowVersion", PropertyType = "global::System.Byte[]", MemberTypeName = "global::System.Byte[]" },
             }
         };
 
@@ -42,7 +42,7 @@ public void GenerateJsonColumnReader()
             EntityName = "UserLog",
             Properties = new EntityProperty[]
             {
-                new() { PropertyName = "Id", ColumnName = "Id", PropertyType = "int", MemberTypeName = "int" },
+                new() { PropertyName = "Id", ColumnName = "Id", PropertyType = "global::System.Int32", MemberTypeName = "global::System.Int32" },
                 new() { PropertyName = "Data", ColumnName = "Data", PropertyType = "global::FluentCommand.Entities.UserImport", MemberTypeName = "global::FluentCommand.Entities.UserImport", IsJsonColumn = true },
                 new() { PropertyName = "OptionalData", ColumnName = "OptionalData", PropertyType = "global::FluentCommand.Entities.UserImport?", MemberTypeName = "global::FluentCommand.Entities.UserImport?", IsJsonColumn = true, IsNullable = true },
                 new() { PropertyName = "DataWithOptions", ColumnName = "DataWithOptions", PropertyType = "global::FluentCommand.Entities.UserImport", MemberTypeName = "global::FluentCommand.Entities.UserImport", IsJsonColumn = true, JsonOptionsProviderName = "global::FluentCommand.Entities.UserImportJsonOptionsProvider" },
@@ -76,7 +76,7 @@ public void GenerateEnumColumnReader()
                     PropertyType = "global::FluentCommand.Entities.BuilderStatus",
                     MemberTypeName = "global::FluentCommand.Entities.BuilderStatus",
                     IsEnum = true,
-                    EnumUnderlyingType = "short"
+                    EnumUnderlyingType = "global::System.Int16"
                 },
                 new()
                 {
@@ -87,7 +87,7 @@ public void GenerateEnumColumnReader()
                     IsEnum = true,
                     IsNullable = true,
                     IsNullableEnum = true,
-                    EnumUnderlyingType = "short"
+                    EnumUnderlyingType = "global::System.Int16"
                 }
             }
         };
@@ -97,4 +97,32 @@ public void GenerateEnumColumnReader()
         Assert.Contains("v_status = (global::FluentCommand.Entities.BuilderStatus)dataRecord.GetInt16(__index);", source);
         Assert.Contains("v_optionalStatus = (global::FluentCommand.Entities.BuilderStatus?)dataRecord.GetValue<short?>(__index);", source);
     }
+
+    [Fact]
+    public void GenerateConverterColumnReader()
+    {
+        var entityClass = new EntityClass
+        {
+            InitializationMode = InitializationMode.ObjectInitializer,
+            FullyQualified = "global::FluentCommand.Entities.ConverterLog",
+            EntityNamespace = "FluentCommand.Entities",
+            EntityName = "ConverterLog",
+            Properties = new EntityProperty[]
+            {
+                new()
+                {
+                    PropertyName = "Value",
+                    ColumnName = "Value",
+                    PropertyType = "global::FluentCommand.Entities.CustomValue",
+                    MemberTypeName = "global::FluentCommand.Entities.CustomValue",
+                    ConverterName = "global::FluentCommand.Entities.CustomValueConverter"
+                }
+            }
+        };
+
+        var source = DataReaderFactoryWriter.Generate(entityClass);
+
+        Assert.Contains("var c_value = global::FluentCommand.Internal.Singleton<global::FluentCommand.Entities.CustomValueConverter>.Current", source);
+        Assert.Contains("as global::FluentCommand.IDataFieldConverter<global::FluentCommand.Entities.CustomValue>;", source);
+    }
 }
diff --git a/test/FluentCommand.Generators.Tests/Snapshots/DataReaderFactoryWriterTests.Generate.verified.txt b/test/FluentCommand.Generators.Tests/Snapshots/DataReaderFactoryWriterTests.Generate.verified.txt
@@ -101,7 +101,7 @@ namespace FluentCommand.Entities
             int v_id = default!;
             string v_name = default!;
             bool v_isActive = default!;
-            System.DateTimeOffset v_updated = default!;
+            global::System.DateTimeOffset v_updated = default!;
             byte[] v_rowVersion = default!;
 
             for (var __index = 0; __index < dataRecord.FieldCount; __index++)
