Enhance constructor handling in ExpressiveSharp generator and fixed various issues

Author: koenbeuk

src/ExpressiveSharp.Generator/Emitter/ExpressionTreeEmitter.cs

@@ -339,21 +339,61 @@ private static bool TryApplyConstructorBody(
         descriptor.ReturnTypeName = fullTypeName;
         ApplyParameterList(constructorDeclarationSyntax.ParameterList, declarationSyntaxRewriter, descriptor);
 
-        // Verify parameterless constructor exists
-        var hasAccessibleParameterlessConstructor = containingType.Constructors
-            .Any(c => !c.IsStatic
-                      && c.Parameters.IsEmpty
-                      && c.DeclaredAccessibility is Accessibility.Public
-                          or Accessibility.Internal
-                          or Accessibility.ProtectedOrInternal);
+        // Detect `: this(...)` chaining to a parameterized ctor (records' primary ctor or any
+        // `this(args)` overload). In that case we emit Expression.New(targetCtor, args) so the
+        // target ctor is invoked with the caller's values — the parameterless requirement is
+        // then irrelevant because we never synthesize `new T()`.
+        IMethodSymbol? chainedTargetCtor = null;
+        List<SyntaxNode>? chainedArgExpressions = null;
+        if (constructorDeclarationSyntax.Initializer is { } initializer
+            && initializer.ThisOrBaseKeyword.IsKind(SyntaxKind.ThisKeyword))
+        {
+            if (semanticModel.GetSymbolInfo(initializer).Symbol is IMethodSymbol target
+                && target.Parameters.Length > 0)
+            {
+                chainedTargetCtor = target;
+                chainedArgExpressions = initializer.ArgumentList.Arguments
+                    .Select(a => (SyntaxNode)a.Expression)
+                    .ToList();
+            }
+        }
 
-        if (!hasAccessibleParameterlessConstructor)
+        // Verify parameterless constructor exists — skip when chaining to a parameterized ctor.
+        if (chainedTargetCtor is null)
+        {
+            var hasAccessibleParameterlessConstructor = containingType.Constructors
+                .Any(c => !c.IsStatic
+                          && c.Parameters.IsEmpty
+                          && c.DeclaredAccessibility is Accessibility.Public
+                              or Accessibility.Internal
+                              or Accessibility.ProtectedOrInternal);
+
+            if (!hasAccessibleParameterlessConstructor)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    Diagnostics.MissingParameterlessConstructor,
+                    constructorDeclarationSyntax.GetLocation(),
+                    containingType.Name));
+                return false;
+            }
+        }
+
+        // Preserve EXP0003: report when a `: base(...)` initializer targets a ctor with no
+        // available source (e.g. BCL exception base classes). The expression tree cannot
+        // represent a call to such a ctor — we still emit the outer body's bindings via the
+        // parameterless ctor, but users should be warned that the base-ctor side effects are
+        // not captured.
+        if (constructorDeclarationSyntax.Initializer is { } baseInit
+            && baseInit.ThisOrBaseKeyword.IsKind(SyntaxKind.BaseKeyword)
+            && semanticModel.GetSymbolInfo(baseInit).Symbol is IMethodSymbol baseTarget
+            && !baseTarget.DeclaringSyntaxReferences.Any(r => r.GetSyntax() is ConstructorDeclarationSyntax))
         {
             context.ReportDiagnostic(Diagnostic.Create(
-                Diagnostics.MissingParameterlessConstructor,
-                constructorDeclarationSyntax.GetLocation(),
-                containingType.Name));
-            return false;
+                Diagnostics.NoSourceAvailableForDelegatedConstructor,
+                baseTarget.Locations.FirstOrDefault() ?? Location.None,
+                baseTarget.ToDisplayString(),
+                baseTarget.ContainingType?.ToDisplayString() ?? "<unknown>",
+                memberSymbol.Name));
         }
 
         // Pass the constructor body to the emitter — it will emit the block as-is.
@@ -374,17 +414,6 @@ or Accessibility.Internal
             return ReportRequiresBodyAndFail(context, constructorDeclarationSyntax, memberSymbol.Name);
         }
 
