Chi Tsai

This commit **updates the `test262` skiplist** and unsupported features list within `utils/testsuite/testsuite_skiplist.py`. This **maintenance** task adds numerous new entries to both lists, preparing the project for an upcoming, significant update to the `test262` test suite, which has not been synchronized in approximately two years. The changes ensure that the test runner correctly identifies and skips tests for features that are not yet implemented or are intentionally unsupported, preventing false failures and streamlining future integration efforts. This impacts the **test suite infrastructure** by refining which JavaScript features are considered supported or skipped during testing.

This commit **updates the test skiplist** for the **Hermes JavaScript engine** to address recent `mjsunit` test failures. It **adds a large number of failing `mjsunit` test paths** to the `PERMANENT_SKIP_LIST` within `utils/testsuite/testsuite_skiplist.py`. This is a **maintenance fix** to prevent the CI/CD pipeline from breaking due to newly introduced `mjsunit` test incompatibilities with Hermes. By skipping these tests, the **Hermes test suite** remains stable, allowing other development to proceed without being blocked by these known issues until they can be properly resolved.

This commit introduces the **`ISerialization` interface** to the **JSI (JavaScript Interface)**, a **new capability** designed to facilitate **serializing and deserializing JavaScript values** between different JSI runtimes. This interface defines methods like `serialize`, `deserialize`, `serializeWithTransfer`, and `deserializeWithTransfer`, enabling the cloning of objects and the transfer of ownership across runtime boundaries. The `Serialized` objects created are opaque and have a lifetime independent of their original runtime, allowing for flexible **inter-runtime communication**. This enhancement to the **JSI core API** provides a foundational mechanism for moving data between distinct JavaScript contexts, though deserialization is strictly limited to runtime instances of the same type.

This commit introduces a **new capability** to the **JSI (JavaScript Interface)** by adding the `ISerialization` interface and `Serialized` class. This interface provides four methods (`serialize`, `deserialize`, `serializeWithTransfer`, `deserializeWithTransfer`) to facilitate **cross-runtime object serialization and deserialization**. It enables the cloning of `jsi::Value` objects between different JSI runtime instances of the same type, with advanced support for transferring ownership of values. The `Serialized` object's lifetime is independent of the original runtime, allowing for flexible data handling. This significantly enhances inter-runtime communication by providing a standardized and robust mechanism for data exchange.

This commit introduces the `JSI_UNSTABLE` preprocessor flag within the **JSI core API** (`jsi.h`) to establish a controlled release process for new features. This **infrastructure change** allows future JSI additions to be developed and iterated upon as "unstable" until a new Hermes release officially stabilizes them. By gating these features, the project can prevent breaking changes for consumers while new APIs are still subject to modification. The change also includes necessary updates to the **BUCK build system** to support this new flag, laying the groundwork for future API development.

This commit introduces a **new capability** for managing the release of experimental features within the **JavaScript Interface (JSI)**. It adds the `JSI_UNSTABLE` preprocessor flag to `packages/react-native/ReactCommon/jsi/jsi/jsi.h`, which will be used to gate new JSI features, allowing them to be developed and iterated upon before being declared stable. This **infrastructure change** ensures that new JSI APIs can evolve and potentially change interfaces or behavior until a new Hermes release, providing a controlled mechanism for introducing **unstable JSI features**. The change also includes necessary updates to the BUCK build system to support this new flag.

This commit **fixes** the JSI `isArray` method in `hermes.cpp` to align with the JavaScript `Array.isArray` specification. Previously, it incorrectly assumed all JSI arrays were `vm::JSArrays`, but now it correctly treats `JSI::Array` as normal objects, supporting array-like objects such as Proxies. This **bug fix** ensures that the **JSI** accurately identifies arrays, improving compliance and robustness for JavaScript execution within the Hermes engine. New tests in `APITest.cpp` validate this corrected behavior for `isArray`, `size`, `getValueAtIndex`, and `setValueAtIndex`.

This commit provides a **bug fix** for the **JSI** `isArray` method within the **React Native runtime**, specifically in `JSCRuntime.cpp`. It updates the native `isArray` implementation to correctly align with the JavaScript specification's `Array.isArray` behavior. Previously, the JSI method failed to properly identify **Proxy objects** as arrays, leading to inconsistencies. This change ensures that JSI's `isArray` now accurately handles all array types, including proxied arrays, improving the reliability of type checking in native modules.

This commit introduces a **new feature** to the **Hermes SynthTrace** system, enabling the accurate **recording and replaying of JavaScript property access operations** where the property name itself is a `jsi::Value`. It extends the `TracingRuntime` with new overloads for `hasProperty`, `getProperty`, and `setPropertyValue` to capture these dynamic property accesses, and modifies the `TraceInterpreter` to correctly execute them during replay. This enhancement significantly improves the fidelity of recorded traces, which is crucial for **debugging and performance analysis** of applications running on Hermes, and is thoroughly validated by new unit tests.

This commit **fixes an inconsistency** in the **Hermes JavaScript engine's JSI implementation** regarding strict mode behavior for property operations. It corrects the `setPropertyValue` method in `hermes.cpp` to properly utilize the `plusThrowOnError` flag, ensuring it throws an error when attempting invalid operations in strict mode, aligning with expected JavaScript semantics. Additionally, it refines `deleteProperty` by removing redundant error checking, as the `throwOnError` flag already handles strict mode error propagation. This **bug fix** enhances the **robustness and strict mode compliance** of property manipulation within Hermes, with a new test case added to `APITest.cpp` to validate the corrected error-throwing behavior.

