perf: typed-record fast path for property writes

Symmetric to the prior commit's read-side fast path. `obj.x = v`
currently dispatches through `$Runtime.SetProperty(obj, "x", v)`,
which does a frozen check, a sealed check, then walks an isinst chain
($TSObject / IHasFields / TSError / Dict / ...) before reaching the
actual store. The chain costs ~10 ns per write on hot paths.

When the receiver's static type is `TypeInfo.Record`, take a direct
`Dictionary<string, object>.set_Item` path. Bails to SetProperty
when the receiver is frozen, sealed, or not actually a bare
Dictionary at runtime — keeps Object.freeze / Object.seal sloppy-mode
semantics intact (frozen → silent no-op, sealed + new property →
silent no-op, sealed + existing property → succeeds via slow path's
`ContainsKey` branch). Skipped under strict mode entirely so
SetPropertyStrict's TypeError surface stays untouched.

Wins on the property-access benchmark, N=1M, .NET 10 / Arm64:
  SinglePropWriteLoop  20.4 ms → 12.4 ms  -39%

Allocations unchanged (24 MB is operand boxing of `i` per iter —
typed-storage rework needed to eliminate).

xUnit: 10310/10310. Standalone-DLL constraint preserved.

Author: nickna

Compilation/ILEmitter.Properties.cs

@@ -379,6 +379,89 @@ private void EmitTypedRecordPropertyGet(Expr.Get g)
         SetStackUnknown();
     }
 
+    /// <summary>
+    /// Phase I fast path for <c>obj.x = v</c> on a record-typed receiver.
+    /// Symmetric to <see cref="EmitTypedRecordPropertyGet"/>, but with
+    /// extra guards for the spec-mandated semantics SetProperty handles:
+    /// <list type="bullet">
+    /// <item>Object.freeze: silent fail in sloppy mode.</item>
+    /// <item>Object.seal: existing-property writes succeed, new-property
+    /// adds silently fail.</item>
+    /// <item>Object.preventExtensions: tracked via PropertyDescriptorStore;
+    /// fall back to slow path which calls PDSCanAddProperty.</item>
+    /// </list>
+    /// We check FrozenObjects/SealedObjects directly; on hit, route to
+    /// the slow path. For the non-frozen, non-sealed common case we go
+    /// straight to <c>dict.set_Item</c>. Skipping the long isinst chain
+    /// inside SetProperty saves ~10 ns/call on hot paths.
+    ///
+    /// Stack on entry: empty. Stack on exit: <c>[boxedValue]</c> — the
+    /// assignment expression's result, matching the slow path.
+    /// </summary>
+    private void EmitTypedRecordPropertySet(Expr.Set s)
+    {
+        EmitExpression(s.Object);
+        EmitBoxIfNeeded(s.Object);
+        var receiverLocal = IL.DeclareLocal(_ctx.Types.Object);
+        IL.Emit(OpCodes.Stloc, receiverLocal);
+
+        EmitExpression(s.Value);
+        EmitBoxIfNeeded(s.Value);
+        var valueLocal = IL.DeclareLocal(_ctx.Types.Object);
+        IL.Emit(OpCodes.Stloc, valueLocal);
+
+        var fallbackLabel = IL.DefineLabel();
+        var endLabel = IL.DefineLabel();
+        var ignoredLocal = IL.DeclareLocal(_ctx.Types.Object);
+        var cwtTryGet = _ctx.Types.GetMethod(
+            _ctx.Types.ConditionalWeakTable, "TryGetValue",
+            _ctx.Types.Object, _ctx.Types.Object.MakeByRefType());
+
+        // Bail to slow path on Object.freeze/seal — keeps spec semantics
+        // intact without having to replicate the property-descriptor
+        // dance here. Check FrozenObjects first; then SealedObjects.
+        IL.Emit(OpCodes.Ldsfld, _ctx.Runtime!.FrozenObjectsField);
+        IL.Emit(OpCodes.Ldloc, receiverLocal);
+        IL.Emit(OpCodes.Ldloca, ignoredLocal);
+        IL.Emit(OpCodes.Callvirt, cwtTryGet);
+        IL.Emit(OpCodes.Brtrue, fallbackLabel);
+
+        IL.Emit(OpCodes.Ldsfld, _ctx.Runtime!.SealedObjectsField);
+        IL.Emit(OpCodes.Ldloc, receiverLocal);
+        IL.Emit(OpCodes.Ldloca, ignoredLocal);
+        IL.Emit(OpCodes.Callvirt, cwtTryGet);
+        IL.Emit(OpCodes.Brtrue, fallbackLabel);
+
+        // dictLocal = receiver as Dictionary<string, object>; if null,
+        // not the shape we're optimized for → fall back.
+        var dictLocal = IL.DeclareLocal(_ctx.Types.DictionaryStringObject);
+        IL.Emit(OpCodes.Ldloc, receiverLocal);
+        IL.Emit(OpCodes.Isinst, _ctx.Types.DictionaryStringObject);
+        IL.Emit(OpCodes.Stloc, dictLocal);
+        IL.Emit(OpCodes.Ldloc, dictLocal);
+        IL.Emit(OpCodes.Brfalse, fallbackLabel);
+
+        // dict[name] = value
+        IL.Emit(OpCodes.Ldloc, dictLocal);
+        IL.Emit(OpCodes.Ldstr, s.Name.Lexeme);
+        IL.Emit(OpCodes.Ldloc, valueLocal);
+        var setItem = _ctx.Types.GetMethod(
+            _ctx.Types.DictionaryStringObject, "set_Item",
+            _ctx.Types.String, _ctx.Types.Object);
+        IL.Emit(OpCodes.Callvirt, setItem);
+        IL.Emit(OpCodes.Br, endLabel);
+
+        IL.MarkLabel(fallbackLabel);
+        IL.Emit(OpCodes.Ldloc, receiverLocal);
+        IL.Emit(OpCodes.Ldstr, s.Name.Lexeme);
+        IL.Emit(OpCodes.Ldloc, valueLocal);
+        IL.Emit(OpCodes.Call, _ctx.Runtime!.SetProperty);
+
+        IL.MarkLabel(endLabel);
+        IL.Emit(OpCodes.Ldloc, valueLocal);
+        SetStackUnknown();
+    }
+
     protected override void EmitSet(Expr.Set s)
     {
         // CommonJS: `module.exports = X` writes → stsfld $exports
@@ -488,6 +571,24 @@ protected override void EmitSet(Expr.Set s)
             }
         }
 