-        // Collect assignments from base/this delegated constructors
-        var delegatedBindings = new List<(IPropertySymbol Property, SyntaxNode ValueSyntax)>();
-        if (constructorDeclarationSyntax.Initializer is { } initializer && compilation is not null)
-        {
-            var initializerSymbol = semanticModel.GetSymbolInfo(initializer).Symbol as IMethodSymbol;
-            if (initializerSymbol is not null)
-            {
-                CollectDelegatedBindings(initializerSymbol, compilation, delegatedBindings, context, memberSymbol.Name);
-            }
-        }
-
         var emitter = new ExpressionTreeEmitter(semanticModel, context);
 
         // Build emitter parameters (constructor params, no @this)
@@ -403,76 +432,11 @@ or Accessibility.Internal
 
         descriptor.ExpressionTreeEmission = emitter.EmitConstructor(
             bodySyntax, emitterParams, descriptor.ReturnTypeName!, delegateTypeFqn,
-            containingType, delegatedBindings);
+            containingType, chainedTargetCtor, chainedArgExpressions);
 
         return true;
     }
 
-    /// <summary>
-    /// Recursively collects property assignments from a delegated constructor chain.
-    /// </summary>
-    private static void CollectDelegatedBindings(
-        IMethodSymbol delegatedCtor,
-        Compilation compilation,
-        List<(IPropertySymbol Property, SyntaxNode ValueSyntax)> bindings,
-        SourceProductionContext context,
-        string memberName)
-    {
-        var syntax = delegatedCtor.DeclaringSyntaxReferences
-            .Select(r => r.GetSyntax())
-            .OfType<ConstructorDeclarationSyntax>()
-            .FirstOrDefault();
-
-        if (syntax is null)
-        {
-            context.ReportDiagnostic(Diagnostic.Create(
-                Diagnostics.NoSourceAvailableForDelegatedConstructor,
-                delegatedCtor.Locations.FirstOrDefault() ?? Location.None,
-                delegatedCtor.ToDisplayString(),
-                delegatedCtor.ContainingType?.ToDisplayString() ?? "<unknown>",
-                memberName));
-            return;
-        }
-
-        // Follow the chain recursively
-        if (syntax.Initializer is { } initializer)
-        {
-            var delegatedSemanticModel = compilation.GetSemanticModel(syntax.SyntaxTree);
-            var initializerSymbol = delegatedSemanticModel.GetSymbolInfo(initializer).Symbol as IMethodSymbol;
-            if (initializerSymbol is not null)
-            {
-                CollectDelegatedBindings(initializerSymbol, compilation, bindings, context, memberName);
-            }
-        }
-
-        // Collect property assignments from this constructor's body
-        if (syntax.Body is not null)
-        {
-            var ctorSemanticModel = compilation.GetSemanticModel(syntax.SyntaxTree);
-            foreach (var statement in syntax.Body.Statements)
-            {
-                if (statement is ExpressionStatementSyntax { Expression: AssignmentExpressionSyntax assignment }
-                    && assignment.Left is MemberAccessExpressionSyntax memberAccess)
-                {
-                    var symbol = ctorSemanticModel.GetSymbolInfo(memberAccess).Symbol;
-                    if (symbol is IPropertySymbol prop)
-                    {
-                        bindings.Add((prop, assignment.Right));
-                    }
-                }
-                else if (statement is ExpressionStatementSyntax { Expression: AssignmentExpressionSyntax simpleAssignment }
-                    && simpleAssignment.Left is IdentifierNameSyntax identifierName)
-                {
-                    var symbol = ctorSemanticModel.GetSymbolInfo(identifierName).Symbol;
-                    if (symbol is IPropertySymbol prop)
-                    {
-                        bindings.Add((prop, simpleAssignment.Right));
-                    }
-                }
-            }
-        }
-    }
-
     /// <summary>
     /// Shared helper: emits expression tree building code for a method body.
     /// </summary>
@@ -628,11 +592,17 @@ private static void WalkOperations(
                     memberName, "??= operator"));
                 return;
 
-            case IDeconstructionAssignmentOperation:
-                context.ReportDiagnostic(Diagnostic.Create(
-                    Diagnostics.UnsupportedStatementInBlockBody,
-                    operation.Syntax?.GetLocation() ?? Location.None,
-                    memberName, "deconstruction assignment"));
+            case IDeconstructionAssignmentOperation decon:
+                // Accept the tuple-literal-to-tuple-literal shape (e.g. `(A, B) = (x, y);`) —
+                // the ctor-body emitter decomposes it into individual property bindings.
+                // Reject everything else (Deconstruct method calls, nested tuples, discards, etc.).
+                if (!IsSimpleTupleLiteralDeconstruction(decon))
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        Diagnostics.UnsupportedStatementInBlockBody,
+                        operation.Syntax?.GetLocation() ?? Location.None,
+                        memberName, "deconstruction assignment"));
+                }
                 return;
 
             case IDynamicInvocationOperation or IDynamicMemberReferenceOperation
