Implement global MSBuild defaults for [Projectable] options

src/EntityFrameworkCore.Projectables.Abstractions/EntityFrameworkCore.Projectables.Abstractions.csproj

@@ -26,6 +26,7 @@
 
   <ItemGroup>
 	<None Include="..\..\README.md" Pack="true" PackagePath="\" />
+	<None Include="build\EntityFrameworkCore.Projectables.Abstractions.props" Pack="true" PackagePath="buildTransitive\" />
   </ItemGroup>
 
 </Project>

src/EntityFrameworkCore.Projectables.Abstractions/build/EntityFrameworkCore.Projectables.Abstractions.props

@@ -0,0 +1,17 @@
+<Project>
+  <PropertyGroup>
+    <!-- Global defaults for [Projectable] options. Override these in your project to set app-wide defaults.
+         Per-member attribute settings always take precedence over these values. -->
+    <Projectables_NullConditionalRewriteSupport
+        Condition="'$(Projectables_NullConditionalRewriteSupport)' == ''" />
+    <Projectables_ExpandEnumMethods
+        Condition="'$(Projectables_ExpandEnumMethods)' == ''" />
+    <Projectables_AllowBlockBody
+        Condition="'$(Projectables_AllowBlockBody)' == ''" />
+  </PropertyGroup>
+  <ItemGroup>
+    <CompilerVisibleProperty Include="Projectables_NullConditionalRewriteSupport" />
+    <CompilerVisibleProperty Include="Projectables_ExpandEnumMethods" />
+    <CompilerVisibleProperty Include="Projectables_AllowBlockBody" />
+  </ItemGroup>
+</Project>

src/EntityFrameworkCore.Projectables.Generator/Comparers/MemberDeclarationSyntaxAndCompilationEqualityComparer.cs

@@ -1,29 +1,30 @@
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
 using EntityFrameworkCore.Projectables.Generator.Models;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace EntityFrameworkCore.Projectables.Generator.Comparers;
 
 /// <summary>
-/// Equality comparer for tuples of (MemberDeclarationSyntax, ProjectableAttributeData) and Compilation,
+/// Equality comparer for tuples of (MemberDeclarationSyntax, ProjectableAttributeData, ProjectableGlobalOptions) and Compilation,
 /// used as keys in the registry to determine if a member's projectable status has changed across incremental generation steps.
 /// </summary>
 internal class MemberDeclarationSyntaxAndCompilationEqualityComparer
-    : IEqualityComparer<((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute), Compilation)>
+    : IEqualityComparer<((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute, ProjectableGlobalOptions GlobalOptions), Compilation)>
 {
     private readonly static MemberDeclarationSyntaxEqualityComparer _memberComparer = new();
 
     public bool Equals(
-        ((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute), Compilation) x,
-        ((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute), Compilation) y)
+        ((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute, ProjectableGlobalOptions GlobalOptions), Compilation) x,
+        ((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute, ProjectableGlobalOptions GlobalOptions), Compilation) y)
     {
         var (xLeft, xCompilation) = x;
         var (yLeft, yCompilation) = y;
 
         // 1. Fast reference equality short-circuit
         if (ReferenceEquals(xLeft.Member, yLeft.Member) &&
-            ReferenceEquals(xCompilation, yCompilation))
+            ReferenceEquals(xCompilation, yCompilation) &&
+            xLeft.GlobalOptions == yLeft.GlobalOptions)
         {
             return true;
         }
@@ -43,17 +44,23 @@ public bool Equals(
             return false;
         }
 
-        // 4. Member text — string allocation, only reached when the SyntaxTree is shared
+        // 4. Global options (primitive record struct) — cheap value comparison
+        if (xLeft.GlobalOptions != yLeft.GlobalOptions)
+        {
+            return false;
+        }
+
+        // 5. Member text — string allocation, only reached when the SyntaxTree is shared
         if (!_memberComparer.Equals(xLeft.Member, yLeft.Member))
         {
             return false;
         }
 
-        // 5. Assembly-level references — most expensive (ImmutableArray enumeration)
+        // 6. Assembly-level references — most expensive (ImmutableArray enumeration)
         return xCompilation.ExternalReferences.SequenceEqual(yCompilation.ExternalReferences);
     }
 
