Merge pull request #73 from mozilla-spidermonkey/esr115

Update to ESR 115

Author: ptomato

docs/Building SpiderMonkey.md

@@ -4,36 +4,28 @@ Use these instructions to build your own copy of SpiderMonkey.
 
 ## Prerequisites ##
 
-You will need a **C++ compiler** that can handle the C++17 standard, **Rust**
-version 1.59 or later, **GNU Make**, **zlib**, and **libffi**.
+You will need a **C++ compiler** that can handle the C++17 standard,
+**Rust** version [1.66][minimum-rust-version] or later, **GNU Make**,
+**zlib**, and **libffi**.
 These can usually be installed with a package manager.
-You will also need **Autoconf 2.13** (not any later version) which is
-also usually available through a package manager.
-The package will usually be called something like `autoconf2.13` rather
-than just `autoconf`.
 
-> **NOTE** SpiderMonkey also requires ICU of at least version 71.1, but
-> it will build a bundled copy by default.
+> **NOTE** SpiderMonkey also requires ICU of at least version
+> [73.1][minimum-icu-version], but it will build a bundled copy by
+> default.
 > If you have a new enough copy installed on your system, you can add
 > `--with-system-icu` in the build instructions below, for a shorter
 > build time.
 
+[minimum-rust-version]: https://searchfox.org/mozilla-esr115/rev/61b47de1faebf23626e519b2464b461589fbea3e/python/mozboot/mozboot/util.py#14
+[minimum-icu-version]: https://searchfox.org/mozilla-esr115/rev/61b47de1faebf23626e519b2464b461589fbea3e/js/moz.configure#1107
+
 ## Getting the source code ##
 
 Currently, the most reliable way to get the SpiderMonkey source code is
 to download the Firefox source.
