Fix 9 broken tests: hasOwn on class instances, PIE symbol key, RegExp sync

Three independent fixes addressing the failing-test cluster:

1. HasOwnPropertyHelper: add $IHasFields branch for user-defined class
   instances. Regression from 1866d2f which unified ObjectHasOwn into
   HasOwnPropertyHelper but lost the $IHasFields → Fields.ContainsKey
   path. Object.hasOwn(p, "name") on a class instance silently returned
   false. New branch dispatches through the per-class HasProperty
   (compile-time backing-field + _fields check) with a PDS fallback for
   defineProperty-installed descriptors.

2. PropertyIsEnumerableHelper symbol-key path: remove the broken
   PDSGetPropertyDescriptor call. PDS is string-keyed; the call was
   passing the Symbol object as the string `name` parameter, which
   ILVerify flagged as StackUnexpected and would have thrown at runtime
   if a defineProperty-installed symbol descriptor ever surfaced. Symbol
   keys go through the per-receiver symbol dict only — spec-default
   enumerable=true per ECMA-262 §17 for plain `obj[sym] = v` assignments.

3. RuntimeTypeSyncTests SharpTSRegExp ignored list: add DefineAccessor
   and TryGetAccessor. These are interpreter-only (added in ad935b8 for
   ECMA-262 §22.2 configurable-accessor parity); compiled $RegExp routes
   defineProperty accessors through the central PropertyDescriptorStore,
   so emitting equivalents would be dead code.

Test results: 10,321/10,321 passing (was 10,312 with 9 failures).

Author: nickna

Compilation/RuntimeEmitter.HasOwnProperty.cs

@@ -18,6 +18,8 @@ public partial class RuntimeEmitter
     /// - $TSFunction: name is "name"/"length" (always cached) or PDS has a
     ///   user-defined descriptor for it.
     /// - $Object: name is in _fields or _getters.
+    /// - $IHasFields (user-defined class instances): per-class HasProperty
+    ///   knows typed backing fields + the dynamic _fields dict.
     /// - Dictionary: ContainsKey(name).
     /// - List/$Array: name is "length" or a numeric index in range.
     /// - String: numeric index in [0,len) or "length".
