--- a/js/public/BuildId.h
+++ b/js/public/BuildId.h
@@ -52,17 +52,17 @@ extern JS_PUBLIC_API void SetProcessBuil
  *   * the buildId defined by the embedder-provided BuildIdOp set by
  *     JS::SetProcessBuildIdOp, and
  *   * CPU feature information for the current CPU.
  *
  * Embedders may use this function to tag cached data whose validity depends
  * on having consistent buildId *and* on the CPU supporting features identical
  * to those in play when the cached data was computed.
  */
-extern MOZ_MUST_USE JS_PUBLIC_API bool GetOptimizedEncodingBuildId(
+[[nodiscard]] extern JS_PUBLIC_API bool GetOptimizedEncodingBuildId(
     BuildIdCharVector* buildId);
 
 /**
  * Script bytecode is dependent on the buildId and a few other things.
  *
  * This function produces a buildId that includes:
  *
  *   * The buildId defined by the embedder-provided BuildIdOp set by
@@ -71,14 +71,14 @@ extern MOZ_MUST_USE JS_PUBLIC_API bool G
  *     other state XDR buffers depend on.
  *
  * Note: this value may depend on runtime preferences so isn't guaranteed to be
  * stable across restarts.
  *
  * Embedders should use this function to tag transcoded bytecode.
  * See Transcoding.h.
  */
-extern MOZ_MUST_USE JS_PUBLIC_API bool GetScriptTranscodingBuildId(
+[[nodiscard]] extern JS_PUBLIC_API bool GetScriptTranscodingBuildId(
     BuildIdCharVector* buildId);
 
 }  // namespace JS
 
 #endif /* js_BuildId_h */

--- a/js/public/SourceText.h
+++ b/js/public/SourceText.h
@@ -133,19 +133,19 @@ class SourceText final {
    * If |ownership == TakeOwnership|, *this function* takes ownership of
    * |units|, *even if* this function fails, and you MUST NOT free |units|
    * yourself.  This single-owner-friendly approach reduces risk of leaks on
    * failure.
    *
    * |units| may be null if |unitsLength == 0|; if so, this will silently be
    * initialized using non-null, unowned units.
    */
-  MOZ_IS_CLASS_INIT MOZ_MUST_USE bool init(JSContext* cx, const Unit* units,
-                                           size_t unitsLength,
-                                           SourceOwnership ownership) {
+  [[nodiscard]] MOZ_IS_CLASS_INIT bool init(JSContext* cx, const Unit* units,
+                                            size_t unitsLength,
+                                            SourceOwnership ownership) {
     MOZ_ASSERT_IF(units == nullptr, unitsLength == 0);
 
     // Ideally we'd use |Unit| and not cast below, but the risk of a static
     // initializer is too great.
     static const CharT emptyString[] = {'\0'};
 
     // Initialize all fields *before* checking length.  This ensures that
     // if |ownership == SourceOwnership::TakeOwnership|, |units| will be
@@ -177,19 +177,19 @@ class SourceText final {
    *
    * (We can't just write this to accept |const CharT*|, because then in the
    * UTF-16 case this overload and the one above would be identical.  So we
    * use SFINAE to expose the |CharT| overload only if it's different.)
    */
   template <typename Char,
             typename = std::enable_if_t<std::is_same_v<Char, CharT> &&
                                         !std::is_same_v<Char, Unit>>>
-  MOZ_IS_CLASS_INIT MOZ_MUST_USE bool init(JSContext* cx, const Char* chars,
-                                           size_t charsLength,
-                                           SourceOwnership ownership) {
+  [[nodiscard]] MOZ_IS_CLASS_INIT bool init(JSContext* cx, const Char* chars,
+                                            size_t charsLength,
+                                            SourceOwnership ownership) {
     return init(cx, reinterpret_cast<const Unit*>(chars), charsLength,
                 ownership);
   }
 
   /**
    * Initialize this using source units transferred out of |data|.
    */
   [[nodiscard]] bool init(JSContext* cx,

--- a/js/public/String.h
+++ b/js/public/String.h
@@ -188,38 +188,38 @@ MOZ_ALWAYS_INLINE void LossyCopyLinearSt
 }
 
 /**
  * Copy characters in |s[start..start + len]| to |dest[0..len]|.
  *
  * This function is fallible.  If you already have a linear string, use the
  * infallible |JS::CopyLinearStringChars| above instead.
  */
-inline MOZ_MUST_USE bool CopyStringChars(JSContext* cx, char16_t* dest,
-                                         JSString* s, size_t len,
-                                         size_t start = 0) {
+[[nodiscard]] inline bool CopyStringChars(JSContext* cx, char16_t* dest,
+                                          JSString* s, size_t len,
+                                          size_t start = 0) {
   JSLinearString* linear = StringToLinearString(cx, s);
   if (!linear) {
     return false;
   }
 
   CopyLinearStringChars(dest, linear, len, start);
   return true;
 }
 
 /**
  * Copy characters in |s[start..start + len]| to |dest[0..len]|, lossily
  * truncating 16-bit values to |char| if necessary.
  *
  * This function is fallible.  If you already have a linear string, use the
  * infallible |JS::LossyCopyLinearStringChars| above instead.
  */
-inline MOZ_MUST_USE bool LossyCopyStringChars(JSContext* cx, char* dest,
-                                              JSString* s, size_t len,
-                                              size_t start = 0) {
+[[nodiscard]] inline bool LossyCopyStringChars(JSContext* cx, char* dest,
+                                               JSString* s, size_t len,
+                                               size_t start = 0) {
   JSLinearString* linear = StringToLinearString(cx, s);
   if (!linear) {
     return false;
   }
 
   LossyCopyLinearStringChars(dest, linear, len, start);
   return true;
 }

--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -289,17 +289,17 @@ class BaseStackFrame {
   //         V
   //     SavedFrame
   //
   // is lossy because we cannot serialize and deserialize the SavedFrame's
   // principals in the offline heap snapshot, so JS::ubi::StackFrame
   // simplifies the principals check into the boolean isSystem() state. This
   // is fine because we only expose JS::ubi::Stack to devtools and chrome
   // code, and not to the web platform.
-  virtual MOZ_MUST_USE bool constructSavedFrameStack(
+  [[nodiscard]] virtual bool constructSavedFrameStack(
       JSContext* cx, MutableHandleObject outSavedFrameStack) const = 0;
 
   // Trace the concrete implementation of JS::ubi::StackFrame.
   virtual void trace(JSTracer* trc) = 0;
 };
 
 // A traits template with a specialization for each backing type that implements
 // the ubi::BaseStackFrame interface. Each specialization must be the a subclass

--- a/js/public/UbiNodeCensus.h
+++ b/js/public/UbiNodeCensus.h
@@ -104,24 +104,24 @@ struct CountType {
   // to this type. Return a nullptr on OOM.
   virtual CountBasePtr makeCount() = 0;
 
   // Trace |count| and all its children, for garbage collection.
   virtual void traceCount(CountBase& count, JSTracer* trc) = 0;
 
   // Implement the 'count' method for counts returned by this CountType
   // instance's 'newCount' method.
-  virtual MOZ_MUST_USE bool count(CountBase& count,
-                                  mozilla::MallocSizeOf mallocSizeOf,
-                                  const Node& node) = 0;
+  [[nodiscard]] virtual bool count(CountBase& count,
+                                   mozilla::MallocSizeOf mallocSizeOf,
+                                   const Node& node) = 0;
 
   // Implement the 'report' method for counts returned by this CountType
   // instance's 'newCount' method.
-  virtual MOZ_MUST_USE bool report(JSContext* cx, CountBase& count,
-                                   MutableHandleValue report) = 0;
+  [[nodiscard]] virtual bool report(JSContext* cx, CountBase& count,
+                                    MutableHandleValue report) = 0;
 };
 
 using CountTypePtr = js::UniquePtr<CountType>;
 
 // An abstract base class for count tree nodes.
 class CountBase {
   // In lieu of a vtable, each CountBase points to its type, which
   // carries not only the implementations of the CountBase methods, but also

--- a/js/public/UbiNodeDominatorTree.h
+++ b/js/public/UbiNodeDominatorTree.h
@@ -317,20 +317,20 @@ class JS_PUBLIC_API DominatorTree {
         finger2 = doms[finger2];
       }
     }
     return finger1;
   }
 
   // Do the post order traversal of the heap graph and populate our
   // predecessor sets.
-  static MOZ_MUST_USE bool doTraversal(JSContext* cx, AutoCheckCannotGC& noGC,
-                                       const Node& root,
-                                       JS::ubi::Vector<Node>& postOrder,
-                                       PredecessorSets& predecessorSets) {
+  [[nodiscard]] static bool doTraversal(JSContext* cx, AutoCheckCannotGC& noGC,
+                                        const Node& root,
+                                        JS::ubi::Vector<Node>& postOrder,
+                                        PredecessorSets& predecessorSets) {
     uint32_t nodeCount = 0;
     auto onNode = [&](const Node& node) {
       nodeCount++;
       if (MOZ_UNLIKELY(nodeCount == UINT32_MAX)) {
         return false;
       }
       return postOrder.append(node);
     };
@@ -349,33 +349,33 @@ class JS_PUBLIC_API DominatorTree {
     };
 
     PostOrder traversal(cx, noGC);
     return traversal.addStart(root) && traversal.traverse(onNode, onEdge);
   }
 
   // Populates the given `map` with an entry for each node to its index in
   // `postOrder`.
-  static MOZ_MUST_USE bool mapNodesToTheirIndices(
+  [[nodiscard]] static bool mapNodesToTheirIndices(
       JS::ubi::Vector<Node>& postOrder, NodeToIndexMap& map) {
     MOZ_ASSERT(map.empty());
     MOZ_ASSERT(postOrder.length() < UINT32_MAX);
     uint32_t length = postOrder.length();
     if (!map.reserve(length)) {
       return false;
     }
     for (uint32_t i = 0; i < length; i++) {
       map.putNewInfallible(postOrder[i], i);
     }
     return true;
   }
 
   // Convert the Node -> NodeSet predecessorSets to a index -> Vector<index>
   // form.
-  static MOZ_MUST_USE bool convertPredecessorSetsToVectors(
+  [[nodiscard]] static bool convertPredecessorSetsToVectors(
       const Node& root, JS::ubi::Vector<Node>& postOrder,
       PredecessorSets& predecessorSets, NodeToIndexMap& nodeToPostOrderIndex,
       JS::ubi::Vector<JS::ubi::Vector<uint32_t>>& predecessorVectors) {
     MOZ_ASSERT(postOrder.length() < UINT32_MAX);
     uint32_t length = postOrder.length();
 
     MOZ_ASSERT(predecessorVectors.length() == 0);
     if (!predecessorVectors.growBy(length)) {
@@ -405,18 +405,18 @@ class JS_PUBLIC_API DominatorTree {
       }
     }
     predecessorSets.clearAndCompact();
     return true;
   }
 
   // Initialize `doms` such that the immediate dominator of the `root` is the
   // `root` itself and all others are `UNDEFINED`.
-  static MOZ_MUST_USE bool initializeDominators(JS::ubi::Vector<uint32_t>& doms,
-                                                uint32_t length) {
+  [[nodiscard]] static bool initializeDominators(
+      JS::ubi::Vector<uint32_t>& doms, uint32_t length) {
     MOZ_ASSERT(doms.length() == 0);
     if (!doms.growByUninitialized(length)) {
       return false;
     }
     doms[length - 1] = length - 1;
     for (uint32_t i = 0; i < length - 1; i++) {
       doms[i] = UNDEFINED;
     }

--- a/js/src/builtin/AtomicsObject.h
+++ b/js/src/builtin/AtomicsObject.h
@@ -24,17 +24,17 @@ class AtomicsObject : public NativeObjec
  public:
   static const JSClass class_;
 };
 
 class FutexThread {
   friend class AutoLockFutexAPI;
 
  public:
-  static MOZ_MUST_USE bool initialize();
+  [[nodiscard]] static bool initialize();
   static void destroy();
 
   static void lock();
   static void unlock();
 
   FutexThread();
   [[nodiscard]] bool initInstance();
   void destroyInstance();

--- a/js/src/builtin/Eval.h
+++ b/js/src/builtin/Eval.h
@@ -13,22 +13,22 @@
 
 namespace js {
 
 // The C++ native for 'eval' (ES5 15.1.2.1). The function is named "indirect
 // eval" because "direct eval" calls (as defined by the spec) will emit
 // JSOp::Eval which in turn calls DirectEval. Thus, even though IndirectEval is
 // the callee function object for *all* calls to eval, it is by construction
 // only ever called in the case indirect eval.
-extern MOZ_MUST_USE bool IndirectEval(JSContext* cx, unsigned argc, Value* vp);
+[[nodiscard]] extern bool IndirectEval(JSContext* cx, unsigned argc, Value* vp);
 
 // Performs a direct eval of |v| (a string containing code, or another value
 // that will be vacuously returned), which must correspond to the currently-
 // executing stack frame, which must be a script frame.
-extern MOZ_MUST_USE bool DirectEval(JSContext* cx, HandleValue v,
-                                    MutableHandleValue vp);
+[[nodiscard]] extern bool DirectEval(JSContext* cx, HandleValue v,
+                                     MutableHandleValue vp);
 
 // True iff fun is a built-in eval function.
 extern bool IsAnyBuiltinEval(JSFunction* fun);
 
 }  // namespace js
 
 #endif /* builtin_Eval_h */

--- a/js/src/builtin/HandlerFunction-inl.h
+++ b/js/src/builtin/HandlerFunction-inl.h
@@ -35,79 +35,79 @@ namespace js {
 // extended slots.
 constexpr size_t HandlerFunctionSlot_Target = 0;
 constexpr size_t HandlerFunctionSlot_Extra = 1;
 
 static_assert(HandlerFunctionSlot_Extra < FunctionExtended::NUM_EXTENDED_SLOTS,
               "handler function slots shouldn't exceed available extended "
               "slots");
 
-inline MOZ_MUST_USE JSFunction* NewHandler(JSContext* cx, Native handler,
-                                           JS::Handle<JSObject*> target) {
+[[nodiscard]] inline JSFunction* NewHandler(JSContext* cx, Native handler,
+                                            JS::Handle<JSObject*> target) {
   cx->check(target);
 
   JS::Handle<PropertyName*> funName = cx->names().empty;
   JS::Rooted<JSFunction*> handlerFun(
       cx, NewNativeFunction(cx, handler, 0, funName,
                             gc::AllocKind::FUNCTION_EXTENDED, GenericObject));
   if (!handlerFun) {
     return nullptr;
   }
   handlerFun->setExtendedSlot(HandlerFunctionSlot_Target,
                               JS::ObjectValue(*target));
   return handlerFun;
 }
 
-inline MOZ_MUST_USE JSFunction* NewHandlerWithExtra(
+[[nodiscard]] inline JSFunction* NewHandlerWithExtra(
     JSContext* cx, Native handler, JS::Handle<JSObject*> target,
     JS::Handle<JSObject*> extra) {
   cx->check(extra);
   JSFunction* handlerFun = NewHandler(cx, handler, target);
   if (handlerFun) {
     handlerFun->setExtendedSlot(HandlerFunctionSlot_Extra,
                                 JS::ObjectValue(*extra));
   }
   return handlerFun;
 }
 
-inline MOZ_MUST_USE JSFunction* NewHandlerWithExtraValue(
+[[nodiscard]] inline JSFunction* NewHandlerWithExtraValue(
     JSContext* cx, Native handler, JS::Handle<JSObject*> target,
     JS::Handle<JS::Value> extra) {
   cx->check(extra);
   JSFunction* handlerFun = NewHandler(cx, handler, target);
   if (handlerFun) {
     handlerFun->setExtendedSlot(HandlerFunctionSlot_Extra, extra);
   }
   return handlerFun;
 }
 
 /**
  * Within the call of a handler function that "closes over" a target value that
  * is always a |T*| object (and never a wrapper around one), return that |T*|.
  */
 template <class T>
-inline MOZ_MUST_USE T* TargetFromHandler(const JS::CallArgs& args) {
+[[nodiscard]] inline T* TargetFromHandler(const JS::CallArgs& args) {
   JSFunction& func = args.callee().as<JSFunction>();
   return &func.getExtendedSlot(HandlerFunctionSlot_Target).toObject().as<T>();
 }
 
 /**
  * Within the call of a handler function that "closes over" a target value and
  * an extra value, return that extra value.
  */
-inline MOZ_MUST_USE JS::Value ExtraValueFromHandler(const JS::CallArgs& args) {
+[[nodiscard]] inline JS::Value ExtraValueFromHandler(const JS::CallArgs& args) {
   JSFunction& func = args.callee().as<JSFunction>();
   return func.getExtendedSlot(HandlerFunctionSlot_Extra);
 }
 
 /**
  * Within the call of a handler function that "closes over" a target value and
  * an extra value, where that extra value is always a |T*| object (and never a
  * wrapper around one), return that |T*|.
  */
 template <class T>
-inline MOZ_MUST_USE T* ExtraFromHandler(const JS::CallArgs& args) {
+[[nodiscard]] inline T* ExtraFromHandler(const JS::CallArgs& args) {
   return &ExtraValueFromHandler(args).toObject().as<T>();
 }
 
 }  // namespace js
 
 #endif  // builtin_HandlerFunction_inl_h

--- a/js/src/builtin/MapObject.cpp
+++ b/js/src/builtin/MapObject.cpp
@@ -531,18 +531,18 @@ class js::OrderedHashTableRef : public g
       TraceManuallyBarrieredEdge(trc, &key, "ordered hash table key");
       unbarrieredTable->rekeyOneEntry(prior, key);
     }
     DeleteNurseryKeys(object);
   }
 };
 
 template <typename ObjectT>
-inline static MOZ_MUST_USE bool PostWriteBarrierImpl(ObjectT* obj,
-                                                     const Value& keyValue) {
+[[nodiscard]] inline static bool PostWriteBarrierImpl(ObjectT* obj,
+                                                      const Value& keyValue) {
   if (MOZ_LIKELY(!keyValue.isObject() && !keyValue.isBigInt())) {
     MOZ_ASSERT_IF(keyValue.isGCThing(), !IsInsideNursery(keyValue.toGCThing()));
     return true;
   }
 
   if (IsInsideNursery(obj)) {
     return true;
   }
@@ -560,23 +560,23 @@ inline static MOZ_MUST_USE bool PostWrit
 
     keyValue.toGCThing()->storeBuffer()->putGeneric(
         OrderedHashTableRef<ObjectT>(obj));
   }
 
   return keys->append(keyValue);
 }
 
-inline static MOZ_MUST_USE bool PostWriteBarrier(MapObject* map,
-                                                 const Value& key) {
+[[nodiscard]] inline static bool PostWriteBarrier(MapObject* map,
+                                                  const Value& key) {
   return PostWriteBarrierImpl(map, key);
 }
 
-inline static MOZ_MUST_USE bool PostWriteBarrier(SetObject* set,
-                                                 const Value& key) {
+[[nodiscard]] inline static bool PostWriteBarrier(SetObject* set,
+                                                  const Value& key) {
   return PostWriteBarrierImpl(set, key);
 }
 
 bool MapObject::getKeysAndValuesInterleaved(
     HandleObject obj, JS::MutableHandle<GCVector<JS::Value>> entries) {
   ValueMap* map = obj->as<MapObject>().getData();
   if (!map) {
     return false;

--- a/js/src/builtin/MapObject.h
+++ b/js/src/builtin/MapObject.h
@@ -108,39 +108,39 @@ class MapObject : public NativeObject {
       "IteratorKind Entries must match self-hosting define for item kind "
       "key-and-value.");
 
   static const JSClass class_;
   static const JSClass protoClass_;
 
   enum { NurseryKeysSlot, HasNurseryMemorySlot, SlotCount };
 
-  static MOZ_MUST_USE bool getKeysAndValuesInterleaved(
+  [[nodiscard]] static bool getKeysAndValuesInterleaved(
       HandleObject obj, JS::MutableHandle<GCVector<JS::Value>> entries);
-  static MOZ_MUST_USE bool entries(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool entries(JSContext* cx, unsigned argc, Value* vp);
   static MapObject* create(JSContext* cx, HandleObject proto = nullptr);
 
   // Publicly exposed Map calls for JSAPI access (webidl maplike/setlike
   // interfaces, etc.)
   static uint32_t size(JSContext* cx, HandleObject obj);
-  static MOZ_MUST_USE bool get(JSContext* cx, HandleObject obj, HandleValue key,
-                               MutableHandleValue rval);
-  static MOZ_MUST_USE bool has(JSContext* cx, HandleObject obj, HandleValue key,
-                               bool* rval);
-  static MOZ_MUST_USE bool delete_(JSContext* cx, HandleObject obj,
-                                   HandleValue key, bool* rval);
+  [[nodiscard]] static bool get(JSContext* cx, HandleObject obj,
+                                HandleValue key, MutableHandleValue rval);
+  [[nodiscard]] static bool has(JSContext* cx, HandleObject obj,
+                                HandleValue key, bool* rval);
+  [[nodiscard]] static bool delete_(JSContext* cx, HandleObject obj,
+                                    HandleValue key, bool* rval);
 
   // Set call for public JSAPI exposure. Does not actually return map object
   // as stated in spec, expects caller to return a value. for instance, with
   // webidl maplike/setlike, should return interface object.
-  static MOZ_MUST_USE bool set(JSContext* cx, HandleObject obj, HandleValue key,
-                               HandleValue val);
-  static MOZ_MUST_USE bool clear(JSContext* cx, HandleObject obj);
-  static MOZ_MUST_USE bool iterator(JSContext* cx, IteratorKind kind,
-                                    HandleObject obj, MutableHandleValue iter);
+  [[nodiscard]] static bool set(JSContext* cx, HandleObject obj,
+                                HandleValue key, HandleValue val);
+  [[nodiscard]] static bool clear(JSContext* cx, HandleObject obj);
+  [[nodiscard]] static bool iterator(JSContext* cx, IteratorKind kind,
+                                     HandleObject obj, MutableHandleValue iter);
 
   using UnbarrieredTable =
       OrderedHashMap<Value, Value, UnbarrieredHashPolicy, ZoneAllocPolicy>;
   friend class OrderedHashTableRef<MapObject>;
 
   static void sweepAfterMinorGC(JSFreeOp* fop, MapObject* mapobj);
 
  private:
@@ -153,41 +153,41 @@ class MapObject : public NativeObject {
 
   static bool finishInit(JSContext* cx, HandleObject ctor, HandleObject proto);
 
   ValueMap* getData() { return static_cast<ValueMap*>(getPrivate()); }
   static ValueMap& extract(HandleObject o);
   static ValueMap& extract(const CallArgs& args);
   static void trace(JSTracer* trc, JSObject* obj);
   static void finalize(JSFreeOp* fop, JSObject* obj);
-  static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool construct(JSContext* cx, unsigned argc, Value* vp);
 
   static bool is(HandleValue v);
   static bool is(HandleObject o);
 
-  static MOZ_MUST_USE bool iterator_impl(JSContext* cx, const CallArgs& args,
-                                         IteratorKind kind);
+  [[nodiscard]] static bool iterator_impl(JSContext* cx, const CallArgs& args,
+                                          IteratorKind kind);
 
-  static MOZ_MUST_USE bool size_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool size(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool get_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool get(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool has_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool has(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool set_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool set(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool delete_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool keys_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool keys(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool values_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool values(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool entries_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool clear_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool clear(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool size_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool size(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool get_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool get(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool has_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool has(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool set_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool set(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool delete_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool delete_(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool keys_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool keys(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool values_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool values(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool entries_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool clear_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool clear(JSContext* cx, unsigned argc, Value* vp);
 };
 
 class MapIteratorObject : public NativeObject {
  public:
   static const JSClass class_;
 
   enum { TargetSlot, RangeSlot, KindSlot, SlotCount };
 
@@ -208,18 +208,18 @@ class MapIteratorObject : public NativeO
   static size_t objectMoved(JSObject* obj, JSObject* old);
 
   void init(MapObject* mapObj, MapObject::IteratorKind kind) {
     initFixedSlot(TargetSlot, JS::ObjectValue(*mapObj));
     initFixedSlot(RangeSlot, JS::PrivateValue(nullptr));
     initFixedSlot(KindSlot, JS::Int32Value(int32_t(kind)));
   }
 
-  static MOZ_MUST_USE bool next(MapIteratorObject* mapIterator,
-                                ArrayObject* resultPairObj);
+  [[nodiscard]] static bool next(MapIteratorObject* mapIterator,
+                                 ArrayObject* resultPairObj);
 
   static JSObject* createResultPair(JSContext* cx);
 
  private:
   inline MapObject::IteratorKind kind() const;
 };
 
 class SetObject : public NativeObject {
@@ -237,33 +237,33 @@ class SetObject : public NativeObject {
       "IteratorKind Entries must match self-hosting define for item kind "
       "key-and-value.");
 
   static const JSClass class_;
   static const JSClass protoClass_;
 
   enum { NurseryKeysSlot, HasNurseryMemorySlot, SlotCount };
 
-  static MOZ_MUST_USE bool keys(JSContext* cx, HandleObject obj,
-                                JS::MutableHandle<GCVector<JS::Value>> keys);
-  static MOZ_MUST_USE bool values(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool add(JSContext* cx, HandleObject obj,
-                               HandleValue key);
+  [[nodiscard]] static bool keys(JSContext* cx, HandleObject obj,
+                                 JS::MutableHandle<GCVector<JS::Value>> keys);
+  [[nodiscard]] static bool values(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool add(JSContext* cx, HandleObject obj,
+                                HandleValue key);
 
   // Publicly exposed Set calls for JSAPI access (webidl maplike/setlike
   // interfaces, etc.)
   static SetObject* create(JSContext* cx, HandleObject proto = nullptr);
   static uint32_t size(JSContext* cx, HandleObject obj);
-  static MOZ_MUST_USE bool has(JSContext* cx, HandleObject obj, HandleValue key,
-                               bool* rval);
-  static MOZ_MUST_USE bool clear(JSContext* cx, HandleObject obj);
-  static MOZ_MUST_USE bool iterator(JSContext* cx, IteratorKind kind,
-                                    HandleObject obj, MutableHandleValue iter);
-  static MOZ_MUST_USE bool delete_(JSContext* cx, HandleObject obj,
-                                   HandleValue key, bool* rval);
+  [[nodiscard]] static bool has(JSContext* cx, HandleObject obj,
+                                HandleValue key, bool* rval);
+  [[nodiscard]] static bool clear(JSContext* cx, HandleObject obj);
+  [[nodiscard]] static bool iterator(JSContext* cx, IteratorKind kind,
+                                     HandleObject obj, MutableHandleValue iter);
+  [[nodiscard]] static bool delete_(JSContext* cx, HandleObject obj,
+                                    HandleValue key, bool* rval);
 
   using UnbarrieredTable =
       OrderedHashSet<Value, UnbarrieredHashPolicy, ZoneAllocPolicy>;
   friend class OrderedHashTableRef<SetObject>;
 
   static void sweepAfterMinorGC(JSFreeOp* fop, SetObject* setobj);
 
  private:
@@ -283,32 +283,32 @@ class SetObject : public NativeObject {
   static void finalize(JSFreeOp* fop, JSObject* obj);
   static bool construct(JSContext* cx, unsigned argc, Value* vp);
 
   static bool is(HandleValue v);
   static bool is(HandleObject o);
 
   static bool isBuiltinAdd(HandleValue add);
 
-  static MOZ_MUST_USE bool iterator_impl(JSContext* cx, const CallArgs& args,
-                                         IteratorKind kind);
+  [[nodiscard]] static bool iterator_impl(JSContext* cx, const CallArgs& args,
+                                          IteratorKind kind);
 
-  static MOZ_MUST_USE bool size_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool size(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool has_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool has(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool add_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool add(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool delete_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool values_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool entries_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool entries(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool clear_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool clear(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool size_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool size(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool has_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool has(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool add_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool add(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool delete_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool delete_(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool values_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool entries_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool entries(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool clear_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool clear(JSContext* cx, unsigned argc, Value* vp);
 };
 
 class SetIteratorObject : public NativeObject {
  public:
   static const JSClass class_;
 
   enum { TargetSlot, RangeSlot, KindSlot, SlotCount };
 
@@ -329,34 +329,34 @@ class SetIteratorObject : public NativeO
   static size_t objectMoved(JSObject* obj, JSObject* old);
 
   void init(SetObject* setObj, SetObject::IteratorKind kind) {
     initFixedSlot(TargetSlot, JS::ObjectValue(*setObj));
     initFixedSlot(RangeSlot, JS::PrivateValue(nullptr));
     initFixedSlot(KindSlot, JS::Int32Value(int32_t(kind)));
   }
 
-  static MOZ_MUST_USE bool next(SetIteratorObject* setIterator,
-                                ArrayObject* resultObj);
+  [[nodiscard]] static bool next(SetIteratorObject* setIterator,
+                                 ArrayObject* resultObj);
 
   static JSObject* createResult(JSContext* cx);
 
  private:
   inline SetObject::IteratorKind kind() const;
 };
 
 using SetInitGetPrototypeOp = NativeObject* (*)(JSContext*,
                                                 Handle<GlobalObject*>);
 using SetInitIsBuiltinOp = bool (*)(HandleValue);
 
 template <SetInitGetPrototypeOp getPrototypeOp, SetInitIsBuiltinOp isBuiltinOp>
-static MOZ_MUST_USE bool IsOptimizableInitForSet(JSContext* cx,
-                                                 HandleObject setObject,
-                                                 HandleValue iterable,
-                                                 bool* optimized) {
+[[nodiscard]] static bool IsOptimizableInitForSet(JSContext* cx,
+                                                  HandleObject setObject,
+                                                  HandleValue iterable,
+                                                  bool* optimized) {
   MOZ_ASSERT(!*optimized);
 
   if (!iterable.isObject()) {
     return true;
   }
 
   RootedObject array(cx, &iterable.toObject());
   if (!IsPackedArray(array)) {

--- a/js/src/builtin/Profilers.h
+++ b/js/src/builtin/Profilers.h
@@ -24,65 +24,65 @@ typedef int pid_t;
  *
  * The profileName is used by some profilers to describe the current profiling
  * run. It may be used for part of the filename of the output, but the
  * specifics depend on the profiler. Many profilers will ignore it. Passing in
  * nullptr is legal; some profilers may use it to output to stdout or similar.
  *
  * Returns true if no profilers fail to start.
  */
-extern MOZ_MUST_USE JS_PUBLIC_API bool JS_StartProfiling(
+[[nodiscard]] extern JS_PUBLIC_API bool JS_StartProfiling(
     const char* profileName, pid_t pid);
 
 /**
  * Stop any profilers that were previously started with JS_StartProfiling.
  * Returns true if no profilers fail to stop.
  */
-extern MOZ_MUST_USE JS_PUBLIC_API bool JS_StopProfiling(
+[[nodiscard]] extern JS_PUBLIC_API bool JS_StopProfiling(
     const char* profileName);
 
 /**
  * Write the current profile data to the given file, if applicable to whatever
  * profiler is being used.
  */
-extern MOZ_MUST_USE JS_PUBLIC_API bool JS_DumpProfile(const char* outfile,
-                                                      const char* profileName);
+[[nodiscard]] extern JS_PUBLIC_API bool JS_DumpProfile(const char* outfile,
+                                                       const char* profileName);
 
 /**
  * Pause currently active profilers (only supported by some profilers). Returns
  * whether any profilers failed to pause. (Profilers that do not support
  * pause/resume do not count.)
  */
-extern MOZ_MUST_USE JS_PUBLIC_API bool JS_PauseProfilers(
+[[nodiscard]] extern JS_PUBLIC_API bool JS_PauseProfilers(
     const char* profileName);
 
 /**
  * Resume suspended profilers
  */
-extern MOZ_MUST_USE JS_PUBLIC_API bool JS_ResumeProfilers(
+[[nodiscard]] extern JS_PUBLIC_API bool JS_ResumeProfilers(
     const char* profileName);
 
 /**
  * The profiling API calls are not able to report errors, so they use a
  * thread-unsafe global memory buffer to hold the last error encountered. This
  * should only be called after something returns false.
  */
 JS_PUBLIC_API const char* JS_UnsafeGetLastProfilingError();
 
 #ifdef MOZ_CALLGRIND
 
-extern MOZ_MUST_USE JS_FRIEND_API bool js_StopCallgrind();
+[[nodiscard]] extern JS_FRIEND_API bool js_StopCallgrind();
 
-extern MOZ_MUST_USE JS_FRIEND_API bool js_StartCallgrind();
+[[nodiscard]] extern JS_FRIEND_API bool js_StartCallgrind();
 
-extern MOZ_MUST_USE JS_FRIEND_API bool js_DumpCallgrind(const char* outfile);
+[[nodiscard]] extern JS_FRIEND_API bool js_DumpCallgrind(const char* outfile);
 
 #endif /* MOZ_CALLGRIND */
 
 #ifdef __linux__
 
-extern MOZ_MUST_USE JS_FRIEND_API bool js_StartPerf();
+[[nodiscard]] extern JS_FRIEND_API bool js_StartPerf();
 
-extern MOZ_MUST_USE JS_FRIEND_API bool js_StopPerf();
+[[nodiscard]] extern JS_FRIEND_API bool js_StopPerf();
 
 #endif /* __linux__ */
 
 #endif /* builtin_Profilers_h */

--- a/js/src/builtin/Promise.cpp
+++ b/js/src/builtin/Promise.cpp
@@ -583,17 +583,17 @@ static bool MaybeGetAndClearExceptionAnd
                                               MutableHandleSavedFrame stack) {
   if (!cx->isExceptionPending()) {
     return false;
   }
 
   return GetAndClearExceptionAndStack(cx, rval, stack);
 }
 
-static MOZ_MUST_USE bool RunRejectFunction(
+[[nodiscard]] static bool RunRejectFunction(
     JSContext* cx, HandleObject onRejectedFunc, HandleValue result,
     HandleObject promiseObj, HandleSavedFrame unwrappedRejectionStack,
     UnhandledRejectionBehavior behavior);
 
 // ES2016, 25.4.1.1.1, Steps 1.a-b.
 // Extracting all of this internal spec algorithm into a helper function would
 // be tedious, so the check in step 1 and the entirety of step 2 aren't
 // included.
@@ -860,17 +860,17 @@ static void RemovePromiseFlags(PromiseOb
 static bool PromiseHasAnyFlag(PromiseObject& promise, int32_t flag) {
   return promise.flags() & flag;
 }
 
 static bool ResolvePromiseFunction(JSContext* cx, unsigned argc, Value* vp);
 static bool RejectPromiseFunction(JSContext* cx, unsigned argc, Value* vp);
 
 // ES2016, 25.4.1.3.
-static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool CreateResolvingFunctions(
+[[nodiscard]] static MOZ_ALWAYS_INLINE bool CreateResolvingFunctions(
     JSContext* cx, HandleObject promise, MutableHandleObject resolveFn,
     MutableHandleObject rejectFn) {
   HandlePropertyName funName = cx->names().empty;
   resolveFn.set(NewNativeFunction(cx, ResolvePromiseFunction, 1, funName,
                                   gc::AllocKind::FUNCTION_EXTENDED,
                                   GenericObject));
   if (!resolveFn) {
     return false;
@@ -910,22 +910,22 @@ static bool IsSettledMaybeWrappedPromise
       return false;
     }
   }
 
   return promise->as<PromiseObject>().state() != JS::PromiseState::Pending;
 }
 
 // ES2016, 25.4.1.7.
-static MOZ_MUST_USE bool RejectMaybeWrappedPromise(
+[[nodiscard]] static bool RejectMaybeWrappedPromise(
     JSContext* cx, HandleObject promiseObj, HandleValue reason,
     HandleSavedFrame unwrappedRejectionStack);
 
 // ES2016, 25.4.1.7.
-static MOZ_MUST_USE bool RejectPromiseInternal(
+[[nodiscard]] static bool RejectPromiseInternal(
     JSContext* cx, Handle<PromiseObject*> promise, HandleValue reason,
     HandleSavedFrame unwrappedRejectionStack = nullptr);
 
 // ES2016, 25.4.1.3.1.
 static bool RejectPromiseFunction(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   JSFunction* reject = &args.callee().as<JSFunction>();
@@ -962,35 +962,35 @@ static bool RejectPromiseFunction(JSCont
   // Step 6.
   if (!RejectMaybeWrappedPromise(cx, promise, reasonVal, nullptr)) {
     return false;
   }
   args.rval().setUndefined();
   return true;
 }
 
-static MOZ_MUST_USE bool FulfillMaybeWrappedPromise(JSContext* cx,
-                                                    HandleObject promiseObj,
-                                                    HandleValue value_);
-
-static MOZ_MUST_USE bool EnqueuePromiseResolveThenableJob(
+[[nodiscard]] static bool FulfillMaybeWrappedPromise(JSContext* cx,
+                                                     HandleObject promiseObj,
+                                                     HandleValue value_);
+
+[[nodiscard]] static bool EnqueuePromiseResolveThenableJob(
     JSContext* cx, HandleValue promiseToResolve, HandleValue thenable,
     HandleValue thenVal);
 
-static MOZ_MUST_USE bool EnqueuePromiseResolveThenableBuiltinJob(
+[[nodiscard]] static bool EnqueuePromiseResolveThenableBuiltinJob(
     JSContext* cx, HandleObject promiseToResolve, HandleObject thenable);
 
 static bool Promise_then_impl(JSContext* cx, HandleValue promiseVal,
                               HandleValue onFulfilled, HandleValue onRejected,
                               MutableHandleValue rval, bool rvalUsed);
 
 // ES2016, 25.4.1.3.2, steps 6-13.
-static MOZ_MUST_USE bool ResolvePromiseInternal(JSContext* cx,
-                                                HandleObject promise,
-                                                HandleValue resolutionVal) {
+[[nodiscard]] static bool ResolvePromiseInternal(JSContext* cx,
+                                                 HandleObject promise,
+                                                 HandleValue resolutionVal) {
   cx->check(promise, resolutionVal);
   MOZ_ASSERT(!IsSettledMaybeWrappedPromise(promise));
 
   // Step 7 (reordered).
   if (!resolutionVal.isObject()) {
     return FulfillMaybeWrappedPromise(cx, promise, resolutionVal);
   }
 
@@ -1255,28 +1255,28 @@ static bool PromiseReactionJob(JSContext
   // Note: the global we pass here might be from a different compartment
   // than job and promise. While it's somewhat unusual to pass objects
   // from multiple compartments, in this case we specifically need the
   // global to be unwrapped because wrapping and unwrapping aren't
   // necessarily symmetric for globals.
   return cx->runtime()->enqueuePromiseJob(cx, job, promise, global);
 }
 
-static MOZ_MUST_USE bool TriggerPromiseReactions(JSContext* cx,
-                                                 HandleValue reactionsVal,
-                                                 JS::PromiseState state,
-                                                 HandleValue valueOrReason);
+[[nodiscard]] static bool TriggerPromiseReactions(JSContext* cx,
+                                                  HandleValue reactionsVal,
+                                                  JS::PromiseState state,
+                                                  HandleValue valueOrReason);
 
 // ES2016, Commoned-out implementation of 25.4.1.4. and 25.4.1.7.
 //
 // This method takes an additional optional |unwrappedRejectionStack| parameter,
 // which is only used for debugging purposes.
 // It allows callers to to pass in the stack of some exception which
 // triggered the rejection of the promise.
-static MOZ_MUST_USE bool ResolvePromise(
+[[nodiscard]] static bool ResolvePromise(
     JSContext* cx, Handle<PromiseObject*> promise, HandleValue valueOrReason,
     JS::PromiseState state,
     HandleSavedFrame unwrappedRejectionStack = nullptr) {
   // Step 1.
   MOZ_ASSERT(promise->state() == JS::PromiseState::Pending);
   MOZ_ASSERT(state == JS::PromiseState::Fulfilled ||
              state == JS::PromiseState::Rejected);
   MOZ_ASSERT_IF(unwrappedRejectionStack, state == JS::PromiseState::Rejected);
@@ -1309,27 +1309,27 @@ static MOZ_MUST_USE bool ResolvePromise(
   PromiseObject::onSettled(cx, promise, unwrappedRejectionStack);
 
   // Step 7 of FulfillPromise.
   // Step 8 of RejectPromise.
   return TriggerPromiseReactions(cx, reactionsVal, state, valueOrReason);
 }
 
 // ES2016, 25.4.1.7.
-static MOZ_MUST_USE bool RejectPromiseInternal(
+[[nodiscard]] static bool RejectPromiseInternal(
     JSContext* cx, Handle<PromiseObject*> promise, HandleValue reason,
     HandleSavedFrame unwrappedRejectionStack) {
   return ResolvePromise(cx, promise, reason, JS::PromiseState::Rejected,
                         unwrappedRejectionStack);
 }
 
 // ES2016, 25.4.1.4.
-static MOZ_MUST_USE bool FulfillMaybeWrappedPromise(JSContext* cx,
-                                                    HandleObject promiseObj,
-                                                    HandleValue value_) {
+[[nodiscard]] static bool FulfillMaybeWrappedPromise(JSContext* cx,
+                                                     HandleObject promiseObj,
+                                                     HandleValue value_) {
   Rooted<PromiseObject*> promise(cx);
   RootedValue value(cx, value_);
 
   mozilla::Maybe<AutoRealm> ar;
   if (!IsProxy(promiseObj)) {
     promise = &promiseObj->as<PromiseObject>();
   } else {
     JSObject* unwrappedPromiseObj = UncheckedUnwrap(promiseObj);
@@ -1345,37 +1345,37 @@ static MOZ_MUST_USE bool FulfillMaybeWra
     }
   }
 
   return ResolvePromise(cx, promise, value, JS::PromiseState::Fulfilled);
 }
 
 static bool GetCapabilitiesExecutor(JSContext* cx, unsigned argc, Value* vp);
 static bool PromiseConstructor(JSContext* cx, unsigned argc, Value* vp);
-static MOZ_MUST_USE PromiseObject* CreatePromiseObjectInternal(
+[[nodiscard]] static PromiseObject* CreatePromiseObjectInternal(
     JSContext* cx, HandleObject proto = nullptr, bool protoIsWrapped = false,
     bool informDebugger = true);
 
 enum GetCapabilitiesExecutorSlots {
   GetCapabilitiesExecutorSlots_Resolve,
   GetCapabilitiesExecutorSlots_Reject
 };
 
-static MOZ_MUST_USE PromiseObject*
+[[nodiscard]] static PromiseObject*
 CreatePromiseObjectWithoutResolutionFunctions(JSContext* cx) {
   PromiseObject* promise = CreatePromiseObjectInternal(cx);
   if (!promise) {
     return nullptr;
   }
 
   AddPromiseFlags(*promise, PROMISE_FLAG_DEFAULT_RESOLVING_FUNCTIONS);
   return promise;
 }
 
-static MOZ_MUST_USE PromiseObject* CreatePromiseWithDefaultResolutionFunctions(
+[[nodiscard]] static PromiseObject* CreatePromiseWithDefaultResolutionFunctions(
     JSContext* cx, MutableHandleObject resolve, MutableHandleObject reject) {
   // ES2016, 25.4.3.1., as if called with GetCapabilitiesExecutor as the
   // executor argument.
 
   // Steps 1-2 (Not applicable).
 
   // Steps 3-7.
   Rooted<PromiseObject*> promise(cx, CreatePromiseObjectInternal(cx));
@@ -1392,17 +1392,17 @@ static MOZ_MUST_USE PromiseObject* Creat
 
   // Steps 9-10 (Not applicable).
 
   // Step 11.
   return promise;
 }
 
 // ES2016, 25.4.1.5.
-static MOZ_MUST_USE bool NewPromiseCapability(
+[[nodiscard]] static bool NewPromiseCapability(
     JSContext* cx, HandleObject C, MutableHandle<PromiseCapability> capability,
     bool canOmitResolutionFunctions) {
   RootedValue cVal(cx, ObjectValue(*C));
 
   // Steps 1-2.
   if (!IsConstructor(C)) {
     ReportValueError(cx, JSMSG_NOT_CONSTRUCTOR, JSDVG_SEARCH_STACK, cVal,
                      nullptr);
@@ -1507,17 +1507,17 @@ static bool GetCapabilitiesExecutor(JSCo
   F->setExtendedSlot(GetCapabilitiesExecutorSlots_Reject, args.get(1));
 
   // Step 7.
   args.rval().setUndefined();
   return true;
 }
 
 // ES2016, 25.4.1.7.
-static MOZ_MUST_USE bool RejectMaybeWrappedPromise(
+[[nodiscard]] static bool RejectMaybeWrappedPromise(
     JSContext* cx, HandleObject promiseObj, HandleValue reason_,
     HandleSavedFrame unwrappedRejectionStack) {
   Rooted<PromiseObject*> promise(cx);
   RootedValue reason(cx, reason_);
 
   mozilla::Maybe<AutoRealm> ar;
   if (!IsProxy(promiseObj)) {
     promise = &promiseObj->as<PromiseObject>();
@@ -1606,37 +1606,37 @@ static bool ForEachReaction(JSContext* c
       return false;
     }
   }
 
   return true;
 }
 
 // ES2016, 25.4.1.8.
-static MOZ_MUST_USE bool TriggerPromiseReactions(JSContext* cx,
-                                                 HandleValue reactionsVal,
-                                                 JS::PromiseState state,
-                                                 HandleValue valueOrReason) {
+[[nodiscard]] static bool TriggerPromiseReactions(JSContext* cx,
+                                                  HandleValue reactionsVal,
+                                                  JS::PromiseState state,
+                                                  HandleValue valueOrReason) {
   MOZ_ASSERT(state == JS::PromiseState::Fulfilled ||
              state == JS::PromiseState::Rejected);
 
   return ForEachReaction(cx, reactionsVal, [&](MutableHandleObject reaction) {
     return EnqueuePromiseReactionJob(cx, reaction, valueOrReason, state);
   });
 }
 
-static MOZ_MUST_USE bool RunFulfillFunction(JSContext* cx,
-                                            HandleObject onFulfilledFunc,
-                                            HandleValue result,
-                                            HandleObject promiseObj);
+[[nodiscard]] static bool RunFulfillFunction(JSContext* cx,
+                                             HandleObject onFulfilledFunc,
+                                             HandleValue result,
+                                             HandleObject promiseObj);
 
 // Implements PromiseReactionJob optimized for the case when the reaction
 // handler is one of the default resolving functions as created by the
 // CreateResolvingFunctions abstract operation.
-static MOZ_MUST_USE bool DefaultResolvingPromiseReactionJob(
+[[nodiscard]] static bool DefaultResolvingPromiseReactionJob(
     JSContext* cx, Handle<PromiseReactionRecord*> reaction) {
   MOZ_ASSERT(reaction->targetState() != JS::PromiseState::Pending);
 
   Rooted<PromiseObject*> promiseToResolve(cx,
                                           reaction->defaultResolvingPromise());
 
   // Testing functions allow to directly settle a promise without going
   // through the resolving functions. In that case the normal bookkeeping to
@@ -1678,17 +1678,17 @@ static MOZ_MUST_USE bool DefaultResolvin
 
   callee = reaction->getFixedSlot(ReactionRecordSlot_Reject).toObjectOrNull();
 
   return RunRejectFunction(cx, callee, handlerResult, promiseObj,
                            unwrappedRejectionStack,
                            reaction->unhandledRejectionBehavior());
 }
 
-static MOZ_MUST_USE bool AsyncFunctionPromiseReactionJob(
+[[nodiscard]] static bool AsyncFunctionPromiseReactionJob(
     JSContext* cx, Handle<PromiseReactionRecord*> reaction) {
   MOZ_ASSERT(reaction->isAsyncFunction());
 
   int32_t handler = reaction->handler().toInt32();
   RootedValue argument(cx, reaction->handlerArg());
   Rooted<AsyncFunctionGeneratorObject*> generator(
       cx, reaction->asyncFunctionGenerator());
 
@@ -1698,17 +1698,17 @@ static MOZ_MUST_USE bool AsyncFunctionPr
   if (handler == PromiseHandlerAsyncFunctionAwaitedFulfilled) {
     return AsyncFunctionAwaitedFulfilled(cx, generator, argument);
   }
 
   MOZ_ASSERT(handler == PromiseHandlerAsyncFunctionAwaitedRejected);
   return AsyncFunctionAwaitedRejected(cx, generator, argument);
 }
 
-static MOZ_MUST_USE bool AsyncGeneratorPromiseReactionJob(
+[[nodiscard]] static bool AsyncGeneratorPromiseReactionJob(
     JSContext* cx, Handle<PromiseReactionRecord*> reaction) {
   MOZ_ASSERT(reaction->isAsyncGenerator());
 
   RootedValue argument(cx, reaction->handlerArg());
   Rooted<AsyncGeneratorObject*> asyncGenObj(cx, reaction->asyncGenerator());
 
   // Await's handlers don't return a value, nor throw any exceptions.
   // They fail only on OOM.
@@ -1982,17 +1982,17 @@ static bool PromiseResolveThenableJob(JS
   if (!MaybeGetAndClearExceptionAndStack(cx, &rval, &stack)) {
     return false;
   }
 
   RootedValue rejectVal(cx, ObjectValue(*rejectFn));
   return Call(cx, rejectVal, UndefinedHandleValue, rval, &rval);
 }
 
-static MOZ_MUST_USE bool OriginalPromiseThenWithoutSettleHandlers(
+[[nodiscard]] static bool OriginalPromiseThenWithoutSettleHandlers(
     JSContext* cx, Handle<PromiseObject*> promise,
     Handle<PromiseObject*> promiseToResolve);
 
 /**
  * Specialization of PromiseResolveThenableJob when the `thenable` is a
  * built-in Promise object and the `then` property is the built-in
  * `Promise.prototype.then` function.
  *
@@ -2048,17 +2048,17 @@ static bool PromiseResolveBuiltinThenabl
 
 /**
  * Tells the embedding to enqueue a Promise resolve thenable job, based on
  * three parameters:
  * promiseToResolve_ - The promise to resolve, obviously.
  * thenable_ - The thenable to resolve the Promise with.
  * thenVal - The `then` function to invoke with the `thenable` as the receiver.
  */
-static MOZ_MUST_USE bool EnqueuePromiseResolveThenableJob(
+[[nodiscard]] static bool EnqueuePromiseResolveThenableJob(
     JSContext* cx, HandleValue promiseToResolve_, HandleValue thenable_,
     HandleValue thenVal) {
   // Need to re-root these to enable wrapping them below.
   RootedValue promiseToResolve(cx, promiseToResolve_);
   RootedValue thenable(cx, thenable_);
 
   // We enter the `then` callable's compartment so that the job function is
   // created in that compartment.
@@ -2116,17 +2116,17 @@ static MOZ_MUST_USE bool EnqueuePromiseR
 }
 
 /**
  * Tells the embedding to enqueue a Promise resolve thenable built-in job,
  * based on two parameters:
  * promiseToResolve - The promise to resolve, obviously.
  * thenable - The thenable to resolve the Promise with.
  */
-static MOZ_MUST_USE bool EnqueuePromiseResolveThenableBuiltinJob(
+[[nodiscard]] static bool EnqueuePromiseResolveThenableBuiltinJob(
     JSContext* cx, HandleObject promiseToResolve, HandleObject thenable) {
   cx->check(promiseToResolve, thenable);
   MOZ_ASSERT(promiseToResolve->is<PromiseObject>());
   MOZ_ASSERT(thenable->is<PromiseObject>());
 
   HandlePropertyName funName = cx->names().empty;
   RootedFunction job(
       cx, NewNativeFunction(cx, PromiseResolveBuiltinThenableJob, 0, funName,
@@ -2141,21 +2141,21 @@ static MOZ_MUST_USE bool EnqueuePromiseR
   job->setExtendedSlot(BuiltinThenableJobSlot_Thenable, ObjectValue(*thenable));
 
   Rooted<GlobalObject*> incumbentGlobal(cx,
                                         cx->runtime()->getIncumbentGlobal(cx));
   return cx->runtime()->enqueuePromiseJob(cx, job, promiseToResolve,
                                           incumbentGlobal);
 }
 
-static MOZ_MUST_USE bool AddDummyPromiseReactionForDebugger(
+[[nodiscard]] static bool AddDummyPromiseReactionForDebugger(
     JSContext* cx, Handle<PromiseObject*> promise,
     HandleObject dependentPromise);
 
-static MOZ_MUST_USE bool AddPromiseReaction(
+[[nodiscard]] static bool AddPromiseReaction(
     JSContext* cx, Handle<PromiseObject*> promise,
     Handle<PromiseReactionRecord*> reaction);
 
 static JSFunction* GetResolveFunctionFromReject(JSFunction* reject) {
   MOZ_ASSERT(reject->maybeNative() == RejectPromiseFunction);
   Value resolveFunVal =
       reject->getExtendedSlot(RejectFunctionSlot_ResolveFunction);
   MOZ_ASSERT(IsNativeFunction(resolveFunVal, ResolvePromiseFunction));
@@ -2220,17 +2220,17 @@ static void ClearResolutionFunctionSlots
   resolve->setExtendedSlot(ResolveFunctionSlot_RejectFunction,
                            UndefinedValue());
 
   reject->setExtendedSlot(RejectFunctionSlot_Promise, UndefinedValue());
   reject->setExtendedSlot(RejectFunctionSlot_ResolveFunction, UndefinedValue());
 }
 
 // ES2016, 25.4.3.1. steps 3-7.
-static MOZ_MUST_USE MOZ_ALWAYS_INLINE PromiseObject*
+[[nodiscard]] static MOZ_ALWAYS_INLINE PromiseObject*
 CreatePromiseObjectInternal(JSContext* cx, HandleObject proto /* = nullptr */,
                             bool protoIsWrapped /* = false */,
                             bool informDebugger /* = true */) {
   // Step 3.
   // Enter the unwrapped proto's compartment, if that's different from
   // the current one.
   // All state stored in a Promise's fixed slots must be created in the
   // same compartment, so we get all of that out of the way here.
@@ -2482,32 +2482,32 @@ class MOZ_STACK_CLASS PromiseForOfIterat
   using JS::ForOfIterator::ForOfIterator;
 
   bool isOptimizedDenseArrayIteration() {
     MOZ_ASSERT(valueIsIterable());
     return index != NOT_ARRAY && IsPackedArray(iterator);
   }
 };
 
-static MOZ_MUST_USE bool PerformPromiseAll(
+[[nodiscard]] static bool PerformPromiseAll(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done);
 
-static MOZ_MUST_USE bool PerformPromiseAllSettled(
+[[nodiscard]] static bool PerformPromiseAllSettled(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done);
 
-static MOZ_MUST_USE bool PerformPromiseAny(
+[[nodiscard]] static bool PerformPromiseAny(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done);
 
-static MOZ_MUST_USE bool PerformPromiseRace(
+[[nodiscard]] static bool PerformPromiseRace(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done);
 
 enum class CombinatorKind { All, AllSettled, Any, Race };
 
 // ES2020 draft rev e97c95d064750fb949b6778584702dd658cf5624
 //
@@ -2515,18 +2515,18 @@ enum class CombinatorKind { All, AllSett
 // 25.6.4.1 Promise.all ( iterable )
 // 25.6.4.2 Promise.allSettled ( iterable )
 // 25.6.4.4 Promise.race ( iterable )
 //
 // Promise.any (Stage 3 proposal)
 // https://tc39.es/proposal-promise-any/
 //
 // Promise.any ( iterable )
-static MOZ_MUST_USE bool CommonPromiseCombinator(JSContext* cx, CallArgs& args,
-                                                 CombinatorKind kind) {
+[[nodiscard]] static bool CommonPromiseCombinator(JSContext* cx, CallArgs& args,
+                                                  CombinatorKind kind) {
   HandleValue iterable = args.get(0);
 
   // Step 2 (moved from NewPromiseCapability, step 1).
   HandleValue CVal = args.thisv();
   if (!CVal.isObject()) {
     const char* message;
     switch (kind) {
       case CombinatorKind::All:
@@ -2649,21 +2649,21 @@ static MOZ_MUST_USE bool CommonPromiseCo
 
 // ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
 // 25.6.4.1 Promise.all ( iterable )
 static bool Promise_static_all(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CommonPromiseCombinator(cx, args, CombinatorKind::All);
 }
 
-static MOZ_MUST_USE bool PerformPromiseThen(
+[[nodiscard]] static bool PerformPromiseThen(
     JSContext* cx, Handle<PromiseObject*> promise, HandleValue onFulfilled_,
     HandleValue onRejected_, Handle<PromiseCapability> resultCapability);
 
-static MOZ_MUST_USE bool PerformPromiseThenWithoutSettleHandlers(
+[[nodiscard]] static bool PerformPromiseThenWithoutSettleHandlers(
     JSContext* cx, Handle<PromiseObject*> promise,
     Handle<PromiseObject*> promiseToResolve,
     Handle<PromiseCapability> resultCapability);
 
 static JSFunction* NewPromiseCombinatorElementFunction(
     JSContext* cx, Native native,
     Handle<PromiseCombinatorDataHolder*> dataHolder, uint32_t index);
 
@@ -2792,20 +2792,20 @@ static bool PromiseAllResolveElementFunc
   }
 
   // Step 8 (omitted).
 
   // Step 9.
   return resultCapability.promise();
 }
 
-static MOZ_MUST_USE bool RunFulfillFunction(JSContext* cx,
-                                            HandleObject onFulfilledFunc,
-                                            HandleValue result,
-                                            HandleObject promiseObj) {
+[[nodiscard]] static bool RunFulfillFunction(JSContext* cx,
+                                             HandleObject onFulfilledFunc,
+                                             HandleValue result,
+                                             HandleObject promiseObj) {
   cx->check(onFulfilledFunc);
   cx->check(result);
   cx->check(promiseObj);
 
   // If |onFulfilledFunc| couldn't be optimized away, just call it.
   if (onFulfilledFunc) {
     RootedValue calleeOrRval(cx, ObjectValue(*onFulfilledFunc));
     return Call(cx, calleeOrRval, UndefinedHandleValue, result, &calleeOrRval);
@@ -2826,17 +2826,17 @@ static MOZ_MUST_USE bool RunFulfillFunct
   if (PromiseHasAnyFlag(*promise, PROMISE_FLAG_DEFAULT_RESOLVING_FUNCTIONS)) {
     return ResolvePromiseInternal(cx, promise, result);
   }
 
   // Otherwise we're done.
   return true;
 }
 
-static MOZ_MUST_USE bool RunRejectFunction(
+[[nodiscard]] static bool RunRejectFunction(
     JSContext* cx, HandleObject onRejectedFunc, HandleValue result,
     HandleObject promiseObj, HandleSavedFrame unwrappedRejectionStack,
     UnhandledRejectionBehavior behavior) {
   cx->check(onRejectedFunc);
   cx->check(result);
   cx->check(promiseObj);
 
   // If |onRejectedFunc| couldn't be optimized away, just call it.
@@ -2875,32 +2875,32 @@ static MOZ_MUST_USE bool RunRejectFuncti
   if (PromiseHasAnyFlag(*promise, PROMISE_FLAG_DEFAULT_RESOLVING_FUNCTIONS)) {
     return RejectPromiseInternal(cx, promise, result, unwrappedRejectionStack);
   }
 
   // Otherwise we're done.
   return true;
 }
 
-static MOZ_MUST_USE JSObject* CommonStaticResolveRejectImpl(
+[[nodiscard]] static JSObject* CommonStaticResolveRejectImpl(
     JSContext* cx, HandleValue thisVal, HandleValue argVal,
     ResolutionMode mode);
 
 static bool IsPromiseSpecies(JSContext* cx, JSFunction* species);
 
 // ES2020 draft rev e97c95d064750fb949b6778584702dd658cf5624
 // 25.6.4.1.1 Runtime Semantics: PerformPromiseAll, steps 5-6 and step 8.
 // 25.6.4.2.1 Runtime Semantics: PerformPromiseAllSettled, steps 5-6 and step 8.
 // 25.6.4.4.1 Runtime Semantics: PerformPromiseRace, steps 3-5.
 //
 // Promise.any (Stage 3 proposal)
 // https://tc39.es/proposal-promise-any/
 // Runtime Semantics: PerformPromiseAny, steps 6-8.
 template <typename T>
-static MOZ_MUST_USE bool CommonPerformPromiseCombinator(
+[[nodiscard]] static bool CommonPerformPromiseCombinator(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     HandleObject resultPromise, HandleValue promiseResolve, bool* done,
     bool resolveReturnsUndefined, T getResolveAndReject) {
   RootedObject promiseCtor(
       cx, GlobalObject::getOrCreatePromiseConstructor(cx, cx->global()));
   if (!promiseCtor) {
     return false;
   }
@@ -3173,17 +3173,17 @@ static MOZ_MUST_USE bool CommonPerformPr
         }
       }
     }
   }
 }
 
 // Create the elements for the Promise combinators Promise.all and
 // Promise.allSettled.
-static MOZ_MUST_USE bool NewPromiseCombinatorElements(
+[[nodiscard]] static bool NewPromiseCombinatorElements(
     JSContext* cx, Handle<PromiseCapability> resultCapability,
     MutableHandle<PromiseCombinatorElements> elements) {
   // We have to be very careful about which compartments we create things for
   // the Promise combinators. In particular, we have to maintain the invariant
   // that anything stored in a reserved slot is same-compartment with the object
   // whose reserved slot it's in. But we want to create the values array in the
   // compartment of the result capability's Promise, because that array can get
   // exposed as the Promise's resolution value to code that has access to the
@@ -3225,17 +3225,17 @@ static MOZ_MUST_USE bool NewPromiseCombi
     }
 
     elements.initialize(array);
   }
   return true;
 }
 
 // Retrieve the combinator elements from the data holder.
-static MOZ_MUST_USE bool GetPromiseCombinatorElements(
+[[nodiscard]] static bool GetPromiseCombinatorElements(
     JSContext* cx, Handle<PromiseCombinatorDataHolder*> data,
     MutableHandle<PromiseCombinatorElements> elements) {
   bool needsWrapping = false;
   JSObject* valuesObj = &data->valuesArray().toObject();
   if (IsProxy(valuesObj)) {
     // See comment for NewPromiseCombinatorElements for why we unwrap here.
     valuesObj = UncheckedUnwrap(valuesObj);
 
@@ -3306,17 +3306,17 @@ static bool PromiseCombinatorElementFunc
   MOZ_ASSERT(idx >= 0);
   *index = uint32_t(idx);
 
   return false;
 }
 
 // ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
 // 25.6.4.1.1 PerformPromiseAll (iteratorRecord, constructor, resultCapability)
-static MOZ_MUST_USE bool PerformPromiseAll(
+[[nodiscard]] static bool PerformPromiseAll(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done) {
   *done = false;
 
   // Step 1.
   MOZ_ASSERT(C->isConstructor());
 
@@ -3443,17 +3443,17 @@ static bool PromiseAllResolveElementFunc
 // 25.6.4.3 Promise.race ( iterable )
 static bool Promise_static_race(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CommonPromiseCombinator(cx, args, CombinatorKind::Race);
 }
 
 // ES2020 draft rev dc1e21c454bd316810be1c0e7af0131a2d7f38e9
 // 25.6.4.3.1 PerformPromiseRace (iteratorRecord, constructor, resultCapability)
-static MOZ_MUST_USE bool PerformPromiseRace(
+[[nodiscard]] static bool PerformPromiseRace(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done) {
   *done = false;
 
   // Step 1.
   MOZ_ASSERT(C->isConstructor());
 
@@ -3498,17 +3498,17 @@ static bool Promise_static_allSettled(JS
   CallArgs args = CallArgsFromVp(argc, vp);
   return CommonPromiseCombinator(cx, args, CombinatorKind::AllSettled);
 }
 
 // ES2020 draft rev e97c95d064750fb949b6778584702dd658cf5624
 // 25.6.4.2 Promise.allSettled ( iterable )
 //
 // PerformPromiseAllSettled ( iteratorRecord, constructor, resultCapability )
-static MOZ_MUST_USE bool PerformPromiseAllSettled(
+[[nodiscard]] static bool PerformPromiseAllSettled(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done) {
   *done = false;
 
   // Step 1.
   MOZ_ASSERT(C->isConstructor());
 
@@ -3709,17 +3709,17 @@ static bool PromiseAnyRejectElementFunct
 static void ThrowAggregateError(JSContext* cx,
                                 Handle<PromiseCombinatorElements> errors,
                                 HandleObject promise);
 
 // Promise.any (Stage 3 proposal)
 // https://tc39.es/proposal-promise-any/
 //
 // PerformPromiseAny ( iteratorRecord, constructor, resultCapability )
-static MOZ_MUST_USE bool PerformPromiseAny(
+[[nodiscard]] static bool PerformPromiseAny(
     JSContext* cx, PromiseForOfIterator& iterator, HandleObject C,
     Handle<PromiseCapability> resultCapability, HandleValue promiseResolve,
     bool* done) {
   *done = false;
 
   // Step 1.
   MOZ_ASSERT(C->isConstructor());
 
@@ -3915,17 +3915,17 @@ static void ThrowAggregateError(JSContex
 }
 
 // https://tc39.github.io/ecma262/#sec-promise.reject
 //
 // Unified implementation of
 // 25.6.4.4 Promise.reject ( r )
 // 25.6.4.5 Promise.resolve ( x )
 // 25.6.4.5.1 PromiseResolve ( C, x )
-static MOZ_MUST_USE JSObject* CommonStaticResolveRejectImpl(
+[[nodiscard]] static JSObject* CommonStaticResolveRejectImpl(
     JSContext* cx, HandleValue thisVal, HandleValue argVal,
     ResolutionMode mode) {
   // Steps 1-2 of Promise.reject and Promise.resolve.
   // Step 1: Let C be the this value.
   // Step 2: If Type(C) is not Object, throw a TypeError exception.
   if (!thisVal.isObject()) {
     const char* msg = mode == ResolveMode ? "Receiver of Promise.resolve call"
                                           : "Receiver of Promise.reject call";
@@ -4326,17 +4326,17 @@ static bool PromiseThenNewPromiseCapabil
                             resultCapability)) {
       return nullptr;
     }
   }
 
   return newPromise;
 }
 
-static MOZ_MUST_USE bool OriginalPromiseThenWithoutSettleHandlers(
+[[nodiscard]] static bool OriginalPromiseThenWithoutSettleHandlers(
     JSContext* cx, Handle<PromiseObject*> promise,
     Handle<PromiseObject*> promiseToResolve) {
   cx->check(promise);
 
   // Steps 3-4.
   Rooted<PromiseCapability> resultCapability(cx);
   if (!PromiseThenNewPromiseCapability(
           cx, promise, CreateDependentPromise::SkipIfCtorUnobservable,
@@ -4344,17 +4344,17 @@ static MOZ_MUST_USE bool OriginalPromise
     return false;
   }
 
   // Step 5.
   return PerformPromiseThenWithoutSettleHandlers(cx, promise, promiseToResolve,
                                                  resultCapability);
 }
 
-static MOZ_MUST_USE bool PerformPromiseThenWithReaction(
+[[nodiscard]] static bool PerformPromiseThenWithReaction(
     JSContext* cx, Handle<PromiseObject*> promise,
     Handle<PromiseReactionRecord*> reaction);
 
 [[nodiscard]] bool js::ReactToUnwrappedPromise(
     JSContext* cx, Handle<PromiseObject*> unwrappedPromise,
     HandleObject onFulfilled_, HandleObject onRejected_,
     UnhandledRejectionBehavior behavior) {
   cx->check(onFulfilled_);
@@ -4465,17 +4465,17 @@ static bool OriginalPromiseThenBuiltin(J
   return promise;
 }
 
 bool js::IsPromiseForAsyncFunctionOrGenerator(JSObject* promise) {
   return promise->is<PromiseObject>() &&
          PromiseHasAnyFlag(promise->as<PromiseObject>(), PROMISE_FLAG_ASYNC);
 }
 
-static MOZ_MUST_USE PromiseObject* CreatePromiseObjectForAsyncGenerator(
+[[nodiscard]] static PromiseObject* CreatePromiseObjectForAsyncGenerator(
     JSContext* cx) {
   PromiseObject* promise = CreatePromiseObjectWithoutResolutionFunctions(cx);
   if (!promise) {
     return nullptr;
   }
 
   AddPromiseFlags(*promise, PROMISE_FLAG_ASYNC);
   return promise;
@@ -4507,20 +4507,21 @@ static MOZ_MUST_USE PromiseObject* Creat
   return ResolvePromiseInternal(cx, resultPromise, value);
 }
 
 // https://tc39.github.io/ecma262/#await
 //
 // Helper function that performs 6.2.3.1 Await(promise) steps 2 and 9.
 // The same steps are also used in a few other places in the spec.
 template <typename T>
-static MOZ_MUST_USE bool InternalAwait(JSContext* cx, HandleValue value,
-                                       HandleObject resultPromise,
-                                       PromiseHandler onFulfilled,
-                                       PromiseHandler onRejected, T extraStep) {
+[[nodiscard]] static bool InternalAwait(JSContext* cx, HandleValue value,
+                                        HandleObject resultPromise,
+                                        PromiseHandler onFulfilled,
+                                        PromiseHandler onRejected,
+                                        T extraStep) {
   // Step 2: Let promise be ? PromiseResolve(%Promise%, « value »).
   RootedObject promise(cx, PromiseObject::unforgeableResolve(cx, value));
   if (!promise) {
     return false;
   }
 
   // This downcast is safe because unforgeableResolve either returns `value`
   // (only if it is already a possibly-wrapped promise) or creates a new
@@ -4783,17 +4784,17 @@ bool js::AsyncFromSyncIteratorMethod(JSC
 
   // Step 11: Return promiseCapability.[[Promise]].
   args.rval().setObject(*resultPromise);
   return true;
 }
 
 enum class ResumeNextKind { Enqueue, Reject, Resolve };
 
-static MOZ_MUST_USE bool AsyncGeneratorResumeNext(
+[[nodiscard]] static bool AsyncGeneratorResumeNext(
     JSContext* cx, Handle<AsyncGeneratorObject*> generator, ResumeNextKind kind,
     HandleValue valueOrException = UndefinedHandleValue, bool done = false);
 
 // 25.5.3.3 AsyncGeneratorResolve ( generator, value, done )
 [[nodiscard]] bool js::AsyncGeneratorResolve(
     JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue value,
     bool done) {
   return AsyncGeneratorResumeNext(cx, asyncGenObj, ResumeNextKind::Resolve,
@@ -4807,17 +4808,17 @@ static MOZ_MUST_USE bool AsyncGeneratorR
   return AsyncGeneratorResumeNext(cx, asyncGenObj, ResumeNextKind::Reject,
                                   exception);
 }
 
 // Unified implementation of:
 // 25.5.3.3 AsyncGeneratorResolve ( generator, value, done )
 // 25.5.3.4 AsyncGeneratorReject ( generator, exception )
 // 25.5.3.5 AsyncGeneratorResumeNext ( generator )
-static MOZ_MUST_USE bool AsyncGeneratorResumeNext(
+[[nodiscard]] static bool AsyncGeneratorResumeNext(
     JSContext* cx, Handle<AsyncGeneratorObject*> generator, ResumeNextKind kind,
     HandleValue valueOrException_ /* = UndefinedHandleValue */,
     bool done /* = false */) {
   RootedValue valueOrException(cx, valueOrException_);
 
   // Many paths through the algorithm end in recursive tail-calls.
   // We implement these with a loop.
   while (true) {
@@ -5262,17 +5263,17 @@ bool Promise_then_noRetVal(JSContext* cx
 // ES2016, 25.4.5.3.
 bool js::Promise_then(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return Promise_then_impl(cx, args.thisv(), args.get(0), args.get(1),
                            args.rval(), true);
 }
 
 // ES2016, 25.4.5.3.1.
-static MOZ_MUST_USE bool PerformPromiseThen(
+[[nodiscard]] static bool PerformPromiseThen(
     JSContext* cx, Handle<PromiseObject*> promise, HandleValue onFulfilled_,
     HandleValue onRejected_, Handle<PromiseCapability> resultCapability) {
   // Step 1 (implicit).
   // Step 2 (implicit).
 
   // Step 3.
   RootedValue onFulfilled(cx, onFulfilled_);
   if (!IsCallable(onFulfilled)) {
@@ -5291,17 +5292,17 @@ static MOZ_MUST_USE bool PerformPromiseT
                             IncumbentGlobalObject::Yes));
   if (!reaction) {
     return false;
   }
 
   return PerformPromiseThenWithReaction(cx, promise, reaction);
 }
 
-static MOZ_MUST_USE bool PerformPromiseThenWithoutSettleHandlers(
+[[nodiscard]] static bool PerformPromiseThenWithoutSettleHandlers(
     JSContext* cx, Handle<PromiseObject*> promise,
     Handle<PromiseObject*> promiseToResolve,
     Handle<PromiseCapability> resultCapability) {
   // Step 1 (implicit).
   // Step 2 (implicit).
 
   // Step 3.
   HandleValue onFulfilled = NullHandleValue;
@@ -5319,17 +5320,17 @@ static MOZ_MUST_USE bool PerformPromiseT
 
   reaction->setIsDefaultResolvingHandler(promiseToResolve);
 
   return PerformPromiseThenWithReaction(cx, promise, reaction);
 }
 
 // https://tc39.github.io/ecma262/#sec-performpromisethen
 // 25.6.5.4.1 PerformPromiseThen steps 8-11.
-static MOZ_MUST_USE bool PerformPromiseThenWithReaction(
+[[nodiscard]] static bool PerformPromiseThenWithReaction(
     JSContext* cx, Handle<PromiseObject*> unwrappedPromise,
     Handle<PromiseReactionRecord*> reaction) {
   // Step 8: If promise.[[PromiseState]] is "pending", then
   JS::PromiseState state = unwrappedPromise->state();
   int32_t flags = unwrappedPromise->flags();
   if (state == JS::PromiseState::Pending) {
     // Step 8.a: Append fulfillReaction as the last element of the List that is
     //           promise.[[PromiseFulfillReactions]].
@@ -5378,17 +5379,17 @@ static MOZ_MUST_USE bool PerformPromiseT
   }
 
   // Step 11: Set promise.[[PromiseIsHandled]] to true.
   unwrappedPromise->setHandled();
 
   return true;
 }
 
-static MOZ_MUST_USE bool AddPromiseReaction(
+[[nodiscard]] static bool AddPromiseReaction(
     JSContext* cx, Handle<PromiseObject*> unwrappedPromise,
     Handle<PromiseReactionRecord*> reaction) {
   MOZ_RELEASE_ASSERT(reaction->is<PromiseReactionRecord>());
   RootedValue reactionVal(cx, ObjectValue(*reaction));
 
   // The code that creates Promise reactions can handle wrapped Promises,
   // unwrapping them as needed. That means that the `promise` and `reaction`
   // objects we have here aren't necessarily from the same compartment. In
@@ -5452,17 +5453,17 @@ static MOZ_MUST_USE bool AddPromiseReact
       return false;
     }
     reactions->setDenseElement(len, reactionVal);
   }
 
   return true;
 }
 
-static MOZ_MUST_USE bool AddDummyPromiseReactionForDebugger(
+[[nodiscard]] static bool AddDummyPromiseReactionForDebugger(
     JSContext* cx, Handle<PromiseObject*> promise,
     HandleObject dependentPromise) {
   if (promise->state() != JS::PromiseState::Pending) {
     return true;
   }
 
   // `dependentPromise` should be a maybe-wrapped Promise.
   MOZ_ASSERT(UncheckedUnwrap(dependentPromise)->is<PromiseObject>());
@@ -5691,17 +5692,17 @@ void PromiseObject::copyUserInteractionF
 
 // We can skip `await` with an already resolved value only if the current frame
 // is the topmost JS frame and the current job is the last job in the job queue.
 // This guarantees that any new job enqueued in the current turn will be
 // executed immediately after the current job.
 //
 // Currently we only support skipping jobs when the async function is resumed
 // at least once.
-static MOZ_MUST_USE bool IsTopMostAsyncFunctionCall(JSContext* cx) {
+[[nodiscard]] static bool IsTopMostAsyncFunctionCall(JSContext* cx) {
   FrameIter iter(cx);
 
   // The current frame should be the async function.
   if (iter.done()) {
     return false;
   }
 
   if (!iter.isFunctionFrame() && iter.isModuleFrame()) {

--- a/js/src/builtin/Promise.h
+++ b/js/src/builtin/Promise.h
@@ -79,17 +79,17 @@ enum class UnhandledRejectionBehavior { 
  *
  * Note: Reactions pushed using this function contain a null `promise` field.
  * That field is only ever used by devtools, which have to treat these reactions
  * specially.
  *
  * 0. The sense of "react" here is the sense of the term as defined by Web IDL:
  *    https://heycam.github.io/webidl/#dfn-perform-steps-once-promise-is-settled
  */
-extern MOZ_MUST_USE bool ReactToUnwrappedPromise(
+[[nodiscard]] extern bool ReactToUnwrappedPromise(
     JSContext* cx, JS::Handle<PromiseObject*> unwrappedPromise,
     JS::Handle<JSObject*> onFulfilled_, JS::Handle<JSObject*> onRejected_,
     UnhandledRejectionBehavior behavior);
 
 /**
  * PromiseResolve ( C, x )
  *
  * The abstract operation PromiseResolve, given a constructor and a value,
@@ -173,44 +173,44 @@ struct PromiseReactionRecordBuilder {
   // Note that resolve, reject, and result may not be same-compartment with cx,
   // or with the promise we're inspecting. This function presents the values
   // exactly as they appear in the reaction record. They may also be wrapped or
   // unwrapped.
   //
   // Some reaction records refer to internal resolution or rejection functions
   // that are not naturally represented as debuggee JavaScript functions. In
   // this case, resolve and reject may be nullptr.
-  virtual MOZ_MUST_USE bool then(JSContext* cx, JS::Handle<JSObject*> resolve,
-                                 JS::Handle<JSObject*> reject,
-                                 JS::Handle<JSObject*> result) = 0;
+  [[nodiscard]] virtual bool then(JSContext* cx, JS::Handle<JSObject*> resolve,
+                                  JS::Handle<JSObject*> reject,
+                                  JS::Handle<JSObject*> result) = 0;
 
   // A reaction record created when one native promise is resolved to another.
   // The 'promise' argument is the promise that will be settled in the same way
   // the promise this reaction record is attached to is settled.
   //
   // Note that promise may not be same-compartment with cx. This function
   // presents the promise exactly as it appears in the reaction record.
-  virtual MOZ_MUST_USE bool direct(
+  [[nodiscard]] virtual bool direct(
       JSContext* cx, JS::Handle<PromiseObject*> unwrappedPromise) = 0;
 
   // A reaction record that resumes an asynchronous function suspended at an
   // await expression. The 'generator' argument is the generator object
   // representing the call.
   //
   // Note that generator may not be same-compartment with cx. This function
   // presents the generator exactly as it appears in the reaction record.
-  virtual MOZ_MUST_USE bool asyncFunction(
+  [[nodiscard]] virtual bool asyncFunction(
       JSContext* cx,
       JS::Handle<AsyncFunctionGeneratorObject*> unwrappedGenerator) = 0;
 
   // A reaction record that resumes an asynchronous generator suspended at an
   // await expression. The 'generator' argument is the generator object
   // representing the call.
   //
   // Note that generator may not be same-compartment with cx. This function
   // presents the generator exactly as it appears in the reaction record.
-  virtual MOZ_MUST_USE bool asyncGenerator(
+  [[nodiscard]] virtual bool asyncGenerator(
       JSContext* cx, JS::Handle<AsyncGeneratorObject*> unwrappedGenerator) = 0;
 };
 
 }  // namespace js
 
 #endif  // builtin_Promise_h

--- a/js/src/builtin/Reflect.h
+++ b/js/src/builtin/Reflect.h
@@ -12,20 +12,20 @@
 namespace js {
 
 extern const JSClass ReflectClass;
 
 }  // namespace js
 
 namespace js {
 
-extern MOZ_MUST_USE bool Reflect_getPrototypeOf(JSContext* cx, unsigned argc,
-                                                Value* vp);
+[[nodiscard]] extern bool Reflect_getPrototypeOf(JSContext* cx, unsigned argc,
+                                                 Value* vp);
 
-extern MOZ_MUST_USE bool Reflect_isExtensible(JSContext* cx, unsigned argc,
-                                              Value* vp);
+[[nodiscard]] extern bool Reflect_isExtensible(JSContext* cx, unsigned argc,
+                                               Value* vp);
 
-extern MOZ_MUST_USE bool Reflect_ownKeys(JSContext* cx, unsigned argc,
-                                         Value* vp);
+[[nodiscard]] extern bool Reflect_ownKeys(JSContext* cx, unsigned argc,
+                                          Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_Reflect_h */

--- a/js/src/builtin/RegExp.h
+++ b/js/src/builtin/RegExp.h
@@ -32,112 +32,113 @@ JSObject* InitRegExpClass(JSContext* cx,
                                        MutableHandleValue rval);
 
 // Translation from MatchPairs to a JS array in regexp_exec()'s output format.
 [[nodiscard]] bool CreateRegExpMatchResult(JSContext* cx, HandleRegExpShared re,
                                            HandleString input,
                                            const MatchPairs& matches,
                                            MutableHandleValue rval);
 
-extern MOZ_MUST_USE bool RegExpMatcher(JSContext* cx, unsigned argc, Value* vp);
-
-extern MOZ_MUST_USE bool RegExpMatcherRaw(JSContext* cx, HandleObject regexp,
-                                          HandleString input,
-                                          int32_t maybeLastIndex,
-                                          MatchPairs* maybeMatches,
-                                          MutableHandleValue output);
-
-extern MOZ_MUST_USE bool RegExpSearcher(JSContext* cx, unsigned argc,
+[[nodiscard]] extern bool RegExpMatcher(JSContext* cx, unsigned argc,
                                         Value* vp);
 
-extern MOZ_MUST_USE bool RegExpSearcherRaw(JSContext* cx, HandleObject regexp,
+[[nodiscard]] extern bool RegExpMatcherRaw(JSContext* cx, HandleObject regexp,
                                            HandleString input,
-                                           int32_t lastIndex,
+                                           int32_t maybeLastIndex,
                                            MatchPairs* maybeMatches,
-                                           int32_t* result);
+                                           MutableHandleValue output);
 
-extern MOZ_MUST_USE bool RegExpTester(JSContext* cx, unsigned argc, Value* vp);
+[[nodiscard]] extern bool RegExpSearcher(JSContext* cx, unsigned argc,
+                                         Value* vp);
 
-extern MOZ_MUST_USE bool RegExpTesterRaw(JSContext* cx, HandleObject regexp,
-                                         HandleString input, int32_t lastIndex,
-                                         int32_t* endIndex);
+[[nodiscard]] extern bool RegExpSearcherRaw(JSContext* cx, HandleObject regexp,
+                                            HandleString input,
+                                            int32_t lastIndex,
+                                            MatchPairs* maybeMatches,
+                                            int32_t* result);
 
-extern MOZ_MUST_USE bool intrinsic_GetElemBaseForLambda(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp);
+[[nodiscard]] extern bool RegExpTester(JSContext* cx, unsigned argc, Value* vp);
 
-extern MOZ_MUST_USE bool intrinsic_GetStringDataProperty(JSContext* cx,
+[[nodiscard]] extern bool RegExpTesterRaw(JSContext* cx, HandleObject regexp,
+                                          HandleString input, int32_t lastIndex,
+                                          int32_t* endIndex);
+
+[[nodiscard]] extern bool intrinsic_GetElemBaseForLambda(JSContext* cx,
                                                          unsigned argc,
                                                          Value* vp);
 
+[[nodiscard]] extern bool intrinsic_GetStringDataProperty(JSContext* cx,
+                                                          unsigned argc,
+                                                          Value* vp);
+
 /*
  * The following functions are for use by self-hosted code.
  */
 
 /*
  * Behaves like RegExp(source, flags).
  * |source| must be a valid regular expression pattern, |flags| is a raw
  * integer value representing the regular expression flags.
  * Must be called without |new|.
  *
  * Dedicated function for RegExp.prototype[@@replace] and
  * RegExp.prototype[@@split] optimized paths.
  */
-extern MOZ_MUST_USE bool regexp_construct_raw_flags(JSContext* cx,
+[[nodiscard]] extern bool regexp_construct_raw_flags(JSContext* cx,
+                                                     unsigned argc, Value* vp);
+
+[[nodiscard]] extern bool IsRegExp(JSContext* cx, HandleValue value,
+                                   bool* result);
+
+[[nodiscard]] extern bool RegExpCreate(JSContext* cx, HandleValue pattern,
+                                       HandleValue flags,
+                                       MutableHandleValue rval);
+
+[[nodiscard]] extern bool RegExpPrototypeOptimizable(JSContext* cx,
+                                                     unsigned argc, Value* vp);
+
+[[nodiscard]] extern bool RegExpPrototypeOptimizableRaw(JSContext* cx,
+                                                        JSObject* proto);
+
+[[nodiscard]] extern bool RegExpInstanceOptimizable(JSContext* cx,
                                                     unsigned argc, Value* vp);
 
-extern MOZ_MUST_USE bool IsRegExp(JSContext* cx, HandleValue value,
-                                  bool* result);
-
-extern MOZ_MUST_USE bool RegExpCreate(JSContext* cx, HandleValue pattern,
-                                      HandleValue flags,
-                                      MutableHandleValue rval);
-
-extern MOZ_MUST_USE bool RegExpPrototypeOptimizable(JSContext* cx,
-                                                    unsigned argc, Value* vp);
-
-extern MOZ_MUST_USE bool RegExpPrototypeOptimizableRaw(JSContext* cx,
+[[nodiscard]] extern bool RegExpInstanceOptimizableRaw(JSContext* cx,
+                                                       JSObject* obj,
                                                        JSObject* proto);
 
-extern MOZ_MUST_USE bool RegExpInstanceOptimizable(JSContext* cx, unsigned argc,
-                                                   Value* vp);
-
-extern MOZ_MUST_USE bool RegExpInstanceOptimizableRaw(JSContext* cx,
-                                                      JSObject* obj,
-                                                      JSObject* proto);
-
-extern MOZ_MUST_USE bool RegExpGetSubstitution(
+[[nodiscard]] extern bool RegExpGetSubstitution(
     JSContext* cx, HandleArrayObject matchResult, HandleLinearString string,
     size_t position, HandleLinearString replacement, size_t firstDollarIndex,
     HandleValue namedCaptures, MutableHandleValue rval);
 
-extern MOZ_MUST_USE bool GetFirstDollarIndex(JSContext* cx, unsigned argc,
-                                             Value* vp);
+[[nodiscard]] extern bool GetFirstDollarIndex(JSContext* cx, unsigned argc,
+                                              Value* vp);
 
-extern MOZ_MUST_USE bool GetFirstDollarIndexRaw(JSContext* cx, JSString* str,
-                                                int32_t* index);
+[[nodiscard]] extern bool GetFirstDollarIndexRaw(JSContext* cx, JSString* str,
+                                                 int32_t* index);
 
 extern int32_t GetFirstDollarIndexRawFlat(JSLinearString* text);
 
 // RegExp ClassSpec members used in RegExpObject.cpp.
-extern MOZ_MUST_USE bool regexp_construct(JSContext* cx, unsigned argc,
-                                          Value* vp);
+[[nodiscard]] extern bool regexp_construct(JSContext* cx, unsigned argc,
+                                           Value* vp);
 extern const JSPropertySpec regexp_static_props[];
 extern const JSPropertySpec regexp_properties[];
 extern const JSFunctionSpec regexp_methods[];
 
 // Used in RegExpObject::isOriginalFlagGetter.
-extern MOZ_MUST_USE bool regexp_global(JSContext* cx, unsigned argc,
-                                       JS::Value* vp);
-extern MOZ_MUST_USE bool regexp_ignoreCase(JSContext* cx, unsigned argc,
+[[nodiscard]] extern bool regexp_global(JSContext* cx, unsigned argc,
+                                        JS::Value* vp);
+[[nodiscard]] extern bool regexp_ignoreCase(JSContext* cx, unsigned argc,
+                                            JS::Value* vp);
+[[nodiscard]] extern bool regexp_multiline(JSContext* cx, unsigned argc,
                                            JS::Value* vp);
-extern MOZ_MUST_USE bool regexp_multiline(JSContext* cx, unsigned argc,
-                                          JS::Value* vp);
-extern MOZ_MUST_USE bool regexp_dotAll(JSContext* cx, unsigned argc,
-                                       JS::Value* vp);
-extern MOZ_MUST_USE bool regexp_sticky(JSContext* cx, unsigned argc,
-                                       JS::Value* vp);
-extern MOZ_MUST_USE bool regexp_unicode(JSContext* cx, unsigned argc,
+[[nodiscard]] extern bool regexp_dotAll(JSContext* cx, unsigned argc,
                                         JS::Value* vp);
+[[nodiscard]] extern bool regexp_sticky(JSContext* cx, unsigned argc,
+                                        JS::Value* vp);
+[[nodiscard]] extern bool regexp_unicode(JSContext* cx, unsigned argc,
+                                         JS::Value* vp);
 
 } /* namespace js */
 
 #endif /* builtin_RegExp_h */

--- a/js/src/builtin/Stream.cpp
+++ b/js/src/builtin/Stream.cpp
@@ -102,17 +102,17 @@ const JSClass ByteStreamChunk::class_ = 
  * Streams spec, 3.10.3
  *      new ReadableByteStreamController ( stream, underlyingSource,
  *                                         highWaterMark )
  * Steps 3 - 16.
  *
  * Note: All arguments must be same-compartment with cx. ReadableStream
  * controllers are always created in the same compartment as the stream.
  */
-static MOZ_MUST_USE ReadableByteStreamController*
+[[nodiscard]] static ReadableByteStreamController*
 CreateReadableByteStreamController(JSContext* cx,
                                    Handle<ReadableStream*> stream,
                                    HandleValue underlyingByteSource,
                                    HandleValue highWaterMarkVal)
 {
     cx->check(stream, underlyingByteSource, highWaterMarkVal);
 
     Rooted<ReadableByteStreamController*> controller(cx,
@@ -385,23 +385,23 @@ static const JSClassOps ReadableByteStre
 JS_STREAMS_CLASS_SPEC(ReadableByteStreamController, 0, SlotCount,
                       ClassSpec::DontDefineConstructor,
                       JSCLASS_BACKGROUND_FINALIZE,
                       &ReadableByteStreamControllerClassOps);
 
 // Streams spec, 3.11.5.1. [[CancelSteps]] ()
 // Unified with 3.9.5.1 above.
 
-static MOZ_MUST_USE bool ReadableByteStreamControllerHandleQueueDrain(
+[[nodiscard]] static bool ReadableByteStreamControllerHandleQueueDrain(
     JSContext* cx, Handle<ReadableStreamController*> unwrappedController);
 
 /**
  * Streams spec, 3.11.5.2. [[PullSteps]] ( forAuthorCode )
  */
-static MOZ_MUST_USE PromiseObject* ReadableByteStreamControllerPullSteps(
+[[nodiscard]] static PromiseObject* ReadableByteStreamControllerPullSteps(
     JSContext* cx, Handle<ReadableByteStreamController*> unwrappedController) {
   // Step 1: Let stream be this.[[controlledReadableByteStream]].
   Rooted<ReadableStream*> unwrappedStream(cx, unwrappedController->stream());
 
   // Step 2: Assert: ! ReadableStreamHasDefaultReader(stream) is true.
 #ifdef DEBUG
   bool result;
   if (!ReadableStreamHasDefaultReader(cx, unwrappedStream, &result)) {
@@ -602,17 +602,17 @@ static MOZ_MUST_USE PromiseObject* Reada
 
 // Streams spec, 3.13.2. IsReadableByteStreamController ( x )
 // Implemented via is<ReadableByteStreamController>()
 
 // Streams spec, 3.13.3.
 //      ReadableByteStreamControllerCallPullIfNeeded ( controller )
 // Unified with 3.9.2 above.
 
-static MOZ_MUST_USE bool ReadableByteStreamControllerInvalidateBYOBRequest(
+[[nodiscard]] static bool ReadableByteStreamControllerInvalidateBYOBRequest(
     JSContext* cx, Handle<ReadableByteStreamController*> unwrappedController);
 
 /**
  * Streams spec, 3.13.5.
  *      ReadableByteStreamControllerClearPendingPullIntos ( controller )
  */
 [[nodiscard]] bool js::ReadableByteStreamControllerClearPendingPullIntos(
     JSContext* cx, Handle<ReadableByteStreamController*> unwrappedController) {
@@ -704,17 +704,17 @@ static MOZ_MUST_USE bool ReadableByteStr
 // Streams spec 3.13.14.
 //      ReadableByteStreamControllerGetDesiredSize ( controller )
 // Unified with 3.10.8 above.
 
 /**
  * Streams spec, 3.13.15.
  *      ReadableByteStreamControllerHandleQueueDrain ( controller )
  */
-static MOZ_MUST_USE bool ReadableByteStreamControllerHandleQueueDrain(
+[[nodiscard]] static bool ReadableByteStreamControllerHandleQueueDrain(
     JSContext* cx, Handle<ReadableStreamController*> unwrappedController) {
   MOZ_ASSERT(unwrappedController->is<ReadableByteStreamController>());
 
   // Step 1: Assert: controller.[[controlledReadableStream]].[[state]]
   //                 is "readable".
   Rooted<ReadableStream*> unwrappedStream(cx, unwrappedController->stream());
   MOZ_ASSERT(unwrappedStream->readable());
 
@@ -741,17 +741,17 @@ enum BYOBRequestSlots {
   BYOBRequestSlot_View,
   BYOBRequestSlotCount
 };
 
 /**
  * Streams spec 3.13.16.
  *      ReadableByteStreamControllerInvalidateBYOBRequest ( controller )
  */
-static MOZ_MUST_USE bool ReadableByteStreamControllerInvalidateBYOBRequest(
+[[nodiscard]] static bool ReadableByteStreamControllerInvalidateBYOBRequest(
     JSContext* cx, Handle<ReadableByteStreamController*> unwrappedController) {
   // Step 1: If controller.[[byobRequest]] is undefined, return.
   RootedValue unwrappedBYOBRequestVal(cx, unwrappedController->byobRequest());
   if (unwrappedBYOBRequestVal.isUndefined()) {
     return true;
   }
 
   RootedNativeObject unwrappedBYOBRequest(

--- a/js/src/builtin/Stream.h
+++ b/js/src/builtin/Stream.h
@@ -15,22 +15,22 @@
 struct JS_PUBLIC_API JSContext;
 
 namespace js {
 
 class PromiseObject;
 class ReadableByteStreamController;
 class ReadableStreamController;
 
-extern MOZ_MUST_USE bool ReadableByteStreamControllerClearPendingPullIntos(
+[[nodiscard]] extern bool ReadableByteStreamControllerClearPendingPullIntos(
     JSContext* cx,
     JS::Handle<ReadableByteStreamController*> unwrappedController);
 
-extern MOZ_MUST_USE bool ReadableByteStreamControllerClose(
+[[nodiscard]] extern bool ReadableByteStreamControllerClose(
     JSContext* cx,
     JS::Handle<ReadableByteStreamController*> unwrappedController);
 
-extern MOZ_MUST_USE PromiseObject* ReadableStreamControllerPullSteps(
+[[nodiscard]] extern PromiseObject* ReadableStreamControllerPullSteps(
     JSContext* cx, JS::Handle<ReadableStreamController*> unwrappedController);
 
 }  // namespace js
 
 #endif /* builtin_Stream_h */

--- a/js/src/builtin/String.h
+++ b/js/src/builtin/String.h
@@ -52,27 +52,27 @@ extern bool str_endsWith(JSContext* cx, 
 
 #if JS_HAS_INTL_API
 /**
  * Returns the input string converted to lower case based on the language
  * specific case mappings for the input locale.
  *
  * Usage: lowerCase = intl_toLocaleLowerCase(string, locale)
  */
-extern MOZ_MUST_USE bool intl_toLocaleLowerCase(JSContext* cx, unsigned argc,
-                                                Value* vp);
+[[nodiscard]] extern bool intl_toLocaleLowerCase(JSContext* cx, unsigned argc,
+                                                 Value* vp);
 
 /**
  * Returns the input string converted to upper case based on the language
  * specific case mappings for the input locale.
  *
  * Usage: upperCase = intl_toLocaleUpperCase(string, locale)
  */
-extern MOZ_MUST_USE bool intl_toLocaleUpperCase(JSContext* cx, unsigned argc,
-                                                Value* vp);
+[[nodiscard]] extern bool intl_toLocaleUpperCase(JSContext* cx, unsigned argc,
+                                                 Value* vp);
 #endif
 
 ArrayObject* StringSplitString(JSContext* cx, HandleString str,
                                HandleString sep, uint32_t limit);
 
 JSString* StringFlatReplaceString(JSContext* cx, HandleString string,
                                   HandleString pattern,
                                   HandleString replacement);

--- a/js/src/builtin/Symbol.h
+++ b/js/src/builtin/Symbol.h
@@ -32,34 +32,35 @@ class SymbolObject : public NativeObject
     return getFixedSlot(PRIMITIVE_VALUE_SLOT).toSymbol();
   }
 
  private:
   inline void setPrimitiveValue(JS::Symbol* symbol) {
     setFixedSlot(PRIMITIVE_VALUE_SLOT, SymbolValue(symbol));
   }
 
-  static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool construct(JSContext* cx, unsigned argc, Value* vp);
 
   // Static methods.
-  static MOZ_MUST_USE bool for_(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool keyFor(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool for_(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool keyFor(JSContext* cx, unsigned argc, Value* vp);
 
   // Methods defined on Symbol.prototype.
-  static MOZ_MUST_USE bool toString_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool toString(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool valueOf_impl(JSContext* cx, const CallArgs& args);
-  static MOZ_MUST_USE bool valueOf(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE bool toPrimitive(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool toString_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool toString(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool valueOf_impl(JSContext* cx, const CallArgs& args);
+  [[nodiscard]] static bool valueOf(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool toPrimitive(JSContext* cx, unsigned argc,
+                                        Value* vp);
 
   // Properties defined on Symbol.prototype.
-  static MOZ_MUST_USE bool descriptionGetter_impl(JSContext* cx,
-                                                  const CallArgs& args);
-  static MOZ_MUST_USE bool descriptionGetter(JSContext* cx, unsigned argc,
-                                             Value* vp);
+  [[nodiscard]] static bool descriptionGetter_impl(JSContext* cx,
+                                                   const CallArgs& args);
+  [[nodiscard]] static bool descriptionGetter(JSContext* cx, unsigned argc,
+                                              Value* vp);
 
   static const JSPropertySpec properties[];
   static const JSFunctionSpec methods[];
   static const JSFunctionSpec staticMethods[];
   static const ClassSpec classSpec_;
 };
 
 } /* namespace js */

--- a/js/src/builtin/WeakMapObject.h
+++ b/js/src/builtin/WeakMapObject.h
@@ -21,17 +21,17 @@ class WeakCollectionObject : public Nati
     return static_cast<ObjectValueWeakMap*>(getPrivate());
   }
 
   size_t sizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
     ObjectValueWeakMap* map = getMap();
     return map ? map->sizeOfIncludingThis(aMallocSizeOf) : 0;
   }
 
-  static MOZ_MUST_USE bool nondeterministicGetKeys(
+  [[nodiscard]] static bool nondeterministicGetKeys(
       JSContext* cx, Handle<WeakCollectionObject*> obj,
       MutableHandleObject ret);
 
  protected:
   static const JSClassOps classOps_;
 };
 
 class WeakMapObject : public WeakCollectionObject {
@@ -40,29 +40,29 @@ class WeakMapObject : public WeakCollect
   static const JSClass protoClass_;
 
  private:
   static const ClassSpec classSpec_;
 
   static const JSPropertySpec properties[];
   static const JSFunctionSpec methods[];
 
-  static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool construct(JSContext* cx, unsigned argc, Value* vp);
 
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool is(HandleValue v);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool is(HandleValue v);
 
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool has_impl(JSContext* cx,
-                                                      const CallArgs& args);
-  static MOZ_MUST_USE bool has(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool get_impl(JSContext* cx,
-                                                      const CallArgs& args);
-  static MOZ_MUST_USE bool get(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool delete_impl(JSContext* cx,
-                                                         const CallArgs& args);
-  static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool set_impl(JSContext* cx,
-                                                      const CallArgs& args);
-  static MOZ_MUST_USE bool set(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool has_impl(JSContext* cx,
+                                                       const CallArgs& args);
+  [[nodiscard]] static bool has(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool get_impl(JSContext* cx,
+                                                       const CallArgs& args);
+  [[nodiscard]] static bool get(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool delete_impl(JSContext* cx,
+                                                          const CallArgs& args);
+  [[nodiscard]] static bool delete_(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool set_impl(JSContext* cx,
+                                                       const CallArgs& args);
+  [[nodiscard]] static bool set(JSContext* cx, unsigned argc, Value* vp);
 };
 
 }  // namespace js
 
 #endif /* builtin_WeakMapObject_h */

--- a/js/src/builtin/WeakRefObject.h
+++ b/js/src/builtin/WeakRefObject.h
@@ -21,17 +21,17 @@ class WeakRefObject : public NativeObjec
   void setTarget(JSObject* target);
 
  private:
   static const JSClassOps classOps_;
   static const ClassSpec classSpec_;
   static const JSPropertySpec properties[];
   static const JSFunctionSpec methods[];
 
-  static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool construct(JSContext* cx, unsigned argc, Value* vp);
   static void trace(JSTracer* trc, JSObject* obj);
   static void finalize(JSFreeOp* op, JSObject* obj);
 
   static bool preserveDOMWrapper(JSContext* cx, HandleObject obj);
 
   static bool deref(JSContext* cx, unsigned argc, Value* vp);
   static void readBarrier(JSContext* cx, Handle<WeakRefObject*> self);
 };

--- a/js/src/builtin/WeakSetObject.h
+++ b/js/src/builtin/WeakSetObject.h
@@ -20,29 +20,29 @@ class WeakSetObject : public WeakCollect
 
  private:
   static const ClassSpec classSpec_;
 
   static const JSPropertySpec properties[];
   static const JSFunctionSpec methods[];
 
   static WeakSetObject* create(JSContext* cx, HandleObject proto = nullptr);
-  static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static bool construct(JSContext* cx, unsigned argc, Value* vp);
 
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool is(HandleValue v);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool is(HandleValue v);
 
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool add_impl(JSContext* cx,
-                                                      const CallArgs& args);
-  static MOZ_MUST_USE bool add(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool delete_impl(JSContext* cx,
-                                                         const CallArgs& args);
-  static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
-  static MOZ_MUST_USE MOZ_ALWAYS_INLINE bool has_impl(JSContext* cx,
-                                                      const CallArgs& args);
-  static MOZ_MUST_USE bool has(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool add_impl(JSContext* cx,
+                                                       const CallArgs& args);
+  [[nodiscard]] static bool add(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool delete_impl(JSContext* cx,
+                                                          const CallArgs& args);
+  [[nodiscard]] static bool delete_(JSContext* cx, unsigned argc, Value* vp);
+  [[nodiscard]] static MOZ_ALWAYS_INLINE bool has_impl(JSContext* cx,
+                                                       const CallArgs& args);
+  [[nodiscard]] static bool has(JSContext* cx, unsigned argc, Value* vp);
 
   static bool isBuiltinAdd(HandleValue add);
 };
 
 }  // namespace js
 
 template <>
 inline bool JSObject::is<js::WeakCollectionObject>() const {

--- a/js/src/builtin/intl/Collator.h
+++ b/js/src/builtin/intl/Collator.h
@@ -58,47 +58,47 @@ class CollatorObject : public NativeObje
 
 /**
  * Returns a new instance of the standard built-in Collator constructor.
  * Self-hosted code cannot cache this constructor (as it does for others in
  * Utilities.js) because it is initialized after self-hosted code is compiled.
  *
  * Usage: collator = intl_Collator(locales, options)
  */
-extern MOZ_MUST_USE bool intl_Collator(JSContext* cx, unsigned argc,
-                                       JS::Value* vp);
+[[nodiscard]] extern bool intl_Collator(JSContext* cx, unsigned argc,
+                                        JS::Value* vp);
 
 /**
  * Returns an array with the collation type identifiers per Unicode
  * Technical Standard 35, Unicode Locale Data Markup Language, for the
  * collations supported for the given locale. "standard" and "search" are
  * excluded.
  *
  * Usage: collations = intl_availableCollations(locale)
  */
-extern MOZ_MUST_USE bool intl_availableCollations(JSContext* cx, unsigned argc,
-                                                  JS::Value* vp);
+[[nodiscard]] extern bool intl_availableCollations(JSContext* cx, unsigned argc,
+                                                   JS::Value* vp);
 
 /**
  * Compares x and y (which must be String values), and returns a number less
  * than 0 if x < y, 0 if x = y, or a number greater than 0 if x > y according
  * to the sort order for the locale and collation options of the given
  * Collator.
  *
  * Spec: ECMAScript Internationalization API Specification, 10.3.2.
  *
  * Usage: result = intl_CompareStrings(collator, x, y)
  */
-extern MOZ_MUST_USE bool intl_CompareStrings(JSContext* cx, unsigned argc,
-                                             JS::Value* vp);
+[[nodiscard]] extern bool intl_CompareStrings(JSContext* cx, unsigned argc,
+                                              JS::Value* vp);
 
 /**
  * Returns true if the given locale sorts upper-case before lower-case
  * characters.
  *
  * Usage: result = intl_isUpperCaseFirst(locale)
  */
-extern MOZ_MUST_USE bool intl_isUpperCaseFirst(JSContext* cx, unsigned argc,
-                                               JS::Value* vp);
+[[nodiscard]] extern bool intl_isUpperCaseFirst(JSContext* cx, unsigned argc,
+                                                JS::Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_intl_Collator_h */

--- a/js/src/builtin/intl/DateTimeFormat.h
+++ b/js/src/builtin/intl/DateTimeFormat.h
@@ -73,98 +73,99 @@ class DateTimeFormatObject : public Nati
 
 /**
  * Returns a new instance of the standard built-in DateTimeFormat constructor.
  * Self-hosted code cannot cache this constructor (as it does for others in
  * Utilities.js) because it is initialized after self-hosted code is compiled.
  *
  * Usage: dateTimeFormat = intl_DateTimeFormat(locales, options)
  */
-extern MOZ_MUST_USE bool intl_DateTimeFormat(JSContext* cx, unsigned argc,
-                                             JS::Value* vp);
+[[nodiscard]] extern bool intl_DateTimeFormat(JSContext* cx, unsigned argc,
+                                              JS::Value* vp);
 
 /**
  * Returns an array with the calendar type identifiers per Unicode
  * Technical Standard 35, Unicode Locale Data Markup Language, for the
  * supported calendars for the given locale. The default calendar is
  * element 0.
  *
  * Usage: calendars = intl_availableCalendars(locale)
  */
-extern MOZ_MUST_USE bool intl_availableCalendars(JSContext* cx, unsigned argc,
-                                                 JS::Value* vp);
+[[nodiscard]] extern bool intl_availableCalendars(JSContext* cx, unsigned argc,
+                                                  JS::Value* vp);
 
 /**
  * Returns the calendar type identifier per Unicode Technical Standard 35,
  * Unicode Locale Data Markup Language, for the default calendar for the given
  * locale.
  *
  * Usage: calendar = intl_defaultCalendar(locale)
  */
-extern MOZ_MUST_USE bool intl_defaultCalendar(JSContext* cx, unsigned argc,
-                                              JS::Value* vp);
+[[nodiscard]] extern bool intl_defaultCalendar(JSContext* cx, unsigned argc,
+                                               JS::Value* vp);
 
 /**
  * 6.4.1 IsValidTimeZoneName ( timeZone )
  *
  * Verifies that the given string is a valid time zone name. If it is a valid
  * time zone name, its IANA time zone name is returned. Otherwise returns null.
  *
  * ES2017 Intl draft rev 4a23f407336d382ed5e3471200c690c9b020b5f3
  *
  * Usage: ianaTimeZone = intl_IsValidTimeZoneName(timeZone)
  */
-extern MOZ_MUST_USE bool intl_IsValidTimeZoneName(JSContext* cx, unsigned argc,
-                                                  JS::Value* vp);
+[[nodiscard]] extern bool intl_IsValidTimeZoneName(JSContext* cx, unsigned argc,
+                                                   JS::Value* vp);
 
 /**
  * Return the canonicalized time zone name. Canonicalization resolves link
  * names to their target time zones.
  *
  * Usage: ianaTimeZone = intl_canonicalizeTimeZone(timeZone)
  */
-extern MOZ_MUST_USE bool intl_canonicalizeTimeZone(JSContext* cx, unsigned argc,
-                                                   JS::Value* vp);
+[[nodiscard]] extern bool intl_canonicalizeTimeZone(JSContext* cx,
+                                                    unsigned argc,
+                                                    JS::Value* vp);
 
 /**
  * Return the default time zone name. The time zone name is not canonicalized.
  *
  * Usage: icuDefaultTimeZone = intl_defaultTimeZone()
  */
-extern MOZ_MUST_USE bool intl_defaultTimeZone(JSContext* cx, unsigned argc,
-                                              JS::Value* vp);
+[[nodiscard]] extern bool intl_defaultTimeZone(JSContext* cx, unsigned argc,
+                                               JS::Value* vp);
 
 /**
  * Return the raw offset from GMT in milliseconds for the default time zone.
  *
  * Usage: defaultTimeZoneOffset = intl_defaultTimeZoneOffset()
  */
-extern MOZ_MUST_USE bool intl_defaultTimeZoneOffset(JSContext* cx,
-                                                    unsigned argc,
-                                                    JS::Value* vp);
+[[nodiscard]] extern bool intl_defaultTimeZoneOffset(JSContext* cx,
+                                                     unsigned argc,
+                                                     JS::Value* vp);
 
 /**
  * Return true if the given string is the default time zone as returned by
  * intl_defaultTimeZone(). Otherwise return false.
  *
  * Usage: isIcuDefaultTimeZone = intl_isDefaultTimeZone(icuDefaultTimeZone)
  */
-extern MOZ_MUST_USE bool intl_isDefaultTimeZone(JSContext* cx, unsigned argc,
-                                                JS::Value* vp);
+[[nodiscard]] extern bool intl_isDefaultTimeZone(JSContext* cx, unsigned argc,
+                                                 JS::Value* vp);
 
 /**
  * Return a pattern in the date-time format pattern language of Unicode
  * Technical Standard 35, Unicode Locale Data Markup Language, for the
  * best-fit date-time format pattern corresponding to skeleton for the
  * given locale.
  *
  * Usage: pattern = intl_patternForSkeleton(locale, skeleton, hourCycle)
  */
-extern MOZ_MUST_USE bool intl_patternForSkeleton(JSContext* cx, unsigned argc,
-                                                 JS::Value* vp);
+[[nodiscard]] extern bool intl_patternForSkeleton(JSContext* cx, unsigned argc,
+                                                  JS::Value* vp);
 
 /**
  * Return a pattern in the date-time format pattern language of Unicode
  * Technical Standard 35, Unicode Locale Data Markup Language, for the
  * best-fit date-time style for the given locale.
  * The function takes six arguments:
  *
  *   locale
@@ -187,47 +188,47 @@ extern MOZ_MUST_USE bool intl_patternFor
  * http://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
  *
  * If `undefined` is passed to `dateStyle` or `timeStyle`, the respective
  * portions of the pattern will not be included in the result.
  *
  * Usage: pattern = intl_patternForStyle(locale, dateStyle, timeStyle, timeZone,
  *                                       hour12, hourCycle)
  */
-extern MOZ_MUST_USE bool intl_patternForStyle(JSContext* cx, unsigned argc,
-                                              JS::Value* vp);
+[[nodiscard]] extern bool intl_patternForStyle(JSContext* cx, unsigned argc,
+                                               JS::Value* vp);
 
 /**
  * Return a skeleton for the pattern in the date-time format pattern language of
  * Unicode Technical Standard 35, Unicode Locale Data Markup Language.
  *
  * Usage: skeleton = intl_skeletonForPattern(pattern)
  */
-extern MOZ_MUST_USE bool intl_skeletonForPattern(JSContext* cx, unsigned argc,
-                                                 JS::Value* vp);
+[[nodiscard]] extern bool intl_skeletonForPattern(JSContext* cx, unsigned argc,
+                                                  JS::Value* vp);
 
 /**
  * Returns a String value representing x (which must be a Number value)
  * according to the effective locale and the formatting options of the
  * given DateTimeFormat.
  *
  * Spec: ECMAScript Internationalization API Specification, 12.3.2.
  *
  * Usage: formatted = intl_FormatDateTime(dateTimeFormat, x, formatToParts)
  */
-extern MOZ_MUST_USE bool intl_FormatDateTime(JSContext* cx, unsigned argc,
-                                             JS::Value* vp);
+[[nodiscard]] extern bool intl_FormatDateTime(JSContext* cx, unsigned argc,
+                                              JS::Value* vp);
 
 /**
  * Returns a String value representing the range between x and y (which both
  * must be Number values) according to the effective locale and the formatting
  * options of the given DateTimeFormat.
  *
  * Spec: Intl.DateTimeFormat.prototype.formatRange proposal
  *
  * Usage: formatted = intl_FormatDateTimeRange(dateTimeFmt, x, y, formatToParts)
  */
-extern MOZ_MUST_USE bool intl_FormatDateTimeRange(JSContext* cx, unsigned argc,
-                                                  JS::Value* vp);
+[[nodiscard]] extern bool intl_FormatDateTimeRange(JSContext* cx, unsigned argc,
+                                                   JS::Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_intl_DateTimeFormat_h */

--- a/js/src/builtin/intl/DisplayNames.h
+++ b/js/src/builtin/intl/DisplayNames.h
@@ -80,14 +80,14 @@ class DisplayNamesObject : public Native
 
 /**
  * Return the display name for the requested code or undefined if no applicable
  * display name was found.
  *
  * Usage: result = intl_ComputeDisplayName(displayNames, locale, calendar,
  *                                         style, fallback, type, code)
  */
-extern MOZ_MUST_USE bool intl_ComputeDisplayName(JSContext* cx, unsigned argc,
-                                                 Value* vp);
+[[nodiscard]] extern bool intl_ComputeDisplayName(JSContext* cx, unsigned argc,
+                                                  Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_intl_DisplayNames_h */

--- a/js/src/builtin/intl/IntlObject.h
+++ b/js/src/builtin/intl/IntlObject.h
@@ -35,32 +35,32 @@ extern const JSClass IntlClass;
  *     1 for bn-IN
  *   weekendEnd
  *     an integer in the range 1=Sunday to 7=Saturday indicating the day
  *     considered the end of a weekend, e.g. 1 for en-US, 1 for en-GB,
  *     1 for bn-IN (note that "weekend" is *not* necessarily two days)
  *
  * NOTE: "calendar" and "locale" properties are *not* added to the object.
  */
-extern MOZ_MUST_USE bool intl_GetCalendarInfo(JSContext* cx, unsigned argc,
-                                              JS::Value* vp);
+[[nodiscard]] extern bool intl_GetCalendarInfo(JSContext* cx, unsigned argc,
+                                               JS::Value* vp);
 
 /**
  * Returns a plain object with locale information for a single valid locale
  * (callers must perform this validation).  The object will have these
  * properties:
  *
  *   direction
  *     a string with a value "ltr" for left-to-right locale, and "rtl" for
  *     right-to-left locale.
  *   locale
  *     a BCP47 compilant locale string for the resolved locale.
  */
-extern MOZ_MUST_USE bool intl_GetLocaleInfo(JSContext* cx, unsigned argc,
-                                            JS::Value* vp);
+[[nodiscard]] extern bool intl_GetLocaleInfo(JSContext* cx, unsigned argc,
+                                             JS::Value* vp);
 
 /**
  * Returns an Array with CLDR-based fields display names.
  * The function takes three arguments:
  *
  *   locale
  *     BCP47 compliant locale string
  *   style
@@ -91,43 +91,43 @@ extern MOZ_MUST_USE bool intl_GetLocaleI
  *
  * [
  *   'year',
  *   'January',
  *   'Monday',
  *   'AM'
  * ]
  */
-extern MOZ_MUST_USE bool intl_ComputeDisplayNames(JSContext* cx, unsigned argc,
-                                                  JS::Value* vp);
+[[nodiscard]] extern bool intl_ComputeDisplayNames(JSContext* cx, unsigned argc,
+                                                   JS::Value* vp);
 /**
  * Compares a BCP 47 language tag against the locales in availableLocales and
  * returns the best available match -- or |undefined| if no match was found.
  * Uses the fallback mechanism of RFC 4647, section 3.4.
  *
  * The set of available locales consulted doesn't necessarily include the
  * default locale or any generalized forms of it (e.g. "de" is a more-general
  * form of "de-CH"). If you want to be sure to consider the default local and
  * its generalized forms (you usually will), pass the default locale as the
  * value of |defaultOrNull|; otherwise pass null.
  *
  * Spec: ECMAScript Internationalization API Specification, 9.2.2.
  * Spec: RFC 4647, section 3.4.
  *
  * Usage: result = intl_BestAvailableLocale("Collator", locale, defaultOrNull)
  */
-extern MOZ_MUST_USE bool intl_BestAvailableLocale(JSContext* cx, unsigned argc,
-                                                  JS::Value* vp);
+[[nodiscard]] extern bool intl_BestAvailableLocale(JSContext* cx, unsigned argc,
+                                                   JS::Value* vp);
 
 /**
  * Returns the input locale in its canonicalized form if ICU supports that
  * locale (perhaps via fallback, e.g. supporting "de-ZA" through "de" support
  * implied by a "de-DE" locale). Otherwise uses the last-ditch locale.
  *
  * Usage: result = intl_supportedLocaleOrFallback(locale)
  */
-extern MOZ_MUST_USE bool intl_supportedLocaleOrFallback(JSContext* cx,
-                                                        unsigned argc,
-                                                        JS::Value* vp);
+[[nodiscard]] extern bool intl_supportedLocaleOrFallback(JSContext* cx,
+                                                         unsigned argc,
+                                                         JS::Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_intl_IntlObject_h */

--- a/js/src/builtin/intl/LanguageTag.h
+++ b/js/src/builtin/intl/LanguageTag.h
@@ -752,17 +752,17 @@ class UnicodeExtensionKeyword final {
       : key_{key[0], key[1]}, type_(type) {}
 
   UnicodeKeySpan key() const { return {key_, sizeof(key_)}; }
   JSLinearString* type() const { return type_; }
 
   void trace(JSTracer* trc);
 };
 
-extern MOZ_MUST_USE bool ApplyUnicodeExtensionToTag(
+[[nodiscard]] extern bool ApplyUnicodeExtensionToTag(
     JSContext* cx, LanguageTag& tag,
     JS::HandleVector<UnicodeExtensionKeyword> keywords);
 
 }  // namespace intl
 
 }  // namespace js
 
 #endif /* builtin_intl_LanguageTag_h */

--- a/js/src/builtin/intl/ListFormat.h
+++ b/js/src/builtin/intl/ListFormat.h
@@ -57,14 +57,14 @@ class ListFormatObject : public NativeOb
 };
 
 /**
  * Returns a string representing the array of string values |list| according to
  * the effective locale and the formatting options of the given ListFormat.
  *
  * Usage: formatted = intl_FormatList(listFormat, list, formatToParts)
  */
-extern MOZ_MUST_USE bool intl_FormatList(JSContext* cx, unsigned argc,
-                                         Value* vp);
+[[nodiscard]] extern bool intl_FormatList(JSContext* cx, unsigned argc,
+                                          Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_intl_ListFormat_h */

--- a/js/src/builtin/intl/Locale.h
+++ b/js/src/builtin/intl/Locale.h
@@ -42,21 +42,21 @@ class LocaleObject : public NativeObject
   const Value& unicodeExtension() const {
     return getFixedSlot(UNICODE_EXTENSION_SLOT);
   }
 
  private:
   static const ClassSpec classSpec_;
 };
 
-extern MOZ_MUST_USE bool intl_ValidateAndCanonicalizeLanguageTag(JSContext* cx,
-                                                                 unsigned argc,
-                                                                 Value* vp);
+[[nodiscard]] extern bool intl_ValidateAndCanonicalizeLanguageTag(JSContext* cx,
+                                                                  unsigned argc,
+                                                                  Value* vp);
 
-extern MOZ_MUST_USE bool intl_TryValidateAndCanonicalizeLanguageTag(
+[[nodiscard]] extern bool intl_TryValidateAndCanonicalizeLanguageTag(
     JSContext* cx, unsigned argc, Value* vp);
 
-extern MOZ_MUST_USE bool intl_ValidateAndCanonicalizeUnicodeExtensionType(
+[[nodiscard]] extern bool intl_ValidateAndCanonicalizeUnicodeExtensionType(
     JSContext* cx, unsigned argc, Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_intl_Locale_h */

--- a/js/src/builtin/intl/NumberFormat.h
+++ b/js/src/builtin/intl/NumberFormat.h
@@ -71,50 +71,50 @@ class NumberFormatObject : public Native
 
 /**
  * Returns a new instance of the standard built-in NumberFormat constructor.
  * Self-hosted code cannot cache this constructor (as it does for others in
  * Utilities.js) because it is initialized after self-hosted code is compiled.
  *
  * Usage: numberFormat = intl_NumberFormat(locales, options)
  */
-extern MOZ_MUST_USE bool intl_NumberFormat(JSContext* cx, unsigned argc,
-                                           Value* vp);
+[[nodiscard]] extern bool intl_NumberFormat(JSContext* cx, unsigned argc,
+                                            Value* vp);
 
 /**
  * Returns the numbering system type identifier per Unicode
  * Technical Standard 35, Unicode Locale Data Markup Language, for the
  * default numbering system for the given locale.
  *
  * Usage: defaultNumberingSystem = intl_numberingSystem(locale)
  */
-extern MOZ_MUST_USE bool intl_numberingSystem(JSContext* cx, unsigned argc,
-                                              Value* vp);
+[[nodiscard]] extern bool intl_numberingSystem(JSContext* cx, unsigned argc,
+                                               Value* vp);
 
 /**
  * Returns a string representing the number x according to the effective
  * locale and the formatting options of the given NumberFormat.
  *
  * Spec: ECMAScript Internationalization API Specification, 11.3.2.
  *
  * Usage: formatted = intl_FormatNumber(numberFormat, x, formatToParts,
  *                                      unitStyle)
  */
-extern MOZ_MUST_USE bool intl_FormatNumber(JSContext* cx, unsigned argc,
-                                           Value* vp);
+[[nodiscard]] extern bool intl_FormatNumber(JSContext* cx, unsigned argc,
+                                            Value* vp);
 
 #if DEBUG || MOZ_SYSTEM_ICU
 /**
  * Returns an object with all available measurement units.
  *
  * Usage: units = intl_availableMeasurementUnits()
  */
-extern MOZ_MUST_USE bool intl_availableMeasurementUnits(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp);
+[[nodiscard]] extern bool intl_availableMeasurementUnits(JSContext* cx,
+                                                         unsigned argc,
+                                                         Value* vp);
 #endif
 
 namespace intl {
 
 /**
  * Class to create a number formatter skeleton.
  *
  * The skeleton syntax is documented at:

--- a/js/src/builtin/intl/PluralRules.h
+++ b/js/src/builtin/intl/PluralRules.h
@@ -89,27 +89,27 @@ class PluralRulesObject : public NativeO
  * Returns a plural rule for the number x according to the effective
  * locale and the formatting options of the given PluralRules.
  *
  * A plural rule is a grammatical category that expresses count distinctions
  * (such as "one", "two", "few" etc.).
  *
  * Usage: rule = intl_SelectPluralRule(pluralRules, x)
  */
-extern MOZ_MUST_USE bool intl_SelectPluralRule(JSContext* cx, unsigned argc,
-                                               JS::Value* vp);
+[[nodiscard]] extern bool intl_SelectPluralRule(JSContext* cx, unsigned argc,
+                                                JS::Value* vp);
 
 /**
  * Returns an array of plural rules categories for a given pluralRules object.
  *
  * Usage: categories = intl_GetPluralCategories(pluralRules)
  *
  * Example:
  *
  * pluralRules = new Intl.PluralRules('pl', {type: 'cardinal'});
  * intl_getPluralCategories(pluralRules); // ['one', 'few', 'many', 'other']
  */
-extern MOZ_MUST_USE bool intl_GetPluralCategories(JSContext* cx, unsigned argc,
-                                                  JS::Value* vp);
+[[nodiscard]] extern bool intl_GetPluralCategories(JSContext* cx, unsigned argc,
+                                                   JS::Value* vp);
 
 }  // namespace js
 
 #endif /* builtin_intl_PluralRules_h */

--- a/js/src/builtin/intl/RelativeTimeFormat.h
+++ b/js/src/builtin/intl/RelativeTimeFormat.h
@@ -64,18 +64,18 @@ class RelativeTimeFormatObject : public 
  * |t| should be a number representing a number to be formatted.
  * |unit| should be "second", "minute", "hour", "day", "week", "month",
  *                  "quarter", or "year".
  * |numeric| should be "always" or "auto".
  *
  * Usage: formatted = intl_FormatRelativeTime(relativeTimeFormat, t,
  *                                            unit, numeric, formatToParts)
  */
-extern MOZ_MUST_USE bool intl_FormatRelativeTime(JSContext* cx, unsigned argc,
-                                                 JS::Value* vp);
+[[nodiscard]] extern bool intl_FormatRelativeTime(JSContext* cx, unsigned argc,
+                                                  JS::Value* vp);
 
 namespace intl {
 
 using FieldType = js::ImmutablePropertyNamePtr JSAtomState::*;
 
 [[nodiscard]] bool FormattedRelativeTimeToParts(
     JSContext* cx, const UFormattedValue* formattedValue, double timeValue,
     FieldType relativeTimeUnit, MutableHandleValue result);

--- a/js/src/builtin/streams/MiscellaneousOperations-inl.h
+++ b/js/src/builtin/streams/MiscellaneousOperations-inl.h
@@ -29,20 +29,20 @@
 
 namespace js {
 
 /**
  * Streams spec, 6.3.5. PromiseCall ( F, V, args )
  * There must be 0-2 |args| arguments, all convertible to JS::Handle<JS::Value>.
  */
 template <class... Args>
-inline MOZ_MUST_USE JSObject* PromiseCall(JSContext* cx,
-                                          JS::Handle<JS::Value> F,
-                                          JS::Handle<JS::Value> V,
-                                          Args&&... args) {
+[[nodiscard]] inline JSObject* PromiseCall(JSContext* cx,
+                                           JS::Handle<JS::Value> F,
+                                           JS::Handle<JS::Value> V,
+                                           Args&&... args) {
   cx->check(F);
   cx->check(V);
   cx->check(args...);
 
   // Step 1: Assert: ! IsCallable(F) is true.
   MOZ_ASSERT(IsCallable(F));
 
   // Step 2: Assert: V is not undefined.
@@ -59,57 +59,57 @@ inline MOZ_MUST_USE JSObject* PromiseCal
 
   // Step 6: Otherwise, return a promise resolved with returnValue.[[Value]].
   return PromiseObject::unforgeableResolve(cx, rval);
 }
 
 /**
  * Resolve the unwrapped promise |unwrappedPromise| with |value|.
  */
-inline MOZ_MUST_USE bool ResolveUnwrappedPromiseWithValue(
+[[nodiscard]] inline bool ResolveUnwrappedPromiseWithValue(
     JSContext* cx, JSObject* unwrappedPromise, JS::Handle<JS::Value> value) {
   cx->check(value);
 
   JS::Rooted<JSObject*> promise(cx, unwrappedPromise);
   if (!cx->compartment()->wrap(cx, &promise)) {
     return false;
   }
 
   return JS::ResolvePromise(cx, promise, value);
 }
 
 /**
  * Resolve the unwrapped promise |unwrappedPromise| with |undefined|.
  */
-inline MOZ_MUST_USE bool ResolveUnwrappedPromiseWithUndefined(
+[[nodiscard]] inline bool ResolveUnwrappedPromiseWithUndefined(
     JSContext* cx, JSObject* unwrappedPromise) {
   return ResolveUnwrappedPromiseWithValue(cx, unwrappedPromise,
                                           JS::UndefinedHandleValue);
 }
 
 /**
  * Reject the unwrapped promise |unwrappedPromise| with |error|, overwriting
  * |*unwrappedPromise| with its wrapped form.
  */
-inline MOZ_MUST_USE bool RejectUnwrappedPromiseWithError(
+[[nodiscard]] inline bool RejectUnwrappedPromiseWithError(
     JSContext* cx, JS::MutableHandle<JSObject*> unwrappedPromise,
     JS::Handle<JS::Value> error) {
   cx->check(error);
 
   if (!cx->compartment()->wrap(cx, unwrappedPromise)) {
     return false;
   }
 
   return JS::RejectPromise(cx, unwrappedPromise, error);
 }
 
 /**
  * Reject the unwrapped promise |unwrappedPromise| with |error|.
  */
-inline MOZ_MUST_USE bool RejectUnwrappedPromiseWithError(
+[[nodiscard]] inline bool RejectUnwrappedPromiseWithError(
     JSContext* cx, JSObject* unwrappedPromise, JS::Handle<JS::Value> error) {
   JS::Rooted<JSObject*> promise(cx, unwrappedPromise);
   return RejectUnwrappedPromiseWithError(cx, &promise, error);
 }
 
 }  // namespace js
 
 #endif  // builtin_streams_MiscellaneousOperations_inl_h

--- a/js/src/builtin/streams/MiscellaneousOperations.h
+++ b/js/src/builtin/streams/MiscellaneousOperations.h
@@ -19,20 +19,20 @@
 #include "vm/PromiseObject.h"  // js::PromiseObject
 
 struct JS_PUBLIC_API JSContext;
 
 namespace js {
 
 class PropertyName;
 
-extern MOZ_MUST_USE PromiseObject* PromiseRejectedWithPendingError(
+[[nodiscard]] extern PromiseObject* PromiseRejectedWithPendingError(
     JSContext* cx);
 
-inline MOZ_MUST_USE bool ReturnPromiseRejectedWithPendingError(
+[[nodiscard]] inline bool ReturnPromiseRejectedWithPendingError(
     JSContext* cx, const JS::CallArgs& args) {
   PromiseObject* promise = PromiseRejectedWithPendingError(cx);
   if (!promise) {
     return false;
   }
 
   args.rval().setObject(*promise);
   return true;
@@ -44,41 +44,41 @@ inline MOZ_MUST_USE bool ReturnPromiseRe
  *                                            algoArgCount, extraArgs )
  *
  * This function only partly implements the standard algorithm. We do not
  * actually create a new JSFunction completely encapsulating the new algorithm.
  * Instead, this just gets the specified method and checks for errors. It's the
  * caller's responsibility to make sure that later, when the algorithm is
  * "performed", the appropriate steps are carried out.
  */
-extern MOZ_MUST_USE bool CreateAlgorithmFromUnderlyingMethod(
+[[nodiscard]] extern bool CreateAlgorithmFromUnderlyingMethod(
     JSContext* cx, JS::Handle<JS::Value> underlyingObject,
     const char* methodNameForErrorMessage, JS::Handle<PropertyName*> methodName,
     JS::MutableHandle<JS::Value> method);
 
 /**
  * Streams spec, 6.3.2. InvokeOrNoop ( O, P, args )
  * As it happens, all callers pass exactly one argument.
  */
-extern MOZ_MUST_USE bool InvokeOrNoop(JSContext* cx, JS::Handle<JS::Value> O,
-                                      JS::Handle<PropertyName*> P,
-                                      JS::Handle<JS::Value> arg,
-                                      JS::MutableHandle<JS::Value> rval);
+[[nodiscard]] extern bool InvokeOrNoop(JSContext* cx, JS::Handle<JS::Value> O,
+                                       JS::Handle<PropertyName*> P,
+                                       JS::Handle<JS::Value> arg,
+                                       JS::MutableHandle<JS::Value> rval);
 
 /**
  * Streams spec, 6.3.7. ValidateAndNormalizeHighWaterMark ( highWaterMark )
  */
-extern MOZ_MUST_USE bool ValidateAndNormalizeHighWaterMark(
+[[nodiscard]] extern bool ValidateAndNormalizeHighWaterMark(
     JSContext* cx, JS::Handle<JS::Value> highWaterMarkVal,
     double* highWaterMark);
 
 /**
  * Streams spec, 6.3.8. MakeSizeAlgorithmFromSizeFunction ( size )
  */
-extern MOZ_MUST_USE bool MakeSizeAlgorithmFromSizeFunction(
+[[nodiscard]] extern bool MakeSizeAlgorithmFromSizeFunction(
     JSContext* cx, JS::Handle<JS::Value> size);
 
 template <class T>
 inline bool IsMaybeWrapped(const JS::Handle<JS::Value> v) {
   return v.isObject() && v.toObject().canUnwrapAs<T>();
 }
 
 }  // namespace js

--- a/js/src/builtin/streams/PipeToState-inl.h
+++ b/js/src/builtin/streams/PipeToState-inl.h
@@ -33,17 +33,17 @@ namespace js {
  * operation.
  *
  * The pipe-to operation must be known to have had an |AbortSignal| associated
  * with it.
  *
  * If the signal is a wrapper, it will be unwrapped, so the result might not be
  * an object from the currently active compartment.
  */
-inline MOZ_MUST_USE JSObject* UnwrapSignalFromPipeToState(
+[[nodiscard]] inline JSObject* UnwrapSignalFromPipeToState(
     JSContext* cx, JS::Handle<PipeToState*> pipeToState) {
   cx->check(pipeToState);
 
   MOZ_ASSERT(pipeToState->hasSignal());
   return UnwrapAndDowncastValue(
       cx, pipeToState->getFixedSlot(PipeToState::Slot_Signal),
       cx->runtime()->maybeAbortSignalClass());
 }

--- a/js/src/builtin/streams/PipeToState.cpp
+++ b/js/src/builtin/streams/PipeToState.cpp
@@ -91,18 +91,18 @@ static WritableStream* GetUnwrappedDest(
   return UnwrapStreamFromWriter(cx, writer);
 }
 
 static bool WritableAndNotClosing(const WritableStream* unwrappedDest) {
   return unwrappedDest->writable() &&
          WritableStreamCloseQueuedOrInFlight(unwrappedDest);
 }
 
-static MOZ_MUST_USE bool Finalize(JSContext* cx, Handle<PipeToState*> state,
-                                  Handle<Maybe<Value>> error) {
+[[nodiscard]] static bool Finalize(JSContext* cx, Handle<PipeToState*> state,
+                                   Handle<Maybe<Value>> error) {
   cx->check(state);
   cx->check(error);
 
   // Step 1: Perform ! WritableStreamDefaultWriterRelease(writer).
   Rooted<WritableStreamDefaultWriter*> writer(cx, state->writer());
   cx->check(writer);
   if (!WritableStreamDefaultWriterRelease(cx, writer)) {
     return false;
@@ -126,17 +126,17 @@ static MOZ_MUST_USE bool Finalize(JSCont
     Rooted<Value> errorVal(cx, *error.get());
     return PromiseObject::reject(cx, promise, errorVal);
   }
 
   // Step 5: Otherwise, resolve promise with undefined.
   return PromiseObject::resolve(cx, promise, UndefinedHandleValue);
 }
 
-static MOZ_MUST_USE bool Finalize(JSContext* cx, unsigned argc, Value* vp) {
+[[nodiscard]] static bool Finalize(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   Rooted<PipeToState*> state(cx, TargetFromHandler<PipeToState>(args));
   cx->check(state);
 
   Rooted<Maybe<Value>> optionalError(cx, Nothing());
   if (Value maybeError = ExtraValueFromHandler(args);
       !maybeError.isMagic(JS_READABLESTREAM_PIPETO_FINALIZE_WITHOUT_ERROR)) {
@@ -152,19 +152,19 @@ static MOZ_MUST_USE bool Finalize(JSCont
   return true;
 }
 
 // Shutdown with an action, steps d-f:
 //   d. Let p be the result of performing action.
 //   e. Upon fulfillment of p, finalize, passing along originalError if it was
 //      given.
 //   f. Upon rejection of p with reason newError, finalize with newError.
-static MOZ_MUST_USE bool ActAndFinalize(JSContext* cx,
-                                        Handle<PipeToState*> state,
-                                        Handle<Maybe<Value>> error) {
+[[nodiscard]] static bool ActAndFinalize(JSContext* cx,
+                                         Handle<PipeToState*> state,
+                                         Handle<Maybe<Value>> error) {
   // Step d: Let p be the result of performing action.
   Rooted<JSObject*> p(cx);
   switch (state->shutdownAction()) {
     // This corresponds to the action performed by |abortAlgorithm| in
     // ReadableStreamPipeTo step 14.1.5.
     case PipeToState::ShutdownAction::AbortAlgorithm: {
       MOZ_ASSERT(error.get().isSome());
 
@@ -285,18 +285,18 @@ static MOZ_MUST_USE bool ActAndFinalize(
   Rooted<JSFunction*> onRejected(cx, NewHandler(cx, OnRejected, state));
   if (!onRejected) {
     return false;
   }
 
   return JS::AddPromiseReactions(cx, p, onFulfilled, onRejected);
 }
 
-static MOZ_MUST_USE bool ActAndFinalize(JSContext* cx, unsigned argc,
-                                        Value* vp) {
+[[nodiscard]] static bool ActAndFinalize(JSContext* cx, unsigned argc,
+                                         Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   Rooted<PipeToState*> state(cx, TargetFromHandler<PipeToState>(args));
   cx->check(state);
 
   Rooted<Maybe<Value>> optionalError(cx, Nothing());
   if (Value maybeError = ExtraValueFromHandler(args);
       !maybeError.isMagic(JS_READABLESTREAM_PIPETO_FINALIZE_WITHOUT_ERROR)) {
@@ -309,17 +309,17 @@ static MOZ_MUST_USE bool ActAndFinalize(
   }
 
   args.rval().setUndefined();
   return true;
 }
 
 // Shutdown with an action: if any of the above requirements ask to shutdown
 // with an action action, optionally with an error originalError, then:
-static MOZ_MUST_USE bool ShutdownWithAction(
+[[nodiscard]] static bool ShutdownWithAction(
     JSContext* cx, Handle<PipeToState*> state,
     PipeToState::ShutdownAction action, Handle<Maybe<Value>> originalError) {
   cx->check(state);
   cx->check(originalError);
 
   // Step a: If shuttingDown is true, abort these substeps.
   if (state->shuttingDown()) {
     return true;
@@ -376,18 +376,18 @@ static MOZ_MUST_USE bool ShutdownWithAct
   // Step e: Upon fulfillment of p, finalize, passing along originalError if it
   //         was given.
   // Step f: Upon rejection of p with reason newError, finalize with newError.
   return ActAndFinalize(cx, state, originalError);
 }
 
 // Shutdown: if any of the above requirements or steps ask to shutdown,
 // optionally with an error error, then:
-static MOZ_MUST_USE bool Shutdown(JSContext* cx, Handle<PipeToState*> state,
-                                  Handle<Maybe<Value>> error) {
+[[nodiscard]] static bool Shutdown(JSContext* cx, Handle<PipeToState*> state,
+                                   Handle<Maybe<Value>> error) {
   cx->check(state);
   cx->check(error);
 
   // Step a: If shuttingDown is true, abort these substeps.
   if (state->shuttingDown()) {
     return true;
   }
 
@@ -438,17 +438,17 @@ static MOZ_MUST_USE bool Shutdown(JSCont
   return Finalize(cx, state, error);
 }
 
 /**
  * Streams spec, 3.4.11. ReadableStreamPipeTo step 14:
  * "a. Errors must be propagated forward: if source.[[state]] is or becomes
  * 'errored', then..."
  */
-static MOZ_MUST_USE bool OnSourceErrored(
+[[nodiscard]] static bool OnSourceErrored(
     JSContext* cx, Handle<PipeToState*> state,
     Handle<ReadableStream*> unwrappedSource) {
   cx->check(state);
 
   Rooted<Maybe<Value>> storedError(cx, Some(unwrappedSource->storedError()));
   if (!cx->compartment()->wrap(cx, &storedError)) {
     return false;
   }
@@ -505,19 +505,19 @@ static MOZ_MUST_USE bool OnSourceErrored
   return true;
 }
 
 /**
  * Streams spec, 3.4.11. ReadableStreamPipeTo step 14:
  * "b. Errors must be propagated backward: if dest.[[state]] is or becomes
  * 'errored', then..."
  */
-static MOZ_MUST_USE bool OnDestErrored(JSContext* cx,
-                                       Handle<PipeToState*> state,
-                                       Handle<WritableStream*> unwrappedDest) {
+[[nodiscard]] static bool OnDestErrored(JSContext* cx,
+                                        Handle<PipeToState*> state,
+                                        Handle<WritableStream*> unwrappedDest) {
   cx->check(state);
 
   Rooted<Maybe<Value>> storedError(cx, Some(unwrappedDest->storedError()));
   if (!cx->compartment()->wrap(cx, &storedError)) {
     return false;
   }
 
   // As in |OnSourceErrored| above, we must deal with the case of |dest|
@@ -549,18 +549,18 @@ static MOZ_MUST_USE bool OnDestErrored(J
   return true;
 }
 
 /**
  * Streams spec, 3.4.11. ReadableStreamPipeTo step 14:
  * "c. Closing must be propagated forward: if source.[[state]] is or becomes
  * 'closed', then..."
  */
-static MOZ_MUST_USE bool OnSourceClosed(JSContext* cx,
-                                        Handle<PipeToState*> state) {
+[[nodiscard]] static bool OnSourceClosed(JSContext* cx,
+                                         Handle<PipeToState*> state) {
   cx->check(state);
 
   Rooted<Maybe<Value>> noError(cx, Nothing());
 
   // It shouldn't be possible for |source| to become closed *during* a pending
   // read: such spontaneous closure *should* be enqueued for processing *after*
   // the settling of the pending read.  (Note also that a [[closedPromise]]
   // resolution in |ReadableStreamClose| occurs only after all pending reads are
@@ -588,18 +588,18 @@ static MOZ_MUST_USE bool OnSourceClosed(
 }
 
 /**
  * Streams spec, 3.4.11. ReadableStreamPipeTo step 14:
  * "d. Closing must be propagated backward: if
  * ! WritableStreamCloseQueuedOrInFlight(dest) is true or dest.[[state]] is
  * 'closed', then..."
  */
-static MOZ_MUST_USE bool OnDestClosed(JSContext* cx,
-                                      Handle<PipeToState*> state) {
+[[nodiscard]] static bool OnDestClosed(JSContext* cx,
+                                       Handle<PipeToState*> state) {
   cx->check(state);
 
   // i. Assert: no chunks have been read or written.
   //
   // This assertion holds when this function is called by
   // |SourceOrDestErroredOrClosed|, before any async internal piping operations
   // happen.
   //
@@ -653,17 +653,17 @@ static MOZ_MUST_USE bool OnDestClosed(JS
 }
 
 /**
  * Streams spec, 3.4.11. ReadableStreamPipeTo step 14:
  * "Error and close states must be propagated: the following conditions must be
  * applied in order.", as applied at the very start of piping, before any reads
  * from source or writes to dest have been triggered.
  */
-static MOZ_MUST_USE bool SourceOrDestErroredOrClosed(
+[[nodiscard]] static bool SourceOrDestErroredOrClosed(
     JSContext* cx, Handle<PipeToState*> state,
     Handle<ReadableStream*> unwrappedSource,
     Handle<WritableStream*> unwrappedDest, bool* erroredOrClosed) {
   cx->check(state);
 
   *erroredOrClosed = true;
 
   // a. Errors must be propagated forward: if source.[[state]] is or becomes
@@ -691,33 +691,33 @@ static MOZ_MUST_USE bool SourceOrDestErr
       unwrappedDest->closed()) {
     return OnDestClosed(cx, state);
   }
 
   *erroredOrClosed = false;
   return true;
 }
 
-static MOZ_MUST_USE bool OnSourceClosed(JSContext* cx, unsigned argc,
-                                        Value* vp) {
+[[nodiscard]] static bool OnSourceClosed(JSContext* cx, unsigned argc,
+                                         Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   Rooted<PipeToState*> state(cx, TargetFromHandler<PipeToState>(args));
   cx->check(state);
 
   if (!OnSourceClosed(cx, state)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-static MOZ_MUST_USE bool OnSourceErrored(JSContext* cx, unsigned argc,
-                                         Value* vp) {
+[[nodiscard]] static bool OnSourceErrored(JSContext* cx, unsigned argc,
+                                          Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   Rooted<PipeToState*> state(cx, TargetFromHandler<PipeToState>(args));
   cx->check(state);
 
   Rooted<ReadableStream*> unwrappedSource(cx, GetUnwrappedSource(cx, state));
   if (!unwrappedSource) {
     return false;
@@ -726,32 +726,33 @@ static MOZ_MUST_USE bool OnSourceErrored
   if (!OnSourceErrored(cx, state, unwrappedSource)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-static MOZ_MUST_USE bool OnDestClosed(JSContext* cx, unsigned argc, Value* vp) {
+[[nodiscard]] static bool OnDestClosed(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   Rooted<PipeToState*> state(cx, TargetFromHandler<PipeToState>(args));
   cx->check(state);
 
   if (!OnDestClosed(cx, state)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-static MOZ_MUST_USE bool OnDestErrored(JSContext* cx, unsigned argc,
-                                       Value* vp) {
+[[nodiscard]] static bool OnDestErrored(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   Rooted<PipeToState*> state(cx, TargetFromHandler<PipeToState>(args));
   cx->check(state);
 
   Rooted<WritableStream*> unwrappedDest(cx, GetUnwrappedDest(cx, state));
   if (!unwrappedDest) {
     return false;
@@ -773,18 +774,18 @@ static inline JSObject* GetClosedPromise
       unwrapAccessorFromStream(cx, unwrappedStream);
   if (!unwrappedAccessor) {
     return nullptr;
   }
 
   return unwrappedAccessor->closedPromise();
 }
 
-static MOZ_MUST_USE bool ReadFromSource(JSContext* cx,
-                                        Handle<PipeToState*> state);
+[[nodiscard]] static bool ReadFromSource(JSContext* cx,
+                                         Handle<PipeToState*> state);
 
 static bool ReadFulfilled(JSContext* cx, Handle<PipeToState*> state,
                           Handle<JSObject*> result) {
   cx->check(state);
   cx->check(result);
 
   state->clearPendingRead();
 
@@ -875,18 +876,18 @@ static bool ReadFulfilled(JSContext* cx,
   }
 
   args.rval().setUndefined();
   return true;
 }
 
 static bool ReadFromSource(JSContext* cx, unsigned argc, Value* vp);
 
-static MOZ_MUST_USE bool ReadFromSource(JSContext* cx,
-                                        Handle<PipeToState*> state) {
+[[nodiscard]] static bool ReadFromSource(JSContext* cx,
+                                         Handle<PipeToState*> state) {
   cx->check(state);
 
   MOZ_ASSERT(!state->hasPendingRead(),
              "should only have one read in flight at a time, because multiple "
              "reads could cause the latter read to ignore backpressure "
              "signals");
 
   // "Shutdown must stop activity: if shuttingDown becomes true, the user agent
@@ -1029,19 +1030,19 @@ static bool ReadFromSource(JSContext* cx
   if (!ReadFromSource(cx, state)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-static MOZ_MUST_USE bool StartPiping(JSContext* cx, Handle<PipeToState*> state,
-                                     Handle<ReadableStream*> unwrappedSource,
-                                     Handle<WritableStream*> unwrappedDest) {
+[[nodiscard]] static bool StartPiping(JSContext* cx, Handle<PipeToState*> state,
+                                      Handle<ReadableStream*> unwrappedSource,
+                                      Handle<WritableStream*> unwrappedDest) {
   cx->check(state);
 
   // "Shutdown must stop activity: if shuttingDown becomes true, the user agent
   // must not initiate further reads from reader..."
   MOZ_ASSERT(!state->shuttingDown(), "can't be shutting down when starting");
 
   // "Error and close states must be propagated: the following conditions must
   // be applied in order."
@@ -1106,18 +1107,18 @@ static MOZ_MUST_USE bool StartPiping(JSC
 }
 
 /**
  * Stream spec, 4.8.1. ReadableStreamPipeTo ( source, dest,
  *                                            preventClose, preventAbort,
  *                                            preventCancel[, signal] )
  * Step 14.1 abortAlgorithm.
  */
-static MOZ_MUST_USE bool PerformAbortAlgorithm(JSContext* cx,
-                                               Handle<PipeToState*> state) {
+[[nodiscard]] static bool PerformAbortAlgorithm(JSContext* cx,
+                                                Handle<PipeToState*> state) {
   cx->check(state);
 
   // Step 14.1: Let abortAlgorithm be the following steps:
   // Step 14.1.1: Let error be a new "AbortError" DOMException.
   // Step 14.1.2: Let actions be an empty ordered set.
   // Step 14.1.3: If preventAbort is false, append the following action to
   //              actions:
   // Step 14.1.3.1: If dest.[[state]] is "writable", return