-    public int GetHashCode(((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute), Compilation) obj)
+    public int GetHashCode(((MemberDeclarationSyntax Member, ProjectableAttributeData Attribute, ProjectableGlobalOptions GlobalOptions), Compilation) obj)
     {
         var (left, compilation) = obj;
         unchecked
@@ -62,7 +69,8 @@ public int GetHashCode(((MemberDeclarationSyntax Member, ProjectableAttributeDat
             hash = hash * 31 + _memberComparer.GetHashCode(left.Member);
             hash = hash * 31 + RuntimeHelpers.GetHashCode(left.Member.SyntaxTree);
             hash = hash * 31 + left.Attribute.GetHashCode();
-
+            hash = hash * 31 + left.GlobalOptions.GetHashCode();
+
             // Incorporate compilation external references to align with Equals
             var references = compilation.ExternalReferences;
             var referencesHash = 17;
@@ -72,7 +80,7 @@ public int GetHashCode(((MemberDeclarationSyntax Member, ProjectableAttributeDat
                 referencesHash = referencesHash * 31 + RuntimeHelpers.GetHashCode(reference);
             }
             hash = hash * 31 + referencesHash;
-            
+
             return hash;
         }
     }

src/EntityFrameworkCore.Projectables.Generator/Interpretation/ProjectableInterpreter.cs

@@ -13,14 +13,18 @@ static internal partial class ProjectableInterpreter
         MemberDeclarationSyntax member,
         ISymbol memberSymbol,
         ProjectableAttributeData projectableAttribute,
+        ProjectableGlobalOptions globalOptions,
         SourceProductionContext context,
         Compilation? compilation = null)
     {
-        // Read directly from the struct fields
-        var nullConditionalRewriteSupport = projectableAttribute.NullConditionalRewriteSupport;
+        // Resolve effective values: per-attribute wins, then global MSBuild default, then hard-coded fallback.
+        var nullConditionalRewriteSupport =
+            projectableAttribute.NullConditionalRewriteSupport ?? globalOptions.NullConditionalRewriteSupport ?? default;
         var useMemberBody = projectableAttribute.UseMemberBody;
-        var expandEnumMethods = projectableAttribute.ExpandEnumMethods;
-        var allowBlockBody = projectableAttribute.AllowBlockBody;
+        var expandEnumMethods =
+            projectableAttribute.ExpandEnumMethods ?? globalOptions.ExpandEnumMethods ?? false;
+        var allowBlockBody =
+            projectableAttribute.AllowBlockBody ?? globalOptions.AllowBlockBody ?? false;
 
         // 1. Resolve the member body (handles UseMemberBody redirection)
         var memberBody = TryResolveMemberBody(member, memberSymbol, useMemberBody, context);

src/EntityFrameworkCore.Projectables.Generator/Models/ProjectableAttributeData.cs

@@ -4,21 +4,23 @@ namespace EntityFrameworkCore.Projectables.Generator.Models;
 
 /// <summary>
 /// Plain-data snapshot of the [Projectable] attribute arguments.
+/// Nullable option fields are <c>null</c> when the named argument was absent from the attribute,
+/// meaning the global MSBuild default (or hard-coded fallback) should be used instead.
 /// </summary>
 readonly internal record struct ProjectableAttributeData
 {
-    public NullConditionalRewriteSupport NullConditionalRewriteSupport { get; }
+    public NullConditionalRewriteSupport? NullConditionalRewriteSupport { get; }
     public string? UseMemberBody { get; }
-    public bool ExpandEnumMethods { get; }
-    public bool AllowBlockBody { get; }
-    
+    public bool? ExpandEnumMethods { get; }
+    public bool? AllowBlockBody { get; }
+
     public ProjectableAttributeData(AttributeData attribute)
     {
-        var nullConditionalRewriteSupport = default(NullConditionalRewriteSupport);
+        NullConditionalRewriteSupport? nullConditionalRewriteSupport = null;
         string? useMemberBody = null;
-        var expandEnumMethods = false;
-        var allowBlockBody = false;
-        
+        bool? expandEnumMethods = null;
+        bool? allowBlockBody = null;
+
         foreach (var namedArgument in attribute.NamedArguments)
         {
             var key = namedArgument.Key;
@@ -40,23 +42,23 @@ value.Value is not null &&
                     }
                     break;
                 case nameof(ExpandEnumMethods):
-                    if (value.Value is bool expand && expand)
+                    if (value.Value is bool expand)
                     {
-                        expandEnumMethods = true;
+                        expandEnumMethods = expand;
                     }
                     break;
                 case nameof(AllowBlockBody):
-                    if (value.Value is bool allow && allow)
+                    if (value.Value is bool allow)
                     {
-                        allowBlockBody = true;
+                        allowBlockBody = allow;
                     }
                     break;
             }
         }
-        
+
         NullConditionalRewriteSupport = nullConditionalRewriteSupport;
         UseMemberBody = useMemberBody;
         ExpandEnumMethods = expandEnumMethods;
         AllowBlockBody = allowBlockBody;
     }
-}
+}

src/EntityFrameworkCore.Projectables.Generator/Models/ProjectableGlobalOptions.cs

@@ -0,0 +1,37 @@
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace EntityFrameworkCore.Projectables.Generator.Models;
+
+/// <summary>
+/// Plain-data snapshot of the MSBuild global defaults for [Projectable] options.
+/// Read from <c>build_property.*</c> entries in <c>AnalyzerConfigOptions.GlobalOptions</c>.
+/// <c>null</c> means the property was not set (no global override).
+/// </summary>
+readonly internal record struct ProjectableGlobalOptions
+{
+    public NullConditionalRewriteSupport? NullConditionalRewriteSupport { get; }
+    public bool? ExpandEnumMethods { get; }
+    public bool? AllowBlockBody { get; }
+
+    public ProjectableGlobalOptions(AnalyzerConfigOptions globalOptions)
+    {
+        if (globalOptions.TryGetValue("build_property.Projectables_NullConditionalRewriteSupport", out var nullConditionalStr)
+            && !string.IsNullOrEmpty(nullConditionalStr)
+            && Enum.TryParse<NullConditionalRewriteSupport>(nullConditionalStr, ignoreCase: true, out var nullConditional))
+        {
+            NullConditionalRewriteSupport = nullConditional;
+        }
+
+        if (globalOptions.TryGetValue("build_property.Projectables_ExpandEnumMethods", out var expandStr)
+            && bool.TryParse(expandStr, out var expand))
+        {
+            ExpandEnumMethods = expand;
+        }
+
+        if (globalOptions.TryGetValue("build_property.Projectables_AllowBlockBody", out var allowStr)
+            && bool.TryParse(allowStr, out var allow))
+        {
+            AllowBlockBody = allow;
+        }
+    }
+}

src/EntityFrameworkCore.Projectables.Generator/ProjectionExpressionGenerator.cs

@@ -38,6 +38,10 @@ public class ProjectionExpressionGenerator : IIncrementalGenerator
 
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
+        // Snapshot global MSBuild defaults once per generator run.
+        var globalOptions = context.AnalyzerConfigOptionsProvider
+            .Select(static (opts, _) => new ProjectableGlobalOptions(opts.GlobalOptions));
+
         // Extract only pure stable data from the attribute in the transform.
         // No live Roslyn objects (no AttributeData, SemanticModel, Compilation, ISymbol) —
         // those are always new instances and defeat incremental caching entirely.
@@ -50,14 +54,23 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     Attribute: new ProjectableAttributeData(c.Attributes[0])
                 ));
 
