diff options
Diffstat (limited to 'js/src/vm')
27 files changed, 281 insertions, 281 deletions
diff --git a/js/src/vm/ArgumentsObject.h b/js/src/vm/ArgumentsObject.h index 63dc044b0f..46ca2976e6 100644 --- a/js/src/vm/ArgumentsObject.h +++ b/js/src/vm/ArgumentsObject.h @@ -173,7 +173,7 @@ class ArgumentsObject : public NativeObject return data()->rareData; } - MOZ_MUST_USE bool createRareData(JSContext* cx); + [[nodiscard]] bool createRareData(JSContext* cx); RareArgumentsData* getOrCreateRareData(JSContext* cx) { if (!data()->rareData && !createRareData(cx)) diff --git a/js/src/vm/ArrayBufferObject.cpp b/js/src/vm/ArrayBufferObject.cpp index 6ace034adb..79db90ac74 100644 --- a/js/src/vm/ArrayBufferObject.cpp +++ b/js/src/vm/ArrayBufferObject.cpp @@ -548,7 +548,7 @@ class js::WasmArrayRawBuffer } #endif - MOZ_MUST_USE bool growToSizeInPlace(uint32_t oldSize, uint32_t newSize) { + [[nodiscard]] bool growToSizeInPlace(uint32_t oldSize, uint32_t newSize) { MOZ_ASSERT(newSize >= oldSize); MOZ_ASSERT_IF(maxSize(), newSize <= maxSize().value()); MOZ_ASSERT(newSize <= mappedSize()); diff --git a/js/src/vm/ArrayBufferObject.h b/js/src/vm/ArrayBufferObject.h index f4010c6c77..31aae59d06 100644 --- a/js/src/vm/ArrayBufferObject.h +++ b/js/src/vm/ArrayBufferObject.h @@ -339,16 +339,16 @@ class ArrayBufferObject : public ArrayBufferObjectMaybeShared // WebAssembly support: static ArrayBufferObject* createForWasm(JSContext* cx, uint32_t initialSize, mozilla::Maybe<uint32_t> maxSize); - static MOZ_MUST_USE bool prepareForAsmJS(JSContext* cx, Handle<ArrayBufferObject*> buffer, + [[nodiscard]] static bool prepareForAsmJS(JSContext* cx, Handle<ArrayBufferObject*> buffer, bool needGuard); size_t wasmMappedSize() const; mozilla::Maybe<uint32_t> wasmMaxSize() const; - static MOZ_MUST_USE bool wasmGrowToSizeInPlace(uint32_t newSize, + [[nodiscard]] static bool wasmGrowToSizeInPlace(uint32_t newSize, Handle<ArrayBufferObject*> oldBuf, MutableHandle<ArrayBufferObject*> newBuf, JSContext* cx); #ifndef WASM_HUGE_MEMORY - static MOZ_MUST_USE bool wasmMovingGrowToSize(uint32_t newSize, + [[nodiscard]] static bool wasmMovingGrowToSize(uint32_t newSize, Handle<ArrayBufferObject*> oldBuf, MutableHandle<ArrayBufferObject*> newBuf, JSContext* cx); diff --git a/js/src/vm/AsyncFunction.cpp b/js/src/vm/AsyncFunction.cpp index 676ad87fdc..b1d0a111db 100644 --- a/js/src/vm/AsyncFunction.cpp +++ b/js/src/vm/AsyncFunction.cpp @@ -50,8 +50,8 @@ GlobalObject::initAsyncFunction(JSContext* cx, Handle<GlobalObject*> global) return true; } -static MOZ_MUST_USE bool AsyncFunctionStart(JSContext* cx, Handle<PromiseObject*> resultPromise, - HandleValue generatorVal); +[[nodiscard]] static bool AsyncFunctionStart(JSContext* cx, Handle<PromiseObject*> resultPromise, + HandleValue generatorVal); #define UNWRAPPED_ASYNC_WRAPPED_SLOT 1 #define WRAPPED_ASYNC_UNWRAPPED_SLOT 0 @@ -184,7 +184,7 @@ AsyncFunctionResume(JSContext* cx, Handle<PromiseObject*> resultPromise, HandleV } // Async Functions proposal 2.2 steps 3-8. -static MOZ_MUST_USE bool +[[nodiscard]] static bool AsyncFunctionStart(JSContext* cx, Handle<PromiseObject*> resultPromise, HandleValue generatorVal) { return AsyncFunctionResume(cx, resultPromise, generatorVal, ResumeKind::Normal, UndefinedHandleValue); @@ -194,7 +194,7 @@ AsyncFunctionStart(JSContext* cx, Handle<PromiseObject*> resultPromise, HandleVa // Implemented in js/src/builtin/Promise.cpp // Async Functions proposal 2.4. -MOZ_MUST_USE bool +[[nodiscard]] bool js::AsyncFunctionAwaitedFulfilled(JSContext* cx, Handle<PromiseObject*> resultPromise, HandleValue generatorVal, HandleValue value) { @@ -205,7 +205,7 @@ js::AsyncFunctionAwaitedFulfilled(JSContext* cx, Handle<PromiseObject*> resultPr } // Async Functions proposal 2.5. -MOZ_MUST_USE bool +[[nodiscard]] bool js::AsyncFunctionAwaitedRejected(JSContext* cx, Handle<PromiseObject*> resultPromise, HandleValue generatorVal, HandleValue reason) { diff --git a/js/src/vm/AsyncFunction.h b/js/src/vm/AsyncFunction.h index d1f9a44da1..47e7674ed1 100644 --- a/js/src/vm/AsyncFunction.h +++ b/js/src/vm/AsyncFunction.h @@ -26,11 +26,11 @@ WrapAsyncFunctionWithProto(JSContext* cx, HandleFunction unwrapped, HandleObject JSObject* WrapAsyncFunction(JSContext* cx, HandleFunction unwrapped); -MOZ_MUST_USE bool +[[nodiscard]] bool AsyncFunctionAwaitedFulfilled(JSContext* cx, Handle<PromiseObject*> resultPromise, HandleValue generatorVal, HandleValue value); -MOZ_MUST_USE bool +[[nodiscard]] bool AsyncFunctionAwaitedRejected(JSContext* cx, Handle<PromiseObject*> resultPromise, HandleValue generatorVal, HandleValue reason); diff --git a/js/src/vm/AsyncIteration.cpp b/js/src/vm/AsyncIteration.cpp index 49fdf7b8d6..fb74d7c7b7 100644 --- a/js/src/vm/AsyncIteration.cpp +++ b/js/src/vm/AsyncIteration.cpp @@ -128,7 +128,7 @@ js::GetUnwrappedAsyncGenerator(JSFunction* wrapped) } // Async Iteration proposal 4.1.1 Await Fulfilled Functions. -MOZ_MUST_USE bool +[[nodiscard]] bool js::AsyncGeneratorAwaitedFulfilled(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue value) { @@ -136,7 +136,7 @@ js::AsyncGeneratorAwaitedFulfilled(JSContext* cx, Handle<AsyncGeneratorObject*> } // Async Iteration proposal 4.1.2 Await Rejected Functions. -MOZ_MUST_USE bool +[[nodiscard]] bool js::AsyncGeneratorAwaitedRejected(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue reason) { @@ -144,7 +144,7 @@ js::AsyncGeneratorAwaitedRejected(JSContext* cx, Handle<AsyncGeneratorObject*> a } // Async Iteration proposal 11.4.3.7 step 8.d-e. -MOZ_MUST_USE bool +[[nodiscard]] bool js::AsyncGeneratorYieldReturnAwaitedFulfilled(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue value) @@ -153,7 +153,7 @@ js::AsyncGeneratorYieldReturnAwaitedFulfilled(JSContext* cx, } // Async Iteration proposal 11.4.3.7 step 8.d-e. -MOZ_MUST_USE bool +[[nodiscard]] bool js::AsyncGeneratorYieldReturnAwaitedRejected(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue reason) @@ -329,7 +329,7 @@ AsyncGeneratorObject::createRequest(JSContext* cx, Handle<AsyncGeneratorObject*> return request; } -static MOZ_MUST_USE bool +[[nodiscard]] static bool InternalEnqueue(JSContext* cx, HandleArrayObject queue, HandleValue val) { uint32_t length; @@ -346,7 +346,7 @@ InternalEnqueue(JSContext* cx, HandleArrayObject queue, HandleValue val) return SetLengthProperty(cx, queue, length + 1); } -static MOZ_MUST_USE bool +[[nodiscard]] static bool InternalDequeue(JSContext* cx, HandleArrayObject queue, MutableHandleValue val) { uint32_t length; @@ -376,7 +376,7 @@ InternalDequeue(JSContext* cx, HandleArrayObject queue, MutableHandleValue val) return SetLengthProperty(cx, queue, newlength); } -/* static */ MOZ_MUST_USE bool +[[nodiscard]] /* static */ bool AsyncGeneratorObject::enqueueRequest(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, Handle<AsyncGeneratorRequest*> request) { @@ -456,7 +456,7 @@ AsyncGeneratorRequest::create(JSContext* cx, CompletionKind completionKind, } // Async Iteration proposal 11.4.3.2 AsyncGeneratorStart steps 5.d-g. -static MOZ_MUST_USE bool +[[nodiscard]] static bool AsyncGeneratorReturned(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue value) { @@ -471,7 +471,7 @@ AsyncGeneratorReturned(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, } // Async Iteration proposal 11.4.3.2 AsyncGeneratorStart steps 5.d, f. -static MOZ_MUST_USE bool +[[nodiscard]] static bool AsyncGeneratorThrown(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj) { // Step 5.d. @@ -492,7 +492,7 @@ AsyncGeneratorThrown(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj) // Async Iteration proposal 11.4.3.7 (partially). // Most steps are done in generator. -static MOZ_MUST_USE bool +[[nodiscard]] static bool AsyncGeneratorYield(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue value) { // Step 5 is done in bytecode. @@ -510,7 +510,7 @@ AsyncGeneratorYield(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, Ha // Async Iteration proposal 11.4.3.5 AsyncGeneratorResumeNext // steps 12-14, 16-20. // Execution context switching is handled in generator. -MOZ_MUST_USE bool +[[nodiscard]] bool js::AsyncGeneratorResume(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, CompletionKind completionKind, HandleValue argument) { @@ -578,7 +578,7 @@ static const JSFunctionSpec async_generator_methods[] = { JS_FS_END }; -/* static */ MOZ_MUST_USE bool +[[nodiscard]] /* static */ bool GlobalObject::initAsyncGenerators(JSContext* cx, Handle<GlobalObject*> global) { if (global->getReservedSlot(ASYNC_ITERATOR_PROTO).isObject()) diff --git a/js/src/vm/AsyncIteration.h b/js/src/vm/AsyncIteration.h index d3deb90b1a..cda309e619 100644 --- a/js/src/vm/AsyncIteration.h +++ b/js/src/vm/AsyncIteration.h @@ -35,17 +35,17 @@ GetWrappedAsyncGenerator(JSFunction* unwrapped); JSFunction* GetUnwrappedAsyncGenerator(JSFunction* wrapped); -MOZ_MUST_USE bool +[[nodiscard]] bool AsyncGeneratorAwaitedFulfilled(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue value); -MOZ_MUST_USE bool +[[nodiscard]] bool AsyncGeneratorAwaitedRejected(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue reason); -MOZ_MUST_USE bool +[[nodiscard]] bool AsyncGeneratorYieldReturnAwaitedFulfilled(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue value); -MOZ_MUST_USE bool +[[nodiscard]] bool AsyncGeneratorYieldReturnAwaitedRejected(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, HandleValue reason); @@ -209,7 +209,7 @@ class AsyncGeneratorObject : public NativeObject return &getFixedSlot(Slot_Generator).toObject().as<GeneratorObject>(); } - static MOZ_MUST_USE bool + [[nodiscard]] static bool enqueueRequest(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, Handle<AsyncGeneratorRequest*> request); @@ -287,7 +287,7 @@ class AsyncFromSyncIteratorObject : public NativeObject } }; -MOZ_MUST_USE bool +[[nodiscard]] bool AsyncGeneratorResume(JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj, CompletionKind completionKind, HandleValue argument); diff --git a/js/src/vm/BigIntType.h b/js/src/vm/BigIntType.h index 693f8bf36c..c46e6b98c4 100644 --- a/js/src/vm/BigIntType.h +++ b/js/src/vm/BigIntType.h @@ -223,10 +223,10 @@ class BigInt final : public js::gc::TenuredCell { static size_t calculateMaximumCharactersRequired(HandleBigInt x, unsigned radix); - static MOZ_MUST_USE bool calculateMaximumDigitsRequired(js::ExclusiveContext* cx, - uint8_t radix, - size_t charCount, - size_t* result); + [[nodiscard]] static bool calculateMaximumDigitsRequired(js::ExclusiveContext* cx, + uint8_t radix, + size_t charCount, + size_t* result); static bool absoluteDivWithDigitDivisor( js::ExclusiveContext* cx, Handle<BigInt*> x, Digit divisor, diff --git a/js/src/vm/Debugger.h b/js/src/vm/Debugger.h index 56a6318ba9..e44cb908fd 100644 --- a/js/src/vm/Debugger.h +++ b/js/src/vm/Debugger.h @@ -110,7 +110,7 @@ class DebuggerWeakMap : private WeakMap<HeapPtr<UnbarrieredKey>, HeapPtr<JSObjec using Base::all; using Base::trace; - MOZ_MUST_USE bool init(uint32_t len = 16) { + [[nodiscard]] bool init(uint32_t len = 16) { return Base::init(len) && zoneCounts.init(); } @@ -166,7 +166,7 @@ class DebuggerWeakMap : private WeakMap<HeapPtr<UnbarrieredKey>, HeapPtr<JSObjec Base::assertEntriesNotAboutToBeFinalized(); } - MOZ_MUST_USE bool incZoneCount(JS::Zone* zone) { + [[nodiscard]] bool incZoneCount(JS::Zone* zone) { CountMap::Ptr p = zoneCounts.lookupWithDefault(zone, 0); if (!p) return false; @@ -219,7 +219,7 @@ class MOZ_RAII EvalOptions { ~EvalOptions(); const char* filename() const { return filename_; } unsigned lineno() const { return lineno_; } - MOZ_MUST_USE bool setFilename(JSContext* cx, const char* filename); + [[nodiscard]] bool setFilename(JSContext* cx, const char* filename); void setLineno(unsigned lineno) { lineno_ = lineno; } }; @@ -391,7 +391,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> static const size_t DEFAULT_MAX_LOG_LENGTH = 5000; - MOZ_MUST_USE bool appendAllocationSite(JSContext* cx, HandleObject obj, HandleSavedFrame frame, + [[nodiscard]] bool appendAllocationSite(JSContext* cx, HandleObject obj, HandleSavedFrame frame, double when); /* @@ -417,7 +417,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * debuggee's compartment. The given debuggee global must be observed by at * least one Debugger that is enabled and tracking allocations. */ - static MOZ_MUST_USE bool addAllocationsTracking(JSContext* cx, Handle<GlobalObject*> debuggee); + [[nodiscard]] static bool addAllocationsTracking(JSContext* cx, Handle<GlobalObject*> debuggee); /* * Remove allocations tracking for objects allocated within the given @@ -429,7 +429,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> /* * Add or remove allocations tracking for all debuggees. */ - MOZ_MUST_USE bool addAllocationsTrackingForAllDebuggees(JSContext* cx); + [[nodiscard]] bool addAllocationsTrackingForAllDebuggees(JSContext* cx); void removeAllocationsTrackingForAllDebuggees(); /* @@ -495,7 +495,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> class ScriptQuery; class ObjectQuery; - MOZ_MUST_USE bool addDebuggeeGlobal(JSContext* cx, Handle<GlobalObject*> obj); + [[nodiscard]] bool addDebuggeeGlobal(JSContext* cx, Handle<GlobalObject*> obj); void removeDebuggeeGlobal(FreeOp* fop, GlobalObject* global, WeakGlobalObjectSet::Enum* debugEnum); @@ -586,8 +586,8 @@ class Debugger : private mozilla::LinkedListElement<Debugger> static const Class class_; private: - static MOZ_MUST_USE bool getHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg, Hook which); - static MOZ_MUST_USE bool setHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg, Hook which); + [[nodiscard]] static bool getHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg, Hook which); + [[nodiscard]] static bool setHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg, Hook which); static bool getEnabled(JSContext* cx, unsigned argc, Value* vp); static bool setEnabled(JSContext* cx, unsigned argc, Value* vp); @@ -656,15 +656,15 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * compute it ourselves from |frame|. */ using DebuggerFrameVector = GCVector<DebuggerFrame*>; - static MOZ_MUST_USE bool getDebuggerFrames(AbstractFramePtr frame, + [[nodiscard]] static bool getDebuggerFrames(AbstractFramePtr frame, MutableHandle<DebuggerFrameVector> frames); public: - static MOZ_MUST_USE bool ensureExecutionObservabilityOfOsrFrame(JSContext* cx, + [[nodiscard]] static bool ensureExecutionObservabilityOfOsrFrame(JSContext* cx, InterpreterFrame* frame); // Public for DebuggerScript_setBreakpoint. - static MOZ_MUST_USE bool ensureExecutionObservabilityOfScript(JSContext* cx, JSScript* script); + [[nodiscard]] static bool ensureExecutionObservabilityOfScript(JSContext* cx, JSScript* script); // Whether the Debugger instance needs to observe all non-AOT JS // execution of its debugees. @@ -679,30 +679,30 @@ class Debugger : private mozilla::LinkedListElement<Debugger> IsObserving observesCoverage() const; private: - static MOZ_MUST_USE bool ensureExecutionObservabilityOfFrame(JSContext* cx, + [[nodiscard]] static bool ensureExecutionObservabilityOfFrame(JSContext* cx, AbstractFramePtr frame); - static MOZ_MUST_USE bool ensureExecutionObservabilityOfCompartment(JSContext* cx, + [[nodiscard]] static bool ensureExecutionObservabilityOfCompartment(JSContext* cx, JSCompartment* comp); static bool hookObservesAllExecution(Hook which); - MOZ_MUST_USE bool updateObservesAllExecutionOnDebuggees(JSContext* cx, IsObserving observing); - MOZ_MUST_USE bool updateObservesCoverageOnDebuggees(JSContext* cx, IsObserving observing); + [[nodiscard]] bool updateObservesAllExecutionOnDebuggees(JSContext* cx, IsObserving observing); + [[nodiscard]] bool updateObservesCoverageOnDebuggees(JSContext* cx, IsObserving observing); void updateObservesAsmJSOnDebuggees(IsObserving observing); JSObject* getHook(Hook hook) const; bool hasAnyLiveHooks(JSRuntime* rt) const; - static MOZ_MUST_USE bool slowPathCheckNoExecute(JSContext* cx, HandleScript script); + [[nodiscard]] static bool slowPathCheckNoExecute(JSContext* cx, HandleScript script); static JSTrapStatus slowPathOnEnterFrame(JSContext* cx, AbstractFramePtr frame); - static MOZ_MUST_USE bool slowPathOnLeaveFrame(JSContext* cx, AbstractFramePtr frame, + [[nodiscard]] static bool slowPathOnLeaveFrame(JSContext* cx, AbstractFramePtr frame, jsbytecode* pc, bool ok); static JSTrapStatus slowPathOnDebuggerStatement(JSContext* cx, AbstractFramePtr frame); static JSTrapStatus slowPathOnExceptionUnwind(JSContext* cx, AbstractFramePtr frame); static void slowPathOnNewScript(JSContext* cx, HandleScript script); static void slowPathOnNewWasmInstance(JSContext* cx, Handle<WasmInstanceObject*> wasmInstance); static void slowPathOnNewGlobalObject(JSContext* cx, Handle<GlobalObject*> global); - static MOZ_MUST_USE bool slowPathOnLogAllocationSite(JSContext* cx, HandleObject obj, + [[nodiscard]] static bool slowPathOnLogAllocationSite(JSContext* cx, HandleObject obj, HandleSavedFrame frame, double when, GlobalObject::DebuggerVector& dbgs); static void slowPathPromiseHook(JSContext* cx, Hook hook, HandleObject promise); @@ -768,10 +768,10 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * Gets a Debugger.Frame object. If maybeIter is non-null, we eagerly copy * its data if we need to make a new Debugger.Frame. */ - MOZ_MUST_USE bool getScriptFrameWithIter(JSContext* cx, AbstractFramePtr frame, + [[nodiscard]] bool getScriptFrameWithIter(JSContext* cx, AbstractFramePtr frame, const ScriptFrameIter* maybeIter, MutableHandleValue vp); - MOZ_MUST_USE bool getScriptFrameWithIter(JSContext* cx, AbstractFramePtr frame, + [[nodiscard]] bool getScriptFrameWithIter(JSContext* cx, AbstractFramePtr frame, const ScriptFrameIter* maybeIter, MutableHandleDebuggerFrame result); @@ -779,7 +779,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> static inline Debugger* fromOnNewGlobalObjectWatchersLink(JSCList* link); - static MOZ_MUST_USE bool replaceFrameGuts(JSContext* cx, AbstractFramePtr from, + [[nodiscard]] static bool replaceFrameGuts(JSContext* cx, AbstractFramePtr from, AbstractFramePtr to, ScriptFrameIter& iter); @@ -787,7 +787,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> Debugger(JSContext* cx, NativeObject* dbg); ~Debugger(); - MOZ_MUST_USE bool init(JSContext* cx); + [[nodiscard]] bool init(JSContext* cx); inline const js::GCPtrNativeObject& toJSObject() const; inline js::GCPtrNativeObject& toJSObjectRef(); static inline Debugger* fromJSObject(const JSObject* obj); @@ -816,14 +816,14 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * them and returns true. If not, it returns false. */ static void markIncomingCrossCompartmentEdges(JSTracer* tracer); - static MOZ_MUST_USE bool markAllIteratively(GCMarker* trc); + [[nodiscard]] static bool markAllIteratively(GCMarker* trc); static void markAll(JSTracer* trc); static void sweepAll(FreeOp* fop); static void detachAllDebuggersFromGlobal(FreeOp* fop, GlobalObject* global); static void findZoneEdges(JS::Zone* v, gc::ZoneComponentFinder& finder); // Checks it the current compartment is allowed to execute code. - static inline MOZ_MUST_USE bool checkNoExecute(JSContext* cx, HandleScript script); + [[nodiscard]] static inline bool checkNoExecute(JSContext* cx, HandleScript script); /* * JSTrapStatus Overview @@ -883,19 +883,19 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * throw, or vice versa: we can redirect to a complete copy of the * alternative path, containing its own call to onLeaveFrame.) */ - static inline MOZ_MUST_USE bool onLeaveFrame(JSContext* cx, AbstractFramePtr frame, + [[nodiscard]] static inline bool onLeaveFrame(JSContext* cx, AbstractFramePtr frame, jsbytecode* pc, bool ok); static inline void onNewScript(JSContext* cx, HandleScript script); static inline void onNewWasmInstance(JSContext* cx, Handle<WasmInstanceObject*> wasmInstance); static inline void onNewGlobalObject(JSContext* cx, Handle<GlobalObject*> global); - static inline MOZ_MUST_USE bool onLogAllocationSite(JSContext* cx, JSObject* obj, + [[nodiscard]] static inline bool onLogAllocationSite(JSContext* cx, JSObject* obj, HandleSavedFrame frame, double when); static JSTrapStatus onTrap(JSContext* cx, MutableHandleValue vp); static JSTrapStatus onSingleStep(JSContext* cx, MutableHandleValue vp); - static MOZ_MUST_USE bool handleBaselineOsr(JSContext* cx, InterpreterFrame* from, + [[nodiscard]] static bool handleBaselineOsr(JSContext* cx, InterpreterFrame* from, jit::BaselineFrame* to); - static MOZ_MUST_USE bool handleIonBailout(JSContext* cx, jit::RematerializedFrame* from, + [[nodiscard]] static bool handleIonBailout(JSContext* cx, jit::RematerializedFrame* from, jit::BaselineFrame* to); static void handleUnrecoverableIonBailoutError(JSContext* cx, jit::RematerializedFrame* frame); static void propagateForcedReturn(JSContext* cx, AbstractFramePtr frame, HandleValue rval); @@ -917,8 +917,8 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * or create a Debugger.Environment object for the given Env. On success, * store the Environment object in *vp and return true. */ - MOZ_MUST_USE bool wrapEnvironment(JSContext* cx, Handle<Env*> env, MutableHandleValue vp); - MOZ_MUST_USE bool wrapEnvironment(JSContext* cx, Handle<Env*> env, + [[nodiscard]] bool wrapEnvironment(JSContext* cx, Handle<Env*> env, MutableHandleValue vp); + [[nodiscard]] bool wrapEnvironment(JSContext* cx, Handle<Env*> env, MutableHandleDebuggerEnvironment result); /* @@ -941,8 +941,8 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * unaccessible uninitialized binding, this produces a plain object of the * form { uninitialized: true }. */ - MOZ_MUST_USE bool wrapDebuggeeValue(JSContext* cx, MutableHandleValue vp); - MOZ_MUST_USE bool wrapDebuggeeObject(JSContext* cx, HandleObject obj, + [[nodiscard]] bool wrapDebuggeeValue(JSContext* cx, MutableHandleValue vp); + [[nodiscard]] bool wrapDebuggeeObject(JSContext* cx, HandleObject obj, MutableHandleDebuggerObject result); /* @@ -972,9 +972,9 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * debugger compartment--mirror symmetry. But compartment wrapping always * happens in the target compartment--rotational symmetry.) */ - MOZ_MUST_USE bool unwrapDebuggeeValue(JSContext* cx, MutableHandleValue vp); - MOZ_MUST_USE bool unwrapDebuggeeObject(JSContext* cx, MutableHandleObject obj); - MOZ_MUST_USE bool unwrapPropertyDescriptor(JSContext* cx, HandleObject obj, + [[nodiscard]] bool unwrapDebuggeeValue(JSContext* cx, MutableHandleValue vp); + [[nodiscard]] bool unwrapDebuggeeObject(JSContext* cx, MutableHandleObject obj); + [[nodiscard]] bool unwrapPropertyDescriptor(JSContext* cx, HandleObject obj, MutableHandle<PropertyDescriptor> desc); /* @@ -983,7 +983,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * Use this if you have already access to a frame pointer without having * to incur the cost of walking the stack. */ - MOZ_MUST_USE bool getScriptFrame(JSContext* cx, AbstractFramePtr frame, MutableHandleValue vp) { + [[nodiscard]] bool getScriptFrame(JSContext* cx, AbstractFramePtr frame, MutableHandleValue vp) { return getScriptFrameWithIter(cx, frame, nullptr, vp); } @@ -995,11 +995,11 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * frame, in which case the cost of walking the stack has already been * paid. */ - MOZ_MUST_USE bool getScriptFrame(JSContext* cx, const ScriptFrameIter& iter, + [[nodiscard]] bool getScriptFrame(JSContext* cx, const ScriptFrameIter& iter, MutableHandleValue vp) { return getScriptFrameWithIter(cx, iter.abstractFramePtr(), &iter, vp); } - MOZ_MUST_USE bool getScriptFrame(JSContext* cx, const ScriptFrameIter& iter, + [[nodiscard]] bool getScriptFrame(JSContext* cx, const ScriptFrameIter& iter, MutableHandleDebuggerFrame result); @@ -1018,7 +1018,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * and |value|. |value| should be the return value or exception value, not * wrapped as a debuggee value. |cx| must be in the debugger compartment. */ - MOZ_MUST_USE bool newCompletionValue(JSContext* cx, JSTrapStatus status, const Value& value, + [[nodiscard]] bool newCompletionValue(JSContext* cx, JSTrapStatus status, const Value& value, MutableHandleValue result); /* @@ -1033,7 +1033,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger> * pending exception. (This ordinarily returns true even if the ok argument * is false.) */ - MOZ_MUST_USE bool receiveCompletionValue(mozilla::Maybe<AutoCompartment>& ac, bool ok, + [[nodiscard]] bool receiveCompletionValue(mozilla::Maybe<AutoCompartment>& ac, bool ok, HandleValue val, MutableHandleValue vp); @@ -1094,19 +1094,19 @@ class DebuggerEnvironment : public NativeObject HandleNativeObject debugger); DebuggerEnvironmentType type() const; - MOZ_MUST_USE bool getParent(JSContext* cx, MutableHandleDebuggerEnvironment result) const; - MOZ_MUST_USE bool getObject(JSContext* cx, MutableHandleDebuggerObject result) const; - MOZ_MUST_USE bool getCallee(JSContext* cx, MutableHandleDebuggerObject result) const; + [[nodiscard]] bool getParent(JSContext* cx, MutableHandleDebuggerEnvironment result) const; + [[nodiscard]] bool getObject(JSContext* cx, MutableHandleDebuggerObject result) const; + [[nodiscard]] bool getCallee(JSContext* cx, MutableHandleDebuggerObject result) const; bool isDebuggee() const; bool isOptimized() const; - static MOZ_MUST_USE bool getNames(JSContext* cx, HandleDebuggerEnvironment environment, + [[nodiscard]] static bool getNames(JSContext* cx, HandleDebuggerEnvironment environment, MutableHandle<IdVector> result); - static MOZ_MUST_USE bool find(JSContext* cx, HandleDebuggerEnvironment environment, + [[nodiscard]] static bool find(JSContext* cx, HandleDebuggerEnvironment environment, HandleId id, MutableHandleDebuggerEnvironment result); - static MOZ_MUST_USE bool getVariable(JSContext* cx, HandleDebuggerEnvironment environment, + [[nodiscard]] static bool getVariable(JSContext* cx, HandleDebuggerEnvironment environment, HandleId id, MutableHandleValue result); - static MOZ_MUST_USE bool setVariable(JSContext* cx, HandleDebuggerEnvironment environment, + [[nodiscard]] static bool setVariable(JSContext* cx, HandleDebuggerEnvironment environment, HandleId id, HandleValue value); private: @@ -1125,19 +1125,19 @@ class DebuggerEnvironment : public NativeObject bool requireDebuggee(JSContext* cx) const; - 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 bool typeGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool parentGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool objectGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool calleeGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool inspectableGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool optimizedOutGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool typeGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool parentGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool objectGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool calleeGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool inspectableGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool optimizedOutGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool namesMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool findMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool getVariableMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool setVariableMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool namesMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool findMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool getVariableMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool setVariableMethod(JSContext* cx, unsigned argc, Value* vp); }; enum class DebuggerFrameType { @@ -1168,22 +1168,22 @@ class DebuggerFrame : public NativeObject static DebuggerFrame* create(JSContext* cx, HandleObject proto, AbstractFramePtr referent, const ScriptFrameIter* maybeIter, HandleNativeObject debugger); - static MOZ_MUST_USE bool getCallee(JSContext* cx, HandleDebuggerFrame frame, + [[nodiscard]] static bool getCallee(JSContext* cx, HandleDebuggerFrame frame, MutableHandleDebuggerObject result); - static MOZ_MUST_USE bool getIsConstructing(JSContext* cx, HandleDebuggerFrame frame, + [[nodiscard]] static bool getIsConstructing(JSContext* cx, HandleDebuggerFrame frame, bool& result); - static MOZ_MUST_USE bool getEnvironment(JSContext* cx, HandleDebuggerFrame frame, + [[nodiscard]] static bool getEnvironment(JSContext* cx, HandleDebuggerFrame frame, MutableHandleDebuggerEnvironment result); static bool getIsGenerator(HandleDebuggerFrame frame); - static MOZ_MUST_USE bool getOffset(JSContext* cx, HandleDebuggerFrame frame, size_t& result); - static MOZ_MUST_USE bool getOlder(JSContext* cx, HandleDebuggerFrame frame, + [[nodiscard]] static bool getOffset(JSContext* cx, HandleDebuggerFrame frame, size_t& result); + [[nodiscard]] static bool getOlder(JSContext* cx, HandleDebuggerFrame frame, MutableHandleDebuggerFrame result); - static MOZ_MUST_USE bool getThis(JSContext* cx, HandleDebuggerFrame frame, + [[nodiscard]] static bool getThis(JSContext* cx, HandleDebuggerFrame frame, MutableHandleValue result); static DebuggerFrameType getType(HandleDebuggerFrame frame); static DebuggerFrameImplementation getImplementation(HandleDebuggerFrame frame); - static MOZ_MUST_USE bool eval(JSContext* cx, HandleDebuggerFrame frame, + [[nodiscard]] static bool eval(JSContext* cx, HandleDebuggerFrame frame, mozilla::Range<const char16_t> chars, HandleObject bindings, const EvalOptions& options, JSTrapStatus& status, MutableHandleValue value); @@ -1197,24 +1197,24 @@ class DebuggerFrame : public NativeObject static const JSFunctionSpec methods_[]; static AbstractFramePtr getReferent(HandleDebuggerFrame frame); - static MOZ_MUST_USE bool getScriptFrameIter(JSContext* cx, HandleDebuggerFrame frame, + [[nodiscard]] static bool getScriptFrameIter(JSContext* cx, HandleDebuggerFrame frame, mozilla::Maybe<ScriptFrameIter>& result); - 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 bool calleeGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool constructingGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool environmentGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool generatorGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool liveGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool offsetGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool olderGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool thisGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool typeGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool implementationGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool calleeGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool constructingGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool environmentGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool generatorGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool liveGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool offsetGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool olderGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool thisGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool typeGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool implementationGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool evalMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool evalWithBindingsMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool evalMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool evalWithBindingsMethod(JSContext* cx, unsigned argc, Value* vp); Debugger* owner() const; }; @@ -1229,75 +1229,75 @@ class DebuggerObject : public NativeObject HandleNativeObject debugger); // Properties - static MOZ_MUST_USE bool getClassName(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getClassName(JSContext* cx, HandleDebuggerObject object, MutableHandleString result); - static MOZ_MUST_USE bool getGlobal(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getGlobal(JSContext* cx, HandleDebuggerObject object, MutableHandleDebuggerObject result); - static MOZ_MUST_USE bool getParameterNames(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getParameterNames(JSContext* cx, HandleDebuggerObject object, MutableHandle<StringVector> result); - static MOZ_MUST_USE bool getBoundTargetFunction(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getBoundTargetFunction(JSContext* cx, HandleDebuggerObject object, MutableHandleDebuggerObject result); - static MOZ_MUST_USE bool getBoundThis(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getBoundThis(JSContext* cx, HandleDebuggerObject object, MutableHandleValue result); - static MOZ_MUST_USE bool getBoundArguments(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getBoundArguments(JSContext* cx, HandleDebuggerObject object, MutableHandle<ValueVector> result); - static MOZ_MUST_USE bool getAllocationSite(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getAllocationSite(JSContext* cx, HandleDebuggerObject object, MutableHandleObject result); - static MOZ_MUST_USE bool getErrorMessageName(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getErrorMessageName(JSContext* cx, HandleDebuggerObject object, MutableHandleString result); - static MOZ_MUST_USE bool getErrorNotes(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getErrorNotes(JSContext* cx, HandleDebuggerObject object, MutableHandleValue result); - static MOZ_MUST_USE bool getErrorLineNumber(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getErrorLineNumber(JSContext* cx, HandleDebuggerObject object, MutableHandleValue result); - static MOZ_MUST_USE bool getErrorColumnNumber(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getErrorColumnNumber(JSContext* cx, HandleDebuggerObject object, MutableHandleValue result); - static MOZ_MUST_USE bool getScriptedProxyTarget(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getScriptedProxyTarget(JSContext* cx, HandleDebuggerObject object, MutableHandleDebuggerObject result); - static MOZ_MUST_USE bool getScriptedProxyHandler(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getScriptedProxyHandler(JSContext* cx, HandleDebuggerObject object, MutableHandleDebuggerObject result); - static MOZ_MUST_USE bool getPromiseValue(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getPromiseValue(JSContext* cx, HandleDebuggerObject object, MutableHandleValue result); - static MOZ_MUST_USE bool getPromiseReason(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getPromiseReason(JSContext* cx, HandleDebuggerObject object, MutableHandleValue result); // Methods - static MOZ_MUST_USE bool isExtensible(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool isExtensible(JSContext* cx, HandleDebuggerObject object, bool& result); - static MOZ_MUST_USE bool isSealed(JSContext* cx, HandleDebuggerObject object, bool& result); - static MOZ_MUST_USE bool isFrozen(JSContext* cx, HandleDebuggerObject object, bool& result); - static MOZ_MUST_USE bool getPrototypeOf(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool isSealed(JSContext* cx, HandleDebuggerObject object, bool& result); + [[nodiscard]] static bool isFrozen(JSContext* cx, HandleDebuggerObject object, bool& result); + [[nodiscard]] static bool getPrototypeOf(JSContext* cx, HandleDebuggerObject object, MutableHandleDebuggerObject result); - static MOZ_MUST_USE bool getOwnPropertyNames(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getOwnPropertyNames(JSContext* cx, HandleDebuggerObject object, MutableHandle<IdVector> result); - static MOZ_MUST_USE bool getOwnPropertySymbols(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getOwnPropertySymbols(JSContext* cx, HandleDebuggerObject object, MutableHandle<IdVector> result); - static MOZ_MUST_USE bool getOwnPropertyDescriptor(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool getOwnPropertyDescriptor(JSContext* cx, HandleDebuggerObject object, HandleId id, MutableHandle<PropertyDescriptor> desc); - static MOZ_MUST_USE bool preventExtensions(JSContext* cx, HandleDebuggerObject object); - static MOZ_MUST_USE bool seal(JSContext* cx, HandleDebuggerObject object); - static MOZ_MUST_USE bool freeze(JSContext* cx, HandleDebuggerObject object); - static MOZ_MUST_USE bool defineProperty(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool preventExtensions(JSContext* cx, HandleDebuggerObject object); + [[nodiscard]] static bool seal(JSContext* cx, HandleDebuggerObject object); + [[nodiscard]] static bool freeze(JSContext* cx, HandleDebuggerObject object); + [[nodiscard]] static bool defineProperty(JSContext* cx, HandleDebuggerObject object, HandleId id, Handle<PropertyDescriptor> desc); - static MOZ_MUST_USE bool defineProperties(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool defineProperties(JSContext* cx, HandleDebuggerObject object, Handle<IdVector> ids, Handle<PropertyDescriptorVector> descs); - static MOZ_MUST_USE bool deleteProperty(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool deleteProperty(JSContext* cx, HandleDebuggerObject object, HandleId id, ObjectOpResult& result); - static MOZ_MUST_USE bool call(JSContext* cx, HandleDebuggerObject object, HandleValue thisv, + [[nodiscard]] static bool call(JSContext* cx, HandleDebuggerObject object, HandleValue thisv, Handle<ValueVector> args, MutableHandleValue result); - static MOZ_MUST_USE bool forceLexicalInitializationByName(JSContext* cx, + [[nodiscard]] static bool forceLexicalInitializationByName(JSContext* cx, HandleDebuggerObject object, HandleId id, bool& result); - static MOZ_MUST_USE bool executeInGlobal(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool executeInGlobal(JSContext* cx, HandleDebuggerObject object, mozilla::Range<const char16_t> chars, HandleObject bindings, const EvalOptions& options, JSTrapStatus& status, MutableHandleValue value); - static MOZ_MUST_USE bool makeDebuggeeValue(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool makeDebuggeeValue(JSContext* cx, HandleDebuggerObject object, HandleValue value, MutableHandleValue result); - static MOZ_MUST_USE bool unsafeDereference(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool unsafeDereference(JSContext* cx, HandleDebuggerObject object, MutableHandleObject result); - static MOZ_MUST_USE bool unwrap(JSContext* cx, HandleDebuggerObject object, + [[nodiscard]] static bool unwrap(JSContext* cx, HandleDebuggerObject object, MutableHandleDebuggerObject result); // Infallible properties @@ -1338,68 +1338,68 @@ class DebuggerObject : public NativeObject PromiseObject* promise() const; - static MOZ_MUST_USE bool requireGlobal(JSContext* cx, HandleDebuggerObject object); - static MOZ_MUST_USE bool requirePromise(JSContext* cx, HandleDebuggerObject object); + [[nodiscard]] static bool requireGlobal(JSContext* cx, HandleDebuggerObject object); + [[nodiscard]] static bool requirePromise(JSContext* cx, HandleDebuggerObject object); - static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool construct(JSContext* cx, unsigned argc, Value* vp); // JSNative properties - static MOZ_MUST_USE bool callableGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool isBoundFunctionGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool isArrowFunctionGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool protoGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool classGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool nameGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool displayNameGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool parameterNamesGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool scriptGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool environmentGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool boundTargetFunctionGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool boundThisGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool boundArgumentsGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool globalGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool allocationSiteGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool errorMessageNameGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool errorNotesGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool errorLineNumberGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool errorColumnNumberGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool isProxyGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool proxyTargetGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool proxyHandlerGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool isPromiseGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseStateGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseValueGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseReasonGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseLifetimeGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseTimeToResolutionGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseAllocationSiteGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseResolutionSiteGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseIDGetter(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool promiseDependentPromisesGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool callableGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool isBoundFunctionGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool isArrowFunctionGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool protoGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool classGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool nameGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool displayNameGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool parameterNamesGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool scriptGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool environmentGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool boundTargetFunctionGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool boundThisGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool boundArgumentsGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool globalGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool allocationSiteGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool errorMessageNameGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool errorNotesGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool errorLineNumberGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool errorColumnNumberGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool isProxyGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool proxyTargetGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool proxyHandlerGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool isPromiseGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseStateGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseValueGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseReasonGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseLifetimeGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseTimeToResolutionGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseAllocationSiteGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseResolutionSiteGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseIDGetter(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool promiseDependentPromisesGetter(JSContext* cx, unsigned argc, Value* vp); // JSNative methods - static MOZ_MUST_USE bool isExtensibleMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool isSealedMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool isFrozenMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool getOwnPropertyNamesMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool getOwnPropertySymbolsMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool getOwnPropertyDescriptorMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool preventExtensionsMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool sealMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool freezeMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool definePropertyMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool definePropertiesMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool deletePropertyMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool callMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool applyMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool asEnvironmentMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool forceLexicalInitializationByNameMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool executeInGlobalMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool executeInGlobalWithBindingsMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool makeDebuggeeValueMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool unsafeDereferenceMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool unwrapMethod(JSContext* cx, unsigned argc, Value* vp); - static MOZ_MUST_USE bool getErrorReport(JSContext* cx, HandleObject maybeError, + [[nodiscard]] static bool isExtensibleMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool isSealedMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool isFrozenMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool getOwnPropertyNamesMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool getOwnPropertySymbolsMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool getOwnPropertyDescriptorMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool preventExtensionsMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool sealMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool freezeMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool definePropertyMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool definePropertiesMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool deletePropertyMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool callMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool applyMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool asEnvironmentMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool forceLexicalInitializationByNameMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool executeInGlobalMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool executeInGlobalWithBindingsMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool makeDebuggeeValueMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool unsafeDereferenceMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool unwrapMethod(JSContext* cx, unsigned argc, Value* vp); + [[nodiscard]] static bool getErrorReport(JSContext* cx, HandleObject maybeError, JSErrorReport*& report); }; @@ -1557,7 +1557,7 @@ Debugger::onLogAllocationSite(JSContext* cx, JSObject* obj, HandleSavedFrame fra return Debugger::slowPathOnLogAllocationSite(cx, hobj, frame, when, *dbgs); } -MOZ_MUST_USE bool ReportObjectRequired(JSContext* cx); +[[nodiscard]] bool ReportObjectRequired(JSContext* cx); } /* namespace js */ diff --git a/js/src/vm/EnvironmentObject.h b/js/src/vm/EnvironmentObject.h index a74018047a..b38ba15a93 100644 --- a/js/src/vm/EnvironmentObject.h +++ b/js/src/vm/EnvironmentObject.h @@ -1083,35 +1083,35 @@ FindScriptOrModulePrivateForScript(JSScript* script); ModuleEnvironmentObject* GetModuleEnvironmentForScript(JSScript* script); -MOZ_MUST_USE bool +[[nodiscard]] bool GetThisValueForDebuggerMaybeOptimizedOut(JSContext* cx, AbstractFramePtr frame, jsbytecode* pc, MutableHandleValue res); -MOZ_MUST_USE bool +[[nodiscard]] bool CheckVarNameConflict(JSContext* cx, Handle<LexicalEnvironmentObject*> lexicalEnv, HandlePropertyName name); -MOZ_MUST_USE bool +[[nodiscard]] bool CheckCanDeclareGlobalBinding(JSContext* cx, Handle<GlobalObject*> global, HandlePropertyName name, bool isFunction); -MOZ_MUST_USE bool +[[nodiscard]] bool CheckLexicalNameConflict(JSContext* cx, Handle<LexicalEnvironmentObject*> lexicalEnv, HandleObject varObj, HandlePropertyName name); -MOZ_MUST_USE bool +[[nodiscard]] bool CheckGlobalDeclarationConflicts(JSContext* cx, HandleScript script, Handle<LexicalEnvironmentObject*> lexicalEnv, HandleObject varObj); -MOZ_MUST_USE bool +[[nodiscard]] bool CheckEvalDeclarationConflicts(JSContext* cx, HandleScript script, HandleObject envChain, HandleObject varObj); -MOZ_MUST_USE bool +[[nodiscard]] bool InitFunctionEnvironmentObjects(JSContext* cx, AbstractFramePtr frame); -MOZ_MUST_USE bool +[[nodiscard]] bool PushVarEnvironmentObject(JSContext* cx, HandleScope scope, AbstractFramePtr frame); #ifdef DEBUG diff --git a/js/src/vm/ErrorReporting.h b/js/src/vm/ErrorReporting.h index ed061e6428..96f3ef6f49 100644 --- a/js/src/vm/ErrorReporting.h +++ b/js/src/vm/ErrorReporting.h @@ -81,7 +81,7 @@ ReportCompileError(ErrorMetadata&& metadata, UniquePtr<JSErrorNotes> notes, * This function DOES NOT respect an existing werror option. If the caller * wishes such option to be respected, it must do so itself. */ -extern MOZ_MUST_USE bool +[[nodiscard]] extern bool ReportCompileWarning(JSContext* cx, ErrorMetadata&& metadata, UniquePtr<JSErrorNotes> notes, unsigned flags, unsigned errorNumber, va_list args); diff --git a/js/src/vm/GeneratorObject.cpp b/js/src/vm/GeneratorObject.cpp index f0718c0f86..4c789e1da8 100644 --- a/js/src/vm/GeneratorObject.cpp +++ b/js/src/vm/GeneratorObject.cpp @@ -371,7 +371,7 @@ GlobalObject::initStarGenerators(JSContext* cx, Handle<GlobalObject*> global) return true; } -MOZ_MUST_USE bool +[[nodiscard]] bool js::CheckStarGeneratorResumptionValue(JSContext* cx, HandleValue v) { // yield/return value should be an Object. diff --git a/js/src/vm/GeneratorObject.h b/js/src/vm/GeneratorObject.h index c717d25e66..d5d7e7dbc2 100644 --- a/js/src/vm/GeneratorObject.h +++ b/js/src/vm/GeneratorObject.h @@ -226,7 +226,7 @@ bool GeneratorThrowOrClose(JSContext* cx, AbstractFramePtr frame, Handle<Generat HandleValue val, uint32_t resumeKind); void SetReturnValueForClosingGenerator(JSContext* cx, AbstractFramePtr frame); -MOZ_MUST_USE bool +[[nodiscard]] bool CheckStarGeneratorResumptionValue(JSContext* cx, HandleValue v); } // namespace js diff --git a/js/src/vm/NativeObject.h b/js/src/vm/NativeObject.h index 86977d109f..56c9ba7f09 100644 --- a/js/src/vm/NativeObject.h +++ b/js/src/vm/NativeObject.h @@ -515,7 +515,7 @@ class NativeObject : public ShapedObject */ bool setSlotSpan(ExclusiveContext* cx, uint32_t span); - static MOZ_MUST_USE bool toDictionaryMode(ExclusiveContext* cx, HandleNativeObject obj); + [[nodiscard]] static bool toDictionaryMode(ExclusiveContext* cx, HandleNativeObject obj); private: friend class TenuringTracer; @@ -614,13 +614,13 @@ class NativeObject : public ShapedObject } public: - static MOZ_MUST_USE bool generateOwnShape(ExclusiveContext* cx, HandleNativeObject obj, + [[nodiscard]] static bool generateOwnShape(ExclusiveContext* cx, HandleNativeObject obj, Shape* newShape = nullptr) { return replaceWithNewEquivalentShape(cx, obj, obj->lastProperty(), newShape); } - static MOZ_MUST_USE bool shadowingShapeChange(ExclusiveContext* cx, HandleNativeObject obj, + [[nodiscard]] static bool shadowingShapeChange(ExclusiveContext* cx, HandleNativeObject obj, const Shape& shape); static bool clearFlag(ExclusiveContext* cx, HandleNativeObject obj, BaseShape::Flag flag); @@ -794,7 +794,7 @@ class NativeObject : public ShapedObject unsigned flags, ShapeTable::Entry* entry, bool allowDictionary, const AutoKeepShapeTables& keep); - static MOZ_MUST_USE bool fillInAfterSwap(JSContext* cx, HandleNativeObject obj, + [[nodiscard]] static bool fillInAfterSwap(JSContext* cx, HandleNativeObject obj, const Vector<Value>& values, void* priv); public: diff --git a/js/src/vm/Printer.h b/js/src/vm/Printer.h index 60f1a62716..9f96e6f16d 100644 --- a/js/src/vm/Printer.h +++ b/js/src/vm/Printer.h @@ -83,14 +83,14 @@ class Sprinter final : public GenericPrinter size_t size; // size of buffer allocated at base ptrdiff_t offset; // offset of next free char in buffer - MOZ_MUST_USE bool realloc_(size_t newSize); + [[nodiscard]] bool realloc_(size_t newSize); public: explicit Sprinter(ExclusiveContext* cx, bool shouldReportOOM = true); ~Sprinter(); // Initialize this sprinter, returns false on error. - MOZ_MUST_USE bool init(); + [[nodiscard]] bool init(); void checkInvariants() const; @@ -114,7 +114,7 @@ class Sprinter final : public GenericPrinter // Format the given format/arguments as if by JS_vsmprintf, then put it. // Return true on success, else return false and report an error (typically // OOM). - MOZ_MUST_USE bool jsprintf(const char* fmt, ...) MOZ_FORMAT_PRINTF(2, 3); + [[nodiscard]] bool jsprintf(const char* fmt, ...) MOZ_FORMAT_PRINTF(2, 3); // Prints a formatted string into the buffer. virtual int vprintf(const char* fmt, va_list ap) override; @@ -142,7 +142,7 @@ class Fprinter final : public GenericPrinter ~Fprinter(); // Initialize this printer, returns false on error. - MOZ_MUST_USE bool init(const char* path); + [[nodiscard]] bool init(const char* path); void init(FILE* fp); bool isInitialized() const { return file_ != nullptr; diff --git a/js/src/vm/RegExpObject.h b/js/src/vm/RegExpObject.h index 5247731112..a251511dd6 100644 --- a/js/src/vm/RegExpObject.h +++ b/js/src/vm/RegExpObject.h @@ -460,7 +460,7 @@ class RegExpObject : public NativeObject static bool isOriginalFlagGetter(JSNative native, RegExpFlag* mask); - static MOZ_MUST_USE bool getShared(JSContext* cx, Handle<RegExpObject*> regexp, + [[nodiscard]] static bool getShared(JSContext* cx, Handle<RegExpObject*> regexp, MutableHandleRegExpShared shared); bool hasShared() { @@ -483,7 +483,7 @@ class RegExpObject : public NativeObject void initAndZeroLastIndex(HandleAtom source, RegExpFlag flags, ExclusiveContext* cx); #ifdef DEBUG - static MOZ_MUST_USE bool dumpBytecode(JSContext* cx, Handle<RegExpObject*> regexp, + [[nodiscard]] static bool dumpBytecode(JSContext* cx, Handle<RegExpObject*> regexp, bool match_only, HandleLinearString input); #endif @@ -492,7 +492,7 @@ class RegExpObject : public NativeObject * Precondition: the syntax for |source| has already been validated. * Side effect: sets the private field. */ - static MOZ_MUST_USE bool createShared(JSContext* cx, Handle<RegExpObject*> regexp, + [[nodiscard]] static bool createShared(JSContext* cx, Handle<RegExpObject*> regexp, MutableHandleRegExpShared shared); PreBarriered<RegExpShared*>& sharedRef() { diff --git a/js/src/vm/SavedFrame.h b/js/src/vm/SavedFrame.h index 6995cbb359..2981b9e4a3 100644 --- a/js/src/vm/SavedFrame.h +++ b/js/src/vm/SavedFrame.h @@ -157,7 +157,7 @@ class SavedFrame : public NativeObject { private: static SavedFrame* create(JSContext* cx); - static MOZ_MUST_USE bool finishSavedFrameInit(JSContext* cx, HandleObject ctor, HandleObject proto); + [[nodiscard]] static bool finishSavedFrameInit(JSContext* cx, HandleObject ctor, HandleObject proto); void initFromLookup(HandleLookup lookup); void initSource(JSAtom* source); void initLine(uint32_t line); @@ -228,7 +228,7 @@ struct ReconstructedSavedFramePrincipals : public JSPrincipals this->refcount = 1; } - MOZ_MUST_USE bool write(JSContext* cx, JSStructuredCloneWriter* writer) override { + [[nodiscard]] bool write(JSContext* cx, JSStructuredCloneWriter* writer) override { MOZ_ASSERT(false, "ReconstructedSavedFramePrincipals should never be exposed to embedders"); return false; } @@ -311,8 +311,8 @@ class ConcreteStackFrame<SavedFrame> : public BaseStackFrame { bool isSystem() const override; - MOZ_MUST_USE bool constructSavedFrameStack(JSContext* cx, - MutableHandleObject outSavedFrameStack) + [[nodiscard]] bool constructSavedFrameStack(JSContext* cx, + MutableHandleObject outSavedFrameStack) const override; }; diff --git a/js/src/vm/SavedStacks.cpp b/js/src/vm/SavedStacks.cpp index 59b3e6bd14..10f147cf13 100644 --- a/js/src/vm/SavedStacks.cpp +++ b/js/src/vm/SavedStacks.cpp @@ -600,7 +600,7 @@ GetFirstSubsumedSavedFrame(JSContext* cx, HandleObject savedFrame, return GetFirstSubsumedFrame(cx, frame, selfHosted, skippedAsync); } -static MOZ_MUST_USE bool +[[nodiscard]] static bool SavedFrame_checkThis(JSContext* cx, CallArgs& args, const char* fnName, MutableHandleObject frame) { diff --git a/js/src/vm/SavedStacks.h b/js/src/vm/SavedStacks.h index 3ea6c40874..b757f7ebdd 100644 --- a/js/src/vm/SavedStacks.h +++ b/js/src/vm/SavedStacks.h @@ -161,11 +161,11 @@ class SavedStacks { creatingSavedFrame(false) { } - MOZ_MUST_USE bool init(); + [[nodiscard]] bool init(); bool initialized() const { return frames.initialized(); } - MOZ_MUST_USE bool saveCurrentStack(JSContext* cx, MutableHandleSavedFrame frame, + [[nodiscard]] bool saveCurrentStack(JSContext* cx, MutableHandleSavedFrame frame, JS::StackCapture&& capture = JS::StackCapture(JS::AllFrames())); - MOZ_MUST_USE bool copyAsyncStack(JSContext* cx, HandleObject asyncStack, + [[nodiscard]] bool copyAsyncStack(JSContext* cx, HandleObject asyncStack, HandleString asyncCause, MutableHandleSavedFrame adoptedStack, uint32_t maxFrameCount = 0); @@ -218,10 +218,10 @@ class SavedStacks { } }; - MOZ_MUST_USE bool insertFrames(JSContext* cx, FrameIter& iter, + [[nodiscard]] bool insertFrames(JSContext* cx, FrameIter& iter, MutableHandleSavedFrame frame, JS::StackCapture&& capture); - MOZ_MUST_USE bool adoptAsyncStack(JSContext* cx, HandleSavedFrame asyncStack, + [[nodiscard]] bool adoptAsyncStack(JSContext* cx, HandleSavedFrame asyncStack, HandleString asyncCause, MutableHandleSavedFrame adoptedStack, uint32_t maxFrameCount); @@ -291,7 +291,7 @@ class SavedStacks { using PCLocationMap = GCHashMap<PCKey, LocationValue, PCLocationHasher, SystemAllocPolicy>; PCLocationMap pcLocationMap; - MOZ_MUST_USE bool getLocation(JSContext* cx, const FrameIter& iter, + [[nodiscard]] bool getLocation(JSContext* cx, const FrameIter& iter, MutableHandle<LocationValue> locationp); }; diff --git a/js/src/vm/Shape.h b/js/src/vm/Shape.h index bb813997f0..b1f3476312 100644 --- a/js/src/vm/Shape.h +++ b/js/src/vm/Shape.h @@ -654,9 +654,9 @@ class Shape : public gc::TenuredCell static inline Shape* search(ExclusiveContext* cx, Shape* start, jsid id); template<MaybeAdding Adding = MaybeAdding::NotAdding> - static inline MOZ_MUST_USE bool search(ExclusiveContext* cx, Shape* start, jsid id, - const AutoKeepShapeTables&, - Shape** pshape, ShapeTable::Entry** pentry); + [[nodiscard]] static inline bool search(ExclusiveContext* cx, Shape* start, jsid id, + const AutoKeepShapeTables&, + Shape** pshape, ShapeTable::Entry** pentry); static inline Shape* searchNoHashify(Shape* start, jsid id); @@ -694,7 +694,7 @@ class Shape : public gc::TenuredCell bool makeOwnBaseShape(ExclusiveContext* cx); - MOZ_ALWAYS_INLINE MOZ_MUST_USE bool maybeCreateTableForLookup(ExclusiveContext* cx); + [[nodiscard]] MOZ_ALWAYS_INLINE bool maybeCreateTableForLookup(ExclusiveContext* cx); public: bool hasTable() const { return base()->hasTable(); } @@ -707,7 +707,7 @@ class Shape : public gc::TenuredCell } template <typename T> - MOZ_MUST_USE ShapeTable* ensureTableForDictionary(ExclusiveContext* cx, const T& nogc) { + [[nodiscard]] ShapeTable* ensureTableForDictionary(ExclusiveContext* cx, const T& nogc) { MOZ_ASSERT(inDictionary()); if (ShapeTable* table = maybeTable(nogc)) return table; diff --git a/js/src/vm/SharedImmutableStringsCache-inl.h b/js/src/vm/SharedImmutableStringsCache-inl.h index da05444d7e..6d46179f6b 100644 --- a/js/src/vm/SharedImmutableStringsCache-inl.h +++ b/js/src/vm/SharedImmutableStringsCache-inl.h @@ -11,7 +11,7 @@ namespace js { template <typename IntoOwnedChars> -MOZ_MUST_USE mozilla::Maybe<SharedImmutableString> +[[nodiscard]] mozilla::Maybe<SharedImmutableString> SharedImmutableStringsCache::getOrCreate(const char* chars, size_t length, IntoOwnedChars intoOwnedChars) { @@ -40,7 +40,7 @@ SharedImmutableStringsCache::getOrCreate(const char* chars, size_t length, } template <typename IntoOwnedTwoByteChars> -MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString> +[[nodiscard]] mozilla::Maybe<SharedImmutableTwoByteString> SharedImmutableStringsCache::getOrCreate(const char16_t* chars, size_t length, IntoOwnedTwoByteChars intoOwnedTwoByteChars) { MOZ_ASSERT(inner_); diff --git a/js/src/vm/SharedImmutableStringsCache.cpp b/js/src/vm/SharedImmutableStringsCache.cpp index 186fc4f490..8711fb9b41 100644 --- a/js/src/vm/SharedImmutableStringsCache.cpp +++ b/js/src/vm/SharedImmutableStringsCache.cpp @@ -91,7 +91,7 @@ SharedImmutableTwoByteString::clone() const return SharedImmutableTwoByteString(string_.clone()); } -MOZ_MUST_USE mozilla::Maybe<SharedImmutableString> +[[nodiscard]] mozilla::Maybe<SharedImmutableString> SharedImmutableStringsCache::getOrCreate(OwnedChars&& chars, size_t length) { OwnedChars owned(mozilla::Move(chars)); @@ -99,13 +99,13 @@ SharedImmutableStringsCache::getOrCreate(OwnedChars&& chars, size_t length) return getOrCreate(owned.get(), length, [&]() { return mozilla::Move(owned); }); } -MOZ_MUST_USE mozilla::Maybe<SharedImmutableString> +[[nodiscard]] mozilla::Maybe<SharedImmutableString> SharedImmutableStringsCache::getOrCreate(const char* chars, size_t length) { return getOrCreate(chars, length, [&]() { return DuplicateString(chars, length); }); } -MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString> +[[nodiscard]] mozilla::Maybe<SharedImmutableTwoByteString> SharedImmutableStringsCache::getOrCreate(OwnedTwoByteChars&& chars, size_t length) { OwnedTwoByteChars owned(mozilla::Move(chars)); @@ -113,7 +113,7 @@ SharedImmutableStringsCache::getOrCreate(OwnedTwoByteChars&& chars, size_t lengt return getOrCreate(owned.get(), length, [&]() { return mozilla::Move(owned); }); } -MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString> +[[nodiscard]] mozilla::Maybe<SharedImmutableTwoByteString> SharedImmutableStringsCache::getOrCreate(const char16_t* chars, size_t length) { return getOrCreate(chars, length, [&]() { return DuplicateString(chars, length); }); diff --git a/js/src/vm/SharedImmutableStringsCache.h b/js/src/vm/SharedImmutableStringsCache.h index bbde5f631e..b4bec63da6 100644 --- a/js/src/vm/SharedImmutableStringsCache.h +++ b/js/src/vm/SharedImmutableStringsCache.h @@ -65,7 +65,7 @@ class SharedImmutableStringsCache * returned. */ template <typename IntoOwnedChars> - MOZ_MUST_USE mozilla::Maybe<SharedImmutableString> + [[nodiscard]] mozilla::Maybe<SharedImmutableString> getOrCreate(const char* chars, size_t length, IntoOwnedChars intoOwnedChars); /** @@ -75,7 +75,7 @@ class SharedImmutableStringsCache * On success, `Some` is returned. In the case of OOM failure, `Nothing` is * returned. */ - MOZ_MUST_USE mozilla::Maybe<SharedImmutableString> + [[nodiscard]] mozilla::Maybe<SharedImmutableString> getOrCreate(OwnedChars&& chars, size_t length); /** @@ -86,7 +86,7 @@ class SharedImmutableStringsCache * On success, `Some` is returned. In the case of OOM failure, `Nothing` is * returned. */ - MOZ_MUST_USE mozilla::Maybe<SharedImmutableString> + [[nodiscard]] mozilla::Maybe<SharedImmutableString> getOrCreate(const char* chars, size_t length); /** @@ -108,7 +108,7 @@ class SharedImmutableStringsCache * returned. */ template <typename IntoOwnedTwoByteChars> - MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString> + [[nodiscard]] mozilla::Maybe<SharedImmutableTwoByteString> getOrCreate(const char16_t* chars, size_t length, IntoOwnedTwoByteChars intoOwnedTwoByteChars); /** @@ -118,7 +118,7 @@ class SharedImmutableStringsCache * On success, `Some` is returned. In the case of OOM failure, `Nothing` is * returned. */ - MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString> + [[nodiscard]] mozilla::Maybe<SharedImmutableTwoByteString> getOrCreate(OwnedTwoByteChars&& chars, size_t length); /** @@ -129,7 +129,7 @@ class SharedImmutableStringsCache * On success, `Some` is returned. In the case of OOM failure, `Nothing` is * returned. */ - MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString> + [[nodiscard]] mozilla::Maybe<SharedImmutableTwoByteString> getOrCreate(const char16_t* chars, size_t length); size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const { diff --git a/js/src/vm/StringBuffer.h b/js/src/vm/StringBuffer.h index 502a3bc6f6..3bda9fc72f 100644 --- a/js/src/vm/StringBuffer.h +++ b/js/src/vm/StringBuffer.h @@ -67,7 +67,7 @@ class StringBuffer return cb.ref<TwoByteCharBuffer>(); } - MOZ_MUST_USE bool inflateChars(); + [[nodiscard]] bool inflateChars(); public: explicit StringBuffer(ExclusiveContext* cx) @@ -92,12 +92,12 @@ class StringBuffer else twoByteChars().clear(); } - MOZ_MUST_USE bool reserve(size_t len) { + [[nodiscard]] bool reserve(size_t len) { if (len > reserved_) reserved_ = len; return isLatin1() ? latin1Chars().reserve(len) : twoByteChars().reserve(len); } - MOZ_MUST_USE bool resize(size_t len) { + [[nodiscard]] bool resize(size_t len) { return isLatin1() ? latin1Chars().resize(len) : twoByteChars().resize(len); } bool empty() const { @@ -110,7 +110,7 @@ class StringBuffer return isLatin1() ? latin1Chars()[idx] : twoByteChars()[idx]; } - MOZ_MUST_USE bool ensureTwoByteChars() { + [[nodiscard]] bool ensureTwoByteChars() { if (isLatin1() && !inflateChars()) return false; @@ -120,7 +120,7 @@ class StringBuffer return true; } - MOZ_MUST_USE bool append(const char16_t c) { + [[nodiscard]] bool append(const char16_t c) { if (isLatin1()) { if (c <= JSString::MAX_LATIN1_CHAR) return latin1Chars().append(Latin1Char(c)); @@ -129,10 +129,10 @@ class StringBuffer } return twoByteChars().append(c); } - MOZ_MUST_USE bool append(Latin1Char c) { + [[nodiscard]] bool append(Latin1Char c) { return isLatin1() ? latin1Chars().append(c) : twoByteChars().append(c); } - MOZ_MUST_USE bool append(char c) { + [[nodiscard]] bool append(char c) { return append(Latin1Char(c)); } @@ -141,37 +141,37 @@ class StringBuffer return twoByteChars(); } - inline MOZ_MUST_USE bool append(const char16_t* begin, const char16_t* end); + [[nodiscard]] inline bool append(const char16_t* begin, const char16_t* end); - MOZ_MUST_USE bool append(const char16_t* chars, size_t len) { + [[nodiscard]] bool append(const char16_t* chars, size_t len) { return append(chars, chars + len); } - MOZ_MUST_USE bool append(const Latin1Char* begin, const Latin1Char* end) { + [[nodiscard]] bool append(const Latin1Char* begin, const Latin1Char* end) { return isLatin1() ? latin1Chars().append(begin, end) : twoByteChars().append(begin, end); } - MOZ_MUST_USE bool append(const Latin1Char* chars, size_t len) { + [[nodiscard]] bool append(const Latin1Char* chars, size_t len) { return append(chars, chars + len); } - MOZ_MUST_USE bool append(const JS::ConstCharPtr chars, size_t len) { + [[nodiscard]] bool append(const JS::ConstCharPtr chars, size_t len) { return append(chars.get(), chars.get() + len); } - MOZ_MUST_USE bool appendN(Latin1Char c, size_t n) { + [[nodiscard]] bool appendN(Latin1Char c, size_t n) { return isLatin1() ? latin1Chars().appendN(c, n) : twoByteChars().appendN(c, n); } - inline MOZ_MUST_USE bool append(JSString* str); - inline MOZ_MUST_USE bool append(JSLinearString* str); - inline MOZ_MUST_USE bool appendSubstring(JSString* base, size_t off, size_t len); - inline MOZ_MUST_USE bool appendSubstring(JSLinearString* base, size_t off, size_t len); + [[nodiscard]] inline bool append(JSString* str); + [[nodiscard]] inline bool append(JSLinearString* str); + [[nodiscard]] inline bool appendSubstring(JSString* base, size_t off, size_t len); + [[nodiscard]] inline bool appendSubstring(JSLinearString* base, size_t off, size_t len); - MOZ_MUST_USE bool append(const char* chars, size_t len) { + [[nodiscard]] bool append(const char* chars, size_t len) { return append(reinterpret_cast<const Latin1Char*>(chars), len); } template <size_t ArrayLength> - MOZ_MUST_USE bool append(const char (&array)[ArrayLength]) { + [[nodiscard]] bool append(const char (&array)[ArrayLength]) { return append(array, ArrayLength - 1); /* No trailing '\0'. */ } diff --git a/js/src/vm/TypeInference.h b/js/src/vm/TypeInference.h index 58c606912c..b66509d1e8 100644 --- a/js/src/vm/TypeInference.h +++ b/js/src/vm/TypeInference.h @@ -843,14 +843,14 @@ public: DPAConstraintInfo(const DPAConstraintInfo&) = delete; void operator=(const DPAConstraintInfo&) = delete; - MOZ_MUST_USE bool addProtoConstraint(JSObject* proto, jsid id) { + [[nodiscard]] bool addProtoConstraint(JSObject* proto, jsid id) { return protoConstraints_.emplaceBack(proto, id); } - MOZ_MUST_USE bool addInliningConstraint(JSScript* caller, JSScript* callee) { + [[nodiscard]] bool addInliningConstraint(JSScript* caller, JSScript* callee) { return inliningConstraints_.emplaceBack(caller, callee); } - MOZ_MUST_USE bool finishConstraints(JSContext* cx, ObjectGroup* group); + [[nodiscard]] bool finishConstraints(JSContext* cx, ObjectGroup* group); }; bool diff --git a/js/src/vm/TypedArrayObject.h b/js/src/vm/TypedArrayObject.h index 8b4b0b5092..8ff820b916 100644 --- a/js/src/vm/TypedArrayObject.h +++ b/js/src/vm/TypedArrayObject.h @@ -316,7 +316,7 @@ class TypedArrayObject : public NativeObject bool convertForSideEffect(JSContext* cx, HandleValue v) const; }; -MOZ_MUST_USE bool TypedArray_bufferGetter(JSContext* cx, unsigned argc, Value* vp); +[[nodiscard]] bool TypedArray_bufferGetter(JSContext* cx, unsigned argc, Value* vp); extern TypedArrayObject* TypedArrayCreateWithTemplate(JSContext* cx, HandleObject templateObj, int32_t len); diff --git a/js/src/vm/Xdr.h b/js/src/vm/Xdr.h index 419b0dc86b..e21448e1e2 100644 --- a/js/src/vm/Xdr.h +++ b/js/src/vm/Xdr.h @@ -426,14 +426,14 @@ class XDRIncrementalEncoder : public XDREncoder AutoXDRTree::Key getTopLevelTreeKey() const override; AutoXDRTree::Key getTreeKey(JSFunction* fun) const override; - MOZ_MUST_USE bool init(); + [[nodiscard]] bool init(); void createOrReplaceSubTree(AutoXDRTree* child) override; void endSubTree() override; // Append the content collected during the incremental encoding into the // buffer given as argument. - MOZ_MUST_USE bool linearize(JS::TranscodeBuffer& buffer); + [[nodiscard]] bool linearize(JS::TranscodeBuffer& buffer); }; } /* namespace js */ |