refactor(android): unify static hermes backend

Switches Android Hermes over to the same Static Hermes header/library surface used by Apple and keeps SHERMES only as a compatibility selector. This absorbs the earlier transient Hermes adapter/header alignment work so reviewers see one Hermes unification step.

Author: DjDeveloperr

NativeScript/napi/hermes/README.md

@@ -0,0 +1,12 @@
+Hermes Node-API adapter
+=======================
+
+`include/` is the single vendored Static Hermes header surface used by both
+Apple and Android builds. It comes from `DjDeveloperr/build-hermes` and must
+stay in sync with the Hermes binaries under `Frameworks/` and
+`platforms/android/test-app/runtime/src/main/libs/hermes/`.
+
+Android still accepts the historical `SHERMES` engine selector so existing
+test/build scripts keep working, but it is now only an alias for `HERMES`.
+Both selectors compile the same adapter and link the same Static Hermes
+artifact.

NativeScript/napi/hermes/include/hermes/AsyncDebuggerAPI.h

@@ -5,8 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifndef HERMES_ASYNCDEBUGGERAPI_H
-#define HERMES_ASYNCDEBUGGERAPI_H
+#pragma once
 
 #ifdef HERMES_ENABLE_DEBUGGER
 
@@ -68,8 +67,6 @@ using DebuggerEventCallback = std::function<void(
     HermesRuntime &runtime,
     AsyncDebuggerAPI &asyncDebugger,
     DebuggerEventType event)>;
-using DebuggerEventCallbackID = uint32_t;
-constexpr const uint32_t kInvalidDebuggerEventCallbackID = 0;
 using InterruptCallback = std::function<void(HermesRuntime &runtime)>;
 using EvalCompleteCallback = std::function<
     void(HermesRuntime &runtime, const debugger::EvalResult &result)>;
