react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactCommon/hermes/inspector/chrome/MessageTypes.cpp

@@ -1,5 +1,5 @@
 // Copyright 2004-present Facebook. All Rights Reserved.
-// @generated SignedSource<<e4c911229f0e8cac24dbc3ec8a933d5e>>
+// @generated SignedSource<<522f29c54f207a4f7b5c33af07cf64d0>>
 
 #include "MessageTypes.h"
 
@@ -46,8 +46,16 @@ std::unique_ptr<Request> Request::fromJsonThrowOnError(const std::string &str) {
       {"Debugger.stepOver", makeUnique<debugger::StepOverRequest>},
       {"HeapProfiler.collectGarbage",
        makeUnique<heapProfiler::CollectGarbageRequest>},
+      {"HeapProfiler.getHeapObjectId",
+       makeUnique<heapProfiler::GetHeapObjectIdRequest>},
+      {"HeapProfiler.getObjectByHeapObjectId",
+       makeUnique<heapProfiler::GetObjectByHeapObjectIdRequest>},
+      {"HeapProfiler.startSampling",
+       makeUnique<heapProfiler::StartSamplingRequest>},
       {"HeapProfiler.startTrackingHeapObjects",
        makeUnique<heapProfiler::StartTrackingHeapObjectsRequest>},
+      {"HeapProfiler.stopSampling",
+       makeUnique<heapProfiler::StopSamplingRequest>},
       {"HeapProfiler.stopTrackingHeapObjects",
        makeUnique<heapProfiler::StopTrackingHeapObjectsRequest>},
       {"HeapProfiler.takeHeapSnapshot",
@@ -219,6 +227,53 @@ dynamic debugger::CallFrame::toDynamic() const {
   return obj;
 }
 
+heapProfiler::SamplingHeapProfileNode::SamplingHeapProfileNode(
+    const dynamic &obj) {
+  assign(callFrame, obj, "callFrame");
+  assign(selfSize, obj, "selfSize");
+  assign(id, obj, "id");
+  assign(children, obj, "children");
+}
+
+dynamic heapProfiler::SamplingHeapProfileNode::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "callFrame", callFrame);
+  put(obj, "selfSize", selfSize);
+  put(obj, "id", id);
+  put(obj, "children", children);
+  return obj;
+}
+
+heapProfiler::SamplingHeapProfileSample::SamplingHeapProfileSample(
+    const dynamic &obj) {
+  assign(size, obj, "size");
+  assign(nodeId, obj, "nodeId");
+  assign(ordinal, obj, "ordinal");
+}
+
+dynamic heapProfiler::SamplingHeapProfileSample::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "size", size);
+  put(obj, "nodeId", nodeId);
+  put(obj, "ordinal", ordinal);
+  return obj;
+}
+
+heapProfiler::SamplingHeapProfile::SamplingHeapProfile(const dynamic &obj) {
+  assign(head, obj, "head");
+  assign(samples, obj, "samples");
+}
+
+dynamic heapProfiler::SamplingHeapProfile::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "head", head);
+  put(obj, "samples", samples);
+  return obj;
+}
+
 runtime::ExecutionContextDescription::ExecutionContextDescription(
     const dynamic &obj) {
   assign(id, obj, "id");
@@ -679,6 +734,92 @@ void heapProfiler::CollectGarbageRequest::accept(
   handler.handle(*this);
 }
 
+heapProfiler::GetHeapObjectIdRequest::GetHeapObjectIdRequest()
+    : Request("HeapProfiler.getHeapObjectId") {}
+
+heapProfiler::GetHeapObjectIdRequest::GetHeapObjectIdRequest(const dynamic &obj)
+    : Request("HeapProfiler.getHeapObjectId") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(objectId, params, "objectId");
+}
+
+dynamic heapProfiler::GetHeapObjectIdRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "objectId", objectId);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void heapProfiler::GetHeapObjectIdRequest::accept(
+    RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
+heapProfiler::GetObjectByHeapObjectIdRequest::GetObjectByHeapObjectIdRequest()
+    : Request("HeapProfiler.getObjectByHeapObjectId") {}
+
+heapProfiler::GetObjectByHeapObjectIdRequest::GetObjectByHeapObjectIdRequest(
+    const dynamic &obj)
+    : Request("HeapProfiler.getObjectByHeapObjectId") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(objectId, params, "objectId");
+  assign(objectGroup, params, "objectGroup");
+}
+
+dynamic heapProfiler::GetObjectByHeapObjectIdRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "objectId", objectId);
+  put(params, "objectGroup", objectGroup);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void heapProfiler::GetObjectByHeapObjectIdRequest::accept(
+    RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
+heapProfiler::StartSamplingRequest::StartSamplingRequest()
+    : Request("HeapProfiler.startSampling") {}
+
+heapProfiler::StartSamplingRequest::StartSamplingRequest(const dynamic &obj)
+    : Request("HeapProfiler.startSampling") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(samplingInterval, params, "samplingInterval");
+}
+
+dynamic heapProfiler::StartSamplingRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "samplingInterval", samplingInterval);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void heapProfiler::StartSamplingRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 heapProfiler::StartTrackingHeapObjectsRequest::StartTrackingHeapObjectsRequest()
     : Request("HeapProfiler.startTrackingHeapObjects") {}
 