@@ -650,4 +620,37 @@ private static void WalkOperations(
             WalkOperations(child, memberName, context);
         }
     }
+
+    /// <summary>
+    /// Returns true when the deconstruction has the shape
+    /// <c>(member, member, ...) = (value, value, ...)</c> — two tuple literals of equal arity
+    /// with the left side referencing only properties or fields of <c>this</c>. Only this shape
+    /// is supported by the constructor-body emitter.
+    /// </summary>
+    private static bool IsSimpleTupleLiteralDeconstruction(IDeconstructionAssignmentOperation decon)
+    {
+        var target = UnwrapConversions(decon.Target);
+        var value = UnwrapConversions(decon.Value);
+
+        if (target is not ITupleOperation targetTuple || value is not ITupleOperation valueTuple
+            || targetTuple.Elements.Length != valueTuple.Elements.Length)
+        {
+            return false;
+        }
+
+        foreach (var element in targetTuple.Elements)
+        {
+            var unwrapped = UnwrapConversions(element);
+            if (unwrapped is not IPropertyReferenceOperation && unwrapped is not IFieldReferenceOperation)
+                return false;
+        }
+        return true;
+    }
+
+    private static IOperation UnwrapConversions(IOperation operation)
+    {
+        while (operation is IConversionOperation conv)
+            operation = conv.Operand;
+        return operation;
+    }
 }

src/ExpressiveSharp.Generator/Interpretation/ExpressiveInterpreter.BodyProcessors.cs

@@ -17,7 +17,7 @@ namespace ExpressiveSharp.Generated
             var p_id = global::System.Linq.Expressions.Expression.Parameter(typeof(int), "id");
             var p_name = global::System.Linq.Expressions.Expression.Parameter(typeof(string), "name");
             var p_suffix = global::System.Linq.Expressions.Expression.Parameter(typeof(string), "suffix");
-            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.Child).GetConstructor(new global::System.Type[] {  }));
+            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.Child).GetConstructor(new global::System.Type[] { typeof(int), typeof(string) }), p_id, p_name);
             var p___this = global::System.Linq.Expressions.Expression.Parameter(typeof(object), "@this"); // Name
             var expr_2 = global::System.Linq.Expressions.Expression.Property(p___this, typeof(global::Foo.Child).GetProperty("Name"));
             var expr_1 = global::System.Linq.Expressions.Expression.Call(typeof(string).GetMethod("Concat", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Static, null, new global::System.Type[] { typeof(string), typeof(string) }, null), expr_2, p_suffix);

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ConstructorTests.ProjectableConstructor_ThisInitializer_ChainedThisAndBase.verified.txt

@@ -0,0 +1,24 @@
+// <auto-generated/>
+#nullable disable
+
+using Foo;
+
+namespace ExpressiveSharp.Generated
+{
+    static partial class Foo_OrderSummary 
+    {
+        // [Expressive]
+        // public OrderSummary(int id, int unit, int qty) : this(id, unit * qty)
+        // {
+        // }
+        static global::System.Linq.Expressions.Expression<global::System.Func<int, int, int, global::Foo.OrderSummary>> _ctor_P0_int_P1_int_P2_int_Expression() 
+        {
+            var p_id = global::System.Linq.Expressions.Expression.Parameter(typeof(int), "id");
+            var p_unit = global::System.Linq.Expressions.Expression.Parameter(typeof(int), "unit");
+            var p_qty = global::System.Linq.Expressions.Expression.Parameter(typeof(int), "qty");
+            var expr_1 = global::System.Linq.Expressions.Expression.MakeBinary(global::System.Linq.Expressions.ExpressionType.Multiply, p_unit, p_qty); // unit * qty
+            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.OrderSummary).GetConstructor(new global::System.Type[] { typeof(int), typeof(decimal) }), p_id, expr_1);
+            return global::System.Linq.Expressions.Expression.Lambda<global::System.Func<int, int, int, global::Foo.OrderSummary>>(expr_0, p_id, p_unit, p_qty);
+        }
+    }
+}

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ConstructorTests.ProjectableConstructor_ThisInitializer_RecordPrimaryCtor_NoParameterlessCtor.verified.txt