@@ -124,6 +126,32 @@ private void EmitHasOwnPropertyHelper(TypeBuilder typeBuilder, EmittedRuntime ru
         il.Emit(OpCodes.Br, falseLabel);
         il.MarkLabel(notTSObject);
 
+        // $IHasFields branch — user-defined class instances. Each compiled
+        // class implements $IHasFields with a per-class HasProperty that
+        // checks typed backing field names + the dynamic _fields dict
+        // (see ILCompiler.Classes.HasFields.EmitHasPropertyBodyCore).
+        // PDS fallback covers `Object.defineProperty(instance, name, ...)`.
+        //
+        // Must run after $TSObject (which also implements $IHasFields but
+        // has its own richer dispatch via TSObjectHasProperty) and before
+        // the Dictionary branch (a class instance isn't a Dictionary, but
+        // ordering here documents the precedence).
+        var notIHasFieldsLabel = il.DefineLabel();
+        il.Emit(OpCodes.Ldarg_0);
+        il.Emit(OpCodes.Isinst, runtime.IHasFieldsInterface);
+        il.Emit(OpCodes.Brfalse, notIHasFieldsLabel);
+        il.Emit(OpCodes.Ldarg_0);
+        il.Emit(OpCodes.Castclass, runtime.IHasFieldsInterface);
+        il.Emit(OpCodes.Ldloc, nameLocal);
+        il.Emit(OpCodes.Callvirt, runtime.IHasFieldsHasProperty);
+        il.Emit(OpCodes.Brtrue, trueLabel);
+        il.Emit(OpCodes.Ldarg_0);
+        il.Emit(OpCodes.Ldloc, nameLocal);
+        il.Emit(OpCodes.Call, runtime.PDSGetPropertyDescriptor);
+        il.Emit(OpCodes.Brtrue, trueLabel);
+        il.Emit(OpCodes.Br, falseLabel);
+        il.MarkLabel(notIHasFieldsLabel);
+
         // Dictionary<string,object> — own property is either a direct key in
         // the backing dict (\"foo\" = 1 syntax) OR a PDS-stored descriptor
         // (Object.defineProperty path, which doesn't write to _fields). Both
@@ -429,28 +457,20 @@ private void EmitPropertyIsEnumerableHelper(TypeBuilder typeBuilder, EmittedRunt
         il.Emit(OpCodes.Throw);
         il.MarkLabel(pieAfterNullLabel);
 
-        // Symbol-keyed lookup: same routing as HasOwnPropertyHelper.
+        // Symbol-keyed lookup. PDSGetPropertyDescriptor's name parameter is
+        // string-typed, so symbol keys can't live there — defineProperty with
+        // a symbol key writes to the per-receiver symbol dict (GetSymbolDict).
+        // Presence in that dict is the spec-default enumerable=true for plain
+        // `obj[sym] = v` assignments; an earlier attempt to honor PDS-installed
+        // descriptors here passed the symbol as the string `name`, which IL-
+        // Verify flagged (StackUnexpected) and would have thrown at runtime if
+        // the path ever ran with a defineProperty-installed symbol descriptor.
+        // ECMA-262 §17 specifies enumerable=true as the default for own data
+        // properties of ordinary objects.
         var pieNotSymbolLabel = il.DefineLabel();
         il.Emit(OpCodes.Ldarg_1);
         il.Emit(OpCodes.Call, runtime.IsSymbolMethod);
         il.Emit(OpCodes.Brfalse, pieNotSymbolLabel);
-        // For Symbol keys: lookup descriptor in PDS (Object.defineProperty-
-        // installed descriptors hold the Enumerable bit). If missing, fall
-        // back to whether the symbol exists in GetSymbolDict (then default
-        // enumerable=true for plain `obj[sym] = v` assignments).
-        var pieSymPdsLocal = il.DeclareLocal(runtime.CompiledPropertyDescriptorType);
-        var pieSymNoPdsLabel = il.DefineLabel();
-        il.Emit(OpCodes.Ldarg_0);
-        il.Emit(OpCodes.Ldarg_1);
-        il.Emit(OpCodes.Call, runtime.PDSGetPropertyDescriptor);
-        il.Emit(OpCodes.Stloc, pieSymPdsLocal);
-        il.Emit(OpCodes.Ldloc, pieSymPdsLocal);
-        il.Emit(OpCodes.Brfalse, pieSymNoPdsLabel);
-        il.Emit(OpCodes.Ldloc, pieSymPdsLocal);
-        il.Emit(OpCodes.Callvirt, runtime.CompiledPropertyDescriptorEnumerable.GetGetMethod()!);
-        il.Emit(OpCodes.Ret);
-        il.MarkLabel(pieSymNoPdsLabel);
-        // No PDS: check symbol dict. Present → enumerable by default; absent → false.
         il.Emit(OpCodes.Ldarg_0);
         il.Emit(OpCodes.Call, runtime.GetSymbolDictMethod);
         il.Emit(OpCodes.Ldarg_1);

SharpTS.Tests/Compilation/RuntimeTypeSyncTests.cs

@@ -97,7 +97,13 @@ public void Dispose()
             [.. BaseIgnored, "SetFromEpochMilliseconds", "ToLocalTime"]),
 
         new(typeof(SharpTSRegExp), "RegExp",
-            [.. BaseIgnored]),
+            [.. BaseIgnored,
+             // Per-instance accessor map (interpreter-only path). Compiled $RegExp
+             // routes defineProperty accessors through the central PropertyDescriptor
+             // Store (PDS), so emitting equivalent instance methods would just be
+             // dead code. See SharpTSRegExp.DefineAccessor / TryGetAccessor
+             // (added in ad935b84 for ECMA-262 §22.2 configurable-accessor parity).
+             "DefineAccessor", "TryGetAccessor"]),
 
         new(typeof(SharpTSError), "Error",
             [.. BaseIgnored, "GetMember"]),