Support IgnoreProperty and generator improvements

Author: pwelter34

src/Directory.Build.props

@@ -25,6 +25,7 @@
     <DefaultLanguage>en-US</DefaultLanguage>
     <LangVersion>latest</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
     <NoWarn>1591</NoWarn>
   </PropertyGroup>
   <PropertyGroup>

src/FluentCommand.Caching/FluentCommand.Caching.csproj

@@ -1,8 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net8.0;net9.0;net10.0</TargetFrameworks>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
     <Description>Fluent Wrapper for DbCommand with distributed caching support using Microsoft.Extensions.Caching and MessagePack serialization</Description>
   </PropertyGroup>
   <ItemGroup>

src/FluentCommand.Csv/FluentCommand.Csv.csproj

@@ -2,8 +2,6 @@
   <PropertyGroup>
     <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
     <RootNamespace>FluentCommand</RootNamespace>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
     <Description>Fluent Wrapper for DbCommand with CSV export support for query results</Description>
   </PropertyGroup>
   <ItemGroup>

src/FluentCommand.Generators/DataReaderFactoryGenerator.cs

@@ -59,12 +59,13 @@ protected static void WriteTypeAccessorSource(SourceProductionContext context, E
             ? InitializationMode.ObjectInitializer
             : InitializationMode.Constructor;
 
+        var classIgnored = GetClassIgnoredProperties(typeAttributes);
         var propertySymbols = GetProperties(targetSymbol);
 
         if (mode == InitializationMode.ObjectInitializer)
         {
             var propertyArray = propertySymbols
-                .Select(p => CreateProperty(p))
+                .Select(p => CreateProperty(p, classIgnored: classIgnored))
                 .ToArray();
 
             return new EntityClass(
@@ -80,8 +81,11 @@ protected static void WriteTypeAccessorSource(SourceProductionContext context, E
 
         // constructor initialization
 
-        // constructor with same number of parameters as properties
-        var constructor = targetSymbol.Constructors.FirstOrDefault(c => c.Parameters.Length == propertySymbols.Count);
+        // constructor with same number of parameters as mappable properties
+        var mappableCount = propertySymbols
+            .Count(p => !classIgnored.Contains(p.Name) && !HasIgnorePropertyAttribute(p.GetAttributes()));
+
+        var constructor = targetSymbol.Constructors.FirstOrDefault(c => c.Parameters.Length == mappableCount);
         if (constructor == null)
             return null;
 
@@ -96,7 +100,7 @@ protected static void WriteTypeAccessorSource(SourceProductionContext context, E
             if (parameter == null)
                 continue;
 
-            var property = CreateProperty(propertySymbol, parameter.Name);
+            var property = CreateProperty(propertySymbol, parameter.Name, classIgnored: classIgnored);
             properties.Add(property);
         }
 
@@ -133,16 +137,17 @@ protected static List<IPropertySymbol> GetProperties(INamedTypeSymbol targetSymb
             currentSymbol = currentSymbol.BaseType;
         }
 
-        return properties.Values.ToList();
+        return [.. properties.Values];
     }
 
-    protected static EntityProperty CreateProperty(IPropertySymbol propertySymbol, string? parameterName = null)
+    protected static EntityProperty CreateProperty(IPropertySymbol propertySymbol, string? parameterName = null, HashSet<string>? classIgnored = null)
     {
         var propertyType = propertySymbol.Type.ToDisplayString();
         var memberTypeName = propertySymbol.Type.WithNullableAnnotation(NullableAnnotation.NotAnnotated).ToDisplayString();
         var propertyName = propertySymbol.Name;
         var hasGetter = propertySymbol.GetMethod != null;
-        var hasSetter = propertySymbol.SetMethod != null && !propertySymbol.SetMethod.IsInitOnly;
+        var hasSetter = propertySymbol.SetMethod?.IsInitOnly == false;
+        var isNotMapped = (classIgnored?.Contains(propertyName) == true) || !IsSupportedType(propertySymbol.Type);
 
         var attributes = propertySymbol.GetAttributes();
         if (attributes == default || attributes.Length == 0)
@@ -153,6 +158,7 @@ protected static EntityProperty CreateProperty(IPropertySymbol propertySymbol, s
                 PropertyType: propertyType,
                 MemberTypeName: memberTypeName,
                 ParameterName: parameterName,
+                IsNotMapped: isNotMapped,
                 HasGetter: hasGetter,
                 HasSetter: hasSetter
             );
@@ -162,7 +168,11 @@ protected static EntityProperty CreateProperty(IPropertySymbol propertySymbol, s
         var converterName = GetConverterName(attributes);
 
         var isKey = HasDataAnnotationAttribute(attributes, "KeyAttribute");
-        var isNotMapped = IsNotMapped(attributes);
+
+        isNotMapped = isNotMapped
+            || IsNotMapped(attributes)
+            || HasIgnorePropertyAttribute(attributes);
+
         var isDatabaseGenerated = GetIsDatabaseGenerated(attributes);
         var isConcurrencyCheck = HasDataAnnotationAttribute(attributes, "ConcurrencyCheckAttribute");
         var foreignKey = GetSchemaAttributeConstructorStringArg(attributes, "ForeignKeyAttribute");
@@ -335,7 +345,51 @@ private static bool GetIsDatabaseGenerated(ImmutableArray<AttributeData> attribu
 
     protected static bool IsIncluded(IPropertySymbol propertySymbol)
     {
-        return !propertySymbol.IsIndexer && !propertySymbol.IsAbstract && propertySymbol.DeclaredAccessibility == Accessibility.Public;
+        return !propertySymbol.IsIndexer
+            && !propertySymbol.IsAbstract
+            && propertySymbol.DeclaredAccessibility == Accessibility.Public;
+    }
+
+    private static bool IsSupportedType(ITypeSymbol type)
+    {
+        // handle nullable value types
+        if (type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T } namedType)
+            return IsSupportedType(namedType.TypeArguments[0]);
+
+        // enums are stored as their underlying integer type
+        if (type.TypeKind == TypeKind.Enum)
+            return true;
+
+        // primitives and string
+        switch (type.SpecialType)
+        {
+            case SpecialType.System_Boolean:
+            case SpecialType.System_Byte:
+            case SpecialType.System_Char:
+            case SpecialType.System_Decimal:
+            case SpecialType.System_Double:
+            case SpecialType.System_Single:
+            case SpecialType.System_Int16:
+            case SpecialType.System_Int32:
+            case SpecialType.System_Int64:
+            case SpecialType.System_String:
+                return true;
+        }
+
+        // byte[]
+        if (type is IArrayTypeSymbol { ElementType.SpecialType: SpecialType.System_Byte })
+            return true;
+
+        // well-known struct types and FluentCommand.ConcurrencyToken
+        var fullName = type.ToDisplayString();
+        return fullName is
+            "System.DateTime" or
+            "System.DateTimeOffset" or
+            "System.Guid" or
+            "System.TimeSpan" or
+            "System.DateOnly" or
+            "System.TimeOnly" or
+            "FluentCommand.ConcurrencyToken";
     }
 
     private static bool IsNotMapped(ImmutableArray<AttributeData> attributes)
@@ -359,4 +413,54 @@ private static bool IsNotMapped(ImmutableArray<AttributeData> attributes)
                 }
             });
     }
+
+    private static bool HasIgnorePropertyAttribute(ImmutableArray<AttributeData> attributes)
+    {
+        return attributes.Any(a => a.AttributeClass is
+        {
+            Name: "IgnorePropertyAttribute",
+            ContainingNamespace:
+            {
+                Name: "Attributes",
+                ContainingNamespace.Name: "FluentCommand"
+            }
+        });
+    }
+
+    private static HashSet<string> GetClassIgnoredProperties(ImmutableArray<AttributeData> attributes)
+    {
+        var ignored = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (var attr in attributes)
+        {
+            if (attr.AttributeClass is not
+                {
+                    Name: "IgnorePropertyAttribute",
+                    ContainingNamespace:
+                    {
+                        Name: "Attributes",
+                        ContainingNamespace.Name: "FluentCommand"
+                    }
+                })
+            {
+                continue;
+            }
+
+            // constructor argument: [IgnoreProperty("Name")] or [IgnoreProperty(nameof(T.Name))]
+            if (attr.ConstructorArguments.Length > 0 && attr.ConstructorArguments[0].Value is string ctorName)
+            {
+                ignored.Add(ctorName);
+                continue;
+            }
+
+            // named argument: [IgnoreProperty(PropertyName = "Name")]
+            foreach (var namedArg in attr.NamedArguments)
+            {
+                if (namedArg.Key == "PropertyName" && namedArg.Value.Value is string namedValue)
+                    ignored.Add(namedValue);
+            }
+        }
+
+        return ignored;
+    }
 }

