Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 224 insertions, 0 deletions

diff --git a/js/src/debugger/Object.h b/js/src/debugger/Object.h
new file mode 100644
index 0000000000..bb3e9a728f
--- /dev/null
+++ b/js/src/debugger/Object.h
@@ -0,0 +1,224 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef debugger_Object_h
+#define debugger_Object_h
+
+#include "mozilla/Assertions.h"  // for AssertionConditionType, MOZ_ASSERT
+#include "mozilla/Maybe.h"       // for Maybe
+#include "mozilla/Range.h"       // for Range
+#include "mozilla/Result.h"      // for Result
+
+#include "jstypes.h"           // for JS_PUBLIC_API
+#include "NamespaceImports.h"  // for Value, MutableHandleValue, HandleId
+
+#include "js/Promise.h"       // for PromiseState
+#include "js/Proxy.h"         // for PropertyDescriptor
+#include "vm/JSObject.h"      // for JSObject (ptr only)
+#include "vm/NativeObject.h"  // for NativeObject
+
+class JS_PUBLIC_API JSAtom;
+struct JS_PUBLIC_API JSContext;
+
+namespace js {
+
+class Completion;
+class Debugger;
+class EvalOptions;
+class GlobalObject;
+class PromiseObject;
+
+class DebuggerObject : public NativeObject {
+ public:
+  static const JSClass class_;
+
+  static NativeObject* initClass(JSContext* cx, Handle<GlobalObject*> global,
+                                 HandleObject debugCtor);
+  static DebuggerObject* create(JSContext* cx, HandleObject proto,
+                                HandleObject referent,
+                                Handle<NativeObject*> debugger);
+
+  void trace(JSTracer* trc);
+
+  // Properties
+  [[nodiscard]] static bool getClassName(JSContext* cx,
+                                         Handle<DebuggerObject*> object,
+                                         MutableHandleString result);
+  [[nodiscard]] static bool getBoundTargetFunction(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      MutableHandle<DebuggerObject*> result);
+  [[nodiscard]] static bool getBoundThis(JSContext* cx,
+                                         Handle<DebuggerObject*> object,
+                                         MutableHandleValue result);
+  [[nodiscard]] static bool getBoundArguments(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      MutableHandle<ValueVector> result);
+  [[nodiscard]] static bool getAllocationSite(JSContext* cx,
+                                              Handle<DebuggerObject*> object,
+                                              MutableHandleObject result);
+  [[nodiscard]] static bool getErrorMessageName(JSContext* cx,
+                                                Handle<DebuggerObject*> object,
+                                                MutableHandleString result);
+  [[nodiscard]] static bool getErrorNotes(JSContext* cx,
+                                          Handle<DebuggerObject*> object,
+                                          MutableHandleValue result);
+  [[nodiscard]] static bool getErrorLineNumber(JSContext* cx,
+                                               Handle<DebuggerObject*> object,
+                                               MutableHandleValue result);
+  [[nodiscard]] static bool getErrorColumnNumber(JSContext* cx,
+                                                 Handle<DebuggerObject*> object,
+                                                 MutableHandleValue result);
+  [[nodiscard]] static bool getScriptedProxyTarget(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      MutableHandle<DebuggerObject*> result);
+  [[nodiscard]] static bool getScriptedProxyHandler(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      MutableHandle<DebuggerObject*> result);
+  [[nodiscard]] static bool getPromiseValue(JSContext* cx,
+                                            Handle<DebuggerObject*> object,
+                                            MutableHandleValue result);
+  [[nodiscard]] static bool getPromiseReason(JSContext* cx,
+                                             Handle<DebuggerObject*> object,
+                                             MutableHandleValue result);
+
+  // Methods
+  [[nodiscard]] static bool isExtensible(JSContext* cx,
+                                         Handle<DebuggerObject*> object,
+                                         bool& result);
+  [[nodiscard]] static bool isSealed(JSContext* cx,
+                                     Handle<DebuggerObject*> object,
+                                     bool& result);
+  [[nodiscard]] static bool isFrozen(JSContext* cx,
+                                     Handle<DebuggerObject*> object,
+                                     bool& result);
+  [[nodiscard]] static JS::Result<Completion> getProperty(
+      JSContext* cx, Handle<DebuggerObject*> object, HandleId id,
+      HandleValue receiver);
+  [[nodiscard]] static JS::Result<Completion> setProperty(
+      JSContext* cx, Handle<DebuggerObject*> object, HandleId id,
+      HandleValue value, HandleValue receiver);
+  [[nodiscard]] static bool getPrototypeOf(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      MutableHandle<DebuggerObject*> result);
+  [[nodiscard]] static bool getOwnPropertyNames(JSContext* cx,
+                                                Handle<DebuggerObject*> object,
+                                                MutableHandleIdVector result);
+  [[nodiscard]] static bool getOwnPropertyNamesLength(
+      JSContext* cx, Handle<DebuggerObject*> object, size_t* result);
+  [[nodiscard]] static bool getOwnPropertySymbols(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      MutableHandleIdVector result);
+  [[nodiscard]] static bool getOwnPrivateProperties(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      MutableHandleIdVector result);
+  [[nodiscard]] static bool getOwnPropertyDescriptor(
+      JSContext* cx, Handle<DebuggerObject*> object, HandleId id,
+      MutableHandle<mozilla::Maybe<PropertyDescriptor>> desc);
+  [[nodiscard]] static bool preventExtensions(JSContext* cx,
+                                              Handle<DebuggerObject*> object);
+  [[nodiscard]] static bool seal(JSContext* cx, Handle<DebuggerObject*> object);
+  [[nodiscard]] static bool freeze(JSContext* cx,
+                                   Handle<DebuggerObject*> object);
+  [[nodiscard]] static bool defineProperty(JSContext* cx,
+                                           Handle<DebuggerObject*> object,
+                                           HandleId id,
+                                           Handle<PropertyDescriptor> desc);
+  [[nodiscard]] static bool defineProperties(
+      JSContext* cx, Handle<DebuggerObject*> object, Handle<IdVector> ids,
+      Handle<PropertyDescriptorVector> descs);
+  [[nodiscard]] static bool deleteProperty(JSContext* cx,
+                                           Handle<DebuggerObject*> object,
+                                           HandleId id, ObjectOpResult& result);
+  [[nodiscard]] static mozilla::Maybe<Completion> call(
+      JSContext* cx, Handle<DebuggerObject*> object, HandleValue thisv,
+      Handle<ValueVector> args);
+  [[nodiscard]] static bool forceLexicalInitializationByName(
+      JSContext* cx, Handle<DebuggerObject*> object, HandleId id, bool& result);
+  [[nodiscard]] static JS::Result<Completion> executeInGlobal(
+      JSContext* cx, Handle<DebuggerObject*> object,
+      mozilla::Range<const char16_t> chars, HandleObject bindings,
+      const EvalOptions& options);
+  [[nodiscard]] static bool makeDebuggeeValue(JSContext* cx,
+                                              Handle<DebuggerObject*> object,
+                                              HandleValue value,
+                                              MutableHandleValue result);
+  [[nodiscard]] static bool makeDebuggeeNativeFunction(
+      JSContext* cx, Handle<DebuggerObject*> object, HandleValue value,
+      MutableHandleValue result);
+  [[nodiscard]] static bool isSameNative(JSContext* cx,
+                                         Handle<DebuggerObject*> object,
+                                         HandleValue value,
+                                         MutableHandleValue result);
+  [[nodiscard]] static bool isNativeGetterWithJitInfo(
+      JSContext* cx, Handle<DebuggerObject*> object, MutableHandleValue result);
+  [[nodiscard]] static bool unsafeDereference(JSContext* cx,
+                                              Handle<DebuggerObject*> object,
+                                              MutableHandleObject result);
+  [[nodiscard]] static bool unwrap(JSContext* cx,
+                                   Handle<DebuggerObject*> object,
+                                   MutableHandle<DebuggerObject*> result);
+
+  // Infallible properties
+  bool isCallable() const;
+  bool isFunction() const;
+  bool isDebuggeeFunction() const;
+  bool isBoundFunction() const;
+  bool isDebuggeeBoundFunction() const;
+  bool isArrowFunction() const;
+  bool isAsyncFunction() const;
+  bool isGeneratorFunction() const;
+  bool isClassConstructor() const;
+  bool isGlobal() const;
+  bool isScriptedProxy() const;
+  bool isPromise() const;
+  bool isError() const;
+  JSAtom* name(JSContext* cx) const;
+  JSAtom* displayName(JSContext* cx) const;
+  JS::PromiseState promiseState() const;
+  double promiseLifetime() const;
+  double promiseTimeToResolution() const;
+
+  Debugger* owner() const;
+
+  JSObject* maybeReferent() const {
+    return maybePtrFromReservedSlot<JSObject>(OBJECT_SLOT);
+  }
+  JSObject* referent() const {
+    JSObject* obj = maybeReferent();
+    MOZ_ASSERT(obj);
+    return obj;
+  }
+
+  void clearReferent() { clearReservedSlotGCThingAsPrivate(OBJECT_SLOT); }
+
+ private:
+  enum { OBJECT_SLOT, OWNER_SLOT, RESERVED_SLOTS };
+
+  static const JSClassOps classOps_;
+
+  static const JSPropertySpec properties_[];
+  static const JSPropertySpec promiseProperties_[];
+  static const JSFunctionSpec methods_[];
+
+  PromiseObject* promise() const;
+
+  [[nodiscard]] static bool requireGlobal(JSContext* cx,
+                                          Handle<DebuggerObject*> object);
+  [[nodiscard]] static bool requirePromise(JSContext* cx,
+                                           Handle<DebuggerObject*> object);
+  [[nodiscard]] static bool construct(JSContext* cx, unsigned argc, Value* vp);
+
+  struct CallData;
+  struct PromiseReactionRecordBuilder;
+
+  [[nodiscard]] static bool getErrorReport(JSContext* cx,
+                                           HandleObject maybeError,
+                                           JSErrorReport*& report);
+};
+
+} /* namespace js */
+
+#endif /* debugger_Object_h */