fixed compat with PolyfillInterceptor

Author: koenbeuk

src/ExpressiveSharp.Generator/Emitter/SynthesizedPropertyEmitter.cs

@@ -14,6 +14,16 @@ namespace ExpressiveSharp.Generator.Emitter;
 static internal class SynthesizedPropertyEmitter
 {
     public static void Emit(SynthesizedPropertySpec spec, string generatedFileName, SourceProductionContext context)
+    {
+        var source = BuildSource(spec);
+        context.AddSource(generatedFileName, SourceText.From(source, Encoding.UTF8));
+    }
+
+    /// <summary>
+    /// Produces the synthesized partial-class C# source as a string. Pure function of the spec —
+    /// safe to call from incremental pipeline transforms (no <see cref="SourceProductionContext"/> required).
+    /// </summary>
+    public static string BuildSource(SynthesizedPropertySpec spec)
     {
         var sb = new StringBuilder();
         sb.AppendLine("// <auto-generated/>");
@@ -57,7 +67,7 @@ public static void Emit(SynthesizedPropertySpec spec, string generatedFileName,
             sb.AppendLine("}");
         }
 
-        context.AddSource(generatedFileName, SourceText.From(sb.ToString(), Encoding.UTF8));
+        return sb.ToString();
     }
 
     private static string BuildCoalesceBody(SynthesizedPropertySpec spec, string indent)

src/ExpressiveSharp.Generator/Interpretation/ExpressivePropertyInterpreter.cs

@@ -130,6 +130,54 @@ public static (ExpressiveDescriptor Descriptor, SynthesizedPropertySpec Spec)? G
         return (descriptor, spec);
     }
 