This commit introduces a **new capability** to the **Hermes JavaScript engine's JSI implementation**, specifically within `HermesRuntimeImpl`. It adds overloads for the `getProperty`, `hasProperty`, and `setPropertyValue` methods, allowing them to accept a `jsi::Value` as the property name. This enhancement provides **greater flexibility** for dynamic property access from native code, where the property identifier might not be a simple string or `PropNameID`. Unit tests in `APITest.cpp` were also added to validate the correct behavior of these new overloads, ensuring the robustness of this **API extension**.

This commit introduces a **new capability** to the **Hermes Synth Trace** system by adding full support for tracing `deleteProperty` operations. It defines a new `DeletePropertyRecord` type, implements its serialization to JSON, and adds corresponding parsing and replay logic within the `TraceInterpreter`. This enhancement to the **TracingRuntime** ensures that all `deleteProperty` API calls are accurately recorded, allowing for more comprehensive and faithful reproduction of execution scenarios during trace-based debugging and analysis.

This commit introduces a **new capability** to the **Hermes VM** by implementing the `deleteProperty` API. The core implementation in `API/hermes/hermes.cpp` enables the deletion of properties from objects using various identifier types, aligning with the behavior of the JavaScript `delete` operator. A new test case in `unittests/API/APITest.cpp` thoroughly verifies the API's functionality, including its error handling for non-configurable properties. This ensures robust and spec-compliant property deletion within the **Hermes** runtime environment.

This commit introduces a **refactoring** within the **JavaScript Interface (JSI)** library by making the **`jsi::Object` constructor explicit** in `jsi/jsi.h`. This change **prevents implicit conversion** from a `Runtime` object to a `jsi::Object`, which was an incorrect and potentially problematic behavior. By enforcing explicit creation, the commit **enhances type safety** and **eliminates a potential "foot-gun"** where a non-JavaScript object could be mistakenly treated as a `jsi::Object`, ensuring all `jsi::Object` instances are intentionally created as actual JavaScript objects.

This commit **refactors** the **JavaScript Interface (JSI)** by making the `jsi::Object` constructor `explicit`. This change prevents the implicit construction of a `jsi::Object` from a `Runtime` object, which is semantically incorrect and could lead to runtime errors. By enforcing explicit construction, the **JSI core** gains improved type safety and clarity, mitigating a potential "foot-gun" for developers working with the native bridge. This **internal quality improvement** ensures more intentional and correct usage of core JSI types within **React Native**.

This commit introduces a **new capability** to the **JSI (JavaScript Interface)** by adding `Value` overloads for the `getProperty`, `hasProperty`, and `setProperty` methods. This allows C++ code interacting with JavaScript objects to use a generic `jsi::Value` as a property key, enhancing flexibility beyond just string or `PropNameID` keys. The change affects the **JSI Runtime** and **Object APIs**, including their inline implementations and decorator patterns, with the default behavior leveraging `Reflect.get`, `Reflect.has`, and `Reflect.set`. A minor **refactoring** in the **Hermes runtime integration** was also performed to support these new overloads, ensuring broader compatibility and improved dynamic property access.

This commit introduces a **new capability** to the **JavaScript Interface (JSI)** by adding `Value` overloads for the `getProperty`, `hasProperty`, and `setProperty` methods. This enhancement allows these core methods to accept a generic JavaScript `Value` as the property key, providing greater flexibility when interacting with JavaScript objects from C++. The change affects the `Runtime` and `Object` interfaces, including their decorators, and provides default implementations using `Reflect.get`, `Reflect.has`, and `Reflect.set`. This makes JSI more versatile for **React Native** and other consumers needing dynamic property access. New test cases have been added to ensure the correct behavior of these new overloads.

This commit introduces a **new `deleteProperty` API** within the **JSI (JavaScript Interface)**, enabling C++ code to programmatically delete properties from JavaScript objects. This **feature addition** extends the `Runtime` and `Object` classes, declaring and implementing new virtual methods for property deletion, with a default implementation leveraging `Reflect.deleteProperty` in `jsi.cpp`. The `RuntimeDecorator` classes are also updated to support this new capability. This enhancement provides native modules with more comprehensive control over JavaScript object manipulation, allowing for dynamic modification of object structures. A new test case in `testlib.cpp` validates the functionality of this crucial **JSI extension**.

This commit introduces a **new capability** to the **JavaScript Interface (JSI)** by adding a `deleteProperty` API. This API allows native code to **programmatically delete properties from JavaScript objects** through the JSI `Runtime` and `Object` classes, with overloads for various property name types. The implementation in `jsi.cpp` leverages `Reflect.deleteProperty` for standard property removal, enhancing the **JSI's object manipulation capabilities**. This feature provides more granular control over JavaScript object structures from the native side, improving the flexibility of JSI-based interactions.

This commit introduces a significant **refactoring** to the **Hermes tracing infrastructure**, primarily affecting `TraceInterpreter` and `TracingRuntime` components. It **replaces `dynamic_cast` to `IHermes` with direct casting** when Hermes-specific runtime functionalities are required in Synth Traces, streamlining access to the Hermes API. Concurrently, the commit **migrates all `unique_ptr` usages of `jsi::Runtime` to `shared_ptr`**, standardizing runtime object ownership and improving memory management consistency across the tracing system and related tools like `synth.cpp`. This change enhances the robustness and maintainability of **Hermes runtime management** for synthetic traces, including updates to associated unit tests.