+        // Phase I fast path: symmetric to the EmitGet typed-record fast
+        // path. When the receiver's static type is `TypeInfo.Record`, the
+        // runtime value is most often a bare `Dictionary<string, object>`
+        // produced by EmitObjectLiteral. Bypass SetProperty's isinst
+        // chain with a direct `Castclass Dictionary; set_Item` on the
+        // common case, falling through to SetProperty for non-Dict
+        // shapes ($Object with setters, class instances, etc.).
+        // Skipped under strict mode — SetPropertyStrict surfaces a
+        // TypeError for assignments to read-only properties / sealed
+        // objects, which we can't replicate in IL without re-doing the
+        // dispatch chain.
+        if (!_ctx.IsStrictMode
+            && objType is TypeInfo.Record)
+        {
+            EmitTypedRecordPropertySet(s);
+            return;
+        }
+
         // Build stack for SetProperty(obj, name, value) or SetPropertyStrict(obj, name, value, strictMode)
         EmitExpression(s.Object);
         EmitBoxIfNeeded(s.Object);

SharpTS.Benchmarks/Benchmarks/PropertyAccessBenchmarks.cs

@@ -21,6 +21,7 @@ public class PropertyAccessBenchmarks
     private MethodInfo _tsChain = null!;
     private MethodInfo _tsMethodCall = null!;
     private MethodInfo _tsClassProp = null!;
+    private MethodInfo _tsPropWrite = null!;
 
     [Params(100, 10_000, 1_000_000)]
     public int N { get; set; }
@@ -42,6 +43,7 @@ public void Setup()
         _tsChain = BenchmarkHarness.GetCompiledMethod(_tsAssembly, "chainPropLoop");
         _tsMethodCall = BenchmarkHarness.GetCompiledMethod(_tsAssembly, "methodCallLoop");
         _tsClassProp = BenchmarkHarness.GetCompiledMethod(_tsAssembly, "classPropLoop");
+        _tsPropWrite = BenchmarkHarness.GetCompiledMethod(_tsAssembly, "singlePropWriteLoop");
     }
 
     [Benchmark]
@@ -63,4 +65,9 @@ public void Setup()
     [BenchmarkCategory("ClassPropLoop")]
     public object? SharpTS_ClassPropLoop()
         => BenchmarkHarness.InvokeCompiled(_tsClassProp, (double)N);
+
+    [Benchmark]
+    [BenchmarkCategory("SinglePropWriteLoop")]
+    public object? SharpTS_SinglePropWriteLoop()
+        => BenchmarkHarness.InvokeCompiled(_tsPropWrite, (double)N);
 }

SharpTS.Benchmarks/TypeScriptSources/PropertyAccess.ts

@@ -60,3 +60,15 @@ function classPropLoop(n: number): number {
     }
     return total;
 }
+
+// Property write — `obj.x = v`. Tight loop assigning to the same property
+// each iteration on a single object. Measures dispatch cost of SetProperty.
+// Explicit annotation keeps `x` widened to number rather than literal 0,
+// otherwise the type checker rejects the iteration assignment.
+function singlePropWriteLoop(n: number): number {
+    const obj: { x: number, y: number } = { x: 0, y: 0 };
+    for (let i: number = 0; i < n; i++) {
+        obj.x = i;
+    }
+    return obj.x as number;
+}