src/FluentCommand.Generators/DataReaderFactoryWriter.cs

@@ -1,3 +1,5 @@
+using System.Text;
+
 using FluentCommand.Generators.Models;
 
 namespace FluentCommand.Generators;

src/FluentCommand.Generators/FluentCommand.Generators.csproj

@@ -1,17 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
     <IsRoslynComponent>true</IsRoslynComponent>
-    <NoPackageAnalysis>true</NoPackageAnalysis>
-    <IncludeBuildOutput>false</IncludeBuildOutput>
-    <DevelopmentDependency>true</DevelopmentDependency>
     <IsPackable>false</IsPackable>
     <AnalyzerLanguage>cs</AnalyzerLanguage>
-    <AnalyzerRoslynVersion>4.4</AnalyzerRoslynVersion>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
-    <Nullable>enable</Nullable>
-    <Description>Source generators for FluentCommand that create DataReader factory methods and extension methods for entity classes</Description>
+    <GenerateDocumentationFile>false</GenerateDocumentationFile>
   </PropertyGroup>
   <ItemGroup>
     <!-- https://learn.microsoft.com/en-us/visualstudio/extensibility/roslyn-version-support -->

src/FluentCommand.Generators/Infrastructure/CollectionBuilderAttribute.cs

@@ -0,0 +1,14 @@
+#pragma warning disable IDE0130 // Namespace does not match folder structure
+
+using System.ComponentModel;
+
+namespace System.Runtime.CompilerServices;
+
+[EditorBrowsable(EditorBrowsableState.Never)]
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
+internal sealed class CollectionBuilderAttribute(Type builderType, string methodName) : Attribute
+{
+    public Type BuilderType { get; } = builderType;
+
+    public string MethodName { get; } = methodName;
+}