-        var compilationAndMemberPairs = memberDeclarations
+        // Flatten (Member, Attribute) + GlobalOptions into a single named tuple.
+        var memberDeclarationsWithGlobalOptions = memberDeclarations
+            .Combine(globalOptions)
+            .Select(static (pair, _) => (
+                Member: pair.Left.Member,
+                Attribute: pair.Left.Attribute,
+                GlobalOptions: pair.Right
+            ));
+
+        var compilationAndMemberPairs = memberDeclarationsWithGlobalOptions
             .Combine(context.CompilationProvider)
             .WithComparer(new MemberDeclarationSyntaxAndCompilationEqualityComparer());
 
         context.RegisterSourceOutput(compilationAndMemberPairs,
             static (spc, source) =>
             {
-                var ((member, attribute), compilation) = source;
+                var ((member, attribute, globalOptions), compilation) = source;
                 var semanticModel = compilation.GetSemanticModel(member.SyntaxTree);
                 var memberSymbol = semanticModel.GetDeclaredSymbol(member);
 
@@ -66,13 +79,13 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     return;
                 }
 
-                Execute(member, semanticModel, memberSymbol, attribute, compilation, spc);
+                Execute(member, semanticModel, memberSymbol, attribute, globalOptions, compilation, spc);
             });
 
         // Build the projection registry: collect all entries and emit a single registry file
         var registryEntries = compilationAndMemberPairs.Select(
             static (source, cancellationToken) => {
-                var ((member, _), compilation) = source;
+                var ((member, _, _), compilation) = source;
 
                 var semanticModel = compilation.GetSemanticModel(member.SyntaxTree);
                 var memberSymbol = semanticModel.GetDeclaredSymbol(member, cancellationToken);
@@ -170,11 +183,12 @@ private static void Execute(
         SemanticModel semanticModel,
         ISymbol memberSymbol,
         ProjectableAttributeData projectableAttribute,
+        ProjectableGlobalOptions globalOptions,
         Compilation? compilation,
         SourceProductionContext context)
     {
         var projectable = ProjectableInterpreter.GetDescriptor(
-            semanticModel, member, memberSymbol, projectableAttribute, context, compilation);
+            semanticModel, member, memberSymbol, projectableAttribute, globalOptions, context, compilation);
 
         if (projectable is null)
         {