@@ -14,7 +14,8 @@ namespace ExpressiveSharp.Generated
         static global::System.Linq.Expressions.Expression<global::System.Func<string, global::Foo.PersonDto>> _ctor_P0_string_Expression() 
         {
             var p_firstName = global::System.Linq.Expressions.Expression.Parameter(typeof(string), "firstName");
-            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] {  }));
+            var expr_1 = global::System.Linq.Expressions.Expression.Constant("Doe", typeof(string)); // "Doe"
+            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] { typeof(string), typeof(string) }), p_firstName, expr_1);
             return global::System.Linq.Expressions.Expression.Lambda<global::System.Func<string, global::Foo.PersonDto>>(expr_0, p_firstName);
         }
     }

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ConstructorTests.ProjectableConstructor_ThisInitializer_RefPreviouslyAssignedProperty.verified.txt

@@ -14,7 +14,9 @@ namespace ExpressiveSharp.Generated
         static global::System.Linq.Expressions.Expression<global::System.Func<string, global::Foo.PersonDto>> _ctor_P0_string_Expression() 
         {
             var p_fullName = global::System.Linq.Expressions.Expression.Parameter(typeof(string), "fullName");
-            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] {  }));
+            var expr_1 = global::System.Linq.Expressions.Expression.Call(p_fullName, typeof(string).GetMethod("ToUpper", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] {  }, null), global::System.Array.Empty<global::System.Linq.Expressions.Expression>()); // fullName.ToUpper()
+            var expr_2 = global::System.Linq.Expressions.Expression.Call(p_fullName, typeof(string).GetMethod("ToLower", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] {  }, null), global::System.Array.Empty<global::System.Linq.Expressions.Expression>()); // fullName.ToLower()
+            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] { typeof(string), typeof(string) }), expr_1, expr_2);
             return global::System.Linq.Expressions.Expression.Lambda<global::System.Func<string, global::Foo.PersonDto>>(expr_0, p_fullName);
         }
     }

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ConstructorTests.ProjectableConstructor_ThisInitializer_SimpleOverload.verified.txt

@@ -17,7 +17,7 @@ namespace ExpressiveSharp.Generated
             var p_fn = global::System.Linq.Expressions.Expression.Parameter(typeof(string), "fn");
             var p_ln = global::System.Linq.Expressions.Expression.Parameter(typeof(string), "ln");
             var p_upper = global::System.Linq.Expressions.Expression.Parameter(typeof(bool), "upper");
-            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] {  }));
+            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] { typeof(string), typeof(string) }), p_fn, p_ln);
             var p___this = global::System.Linq.Expressions.Expression.Parameter(typeof(object), "@this"); // FirstName
             var expr_5 = global::System.Linq.Expressions.Expression.Property(p___this, typeof(global::Foo.PersonDto).GetProperty("FirstName"));
             var expr_6 = global::System.Linq.Expressions.Expression.Constant(" ", typeof(string)); // " "

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/ConstructorTests.ProjectableConstructor_ThisInitializer_WithBodyAfter.verified.txt

@@ -16,7 +16,7 @@ namespace ExpressiveSharp.Generated
         {
             var p_score = global::System.Linq.Expressions.Expression.Parameter(typeof(int), "score");
             var p_prefix = global::System.Linq.Expressions.Expression.Parameter(typeof(string), "prefix");
-            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] {  }));
+            var expr_0 = global::System.Linq.Expressions.Expression.New(typeof(global::Foo.PersonDto).GetConstructor(new global::System.Type[] { typeof(int) }), p_score);
             var p___this = global::System.Linq.Expressions.Expression.Parameter(typeof(object), "@this"); // Label
             var expr_2 = global::System.Linq.Expressions.Expression.Property(p___this, typeof(global::Foo.PersonDto).GetProperty("Label"));
             var expr_1 = global::System.Linq.Expressions.Expression.Call(typeof(string).GetMethod("Concat", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Static, null, new global::System.Type[] { typeof(string), typeof(string) }, null), p_prefix, expr_2);