+    /// <summary>
+    /// Builds the <see cref="SynthesizedPropertySpec"/> for a stub if it passes the same validation
+    /// rules as <see cref="GetDescriptor"/>, but reports no diagnostics. Used by
+    /// <c>PolyfillInterceptorGenerator</c> to compute the synthesized partial-class source for
+    /// in-memory compilation augmentation; diagnostic ownership stays with <see cref="GetDescriptor"/>
+    /// inside <c>ExpressiveGenerator</c>.
+    /// </summary>
+    public static SynthesizedPropertySpec? TryBuildSpec(
+        PropertyDeclarationSyntax stubProperty,
+        IPropertySymbol stubSymbol,
+        ExpressivePropertyAttributeData attributeData)
+    {
+        var targetName = attributeData.TargetName;
+        if (string.IsNullOrWhiteSpace(targetName)) return null;
+        if (stubSymbol.IsStatic) return null;
+        if (stubProperty.ExpressionBody is null) return null;
+
+        var containingType = stubSymbol.ContainingType;
+        if (!IsPartialType(containingType)) return null;
+
+        if (containingType.GetMembers(targetName!).Any(m =>
+            m is IPropertySymbol or IMethodSymbol or IFieldSymbol or IEventSymbol))
+            return null;
+
+        if (FindInheritedMember(containingType, targetName!) is not null) return null;
+
+        var returnType = stubSymbol.Type;
+        var useTernary = IsNullablePropertyType(returnType);
+        var propertyTypeFqn = returnType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+        var backingFieldTypeFqn = useTernary ? propertyTypeFqn : MakeNullableTypeFqn(returnType);
+
+        return new SynthesizedPropertySpec
+        {
+            PropertyTypeFqn = propertyTypeFqn,
+            PropertyName = targetName!,
+            StubMemberName = stubSymbol.Name,
+            StubIsMethod = false,
+            UseTernaryShape = useTernary,
+            BackingFieldTypeFqn = backingFieldTypeFqn,
+            ContainingTypeName = containingType.Name,
+            ContainingTypeNamespace = containingType.ContainingNamespace.IsGlobalNamespace
+                ? null
+                : containingType.ContainingNamespace.ToDisplayString(),
+            ContainingTypePath = GetNestedInClassPath(containingType).ToList(),
+            ContainingTypeKeyword = GetTypeKeyword(containingType),
+        };
+    }
+
     private static ExpressiveDescriptor? BuildDescriptor(
         SemanticModel semanticModel,
         SourceProductionContext context,

src/ExpressiveSharp.Generator/PolyfillInterceptorGenerator.cs

@@ -1,8 +1,13 @@
+using System.Collections.Immutable;
 using System.Text;
+using ExpressiveSharp.Generator.Emitter;
 using ExpressiveSharp.Generator.Infrastructure;
+using ExpressiveSharp.Generator.Interpretation;
+using ExpressiveSharp.Generator.Models;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.Text;
 
 namespace ExpressiveSharp.Generator;
@@ -26,6 +31,8 @@ public class PolyfillInterceptorGenerator : IIncrementalGenerator
     private const string PolyfillTypeName = "ExpressiveSharp.ExpressionPolyfill";
     private const string PolyfillMethodName = "Create";
 
+    private const string ExpressivePropertyAttributeName = "ExpressiveSharp.Mapping.ExpressivePropertyAttribute";
+
     private const string ClosureHelperSource = """
 
                 file static class __ClosureHelper
@@ -133,11 +140,55 @@ inv.Expression is MemberAccessExpressionSyntax &&
             .Combine(context.CompilationProvider)
             .WithComparer(CompilationUnitAndCompilationComparer.Instance);
 
+        // ── Synthesized-property sources for compilation augmentation ─────────────
+        //
+        // [ExpressiveProperty]-decorated stubs cause ExpressiveGenerator to emit a partial-class
+        // file declaring the synthesized property (e.g. Rectangle.IsSquareProp). Roslyn source
+        // generators all run against the SAME input compilation — one generator never sees
+        // another's AddSource output — so without help, the SemanticModel below cannot bind
+        // references to synthesized properties inside intercepted lambdas. We mirror the
+        // synthesis pipeline here, producing the same partial-class source strings, and use
+        // them to augment the in-memory compilation just for binding (we do NOT call AddSource
+        // — ExpressiveGenerator owns the user-visible emission).
+        var synthesizedDeclarations = context.SyntaxProvider
+            .ForAttributeWithMetadataName(
+                ExpressivePropertyAttributeName,
+                predicate: static (s, _) => s is PropertyDeclarationSyntax,
+                transform: static (c, _) => (
+                    Stub: (PropertyDeclarationSyntax)c.TargetNode,
+                    Attribute: new ExpressivePropertyAttributeData(c.Attributes[0])
+                ));
+
+        var synthesizedSources = synthesizedDeclarations
+            .Combine(context.CompilationProvider)
+            .Select(static (pair, ct) =>
+            {
+                ct.ThrowIfCancellationRequested();
+                var ((stub, attribute), compilation) = pair;
+                var semanticModel = compilation.GetSemanticModel(stub.SyntaxTree);
+                if (semanticModel.GetDeclaredSymbol(stub, ct) is not IPropertySymbol stubSymbol)
+                    return default;
+
+                var spec = ExpressivePropertyInterpreter.TryBuildSpec(stub, stubSymbol, attribute);
+                if (spec is null) return default;
+
+                var hint = $"{spec.ContainingTypeName}.{spec.PropertyName}.Synthesized.augment.cs";
+                var source = SynthesizedPropertyEmitter.BuildSource(spec);
+                return (HintName: hint, Source: source);
+            })
+            .Where(static t => t.Source is not null)
+            .Collect()
+            .WithComparer(SynthesizedSourceArrayComparer.Instance);
+
+        var filesWithCompilationAndSynth = filesWithCompilation
+            .Combine(synthesizedSources)
+            .WithComparer(FileAndSynthesizedSourcesComparer.Instance);
+
         // All semantic analysis, code emission, and EXP_EMIT_FAILED diagnostic reporting
         // happen inside ProcessFileAndEmit. One output file is produced per source file,
         // containing all interceptors for that file.
-        context.RegisterSourceOutput(filesWithCompilation,
-            static (spc, pair) => ProcessFileAndEmit(pair.Left, pair.Right, spc));
+        context.RegisterSourceOutput(filesWithCompilationAndSynth,
+            static (spc, pair) => ProcessFileAndEmit(pair.Left.Left, pair.Left.Right, pair.Right, spc));
     }
 
     // ── Per-file processing and emission ────────────────────────────────────
@@ -151,10 +202,33 @@ inv.Expression is MemberAccessExpressionSyntax &&
     private static void ProcessFileAndEmit(
         CompilationUnitSyntax unit,
         Compilation compilation,
+        ImmutableArray<(string HintName, string Source)> synthesizedSources,
         SourceProductionContext spc)
     {
         var ct = spc.CancellationToken;
-        var model = compilation.GetSemanticModel(unit.SyntaxTree);
+
+        // Augment the compilation in-memory with the synthesized partial-class declarations
+        // (one per [ExpressiveProperty] stub). The augmented Compilation is local to this
+        // emitter — it never escapes via AddSource — so there is no double-emission. Without
+        // this, the SemanticModel below cannot bind references like `Rectangle { IsSquareProp: ... }`
+        // because ExpressiveGenerator's synthesized property is invisible to this generator.
+        var modelCompilation = compilation;
+        if (synthesizedSources.Length > 0)
+        {
+            var parseOptions = compilation.SyntaxTrees.FirstOrDefault()?.Options as CSharpParseOptions
+                ?? CSharpParseOptions.Default;
+            var trees = new SyntaxTree[synthesizedSources.Length];
+            for (var i = 0; i < synthesizedSources.Length; i++)
+            {
+                trees[i] = CSharpSyntaxTree.ParseText(
+                    synthesizedSources[i].Source,
+                    parseOptions,
+                    cancellationToken: ct);
+            }
+            modelCompilation = compilation.AddSyntaxTrees(trees);
+        }
+
+        var model = modelCompilation.GetSemanticModel(unit.SyntaxTree);
         var sourcePath = unit.SyntaxTree.FilePath;
         var fileTag = GetFileTag(sourcePath);
 
@@ -453,6 +527,22 @@ private static string GetFileTag(string sourcePath)
         var bodyNode = lambda.Body is ExpressionSyntax expr ? (SyntaxNode)expr : lambda.Body;
         if (bodyNode is null) return null;
 
+        // Pre-check: if Roslyn can't bind something in the body (e.g. a synthesized member that
+        // isn't visible to this generator's compilation), the IOperation tree contains
+        // IInvalidOperation nodes and the emitted expression tree would be garbage. Surface
+        // EXP0010 so the user notices instead of silently falling back to the delegate stub.
+        // We don't fail on a null IOperation — that can mean transparent syntax that the
+        // emitter unwraps separately, not a binding failure.
+        var bodyOperation = model.GetOperation(bodyNode);
+        if (bodyOperation is not null && ContainsInvalidOperation(bodyOperation))
+        {
+            spc.ReportDiagnostic(Diagnostic.Create(
+                Diagnostics.InterceptorEmissionFailed,
+                lambda.GetLocation(),
+                "lambda body contains unresolvable references — the original delegate stub will be used at runtime"));
+            return null;
+        }
+
         var emitter = new Emitter.ExpressionTreeEmitter(model, spc, varPrefix: varPrefix, delegateVarName: delegateVarName);
 
         if (typeAliases is not null)
@@ -523,6 +613,20 @@ private static string GetFileTag(string sourcePath)
     private static bool IsAnonymousType(ITypeSymbol type)
         => type is INamedTypeSymbol { IsAnonymousType: true };
 
+    /// <summary>
+    /// Walks an <see cref="IOperation"/> tree looking for any <c>IInvalidOperation</c>, which
+    /// Roslyn produces when binding fails (unknown member, malformed reference, etc.).
+    /// </summary>
+    private static bool ContainsInvalidOperation(IOperation op)
+    {
+        if (op is IInvalidOperation) return true;
+        foreach (var child in op.ChildOperations)
+        {
+            if (ContainsInvalidOperation(child)) return true;
+        }
+        return false;
+    }
+
     // ── Formatting helpers ───────────────────────────────────────────────────
 
     private static bool HasLambdaArgument(InvocationExpressionSyntax inv)
@@ -945,4 +1049,84 @@ public bool Equals(
         public int GetHashCode((CompilationUnitSyntax Left, Compilation Right) obj)
             => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj.Left);
     }
+
+    // ── SynthesizedSourceArrayComparer ─────────────────────────────────────────
+
+    /// <summary>
+    /// Sequence-equality on the collected (HintName, Source) pairs from the synthesized-property
+    /// pipeline. ImmutableArray's default equality is reference, so without this comparer Roslyn
+    /// would treat every regenerated array as distinct and invalidate every downstream consumer
+    /// on every input edit.
+    /// </summary>
+    private sealed class SynthesizedSourceArrayComparer
+        : IEqualityComparer<ImmutableArray<(string HintName, string Source)>>
+    {
+        public readonly static SynthesizedSourceArrayComparer Instance = new();
+
+        private SynthesizedSourceArrayComparer() { }
+
+        public bool Equals(
+            ImmutableArray<(string HintName, string Source)> x,
+            ImmutableArray<(string HintName, string Source)> y)
+        {
+            if (x.Length != y.Length) return false;
+            for (var i = 0; i < x.Length; i++)
+            {
+                if (x[i].HintName != y[i].HintName) return false;
+                if (x[i].Source != y[i].Source) return false;
+            }
+            return true;
+        }
+
+        public int GetHashCode(ImmutableArray<(string HintName, string Source)> obj)
+        {
+            unchecked
+            {
+                var hash = 17;
+                for (var i = 0; i < obj.Length; i++)
+                {
+                    hash = hash * 31 + (obj[i].HintName?.GetHashCode() ?? 0);
+                    hash = hash * 31 + (obj[i].Source?.GetHashCode() ?? 0);
+                }
+                return hash;
+            }
+        }
+    }
+
+    // ── FileAndSynthesizedSourcesComparer ──────────────────────────────────────
+
+    /// <summary>
+    /// Combined comparer for the per-file pipeline + synthesized-source array. ANDs the existing
+    /// <see cref="CompilationUnitAndCompilationComparer"/> reference-equality on the file root with
+    /// sequence-equality on the synthesized array.
+    ///
+    /// <para>
+    /// Editing a file with no <c>[ExpressiveProperty]</c> change → file ref unchanged AND array
+    /// unchanged → skip. Editing an <c>[ExpressiveProperty]</c> attribute → array changes → all
+    /// files re-emit (correct: synthesized binding may affect any file's lambdas).
+    /// </para>
+    /// </summary>
+    private sealed class FileAndSynthesizedSourcesComparer
+        : IEqualityComparer<((CompilationUnitSyntax Left, Compilation Right) Left, ImmutableArray<(string HintName, string Source)> Right)>
+    {
+        public readonly static FileAndSynthesizedSourcesComparer Instance = new();
+
+        private FileAndSynthesizedSourcesComparer() { }
+
+        public bool Equals(
+            ((CompilationUnitSyntax Left, Compilation Right) Left, ImmutableArray<(string HintName, string Source)> Right) x,
+            ((CompilationUnitSyntax Left, Compilation Right) Left, ImmutableArray<(string HintName, string Source)> Right) y)
+            => CompilationUnitAndCompilationComparer.Instance.Equals(x.Left, y.Left)
+                && SynthesizedSourceArrayComparer.Instance.Equals(x.Right, y.Right);
+
+        public int GetHashCode(
+            ((CompilationUnitSyntax Left, Compilation Right) Left, ImmutableArray<(string HintName, string Source)> Right) obj)
+        {
+            unchecked
+            {
+                return CompilationUnitAndCompilationComparer.Instance.GetHashCode(obj.Left) * 31
+                    + SynthesizedSourceArrayComparer.Instance.GetHashCode(obj.Right);
+            }
+        }
+    }
 }

tests/ExpressiveSharp.Generator.Tests/PolyfillInterceptorGenerator/SynthesizedPropertyInterceptorTests.Select_ReferencesSynthesizedProperty.verified.txt

@@ -0,0 +1,32 @@
+// <auto-generated/>
+#nullable disable
+
+namespace ExpressiveSharp.Generated.Interceptors
+{
+    internal static partial class PolyfillInterceptors
+    {
+        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(/* scrubbed */)]
+        internal static global::ExpressiveSharp.IExpressiveQueryable<string> __Polyfill_Select_361d_19_18(
+            this global::ExpressiveSharp.IExpressiveQueryable<global::TestNs.Account> source,
+            global::System.Func<global::TestNs.Account, string> __func)
+        {
+            // Source: a => a.FullName
+            var i361d19c18_p_a = global::System.Linq.Expressions.Expression.Parameter(typeof(global::TestNs.Account), "a");
+            var i361d19c18_expr_0 = global::System.Linq.Expressions.Expression.Property(i361d19c18_p_a, typeof(global::TestNs.Account).GetProperty("FullName")); // a.FullName
+            var __lambda = global::System.Linq.Expressions.Expression.Lambda<global::System.Func<global::TestNs.Account, string>>(i361d19c18_expr_0, i361d19c18_p_a);
+            return global::ExpressiveSharp.ExpressiveQueryableExtensions.AsExpressive(
+                global::System.Linq.Queryable.Select(
+                    (global::System.Linq.IQueryable<global::TestNs.Account>)source,
+                    __lambda));
+        }
+    }
+}
+
+namespace System.Runtime.CompilerServices
+{
+    [global::System.AttributeUsage(global::System.AttributeTargets.Method, AllowMultiple = true)]
+    file sealed class InterceptsLocationAttribute : global::System.Attribute
+    {
+        public InterceptsLocationAttribute(int version, string data) { }
+    }
+}