-At the time of writing, the latest source for Firefox ESR 102, which
-contains the source for SpiderMonkey ESR 102, can be found here:
-https://ftp.mozilla.org/pub/firefox/releases/102.1.0esr/source/
-
-This version is broken for embedder builds so you will need to either
-wait for version 102.2.0 or patch the 102.1.0 source with the fixes for
-the following bugs:
-
- - [1776254 - Cannot build library for SM embedding examples, missing
-   ProfilingCategoryList.h](https://bugzilla.mozilla.org/show_bug.cgi?id=1776254)
- - [1780857 - Embedder build broken in js/public/Debug.h if DEBUG not
-   defined](https://bugzilla.mozilla.org/show_bug.cgi?id=1780857)
+At the time of writing, the latest source for Firefox ESR 115, which
+contains the source for SpiderMonkey ESR 115, can be found here:
+https://ftp.mozilla.org/pub/firefox/releases/115.1.0esr/source/
 
 The ESR releases have a major release approximately once a year with
 security patches released throughout the year.

docs/Migration Guide.md

@@ -5,11 +5,46 @@ of SpiderMonkey to the next ESR version.
 
 ## ESR 102 to ESR 115 ##
 
+### More Versatile `JS_InitClass` ###
+
+In previous versions of SpiderMonkey, the name of the constructor
+function added by `JS_InitClass` was always the name of the prototype
+object's `JSClass`.
+This limitation caused the instances and the prototype to always share
+the same `JSClass` and `JSClassOps` specification.
+If the prototype should behave differently than the instances, custom
+checks were needed.
+Now `JS_InitClass` accepts a `const char *` parameter for naming the
+constructor function, so a different `JSClass *` can be used for the
+prototype object.
+If `nullptr` is passed, the prototype object will be a plain JS object.
+See [this patch from bug 1808171](https://hg.mozilla.org/releases/mozilla-esr115/rev/15e1e69037e370750f704d97d631e23ef32f3812).
+
+### Bound Function Objects ###
+
+Bound function objects (callable functions created with
+`Function.prototype.bind()`) are no longer `JSFunction` objects.
+`JS::GetBuiltinClass()` will not return `js::ESClass::Function` for such
+objects.
+
+Unless you are using `JS::GetBuiltinClass()` to determine whether an
+object is callable, you will most likely not have to migrate anything.
+Consider using `JS::IsCallable()`.
+
+If you need to check whether an object is specifically a bound function
+object, use `JS_ObjectIsBoundFunction()`.
+
 ### Various API changes ###
 
 This is a non-exhaustive list of minor API changes and renames.
 
 - `JS::ModuleInstantiate` → `JS::ModuleLink`
+- `mozilla::Tuple` → `std::tuple` (`<mozilla/Tuple.h>` is removed, use
+  the standard C++ header `<tuple>` instead)
+- `mozilla::IsFinite()` → `std::isfinite()`
+- `mozilla::IsNaN()` → `std::isnan()`
+- Script filenames are now always encoded as UTF-8, see
+  [this patch from bug 1492090](https://hg.mozilla.org/releases/mozilla-esr115/rev/416af93c3205460856a2cae7bee084a656ee2ee9)
 
 ## ESR 91 to ESR 102 ##
 

examples/cookbook.cpp

@@ -819,7 +819,7 @@ static bool MyClassConstructor(JSContext* cx, unsigned argc, JS::Value* vp) {
 
 static bool DefineMyClass(JSContext* cx, JS::HandleObject global) {
   JS::RootedObject protoObj(
-      cx, JS_InitClass(cx, global, nullptr, &myClass,
+      cx, JS_InitClass(cx, global, nullptr, nullptr, myClass.name,
                        // native constructor function and min arg count
                        MyClassConstructor, 2,
 

examples/resolve.cpp

@@ -72,16 +72,6 @@ class Crc {
     return JS::GetMaybePtrFromReservedSlot<Crc>(obj, CrcSlot);
   }
 
-  static bool isPrototype(JSObject* obj) { return getPriv(obj) == nullptr; }
-
-  static bool checkIsInstance(JSContext* cx, JSObject* obj, const char* what) {
-    if (isPrototype(obj)) {
-      JS_ReportErrorASCII(cx, "can't %s on Crc.prototype", what);
-      return false;
-    }
-    return true;
-  }
-
   static bool constructor(JSContext* cx, unsigned argc, JS::Value* vp) {
     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 
@@ -106,26 +96,21 @@ class Crc {
     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
     JS::RootedObject thisObj(cx);
     if (!args.computeThis(cx, &thisObj)) return false;
-    if (!checkIsInstance(cx, thisObj, "call update()")) return false;
+    if (!JS_InstanceOf(cx, thisObj, &Crc::klass, &args)) return false;
     return getPriv(thisObj)->updateImpl(cx, args);
   }
 
   static bool getChecksum(JSContext* cx, unsigned argc, JS::Value* vp) {
     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
     JS::RootedObject thisObj(cx);
     if (!args.computeThis(cx, &thisObj)) return false;
-    if (!checkIsInstance(cx, thisObj, "read checksum")) return false;
+    if (!JS_InstanceOf(cx, thisObj, &Crc::klass, &args)) return false;
     return getPriv(thisObj)->getChecksumImpl(cx, args);
   }
 
   static bool newEnumerate(JSContext* cx, JS::HandleObject obj,
                            JS::MutableHandleIdVector properties,
                            bool enumerableOnly) {
-    // We only want to enumerate if obj is the prototype. For instances, we
-    // should return immediately, and this will be called again on the
-    // prototype.
-    if (!isPrototype(obj)) return true;
-
     jsid idUpdate =
         JS::PropertyKey::fromPinnedString(JS_AtomizeAndPinString(cx, "update"));
     if (!properties.append(idUpdate)) return false;
@@ -139,13 +124,6 @@ class Crc {
 
   static bool resolve(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
                       bool* resolved) {
-    // We only want to resolve if obj is the prototype. For instances, we should
-    // return immediately, and this will be called again on the prototype.
-    if (!isPrototype(obj)) {
-      *resolved = false;
-      return true;
-    }
-
     if (!id.isString()) {
       *resolved = false;
       return true;
@@ -214,24 +192,21 @@ class Crc {
  public:
   static bool DefinePrototype(JSContext* cx) {
     JS::RootedObject global(cx, JS::CurrentGlobalOrNull(cx));
-    JS::RootedObject proto(
-        cx, JS_InitClass(cx,
-                         global,   // the object in which to define the class
-                         nullptr,  // the prototype of the parent class
-                                   // (in our case, no parent class)
-                         &Crc::klass,  // the JSClass defined above
-                         &Crc::constructor,
-                         0,  // constructor and num. args
-                         // The four nullptrs below are for arrays where you
-                         // would list predefined (not lazy) methods and
-                         // properties, static and non-static
-                         nullptr, nullptr, nullptr, nullptr));
-    if (!proto) return false;
-
-    // Here's how we tell the prototype apart from instances. The private
-    // pointer will be null.
-    JS::SetReservedSlot(proto, CrcSlot, JS::UndefinedValue());
-    return true;
+    return JS_InitClass(cx,
+                        global,   // the object in which to define the class
+                        nullptr,  // the prototype object, Crc.prototype
+                                  // (in our case, a plain JS object because
+                                  // calling "Crc.prototype.update" does not
+                                  // make sense)
+                        nullptr,  // the prototype of the parent class (in our
+                                  // case, Object.prototype)
+                        Crc::klass.name,  // "Crc", the constructor name
+                        &Crc::constructor,
+                        0,  // constructor and num. args
+                        // The four nullptrs below are for arrays where you
+                        // would list predefined (not lazy) methods and
+                        // properties, static and non-static
+                        nullptr, nullptr, nullptr, nullptr);
   }
 };
 constexpr JSClassOps Crc::classOps;

meson.build

@@ -1,4 +1,4 @@
-project('spidermonkey-embedding-examples', 'cpp', version: 'esr102',
+project('spidermonkey-embedding-examples', 'cpp', version: 'esr115',
     meson_version: '>= 0.43.0',
     default_options: ['cpp_std=c++17', 'warning_level=3'])
 
@@ -7,7 +7,7 @@ cxx = meson.get_compiler('cpp')
 args = []
 
 zlib = dependency('zlib')  # (is already a SpiderMonkey dependency)
-spidermonkey = dependency('mozjs-102')
+spidermonkey = dependency('mozjs-115')
 readline = cxx.find_library('readline')
 
 # Check if SpiderMonkey was compiled with --enable-debug. If this is the case,