Merge pull request #175 from koenbeuk/feature/memberbody-stricter

UseMemberBody more strict with expressions

Author: PhenX

README.md

@@ -316,7 +316,7 @@ Multiple `[Projectable]` constructors (overloads) per class are fully supported.
 
 #### Can I redirect the expression body to a different member with `UseMemberBody`?
 
-Yes! The `UseMemberBody` property on `[Projectable]` lets you redirect the source of the generated expression to a *different* member on the same type (and in the same file). 
+Yes! The `UseMemberBody` property on `[Projectable]` lets you redirect the source of the generated expression to a *different* member on the same type.
 
 This is useful when you want to:
 
@@ -343,6 +343,8 @@ public class Entity
 
 The generated expression is `(@this) => @this.Id * 2`, so `Computed` projects as `Id * 2` in SQL even though the arrow body says `Id`.
 
+> **Note:** When delegating to a regular method or property body the target member must be declared in the **same source file** as the `[Projectable]` member so the generator can read its body.
+
 ##### Using an `Expression<Func<...>>` property as the body
 
 For even more control you can supply the body as a typed `Expression<Func<...>>` property. This lets you write the expression once and reuse it from both the `[Projectable]` member and any runtime code that needs the expression tree directly:
@@ -360,9 +362,26 @@ public class Entity
 }
 ```
 
-> **Note:** When the projectable member is a *property*, the `Expression<Func<...>>` property body is handled entirely by the runtime resolver — no extra source is generated. This works transparently.
+Unlike regular method/property delegation, `Expression<Func<...>>` backing properties may be declared in a **different file** — for example in a separate part of a `partial class`:
+
+```csharp
+// File: Entity.cs
+public partial class Entity
+{
+    public int Id { get; set; }
 
-For **instance methods**, name the lambda parameter `@this` so that it matches the generator's own naming convention:
+    [Projectable(UseMemberBody = nameof(IdDoubledExpr))]
+    public int Computed => Id;
+}
+
+// File: Entity.Expressions.cs
+public partial class Entity
+{
+    private static Expression<Func<Entity, int>> IdDoubledExpr => @this => @this.Id * 2;
+}
+```
+
+For **instance methods**, the generator automatically aligns lambda parameter names with the method's own parameter names, so you are free to choose any names in the lambda. Using `@this` for the receiver is conventional and avoids any renaming:
 
 ```csharp
 public class Entity
@@ -372,10 +391,19 @@ public class Entity
     [Projectable(UseMemberBody = nameof(IsPositiveExpr))]
     public bool IsPositive() => Value > 0;
 