@@ -708,6 +849,26 @@ void heapProfiler::StartTrackingHeapObjectsRequest::accept(
   handler.handle(*this);
 }
 
+heapProfiler::StopSamplingRequest::StopSamplingRequest()
+    : Request("HeapProfiler.stopSampling") {}
+
+heapProfiler::StopSamplingRequest::StopSamplingRequest(const dynamic &obj)
+    : Request("HeapProfiler.stopSampling") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+}
+
+dynamic heapProfiler::StopSamplingRequest::toDynamic() const {
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  return obj;
+}
+
+void heapProfiler::StopSamplingRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 heapProfiler::StopTrackingHeapObjectsRequest::StopTrackingHeapObjectsRequest()
     : Request("HeapProfiler.stopTrackingHeapObjects") {}
 
@@ -973,6 +1134,59 @@ dynamic debugger::SetInstrumentationBreakpointResponse::toDynamic() const {
   return obj;
 }
 
+heapProfiler::GetHeapObjectIdResponse::GetHeapObjectIdResponse(
+    const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(heapSnapshotObjectId, res, "heapSnapshotObjectId");
+}
+
+dynamic heapProfiler::GetHeapObjectIdResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "heapSnapshotObjectId", heapSnapshotObjectId);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
+heapProfiler::GetObjectByHeapObjectIdResponse::GetObjectByHeapObjectIdResponse(
+    const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(result, res, "result");
+}
+
+dynamic heapProfiler::GetObjectByHeapObjectIdResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "result", result);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
+heapProfiler::StopSamplingResponse::StopSamplingResponse(const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(profile, res, "profile");
+}
+
+dynamic heapProfiler::StopSamplingResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "profile", profile);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
 runtime::EvaluateResponse::EvaluateResponse(const dynamic &obj) {
   assign(id, obj, "id");
 

package/ReactCommon/hermes/inspector/chrome/MessageTypes.h

@@ -1,5 +1,5 @@
 // Copyright 2004-present Facebook. All Rights Reserved.
-// @generated SignedSource<<e3e5526b8e266b560b9dc9e42cc0d6c5>>
+// @generated SignedSource<<a541d174394c8959b9fb6a7c575e7040>>
 
 #pragma once
 
@@ -72,10 +72,21 @@ using UnserializableValue = std::string;
 namespace heapProfiler {
 struct AddHeapSnapshotChunkNotification;
 struct CollectGarbageRequest;
+struct GetHeapObjectIdRequest;
+struct GetHeapObjectIdResponse;
+struct GetObjectByHeapObjectIdRequest;
+struct GetObjectByHeapObjectIdResponse;
+using HeapSnapshotObjectId = std::string;
 struct HeapStatsUpdateNotification;
 struct LastSeenObjectIdNotification;
 struct ReportHeapSnapshotProgressNotification;
+struct SamplingHeapProfile;
+struct SamplingHeapProfileNode;
+struct SamplingHeapProfileSample;
+struct StartSamplingRequest;
 struct StartTrackingHeapObjectsRequest;
+struct StopSamplingRequest;
+struct StopSamplingResponse;
 struct StopTrackingHeapObjectsRequest;
 struct TakeHeapSnapshotRequest;
 } // namespace heapProfiler
@@ -101,8 +112,13 @@ struct RequestHandler {
   virtual void handle(const debugger::StepOutRequest &req) = 0;
   virtual void handle(const debugger::StepOverRequest &req) = 0;
   virtual void handle(const heapProfiler::CollectGarbageRequest &req) = 0;
+  virtual void handle(const heapProfiler::GetHeapObjectIdRequest &req) = 0;
+  virtual void handle(
+      const heapProfiler::GetObjectByHeapObjectIdRequest &req) = 0;
+  virtual void handle(const heapProfiler::StartSamplingRequest &req) = 0;
   virtual void handle(
       const heapProfiler::StartTrackingHeapObjectsRequest &req) = 0;
+  virtual void handle(const heapProfiler::StopSamplingRequest &req) = 0;
   virtual void handle(
       const heapProfiler::StopTrackingHeapObjectsRequest &req) = 0;
   virtual void handle(const heapProfiler::TakeHeapSnapshotRequest &req) = 0;
@@ -130,8 +146,13 @@ struct NoopRequestHandler : public RequestHandler {
   void handle(const debugger::StepOutRequest &req) override {}
   void handle(const debugger::StepOverRequest &req) override {}
   void handle(const heapProfiler::CollectGarbageRequest &req) override {}
+  void handle(const heapProfiler::GetHeapObjectIdRequest &req) override {}
+  void handle(
+      const heapProfiler::GetObjectByHeapObjectIdRequest &req) override {}
+  void handle(const heapProfiler::StartSamplingRequest &req) override {}
   void handle(
       const heapProfiler::StartTrackingHeapObjectsRequest &req) override {}
+  void handle(const heapProfiler::StopSamplingRequest &req) override {}
   void handle(
       const heapProfiler::StopTrackingHeapObjectsRequest &req) override {}
   void handle(const heapProfiler::TakeHeapSnapshotRequest &req) override {}
@@ -230,6 +251,36 @@ struct debugger::CallFrame : public Serializable {
   folly::Optional<runtime::RemoteObject> returnValue;
 };
 
+struct heapProfiler::SamplingHeapProfileNode : public Serializable {
+  SamplingHeapProfileNode() = default;
+  explicit SamplingHeapProfileNode(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  runtime::CallFrame callFrame{};
+  double selfSize{};
+  int id{};
+  std::vector<heapProfiler::SamplingHeapProfileNode> children;
+};
+
+struct heapProfiler::SamplingHeapProfileSample : public Serializable {
+  SamplingHeapProfileSample() = default;
+  explicit SamplingHeapProfileSample(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  double size{};
+  int nodeId{};
+  double ordinal{};
+};
+
+struct heapProfiler::SamplingHeapProfile : public Serializable {
+  SamplingHeapProfile() = default;
+  explicit SamplingHeapProfile(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  heapProfiler::SamplingHeapProfileNode head{};
+  std::vector<heapProfiler::SamplingHeapProfileSample> samples;
+};
+
 struct runtime::ExecutionContextDescription : public Serializable {
   ExecutionContextDescription() = default;
   explicit ExecutionContextDescription(const folly::dynamic &obj);
@@ -424,6 +475,37 @@ struct heapProfiler::CollectGarbageRequest : public Request {
   void accept(RequestHandler &handler) const override;
 };
 
+struct heapProfiler::GetHeapObjectIdRequest : public Request {
+  GetHeapObjectIdRequest();
+  explicit GetHeapObjectIdRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+
+  runtime::RemoteObjectId objectId{};
+};
+
+struct heapProfiler::GetObjectByHeapObjectIdRequest : public Request {
+  GetObjectByHeapObjectIdRequest();
+  explicit GetObjectByHeapObjectIdRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+
+  heapProfiler::HeapSnapshotObjectId objectId{};
+  folly::Optional<std::string> objectGroup;
+};
+
+struct heapProfiler::StartSamplingRequest : public Request {
+  StartSamplingRequest();
+  explicit StartSamplingRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+
+  folly::Optional<double> samplingInterval;
+};
+
 struct heapProfiler::StartTrackingHeapObjectsRequest : public Request {
   StartTrackingHeapObjectsRequest();
   explicit StartTrackingHeapObjectsRequest(const folly::dynamic &obj);
@@ -434,6 +516,14 @@ struct heapProfiler::StartTrackingHeapObjectsRequest : public Request {
   folly::Optional<bool> trackAllocations;
 };
 
+struct heapProfiler::StopSamplingRequest : public Request {
+  StopSamplingRequest();
+  explicit StopSamplingRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+};
+
 struct heapProfiler::StopTrackingHeapObjectsRequest : public Request {
   StopTrackingHeapObjectsRequest();
   explicit StopTrackingHeapObjectsRequest(const folly::dynamic &obj);
@@ -544,6 +634,30 @@ struct debugger::SetInstrumentationBreakpointResponse : public Response {
   debugger::BreakpointId breakpointId{};
 };
 
+struct heapProfiler::GetHeapObjectIdResponse : public Response {
+  GetHeapObjectIdResponse() = default;
+  explicit GetHeapObjectIdResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  heapProfiler::HeapSnapshotObjectId heapSnapshotObjectId{};
+};
+
+struct heapProfiler::GetObjectByHeapObjectIdResponse : public Response {
+  GetObjectByHeapObjectIdResponse() = default;
+  explicit GetObjectByHeapObjectIdResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  runtime::RemoteObject result{};
+};
+
+struct heapProfiler::StopSamplingResponse : public Response {
+  StopSamplingResponse() = default;
+  explicit StopSamplingResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  heapProfiler::SamplingHeapProfile profile{};
+};
+
 struct runtime::EvaluateResponse : public Response {
   EvaluateResponse() = default;
   explicit EvaluateResponse(const folly::dynamic &obj);

package/ReactCommon/hermes/inspector/chrome/tests/ConnectionTests.cpp

@@ -22,6 +22,7 @@
 #include <hermes/DebuggerAPI.h>
 #include <hermes/hermes.h>
 #include <hermes/inspector/chrome/MessageTypes.h>
+#include <jsi/instrumentation.h>
 
 namespace facebook {
 namespace hermes {
@@ -199,6 +200,12 @@ ResponseType send(SyncConnection &conn, int id) {
   return expectResponse<ResponseType>(conn, id);
 }
 
+template <typename RequestType, typename ResponseType = m::OkResponse>
+ResponseType send(SyncConnection &conn, RequestType req) {
+  conn.send(req.toJson());
+  return expectResponse<ResponseType>(conn, req.id);
+}
+
 void sendRuntimeEvalRequest(
     SyncConnection &conn,
     int id,
@@ -2449,6 +2456,143 @@ TEST(ConnectionTests, runIfWaitingForDebugger) {
   expectNotification<m::debugger::ResumedNotification>(conn);
 }
 
+TEST(ConnectionTests, heapProfilerSampling) {
+  TestContext context;
+  AsyncHermesRuntime &asyncRuntime = context.runtime();
+  SyncConnection &conn = context.conn();
+  int msgId = 1;
+
+  send<m::debugger::EnableRequest>(conn, msgId++);
+  expectExecutionContextCreated(conn);
+
+  asyncRuntime.executeScriptAsync(R"(
+      debugger;
+      function allocator() {
+        // Do some allocation.
+        return new Object;
+      }
+      (function main() {
+        var a = [];
+        for (var i = 0; i < 100; i++) {
+          a[i] = allocator();
+        }
+      })();
+      debugger;
+    )");
+  expectNotification<m::debugger::ScriptParsedNotification>(conn);
+
+  // We should get a pause before the first statement.
+  expectNotification<m::debugger::PausedNotification>(conn);
+
+  {
+    m::heapProfiler::StartSamplingRequest req;
+    req.id = msgId++;
+    // Sample every 256 bytes to ensure there are some samples. The default is
+    // 32768, which is too high for a small example. Note that sampling is a
+    // random process, so there's no guarantee there will be any samples in any
+    // finite number of allocations. In practice the likelihood is so high that
+    // there shouldn't be any issues.
+    req.samplingInterval = 256;
+    send(conn, req);
+  }
+  // Resume, run the allocations, and once it's paused again, stop them.
+  send<m::debugger::ResumeRequest>(conn, msgId++);
+  expectNotification<m::debugger::ResumedNotification>(conn);
+  expectNotification<m::debugger::PausedNotification>(conn);
+  // Send the stop sampling request, expect the value coming back to be JSON.
+  auto resp = send<
+      m::heapProfiler::StopSamplingRequest,
+      m::heapProfiler::StopSamplingResponse>(conn, msgId++);
+  // Make sure there were some samples.
+  EXPECT_NE(resp.profile.samples.size(), 0);
+  // Don't test the content of the JSON, that is tested via the
+  // SamplingHeapProfilerTest.
+
+  // Resume and exit
+  send<m::debugger::ResumeRequest>(conn, msgId++);
+  expectNotification<m::debugger::ResumedNotification>(conn);
+}
+
+TEST(ConnectionTests, heapSnapshotRemoteObject) {
+  TestContext context;
+  AsyncHermesRuntime &asyncRuntime = context.runtime();
+  std::shared_ptr<HermesRuntime> runtime = asyncRuntime.runtime();
+  SyncConnection &conn = context.conn();
+  int msgId = 1;
+
+  send<m::debugger::EnableRequest>(conn, msgId++);
+  expectExecutionContextCreated(conn);
+
+  asyncRuntime.executeScriptAsync(R"(
+    storeValue([1, 2, 3]);
+    debugger;
+  )");
+  expectNotification<m::debugger::ScriptParsedNotification>(conn);
+
+  // We should get a pause before the first statement.
+  expectNotification<m::debugger::PausedNotification>(conn);
+
+  {
+    // Take a heap snapshot first to assign IDs.
+    m::heapProfiler::TakeHeapSnapshotRequest req;
+    req.id = msgId++;
+    req.reportProgress = false;
+    // We don't need the response because we can directly query for object IDs
+    // from the runtime.
+    send(conn, req);
+  }
+
+  const uint64_t globalObjID = runtime->getUniqueID(runtime->global());
+  jsi::Value storedValue = asyncRuntime.awaitStoredValue();
+  const uint64_t storedObjID =
+      runtime->getUniqueID(storedValue.asObject(*runtime));
+
+  auto testObject = [&msgId, &conn](
+                        uint64_t objID,
+                        const char *type,
+                        const char *className,
+                        const char *description,
+                        const char *subtype) {
+    // Get the object by its snapshot ID.
+    m::heapProfiler::GetObjectByHeapObjectIdRequest req;
+    req.id = msgId++;
+    req.objectId = std::to_string(objID);
+    auto resp = send<
+        m::heapProfiler::GetObjectByHeapObjectIdRequest,
+        m::heapProfiler::GetObjectByHeapObjectIdResponse>(conn, req);
+    EXPECT_EQ(resp.result.type, type);
+    EXPECT_EQ(resp.result.className, className);
+    EXPECT_EQ(resp.result.description, description);
+    if (subtype) {
+      EXPECT_EQ(resp.result.subtype, subtype);
+    }
+
+    // Check that fetching the object by heap snapshot ID works.
+    m::heapProfiler::GetHeapObjectIdRequest idReq;
+    idReq.id = msgId++;
+    idReq.objectId = resp.result.objectId.value();
+    auto idResp = send<
+        m::heapProfiler::GetHeapObjectIdRequest,
+        m::heapProfiler::GetHeapObjectIdResponse>(conn, idReq);
+    EXPECT_EQ(atoi(idResp.heapSnapshotObjectId.c_str()), objID);
+  };
+
+  // Test once before a collection.
+  testObject(globalObjID, "object", "Object", "Object", nullptr);
+  testObject(storedObjID, "object", "Array", "Array(3)", "array");
+  // Force a collection to move the heap.
+  runtime->instrumentation().collectGarbage("test");
+  // A collection should not disturb the unique ID lookup, and it should be the
+  // same object as before. Note that it won't have the same remote ID, because
+  // Hermes doesn't do uniquing.
+  testObject(globalObjID, "object", "Object", "Object", nullptr);
+  testObject(storedObjID, "object", "Array", "Array(3)", "array");
+
+  // Resume and exit.
+  send<m::debugger::ResumeRequest>(conn, msgId++);
+  expectNotification<m::debugger::ResumedNotification>(conn);
+}
+
 } // namespace chrome
 } // namespace inspector
 } // namespace hermes

package/ReactCommon/hermes/inspector/tools/message_types.txt

@@ -22,8 +22,12 @@ HeapProfiler.reportHeapSnapshotProgress
 HeapProfiler.takeHeapSnapshot
 HeapProfiler.startTrackingHeapObjects
 HeapProfiler.stopTrackingHeapObjects
+HeapProfiler.startSampling
+HeapProfiler.stopSampling
 HeapProfiler.heapStatsUpdate
 HeapProfiler.lastSeenObjectId
+HeapProfiler.getObjectByHeapObjectId
+HeapProfiler.getHeapObjectId
 Runtime.consoleAPICalled
 Runtime.evaluate
 Runtime.executionContextCreated

package/ReactCommon/hermes/inspector/tools/msggen/__tests__/CommandTest.js

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
-import { Command } from '../src/Command.js';
+import {Command} from '../src/Command.js';
 
 test('parses simple command', () => {
   let obj = {

package/ReactCommon/hermes/inspector/tools/msggen/__tests__/EventTest.js

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
-import { Event } from '../src/Event.js';
+import {Event} from '../src/Event.js';
 
 test('parses simple event', () => {
   let obj = {

package/ReactCommon/hermes/inspector/tools/msggen/__tests__/GraphTest.js

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
-import { Graph } from '../src/Graph.js';
+import {Graph} from '../src/Graph.js';
 
 // graph looks like this before test: https://pxl.cl/9k8t
 let graph = null;

package/ReactCommon/hermes/inspector/tools/msggen/__tests__/HeaderWriterTest.js

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
-import { expectCodeIsEqual, FakeWritable } from '../src/TestHelpers';
+import {expectCodeIsEqual, FakeWritable} from '../src/TestHelpers';
 import {
   emitNotificationDecl,
   emitRequestDecl,

package/ReactCommon/hermes/inspector/tools/msggen/__tests__/ImplementationWriterTest.js

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
-import { expectCodeIsEqual, FakeWritable } from '../src/TestHelpers';
+import {expectCodeIsEqual, FakeWritable} from '../src/TestHelpers';
 import {
   emitNotificationDef,
   emitRequestDef,

package/ReactCommon/hermes/inspector/tools/msggen/__tests__/PropertyTest.js

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
-import { Property } from '../src/Property.js';
+import {Property} from '../src/Property.js';
 
 test('parses required primitive prop', () => {
   let obj = {

package/ReactCommon/hermes/inspector/tools/msggen/__tests__/TypeTest.js

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
-import { Type } from '../src/Type.js';
+import {Type} from '../src/Type.js';
 
 test('parses primitive type', () => {
   let obj = {