Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 570 insertions, 0 deletions

diff --git a/js/src/vm/ErrorReporting.cpp b/js/src/vm/ErrorReporting.cpp
new file mode 100644
index 0000000000..cfd107345c
--- /dev/null
+++ b/js/src/vm/ErrorReporting.cpp
@@ -0,0 +1,570 @@
+/* -*- 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/. */
+
+#include "vm/ErrorReporting.h"
+
+#include <stdarg.h>
+#include <utility>
+
+#include "jsexn.h"
+#include "jsfriendapi.h"
+
+#include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
+#include "js/Printf.h"                // JS_vsmprintf
+#include "js/Warnings.h"              // JS::WarningReporter
+#include "vm/GlobalObject.h"
+#include "vm/JSContext.h"
+
+#include "vm/JSContext-inl.h"
+
+using namespace js;
+
+using JS::HandleObject;
+using JS::HandleValue;
+using JS::UniqueTwoByteChars;
+
+void js::CallWarningReporter(JSContext* cx, JSErrorReport* reportp) {
+  MOZ_ASSERT(reportp->isWarning());
+
+  if (JS::WarningReporter warningReporter = cx->runtime()->warningReporter) {
+    warningReporter(cx, reportp);
+  }
+}
+
+void js::CompileError::throwError(JSContext* cx) {
+  if (isWarning()) {
+    CallWarningReporter(cx, this);
+    return;
+  }
+
+  // If there's a runtime exception type associated with this error
+  // number, set that as the pending exception.  For errors occuring at
+  // compile time, this is very likely to be a JSEXN_SYNTAXERR.
+  ErrorToException(cx, this, nullptr, nullptr);
+}
+
+bool js::ReportExceptionClosure::operator()(JSContext* cx) {
+  cx->setPendingExceptionAndCaptureStack(exn_);
+  return false;
+}
+
+bool js::ReportCompileWarning(JSContext* cx, ErrorMetadata&& metadata,
+                              UniquePtr<JSErrorNotes> notes,
+                              unsigned errorNumber, va_list* args) {
+  // On the main thread, report the error immediately. When compiling off
+  // thread, save the error so that the thread finishing the parse can report
+  // it later.
+  CompileError tempErr;
+  CompileError* err = &tempErr;
+  if (cx->isHelperThreadContext() && !cx->addPendingCompileError(&err)) {
+    return false;
+  }
+
+  err->notes = std::move(notes);
+  err->isWarning_ = true;
+  err->errorNumber = errorNumber;
+
+  err->filename = metadata.filename;
+  err->lineno = metadata.lineNumber;
+  err->column = metadata.columnNumber;
+  err->isMuted = metadata.isMuted;
+
+  if (UniqueTwoByteChars lineOfContext = std::move(metadata.lineOfContext)) {
+    err->initOwnedLinebuf(lineOfContext.release(), metadata.lineLength,
+                          metadata.tokenOffset);
+  }
+
+  if (!ExpandErrorArgumentsVA(cx, GetErrorMessage, nullptr, errorNumber,
+                              ArgumentsAreLatin1, err, *args)) {
+    return false;
+  }
+
+  if (!cx->isHelperThreadContext()) {
+    err->throwError(cx);
+  }
+
+  return true;
+}
+
+static void ReportCompileErrorImpl(JSContext* cx, js::ErrorMetadata&& metadata,
+                                   js::UniquePtr<JSErrorNotes> notes,
+                                   unsigned errorNumber, va_list* args,
+                                   ErrorArgumentsType argumentsType) {
+  // On the main thread, report the error immediately. When compiling off
+  // thread, save the error so that the thread finishing the parse can report
+  // it later.
+  js::CompileError tempErr;
+  js::CompileError* err = &tempErr;
+  if (cx->isHelperThreadContext() && !cx->addPendingCompileError(&err)) {
+    return;
+  }
+
+  err->notes = std::move(notes);
+  err->isWarning_ = false;
+  err->errorNumber = errorNumber;
+
+  err->filename = metadata.filename;
+  err->lineno = metadata.lineNumber;
+  err->column = metadata.columnNumber;
+  err->isMuted = metadata.isMuted;
+
+  if (UniqueTwoByteChars lineOfContext = std::move(metadata.lineOfContext)) {
+    err->initOwnedLinebuf(lineOfContext.release(), metadata.lineLength,
+                          metadata.tokenOffset);
+  }
+
+  if (!js::ExpandErrorArgumentsVA(cx, js::GetErrorMessage, nullptr, errorNumber,
+                                  argumentsType, err, *args)) {
+    return;
+  }
+
+  if (!cx->isHelperThreadContext()) {
+    err->throwError(cx);
+  }
+}
+
+void js::ReportCompileErrorLatin1(JSContext* cx, ErrorMetadata&& metadata,
+                                  UniquePtr<JSErrorNotes> notes,
+                                  unsigned errorNumber, va_list* args) {
+  ReportCompileErrorImpl(cx, std::move(metadata), std::move(notes), errorNumber,
+                         args, ArgumentsAreLatin1);
+}
+
+void js::ReportCompileErrorUTF8(JSContext* cx, ErrorMetadata&& metadata,
+                                UniquePtr<JSErrorNotes> notes,
+                                unsigned errorNumber, va_list* args) {
+  ReportCompileErrorImpl(cx, std::move(metadata), std::move(notes), errorNumber,
+                         args, ArgumentsAreUTF8);
+}
+
+void js::ReportErrorToGlobal(JSContext* cx, Handle<GlobalObject*> global,
+                             HandleValue error) {
+  MOZ_ASSERT(!cx->isExceptionPending());
+#ifdef DEBUG
+  // No assertSameCompartment version that doesn't take JSContext...
+  if (error.isObject()) {
+    AssertSameCompartment(global, &error.toObject());
+  }
+#endif  // DEBUG
+  js::ReportExceptionClosure report(error);
+  PrepareScriptEnvironmentAndInvoke(cx, global, report);
+}
+
+static void ReportError(JSContext* cx, JSErrorReport* reportp,
+                        JSErrorCallback callback, void* userRef) {
+  if (reportp->isWarning()) {
+    CallWarningReporter(cx, reportp);
+    return;
+  }
+
+  // Check the error report, and set a JavaScript-catchable exception
+  // if the error is defined to have an associated exception.
+  ErrorToException(cx, reportp, callback, userRef);
+}
+
+/*
+ * The given JSErrorReport object have been zeroed and must not outlive
+ * cx->fp() (otherwise owned fields may become invalid).
+ */
+static void PopulateReportBlame(JSContext* cx, JSErrorReport* report) {
+  JS::Realm* realm = cx->realm();
+  if (!realm) {
+    return;
+  }
+
+  /*
+   * Walk stack until we find a frame that is associated with a non-builtin
+   * rather than a builtin frame and which we're allowed to know about.
+   */
+  NonBuiltinFrameIter iter(cx, realm->principals());
+  if (iter.done()) {
+    return;
+  }
+
+  report->filename = iter.filename();
+  if (iter.hasScript()) {
+    report->sourceId = iter.script()->scriptSource()->id();
+  }
+  uint32_t column;
+  report->lineno = iter.computeLine(&column);
+  report->column = FixupColumnForDisplay(column);
+  report->isMuted = iter.mutedErrors();
+}
+
+class MOZ_RAII AutoMessageArgs {
+  size_t totalLength_;
+  /* only {0} thru {9} supported */
+  mozilla::Array<const char*, JS::MaxNumErrorArguments> args_;
+  mozilla::Array<size_t, JS::MaxNumErrorArguments> lengths_;
+  uint16_t count_;
+  bool allocatedElements_ : 1;
+
+ public:
+  AutoMessageArgs() : totalLength_(0), count_(0), allocatedElements_(false) {
+    PodArrayZero(args_);
+  }
+
+  ~AutoMessageArgs() {
+    /* free the arguments only if we allocated them */
+    if (allocatedElements_) {
+      uint16_t i = 0;
+      while (i < count_) {
+        if (args_[i]) {
+          js_free((void*)args_[i]);
+        }
+        i++;
+      }
+    }
+  }
+
+  const char* args(size_t i) const {
+    MOZ_ASSERT(i < count_);
+    return args_[i];
+  }
+
+  size_t totalLength() const { return totalLength_; }
+
+  size_t lengths(size_t i) const {
+    MOZ_ASSERT(i < count_);
+    return lengths_[i];
+  }
+
+  uint16_t count() const { return count_; }
+
+  /* Gather the arguments into an array, and accumulate their sizes.
+   *
+   * We could template on the type of argsArg, but we're already trusting people
+   * to do the right thing with varargs, so might as well trust them on this
+   * part too.  Upstream consumers do assert that it's the right thing.  Also,
+   * if argsArg were strongly typed we'd still need casting below for this to
+   * compile, because typeArg is not known at compile-time here.
+   */
+  bool init(JSContext* cx, void* argsArg, uint16_t countArg,
+            ErrorArgumentsType typeArg, va_list ap) {
+    MOZ_ASSERT(countArg > 0);
+
+    count_ = countArg;
+
+    for (uint16_t i = 0; i < count_; i++) {
+      switch (typeArg) {
+        case ArgumentsAreASCII:
+        case ArgumentsAreUTF8: {
+          const char* c = argsArg ? static_cast<const char**>(argsArg)[i]
+                                  : va_arg(ap, const char*);
+          args_[i] = c;
+          MOZ_ASSERT_IF(typeArg == ArgumentsAreASCII,
+                        JS::StringIsASCII(args_[i]));
+          lengths_[i] = strlen(args_[i]);
+          break;
+        }
+        case ArgumentsAreLatin1: {
+          MOZ_ASSERT(!argsArg);
+          const Latin1Char* latin1 = va_arg(ap, Latin1Char*);
+          size_t len = strlen(reinterpret_cast<const char*>(latin1));
+          mozilla::Range<const Latin1Char> range(latin1, len);
+          char* utf8 = JS::CharsToNewUTF8CharsZ(cx, range).c_str();
+          if (!utf8) {
+            return false;
+          }
+
+          args_[i] = utf8;
+          lengths_[i] = strlen(utf8);
+          allocatedElements_ = true;
+          break;
+        }
+        case ArgumentsAreUnicode: {
+          const char16_t* uc = argsArg
+                                   ? static_cast<const char16_t**>(argsArg)[i]
+                                   : va_arg(ap, const char16_t*);
+          size_t len = js_strlen(uc);
+          mozilla::Range<const char16_t> range(uc, len);
+          char* utf8 = JS::CharsToNewUTF8CharsZ(cx, range).c_str();
+          if (!utf8) {
+            return false;
+          }
+
+          args_[i] = utf8;
+          lengths_[i] = strlen(utf8);
+          allocatedElements_ = true;
+          break;
+        }
+      }
+      totalLength_ += lengths_[i];
+    }
+    return true;
+  }
+};
+
+/*
+ * The arguments from ap need to be packaged up into an array and stored
+ * into the report struct.
+ *
+ * The format string addressed by the error number may contain operands
+ * identified by the format {N}, where N is a decimal digit. Each of these
+ * is to be replaced by the Nth argument from the va_list. The complete
+ * message is placed into reportp->message_.
+ *
+ * Returns true if the expansion succeeds (can fail if out of memory).
+ *
+ * messageArgs is a `const char**` or a `const char16_t**` but templating on
+ * that is not worth it here because AutoMessageArgs takes a void* anyway, and
+ * using void* here simplifies our callers a bit.
+ */
+template <typename T>
+static bool ExpandErrorArgumentsHelper(JSContext* cx, JSErrorCallback callback,
+                                       void* userRef,
+                                       const unsigned errorNumber,
+                                       void* messageArgs,
+                                       ErrorArgumentsType argumentsType,
+                                       T* reportp, va_list ap) {
+  const JSErrorFormatString* efs;
+
+  if (!callback) {
+    callback = GetErrorMessage;
+  }
+
+  {
+    gc::AutoSuppressGC suppressGC(cx);
+    efs = callback(userRef, errorNumber);
+  }
+
+  if (efs) {
+    if constexpr (std::is_same_v<T, JSErrorReport>) {
+      reportp->exnType = efs->exnType;
+    }
+
+    MOZ_ASSERT(reportp->errorNumber == errorNumber);
+    reportp->errorMessageName = efs->name;
+
+    MOZ_ASSERT_IF(argumentsType == ArgumentsAreASCII,
+                  JS::StringIsASCII(efs->format));
+
+    uint16_t argCount = efs->argCount;
+    MOZ_RELEASE_ASSERT(argCount <= JS::MaxNumErrorArguments);
+    if (argCount > 0) {
+      /*
+       * Parse the error format, substituting the argument X
+       * for {X} in the format.
+       */
+      if (efs->format) {
+        const char* fmt;
+        char* out;
+#ifdef DEBUG
+        int expandedArgs = 0;
+#endif
+        size_t expandedLength;
+        size_t len = strlen(efs->format);
+
+        AutoMessageArgs args;
+        if (!args.init(cx, messageArgs, argCount, argumentsType, ap)) {
+          return false;
+        }
+
+        expandedLength = len - (3 * args.count()) /* exclude the {n} */
+                         + args.totalLength();
+
+        /*
+         * Note - the above calculation assumes that each argument
+         * is used once and only once in the expansion !!!
+         */
+        char* utf8 = out = cx->pod_malloc<char>(expandedLength + 1);
+        if (!out) {
+          return false;
+        }
+
+        fmt = efs->format;
+        while (*fmt) {
+          if (*fmt == '{') {
+            if (mozilla::IsAsciiDigit(fmt[1])) {
+              int d = AsciiDigitToNumber(fmt[1]);
+              MOZ_RELEASE_ASSERT(d < args.count());
+              strncpy(out, args.args(d), args.lengths(d));
+              out += args.lengths(d);
+              fmt += 3;
+#ifdef DEBUG
+              expandedArgs++;
+#endif
+              continue;
+            }
+          }
+          *out++ = *fmt++;
+        }
+        MOZ_ASSERT(expandedArgs == args.count());
+        *out = 0;
+
+        reportp->initOwnedMessage(utf8);
+      }
+    } else {
+      /* Non-null messageArgs should have at least one non-null arg. */
+      MOZ_ASSERT(!messageArgs);
+      /*
+       * Zero arguments: the format string (if it exists) is the
+       * entire message.
+       */
+      if (efs->format) {
+        reportp->initBorrowedMessage(efs->format);
+      }
+    }
+  }
+  if (!reportp->message()) {
+    /* where's the right place for this ??? */
+    const char* defaultErrorMessage =
+        "No error message available for error number %d";
+    size_t nbytes = strlen(defaultErrorMessage) + 16;
+    char* message = cx->pod_malloc<char>(nbytes);
+    if (!message) {
+      return false;
+    }
+    snprintf(message, nbytes, defaultErrorMessage, errorNumber);
+    reportp->initOwnedMessage(message);
+  }
+  return true;
+}
+
+bool js::ExpandErrorArgumentsVA(JSContext* cx, JSErrorCallback callback,
+                                void* userRef, const unsigned errorNumber,
+                                const char16_t** messageArgs,
+                                ErrorArgumentsType argumentsType,
+                                JSErrorReport* reportp, va_list ap) {
+  MOZ_ASSERT(argumentsType == ArgumentsAreUnicode);
+  return ExpandErrorArgumentsHelper(cx, callback, userRef, errorNumber,
+                                    messageArgs, argumentsType, reportp, ap);
+}
+
+bool js::ExpandErrorArgumentsVA(JSContext* cx, JSErrorCallback callback,
+                                void* userRef, const unsigned errorNumber,
+                                const char** messageArgs,
+                                ErrorArgumentsType argumentsType,
+                                JSErrorReport* reportp, va_list ap) {
+  MOZ_ASSERT(argumentsType != ArgumentsAreUnicode);
+  return ExpandErrorArgumentsHelper(cx, callback, userRef, errorNumber,
+                                    messageArgs, argumentsType, reportp, ap);
+}
+
+bool js::ExpandErrorArgumentsVA(JSContext* cx, JSErrorCallback callback,
+                                void* userRef, const unsigned errorNumber,
+                                ErrorArgumentsType argumentsType,
+                                JSErrorReport* reportp, va_list ap) {
+  return ExpandErrorArgumentsHelper(cx, callback, userRef, errorNumber, nullptr,
+                                    argumentsType, reportp, ap);
+}
+
+bool js::ExpandErrorArgumentsVA(JSContext* cx, JSErrorCallback callback,
+                                void* userRef, const unsigned errorNumber,
+                                const char16_t** messageArgs,
+                                ErrorArgumentsType argumentsType,
+                                JSErrorNotes::Note* notep, va_list ap) {
+  return ExpandErrorArgumentsHelper(cx, callback, userRef, errorNumber,
+                                    messageArgs, argumentsType, notep, ap);
+}
+
+bool js::ReportErrorNumberVA(JSContext* cx, IsWarning isWarning,
+                             JSErrorCallback callback, void* userRef,
+                             const unsigned errorNumber,
+                             ErrorArgumentsType argumentsType, va_list ap) {
+  JSErrorReport report;
+  report.isWarning_ = isWarning == IsWarning::Yes;
+  report.errorNumber = errorNumber;
+  PopulateReportBlame(cx, &report);
+
+  if (!ExpandErrorArgumentsVA(cx, callback, userRef, errorNumber, argumentsType,
+                              &report, ap)) {
+    return false;
+  }
+
+  ReportError(cx, &report, callback, userRef);
+
+  return report.isWarning();
+}
+
+template <typename CharT>
+static bool ExpandErrorArguments(JSContext* cx, JSErrorCallback callback,
+                                 void* userRef, const unsigned errorNumber,
+                                 const CharT** messageArgs,
+                                 js::ErrorArgumentsType argumentsType,
+                                 JSErrorReport* reportp, ...) {
+  va_list ap;
+  va_start(ap, reportp);
+  bool expanded =
+      js::ExpandErrorArgumentsVA(cx, callback, userRef, errorNumber,
+                                 messageArgs, argumentsType, reportp, ap);
+  va_end(ap);
+  return expanded;
+}
+
+template <js::ErrorArgumentsType argType, typename CharT>
+static bool ReportErrorNumberArray(JSContext* cx, IsWarning isWarning,
+                                   JSErrorCallback callback, void* userRef,
+                                   const unsigned errorNumber,
+                                   const CharT** args) {
+  static_assert(
+      (argType == ArgumentsAreUnicode && std::is_same_v<CharT, char16_t>) ||
+          (argType != ArgumentsAreUnicode && std::is_same_v<CharT, char>),
+      "Mismatch between character type and argument type");
+
+  JSErrorReport report;
+  report.isWarning_ = isWarning == IsWarning::Yes;
+  report.errorNumber = errorNumber;
+  PopulateReportBlame(cx, &report);
+
+  if (!ExpandErrorArguments(cx, callback, userRef, errorNumber, args, argType,
+                            &report)) {
+    return false;
+  }
+
+  ReportError(cx, &report, callback, userRef);
+
+  return report.isWarning();
+}
+
+bool js::ReportErrorNumberUCArray(JSContext* cx, IsWarning isWarning,
+                                  JSErrorCallback callback, void* userRef,
+                                  const unsigned errorNumber,
+                                  const char16_t** args) {
+  return ReportErrorNumberArray<ArgumentsAreUnicode>(
+      cx, isWarning, callback, userRef, errorNumber, args);
+}
+
+bool js::ReportErrorNumberUTF8Array(JSContext* cx, IsWarning isWarning,
+                                    JSErrorCallback callback, void* userRef,
+                                    const unsigned errorNumber,
+                                    const char** args) {
+  return ReportErrorNumberArray<ArgumentsAreUTF8>(cx, isWarning, callback,
+                                                  userRef, errorNumber, args);
+}
+
+bool js::ReportErrorVA(JSContext* cx, IsWarning isWarning, const char* format,
+                       js::ErrorArgumentsType argumentsType, va_list ap) {
+  JSErrorReport report;
+
+  UniqueChars message(JS_vsmprintf(format, ap));
+  if (!message) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  MOZ_ASSERT_IF(argumentsType == ArgumentsAreASCII,
+                JS::StringIsASCII(message.get()));
+
+  report.isWarning_ = isWarning == IsWarning::Yes;
+  report.errorNumber = JSMSG_USER_DEFINED_ERROR;
+  if (argumentsType == ArgumentsAreASCII || argumentsType == ArgumentsAreUTF8) {
+    report.initOwnedMessage(message.release());
+  } else {
+    MOZ_ASSERT(argumentsType == ArgumentsAreLatin1);
+    JS::Latin1Chars latin1(message.get(), strlen(message.get()));
+    JS::UTF8CharsZ utf8(JS::CharsToNewUTF8CharsZ(cx, latin1));
+    if (!utf8) {
+      return false;
+    }
+    report.initOwnedMessage(reinterpret_cast<const char*>(utf8.get()));
+  }
+  PopulateReportBlame(cx, &report);
+
+  ReportError(cx, &report, nullptr, nullptr);
+
+  return report.isWarning();
+}