Admit member call spread sources (#3025)

Author: rogeralsing

docs/unified-bytecode-expansion-contract.md

@@ -336,7 +336,7 @@ must still obey the no-mixed-execution rule.
 | `DeleteDependency` | `delete` expressions outside the admitted ordinary named/computed property delete lane and the with-backed dynamic-name delete lane | Existing sync IR delete route | Delete semantics lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~Evaluate_PropertyReadAdjacentFamilies_DeclineWithExplicitCodes"` |
 | `SuperPropertyDependency` | Out-of-boundary super call targets; super property reads/writes/updates are admitted by dedicated VM opcodes | Existing class / constructor route for remaining call-target shapes | Super semantics lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~Evaluate_SuperPropertyAccess_AcceptsOwnedOpcodes"` |
 | `OptionalChainDependency` | Optional chains outside the admitted optional property-read, optional-call, and exact optional named/computed delete boundaries | Existing sync IR optional-chain route | Optional-chain widening lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~Evaluate_OptionalChainNamedPrefixPlainCallExpressionPlan_AcceptsExecutableInvocationBoundary"` |
-| `ObjectLiteralOrSpreadDependency` | Non-simple object spread sources, unsupported array spread, and object methods/accessors only when they appear inside restricted simple literal spans | Existing sync IR literal/spread route for remaining spans | Literal/spread lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~Evaluate_NonSimpleSourceArraySpread_DeclinesWithExplicitCode"` |
+| `ObjectLiteralOrSpreadDependency` | Object/array spread sources outside simple operands and direct named member-call spread sources, and object methods/accessors only when they appear inside restricted simple literal spans | Existing sync IR literal/spread route for remaining spans | Literal/spread lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~Evaluate_ObjectLiteralUnsupportedFeatures_DeclineWithExplicitCodes"` |
 | `PrivateFieldDependency` | Private-name operations outside the admitted routes; `#name in obj`, direct private named reads/writes/updates, direct private named compound/logical writes, and direct private named method calls are VM-owned when the surrounding class method is otherwise production-eligible. Private member deletes are parser early errors before production eligibility. | Existing private-name route for remaining private member access | Private-name lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~Evaluate_PrivateFieldIn_AcceptsAndVmChecksPrivateBrand"` |
 | `ForInDriverStateDependency` | Unsupported for-in driver state such as awaited object source | Existing for-in IR driver route | Driver-state lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~IsSupportedForInInit_AwaitedSource_Declines"` |
 | `DestructuringDependency` | Binding declarations with defaults, computed binding names, assignment targets, awaited binding values, unsupported destructuring driver shapes, and targets outside the admitted driver or descriptor-backed lanes | Existing destructuring IR route for remaining shapes | Destructuring driver lane | `rtk dotnet test tests/Asynkron.JsEngine.Tests --filter "FullyQualifiedName~UnifiedBytecodeProductionEligibilityTests&FullyQualifiedName~Evaluate_UnsupportedDestructuringDriverShapes_DeclineWithExplicitReason"` |

src/Asynkron.JsEngine/Execution/UnifiedBytecode/UnifiedBytecodeCompiler.cs

@@ -6053,7 +6053,7 @@ private static bool TryAppendCallArguments(
             {
                 if (!TryAppendSimpleArrayLiteralSpan(
                         expressionProgram, operationIndex, activationSlots,
-                        unified, literalConstants, out var arraySpanLen, out reason))
+                        unified, literalConstants, stringConstants, callTargetConstants, slotLayout, out var arraySpanLen, out reason))
                 {
                     return false;
                 }
@@ -6151,6 +6151,9 @@ private static bool TryAppendSimpleArrayLiteralSpan(
         ActivationSlotShape activationSlots,
         ImmutableArray<UnifiedBytecodeInstruction>.Builder unified,
         ImmutableArray<JsValue>.Builder literalConstants,
+        ImmutableArray<string>.Builder stringConstants,
+        ImmutableArray<UnifiedBytecodeCallTarget>.Builder? callTargetConstants,
+        UnifiedBytecodeSlotLayout? slotLayout,
         out int spanLength,
         out string reason)
     {
@@ -6175,14 +6178,44 @@ private static bool TryAppendSimpleArrayLiteralSpan(
                 continue;
             }
 
-            if (!TryAppendSimpleOperandLoad(elementOp, expressionProgram, activationSlots, unified, literalConstants, out reason))
+            if (slotLayout is not null &&
+                callTargetConstants is not null &&
+                TryMeasureSimpleDirectNamedCallOperandSpan(
+                    expressionProgram,
+                    i,
+                    activationSlots,
+                    out _,
+                    out _,
+                    out var callElementSpanLength))
+            {
+                if (!TryAppendSimpleDirectNamedCallOperandSpan(
+                        expressionProgram,
+                        i,
+                        activationSlots,
+                        slotLayout,
+                        unified,
+                        literalConstants,
+                        stringConstants,
+                        callTargetConstants,
+                        out reason))
+                {
+                    spanLength = 0;
+                    return false;
+                }
+
+                i += callElementSpanLength;
+            }
+            else if (TryAppendSimpleOperandLoad(elementOp, expressionProgram, activationSlots, unified, literalConstants, out reason))
+            {
+                i++;
+            }
+            else
             {
                 // Non-simple op — element scan is done; the array literal ends here.
                 // Undo the failed load (TryAppendSimpleOperandLoad adds nothing on failure).
                 break;
             }
 
-            i++;
             if (i >= expressionProgram.OperationCount)
             {
                 spanLength = 0;
@@ -6373,6 +6406,38 @@ callTargetConstants is not null &&
             }
 
             var firstOp = expressionProgram.GetOperation(i);
+            if (slotLayout is not null &&
+                callTargetConstants is not null &&
+                TryMeasureSimpleDirectNamedCallOperandSpan(
+                    expressionProgram,
+                    i,
+                    activationSlots,
+                    out _,
+                    out _,
+                    out var spreadCallSpanLength) &&
+                i + spreadCallSpanLength < expressionProgram.OperationCount &&
+                expressionProgram.GetOperation(i + spreadCallSpanLength).Kind == ExpressionOpKind.ObjectSpread)
+            {
+                if (!TryAppendSimpleDirectNamedCallOperandSpan(
+                        expressionProgram,
+                        i,
+                        activationSlots,
+                        slotLayout,
+                        unified,
+                        literalConstants,
+                        stringConstants,
+                        callTargetConstants,
+                        out reason))
+                {
+                    spanLength = 0;
+                    return false;
+                }
+
+                unified.Add(new UnifiedBytecodeInstruction(UnifiedBytecodeOpCode.ObjectSpread));
+                i += spreadCallSpanLength + 1;
+                continue;
+            }
+
             if (!TryAppendSimpleOperandLoad(firstOp, expressionProgram, activationSlots, unified, literalConstants, out reason))
             {
                 // Non-simple first op — property scan is done; the object literal ends here.
@@ -6544,6 +6609,131 @@ private static bool TryAppendSimpleIdentifierCallOperandSpan(
         return true;
     }
 
+    private static bool TryMeasureSimpleDirectNamedCallOperandSpan(
+        ExpressionProgram expressionProgram,
+        int startIndex,
+        ActivationSlotShape activationSlots,
+        out int callIndex,
+        out int argumentCount,
+        out int spanLength)
+    {
+        callIndex = -1;
+        argumentCount = 0;
+        spanLength = 0;
+        if (startIndex + 2 >= expressionProgram.OperationCount)
+        {
+            return false;
+        }
+
+        if (!CanAppendSimpleOperandLoad(expressionProgram.GetOperation(startIndex), expressionProgram, activationSlots))
+        {
+            return false;
+        }
+
+        var callTarget = expressionProgram.GetOperation(startIndex + 1);
+        if (callTarget.Kind != ExpressionOpKind.LoadNamedCallTarget ||
+            callTarget.IsOptional ||
+            callTarget.ShortCircuitOnNullishTarget ||
+            callTarget.GetString(expressionProgram.StringConstants.AsSpan()).IsPrivateName())
+        {
+            return false;
+        }
+
+        var operationIndex = startIndex + 2;
+        while (operationIndex < expressionProgram.OperationCount &&
+               CanAppendSimpleOperandLoad(expressionProgram.GetOperation(operationIndex), expressionProgram, activationSlots))
+        {
+            argumentCount++;
+            operationIndex++;
+        }
+
+        if (operationIndex >= expressionProgram.OperationCount)
+        {
+            return false;
+        }
+
+        var call = expressionProgram.GetOperation(operationIndex);
+        if (call.Kind != ExpressionOpKind.Call ||
+            !call.HasExplicitThis ||
+            call.IsDirectEval ||
+            call.SpreadMaskConstantIndex >= 0 ||
+            call.ArgumentCount != argumentCount)
+        {
+            argumentCount = 0;
+            return false;
+        }
+
+        callIndex = operationIndex;
+        spanLength = operationIndex - startIndex + 1;
+        return true;
+    }
+
+    private static bool TryAppendSimpleDirectNamedCallOperandSpan(
+        ExpressionProgram expressionProgram,
+        int startIndex,
+        ActivationSlotShape activationSlots,
+        UnifiedBytecodeSlotLayout slotLayout,
+        ImmutableArray<UnifiedBytecodeInstruction>.Builder unified,
+        ImmutableArray<JsValue>.Builder literalConstants,
+        ImmutableArray<string>.Builder stringConstants,
+        ImmutableArray<UnifiedBytecodeCallTarget>.Builder callTargetConstants,
+        out string reason)
+    {
+        if (!TryMeasureSimpleDirectNamedCallOperandSpan(
+                expressionProgram,
+                startIndex,
+                activationSlots,
+                out var callIndex,
+                out var argumentCount,
+                out _))
+        {
+            reason = "Spread sources only admit direct named member calls with simple arguments.";
+            return false;
+        }
+
+        if (!TryAppendSimpleOperandLoad(
+                expressionProgram.GetOperation(startIndex),
+                expressionProgram,
+                activationSlots,
+                unified,
+                literalConstants,
+                out reason))
+        {
+            return false;
+        }
+
+        var callTarget = expressionProgram.GetOperation(startIndex + 1);
+        var callTargetNameIndex = stringConstants.Count;
+        stringConstants.Add(callTarget.GetString(expressionProgram.StringConstants.AsSpan()));
+        var callTargetConstantIndex = callTargetConstants.Count;
+        callTargetConstants.Add(new UnifiedBytecodeCallTarget(
+            UnifiedBytecodeCallTargetKind.NamedMember,
+            NameConstantIndex: callTargetNameIndex));
+        unified.Add(new UnifiedBytecodeInstruction(
+            UnifiedBytecodeOpCode.PrepareNamedCallTarget,
+            callTargetConstantIndex));
+
+        for (var operationIndex = startIndex + 2; operationIndex < callIndex; operationIndex++)
+        {
+            if (!TryAppendSimpleOperandLoad(
+                    expressionProgram.GetOperation(operationIndex),
+                    expressionProgram,
+                    activationSlots,
+                    unified,
+                    literalConstants,
+                    out reason))
+            {
+                return false;
+            }
+        }
+
+        unified.Add(new UnifiedBytecodeInstruction(
+            UnifiedBytecodeOpCode.CallInvocationBoundary,
+            EncodeCallBoundaryOperand(argumentCount, spreadMaskIndex: -1, isDirectEval: false)));
+        reason = string.Empty;
+        return true;
+    }
+
     private static bool TryMeasureSimpleObjectLiteralSpan(
         ExpressionProgram expressionProgram,
         int startIndex,
@@ -9076,7 +9266,8 @@ private static bool TryAppendFirstBoundaryPropertyReadBinaryExpression(
             if (rhsOp.Kind == ExpressionOpKind.CreateArray)
             {
                 if (!TryAppendSimpleArrayLiteralSpan(
-                        expressionProgram, rhsStart, activationSlots, unified, literalConstants,
+                        expressionProgram, rhsStart, activationSlots, unified, literalConstants, stringConstants,
+                        callTargetConstants: null, slotLayout: null,
                         out var arraySpanLen, out reason) ||
                     rhsStart + arraySpanLen - 1 != rhsEnd)
                 {