+    // Any receiver name works; @this is conventional
     private static Expression<Func<Entity, bool>> IsPositiveExpr => @this => @this.Value > 0;
 }
 ```
 
+If the lambda parameter names differ from the method's parameter names the generator renames them automatically:
+
+```csharp
+// Lambda uses (c, t) but method parameter is named threshold — generated code uses threshold
+private static Expression<Func<Entity, int, bool>> ExceedsThresholdExpr =>
+    (c, t) => c.Value > t;
+```
+
 ##### Static extension methods
 
 `UseMemberBody` works equally well on static extension methods. Name the lambda parameters to match the method's parameter names:

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

@@ -0,0 +1,98 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace EntityFrameworkCore.Projectables.Generator;
+
+public static partial class ProjectableInterpreter
+{
+    /// <summary>
+    /// Visits <paramref name="parameterList"/> through <paramref name="rewriter"/> and appends
+    /// all resulting parameters to <see cref="ProjectableDescriptor.ParametersList"/>.
+    /// </summary>
+    private static void ApplyParameterList(
+        ParameterListSyntax parameterList,
+        DeclarationSyntaxRewriter rewriter,
+        ProjectableDescriptor descriptor)
+    {
+        foreach (var p in ((ParameterListSyntax)rewriter.Visit(parameterList)).Parameters)
+        {
+            descriptor.ParametersList = descriptor.ParametersList!.AddParameters(p);
+        }
+    }
+
+    /// <summary>
+    /// Visits the type-parameter list and constraint clauses of <paramref name="methodDecl"/>
+    /// through <paramref name="rewriter"/> and stores them on <paramref name="descriptor"/>.
+    /// </summary>
+    private static void ApplyTypeParameters(
+        MethodDeclarationSyntax methodDecl,
+        DeclarationSyntaxRewriter rewriter,
+        ProjectableDescriptor descriptor)
+    {
+        if (methodDecl.TypeParameterList is not null)
+        {
+            descriptor.TypeParameterList = SyntaxFactory.TypeParameterList();
+            foreach (var tp in ((TypeParameterListSyntax)rewriter.Visit(methodDecl.TypeParameterList)).Parameters)
+            {
+                descriptor.TypeParameterList = descriptor.TypeParameterList.AddParameters(tp);
+            }
+        }
+
+        if (methodDecl.ConstraintClauses.Any())
+        {
+            descriptor.ConstraintClauses = SyntaxFactory.List(
+                methodDecl.ConstraintClauses
+                    .Select(x => (TypeParameterConstraintClauseSyntax)rewriter.Visit(x)));
+        }
+    }
+
+    /// <summary>
+    /// Returns the readable getter expression from a property declaration, trying in order:
+    /// the property-level expression-body, the getter's expression-body, then the first
+    /// <see langword="return"/> expression in a block-bodied getter.
+    /// Returns <c>null</c> when none of these are present.
+    /// </summary>
+    private static ExpressionSyntax? TryGetPropertyGetterExpression(PropertyDeclarationSyntax prop)
+    {
+        if (prop.ExpressionBody?.Expression is { } exprBody)
+        {
+            return exprBody;
+        }
+
+        if (prop.AccessorList is not null)
+        {
+            var getter = prop.AccessorList.Accessors
+                .FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
+
+            if (getter?.ExpressionBody?.Expression is { } getterExpr)
+            {
+                return getterExpr;
+            }
+
+            if (getter?.Body?.Statements.OfType<ReturnStatementSyntax>().FirstOrDefault()?.Expression is { } returnExpr)
+            {
+                return returnExpr;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Reports <see cref="Diagnostics.RequiresBodyDefinition"/> for <paramref name="node"/>
+    /// and returns <c>false</c> so callers can write <c>return ReportRequiresBodyAndFail(…)</c>.
+    /// </summary>
+    private static bool ReportRequiresBodyAndFail(
+        SourceProductionContext context,
+        SyntaxNode node,
+        string memberName)
+    {
+        context.ReportDiagnostic(Diagnostic.Create(
+            Diagnostics.RequiresBodyDefinition,
+            node.GetLocation(),
+            memberName));
+        return false;
+    }
+}
+

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

@@ -67,64 +67,133 @@ x is IPropertySymbol xProperty &&
         }).ToList();
 
         // Expression-property candidates: a property returning Expression<TDelegate>.
-        // Supported in the generator only when the projectable member is a method.
-        // When the projectable member is a property, the runtime resolver handles it.
-        var exprPropertyCandidates = memberSymbol is IMethodSymbol
-            ? allCandidates.Where(IsExpressionDelegateProperty).ToList()
-            : [];
-
-        // Filter Expression<TDelegate> candidates whose Func generic-argument count is
-        // compatible with the projectable method's parameter list.
+        // Supported in the generator for both projectable methods and projectable properties.
+        var exprPropertyCandidates = allCandidates.Where(IsExpressionDelegateProperty).ToList();
+
+        // Filter Expression<TDelegate> candidates whose Func generic-argument count, return type,
+        // and parameter types are all compatible with the projectable member's signature.
         List<ISymbol> compatibleExprPropertyCandidates = [];
-        if (exprPropertyCandidates.Count > 0 && memberSymbol is IMethodSymbol exprCheckMethod)
+        if (exprPropertyCandidates.Count > 0)
         {
-            var isExtensionBlock = memberSymbol.ContainingType is { IsExtension: true };
-            var hasImplicitThis = !exprCheckMethod.IsStatic || isExtensionBlock;
-            var expectedFuncArgCount = exprCheckMethod.Parameters.Length + (hasImplicitThis ? 2 : 1);
-
-            compatibleExprPropertyCandidates = exprPropertyCandidates.Where(x =>
+            if (memberSymbol is IMethodSymbol exprCheckMethod)
             {
-                if (x is not IPropertySymbol propSym)
-                {
-                    return false;
-                }
+                var isExtensionBlock = memberSymbol.ContainingType is { IsExtension: true };
+                var hasImplicitThis = !exprCheckMethod.IsStatic || isExtensionBlock;
+                var expectedFuncArgCount = exprCheckMethod.Parameters.Length + (hasImplicitThis ? 2 : 1);
 
-                if (propSym.Type is not INamedTypeSymbol exprType || exprType.TypeArguments.Length != 1)
+                // Determine the expected receiver type when hasImplicitThis is true.
+                // For extension-block members the receiver is the extension parameter's type;
+                // for ordinary instance methods it is the containing type.
+                ITypeSymbol? expectedReceiverType = null;
+                if (hasImplicitThis)
                 {
-                    return false;
+                    expectedReceiverType = isExtensionBlock
+                        ? exprCheckMethod.ContainingType.ExtensionParameter?.Type
+                        : exprCheckMethod.ContainingType;
                 }
 
-                if (exprType.TypeArguments[0] is not INamedTypeSymbol delegateType)
+                compatibleExprPropertyCandidates = exprPropertyCandidates.Where(x =>
                 {
-                    return false;
-                }
+                    if (x is not IPropertySymbol propSym)
+                    {
+                        return false;
+                    }
 
-                return delegateType.TypeArguments.Length == expectedFuncArgCount;
-            }).ToList();
-        }
+                    if (propSym.Type is not INamedTypeSymbol exprType || exprType.TypeArguments.Length != 1)
+                    {
+                        return false;
+                    }
 
-        // Step 3: if no generator-handled candidates exist, diagnose or skip
-        if (regularCompatible.Count == 0 && compatibleExprPropertyCandidates.Count == 0)
-        {
-            // Expression properties were found but all have incompatible Func signatures.
-            if (exprPropertyCandidates.Count > 0)
-            {
-                context.ReportDiagnostic(Diagnostic.Create(
-                    Diagnostics.UseMemberBodyIncompatible,
-                    member.GetLocation(),
-                    memberSymbol.Name,
-                    useMemberBody));
-                return null;
-            }
+                    if (exprType.TypeArguments[0] is not INamedTypeSymbol delegateType)
+                    {
+                        return false;
+                    }
+
+                    if (delegateType.TypeArguments.Length != expectedFuncArgCount)
+                    {
+                        return false;
+                    }
+
+                    // Receiver-type check: when hasImplicitThis is true, TypeArguments[0] must match
+                    // the implicit receiver — the containing type for instance methods, or the extension
+                    // receiver type for extension-block members.
+                    if (hasImplicitThis && expectedReceiverType is not null)
+                    {
+                        if (!comparer.Equals(delegateType.TypeArguments[0], expectedReceiverType))
+                        {
+                            return false;
+                        }
+                    }
+
+                    // Return-type check: the last type argument of the delegate must match the method's return type.
+                    var delegateReturnType = delegateType.TypeArguments[delegateType.TypeArguments.Length - 1];
+                    if (!comparer.Equals(delegateReturnType, exprCheckMethod.ReturnType))
+                    {
+                        return false;
+                    }
+
+                    // Parameter-type checks: each explicit parameter type must match.
+                    // When hasImplicitThis is true, TypeArguments[0] is the implicit receiver — skip it.
+                    var paramOffset = hasImplicitThis ? 1 : 0;
+                    for (var i = 0; i < exprCheckMethod.Parameters.Length; i++)
+                    {
+                        if (!comparer.Equals(delegateType.TypeArguments[paramOffset + i], exprCheckMethod.Parameters[i].Type))
+                        {
+                            return false;
+                        }
+                    }
 
-            // A projectable *property* backed by an Expression<TDelegate> property is
-            // handled at runtime by ProjectionExpressionResolver; skip silently so the
-            // runtime path can take over without a spurious error.
-            if (memberSymbol is IPropertySymbol && allCandidates.Any(IsExpressionDelegateProperty))
+                    return true;
+                }).ToList();
+            }
+            else if (memberSymbol is IPropertySymbol exprCheckProperty)
             {
-                return null;
+                // Instance property: Func<ContainingType, PropType> — 2 type arguments.
+                // Static property:   Func<PropType>                  — 1 type argument.
+                var expectedFuncArgCount = exprCheckProperty.IsStatic ? 1 : 2;
+
+                compatibleExprPropertyCandidates = exprPropertyCandidates.Where(x =>
+                {
+                    if (x is not IPropertySymbol propSym)
+                    {
+                        return false;
+                    }
+
+                    if (propSym.Type is not INamedTypeSymbol exprType || exprType.TypeArguments.Length != 1)
+                    {
+                        return false;
+                    }
+
+                    if (exprType.TypeArguments[0] is not INamedTypeSymbol delegateType)
+                    {
+                        return false;
+                    }
+
+                    if (delegateType.TypeArguments.Length != expectedFuncArgCount)
+                    {
+                        return false;
+                    }
+
+                    // For instance properties, the first delegate type argument must be the containing type
+                    // (the implicit receiver).
+                    if (!exprCheckProperty.IsStatic)
+                    {
+                        var receiverType = delegateType.TypeArguments[0];
+                        if (!comparer.Equals(receiverType, exprCheckProperty.ContainingType))
+                        {
+                            return false;
+                        }
+                    }
+                    // Return-type check: the last type argument of the delegate must match the property type.
+                    var delegateReturnType = delegateType.TypeArguments[delegateType.TypeArguments.Length - 1];
+                    return comparer.Equals(delegateReturnType, exprCheckProperty.Type);
+                }).ToList();
             }
+        }
 
+        // Step 3: if no generator-handled candidates exist, diagnose
+        if (regularCompatible.Count == 0 && compatibleExprPropertyCandidates.Count == 0)
+        {
             context.ReportDiagnostic(Diagnostic.Create(
                 Diagnostics.UseMemberBodyIncompatible,
                 member.GetLocation(),
@@ -165,6 +234,9 @@ x is IPropertySymbol xProperty &&
         // These don't need to share the member's static modifier because a
         // static Expression<Func<...>> property can legitimately back either
         // a static or an instance projectable method.
+        // They are also allowed to live in a different file (e.g. a split partial class):
+        // a direct lambda body can be extracted purely syntactically without a shared
+        // SemanticModel; the runtime fallback handles any cases the generator can't inline.
         if (resolvedBody is null && compatibleExprPropertyCandidates.Count > 0)
         {
             resolvedBody = compatibleExprPropertyCandidates
@@ -173,7 +245,7 @@ x is IPropertySymbol xProperty &&
                 .OfType<MemberDeclarationSyntax>()
                 .FirstOrDefault(x =>
                 {
-                    if (x == null || x.SyntaxTree != member.SyntaxTree)
+                    if (x == null)
                     {
                         return false;
                     }
@@ -198,25 +270,17 @@ x is IPropertySymbol xProperty &&
     }
 
     /// <summary>Returns true when a <see cref="PropertyDeclarationSyntax"/> has a readable body.</summary>
-    private static bool HasReadablePropertyBody(PropertyDeclarationSyntax xProp)
+    private static bool HasReadablePropertyBody(PropertyDeclarationSyntax prop)
     {
-        if (xProp.ExpressionBody is not null)
+        if (prop.ExpressionBody is not null)
         {
             return true;
         }
 
-        if (xProp.AccessorList is not null)
-        {
-            var getter = xProp.AccessorList.Accessors
-                .FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
-
-            if (getter?.ExpressionBody is not null || getter?.Body is not null)
-            {
-                return true;
-            }
-        }
-
-        return false;
+        var getter = prop.AccessorList?.Accessors
+            .FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
+        
+        return getter?.ExpressionBody is not null || getter?.Body is not null;
     }
 
     /// <summary>Returns true when a symbol is a property returning <c>Expression&lt;TDelegate&gt;</c>.</summary>