@@ -82,36 +79,34 @@ using EvalCompleteCallback = std::function<
 /// functions that are safe to call on any thread. All other functions must be
 /// called on the runtime thread.
 class HERMES_EXPORT AsyncDebuggerAPI : private debugger::EventObserver {
-  /// Hide the constructor so users can only construct via static create
-  /// methods.
-  AsyncDebuggerAPI(HermesRuntime &runtime);
-
  public:
-  /// Creates an AsyncDebuggerAPI for use with the provided HermesRuntime. This
-  /// should be called and created at the same time as creating HermesRuntime.
-  static std::unique_ptr<AsyncDebuggerAPI> create(HermesRuntime &runtime);
+  /// Constructs an AsyncDebuggerAPI for use with the provided HermesRuntime.
+  /// This should be called and created at the same time as creating
+  /// HermesRuntime.
+  explicit AsyncDebuggerAPI(HermesRuntime &runtime);
 
   /// Must be destroyed on the runtime thread or when you're sure nothing is
   /// interacting with the runtime. Must be destroyed before destroying
   /// HermesRuntime.
   ~AsyncDebuggerAPI() override;
 
-  /// Add a callback function to invoke when the runtime pauses due to various
+  /// Set a callback function to invoke when the runtime pauses due to various
   /// conditions such as hitting a "debugger;" statement. Can be called from any
-  /// thread. If there are no DebuggerEventCallback, then any reason that might
+  /// thread. If there is no DebuggerEventCallback, then any reason that might
   /// trigger a pause, such as a "debugger;" statement or breakpoints, will not
-  /// actually pause and will simply continue execution. Any caller that adds an
+  /// actually pause and will simply continue execution. Any caller that sets an
   /// event callback cannot just be observing events and never call
   /// \p resumeFromPaused in any of its code paths. The caller must either
   /// expose UI enabling human action for controlling the debugger, or it must
   /// have programmatic logic that controls the debugger via
   /// \p resumeFromPaused.
-  DebuggerEventCallbackID addDebuggerEventCallback_TS(
-      DebuggerEventCallback callback);
+  ///
+  /// The provided callback must be non-empty. Use \p
+  /// clearDebuggerEventCallback_TS to clear the callback.
+  void setDebuggerEventCallback_TS(DebuggerEventCallback callback);
 
-  /// Remove a previously added callback function. If there is no callback
-  /// registered using the provided \p id, the function does nothing.
-  void removeDebuggerEventCallback_TS(DebuggerEventCallbackID id);
+  /// Clear the debugger event callback. Can be called from any thread.
+  void clearDebuggerEventCallback_TS();
 
   /// Whether the runtime is currently paused waiting for the next action.
   /// Should only be called from the runtime thread.
@@ -120,7 +115,7 @@ class HERMES_EXPORT AsyncDebuggerAPI : private debugger::EventObserver {
   /// Whether the runtime is currently paused for any reason (e.g. script
   /// parsed, running interrupts, or waiting for a command).
   /// Should only be called from the runtime thread.
-  bool isPaused();
+  bool isPaused() const;
 
   /// Provide the next action to perform. Should only be called from the runtime
   /// thread and only if the next command is expected to be set.
@@ -145,11 +140,6 @@ class HERMES_EXPORT AsyncDebuggerAPI : private debugger::EventObserver {
   debugger::Command didPause(debugger::Debugger &debugger) override;
 
  private:
-  struct EventCallbackEntry {
-    DebuggerEventCallbackID id;
-    DebuggerEventCallback callback;
-  };
-
   /// This function infinite loops and uses \p signal_ to block the runtime
   /// thread. It gets woken up if new InterruptCallback is queued or if
   /// DebuggerEventCallback changes.
@@ -163,11 +153,8 @@ class HERMES_EXPORT AsyncDebuggerAPI : private debugger::EventObserver {
   /// to run all interrupts, but will stop if any interrupt sets a next command.
   void runInterrupts(bool ignoreNextCommand = true);
 
-  /// Returns the next DebuggerEventCallback to execute if any.
-  std::optional<DebuggerEventCallback> takeNextEventCallback();
-
-  /// Runs every DebuggerEventCallback that has been registered.
-  void runEventCallbacks(DebuggerEventType event);
+  /// Runs the DebuggerEventCallback that has been registered (if any).
+  void runEventCallback(DebuggerEventType event);
 
   HermesRuntime &runtime_;
 
@@ -186,19 +173,8 @@ class HERMES_EXPORT AsyncDebuggerAPI : private debugger::EventObserver {
   /// calls to didPause.
   bool inDidPause_ = false;
 
-  /// Next ID to use when adding a DebuggerEventCallback.
-  uint32_t nextEventCallbackID_ TSA_GUARDED_BY(mutex_);
-
-  /// Callback functions to invoke to notify events in \p didPause. Using
-  /// std::list which requires O(N) search when removing an element, but removal
-  /// should be a rare event. So the choice of using std::list is to optimize
-  /// for typical usage.
-  std::list<EventCallbackEntry> eventCallbacks_ TSA_GUARDED_BY(mutex_){};
-
-  /// Iterator for eventCallbacks_. Used to traverse through the list when
-  /// running the callbacks.
-  std::list<EventCallbackEntry>::iterator eventCallbackIterator_
-      TSA_GUARDED_BY(mutex_);
+  /// The debugger event callback to invoke when the runtime pauses.
+  DebuggerEventCallback eventCallback_ TSA_GUARDED_BY(mutex_){};
 
   /// Queue of interrupt callback functions to invoke.
   std::queue<InterruptCallback> interruptCallbacks_ TSA_GUARDED_BY(mutex_){};
@@ -257,32 +233,25 @@ using DebuggerEventCallback = std::function<void(
     HermesRuntime &runtime,
     AsyncDebuggerAPI &asyncDebugger,
     DebuggerEventType event)>;
-using DebuggerEventCallbackID = uint32_t;
-constexpr const uint32_t kInvalidDebuggerEventCallbackID = 0;
 using InterruptCallback = std::function<void(HermesRuntime &runtime)>;
 using EvalCompleteCallback = std::function<
     void(HermesRuntime &runtime, const debugger::EvalResult &result)>;
 
 class HERMES_EXPORT AsyncDebuggerAPI {
  public:
-  static std::unique_ptr<AsyncDebuggerAPI> create(HermesRuntime &runtime) {
-    return nullptr;
-  }
+  explicit AsyncDebuggerAPI(HermesRuntime &) {}
 
   ~AsyncDebuggerAPI() {}
 
-  DebuggerEventCallbackID addDebuggerEventCallback_TS(
-      DebuggerEventCallback callback) {
-    return kInvalidDebuggerEventCallbackID;
-  }
+  void setDebuggerEventCallback_TS(DebuggerEventCallback callback) {}
 
-  void removeDebuggerEventCallback_TS(DebuggerEventCallbackID id) {}
+  void clearDebuggerEventCallback_TS() {}
 
   bool isWaitingForCommand() {
     return false;
   }
 
-  bool isPaused() {
+  bool isPaused() const {
     return false;
   }
 
@@ -305,5 +274,3 @@ class HERMES_EXPORT AsyncDebuggerAPI {
 } // namespace facebook
 
 #endif // !HERMES_ENABLE_DEBUGGER
-
-#endif // HERMES_ASYNCDEBUGGERAPI_H

NativeScript/napi/hermes/include/hermes/CompileJS.h

@@ -5,8 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifndef HERMES_COMPILEJS_H
-#define HERMES_COMPILEJS_H
+#pragma once
 
 #include <optional>
 #include <string>
@@ -68,6 +67,31 @@ bool compileJS(
     std::string &bytecode,
     bool optimize = true);
 
-} // namespace hermes
+/// Options for overload of compileJS that accepts CompileJSOptions.
+struct CompileJSOptions {
+  /// If true, the bytecode will be optimized.
+  bool optimize{true};
+  /// Maximum number of instructions (in addition to parameter handling)
+  /// that is allowed for inlining of small functions.
+  unsigned inlineMaxSize{50};
+  /// If true, the bytecode will be interruptable.
+  bool emitAsyncBreakCheck{false};
+  /// If true, debugging information will be generated in the bytecode.
+  bool debug{false};
+  /// Enable ES6 block scoping support.
+  bool enableES6BlockScoping{false};
+  /// Enable async generators support.
+  bool enableAsyncGenerators{false};
+};
 
-#endif
+/// Like the other compileJS overloads, but takes a struct of options with some
+/// additional configurability.
+bool compileJS(
+    const std::string &str,
+    const std::string &sourceURL,
+    std::string &bytecode,
+    const CompileJSOptions &options,
+    DiagnosticHandler *diagHandler,
+    std::optional<std::string_view> sourceMapBuf = std::nullopt);
+
+} // namespace hermes

NativeScript/napi/hermes/include/hermes/DebuggerAPI.h

@@ -5,8 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifndef HERMES_DEBUGGERAPI_H
-#define HERMES_DEBUGGERAPI_H
+#pragma once
 
 #ifdef HERMES_ENABLE_DEBUGGER
 
@@ -31,6 +30,9 @@ class HermesValue;
 namespace facebook {
 namespace hermes {
 class HermesRuntime;
+// Forward declaration of the internal Root API class, which is marked as a
+// friend of the Debugger.
+class HermesRootAPI;
 
 namespace debugger {
 
@@ -269,6 +271,7 @@ class HERMES_EXPORT Debugger {
   ::facebook::jsi::Value getThrownValue();
 
  private:
+  friend HermesRootAPI;
   friend std::unique_ptr<HermesRuntime> hermes::makeHermesRuntime(
       const ::hermes::vm::RuntimeConfig &);
   friend std::unique_ptr<jsi::ThreadSafeRuntime>
@@ -497,5 +500,3 @@ class EventObserver {
 } // namespace facebook
 
 #endif // !HERMES_ENABLE_DEBUGGER
-
-#endif // HERMES_DEBUGGERAPI_H

NativeScript/napi/hermes/include/hermes/Public/Buffer.h

@@ -5,8 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifndef HERMES_PUBLIC_CTORCONFIG_H
-#define HERMES_PUBLIC_CTORCONFIG_H
+#pragma once
 
 #include <utility>
 
@@ -128,11 +127,11 @@
     return TypeAsSingleToken{__VA_ARGS__};             \
   }
 
-#define _HERMES_CTORCONFIG_SETTER(CX, TYPE, NAME, ...) \
-  inline auto with##NAME(TYPE NAME)->decltype(*this) { \
-    config_.NAME##_ = std::move(NAME);                 \
-    NAME##Explicit_ = true;                            \
-    return *this;                                      \
+#define _HERMES_CTORCONFIG_SETTER(CX, TYPE, NAME, ...)   \
+  inline auto with##NAME(TYPE NAME) -> decltype(*this) { \
+    config_.NAME##_ = std::move(NAME);                   \
+    NAME##Explicit_ = true;                              \
+    return *this;                                        \
   }
 
 #define _HERMES_CTORCONFIG_BUILDER_GETTER(CX, TYPE, NAME, ...) \
@@ -144,5 +143,3 @@
   if (newConfig.has##NAME()) {                         \
     with##NAME(newConfig.config_.get##NAME());         \
   }
-
-#endif //  HERMES_PUBLIC_CTORCONFIG_H

NativeScript/napi/hermes/include/hermes/Public/CtorConfig.h

@@ -5,17 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifndef HERMES_PUBLIC_DEBUGGERTYPES_H
-#define HERMES_PUBLIC_DEBUGGERTYPES_H
+#pragma once
 
 #include <cstdint>
 #include <string>
 #include <vector>
-#pragma GCC diagnostic push
 
-#ifdef HERMES_COMPILER_SUPPORTS_WSHORTEN_64_TO_32
-#pragma GCC diagnostic ignored "-Wshorten-64-to-32"
-#endif
 namespace hermes {
 namespace vm {
 class Debugger;
@@ -88,7 +83,7 @@ struct StackTrace {
 
  private:
   explicit StackTrace(std::vector<CallFrameInfo> frames)
-      : frames_(std::move(frames)){};
+      : frames_(std::move(frames)) {};
   friend ProgramState;
   friend ::hermes::vm::Debugger;
   std::vector<CallFrameInfo> frames_;
@@ -196,5 +191,3 @@ struct BreakpointInfo {
 } // namespace debugger
 } // namespace hermes
 } // namespace facebook
-
-#endif