Bug 1523969 part 13 - Move method definition inline comments to new line in 'js/'. r=jorendorff
authorRyan Hunt <rhunt@eqrion.net>
Mon, 25 Feb 2019 16:09:04 -0600
changeset 519776 f99b937e9e7ce91e7d648a37251d4af8d1d6da68
parent 519775 e16639cc628dd65afbae8bfa83b8da8bef6d8bb3
child 519777 e0fb4657355d4d8052bff3f1e8baac265b5efef7
push id10862
push userffxbld-merge
push dateMon, 11 Mar 2019 13:01:11 +0000
treeherdermozilla-beta@a2e7f5c935da [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjorendorff
bugs1523969
milestone67.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1523969 part 13 - Move method definition inline comments to new line in 'js/'. r=jorendorff Differential Revision: https://phabricator.services.mozilla.com/D21114
js/ipc/JavaScriptShared.cpp
js/src/builtin/AtomicsObject.cpp
js/src/builtin/DataViewObject.cpp
js/src/builtin/Eval.cpp
js/src/builtin/MapObject.cpp
js/src/builtin/ModuleObject.cpp
js/src/builtin/Promise.cpp
js/src/builtin/Stream.cpp
js/src/builtin/String.cpp
js/src/builtin/TypedObject.cpp
js/src/builtin/WeakMapObject.cpp
js/src/builtin/WeakSetObject.cpp
js/src/builtin/intl/IntlObject.cpp
js/src/ctypes/CTypes.cpp
js/src/frontend/BinSourceRuntimeSupport.cpp
js/src/frontend/EmitterScope.cpp
js/src/frontend/ParseNode.cpp
js/src/gc/Allocator.cpp
js/src/gc/GC.cpp
js/src/gc/Nursery.cpp
js/src/gc/RootMarking.cpp
js/src/gc/Statistics.cpp
js/src/jit/BaselineDebugModeOSR.cpp
js/src/jit/BaselineIC.cpp
js/src/jit/CompileWrappers.cpp
js/src/jit/ExecutableAllocator.cpp
js/src/jit/Ion.cpp
js/src/jit/IonIC.cpp
js/src/jit/JitcodeMap.cpp
js/src/jit/MIR.cpp
js/src/jit/OptimizationTracking.cpp
js/src/jit/RematerializedFrame.cpp
js/src/jit/VMFunctions.cpp
js/src/jit/arm/Assembler-arm.cpp
js/src/jit/arm/Simulator-arm.cpp
js/src/jit/arm64/Assembler-arm64.cpp
js/src/jit/mips32/Assembler-mips32.cpp
js/src/jit/mips32/Simulator-mips32.cpp
js/src/jit/mips64/Assembler-mips64.cpp
js/src/jit/mips64/Simulator-mips64.cpp
js/src/jit/x86-shared/Assembler-x86-shared.cpp
js/src/jsexn.cpp
js/src/proxy/Proxy.cpp
js/src/proxy/ScriptedProxyHandler.cpp
js/src/shell/OSObject.cpp
js/src/threading/Mutex.cpp
js/src/util/StructuredSpewer.cpp
js/src/vm/ArgumentsObject.cpp
js/src/vm/ArrayBufferObject.cpp
js/src/vm/ArrayBufferViewObject.cpp
js/src/vm/AsyncFunction.cpp
js/src/vm/AsyncIteration.cpp
js/src/vm/Compartment.cpp
js/src/vm/DateTime.cpp
js/src/vm/Debugger.cpp
js/src/vm/DebuggerMemory.cpp
js/src/vm/EnvironmentObject.cpp
js/src/vm/ErrorObject.cpp
js/src/vm/GeckoProfiler.cpp
js/src/vm/GeneratorObject.cpp
js/src/vm/GlobalObject.cpp
js/src/vm/Iteration.cpp
js/src/vm/JSFunction.cpp
js/src/vm/JSObject.cpp
js/src/vm/JSScript.cpp
js/src/vm/MemoryMetrics.cpp
js/src/vm/NativeObject.cpp
js/src/vm/ObjectGroup.cpp
js/src/vm/PIC.cpp
js/src/vm/ProxyObject.cpp
js/src/vm/RegExpObject.cpp
js/src/vm/Runtime.cpp
js/src/vm/SavedStacks.cpp
js/src/vm/Scope.cpp
js/src/vm/Shape.cpp
js/src/vm/SharedArrayObject.cpp
js/src/vm/StringType.cpp
js/src/vm/TypeInference.cpp
js/src/vm/TypedArrayObject.cpp
js/src/vm/UnboxedObject.cpp
js/src/wasm/WasmCode.cpp
js/src/wasm/WasmJS.cpp
js/src/wasm/WasmModule.cpp
js/src/wasm/WasmTable.cpp
js/src/wasm/WasmTypes.cpp
js/xpconnect/loader/ChromeScriptLoader.cpp
js/xpconnect/loader/ScriptPreloader.cpp
js/xpconnect/loader/mozJSComponentLoader.cpp
js/xpconnect/src/XPCJSContext.cpp
js/xpconnect/src/XPCJSRuntime.cpp
js/xpconnect/src/XPCWrappedNativeJSOps.cpp
js/xpconnect/wrappers/WrapperFactory.cpp
js/xpconnect/wrappers/XrayWrapper.cpp
--- a/js/ipc/JavaScriptShared.cpp
+++ b/js/ipc/JavaScriptShared.cpp
@@ -381,31 +381,33 @@ JS::Symbol* JavaScriptShared::fromSymbol
       return GetSymbolFor(cx, str);
     }
 
     default:
       return nullptr;
   }
 }
 
-/* static */ void JavaScriptShared::ConvertID(const nsID& from, JSIID* to) {
+/* static */
+void JavaScriptShared::ConvertID(const nsID& from, JSIID* to) {
   to->m0() = from.m0;
   to->m1() = from.m1;
   to->m2() = from.m2;
   to->m3_0() = from.m3[0];
   to->m3_1() = from.m3[1];
   to->m3_2() = from.m3[2];
   to->m3_3() = from.m3[3];
   to->m3_4() = from.m3[4];
   to->m3_5() = from.m3[5];
   to->m3_6() = from.m3[6];
   to->m3_7() = from.m3[7];
 }
 
-/* static */ void JavaScriptShared::ConvertID(const JSIID& from, nsID* to) {
+/* static */
+void JavaScriptShared::ConvertID(const JSIID& from, nsID* to) {
   to->m0 = from.m0();
   to->m1 = from.m1();
   to->m2 = from.m2();
   to->m3[0] = from.m3_0();
   to->m3[1] = from.m3_1();
   to->m3[2] = from.m3_2();
   to->m3[3] = from.m3_3();
   to->m3[4] = from.m3_4();
--- a/js/src/builtin/AtomicsObject.cpp
+++ b/js/src/builtin/AtomicsObject.cpp
@@ -772,42 +772,46 @@ bool js::atomics_notify(JSContext* cx, u
        sab->dataPointerShared().unwrap(/* arithmetic */));
 
   r.setNumber(
       double(atomics_notify_impl(sab->rawBufferObject(), byteOffset, count)));
 
   return true;
 }
 
-/* static */ bool js::FutexThread::initialize() {
+/* static */
+bool js::FutexThread::initialize() {
   MOZ_ASSERT(!lock_);
   lock_ = js_new<js::Mutex>(mutexid::FutexThread);
   return lock_ != nullptr;
 }
 
-/* static */ void js::FutexThread::destroy() {
+/* static */
+void js::FutexThread::destroy() {
   if (lock_) {
     js::Mutex* lock = lock_;
     js_delete(lock);
     lock_ = nullptr;
   }
 }
 
-/* static */ void js::FutexThread::lock() {
+/* static */
+void js::FutexThread::lock() {
   // Load the atomic pointer.
   js::Mutex* lock = lock_;
 
   lock->lock();
 }
 
 /* static */ mozilla::Atomic<js::Mutex*, mozilla::SequentiallyConsistent,
                              mozilla::recordreplay::Behavior::DontPreserve>
     FutexThread::lock_;
 
-/* static */ void js::FutexThread::unlock() {
+/* static */
+void js::FutexThread::unlock() {
   // Load the atomic pointer.
   js::Mutex* lock = lock_;
 
   lock->unlock();
 }
 
 js::FutexThread::FutexThread()
     : cond_(nullptr), state_(Idle), canWait_(false) {}
--- a/js/src/builtin/DataViewObject.cpp
+++ b/js/src/builtin/DataViewObject.cpp
@@ -242,19 +242,21 @@ bool DataViewObject::construct(JSContext
 
   if (bufobj->is<WrapperObject>()) {
     return constructWrapped(cx, bufobj, args);
   }
   return constructSameCompartment(cx, bufobj, args);
 }
 
 template <typename NativeType>
-/* static */ SharedMem<uint8_t*> DataViewObject::getDataPointer(
-    JSContext* cx, Handle<DataViewObject*> obj, uint64_t offset,
-    bool* isSharedMemory) {
+/* static */
+SharedMem<uint8_t*> DataViewObject::getDataPointer(JSContext* cx,
+                                                   Handle<DataViewObject*> obj,
+                                                   uint64_t offset,
+                                                   bool* isSharedMemory) {
   const size_t TypeSize = sizeof(NativeType);
   if (offset > UINT32_MAX - TypeSize || offset + TypeSize > obj->byteLength()) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_OFFSET_OUT_OF_DATAVIEW);
     return SharedMem<uint8_t*>::unshared(nullptr);
   }
 
   MOZ_ASSERT(offset < UINT32_MAX);
@@ -369,19 +371,19 @@ struct DataViewIO {
     if (wantSwap) {
       temp = swapBytes(temp);
     }
     Memcpy(unalignedBuffer, (uint8_t*)&temp, sizeof(ReadWriteType));
   }
 };
 
 template <typename NativeType>
-/* static */ bool DataViewObject::read(JSContext* cx,
-                                       Handle<DataViewObject*> obj,
-                                       const CallArgs& args, NativeType* val) {
+/* static */
+bool DataViewObject::read(JSContext* cx, Handle<DataViewObject*> obj,
+                          const CallArgs& args, NativeType* val) {
   // Steps 1-2. done by the caller
   // Step 3. unnecessary assert
 
   // Step 4.
   uint64_t getIndex;
   if (!ToIndex(cx, args.get(0), &getIndex)) {
     return false;
   }
@@ -471,19 +473,19 @@ inline bool WebIDLCast<float>(JSContext*
 template <>
 inline bool WebIDLCast<double>(JSContext* cx, HandleValue value, double* out) {
   return ToNumber(cx, value, out);
 }
 
 // https://tc39.github.io/ecma262/#sec-setviewvalue
 // SetViewValue ( view, requestIndex, isLittleEndian, type, value )
 template <typename NativeType>
-/* static */ bool DataViewObject::write(JSContext* cx,
-                                        Handle<DataViewObject*> obj,
-                                        const CallArgs& args) {
+/* static */
+bool DataViewObject::write(JSContext* cx, Handle<DataViewObject*> obj,
+                           const CallArgs& args) {
   // Steps 1-2. done by the caller
   // Step 3. unnecessary assert
 
   // Step 4.
   uint64_t getIndex;
   if (!ToIndex(cx, args.get(0), &getIndex)) {
     return false;
   }
--- a/js/src/builtin/Eval.cpp
+++ b/js/src/builtin/Eval.cpp
@@ -44,26 +44,28 @@ static void AssertInnerizedEnvironmentCh
 
 static bool IsEvalCacheCandidate(JSScript* script) {
   // Make sure there are no inner objects which might use the wrong parent
   // and/or call scope by reusing the previous eval's script.
   return script->isDirectEvalInFunction() && !script->hasSingletons() &&
          !script->hasObjects();
 }
 
-/* static */ HashNumber EvalCacheHashPolicy::hash(const EvalCacheLookup& l) {
+/* static */
+HashNumber EvalCacheHashPolicy::hash(const EvalCacheLookup& l) {
   AutoCheckCannotGC nogc;
   uint32_t hash = l.str->hasLatin1Chars()
                       ? HashString(l.str->latin1Chars(nogc), l.str->length())
                       : HashString(l.str->twoByteChars(nogc), l.str->length());
   return AddToHash(hash, l.callerScript.get(), l.pc);
 }
 
-/* static */ bool EvalCacheHashPolicy::match(const EvalCacheEntry& cacheEntry,
-                                             const EvalCacheLookup& l) {
+/* static */
+bool EvalCacheHashPolicy::match(const EvalCacheEntry& cacheEntry,
+                                const EvalCacheLookup& l) {
   MOZ_ASSERT(IsEvalCacheCandidate(cacheEntry.script));
 
   return EqualStrings(cacheEntry.str, l.str) &&
          cacheEntry.callerScript == l.callerScript && cacheEntry.pc == l.pc;
 }
 
 // Add the script to the eval cache when EvalKernel is finished
 class EvalScriptGuard {
--- a/js/src/builtin/MapObject.cpp
+++ b/js/src/builtin/MapObject.cpp
@@ -160,18 +160,19 @@ static inline ValueMap::Range* MapIterat
 
 inline MapObject::IteratorKind MapIteratorObject::kind() const {
   int32_t i = getSlot(KindSlot).toInt32();
   MOZ_ASSERT(i == MapObject::Keys || i == MapObject::Values ||
              i == MapObject::Entries);
   return MapObject::IteratorKind(i);
 }
 
-/* static */ bool GlobalObject::initMapIteratorProto(
-    JSContext* cx, Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initMapIteratorProto(JSContext* cx,
+                                        Handle<GlobalObject*> global) {
   Rooted<JSObject*> base(
       cx, GlobalObject::getOrCreateIteratorPrototype(cx, global));
   if (!base) {
     return false;
   }
   RootedPlainObject proto(cx, NewObjectWithGivenProto<PlainObject>(cx, base));
   if (!proto) {
     return false;
@@ -337,17 +338,18 @@ bool MapIteratorObject::next(Handle<MapI
       resultPairObj->setDenseElementWithType(cx, 1, range->front().value);
       break;
     }
   }
   range->popFront();
   return false;
 }
 
-/* static */ JSObject* MapIteratorObject::createResultPair(JSContext* cx) {
+/* static */
+JSObject* MapIteratorObject::createResultPair(JSContext* cx) {
   RootedArrayObject resultPairObj(
       cx, NewDenseFullyAllocatedArray(cx, 2, nullptr, TenuredObject));
   if (!resultPairObj) {
     return nullptr;
   }
 
   Rooted<TaggedProto> proto(cx, resultPairObj->taggedProto());
   ObjectGroup* group = ObjectGroupRealm::makeGroup(
@@ -621,17 +623,18 @@ MapObject* MapObject::create(JSContext* 
 
 void MapObject::finalize(FreeOp* fop, JSObject* obj) {
   MOZ_ASSERT(fop->onMainThread());
   if (ValueMap* map = obj->as<MapObject>().getData()) {
     fop->delete_(map);
   }
 }
 
-/* static */ void MapObject::sweepAfterMinorGC(FreeOp* fop, MapObject* mapobj) {
+/* static */
+void MapObject::sweepAfterMinorGC(FreeOp* fop, MapObject* mapobj) {
   if (IsInsideNursery(mapobj) && !IsForwarded(mapobj)) {
     finalize(fop, mapobj);
     return;
   }
 
   mapobj = MaybeForwarded(mapobj);
   mapobj->getData()->destroyNurseryRanges();
   SetHasNurseryMemory(mapobj, false);
@@ -930,18 +933,19 @@ static inline ValueSet::Range* SetIterat
 }
 
 inline SetObject::IteratorKind SetIteratorObject::kind() const {
   int32_t i = getSlot(KindSlot).toInt32();
   MOZ_ASSERT(i == SetObject::Values || i == SetObject::Entries);
   return SetObject::IteratorKind(i);
 }
 
-/* static */ bool GlobalObject::initSetIteratorProto(
-    JSContext* cx, Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initSetIteratorProto(JSContext* cx,
+                                        Handle<GlobalObject*> global) {
   Rooted<JSObject*> base(
       cx, GlobalObject::getOrCreateIteratorPrototype(cx, global));
   if (!base) {
     return false;
   }
   RootedPlainObject proto(cx, NewObjectWithGivenProto<PlainObject>(cx, base));
   if (!proto) {
     return false;
@@ -1077,17 +1081,18 @@ bool SetIteratorObject::next(Handle<SetI
     return true;
   }
 
   resultObj->setDenseElementWithType(cx, 0, range->front().get());
   range->popFront();
   return false;
 }
 
-/* static */ JSObject* SetIteratorObject::createResult(JSContext* cx) {
+/* static */
+JSObject* SetIteratorObject::createResult(JSContext* cx) {
   RootedArrayObject resultObj(
       cx, NewDenseFullyAllocatedArray(cx, 1, nullptr, TenuredObject));
   if (!resultObj) {
     return nullptr;
   }
 
   Rooted<TaggedProto> proto(cx, resultObj->taggedProto());
   ObjectGroup* group = ObjectGroupRealm::makeGroup(
@@ -1236,17 +1241,18 @@ void SetObject::trace(JSTracer* trc, JSO
 void SetObject::finalize(FreeOp* fop, JSObject* obj) {
   MOZ_ASSERT(fop->onMainThread());
   SetObject* setobj = static_cast<SetObject*>(obj);
   if (ValueSet* set = setobj->getData()) {
     fop->delete_(set);
   }
 }
 
-/* static */ void SetObject::sweepAfterMinorGC(FreeOp* fop, SetObject* setobj) {
+/* static */
+void SetObject::sweepAfterMinorGC(FreeOp* fop, SetObject* setobj) {
   if (IsInsideNursery(setobj) && !IsForwarded(setobj)) {
     finalize(fop, setobj);
     return;
   }
 
   setobj = MaybeForwarded(setobj);
   setobj->getData()->destroyNurseryRanges();
   SetHasNurseryMemory(setobj, false);
--- a/js/src/builtin/ModuleObject.cpp
+++ b/js/src/builtin/ModuleObject.cpp
@@ -89,22 +89,24 @@ DEFINE_GETTER_FUNCTIONS(ImportEntryObjec
 DEFINE_GETTER_FUNCTIONS(ImportEntryObject, columnNumber, ColumnNumberSlot)
 
 DEFINE_ATOM_ACCESSOR_METHOD(ImportEntryObject, moduleRequest)
 DEFINE_ATOM_ACCESSOR_METHOD(ImportEntryObject, importName)
 DEFINE_ATOM_ACCESSOR_METHOD(ImportEntryObject, localName)
 DEFINE_UINT32_ACCESSOR_METHOD(ImportEntryObject, lineNumber)
 DEFINE_UINT32_ACCESSOR_METHOD(ImportEntryObject, columnNumber)
 
-/* static */ bool ImportEntryObject::isInstance(HandleValue value) {
+/* static */
+bool ImportEntryObject::isInstance(HandleValue value) {
   return value.isObject() && value.toObject().is<ImportEntryObject>();
 }
 
-/* static */ bool GlobalObject::initImportEntryProto(
-    JSContext* cx, Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initImportEntryProto(JSContext* cx,
+                                        Handle<GlobalObject*> global) {
   static const JSPropertySpec protoAccessors[] = {
       JS_PSG("moduleRequest", ImportEntryObject_moduleRequestGetter, 0),
       JS_PSG("importName", ImportEntryObject_importNameGetter, 0),
       JS_PSG("localName", ImportEntryObject_localNameGetter, 0),
       JS_PSG("lineNumber", ImportEntryObject_lineNumberGetter, 0),
       JS_PSG("columnNumber", ImportEntryObject_columnNumberGetter, 0),
       JS_PS_END};
 
@@ -117,17 +119,18 @@ DEFINE_UINT32_ACCESSOR_METHOD(ImportEntr
   if (!DefinePropertiesAndFunctions(cx, proto, protoAccessors, nullptr)) {
     return false;
   }
 
   global->initReservedSlot(IMPORT_ENTRY_PROTO, ObjectValue(*proto));
   return true;
 }
 
-/* static */ ImportEntryObject* ImportEntryObject::create(
+/* static */
+ImportEntryObject* ImportEntryObject::create(
     JSContext* cx, HandleAtom moduleRequest, HandleAtom importName,
     HandleAtom localName, uint32_t lineNumber, uint32_t columnNumber) {
   RootedObject proto(
       cx, GlobalObject::getOrCreateImportEntryPrototype(cx, cx->global()));
   if (!proto) {
     return nullptr;
   }
 
@@ -160,22 +163,24 @@ DEFINE_GETTER_FUNCTIONS(ExportEntryObjec
 
 DEFINE_ATOM_OR_NULL_ACCESSOR_METHOD(ExportEntryObject, exportName)
 DEFINE_ATOM_OR_NULL_ACCESSOR_METHOD(ExportEntryObject, moduleRequest)
 DEFINE_ATOM_OR_NULL_ACCESSOR_METHOD(ExportEntryObject, importName)
 DEFINE_ATOM_OR_NULL_ACCESSOR_METHOD(ExportEntryObject, localName)
 DEFINE_UINT32_ACCESSOR_METHOD(ExportEntryObject, lineNumber)
 DEFINE_UINT32_ACCESSOR_METHOD(ExportEntryObject, columnNumber)
 
-/* static */ bool ExportEntryObject::isInstance(HandleValue value) {
+/* static */
+bool ExportEntryObject::isInstance(HandleValue value) {
   return value.isObject() && value.toObject().is<ExportEntryObject>();
 }
 
-/* static */ bool GlobalObject::initExportEntryProto(
-    JSContext* cx, Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initExportEntryProto(JSContext* cx,
+                                        Handle<GlobalObject*> global) {
   static const JSPropertySpec protoAccessors[] = {
       JS_PSG("exportName", ExportEntryObject_exportNameGetter, 0),
       JS_PSG("moduleRequest", ExportEntryObject_moduleRequestGetter, 0),
       JS_PSG("importName", ExportEntryObject_importNameGetter, 0),
       JS_PSG("localName", ExportEntryObject_localNameGetter, 0),
       JS_PSG("lineNumber", ExportEntryObject_lineNumberGetter, 0),
       JS_PSG("columnNumber", ExportEntryObject_columnNumberGetter, 0),
       JS_PS_END};
@@ -193,17 +198,18 @@ DEFINE_UINT32_ACCESSOR_METHOD(ExportEntr
   global->initReservedSlot(EXPORT_ENTRY_PROTO, ObjectValue(*proto));
   return true;
 }
 
 static Value StringOrNullValue(JSString* maybeString) {
   return maybeString ? StringValue(maybeString) : NullValue();
 }
 
-/* static */ ExportEntryObject* ExportEntryObject::create(
+/* static */
+ExportEntryObject* ExportEntryObject::create(
     JSContext* cx, HandleAtom maybeExportName, HandleAtom maybeModuleRequest,
     HandleAtom maybeImportName, HandleAtom maybeLocalName, uint32_t lineNumber,
     uint32_t columnNumber) {
   // Line and column numbers are optional for export entries since direct
   // entries are checked at parse time.
 
   RootedObject proto(
       cx, GlobalObject::getOrCreateExportEntryPrototype(cx, cx->global()));
@@ -238,22 +244,24 @@ DEFINE_GETTER_FUNCTIONS(RequestedModuleO
                         ModuleSpecifierSlot)
 DEFINE_GETTER_FUNCTIONS(RequestedModuleObject, lineNumber, LineNumberSlot)
 DEFINE_GETTER_FUNCTIONS(RequestedModuleObject, columnNumber, ColumnNumberSlot)
 
 DEFINE_ATOM_ACCESSOR_METHOD(RequestedModuleObject, moduleSpecifier)
 DEFINE_UINT32_ACCESSOR_METHOD(RequestedModuleObject, lineNumber)
 DEFINE_UINT32_ACCESSOR_METHOD(RequestedModuleObject, columnNumber)
 
-/* static */ bool RequestedModuleObject::isInstance(HandleValue value) {
+/* static */
+bool RequestedModuleObject::isInstance(HandleValue value) {
   return value.isObject() && value.toObject().is<RequestedModuleObject>();
 }
 
-/* static */ bool GlobalObject::initRequestedModuleProto(
-    JSContext* cx, Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initRequestedModuleProto(JSContext* cx,
+                                            Handle<GlobalObject*> global) {
   static const JSPropertySpec protoAccessors[] = {
       JS_PSG("moduleSpecifier", RequestedModuleObject_moduleSpecifierGetter, 0),
       JS_PSG("lineNumber", RequestedModuleObject_lineNumberGetter, 0),
       JS_PSG("columnNumber", RequestedModuleObject_columnNumberGetter, 0),
       JS_PS_END};
 
   RootedObject proto(
       cx, GlobalObject::createBlankPrototype<PlainObject>(cx, global));
@@ -264,19 +272,21 @@ DEFINE_UINT32_ACCESSOR_METHOD(RequestedM
   if (!DefinePropertiesAndFunctions(cx, proto, protoAccessors, nullptr)) {
     return false;
   }
 
   global->initReservedSlot(REQUESTED_MODULE_PROTO, ObjectValue(*proto));
   return true;
 }
 
-/* static */ RequestedModuleObject* RequestedModuleObject::create(
-    JSContext* cx, HandleAtom moduleSpecifier, uint32_t lineNumber,
-    uint32_t columnNumber) {
+/* static */
+RequestedModuleObject* RequestedModuleObject::create(JSContext* cx,
+                                                     HandleAtom moduleSpecifier,
+                                                     uint32_t lineNumber,
+                                                     uint32_t columnNumber) {
   RootedObject proto(
       cx, GlobalObject::getOrCreateRequestedModulePrototype(cx, cx->global()));
   if (!proto) {
     return nullptr;
   }
 
   RequestedModuleObject* self =
       NewObjectWithGivenProto<RequestedModuleObject>(cx, proto);
@@ -352,24 +362,26 @@ bool IndirectBindingMap::lookup(jsid nam
   *envOut = binding.environment;
   *shapeOut = binding.shape;
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // ModuleNamespaceObject
 
-/* static */ const ModuleNamespaceObject::ProxyHandler
-    ModuleNamespaceObject::proxyHandler;
+/* static */
+const ModuleNamespaceObject::ProxyHandler ModuleNamespaceObject::proxyHandler;
 
-/* static */ bool ModuleNamespaceObject::isInstance(HandleValue value) {
+/* static */
+bool ModuleNamespaceObject::isInstance(HandleValue value) {
   return value.isObject() && value.toObject().is<ModuleNamespaceObject>();
 }
 
-/* static */ ModuleNamespaceObject* ModuleNamespaceObject::create(
+/* static */
+ModuleNamespaceObject* ModuleNamespaceObject::create(
     JSContext* cx, HandleModuleObject module, HandleObject exports,
     UniquePtr<IndirectBindingMap> bindings) {
   RootedValue priv(cx, ObjectValue(*module));
   ProxyOptions options;
   options.setLazyProto(true);
   options.setSingleton(true);
   Rooted<UniquePtr<IndirectBindingMap>> rootedBindings(cx, std::move(bindings));
   RootedObject object(
@@ -703,21 +715,23 @@ DEFINE_ARRAY_SLOT_ACCESSOR(ModuleObject,
 DEFINE_ARRAY_SLOT_ACCESSOR(ModuleObject, importEntries, ImportEntriesSlot)
 DEFINE_ARRAY_SLOT_ACCESSOR(ModuleObject, localExportEntries,
                            LocalExportEntriesSlot)
 DEFINE_ARRAY_SLOT_ACCESSOR(ModuleObject, indirectExportEntries,
                            IndirectExportEntriesSlot)
 DEFINE_ARRAY_SLOT_ACCESSOR(ModuleObject, starExportEntries,
                            StarExportEntriesSlot)
 
-/* static */ bool ModuleObject::isInstance(HandleValue value) {
+/* static */
+bool ModuleObject::isInstance(HandleValue value) {
   return value.isObject() && value.toObject().is<ModuleObject>();
 }
 
-/* static */ ModuleObject* ModuleObject::create(JSContext* cx) {
+/* static */
+ModuleObject* ModuleObject::create(JSContext* cx) {
   RootedObject proto(
       cx, GlobalObject::getOrCreateModulePrototype(cx, cx->global()));
   if (!proto) {
     return nullptr;
   }
 
   RootedModuleObject self(cx, NewObjectWithGivenProto<ModuleObject>(cx, proto));
   if (!self) {
@@ -736,17 +750,18 @@ DEFINE_ARRAY_SLOT_ACCESSOR(ModuleObject,
   if (!funDecls) {
     return nullptr;
   }
 
   self->initReservedSlot(FunctionDeclarationsSlot, PrivateValue(funDecls));
   return self;
 }
 
-/* static */ void ModuleObject::finalize(js::FreeOp* fop, JSObject* obj) {
+/* static */
+void ModuleObject::finalize(js::FreeOp* fop, JSObject* obj) {
   MOZ_ASSERT(fop->maybeOnHelperThread());
   ModuleObject* self = &obj->as<ModuleObject>();
   if (self->hasImportBindings()) {
     fop->delete_(&self->importBindings());
   }
   if (FunctionDeclarationVector* funDecls = self->functionDeclarations()) {
     fop->delete_(funDecls);
   }
@@ -831,17 +846,18 @@ void ModuleObject::initImportExportData(
 }
 
 static bool FreezeObjectProperty(JSContext* cx, HandleNativeObject obj,
                                  uint32_t slot) {
   RootedObject property(cx, &obj->getSlot(slot).toObject());
   return FreezeObject(cx, property);
 }
 
-/* static */ bool ModuleObject::Freeze(JSContext* cx, HandleModuleObject self) {
+/* static */
+bool ModuleObject::Freeze(JSContext* cx, HandleModuleObject self) {
   return FreezeObjectProperty(cx, self, RequestedModulesSlot) &&
          FreezeObjectProperty(cx, self, ImportEntriesSlot) &&
          FreezeObjectProperty(cx, self, LocalExportEntriesSlot) &&
          FreezeObjectProperty(cx, self, IndirectExportEntriesSlot) &&
          FreezeObjectProperty(cx, self, StarExportEntriesSlot) &&
          FreezeObject(cx, self);
 }
 
@@ -944,17 +960,18 @@ void ModuleObject::setMetaObject(JSObjec
   MOZ_ASSERT(!metaObject());
   setReservedSlot(MetaObjectSlot, ObjectValue(*obj));
 }
 
 Scope* ModuleObject::enclosingScope() const {
   return script()->enclosingScope();
 }
 
-/* static */ void ModuleObject::trace(JSTracer* trc, JSObject* obj) {
+/* static */
+void ModuleObject::trace(JSTracer* trc, JSObject* obj) {
   ModuleObject& module = obj->as<ModuleObject>();
 
   if (module.hasImportBindings()) {
     module.importBindings().trace(trc);
   }
 
   if (FunctionDeclarationVector* funDecls = module.functionDeclarations()) {
     funDecls->trace(trc);
@@ -967,18 +984,19 @@ bool ModuleObject::noteFunctionDeclarati
   if (!funDecls->emplaceBack(name, fun)) {
     ReportOutOfMemory(cx);
     return false;
   }
 
   return true;
 }
 
-/* static */ bool ModuleObject::instantiateFunctionDeclarations(
-    JSContext* cx, HandleModuleObject self) {
+/* static */
+bool ModuleObject::instantiateFunctionDeclarations(JSContext* cx,
+                                                   HandleModuleObject self) {
 #ifdef DEBUG
   MOZ_ASSERT(self->status() == MODULE_STATUS_INSTANTIATING);
   if (!AssertFrozen(cx, self)) {
     return false;
   }
 #endif
 
   FunctionDeclarationVector* funDecls = self->functionDeclarations();
@@ -1006,18 +1024,19 @@ bool ModuleObject::noteFunctionDeclarati
     }
   }
 
   js_delete(funDecls);
   self->setReservedSlot(FunctionDeclarationsSlot, UndefinedValue());
   return true;
 }
 
-/* static */ bool ModuleObject::execute(JSContext* cx, HandleModuleObject self,
-                                        MutableHandleValue rval) {
+/* static */
+bool ModuleObject::execute(JSContext* cx, HandleModuleObject self,
+                           MutableHandleValue rval) {
 #ifdef DEBUG
   MOZ_ASSERT(self->status() == MODULE_STATUS_EVALUATING);
   if (!AssertFrozen(cx, self)) {
     return false;
   }
 #endif
 
   RootedScript script(cx, self->script());
@@ -1031,18 +1050,20 @@ bool ModuleObject::noteFunctionDeclarati
     JS_ReportErrorASCII(cx,
                         "Module declarations have not yet been instantiated");
     return false;
   }
 
   return Execute(cx, script, *scope, rval.address());
 }
 
-/* static */ ModuleNamespaceObject* ModuleObject::createNamespace(
-    JSContext* cx, HandleModuleObject self, HandleObject exports) {
+/* static */
+ModuleNamespaceObject* ModuleObject::createNamespace(JSContext* cx,
+                                                     HandleModuleObject self,
+                                                     HandleObject exports) {
   MOZ_ASSERT(!self->namespace_());
   MOZ_ASSERT(exports->is<ArrayObject>());
 
   auto bindings = cx->make_unique<IndirectBindingMap>();
   if (!bindings) {
     return nullptr;
   }
 
@@ -1060,27 +1081,28 @@ static bool InvokeSelfHostedMethod(JSCon
                                    HandlePropertyName name) {
   RootedValue thisv(cx, ObjectValue(*self));
   FixedInvokeArgs<0> args(cx);
 
   RootedValue ignored(cx);
   return CallSelfHostedFunction(cx, name, thisv, args, &ignored);
 }
 
-/* static */ bool ModuleObject::Instantiate(JSContext* cx,
-                                            HandleModuleObject self) {
+/* static */
+bool ModuleObject::Instantiate(JSContext* cx, HandleModuleObject self) {
   return InvokeSelfHostedMethod(cx, self, cx->names().ModuleInstantiate);
 }
 
-/* static */ bool ModuleObject::Evaluate(JSContext* cx,
-                                         HandleModuleObject self) {
+/* static */
+bool ModuleObject::Evaluate(JSContext* cx, HandleModuleObject self) {
   return InvokeSelfHostedMethod(cx, self, cx->names().ModuleEvaluate);
 }
 
-/* static */ ModuleNamespaceObject* ModuleObject::GetOrCreateModuleNamespace(
+/* static */
+ModuleNamespaceObject* ModuleObject::GetOrCreateModuleNamespace(
     JSContext* cx, HandleModuleObject self) {
   FixedInvokeArgs<1> args(cx);
   args[0].setObject(*self);
 
   RootedValue result(cx);
   if (!CallSelfHostedFunction(cx, cx->names().GetModuleNamespace,
                               UndefinedHandleValue, args, &result)) {
     return nullptr;
@@ -1097,18 +1119,19 @@ DEFINE_GETTER_FUNCTIONS(ModuleObject, im
 DEFINE_GETTER_FUNCTIONS(ModuleObject, localExportEntries,
                         LocalExportEntriesSlot)
 DEFINE_GETTER_FUNCTIONS(ModuleObject, indirectExportEntries,
                         IndirectExportEntriesSlot)
 DEFINE_GETTER_FUNCTIONS(ModuleObject, starExportEntries, StarExportEntriesSlot)
 DEFINE_GETTER_FUNCTIONS(ModuleObject, dfsIndex, DFSIndexSlot)
 DEFINE_GETTER_FUNCTIONS(ModuleObject, dfsAncestorIndex, DFSAncestorIndexSlot)
 
-/* static */ bool GlobalObject::initModuleProto(JSContext* cx,
-                                                Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initModuleProto(JSContext* cx,
+                                   Handle<GlobalObject*> global) {
   static const JSPropertySpec protoAccessors[] = {
       JS_PSG("namespace", ModuleObject_namespace_Getter, 0),
       JS_PSG("status", ModuleObject_statusGetter, 0),
       JS_PSG("evaluationError", ModuleObject_evaluationErrorGetter, 0),
       JS_PSG("requestedModules", ModuleObject_requestedModulesGetter, 0),
       JS_PSG("importEntries", ModuleObject_importEntriesGetter, 0),
       JS_PSG("localExportEntries", ModuleObject_localExportEntriesGetter, 0),
       JS_PSG("indirectExportEntries", ModuleObject_indirectExportEntriesGetter,
--- a/js/src/builtin/Promise.cpp
+++ b/js/src/builtin/Promise.cpp
@@ -2125,19 +2125,20 @@ static bool PromiseConstructor(JSContext
   args.rval().setObject(*promise);
   if (needsWrapping) {
     return cx->compartment()->wrap(cx, args.rval());
   }
   return true;
 }
 
 // ES2016, 25.4.3.1. steps 3-11.
-/* static */ PromiseObject* PromiseObject::create(
-    JSContext* cx, HandleObject executor, HandleObject proto /* = nullptr */,
-    bool needsWrapping /* = false */) {
+/* static */
+PromiseObject* PromiseObject::create(JSContext* cx, HandleObject executor,
+                                     HandleObject proto /* = nullptr */,
+                                     bool needsWrapping /* = false */) {
   MOZ_ASSERT(executor->isCallable());
 
   RootedObject usedProto(cx, proto);
   // If the proto is wrapped, that means the current function is running
   // with a different compartment active from the one the Promise instance
   // is to be created in.
   // See the comment in PromiseConstructor for details.
   if (needsWrapping) {
@@ -2215,18 +2216,18 @@ static bool PromiseConstructor(JSContext
   Debugger::onNewPromise(cx, promise);
 
   // Step 11.
   return promise;
 }
 
 // ES2016, 25.4.3.1. skipping creation of resolution functions and executor
 // function invocation.
-/* static */ PromiseObject* PromiseObject::createSkippingExecutor(
-    JSContext* cx) {
+/* static */
+PromiseObject* PromiseObject::createSkippingExecutor(JSContext* cx) {
   return CreatePromiseObjectWithoutResolutionFunctions(cx);
 }
 
 class MOZ_STACK_CLASS PromiseForOfIterator : public JS::ForOfIterator {
  public:
   using JS::ForOfIterator::ForOfIterator;
 
   bool isOptimizedDenseArrayIteration() {
@@ -3170,18 +3171,18 @@ static bool Promise_reject(JSContext* cx
   }
   args.rval().setObject(*result);
   return true;
 }
 
 /**
  * Unforgeable version of ES2016, 25.4.4.4, Promise.reject.
  */
-/* static */ JSObject* PromiseObject::unforgeableReject(JSContext* cx,
-                                                        HandleValue value) {
+/* static */
+JSObject* PromiseObject::unforgeableReject(JSContext* cx, HandleValue value) {
   JSObject* promiseCtor = JS::GetPromiseConstructor(cx);
   if (!promiseCtor) {
     return nullptr;
   }
   RootedValue cVal(cx, ObjectValue(*promiseCtor));
   return CommonStaticResolveRejectImpl(cx, cVal, value, RejectMode);
 }
 
@@ -3199,18 +3200,18 @@ static bool Promise_static_resolve(JSCon
   }
   args.rval().setObject(*result);
   return true;
 }
 
 /**
  * Unforgeable version of ES2016, 25.4.4.5, Promise.resolve.
  */
-/* static */ JSObject* PromiseObject::unforgeableResolve(JSContext* cx,
-                                                         HandleValue value) {
+/* static */
+JSObject* PromiseObject::unforgeableResolve(JSContext* cx, HandleValue value) {
   JSObject* promiseCtor = JS::GetPromiseConstructor(cx);
   if (!promiseCtor) {
     return nullptr;
   }
   RootedValue cVal(cx, ObjectValue(*promiseCtor));
   return CommonStaticResolveRejectImpl(cx, cVal, value, ResolveMode);
 }
 
@@ -4480,19 +4481,19 @@ bool PromiseObject::dependentPromises(JS
     }
 
     values[valuesIndex++].setObject(*promiseObj);
   }
 
   return true;
 }
 
-/* static */ bool PromiseObject::resolve(JSContext* cx,
-                                         Handle<PromiseObject*> promise,
-                                         HandleValue resolutionValue) {
+/* static */
+bool PromiseObject::resolve(JSContext* cx, Handle<PromiseObject*> promise,
+                            HandleValue resolutionValue) {
   MOZ_ASSERT(!PromiseHasAnyFlag(*promise, PROMISE_FLAG_ASYNC));
   if (promise->state() != JS::PromiseState::Pending) {
     return true;
   }
 
   if (PromiseHasAnyFlag(*promise, PROMISE_FLAG_DEFAULT_RESOLVING_FUNCTIONS)) {
     return ResolvePromiseInternal(cx, promise, resolutionValue);
   }
@@ -4510,19 +4511,19 @@ bool PromiseObject::dependentPromises(JS
   if (!cx->compartment()->wrap(cx, &funVal)) {
     return false;
   }
 
   RootedValue dummy(cx);
   return Call(cx, funVal, UndefinedHandleValue, resolutionValue, &dummy);
 }
 
-/* static */ bool PromiseObject::reject(JSContext* cx,
-                                        Handle<PromiseObject*> promise,
-                                        HandleValue rejectionValue) {
+/* static */
+bool PromiseObject::reject(JSContext* cx, Handle<PromiseObject*> promise,
+                           HandleValue rejectionValue) {
   MOZ_ASSERT(!PromiseHasAnyFlag(*promise, PROMISE_FLAG_ASYNC));
   if (promise->state() != JS::PromiseState::Pending) {
     return true;
   }
 
   if (PromiseHasAnyFlag(*promise, PROMISE_FLAG_DEFAULT_RESOLVING_FUNCTIONS)) {
     return ResolvePromise(cx, promise, rejectionValue,
                           JS::PromiseState::Rejected);
@@ -4530,18 +4531,18 @@ bool PromiseObject::dependentPromises(JS
 
   RootedValue funVal(cx, promise->getFixedSlot(PromiseSlot_RejectFunction));
   MOZ_ASSERT(IsCallable(funVal));
 
   RootedValue dummy(cx);
   return Call(cx, funVal, UndefinedHandleValue, rejectionValue, &dummy);
 }
 
-/* static */ void PromiseObject::onSettled(JSContext* cx,
-                                           Handle<PromiseObject*> promise) {
+/* static */
+void PromiseObject::onSettled(JSContext* cx, Handle<PromiseObject*> promise) {
   PromiseDebugInfo::setResolutionInfo(cx, promise);
 
   if (promise->state() == JS::PromiseState::Rejected &&
       promise->isUnhandled()) {
     cx->runtime()->addUnhandledRejectedPromise(cx, promise);
   }
 
   Debugger::onPromiseSettled(cx, promise);
@@ -5034,17 +5035,18 @@ void OffThreadPromiseRuntimeState::init(
   MOZ_ASSERT(!initialized());
 
   dispatchToEventLoopCallback_ = callback;
   dispatchToEventLoopClosure_ = closure;
 
   MOZ_ASSERT(initialized());
 }
 
-/* static */ bool OffThreadPromiseRuntimeState::internalDispatchToEventLoop(
+/* static */
+bool OffThreadPromiseRuntimeState::internalDispatchToEventLoop(
     void* closure, JS::Dispatchable* d) {
   OffThreadPromiseRuntimeState& state =
       *reinterpret_cast<OffThreadPromiseRuntimeState*>(closure);
   MOZ_ASSERT(state.usingInternalDispatchQueue());
 
   LockGuard<Mutex> lock(state.mutex_);
 
   if (state.internalDispatchQueueClosed_) {
--- a/js/src/builtin/Stream.cpp
+++ b/js/src/builtin/Stream.cpp
@@ -875,18 +875,19 @@ MOZ_MUST_USE ReadableStream* CreateReada
 // Streams spec, 3.3.4. CreateReadableByteStream (
 //                          startAlgorithm, pullAlgorithm, cancelAlgorithm
 //                          [, highWaterMark [, autoAllocateChunkSize ] ] )
 // Not implemented.
 
 /**
  * Streams spec, 3.3.5. InitializeReadableStream ( stream )
  */
-MOZ_MUST_USE /* static */ ReadableStream* ReadableStream::create(
-    JSContext* cx, HandleObject proto /* = nullptr */) {
+MOZ_MUST_USE /* static */
+    ReadableStream*
+    ReadableStream::create(JSContext* cx, HandleObject proto /* = nullptr */) {
   // In the spec, InitializeReadableStream is always passed a newly created
   // ReadableStream object. We instead create it here and return it below.
   Rooted<ReadableStream*> stream(
       cx, NewObjectWithClassProto<ReadableStream>(cx, proto));
   if (!stream) {
     return nullptr;
   }
 
--- a/js/src/builtin/String.cpp
+++ b/js/src/builtin/String.cpp
@@ -3688,18 +3688,19 @@ static const JSFunctionSpec string_stati
 #if EXPOSE_INTL_API
     JS_SELF_HOSTED_FN("normalize", "String_static_normalize", 1, 0),
 #endif
     JS_SELF_HOSTED_FN("concat", "String_static_concat", 2, 0),
 
     JS_SELF_HOSTED_FN("localeCompare", "String_static_localeCompare", 2, 0),
     JS_FS_END};
 
-/* static */ Shape* StringObject::assignInitialShape(
-    JSContext* cx, Handle<StringObject*> obj) {
+/* static */
+Shape* StringObject::assignInitialShape(JSContext* cx,
+                                        Handle<StringObject*> obj) {
   MOZ_ASSERT(obj->empty());
 
   return NativeObject::addDataProperty(cx, obj, cx->names().length, LENGTH_SLOT,
                                        JSPROP_PERMANENT | JSPROP_READONLY);
 }
 
 JSObject* js::InitStringClass(JSContext* cx, Handle<GlobalObject*> global) {
   Rooted<JSString*> empty(cx, cx->runtime()->emptyString);
--- a/js/src/builtin/TypedObject.cpp
+++ b/js/src/builtin/TypedObject.cpp
@@ -254,17 +254,18 @@ bool ScalarTypeDescr::call(JSContext* cx
 #undef SCALARTYPE_CALL
     case Scalar::Int64:
     case Scalar::MaxTypedArrayViewType:
       MOZ_CRASH();
   }
   return true;
 }
 
-/* static */ TypeDescr* GlobalObject::getOrCreateScalarTypeDescr(
+/* static */
+TypeDescr* GlobalObject::getOrCreateScalarTypeDescr(
     JSContext* cx, Handle<GlobalObject*> global, Scalar::Type scalarType) {
   int32_t slot = 0;
   switch (scalarType) {
     case Scalar::Int32:
       slot = TypedObjectModuleObject::Int32Desc;
       break;
     case Scalar::Int64:
       MOZ_CRASH("No Int64 support yet");
@@ -282,17 +283,18 @@ bool ScalarTypeDescr::call(JSContext* cx
       cx, &GlobalObject::getOrCreateTypedObjectModule(cx, global)
                ->as<TypedObjectModuleObject>());
   if (!module) {
     return nullptr;
   }
   return &module->getReservedSlot(slot).toObject().as<TypeDescr>();
 }
 
-/* static */ TypeDescr* GlobalObject::getOrCreateReferenceTypeDescr(
+/* static */
+TypeDescr* GlobalObject::getOrCreateReferenceTypeDescr(
     JSContext* cx, Handle<GlobalObject*> global, ReferenceType type) {
   int32_t slot = 0;
   switch (type) {
     case ReferenceType::TYPE_OBJECT:
       slot = TypedObjectModuleObject::ObjectDesc;
       break;
     case ReferenceType::TYPE_WASM_ANYREF:
       slot = TypedObjectModuleObject::WasmAnyRefDesc;
@@ -757,19 +759,19 @@ CheckedInt32 StructMetaTypeDescr::Layout
 
 CheckedInt32 StructMetaTypeDescr::Layout::close(int32_t* alignment) {
   if (alignment) {
     *alignment = structAlignment;
   }
   return RoundUpToAlignment(sizeSoFar, structAlignment);
 }
 
-/* static */ JSObject* StructMetaTypeDescr::create(JSContext* cx,
-                                                   HandleObject metaTypeDescr,
-                                                   HandleObject fields) {
+/* static */
+JSObject* StructMetaTypeDescr::create(JSContext* cx, HandleObject metaTypeDescr,
+                                      HandleObject fields) {
   // Obtain names of fields, which are the own properties of `fields`
   AutoIdVector ids(cx);
   if (!GetPropertyKeys(cx, fields, JSITER_OWNONLY | JSITER_SYMBOLS, &ids)) {
     return nullptr;
   }
 
   // Iterate through each field. Collect values for the various
   // vectors below and also track total size and alignment. Be wary
@@ -828,17 +830,18 @@ CheckedInt32 StructMetaTypeDescr::Layout
     return nullptr;
   }
 
   return createFromArrays(cx, structTypePrototype, opaque,
                           /* allowConstruct= */ true, ids, fieldTypeObjs,
                           fieldProps);
 }
 
-/* static */ StructTypeDescr* StructMetaTypeDescr::createFromArrays(
+/* static */
+StructTypeDescr* StructMetaTypeDescr::createFromArrays(
     JSContext* cx, HandleObject structTypePrototype, bool opaque,
     bool allowConstruct, AutoIdVector& ids, AutoValueVector& fieldTypeObjs,
     Vector<StructFieldProps>& fieldProps) {
   StringBuffer stringBuffer(cx);      // Canonical string repr
   AutoValueVector fieldNames(cx);     // Name of each field.
   AutoValueVector fieldOffsets(cx);   // Offset of each field field.
   AutoValueVector fieldMuts(cx);      // Mutability of each field.
   RootedObject userFieldOffsets(cx);  // User-exposed {f:offset} object
@@ -1308,18 +1311,19 @@ static JSObject* DefineMetaTypeDescr(JSC
 }
 
 /*  The initialization strategy for TypedObjects is mildly unusual
  * compared to other classes. Because all of the types are members
  * of a single global, `TypedObject`, we basically make the
  * initializer for the `TypedObject` class populate the
  * `TypedObject` global (which is referred to as "module" herein).
  */
-/* static */ bool GlobalObject::initTypedObjectModule(
-    JSContext* cx, Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initTypedObjectModule(JSContext* cx,
+                                         Handle<GlobalObject*> global) {
   RootedObject objProto(cx,
                         GlobalObject::getOrCreateObjectPrototype(cx, global));
   if (!objProto) {
     return false;
   }
 
   Rooted<TypedObjectModuleObject*> module(cx);
   module = NewObjectWithGivenProto<TypedObjectModuleObject>(cx, objProto,
@@ -1485,30 +1489,32 @@ bool TypedObject::isAttached() const {
   JSObject& owner = as<OutlineTypedObject>().owner();
   if (owner.is<ArrayBufferObject>() &&
       owner.as<ArrayBufferObject>().isDetached()) {
     return false;
   }
   return true;
 }
 
-/* static */ bool TypedObject::GetByteOffset(JSContext* cx, unsigned argc,
-                                             Value* vp) {
+/* static */
+bool TypedObject::GetByteOffset(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   args.rval().setInt32(
       AssertedCast<int32_t>(args[0].toObject().as<TypedObject>().offset()));
   return true;
 }
 
 /******************************************************************************
  * Outline typed objects
  */
 
-/*static*/ OutlineTypedObject* OutlineTypedObject::createUnattached(
-    JSContext* cx, HandleTypeDescr descr, gc::InitialHeap heap) {
+/*static*/
+OutlineTypedObject* OutlineTypedObject::createUnattached(JSContext* cx,
+                                                         HandleTypeDescr descr,
+                                                         gc::InitialHeap heap) {
   if (descr->opaque()) {
     return createUnattachedWithClass(cx, &OutlineOpaqueTypedObject::class_,
                                      descr, heap);
   } else {
     return createUnattachedWithClass(cx, &OutlineTransparentTypedObject::class_,
                                      descr, heap);
   }
 }
@@ -1534,17 +1540,18 @@ void OutlineTypedObject::setOwnerAndData
       // object. But that will result in the tenured owner's data containing a
       // nursery pointer, and thus we need a store buffer edge. Since we can't
       // catch the actual write, register the owner preemptively now.
       storeBuffer()->putWholeCell(owner);
     }
   }
 }
 
-/*static*/ OutlineTypedObject* OutlineTypedObject::createUnattachedWithClass(
+/*static*/
+OutlineTypedObject* OutlineTypedObject::createUnattachedWithClass(
     JSContext* cx, const Class* clasp, HandleTypeDescr descr,
     gc::InitialHeap heap) {
   MOZ_ASSERT(clasp == &OutlineTransparentTypedObject::class_ ||
              clasp == &OutlineOpaqueTypedObject::class_);
 
   AutoSetNewObjectMetadata metadata(cx);
 
   RootedObjectGroup group(
@@ -1601,17 +1608,18 @@ void OutlineTypedObject::attach(JSContex
   } else {
     MOZ_ASSERT(owner->is<InlineTypedObject>());
     JS::AutoCheckCannotGC nogc(cx);
     setOwnerAndData(
         owner, owner->as<InlineTypedObject>().inlineTypedMem(nogc) + offset);
   }
 }
 
-/*static*/ OutlineTypedObject* OutlineTypedObject::createDerived(
+/*static*/
+OutlineTypedObject* OutlineTypedObject::createDerived(
     JSContext* cx, HandleTypeDescr type, HandleTypedObject typedObj,
     uint32_t offset) {
   MOZ_ASSERT(offset <= typedObj->size());
   MOZ_ASSERT(offset + type->size() <= typedObj->size());
 
   const js::Class* clasp = typedObj->opaque()
                                ? &OutlineOpaqueTypedObject::class_
                                : &OutlineTransparentTypedObject::class_;
@@ -1620,19 +1628,19 @@ void OutlineTypedObject::attach(JSContex
   if (!obj) {
     return nullptr;
   }
 
   obj->attach(cx, *typedObj, offset);
   return obj;
 }
 
-/*static*/ TypedObject* TypedObject::createZeroed(JSContext* cx,
-                                                  HandleTypeDescr descr,
-                                                  gc::InitialHeap heap) {
+/*static*/
+TypedObject* TypedObject::createZeroed(JSContext* cx, HandleTypeDescr descr,
+                                       gc::InitialHeap heap) {
   // If possible, create an object with inline data.
   if (InlineTypedObject::canAccommodateType(descr)) {
     AutoSetNewObjectMetadata metadata(cx);
 
     InlineTypedObject* obj = InlineTypedObject::create(cx, descr, heap);
     if (!obj) {
       return nullptr;
     }
@@ -1655,18 +1663,18 @@ void OutlineTypedObject::attach(JSContex
   if (!buffer) {
     return nullptr;
   }
   descr->initInstances(cx->runtime(), buffer->dataPointer(), 1);
   obj->attach(cx, *buffer, 0);
   return obj;
 }
 
-/* static */ void OutlineTypedObject::obj_trace(JSTracer* trc,
-                                                JSObject* object) {
+/* static */
+void OutlineTypedObject::obj_trace(JSTracer* trc, JSObject* object) {
   OutlineTypedObject& typedObj = object->as<OutlineTypedObject>();
 
   TraceEdge(trc, typedObj.shapePtr(), "OutlineTypedObject_shape");
 
   if (!typedObj.owner_) {
     return;
   }
 
@@ -1717,19 +1725,20 @@ bool TypeDescr::hasProperty(const JSAtom
       size_t index;
       return as<StructTypeDescr>().fieldIndex(id, &index);
     }
   }
 
   MOZ_CRASH("Unexpected kind");
 }
 
-/* static */ bool TypedObject::obj_lookupProperty(
-    JSContext* cx, HandleObject obj, HandleId id, MutableHandleObject objp,
-    MutableHandle<PropertyResult> propp) {
+/* static */
+bool TypedObject::obj_lookupProperty(JSContext* cx, HandleObject obj,
+                                     HandleId id, MutableHandleObject objp,
+                                     MutableHandle<PropertyResult> propp) {
   if (obj->as<TypedObject>().typeDescr().hasProperty(cx->names(), id)) {
     propp.setNonNativeProperty();
     objp.set(obj);
     return true;
   }
 
   RootedObject proto(cx, obj->staticPrototype());
   if (!proto) {
@@ -1872,21 +1881,21 @@ bool TypedObject::obj_getElement(JSConte
   if (!proto) {
     vp.setUndefined();
     return true;
   }
 
   return GetElement(cx, proto, receiver, index, vp);
 }
 
-/*static*/ bool TypedObject::obj_getArrayElement(JSContext* cx,
-                                                 Handle<TypedObject*> typedObj,
-                                                 Handle<TypeDescr*> typeDescr,
-                                                 uint32_t index,
-                                                 MutableHandleValue vp) {
+/*static*/
+bool TypedObject::obj_getArrayElement(JSContext* cx,
+                                      Handle<TypedObject*> typedObj,
+                                      Handle<TypeDescr*> typeDescr,
+                                      uint32_t index, MutableHandleValue vp) {
   // Elements are not inherited from the prototype.
   if (index >= (size_t)typedObj->length()) {
     vp.setUndefined();
     return true;
   }
 
   Rooted<TypeDescr*> elementType(
       cx, &typeDescr->as<ArrayTypeDescr>().elementType());
@@ -2112,18 +2121,20 @@ bool TypedObject::obj_newEnumerate(JSCon
 void OutlineTypedObject::notifyBufferDetached(void* newData) {
   setData(reinterpret_cast<uint8_t*>(newData));
 }
 
 /******************************************************************************
  * Inline typed objects
  */
 
-/* static */ InlineTypedObject* InlineTypedObject::create(
-    JSContext* cx, HandleTypeDescr descr, gc::InitialHeap heap) {
+/* static */
+InlineTypedObject* InlineTypedObject::create(JSContext* cx,
+                                             HandleTypeDescr descr,
+                                             gc::InitialHeap heap) {
   gc::AllocKind allocKind = allocKindForTypeDescriptor(descr);
 
   const Class* clasp = descr->opaque() ? &InlineOpaqueTypedObject::class_
                                        : &InlineTransparentTypedObject::class_;
 
   RootedObjectGroup group(
       cx, ObjectGroup::defaultNewGroup(
               cx, clasp, TaggedProto(&descr->typedProto()), descr));
@@ -2131,49 +2142,51 @@ void OutlineTypedObject::notifyBufferDet
     return nullptr;
   }
 
   NewObjectKind newKind =
       (heap == gc::TenuredHeap) ? TenuredObject : GenericObject;
   return NewObjectWithGroup<InlineTypedObject>(cx, group, allocKind, newKind);
 }
 
-/* static */ InlineTypedObject* InlineTypedObject::createCopy(
+/* static */
+InlineTypedObject* InlineTypedObject::createCopy(
     JSContext* cx, Handle<InlineTypedObject*> templateObject,
     gc::InitialHeap heap) {
   AutoSetNewObjectMetadata metadata(cx);
 
   Rooted<TypeDescr*> descr(cx, &templateObject->typeDescr());
   InlineTypedObject* res = create(cx, descr, heap);
   if (!res) {
     return nullptr;
   }
 
   memcpy(res->inlineTypedMem(), templateObject->inlineTypedMem(),
          templateObject->size());
   return res;
 }
 
-/* static */ void InlineTypedObject::obj_trace(JSTracer* trc,
-                                               JSObject* object) {
+/* static */
+void InlineTypedObject::obj_trace(JSTracer* trc, JSObject* object) {
   InlineTypedObject& typedObj = object->as<InlineTypedObject>();
 
   TraceEdge(trc, typedObj.shapePtr(), "InlineTypedObject_shape");
 
   // Inline transparent objects do not have references and do not need more
   // tracing. If there is an entry in the compartment's LazyArrayBufferTable,
   // tracing that reference will be taken care of by the table itself.
   if (typedObj.is<InlineTransparentTypedObject>()) {
     return;
   }
 
   typedObj.typeDescr().traceInstances(trc, typedObj.inlineTypedMem(), 1);
 }
 
-/* static */ size_t InlineTypedObject::obj_moved(JSObject* dst, JSObject* src) {
+/* static */
+size_t InlineTypedObject::obj_moved(JSObject* dst, JSObject* src) {
   if (!IsInsideNursery(src)) {
     return 0;
   }
 
   // Inline typed object element arrays can be preserved on the stack by Ion
   // and need forwarding pointers created during a minor GC. We can't do this
   // in the trace hook because we don't have any stale data to determine
   // whether this object moved and where it was moved from.
@@ -2235,18 +2248,18 @@ DEFINE_TYPEDOBJ_CLASS(OutlineTransparent
 DEFINE_TYPEDOBJ_CLASS(OutlineOpaqueTypedObject, OutlineTypedObject::obj_trace,
                       nullptr);
 DEFINE_TYPEDOBJ_CLASS(InlineTransparentTypedObject,
                       InlineTypedObject::obj_trace,
                       InlineTypedObject::obj_moved);
 DEFINE_TYPEDOBJ_CLASS(InlineOpaqueTypedObject, InlineTypedObject::obj_trace,
                       InlineTypedObject::obj_moved);
 
-/*static*/ bool TypedObject::construct(JSContext* cx, unsigned int argc,
-                                       Value* vp) {
+/*static*/
+bool TypedObject::construct(JSContext* cx, unsigned int argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   MOZ_ASSERT(args.callee().is<TypeDescr>());
   Rooted<TypeDescr*> callee(cx, &args.callee().as<TypeDescr>());
 
   MOZ_ASSERT(cx->realm() == callee->realm());
 
   // Types created by Wasm may not be constructible from JS due to field types
@@ -2895,14 +2908,15 @@ static bool CreateTraceList(JSContext* c
   }
 
   PodCopy(list, entries.begin(), entries.length());
 
   descr->initReservedSlot(JS_DESCR_SLOT_TRACE_LIST, PrivateValue(list));
   return true;
 }
 
-/* static */ void TypeDescr::finalize(FreeOp* fop, JSObject* obj) {
+/* static */
+void TypeDescr::finalize(FreeOp* fop, JSObject* obj) {
   TypeDescr& descr = obj->as<TypeDescr>();
   if (descr.hasTraceList()) {
     js_free(const_cast<int32_t*>(descr.traceList()));
   }
 }
--- a/js/src/builtin/WeakMapObject.cpp
+++ b/js/src/builtin/WeakMapObject.cpp
@@ -39,17 +39,18 @@ using namespace js;
       return true;
     }
   }
 
   args.rval().setBoolean(false);
   return true;
 }
 
-/* static */ bool WeakMapObject::has(JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool WeakMapObject::has(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<WeakMapObject::is, WeakMapObject::has_impl>(cx,
                                                                           args);
 }
 
 /* static */ MOZ_ALWAYS_INLINE bool WeakMapObject::get_impl(
     JSContext* cx, const CallArgs& args) {
   MOZ_ASSERT(WeakMapObject::is(args.thisv()));
@@ -67,17 +68,18 @@ using namespace js;
       return true;
     }
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool WeakMapObject::get(JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool WeakMapObject::get(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<WeakMapObject::is, WeakMapObject::get_impl>(cx,
                                                                           args);
 }
 
 /* static */ MOZ_ALWAYS_INLINE bool WeakMapObject::delete_impl(
     JSContext* cx, const CallArgs& args) {
   MOZ_ASSERT(WeakMapObject::is(args.thisv()));
@@ -96,18 +98,18 @@ using namespace js;
       return true;
     }
   }
 
   args.rval().setBoolean(false);
   return true;
 }
 
-/* static */ bool WeakMapObject::delete_(JSContext* cx, unsigned argc,
-                                         Value* vp) {
+/* static */
+bool WeakMapObject::delete_(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<WeakMapObject::is, WeakMapObject::delete_impl>(
       cx, args);
 }
 
 /* static */ MOZ_ALWAYS_INLINE bool WeakMapObject::set_impl(
     JSContext* cx, const CallArgs& args) {
   MOZ_ASSERT(WeakMapObject::is(args.thisv()));
@@ -122,17 +124,18 @@ using namespace js;
 
   if (!WeakCollectionPutEntryInternal(cx, map, key, args.get(1))) {
     return false;
   }
   args.rval().set(args.thisv());
   return true;
 }
 
-/* static */ bool WeakMapObject::set(JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool WeakMapObject::set(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<WeakMapObject::is, WeakMapObject::set_impl>(cx,
                                                                           args);
 }
 
 bool WeakCollectionObject::nondeterministicGetKeys(
     JSContext* cx, Handle<WeakCollectionObject*> obj, MutableHandleObject ret) {
   RootedObject arr(cx, NewDenseEmptyArray(cx));
@@ -212,18 +215,18 @@ JS_PUBLIC_API bool JS::GetWeakMapEntry(J
 JS_PUBLIC_API bool JS::SetWeakMapEntry(JSContext* cx, HandleObject mapObj,
                                        HandleObject key, HandleValue val) {
   CHECK_THREAD(cx);
   cx->check(key, val);
   Handle<WeakMapObject*> rootedMap = mapObj.as<WeakMapObject>();
   return WeakCollectionPutEntryInternal(cx, rootedMap, key, val);
 }
 
-/* static */ bool WeakMapObject::construct(JSContext* cx, unsigned argc,
-                                           Value* vp) {
+/* static */
+bool WeakMapObject::construct(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   // ES6 draft rev 31 (15 Jan 2015) 23.3.1.1 step 1.
   if (!ThrowIfNotConstructing(cx, args, "WeakMap")) {
     return false;
   }
 
   RootedObject proto(cx);
--- a/js/src/builtin/WeakSetObject.cpp
+++ b/js/src/builtin/WeakSetObject.cpp
@@ -45,17 +45,18 @@ using namespace js;
     return false;
   }
 
   // Steps 6.a.i, 8.
   args.rval().set(args.thisv());
   return true;
 }
 
-/* static */ bool WeakSetObject::add(JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool WeakSetObject::add(JSContext* cx, unsigned argc, Value* vp) {
   // Steps 1-3.
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<WeakSetObject::is, WeakSetObject::add_impl>(cx,
                                                                           args);
 }
 
 // ES2018 draft rev 7a2d3f053ecc2336fc19f377c55d52d78b11b296
 // 23.4.3.3 WeakSet.prototype.delete ( value )
@@ -80,18 +81,18 @@ using namespace js;
     }
   }
 
   // Step 7.
   args.rval().setBoolean(false);
   return true;
 }
 
-/* static */ bool WeakSetObject::delete_(JSContext* cx, unsigned argc,
-                                         Value* vp) {
+/* static */
+bool WeakSetObject::delete_(JSContext* cx, unsigned argc, Value* vp) {
   // Steps 1-3.
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<WeakSetObject::is, WeakSetObject::delete_impl>(
       cx, args);
 }
 
 // ES2018 draft rev 7a2d3f053ecc2336fc19f377c55d52d78b11b296
 // 23.4.3.4 WeakSet.prototype.has ( value )
@@ -115,17 +116,18 @@ using namespace js;
     }
   }
 
   // Step 7.
   args.rval().setBoolean(false);
   return true;
 }
 
-/* static */ bool WeakSetObject::has(JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool WeakSetObject::has(JSContext* cx, unsigned argc, Value* vp) {
   // Steps 1-3.
   CallArgs args = CallArgsFromVp(argc, vp);
   return CallNonGenericMethod<WeakSetObject::is, WeakSetObject::has_impl>(cx,
                                                                           args);
 }
 
 const ClassSpec WeakSetObject::classSpec_ = {
     GenericCreateConstructor<WeakSetObject::construct, 0,
--- a/js/src/builtin/intl/IntlObject.cpp
+++ b/js/src/builtin/intl/IntlObject.cpp
@@ -514,18 +514,18 @@ static const JSFunctionSpec intl_static_
     JS_FN(js_toSource_str, intl_toSource, 0, 0),
     JS_SELF_HOSTED_FN("getCanonicalLocales", "Intl_getCanonicalLocales", 1, 0),
     JS_FS_END};
 
 /**
  * Initializes the Intl Object and its standard built-in properties.
  * Spec: ECMAScript Internationalization API Specification, 8.0, 8.1
  */
-/* static */ bool GlobalObject::initIntlObject(JSContext* cx,
-                                               Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initIntlObject(JSContext* cx, Handle<GlobalObject*> global) {
   RootedObject proto(cx, GlobalObject::getOrCreateObjectPrototype(cx, global));
   if (!proto) {
     return false;
   }
 
   // The |Intl| object is just a plain object with some "static" function
   // properties and some constructor properties.
   RootedObject intl(
--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -6217,17 +6217,18 @@ JSObject* StructType::BuildFieldsArray(J
   // Seal the fields array.
   if (!JS_FreezeObject(cx, fieldsProp)) {
     return nullptr;
   }
 
   return fieldsProp;
 }
 
-/* static */ bool StructType::IsStruct(HandleValue v) {
+/* static */
+bool StructType::IsStruct(HandleValue v) {
   if (!v.isObject()) {
     return false;
   }
   JSObject* obj = &v.toObject();
   return CType::IsCType(obj) && CType::GetTypeCode(obj) == TYPE_struct;
 }
 
 bool StructType::FieldsArrayGetter(JSContext* cx, const JS::CallArgs& args) {
--- a/js/src/frontend/BinSourceRuntimeSupport.cpp
+++ b/js/src/frontend/BinSourceRuntimeSupport.cpp
@@ -8,17 +8,18 @@
 
 #include "gc/Tracer.h"
 #include "js/Vector.h"
 #include "vm/StringType.h"
 
 namespace js {
 namespace frontend {
 
-/* static */ BinASTSourceMetadata* BinASTSourceMetadata::Create(
+/* static */
+BinASTSourceMetadata* BinASTSourceMetadata::Create(
     const Vector<BinKind>& binKinds, uint32_t numStrings) {
   uint32_t numBinKinds = binKinds.length();
 
   BinASTSourceMetadata* data = static_cast<BinASTSourceMetadata*>(
       js_malloc(BinASTSourceMetadata::totalSize(numBinKinds, numStrings)));
   if (!data) {
     return nullptr;
   }
--- a/js/src/frontend/EmitterScope.cpp
+++ b/js/src/frontend/EmitterScope.cpp
@@ -124,18 +124,18 @@ Scope* EmitterScope::enclosingScope(Byte
     return es->scope(bce);
   }
 
   // The enclosing script is already compiled or the current script is the
   // global script.
   return bce->sc->compilationEnclosingScope();
 }
 
-/* static */ bool EmitterScope::nameCanBeFree(BytecodeEmitter* bce,
-                                              JSAtom* name) {
+/* static */
+bool EmitterScope::nameCanBeFree(BytecodeEmitter* bce, JSAtom* name) {
   // '.generator' cannot be accessed by name.
   return name != bce->cx->names().dotGenerator;
 }
 
 #ifdef DEBUG
 static bool NameIsOnEnvironment(Scope* scope, JSAtom* name) {
   for (BindingIter bi(scope); bi; bi++) {
     // If found, the name must already be on the environment or an import,
@@ -162,19 +162,19 @@ static bool NameIsOnEnvironment(Scope* s
     }
   }
 
   // If not found, assume it's on the global or dynamically accessed.
   return true;
 }
 #endif
 
-/* static */ NameLocation EmitterScope::searchInEnclosingScope(JSAtom* name,
-                                                               Scope* scope,
-                                                               uint8_t hops) {
+/* static */
+NameLocation EmitterScope::searchInEnclosingScope(JSAtom* name, Scope* scope,
+                                                  uint8_t hops) {
   for (ScopeIter si(scope); si; si++) {
     MOZ_ASSERT(NameIsOnEnvironment(si.scope(), name));
 
     bool hasEnv = si.hasSyntacticEnvironment();
 
     switch (si.kind()) {
       case ScopeKind::Function:
         if (hasEnv) {
--- a/js/src/frontend/ParseNode.cpp
+++ b/js/src/frontend/ParseNode.cpp
@@ -402,18 +402,18 @@ ObjectBox::ObjectBox(JSFunction* functio
   MOZ_ASSERT(asFunctionBox()->function() == function);
 }
 
 FunctionBox* ObjectBox::asFunctionBox() {
   MOZ_ASSERT(isFunctionBox());
   return static_cast<FunctionBox*>(this);
 }
 
-/* static */ void TraceListNode::TraceList(JSTracer* trc,
-                                           TraceListNode* listHead) {
+/* static */
+void TraceListNode::TraceList(JSTracer* trc, TraceListNode* listHead) {
   for (TraceListNode* node = listHead; node; node = node->traceLink) {
     node->trace(trc);
   }
 }
 
 void TraceListNode::trace(JSTracer* trc) {
   TraceGenericPointerRoot(trc, &gcThing, "parser.traceListNode");
 }
--- a/js/src/gc/Allocator.cpp
+++ b/js/src/gc/Allocator.cpp
@@ -255,18 +255,19 @@ T* js::Allocate(JSContext* cx) {
 #define DECL_ALLOCATOR_INSTANCES(allocKind, traceKind, type, sizedType, \
                                  bgFinal, nursery, compact)             \
   template type* js::Allocate<type, NoGC>(JSContext * cx);              \
   template type* js::Allocate<type, CanGC>(JSContext * cx);
 FOR_EACH_NONOBJECT_NONNURSERY_ALLOCKIND(DECL_ALLOCATOR_INSTANCES)
 #undef DECL_ALLOCATOR_INSTANCES
 
 template <typename T, AllowGC allowGC>
-/* static */ T* GCRuntime::tryNewTenuredThing(JSContext* cx, AllocKind kind,
-                                              size_t thingSize) {
+/* static */
+T* GCRuntime::tryNewTenuredThing(JSContext* cx, AllocKind kind,
+                                 size_t thingSize) {
   // Bump allocate in the arena's current free-list span.
   T* t = reinterpret_cast<T*>(cx->freeLists().allocate(kind));
   if (MOZ_UNLIKELY(!t)) {
     // Get the next available free list and allocate out of it. This may
     // acquire a new arena, which will lock the chunk list. If there are no
     // chunks available it may also allocate new memory directly.
     t = reinterpret_cast<T*>(refillFreeListFromAnyThread(cx, kind));
 
@@ -353,17 +354,18 @@ bool GCRuntime::gcIfNeededAtAllocation(J
     PrepareZoneForGC(cx->zone());
     gc(GC_NORMAL, JS::GCReason::INCREMENTAL_TOO_SLOW);
   }
 
   return true;
 }
 
 template <typename T>
-/* static */ void GCRuntime::checkIncrementalZoneState(JSContext* cx, T* t) {
+/* static */
+void GCRuntime::checkIncrementalZoneState(JSContext* cx, T* t) {
 #ifdef DEBUG
   if (cx->helperThread() || !t) {
     return;
   }
 
   TenuredCell* cell = &t->asTenured();
   Zone* zone = cell->zone();
   if (zone->isGCMarking() || zone->isGCSweeping()) {
@@ -396,50 +398,53 @@ bool GCRuntime::startBackgroundAllocTask
 
   // Join the previous invocation of the task. This will return immediately
   // if the thread has never been started.
   allocTask.joinWithLockHeld(helperLock);
 
   return allocTask.startWithLockHeld(helperLock);
 }
 
-/* static */ TenuredCell* GCRuntime::refillFreeListFromAnyThread(
-    JSContext* cx, AllocKind thingKind) {
+/* static */
+TenuredCell* GCRuntime::refillFreeListFromAnyThread(JSContext* cx,
+                                                    AllocKind thingKind) {
   MOZ_ASSERT(cx->freeLists().isEmpty(thingKind));
 
   if (!cx->helperThread()) {
     return refillFreeListFromMainThread(cx, thingKind);
   }
 
   return refillFreeListFromHelperThread(cx, thingKind);
 }
 
-/* static */ TenuredCell* GCRuntime::refillFreeListFromMainThread(
-    JSContext* cx, AllocKind thingKind) {
+/* static */
+TenuredCell* GCRuntime::refillFreeListFromMainThread(JSContext* cx,
+                                                     AllocKind thingKind) {
   // It should not be possible to allocate on the main thread while we are
   // inside a GC.
   MOZ_ASSERT(!JS::RuntimeHeapIsBusy(), "allocating while under GC");
 
   return cx->zone()->arenas.refillFreeListAndAllocate(
       cx->freeLists(), thingKind, ShouldCheckThresholds::CheckThresholds);
 }
 
-/* static */ TenuredCell* GCRuntime::refillFreeListFromHelperThread(
-    JSContext* cx, AllocKind thingKind) {
+/* static */
+TenuredCell* GCRuntime::refillFreeListFromHelperThread(JSContext* cx,
+                                                       AllocKind thingKind) {
   // A GC may be happening on the main thread, but zones used by off thread
   // tasks are never collected.
   Zone* zone = cx->zone();
   MOZ_ASSERT(!zone->wasGCStarted());
 
   return zone->arenas.refillFreeListAndAllocate(
       cx->freeLists(), thingKind, ShouldCheckThresholds::CheckThresholds);
 }
 
-/* static */ TenuredCell* GCRuntime::refillFreeListInGC(Zone* zone,
-                                                        AllocKind thingKind) {
+/* static */
+TenuredCell* GCRuntime::refillFreeListInGC(Zone* zone, AllocKind thingKind) {
   // Called by compacting GC to refill a free list while we are in a GC.
   MOZ_ASSERT(JS::RuntimeHeapIsCollecting());
   MOZ_ASSERT_IF(!JS::RuntimeHeapIsMinorCollecting(),
                 !zone->runtimeFromMainThread()->gc.isBackgroundSweeping());
 
   return zone->arenas.refillFreeListAndAllocate(
       zone->arenas.freeLists(), thingKind,
       ShouldCheckThresholds::DontCheckThresholds);
@@ -712,17 +717,18 @@ void BackgroundAllocTask::run() {
         break;
       }
       chunk->init(runtime());
     }
     chunkPool_.ref().push(chunk);
   }
 }
 
-/* static */ Chunk* Chunk::allocate(JSRuntime* rt) {
+/* static */
+Chunk* Chunk::allocate(JSRuntime* rt) {
   Chunk* chunk = static_cast<Chunk*>(MapAlignedPages(ChunkSize, ChunkSize));
   if (!chunk) {
     return nullptr;
   }
   rt->gc.stats().count(gcstats::COUNT_NEW_CHUNK);
   return chunk;
 }
 
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -534,17 +534,18 @@ void Arena::unmarkPreMarkedFreeCells() {
 #ifdef DEBUG
 void Arena::checkNoMarkedFreeCells() {
   for (ArenaFreeCellIter iter(this); !iter.done(); iter.next()) {
     MOZ_ASSERT(!iter.getCell()->isMarkedAny());
   }
 }
 #endif
 
-/* static */ void Arena::staticAsserts() {
+/* static */
+void Arena::staticAsserts() {
   static_assert(size_t(AllocKind::LIMIT) <= 255,
                 "We must be able to fit the allockind into uint8_t.");
   static_assert(mozilla::ArrayLength(ThingSizes) == size_t(AllocKind::LIMIT),
                 "We haven't defined all thing sizes.");
   static_assert(
       mozilla::ArrayLength(FirstThingOffsets) == size_t(AllocKind::LIMIT),
       "We haven't defined all offsets.");
   static_assert(
@@ -1938,17 +1939,18 @@ void GCRuntime::setMaxMallocBytes(size_t
 
 float ZoneHeapThreshold::eagerAllocTrigger(bool highFrequencyGC) const {
   float eagerTriggerFactor = highFrequencyGC
                                  ? HighFrequencyEagerAllocTriggerFactor
                                  : LowFrequencyEagerAllocTriggerFactor;
   return eagerTriggerFactor * gcTriggerBytes();
 }
 
-/* static */ float ZoneHeapThreshold::computeZoneHeapGrowthFactorForHeapSize(
+/* static */
+float ZoneHeapThreshold::computeZoneHeapGrowthFactorForHeapSize(
     size_t lastBytes, const GCSchedulingTunables& tunables,
     const GCSchedulingState& state) {
   if (!tunables.isDynamicHeapGrowthEnabled()) {
     return 3.0f;
   }
 
   // For small zones, our collection heuristics do not matter much: favor
   // something simple in this case.
@@ -1989,17 +1991,18 @@ float ZoneHeapThreshold::eagerAllocTrigg
   float factor = maxRatio - ((maxRatio - minRatio) *
                              ((lastBytes - lowLimit) / (highLimit - lowLimit)));
 
   MOZ_ASSERT(factor >= minRatio);
   MOZ_ASSERT(factor <= maxRatio);
   return factor;
 }
 
-/* static */ size_t ZoneHeapThreshold::computeZoneTriggerBytes(
+/* static */
+size_t ZoneHeapThreshold::computeZoneTriggerBytes(
     float growthFactor, size_t lastBytes, JSGCInvocationKind gckind,
     const GCSchedulingTunables& tunables, const AutoLockGC& lock) {
   size_t base =
       gckind == GC_SHRINK
           ? Max(lastBytes, tunables.minEmptyChunkCount(lock) * ChunkSize)
           : Max(lastBytes, tunables.gcZoneAllocThresholdBase());
   float trigger = float(base) * growthFactor;
   return size_t(Min(float(tunables.gcMaxBytes()), trigger));
@@ -3077,18 +3080,19 @@ inline void ArenaLists::queueForBackgrou
 
   MOZ_ASSERT(concurrentUse(thingKind) == ConcurrentUse::None);
 
   arenaListsToSweep(thingKind) = al->head();
   al->clear();
   concurrentUse(thingKind) = ConcurrentUse::BackgroundFinalize;
 }
 
-/*static*/ void ArenaLists::backgroundFinalize(FreeOp* fop, Arena* listHead,
-                                               Arena** empty) {
+/*static*/
+void ArenaLists::backgroundFinalize(FreeOp* fop, Arena* listHead,
+                                    Arena** empty) {
   MOZ_ASSERT(listHead);
   MOZ_ASSERT(empty);
 
   AllocKind thingKind = listHead->getAllocKind();
   Zone* zone = listHead->zone;
 
   size_t thingsPerArena = Arena::thingsPerArena(thingKind);
   SortedArenaList finalizedSorted(thingsPerArena);
@@ -3681,17 +3685,18 @@ void GCRuntime::freeFromBackgroundThread
       rt->defaultFreeOp()->free_(r.front());
     }
   } while (!lifoBlocksToFree.ref().isEmpty() ||
            !buffersToFreeAfterMinorGC.ref().empty());
 }
 
 void GCRuntime::waitBackgroundFreeEnd() { freeTask.join(); }
 
-/* static */ bool UniqueIdGCPolicy::needsSweep(Cell** cellp, uint64_t*) {
+/* static */
+bool UniqueIdGCPolicy::needsSweep(Cell** cellp, uint64_t*) {
   Cell* cell = *cellp;
   return MapGCThingTyped(cell, cell->getTraceKind(), [](auto t) {
     mozilla::DebugOnly<const Cell*> prior = t;
     bool result = IsAboutToBeFinalizedUnbarriered(&t);
     // Sweep should not have to deal with moved pointers, since moving GC
     // handles updating the UID table manually.
     MOZ_ASSERT(t == prior);
     return result;
@@ -5014,17 +5019,18 @@ void GCRuntime::getNextSweepGroup() {
  * GCRuntime::markIncomingCrossCompartmentPointers.
  */
 
 static bool IsGrayListObject(JSObject* obj) {
   MOZ_ASSERT(obj);
   return obj->is<CrossCompartmentWrapperObject>() && !IsDeadProxyObject(obj);
 }
 
-/* static */ unsigned ProxyObject::grayLinkReservedSlot(JSObject* obj) {
+/* static */
+unsigned ProxyObject::grayLinkReservedSlot(JSObject* obj) {
   MOZ_ASSERT(IsGrayListObject(obj));
   return CrossCompartmentWrapperObject::GrayLinkReservedSlot;
 }
 
 #ifdef DEBUG
 static void AssertNotOnGrayList(JSObject* obj) {
   MOZ_ASSERT_IF(
       IsGrayListObject(obj),
--- a/js/src/gc/Nursery.cpp
+++ b/js/src/gc/Nursery.cpp
@@ -81,18 +81,18 @@ inline void js::NurseryChunk::poisonAfte
   MOZ_ASSERT(extent <= ChunkSize);
   // We can poison the same chunk more than once, so first make sure memory
   // sanitizers will let us poison it.
   MOZ_MAKE_MEM_UNDEFINED(this, extent);
 
   Poison(this, JS_SWEPT_NURSERY_PATTERN, extent, MemCheckKind::MakeNoAccess);
 }
 
-/* static */ inline js::NurseryChunk* js::NurseryChunk::fromChunk(
-    Chunk* chunk) {
+/* static */
+inline js::NurseryChunk* js::NurseryChunk::fromChunk(Chunk* chunk) {
   return reinterpret_cast<NurseryChunk*>(chunk);
 }
 
 inline Chunk* js::NurseryChunk::toChunk(JSRuntime* rt) {
   auto chunk = reinterpret_cast<Chunk*>(this);
   chunk->init(rt);
   return chunk;
 }
@@ -653,26 +653,27 @@ void js::Nursery::renderProfileJSON(JSON
     json.property(names[i++], time, json.MICROSECONDS);
   }
 
   json.endObject();  // timings value
 
   json.endObject();
 }
 
-/* static */ void js::Nursery::printProfileHeader() {
+/* static */
+void js::Nursery::printProfileHeader() {
   fprintf(stderr, "MinorGC:               Reason  PRate Size        ");
 #define PRINT_HEADER(name, text) fprintf(stderr, " %6s", text);
   FOR_EACH_NURSERY_PROFILE_TIME(PRINT_HEADER)
 #undef PRINT_HEADER
   fprintf(stderr, "\n");
 }
 
-/* static */ void js::Nursery::printProfileDurations(
-    const ProfileDurations& times) {
+/* static */
+void js::Nursery::printProfileDurations(const ProfileDurations& times) {
   for (auto time : times) {
     fprintf(stderr, " %6" PRIi64, static_cast<int64_t>(time.ToMicroseconds()));
   }
   fprintf(stderr, "\n");
 }
 
 void js::Nursery::printTotalProfileTimes() {
   if (enableProfiling_) {
--- a/js/src/gc/RootMarking.cpp
+++ b/js/src/gc/RootMarking.cpp
@@ -212,23 +212,25 @@ inline void AutoGCRooter::trace(JSTracer
       }
       return;
     }
   }
 
   MOZ_CRASH("Bad AutoGCRooter::Tag");
 }
 
-/* static */ void AutoGCRooter::traceAll(JSContext* cx, JSTracer* trc) {
+/* static */
+void AutoGCRooter::traceAll(JSContext* cx, JSTracer* trc) {
   for (AutoGCRooter* gcr = cx->autoGCRooters_; gcr; gcr = gcr->down) {
     gcr->trace(trc);
   }
 }
 
-/* static */ void AutoGCRooter::traceAllWrappers(JSContext* cx, JSTracer* trc) {
+/* static */
+void AutoGCRooter::traceAllWrappers(JSContext* cx, JSTracer* trc) {
   for (AutoGCRooter* gcr = cx->autoGCRooters_; gcr; gcr = gcr->down) {
     if (gcr->tag_ == Tag::WrapperVector || gcr->tag_ == Tag::Wrapper) {
       gcr->trace(trc);
     }
   }
 }
 
 void StackShape::trace(JSTracer* trc) {
--- a/js/src/gc/Statistics.cpp
+++ b/js/src/gc/Statistics.cpp
@@ -809,17 +809,18 @@ Statistics::~Statistics() {
   if (gcTimerFile && gcTimerFile != stdout && gcTimerFile != stderr) {
     fclose(gcTimerFile);
   }
   if (gcDebugFile && gcDebugFile != stdout && gcDebugFile != stderr) {
     fclose(gcDebugFile);
   }
 }
 
-/* static */ bool Statistics::initialize() {
+/* static */
+bool Statistics::initialize() {
 #ifdef DEBUG
   // Sanity check generated tables.
   for (auto i : AllPhases()) {
     auto parent = phases[i].parent;
     if (parent != Phase::NONE) {
       MOZ_ASSERT(phases[i].depth == phases[parent].depth + 1);
     }
     auto firstChild = phases[i].firstChild;
@@ -1458,17 +1459,18 @@ void Statistics::printProfileHeader() {
   fprintf(stderr, " %6s", "budget");
   fprintf(stderr, " %6s", "total");
 #define PRINT_PROFILE_HEADER(name, text, phase) fprintf(stderr, " %6s", text);
   FOR_EACH_GC_PROFILE_TIME(PRINT_PROFILE_HEADER)
 #undef PRINT_PROFILE_HEADER
   fprintf(stderr, "\n");
 }
 
-/* static */ void Statistics::printProfileTimes(const ProfileDurations& times) {
+/* static */
+void Statistics::printProfileTimes(const ProfileDurations& times) {
   for (auto time : times) {
     fprintf(stderr, " %6" PRIi64, static_cast<int64_t>(time.ToMilliseconds()));
   }
   fprintf(stderr, "\n");
 }
 
 void Statistics::printSliceProfile() {
   const SliceData& slice = slices_.back();
--- a/js/src/jit/BaselineDebugModeOSR.cpp
+++ b/js/src/jit/BaselineDebugModeOSR.cpp
@@ -1017,18 +1017,20 @@ JitCode* JitRuntime::generateBaselineDeb
 
 #ifdef JS_ION_PERF
   writePerfSpewerJitCodeProfile(code, "BaselineDebugModeOSRHandler");
 #endif
 
   return code;
 }
 
-/* static */ void DebugModeOSRVolatileJitFrameIter::forwardLiveIterators(
-    JSContext* cx, uint8_t* oldAddr, uint8_t* newAddr) {
+/* static */
+void DebugModeOSRVolatileJitFrameIter::forwardLiveIterators(JSContext* cx,
+                                                            uint8_t* oldAddr,
+                                                            uint8_t* newAddr) {
   DebugModeOSRVolatileJitFrameIter* iter;
   for (iter = cx->liveVolatileJitFrameIter_; iter; iter = iter->prev) {
     if (iter->isWasm()) {
       continue;
     }
     iter->asJSJit().exchangeReturnAddressIfMatch(oldAddr, newAddr);
   }
 }
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -103,18 +103,18 @@ ICFallbackStub* ICEntry::fallbackStub() 
 }
 
 void ICEntry::trace(JSTracer* trc) {
   for (ICStub* stub = firstStub(); stub; stub = stub->next()) {
     stub->trace(trc);
   }
 }
 
-/* static */ UniquePtr<ICScript> ICScript::create(JSContext* cx,
-                                                  JSScript* script) {
+/* static */
+UniquePtr<ICScript> ICScript::create(JSContext* cx, JSScript* script) {
   MOZ_ASSERT(cx->realm()->jitRealm());
   MOZ_ASSERT(jit::IsBaselineEnabled(cx));
 
   FallbackICStubSpace stubSpace;
   js::Vector<ICEntry, 16, SystemAllocPolicy> icEntries;
 
   auto addIC = [cx, &icEntries, script](jsbytecode* pc, ICStub* stub) {
     if (!stub) {
@@ -458,17 +458,18 @@ void ICStubIterator::unlink(JSContext* c
 
   fallbackStub_->unlinkStub(cx->zone(), previousStub_, currentStub_);
 
   // Mark the current iterator position as unlinked, so operator++ works
   // properly.
   unlinked_ = true;
 }
 
-/* static */ bool ICStub::NonCacheIRStubMakesGCCalls(Kind kind) {
+/* static */
+bool ICStub::NonCacheIRStubMakesGCCalls(Kind kind) {
   MOZ_ASSERT(IsValidKind(kind));
   MOZ_ASSERT(!IsCacheIRKind(kind));
 
   switch (kind) {
     case Call_Fallback:
     case Call_Scripted:
     case Call_AnyScripted:
     case Call_Native:
@@ -509,17 +510,18 @@ void ICStub::traceCode(JSTracer* trc, co
 }
 
 void ICStub::updateCode(JitCode* code) {
   // Write barrier on the old code.
   JitCode::writeBarrierPre(jitCode());
   stubCode_ = code->raw();
 }
 
-/* static */ void ICStub::trace(JSTracer* trc) {
+/* static */
+void ICStub::trace(JSTracer* trc) {
   traceCode(trc, "shared-stub-jitcode");
 
   // If the stub is a monitored fallback stub, then trace the monitor ICs
   // hanging off of that stub.  We don't need to worry about the regular
   // monitored stubs, because the regular monitored stubs will always have a
   // monitored fallback stub that references the same stub chain.
   if (isMonitoredFallback()) {
     ICTypeMonitor_Fallback* lastMonStub =
@@ -1038,18 +1040,19 @@ bool ICUpdatedStub::initUpdatingChain(JS
   if (!stub) {
     return false;
   }
 
   firstUpdateStub_ = stub;
   return true;
 }
 
-/* static */ ICStubSpace* ICStubCompiler::StubSpaceForStub(bool makesGCCalls,
-                                                           JSScript* script) {
+/* static */
+ICStubSpace* ICStubCompiler::StubSpaceForStub(bool makesGCCalls,
+                                              JSScript* script) {
   if (makesGCCalls) {
     return script->icScript()->fallbackStubSpace();
   }
   return script->zone()->jitZone()->optimizedStubSpace();
 }
 
 JitCode* ICStubCompiler::getStubCode() {
   JitRealm* realm = cx->realm()->jitRealm();
--- a/js/src/jit/CompileWrappers.cpp
+++ b/js/src/jit/CompileWrappers.cpp
@@ -14,17 +14,18 @@
 
 using namespace js;
 using namespace js::jit;
 
 JSRuntime* CompileRuntime::runtime() {
   return reinterpret_cast<JSRuntime*>(this);
 }
 
-/* static */ CompileRuntime* CompileRuntime::get(JSRuntime* rt) {
+/* static */
+CompileRuntime* CompileRuntime::get(JSRuntime* rt) {
   return reinterpret_cast<CompileRuntime*>(rt);
 }
 
 #ifdef JS_GC_ZEAL
 const uint32_t* CompileRuntime::addressOfGCZealModeBits() {
   return runtime()->gc.addressOfZealModeBits();
 }
 #endif
@@ -94,17 +95,18 @@ bool CompileRuntime::isInsideNursery(gc:
 const DOMCallbacks* CompileRuntime::DOMcallbacks() {
   return runtime()->DOMcallbacks;
 }
 
 bool CompileRuntime::runtimeMatches(JSRuntime* rt) { return rt == runtime(); }
 
 Zone* CompileZone::zone() { return reinterpret_cast<Zone*>(this); }
 
-/* static */ CompileZone* CompileZone::get(Zone* zone) {
+/* static */
+CompileZone* CompileZone::get(Zone* zone) {
   return reinterpret_cast<CompileZone*>(zone);
 }
 
 CompileRuntime* CompileZone::runtime() {
   return CompileRuntime::get(zone()->runtimeFromAnyThread());
 }
 
 bool CompileZone::isAtomsZone() { return zone()->isAtomsZone(); }
@@ -163,17 +165,18 @@ bool CompileZone::nurseryExists() {
 void CompileZone::setMinorGCShouldCancelIonCompilations() {
   MOZ_ASSERT(CurrentThreadCanAccessZone(zone()));
   JSRuntime* rt = zone()->runtimeFromMainThread();
   rt->gc.storeBuffer().setShouldCancelIonCompilations();
 }
 
 JS::Realm* CompileRealm::realm() { return reinterpret_cast<JS::Realm*>(this); }
 
-/* static */ CompileRealm* CompileRealm::get(JS::Realm* realm) {
+/* static */
+CompileRealm* CompileRealm::get(JS::Realm* realm) {
   return reinterpret_cast<CompileRealm*>(realm);
 }
 
 CompileZone* CompileRealm::zone() { return CompileZone::get(realm()->zone()); }
 
 CompileRuntime* CompileRealm::runtime() {
   return CompileRuntime::get(realm()->runtimeFromAnyThread());
 }
--- a/js/src/jit/ExecutableAllocator.cpp
+++ b/js/src/jit/ExecutableAllocator.cpp
@@ -149,18 +149,19 @@ ExecutablePool* ExecutableAllocator::poo
       pool->addRef();
     }
   }
 
   // Pass ownership to the caller.
   return pool;
 }
 
-/* static */ size_t ExecutableAllocator::roundUpAllocationSize(
-    size_t request, size_t granularity) {
+/* static */
+size_t ExecutableAllocator::roundUpAllocationSize(size_t request,
+                                                  size_t granularity) {
   if ((std::numeric_limits<size_t>::max() - granularity) <= request) {
     return OVERSIZE_ALLOCATION;
   }
 
   // Round up to next page boundary
   size_t size = request + (granularity - 1);
   size = size & ~(granularity - 1);
   MOZ_ASSERT(size >= request);
@@ -252,26 +253,28 @@ void ExecutableAllocator::addSizeOfCode(
     sizes->ion += pool->m_codeBytes[CodeKind::Ion];
     sizes->baseline += pool->m_codeBytes[CodeKind::Baseline];
     sizes->regexp += pool->m_codeBytes[CodeKind::RegExp];
     sizes->other += pool->m_codeBytes[CodeKind::Other];
     sizes->unused += pool->m_allocation.size - pool->usedCodeBytes();
   }
 }
 
-/* static */ void ExecutableAllocator::reprotectPool(
-    JSRuntime* rt, ExecutablePool* pool, ProtectionSetting protection) {
+/* static */
+void ExecutableAllocator::reprotectPool(JSRuntime* rt, ExecutablePool* pool,
+                                        ProtectionSetting protection) {
   char* start = pool->m_allocation.pages;
   if (!ReprotectRegion(start, pool->m_freePtr - start, protection)) {
     MOZ_CRASH();
   }
 }
 
-/* static */ void ExecutableAllocator::poisonCode(
-    JSRuntime* rt, JitPoisonRangeVector& ranges) {
+/* static */
+void ExecutableAllocator::poisonCode(JSRuntime* rt,
+                                     JitPoisonRangeVector& ranges) {
   MOZ_ASSERT(CurrentThreadCanAccessRuntime(rt));
 
 #ifdef DEBUG
   // Make sure no pools have the mark bit set.
   for (size_t i = 0; i < ranges.length(); i++) {
     MOZ_ASSERT(!ranges[i].pool->isMarked());
   }
 #endif
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -527,54 +527,56 @@ uint8_t* jit::LazyLinkTopActivation(JSCo
   LinkIonScript(cx, calleeScript);
 
   MOZ_ASSERT(calleeScript->hasBaselineScript());
   MOZ_ASSERT(calleeScript->jitCodeRaw());
 
   return calleeScript->jitCodeRaw();
 }
 
-/* static */ void JitRuntime::Trace(JSTracer* trc,
-                                    const AutoAccessAtomsZone& access) {
+/* static */
+void JitRuntime::Trace(JSTracer* trc, const AutoAccessAtomsZone& access) {
   MOZ_ASSERT(!JS::RuntimeHeapIsMinorCollecting());
 
   // Shared stubs are allocated in the atoms zone, so do not iterate
   // them after the atoms heap after it has been "finished."
   if (trc->runtime()->atomsAreFinished()) {
     return;
   }
 
   Zone* zone = trc->runtime()->atomsZone(access);
   for (auto i = zone->cellIterUnsafe<JitCode>(); !i.done(); i.next()) {
     JitCode* code = i;
     TraceRoot(trc, &code, "wrapper");
   }
 }
 
-/* static */ void JitRuntime::TraceJitcodeGlobalTableForMinorGC(JSTracer* trc) {
+/* static */
+void JitRuntime::TraceJitcodeGlobalTableForMinorGC(JSTracer* trc) {
   if (trc->runtime()->geckoProfiler().enabled() &&
       trc->runtime()->hasJitRuntime() &&
       trc->runtime()->jitRuntime()->hasJitcodeGlobalTable()) {
     trc->runtime()->jitRuntime()->getJitcodeGlobalTable()->traceForMinorGC(trc);
   }
 }
 
-/* static */ bool JitRuntime::MarkJitcodeGlobalTableIteratively(
-    GCMarker* marker) {
+/* static */
+bool JitRuntime::MarkJitcodeGlobalTableIteratively(GCMarker* marker) {
   if (marker->runtime()->hasJitRuntime() &&
       marker->runtime()->jitRuntime()->hasJitcodeGlobalTable()) {
     return marker->runtime()
         ->jitRuntime()
         ->getJitcodeGlobalTable()
         ->markIteratively(marker);
   }
   return false;
 }
 
-/* static */ void JitRuntime::SweepJitcodeGlobalTable(JSRuntime* rt) {
+/* static */
+void JitRuntime::SweepJitcodeGlobalTable(JSRuntime* rt) {
   if (rt->hasJitRuntime() && rt->jitRuntime()->hasJitcodeGlobalTable()) {
     rt->jitRuntime()->getJitcodeGlobalTable()->sweep(rt);
   }
 }
 
 void JitRealm::sweep(JS::Realm* realm) {
   // Any outstanding compilations should have been cancelled by the GC.
   MOZ_ASSERT(!HasOffThreadIonCompile(realm));
@@ -899,17 +901,18 @@ void IonScript::trace(JSTracer* trc) {
   }
 
   // Trace caches so that the JSScript pointer can be updated if moved.
   for (size_t i = 0; i < numICs(); i++) {
     getICFromIndex(i).trace(trc);
   }
 }
 
-/* static */ void IonScript::writeBarrierPre(Zone* zone, IonScript* ionScript) {
+/* static */
+void IonScript::writeBarrierPre(Zone* zone, IonScript* ionScript) {
   if (zone->needsIncrementalBarrier()) {
     ionScript->trace(zone->barrierTracer());
   }
 }
 
 void IonScript::copySnapshots(const SnapshotWriter* writer) {
   MOZ_ASSERT(writer->listSize() == snapshotsListSize_);
   memcpy((uint8_t*)this + snapshots_, writer->listBuffer(), snapshotsListSize_);
--- a/js/src/jit/IonIC.cpp
+++ b/js/src/jit/IonIC.cpp
@@ -110,21 +110,20 @@ void IonIC::trace(JSTracer* trc) {
     TraceCacheIRStub(trc, stub, stub->stubInfo());
 
     nextCodeRaw = stub->nextCodeRaw();
   }
 
   MOZ_ASSERT(nextCodeRaw == fallbackLabel_.raw());
 }
 
-/* static */ bool IonGetPropertyIC::update(JSContext* cx,
-                                           HandleScript outerScript,
-                                           IonGetPropertyIC* ic,
-                                           HandleValue val, HandleValue idVal,
-                                           MutableHandleValue res) {
+/* static */
+bool IonGetPropertyIC::update(JSContext* cx, HandleScript outerScript,
+                              IonGetPropertyIC* ic, HandleValue val,
+                              HandleValue idVal, MutableHandleValue res) {
   // Override the return value if we are invalidated (bug 728188).
   IonScript* ionScript = outerScript->ionScript();
   AutoDetectInvalidation adi(cx, res, ionScript);
 
   // If the IC is idempotent, we will redo the op in the interpreter.
   if (ic->idempotent()) {
     adi.disable();
   }
@@ -194,20 +193,21 @@ void IonIC::trace(JSTracer* trc) {
     if (!ic->monitoredResult()) {
       TypeScript::Monitor(cx, ic->script(), ic->pc(), res);
     }
   }
 
   return true;
 }
 
-/* static */ bool IonGetPropSuperIC::update(
-    JSContext* cx, HandleScript outerScript, IonGetPropSuperIC* ic,
-    HandleObject obj, HandleValue receiver, HandleValue idVal,
-    MutableHandleValue res) {
+/* static */
+bool IonGetPropSuperIC::update(JSContext* cx, HandleScript outerScript,
+                               IonGetPropSuperIC* ic, HandleObject obj,
+                               HandleValue receiver, HandleValue idVal,
+                               MutableHandleValue res) {
   // Override the return value if we are invalidated (bug 728188).
   IonScript* ionScript = outerScript->ionScript();
   AutoDetectInvalidation adi(cx, res, ionScript);
 
   if (ic->state().maybeTransition()) {
     ic->discardStubs(cx->zone());
   }
 
@@ -237,21 +237,20 @@ void IonIC::trace(JSTracer* trc) {
     return false;
   }
 
   // Monitor changes to cache entry.
   TypeScript::Monitor(cx, ic->script(), ic->pc(), res);
   return true;
 }
 
-/* static */ bool IonSetPropertyIC::update(JSContext* cx,
-                                           HandleScript outerScript,
-                                           IonSetPropertyIC* ic,
-                                           HandleObject obj, HandleValue idVal,
-                                           HandleValue rhs) {
+/* static */
+bool IonSetPropertyIC::update(JSContext* cx, HandleScript outerScript,
+                              IonSetPropertyIC* ic, HandleObject obj,
+                              HandleValue idVal, HandleValue rhs) {
   RootedShape oldShape(cx);
   RootedObjectGroup oldGroup(cx);
   IonScript* ionScript = outerScript->ionScript();
 
   bool attached = false;
   bool isTemporarilyUnoptimizable = false;
   bool canAddSlot = false;
 
@@ -379,19 +378,20 @@ static void TryAttachIonStub(JSContext* 
                             &attached);
     }
     if (!attached) {
       ic->state().trackNotAttached();
     }
   }
 }
 
-/* static */ bool IonGetNameIC::update(JSContext* cx, HandleScript outerScript,
-                                       IonGetNameIC* ic, HandleObject envChain,
-                                       MutableHandleValue res) {
+/* static */
+bool IonGetNameIC::update(JSContext* cx, HandleScript outerScript,
+                          IonGetNameIC* ic, HandleObject envChain,
+                          MutableHandleValue res) {
   IonScript* ionScript = outerScript->ionScript();
   jsbytecode* pc = ic->pc();
   RootedPropertyName name(cx, ic->script()->getName(pc));
 
   TryAttachIonStub<GetNameIRGenerator, IonGetNameIC>(cx, ic, ionScript,
                                                      envChain, name);
 
   RootedObject obj(cx);
@@ -412,91 +412,90 @@ static void TryAttachIonStub(JSContext* 
   }
 
   // No need to call TypeScript::Monitor, IonBuilder always inserts a type
   // barrier after GetName ICs.
 
   return true;
 }
 
-/* static */ JSObject* IonBindNameIC::update(JSContext* cx,
-                                             HandleScript outerScript,
-                                             IonBindNameIC* ic,
-                                             HandleObject envChain) {
+/* static */
+JSObject* IonBindNameIC::update(JSContext* cx, HandleScript outerScript,
+                                IonBindNameIC* ic, HandleObject envChain) {
   IonScript* ionScript = outerScript->ionScript();
   jsbytecode* pc = ic->pc();
   RootedPropertyName name(cx, ic->script()->getName(pc));
 
   TryAttachIonStub<BindNameIRGenerator, IonBindNameIC>(cx, ic, ionScript,
                                                        envChain, name);
 
   RootedObject holder(cx);
   if (!LookupNameUnqualified(cx, name, envChain, &holder)) {
     return nullptr;
   }
 
   return holder;
 }
 
-/* static */ JSObject* IonGetIteratorIC::update(JSContext* cx,
-                                                HandleScript outerScript,
-                                                IonGetIteratorIC* ic,
-                                                HandleValue value) {
+/* static */
+JSObject* IonGetIteratorIC::update(JSContext* cx, HandleScript outerScript,
+                                   IonGetIteratorIC* ic, HandleValue value) {
   IonScript* ionScript = outerScript->ionScript();
 
   TryAttachIonStub<GetIteratorIRGenerator, IonGetIteratorIC>(cx, ic, ionScript,
                                                              value);
 
   return ValueToIterator(cx, value);
 }
 
-/* static */ bool IonHasOwnIC::update(JSContext* cx, HandleScript outerScript,
-                                      IonHasOwnIC* ic, HandleValue val,
-                                      HandleValue idVal, int32_t* res) {
+/* static */
+bool IonHasOwnIC::update(JSContext* cx, HandleScript outerScript,
+                         IonHasOwnIC* ic, HandleValue val, HandleValue idVal,
+                         int32_t* res) {
   IonScript* ionScript = outerScript->ionScript();
 
   TryAttachIonStub<HasPropIRGenerator, IonHasOwnIC>(
       cx, ic, ionScript, CacheKind::HasOwn, idVal, val);
 
   bool found;
   if (!HasOwnProperty(cx, val, idVal, &found)) {
     return false;
   }
 
   *res = found;
   return true;
 }
 
-/* static */ bool IonInIC::update(JSContext* cx, HandleScript outerScript,
-                                  IonInIC* ic, HandleValue key,
-                                  HandleObject obj, bool* res) {
+/* static */
+bool IonInIC::update(JSContext* cx, HandleScript outerScript, IonInIC* ic,
+                     HandleValue key, HandleObject obj, bool* res) {
   IonScript* ionScript = outerScript->ionScript();
   RootedValue objV(cx, ObjectValue(*obj));
 
   TryAttachIonStub<HasPropIRGenerator, IonInIC>(cx, ic, ionScript,
                                                 CacheKind::In, key, objV);
 
   return OperatorIn(cx, key, obj, res);
 }
-/* static */ bool IonInstanceOfIC::update(JSContext* cx,
-                                          HandleScript outerScript,
-                                          IonInstanceOfIC* ic, HandleValue lhs,
-                                          HandleObject rhs, bool* res) {
+/* static */
+bool IonInstanceOfIC::update(JSContext* cx, HandleScript outerScript,
+                             IonInstanceOfIC* ic, HandleValue lhs,
+                             HandleObject rhs, bool* res) {
   IonScript* ionScript = outerScript->ionScript();
 
   TryAttachIonStub<InstanceOfIRGenerator, IonInstanceOfIC>(cx, ic, ionScript,
                                                            lhs, rhs);
 
   return HasInstance(cx, rhs, lhs, res);
 }
 
-/*  static */ bool IonUnaryArithIC::update(JSContext* cx,
-                                           HandleScript outerScript,
-                                           IonUnaryArithIC* ic, HandleValue val,
-                                           MutableHandleValue res) {
+/*  static */
+bool IonUnaryArithIC::update(JSContext* cx, HandleScript outerScript,
+                             IonUnaryArithIC* ic, HandleValue val,
+                             MutableHandleValue res) {
   IonScript* ionScript = outerScript->ionScript();
   RootedScript script(cx, ic->script());
   jsbytecode* pc = ic->pc();
   JSOp op = JSOp(*pc);
 
   // The unary operations take a copied val because the original value is needed
   // below.
   RootedValue valCopy(cx, val);
@@ -530,21 +529,20 @@ static void TryAttachIonStub(JSContext* 
   }
 
   TryAttachIonStub<UnaryArithIRGenerator, IonUnaryArithIC>(cx, ic, ionScript,
                                                            op, val, res);
 
   return true;
 }
 
-/* static */ bool IonBinaryArithIC::update(JSContext* cx,
-                                           HandleScript outerScript,
-                                           IonBinaryArithIC* ic,
-                                           HandleValue lhs, HandleValue rhs,
-                                           MutableHandleValue ret) {
+/* static */
+bool IonBinaryArithIC::update(JSContext* cx, HandleScript outerScript,
+                              IonBinaryArithIC* ic, HandleValue lhs,
+                              HandleValue rhs, MutableHandleValue ret) {
   IonScript* ionScript = outerScript->ionScript();
   RootedScript script(cx, ic->script());
   jsbytecode* pc = ic->pc();
   JSOp op = JSOp(*pc);
 
   // Don't pass lhs/rhs directly, we need the original values when
   // generating stubs.
   RootedValue lhsCopy(cx, lhs);
@@ -601,19 +599,20 @@ static void TryAttachIonStub(JSContext* 
   }
 
   TryAttachIonStub<BinaryArithIRGenerator, IonBinaryArithIC>(cx, ic, ionScript,
                                                              op, lhs, rhs, ret);
 
   return true;
 }
 
-/* static */ bool IonCompareIC::update(JSContext* cx, HandleScript outerScript,
-                                       IonCompareIC* ic, HandleValue lhs,
-                                       HandleValue rhs, bool* res) {
+/* static */
+bool IonCompareIC::update(JSContext* cx, HandleScript outerScript,
+                          IonCompareIC* ic, HandleValue lhs, HandleValue rhs,
+                          bool* res) {
   IonScript* ionScript = outerScript->ionScript();
   RootedScript script(cx, ic->script());
   jsbytecode* pc = ic->pc();
   JSOp op = JSOp(*pc);
 
   // Don't pass lhs/rhs directly, we need the original values when
   // generating stubs.
   RootedValue lhsCopy(cx, lhs);
--- a/js/src/jit/JitcodeMap.cpp
+++ b/js/src/jit/JitcodeMap.cpp
@@ -240,18 +240,19 @@ static int ComparePointers(const void* a
     return -1;
   }
   if (a_ptr > b_ptr) {
     return 1;
   }
   return 0;
 }
 
-/* static */ int JitcodeGlobalEntry::compare(const JitcodeGlobalEntry& ent1,
-                                             const JitcodeGlobalEntry& ent2) {
+/* static */
+int JitcodeGlobalEntry::compare(const JitcodeGlobalEntry& ent1,
+                                const JitcodeGlobalEntry& ent2) {
   // Both parts of compare cannot be a query.
   MOZ_ASSERT(!(ent1.isQuery() && ent2.isQuery()));
 
   // Ensure no overlaps for non-query lookups.
   MOZ_ASSERT_IF(!ent1.isQuery() && !ent2.isQuery(), !ent1.overlapsWith(ent2));
 
   // For two non-query entries, just comapare the start addresses.
   if (!ent1.isQuery() && !ent2.isQuery()) {
@@ -270,19 +271,19 @@ static int ComparePointers(const void* a
     // query ptr > entry
     return flip * 1;
   }
 
   // query ptr < entry
   return flip * -1;
 }
 
-/* static */ char* JitcodeGlobalEntry::createScriptString(JSContext* cx,
-                                                          JSScript* script,
-                                                          size_t* length) {
+/* static */
+char* JitcodeGlobalEntry::createScriptString(JSContext* cx, JSScript* script,
+                                             size_t* length) {
   // If the script has a function, try calculating its name.
   bool hasName = false;
   size_t nameLength = 0;
   UniqueChars nameStr;
   JSFunction* func = script->functionDelazifying();
   if (func && func->displayAtom()) {
     nameStr = StringToNewUTF8CharsZ(cx, *func->displayAtom());
     if (!nameStr) {
@@ -1002,47 +1003,48 @@ void JitcodeGlobalEntry::IonCacheEntry::
     IonTrackedOptimizationsTypeInfo::ForEachOpAdapter& op) {
   JitcodeGlobalEntry& entry = RejoinEntry(rt, *this, nativeStartAddr());
   if (!entry.hasTrackedOptimizations()) {
     return;
   }
   entry.forEachOptimizationTypeInfo(rt, index, op);
 }
 
-/* static */ void JitcodeRegionEntry::WriteHead(CompactBufferWriter& writer,
-                                                uint32_t nativeOffset,
-                                                uint8_t scriptDepth) {
+/* static */
+void JitcodeRegionEntry::WriteHead(CompactBufferWriter& writer,
+                                   uint32_t nativeOffset, uint8_t scriptDepth) {
   writer.writeUnsigned(nativeOffset);
   writer.writeByte(scriptDepth);
 }
 
-/* static */ void JitcodeRegionEntry::ReadHead(CompactBufferReader& reader,
-                                               uint32_t* nativeOffset,
-                                               uint8_t* scriptDepth) {
+/* static */
+void JitcodeRegionEntry::ReadHead(CompactBufferReader& reader,
+                                  uint32_t* nativeOffset,
+                                  uint8_t* scriptDepth) {
   *nativeOffset = reader.readUnsigned();
   *scriptDepth = reader.readByte();
 }
 
-/* static */ void JitcodeRegionEntry::WriteScriptPc(CompactBufferWriter& writer,
-                                                    uint32_t scriptIdx,
-                                                    uint32_t pcOffset) {
+/* static */
+void JitcodeRegionEntry::WriteScriptPc(CompactBufferWriter& writer,
+                                       uint32_t scriptIdx, uint32_t pcOffset) {
   writer.writeUnsigned(scriptIdx);
   writer.writeUnsigned(pcOffset);
 }
 
-/* static */ void JitcodeRegionEntry::ReadScriptPc(CompactBufferReader& reader,
-                                                   uint32_t* scriptIdx,
-                                                   uint32_t* pcOffset) {
+/* static */
+void JitcodeRegionEntry::ReadScriptPc(CompactBufferReader& reader,
+                                      uint32_t* scriptIdx, uint32_t* pcOffset) {
   *scriptIdx = reader.readUnsigned();
   *pcOffset = reader.readUnsigned();
 }
 
-/* static */ void JitcodeRegionEntry::WriteDelta(CompactBufferWriter& writer,
-                                                 uint32_t nativeDelta,
-                                                 int32_t pcDelta) {
+/* static */
+void JitcodeRegionEntry::WriteDelta(CompactBufferWriter& writer,
+                                    uint32_t nativeDelta, int32_t pcDelta) {
   if (pcDelta >= 0) {
     // 1 and 2-byte formats possible.
 
     //  NNNN-BBB0
     if (pcDelta <= ENC1_PC_DELTA_MAX && nativeDelta <= ENC1_NATIVE_DELTA_MAX) {
       uint8_t encVal = ENC1_MASK_VAL | (pcDelta << ENC1_PC_DELTA_SHIFT) |
                        (nativeDelta << ENC1_NATIVE_DELTA_SHIFT);
       writer.writeByte(encVal);
@@ -1085,19 +1087,19 @@ void JitcodeGlobalEntry::IonCacheEntry::
     writer.writeByte((encVal >> 24) & 0xff);
     return;
   }
 
   // Should never get here.
   MOZ_CRASH("pcDelta/nativeDelta values are too large to encode.");
 }
 
-/* static */ void JitcodeRegionEntry::ReadDelta(CompactBufferReader& reader,
-                                                uint32_t* nativeDelta,
-                                                int32_t* pcDelta) {
+/* static */
+void JitcodeRegionEntry::ReadDelta(CompactBufferReader& reader,
+                                   uint32_t* nativeDelta, int32_t* pcDelta) {
   // NB:
   // It's possible to get nativeDeltas with value 0 in two cases:
   //
   // 1. The last region's run.  This is because the region table's start
   // must be 4-byte aligned, and we must insert padding bytes to align the
   // payload section before emitting the table.
   //
   // 2. A zero-offset nativeDelta with a negative pcDelta.
@@ -1155,18 +1157,19 @@ void JitcodeGlobalEntry::IonCacheEntry::
     pcDeltaU |= ~ENC4_PC_DELTA_MAX;
   }
   *pcDelta = pcDeltaU;
 
   MOZ_ASSERT(*pcDelta != 0);
   MOZ_ASSERT_IF(*nativeDelta == 0, *pcDelta <= 0);
 }
 
-/* static */ uint32_t JitcodeRegionEntry::ExpectedRunLength(
-    const NativeToBytecode* entry, const NativeToBytecode* end) {
+/* static */
+uint32_t JitcodeRegionEntry::ExpectedRunLength(const NativeToBytecode* entry,
+                                               const NativeToBytecode* end) {
   MOZ_ASSERT(entry < end);
 
   // We always use the first entry, so runLength starts at 1
   uint32_t runLength = 1;
 
   uint32_t curNativeOffset = entry->nativeOffset.offset();
   uint32_t curBytecodeOffset = entry->tree->script()->pcToOffset(entry->pc);
 
@@ -1246,21 +1249,21 @@ struct JitcodeMapBufferWriteSpewer {
 #else   // !JS_JITSPEW
   explicit JitcodeMapBufferWriteSpewer(CompactBufferWriter& w) {}
   void spewAndAdvance(const char* name) {}
 #endif  // JS_JITSPEW
 };
 
 // Write a run, starting at the given NativeToBytecode entry, into the given
 // buffer writer.
-/* static */ bool JitcodeRegionEntry::WriteRun(CompactBufferWriter& writer,
-                                               JSScript** scriptList,
-                                               uint32_t scriptListSize,
-                                               uint32_t runLength,
-                                               const NativeToBytecode* entry) {
+/* static */
+bool JitcodeRegionEntry::WriteRun(CompactBufferWriter& writer,
+                                  JSScript** scriptList,
+                                  uint32_t scriptListSize, uint32_t runLength,
+                                  const NativeToBytecode* entry) {
   MOZ_ASSERT(runLength > 0);
   MOZ_ASSERT(runLength <= MAX_RUN_LENGTH);
 
   // Calculate script depth.
   MOZ_ASSERT(entry->tree->depth() <= 0xff);
   uint8_t scriptDepth = entry->tree->depth();
   uint32_t regionNativeOffset = entry->nativeOffset.offset();
 
@@ -1490,17 +1493,18 @@ uint32_t JitcodeIonTable::findRegionEntr
       // Target entry is at midEntry or above.
       idx = mid;
       count -= step;
     }
   }
   return idx;
 }
 
-/* static */ bool JitcodeIonTable::WriteIonTable(
+/* static */
+bool JitcodeIonTable::WriteIonTable(
     CompactBufferWriter& writer, JSScript** scriptList, uint32_t scriptListSize,
     const NativeToBytecode* start, const NativeToBytecode* end,
     uint32_t* tableOffsetOut, uint32_t* numRegionsOut) {
   MOZ_ASSERT(tableOffsetOut != nullptr);
   MOZ_ASSERT(numRegionsOut != nullptr);
   MOZ_ASSERT(writer.length() == 0);
   MOZ_ASSERT(scriptListSize > 0);
 
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -3390,18 +3390,19 @@ static inline bool MustBeUInt32(MDefinit
     *pwrapped = defConst;
     return defConst->type() == MIRType::Int32 && defConst->toInt32() >= 0;
   }
 
   *pwrapped = nullptr;  // silence GCC warning
   return false;
 }
 
-/* static */ bool MBinaryInstruction::unsignedOperands(MDefinition* left,
-                                                       MDefinition* right) {
+/* static */
+bool MBinaryInstruction::unsignedOperands(MDefinition* left,
+                                          MDefinition* right) {
   MDefinition* replace;
   if (!MustBeUInt32(left, &replace)) {
     return false;
   }
   if (replace->type() != MIRType::Int32) {
     return false;
   }
   if (!MustBeUInt32(right, &replace)) {
--- a/js/src/jit/OptimizationTracking.cpp
+++ b/js/src/jit/OptimizationTracking.cpp
@@ -200,28 +200,29 @@ HashNumber OptimizationTypeInfo::hash() 
 template <class Vec>
 static HashNumber HashVectorContents(const Vec* xs, HashNumber h) {
   for (auto x = xs->begin(); x != xs->end(); x++) {
     h = CombineHash(h, x->hash());
   }
   return h;
 }
 
-/* static */ HashNumber UniqueTrackedOptimizations::Key::hash(
-    const Lookup& lookup) {
+/* static */
+HashNumber UniqueTrackedOptimizations::Key::hash(const Lookup& lookup) {
   HashNumber h = HashVectorContents(lookup.types, 0);
   h = HashVectorContents(lookup.attempts, h);
   h += (h << 3);
   h ^= (h >> 11);
   h += (h << 15);
   return h;
 }
 
-/* static */ bool UniqueTrackedOptimizations::Key::match(const Key& key,
-                                                         const Lookup& lookup) {
+/* static */
+bool UniqueTrackedOptimizations::Key::match(const Key& key,
+                                            const Lookup& lookup) {
   return VectorContentsMatch(key.attempts, lookup.attempts) &&
          VectorContentsMatch(key.types, lookup.types);
 }
 
 bool UniqueTrackedOptimizations::add(
     const TrackedOptimizations* optimizations) {
   MOZ_ASSERT(!sorted());
   Key key;
@@ -521,17 +522,18 @@ IonTrackedOptimizationsRegionTable::find
     } else {
       // Entry is in mid.
       return Some(entry(i));
     }
   }
   return Nothing();
 }
 
-/* static */ uint32_t IonTrackedOptimizationsRegion::ExpectedRunLength(
+/* static */
+uint32_t IonTrackedOptimizationsRegion::ExpectedRunLength(
     const NativeToTrackedOptimizations* start,
     const NativeToTrackedOptimizations* end) {
   MOZ_ASSERT(start < end);
 
   // A run always has at least 1 entry, which is not delta encoded.
   uint32_t runLength = 1;
   uint32_t prevEndOffset = start->endOffset.offset();
 
@@ -572,19 +574,21 @@ bool OptimizationTypeInfo::writeCompact(
     if (!uniqueTypes.getIndexOf(types_[i], &index)) {
       return false;
     }
     writer.writeByte(index);
   }
   return true;
 }
 
-/* static */ void IonTrackedOptimizationsRegion::ReadDelta(
-    CompactBufferReader& reader, uint32_t* startDelta, uint32_t* length,
-    uint8_t* index) {
+/* static */
+void IonTrackedOptimizationsRegion::ReadDelta(CompactBufferReader& reader,
+                                              uint32_t* startDelta,
+                                              uint32_t* length,
+                                              uint8_t* index) {
   // 2 bytes
   // SSSS-SSSL LLLL-LII0
   const uint32_t firstByte = reader.readByte();
   const uint32_t secondByte = reader.readByte();
   if ((firstByte & ENC1_MASK) == ENC1_MASK_VAL) {
     uint32_t encVal = firstByte | secondByte << 8;
     *startDelta = encVal >> ENC1_START_DELTA_SHIFT;
     *length = (encVal >> ENC1_LENGTH_SHIFT) & ENC1_LENGTH_MAX;
@@ -625,19 +629,20 @@ bool OptimizationTypeInfo::writeCompact(
   uint64_t encVal = firstByte | secondByte << 8 | thirdByte << 16 |
                     fourthByte << 24 | fifthByte << 32;
   *startDelta = encVal >> ENC4_START_DELTA_SHIFT;
   *length = (encVal >> ENC4_LENGTH_SHIFT) & ENC4_LENGTH_MAX;
   *index = (encVal >> ENC4_INDEX_SHIFT) & ENC4_INDEX_MAX;
   MOZ_ASSERT(length != 0);
 }
 
-/* static */ void IonTrackedOptimizationsRegion::WriteDelta(
-    CompactBufferWriter& writer, uint32_t startDelta, uint32_t length,
-    uint8_t index) {
+/* static */
+void IonTrackedOptimizationsRegion::WriteDelta(CompactBufferWriter& writer,
+                                               uint32_t startDelta,
+                                               uint32_t length, uint8_t index) {
   // 2 bytes
   // SSSS-SSSL LLLL-LII0
   if (startDelta <= ENC1_START_DELTA_MAX && length <= ENC1_LENGTH_MAX &&
       index <= ENC1_INDEX_MAX) {
     uint16_t val = ENC1_MASK_VAL | (startDelta << ENC1_START_DELTA_SHIFT) |
                    (length << ENC1_LENGTH_SHIFT) | (index << ENC1_INDEX_SHIFT);
     writer.writeByte(val & 0xff);
     writer.writeByte((val >> 8) & 0xff);
@@ -687,17 +692,18 @@ bool OptimizationTypeInfo::writeCompact(
     writer.writeByte((val >> 24) & 0xff);
     writer.writeByte((val >> 32) & 0xff);
     return;
   }
 
   MOZ_CRASH("startDelta,length,index triple too large to encode.");
 }
 
-/* static */ bool IonTrackedOptimizationsRegion::WriteRun(
+/* static */
+bool IonTrackedOptimizationsRegion::WriteRun(
     CompactBufferWriter& writer, const NativeToTrackedOptimizations* start,
     const NativeToTrackedOptimizations* end,
     const UniqueTrackedOptimizations& unique) {
   // Write the header, which is the range that this whole run encompasses.
   JitSpew(JitSpew_OptimizationTrackingExtended, "     Header: [%zu, %zu]",
           start->startOffset.offset(), (end - 1)->endOffset.offset());
   writer.writeUnsigned(start->startOffset.offset());
   writer.writeUnsigned((end - 1)->endOffset.offset());
--- a/js/src/jit/RematerializedFrame.cpp
+++ b/js/src/jit/RematerializedFrame.cpp
@@ -50,19 +50,20 @@ RematerializedFrame::RematerializedFrame
   }
 
   CopyValueToRematerializedFrame op(slots_);
   iter.readFrameArgsAndLocals(cx, op, op, &envChain_, &hasInitialEnv_,
                               &returnValue_, &argsObj_, &thisArgument_,
                               &newTarget_, ReadFrame_Actuals, fallback);
 }
 
-/* static */ RematerializedFrame* RematerializedFrame::New(
-    JSContext* cx, uint8_t* top, InlineFrameIterator& iter,
-    MaybeReadFallback& fallback) {
+/* static */
+RematerializedFrame* RematerializedFrame::New(JSContext* cx, uint8_t* top,
+                                              InlineFrameIterator& iter,
+                                              MaybeReadFallback& fallback) {
   unsigned numFormals =
       iter.isFunctionFrame() ? iter.calleeTemplate()->nargs() : 0;
   unsigned argSlots = Max(numFormals, iter.numActualArgs());
   unsigned extraSlots = argSlots + iter.script()->nfixed();
 
   // One Value slot is included in sizeof(RematerializedFrame), so we can
   // reduce the extra slot count by one.  However, if there are zero slot
   // allocations total, then reducing the slots by one will lead to
@@ -76,17 +77,18 @@ RematerializedFrame::RematerializedFrame
   if (!buf) {
     return nullptr;
   }
 
   return new (buf)
       RematerializedFrame(cx, top, iter.numActualArgs(), iter, fallback);
 }
 
-/* static */ bool RematerializedFrame::RematerializeInlineFrames(
+/* static */
+bool RematerializedFrame::RematerializeInlineFrames(
     JSContext* cx, uint8_t* top, InlineFrameIterator& iter,
     MaybeReadFallback& fallback, GCVector<RematerializedFrame*>& frames) {
   Rooted<GCVector<RematerializedFrame*>> tempFrames(
       cx, GCVector<RematerializedFrame*>(cx));
   if (!tempFrames.resize(iter.frameCount())) {
     return false;
   }
 
@@ -107,18 +109,18 @@ RematerializedFrame::RematerializedFrame
     }
     ++iter;
   }
 
   frames = std::move(tempFrames.get());
   return true;
 }
 
-/* static */ void RematerializedFrame::FreeInVector(
-    GCVector<RematerializedFrame*>& frames) {
+/* static */
+void RematerializedFrame::FreeInVector(GCVector<RematerializedFrame*>& frames) {
   for (size_t i = 0; i < frames.length(); i++) {
     RematerializedFrame* f = frames[i];
     MOZ_ASSERT(!Debugger::inFrameMaps(f));
     f->RematerializedFrame::~RematerializedFrame();
     js_free(f);
   }
   frames.clear();
 }
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -141,17 +141,18 @@ bool JitRuntime::generateVMWrappers(JSCo
     MOZ_ASSERT(functionWrapperOffsets_.length() == size_t(id));
     functionWrapperOffsets_.infallibleAppend(offset);
   }
 
   return true;
 }
 
 // Statics are initialized to null.
-/* static */ VMFunction* VMFunction::functions;
+/* static */
+VMFunction* VMFunction::functions;
 
 AutoDetectInvalidation::AutoDetectInvalidation(JSContext* cx,
                                                MutableHandleValue rval)
     : cx_(cx),
       ionScript_(GetTopJitJSScript(cx)->ionScript()),
       rval_(rval),
       disabled_(false) {}
 
--- a/js/src/jit/arm/Assembler-arm.cpp
+++ b/js/src/jit/arm/Assembler-arm.cpp
@@ -736,18 +736,19 @@ static void TraceOneDataRelocation(JSTra
     // L_LDR won't cause any instructions to be updated.
     if (rs != Assembler::L_LDR) {
       AutoFlushICache::flush(uintptr_t(iter.cur()), 4);
       AutoFlushICache::flush(uintptr_t(iter.next()), 4);
     }
   }
 }
 
-/* static */ void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
-                                                  CompactBufferReader& reader) {
+/* static */
+void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
+                                     CompactBufferReader& reader) {
   while (reader.more()) {
     size_t offset = reader.readUnsigned();
     InstructionIterator iter((Instruction*)(code->raw() + offset));
     TraceOneDataRelocation(trc, iter);
   }
 }
 
 void Assembler::copyJumpRelocationTable(uint8_t* dest) {
@@ -1068,17 +1069,18 @@ O2RegRegShift jit::ror(Register r, Regis
 }
 
 O2RegRegShift jit::asr(Register r, Register amt) {
   return O2RegRegShift(r, ASR, amt);
 }
 
 static js::jit::DoubleEncoder doubleEncoder;
 
-/* static */ const js::jit::VFPImm js::jit::VFPImm::One(0x3FF00000);
+/* static */
+const js::jit::VFPImm js::jit::VFPImm::One(0x3FF00000);
 
 js::jit::VFPImm::VFPImm(uint32_t top) {
   data_ = -1;
   datastore::Imm8VFPImmData tmp;
   if (doubleEncoder.lookup(top, &tmp)) {
     data_ = tmp.encode();
   }
 }
@@ -1206,24 +1208,25 @@ BufferOffset Assembler::as_alu(Register 
   return writeInst(EncodeAlu(dest, src1, op2, op, s, c));
 }
 
 BufferOffset Assembler::as_mov(Register dest, Operand2 op2, SBit s,
                                Condition c) {
   return as_alu(dest, InvalidReg, op2, OpMov, s, c);
 }
 
-/* static */ void Assembler::as_alu_patch(Register dest, Register src1,
-                                          Operand2 op2, ALUOp op, SBit s,
-                                          Condition c, uint32_t* pos) {
+/* static */
+void Assembler::as_alu_patch(Register dest, Register src1, Operand2 op2,
+                             ALUOp op, SBit s, Condition c, uint32_t* pos) {
   WriteInstStatic(EncodeAlu(dest, src1, op2, op, s, c), pos);
 }
 
-/* static */ void Assembler::as_mov_patch(Register dest, Operand2 op2, SBit s,
-                                          Condition c, uint32_t* pos) {
+/* static */
+void Assembler::as_mov_patch(Register dest, Operand2 op2, SBit s, Condition c,
+                             uint32_t* pos) {
   as_alu_patch(dest, InvalidReg, op2, OpMov, s, c, pos);
 }
 
 BufferOffset Assembler::as_mvn(Register dest, Operand2 op2, SBit s,
                                Condition c) {
   return as_alu(dest, InvalidReg, op2, OpMvn, s, c);
 }
 
@@ -1330,27 +1333,29 @@ static uint32_t EncodeMovT(Register dest
 
 // Not quite ALU worthy, but these are useful none the less. These also have
 // the isue of these being formatted completly differently from the standard ALU
 // operations.
 BufferOffset Assembler::as_movw(Register dest, Imm16 imm, Condition c) {
   return writeInst(EncodeMovW(dest, imm, c));
 }
 
-/* static */ void Assembler::as_movw_patch(Register dest, Imm16 imm,
-                                           Condition c, Instruction* pos) {
+/* static */
+void Assembler::as_movw_patch(Register dest, Imm16 imm, Condition c,
+                              Instruction* pos) {
   WriteInstStatic(EncodeMovW(dest, imm, c), (uint32_t*)pos);
 }
 
 BufferOffset Assembler::as_movt(Register dest, Imm16 imm, Condition c) {
   return writeInst(EncodeMovT(dest, imm, c));
 }
 
-/* static */ void Assembler::as_movt_patch(Register dest, Imm16 imm,
-                                           Condition c, Instruction* pos) {
+/* static */
+void Assembler::as_movt_patch(Register dest, Imm16 imm, Condition c,
+                              Instruction* pos) {
   WriteInstStatic(EncodeMovT(dest, imm, c), (uint32_t*)pos);
 }
 
 static const int mull_tag = 0x90;
 
 BufferOffset Assembler::as_genmul(Register dhi, Register dlo, Register rm,
                                   Register rn, MULOp op, SBit s, Condition c) {
   return writeInst(RN(dhi) | maybeRD(dlo) | RM(rm) | rn.code() | op | s | c |
@@ -1423,19 +1428,19 @@ static uint32_t EncodeDtr(LoadStore ls, 
          addr.encode();
 }
 
 BufferOffset Assembler::as_dtr(LoadStore ls, int size, Index mode, Register rt,
                                DTRAddr addr, Condition c) {
   return writeInst(EncodeDtr(ls, size, mode, rt, addr, c));
 }
 
-/* static */ void Assembler::as_dtr_patch(LoadStore ls, int size, Index mode,
-                                          Register rt, DTRAddr addr,
-                                          Condition c, uint32_t* dest) {
+/* static */
+void Assembler::as_dtr_patch(LoadStore ls, int size, Index mode, Register rt,
+                             DTRAddr addr, Condition c, uint32_t* dest) {
   WriteInstStatic(EncodeDtr(ls, size, mode, rt, addr, c), dest);
 }
 
 class PoolHintData {
  public:
   enum LoadType {
     // Set 0 to bogus, since that is the value most likely to be
     // accidentally left somewhere.
@@ -1589,18 +1594,18 @@ BufferOffset Assembler::as_Imm32Pool(Reg
                                      Condition c) {
   PoolHintPun php;
   php.phd.init(0, c, PoolHintData::PoolDTR, dest);
   BufferOffset offs = allocLiteralLoadEntry(
       1, 1, php, (uint8_t*)&value, LiteralDoc(value), nullptr, dest == pc);
   return offs;
 }
 
-/* static */ void Assembler::WritePoolEntry(Instruction* addr, Condition c,
-                                            uint32_t data) {
+/* static */
+void Assembler::WritePoolEntry(Instruction* addr, Condition c, uint32_t data) {
   MOZ_ASSERT(addr->is<InstLDR>());
   *addr->as<InstLDR>()->dest() = data;
   MOZ_ASSERT(addr->extractCond() == c);
 }
 
 BufferOffset Assembler::as_BranchPool(uint32_t value, RepatchLabel* label,
                                       const LabelDoc& documentation,
                                       ARMBuffer::PoolEntry* pe, Condition c) {
@@ -1949,18 +1954,18 @@ BufferOffset Assembler::as_msr(Register 
 enum vfp_tags { VfpTag = 0x0C000A00, VfpArith = 0x02000000 };
 
 BufferOffset Assembler::writeVFPInst(vfp_size sz, uint32_t blob) {
   MOZ_ASSERT((sz & blob) == 0);
   MOZ_ASSERT((VfpTag & blob) == 0);
   return writeInst(VfpTag | sz | blob);
 }
 
-/* static */ void Assembler::WriteVFPInstStatic(vfp_size sz, uint32_t blob,
-                                                uint32_t* dest) {
+/* static */
+void Assembler::WriteVFPInstStatic(vfp_size sz, uint32_t blob, uint32_t* dest) {
   MOZ_ASSERT((sz & blob) == 0);
   MOZ_ASSERT((VfpTag & blob) == 0);
   WriteInstStatic(VfpTag | sz | blob, dest);
 }
 
 // Unityped variants: all registers hold the same (ieee754 single/double)
 // notably not included are vcvt; vmov vd, #imm; vmov rt, vn.
 BufferOffset Assembler::as_vfp_float(VFPRegister vd, VFPRegister vn,
@@ -2141,19 +2146,19 @@ static uint32_t EncodeVdtr(LoadStore ls,
 
 BufferOffset Assembler::as_vdtr(
     LoadStore ls, VFPRegister vd, VFPAddr addr,
     Condition c /* vfp doesn't have a wb option */) {
   vfp_size sz = vd.isDouble() ? IsDouble : IsSingle;
   return writeVFPInst(sz, EncodeVdtr(ls, vd, addr, c));
 }
 
-/* static */ void Assembler::as_vdtr_patch(LoadStore ls, VFPRegister vd,
-                                           VFPAddr addr, Condition c,
-                                           uint32_t* dest) {
+/* static */
+void Assembler::as_vdtr_patch(LoadStore ls, VFPRegister vd, VFPAddr addr,
+                              Condition c, uint32_t* dest) {
   vfp_size sz = vd.isDouble() ? IsDouble : IsSingle;
   WriteVFPInstStatic(sz, EncodeVdtr(ls, vd, addr, c), dest);
 }
 
 // VFP's ldm/stm work differently from the standard arm ones. You can only
 // transfer a range.
 
 BufferOffset Assembler::as_vdtm(LoadStore st, Register rn, VFPRegister vd,
@@ -2789,18 +2794,19 @@ uint32_t Assembler::GetPoolMaxOffset() {
   return AsmPoolMaxOffset;
 }
 
 SecondScratchRegisterScope::SecondScratchRegisterScope(MacroAssembler& masm)
     : AutoRegisterScope(masm, masm.getSecondScratchReg()) {}
 
 #ifdef JS_DISASM_ARM
 
-/* static */ void Assembler::disassembleInstruction(const Instruction* i,
-                                                    DisasmBuffer& buffer) {
+/* static */
+void Assembler::disassembleInstruction(const Instruction* i,
+                                       DisasmBuffer& buffer) {
   disasm::NameConverter converter;
   disasm::Disassembler dasm(converter);
   uint8_t* loc = reinterpret_cast<uint8_t*>(const_cast<uint32_t*>(i->raw()));
   dasm.InstructionDecode(buffer, loc);
 }
 
 void Assembler::initDisassembler() {
   // The line is normally laid out like this:
--- a/js/src/jit/arm/Simulator-arm.cpp
+++ b/js/src/jit/arm/Simulator-arm.cpp
@@ -1031,17 +1031,18 @@ static void FlushICacheLocked(SimulatorP
     MOZ_ASSERT((start & CachePage::kPageMask) == 0);
     offset = 0;
   }
   if (size != 0) {
     FlushOnePageLocked(i_cache, start, size);
   }
 }
 
-/* static */ void SimulatorProcess::checkICacheLocked(SimInstruction* instr) {
+/* static */
+void SimulatorProcess::checkICacheLocked(SimInstruction* instr) {
   intptr_t address = reinterpret_cast<intptr_t>(instr);
   void* page = reinterpret_cast<void*>(address & (~CachePage::kPageMask));
   void* line = reinterpret_cast<void*>(address & (~CachePage::kLineMask));
   int offset = (address & CachePage::kPageMask);
   CachePage* cache_page = GetCachePageLocked(icache(), page);
   char* cache_valid_byte = cache_page->validityByte(offset);
   bool cache_hit = (*cache_valid_byte == CachePage::LINE_VALID);
   char* cached_line = cache_page->cachedData(offset & ~CachePage::kLineMask);
@@ -1070,17 +1071,18 @@ bool SimulatorProcess::ICacheHasher::mat
   return k == l;
 }
 
 void Simulator::setLastDebuggerInput(char* input) {
   js_free(lastDebuggerInput_);
   lastDebuggerInput_ = input;
 }
 
-/* static */ void SimulatorProcess::FlushICache(void* start_addr, size_t size) {
+/* static */
+void SimulatorProcess::FlushICache(void* start_addr, size_t size) {
   JitSpewCont(JitSpew_CacheFlush, "[%p %zx]", start_addr, size);
   if (!ICacheCheckingDisableCount) {
     AutoLockSimulatorCache als;
     js::jit::FlushICacheLocked(icache(), start_addr, size);
   }
 }
 
 Simulator::Simulator() {
@@ -1236,18 +1238,19 @@ SimulatorProcess::~SimulatorProcess() {
   Redirection* r = redirection_;
   while (r) {
     Redirection* next = r->next_;
     js_delete(r);
     r = next;
   }
 }
 
-/* static */ void* Simulator::RedirectNativeFunction(void* nativeFunction,
-                                                     ABIFunctionType type) {
+/* static */
+void* Simulator::RedirectNativeFunction(void* nativeFunction,
+                                        ABIFunctionType type) {
   Redirection* redirection = Redirection::Get(nativeFunction, type);
   return redirection->addressOfSwiInstruction();
 }
 
 // Sets the register in the architecture state. It will also deal with updating
 // Simulator internal state for special registers such as PC.
 void Simulator::set_register(int reg, int32_t value) {
   MOZ_ASSERT(reg >= 0 && reg < num_registers);
--- a/js/src/jit/arm64/Assembler-arm64.cpp
+++ b/js/src/jit/arm64/Assembler-arm64.cpp
@@ -596,18 +596,19 @@ void Assembler::TraceJumpRelocations(JST
   RelocationIterator iter(reader);
   while (iter.read()) {
     JitCode* child = CodeFromJump(code, code->raw() + iter.offset());
     TraceManuallyBarrieredEdge(trc, &child, "rel32");
     MOZ_ASSERT(child == CodeFromJump(code, code->raw() + iter.offset()));
   }
 }
 
-/* static */ void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
-                                                  CompactBufferReader& reader) {
+/* static */
+void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
+                                     CompactBufferReader& reader) {
   uint8_t* buffer = code->raw();
 
   while (reader.more()) {
     size_t offset = reader.readUnsigned();
     Instruction* load = (Instruction*)&buffer[offset];
 
     // The only valid traceable operation is a 64-bit load to an ARMRegister.
     // Refer to movePatchablePtr() for generation.
--- a/js/src/jit/mips32/Assembler-mips32.cpp
+++ b/js/src/jit/mips32/Assembler-mips32.cpp
@@ -156,18 +156,19 @@ static void TraceOneDataRelocation(JSTra
   TraceManuallyBarrieredGenericPointerEdge(
       trc, reinterpret_cast<gc::Cell**>(&ptr), "ion-masm-ptr");
   if (ptr != prior) {
     AssemblerMIPSShared::UpdateLuiOriValue(inst, inst->next(), uint32_t(ptr));
     AutoFlushICache::flush(uintptr_t(inst), 8);
   }
 }
 
-/* static */ void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
-                                                  CompactBufferReader& reader) {
+/* static */
+void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
+                                     CompactBufferReader& reader) {
   while (reader.more()) {
     size_t offset = reader.readUnsigned();
     Instruction* inst = (Instruction*)(code->raw() + offset);
     TraceOneDataRelocation(trc, inst);
   }
 }
 
 Assembler::Condition Assembler::UnsignedCondition(Condition cond) {
--- a/js/src/jit/mips32/Simulator-mips32.cpp
+++ b/js/src/jit/mips32/Simulator-mips32.cpp
@@ -1109,17 +1109,18 @@ static void FlushICacheLocked(SimulatorP
     MOZ_ASSERT((start & CachePage::kPageMask) == 0);
     offset = 0;
   }
   if (size != 0) {
     FlushOnePageLocked(i_cache, start, size);
   }
 }
 
-/* static */ void SimulatorProcess::checkICacheLocked(SimInstruction* instr) {
+/* static */
+void SimulatorProcess::checkICacheLocked(SimInstruction* instr) {
   intptr_t address = reinterpret_cast<intptr_t>(instr);
   void* page = reinterpret_cast<void*>(address & (~CachePage::kPageMask));
   void* line = reinterpret_cast<void*>(address & (~CachePage::kLineMask));
   int offset = (address & CachePage::kPageMask);
   CachePage* cache_page = GetCachePageLocked(icache(), page);
   char* cache_valid_byte = cache_page->validityByte(offset);
   bool cache_hit = (*cache_valid_byte == CachePage::LINE_VALID);
   char* cached_line = cache_page->cachedData(offset & ~CachePage::kLineMask);
@@ -1142,17 +1143,18 @@ HashNumber SimulatorProcess::ICacheHashe
 }
 
 bool SimulatorProcess::ICacheHasher::match(const Key& k, const Lookup& l) {
   MOZ_ASSERT((reinterpret_cast<intptr_t>(k) & CachePage::kPageMask) == 0);
   MOZ_ASSERT((reinterpret_cast<intptr_t>(l) & CachePage::kPageMask) == 0);
   return k == l;
 }
 
-/* static */ void SimulatorProcess::FlushICache(void* start_addr, size_t size) {
+/* static */
+void SimulatorProcess::FlushICache(void* start_addr, size_t size) {
   if (!ICacheCheckingDisableCount) {
     AutoLockSimulatorCache als;
     js::jit::FlushICacheLocked(icache(), start_addr, size);
   }
 }
 
 Simulator::Simulator() {
   // Set up simulator support first. Some of this information is needed to
@@ -1294,18 +1296,19 @@ SimulatorProcess::~SimulatorProcess() {
   Redirection* r = redirection_;
   while (r) {
     Redirection* next = r->next_;
     js_delete(r);
     r = next;
   }
 }
 
-/* static */ void* Simulator::RedirectNativeFunction(void* nativeFunction,
-                                                     ABIFunctionType type) {
+/* static */
+void* Simulator::RedirectNativeFunction(void* nativeFunction,
+                                        ABIFunctionType type) {
   Redirection* redirection = Redirection::Get(nativeFunction, type);
   return redirection->addressOfSwiInstruction();
 }
 
 // Get the active Simulator for the current thread.
 Simulator* Simulator::Current() {
   JSContext* cx = TlsContext.get();
   MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx->runtime()));
--- a/js/src/jit/mips64/Assembler-mips64.cpp
+++ b/js/src/jit/mips64/Assembler-mips64.cpp
@@ -130,18 +130,19 @@ static void TraceOneDataRelocation(JSTra
   }
 
   if (ptr != prior) {
     Assembler::UpdateLoad64Value(inst, uint64_t(ptr));
     AutoFlushICache::flush(uintptr_t(inst), 6 * sizeof(uint32_t));
   }
 }
 
-/* static */ void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
-                                                  CompactBufferReader& reader) {
+/* static */
+void Assembler::TraceDataRelocations(JSTracer* trc, JitCode* code,
+                                     CompactBufferReader& reader) {
   while (reader.more()) {
     size_t offset = reader.readUnsigned();
     Instruction* inst = (Instruction*)(code->raw() + offset);
     TraceOneDataRelocation(trc, inst);
   }
 }
 
 void Assembler::Bind(uint8_t* rawCode, const CodeLabel& label) {
--- a/js/src/jit/mips64/Simulator-mips64.cpp
+++ b/js/src/jit/mips64/Simulator-mips64.cpp
@@ -1136,17 +1136,18 @@ static void FlushICacheLocked(SimulatorP
     MOZ_ASSERT((start & CachePage::kPageMask) == 0);
     offset = 0;
   }
   if (size != 0) {
     FlushOnePageLocked(i_cache, start, size);
   }
 }
 
-/* static */ void SimulatorProcess::checkICacheLocked(SimInstruction* instr) {
+/* static */
+void SimulatorProcess::checkICacheLocked(SimInstruction* instr) {
   intptr_t address = reinterpret_cast<intptr_t>(instr);
   void* page = reinterpret_cast<void*>(address & (~CachePage::kPageMask));
   void* line = reinterpret_cast<void*>(address & (~CachePage::kLineMask));
   int offset = (address & CachePage::kPageMask);
   CachePage* cache_page = GetCachePageLocked(icache(), page);
   char* cache_valid_byte = cache_page->validityByte(offset);
   bool cache_hit = (*cache_valid_byte == CachePage::LINE_VALID);
   char* cached_line = cache_page->cachedData(offset & ~CachePage::kLineMask);
@@ -1169,17 +1170,18 @@ HashNumber SimulatorProcess::ICacheHashe
 }
 
 bool SimulatorProcess::ICacheHasher::match(const Key& k, const Lookup& l) {
   MOZ_ASSERT((reinterpret_cast<intptr_t>(k) & CachePage::kPageMask) == 0);
   MOZ_ASSERT((reinterpret_cast<intptr_t>(l) & CachePage::kPageMask) == 0);
   return k == l;
 }
 
-/* static */ void SimulatorProcess::FlushICache(void* start_addr, size_t size) {
+/* static */
+void SimulatorProcess::FlushICache(void* start_addr, size_t size) {
   if (!ICacheCheckingDisableCount) {
     AutoLockSimulatorCache als;
     js::jit::FlushICacheLocked(icache(), start_addr, size);
   }
 }
 
 Simulator::Simulator() {
   // Set up simulator support first. Some of this information is needed to
@@ -1321,18 +1323,19 @@ SimulatorProcess::~SimulatorProcess() {
   Redirection* r = redirection_;
   while (r) {
     Redirection* next = r->next_;
     js_delete(r);
     r = next;
   }
 }
 
-/* static */ void* Simulator::RedirectNativeFunction(void* nativeFunction,
-                                                     ABIFunctionType type) {
+/* static */
+void* Simulator::RedirectNativeFunction(void* nativeFunction,
+                                        ABIFunctionType type) {
   Redirection* redirection = Redirection::Get(nativeFunction, type);
   return redirection->addressOfSwiInstruction();
 }
 
 // Get the active Simulator for the current thread.
 Simulator* Simulator::Current() {
   JSContext* cx = TlsContext.get();
   MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx->runtime()));
--- a/js/src/jit/x86-shared/Assembler-x86-shared.cpp
+++ b/js/src/jit/x86-shared/Assembler-x86-shared.cpp
@@ -31,18 +31,19 @@ void AssemblerX86Shared::copyJumpRelocat
 }
 
 void AssemblerX86Shared::copyDataRelocationTable(uint8_t* dest) {
   if (dataRelocations_.length()) {
     memcpy(dest, dataRelocations_.buffer(), dataRelocations_.length());
   }
 }
 
-/* static */ void AssemblerX86Shared::TraceDataRelocations(
-    JSTracer* trc, JitCode* code, CompactBufferReader& reader) {
+/* static */
+void AssemblerX86Shared::TraceDataRelocations(JSTracer* trc, JitCode* code,
+                                              CompactBufferReader& reader) {
   while (reader.more()) {
     size_t offset = reader.readUnsigned();
     MOZ_ASSERT(offset >= sizeof(void*) && offset <= code->instructionsSize());
 
     uint8_t* src = code->raw() + offset;
     void* data = X86Encoding::GetPointer(src);
 
 #ifdef JS_PUNBOX64
--- a/js/src/jsexn.cpp
+++ b/js/src/jsexn.cpp
@@ -541,17 +541,18 @@ static bool exn_toSource(JSContext* cx, 
   JSString* str = sb.finishString();
   if (!str) {
     return false;
   }
   args.rval().setString(str);
   return true;
 }
 
-/* static */ JSObject* ErrorObject::createProto(JSContext* cx, JSProtoKey key) {
+/* static */
+JSObject* ErrorObject::createProto(JSContext* cx, JSProtoKey key) {
   JSExnType type = ExnTypeFromProtoKey(key);
 
   if (type == JSEXN_ERR) {
     return GlobalObject::createBlankPrototype(
         cx, cx->global(), &ErrorObject::protoClasses[JSEXN_ERR]);
   }
 
   RootedObject protoProto(
@@ -559,18 +560,18 @@ static bool exn_toSource(JSContext* cx, 
   if (!protoProto) {
     return nullptr;
   }
 
   return GlobalObject::createBlankPrototypeInheriting(
       cx, &ErrorObject::protoClasses[type], protoProto);
 }
 
-/* static */ JSObject* ErrorObject::createConstructor(JSContext* cx,
-                                                      JSProtoKey key) {
+/* static */
+JSObject* ErrorObject::createConstructor(JSContext* cx, JSProtoKey key) {
   JSExnType type = ExnTypeFromProtoKey(key);
   RootedObject ctor(cx);
 
   if (type == JSEXN_ERR) {
     ctor = GenericCreateConstructor<Error, 1, gc::AllocKind::FUNCTION_EXTENDED>(
         cx, key);
   } else {
     RootedFunction proto(
--- a/js/src/proxy/Proxy.cpp
+++ b/js/src/proxy/Proxy.cpp
@@ -157,68 +157,70 @@ JS_FRIEND_API bool js::AppendUnique(JSCo
       if (!uniqueOthers.append(others[i])) {
         return false;
       }
     }
   }
   return base.appendAll(uniqueOthers);
 }
 
-/* static */ bool Proxy::getPrototype(JSContext* cx, HandleObject proxy,
-                                      MutableHandleObject proto) {
+/* static */
+bool Proxy::getPrototype(JSContext* cx, HandleObject proxy,
+                         MutableHandleObject proto) {
   MOZ_ASSERT(proxy->hasDynamicPrototype());
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   return proxy->as<ProxyObject>().handler()->getPrototype(cx, proxy, proto);
 }
 
-/* static */ bool Proxy::setPrototype(JSContext* cx, HandleObject proxy,
-                                      HandleObject proto,
-                                      ObjectOpResult& result) {
+/* static */
+bool Proxy::setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
+                         ObjectOpResult& result) {
   MOZ_ASSERT(proxy->hasDynamicPrototype());
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   return proxy->as<ProxyObject>().handler()->setPrototype(cx, proxy, proto,
                                                           result);
 }
 
-/* static */ bool Proxy::getPrototypeIfOrdinary(JSContext* cx,
-                                                HandleObject proxy,
-                                                bool* isOrdinary,
-                                                MutableHandleObject proto) {
+/* static */
+bool Proxy::getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy,
+                                   bool* isOrdinary,
+                                   MutableHandleObject proto) {
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   return proxy->as<ProxyObject>().handler()->getPrototypeIfOrdinary(
       cx, proxy, isOrdinary, proto);
 }
 
-/* static */ bool Proxy::setImmutablePrototype(JSContext* cx,
-                                               HandleObject proxy,
-                                               bool* succeeded) {
+/* static */
+bool Proxy::setImmutablePrototype(JSContext* cx, HandleObject proxy,
+                                  bool* succeeded) {
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   const BaseProxyHandler* handler = proxy->as<ProxyObject>().handler();
   return handler->setImmutablePrototype(cx, proxy, succeeded);
 }
 
-/* static */ bool Proxy::preventExtensions(JSContext* cx, HandleObject proxy,
-                                           ObjectOpResult& result) {
+/* static */
+bool Proxy::preventExtensions(JSContext* cx, HandleObject proxy,
+                              ObjectOpResult& result) {
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   const BaseProxyHandler* handler = proxy->as<ProxyObject>().handler();
   return handler->preventExtensions(cx, proxy, result);
 }
 
-/* static */ bool Proxy::isExtensible(JSContext* cx, HandleObject proxy,
-                                      bool* extensible) {
+/* static */
+bool Proxy::isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) {
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   return proxy->as<ProxyObject>().handler()->isExtensible(cx, proxy,
                                                           extensible);
 }
 
 bool Proxy::has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) {
@@ -607,19 +609,19 @@ bool Proxy::boxedValue_unbox(JSContext* 
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   return proxy->as<ProxyObject>().handler()->boxedValue_unbox(cx, proxy, vp);
 }
 
 JSObject* const TaggedProto::LazyProto = reinterpret_cast<JSObject*>(0x1);
 
-/* static */ bool Proxy::getElements(JSContext* cx, HandleObject proxy,
-                                     uint32_t begin, uint32_t end,
-                                     ElementAdder* adder) {
+/* static */
+bool Proxy::getElements(JSContext* cx, HandleObject proxy, uint32_t begin,
+                        uint32_t end, ElementAdder* adder) {
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
   const BaseProxyHandler* handler = proxy->as<ProxyObject>().handler();
   AutoEnterPolicy policy(cx, handler, proxy, JSID_VOIDHANDLE,
                          BaseProxyHandler::GET,
                          /* mayThrow = */ true);
   if (!policy.allowed()) {
@@ -627,17 +629,18 @@ JSObject* const TaggedProto::LazyProto =
       MOZ_ASSERT(!cx->isExceptionPending());
       return js::GetElementsWithAdder(cx, proxy, proxy, begin, end, adder);
     }
     return false;
   }
   return handler->getElements(cx, proxy, begin, end, adder);
 }
 
-/* static */ void Proxy::trace(JSTracer* trc, JSObject* proxy) {
+/* static */
+void Proxy::trace(JSTracer* trc, JSObject* proxy) {
   const BaseProxyHandler* handler = proxy->as<ProxyObject>().handler();
   handler->trace(trc, proxy);
 }
 
 static bool proxy_LookupProperty(JSContext* cx, HandleObject obj, HandleId id,
                                  MutableHandleObject objp,
                                  MutableHandle<JS::PropertyResult> propp) {
   bool found;
@@ -658,22 +661,23 @@ static bool proxy_LookupProperty(JSConte
 static bool proxy_DeleteProperty(JSContext* cx, HandleObject obj, HandleId id,
                                  ObjectOpResult& result) {
   if (!Proxy::delete_(cx, obj, id, result)) {
     return false;
   }
   return SuppressDeletedProperty(cx, obj, id);  // XXX is this necessary?
 }
 
-/* static */ void ProxyObject::traceEdgeToTarget(JSTracer* trc,
-                                                 ProxyObject* obj) {
+/* static */
+void ProxyObject::traceEdgeToTarget(JSTracer* trc, ProxyObject* obj) {
   TraceCrossCompartmentEdge(trc, obj, obj->slotOfPrivate(), "proxy target");
 }
 
-/* static */ void ProxyObject::trace(JSTracer* trc, JSObject* obj) {
+/* static */
+void ProxyObject::trace(JSTracer* trc, JSObject* obj) {
   ProxyObject* proxy = &obj->as<ProxyObject>();
 
   TraceEdge(trc, proxy->shapePtr(), "ProxyObject_shape");
 
 #ifdef DEBUG
   if (TlsContext.get()->isStrictProxyCheckingEnabled() &&
       proxy->is<WrapperObject>()) {
     JSObject* referent = MaybeForwarded(proxy->target());
--- a/js/src/proxy/ScriptedProxyHandler.cpp
+++ b/js/src/proxy/ScriptedProxyHandler.cpp
@@ -161,18 +161,18 @@ static bool IsCompatiblePropertyDescript
         "proxy can't report different getters for a currently non-configurable "
         "property";
     *errorDetails = DETAILS_GETTERS_DIFFERENT;
   }
   return true;
 }
 
 // Get the [[ProxyHandler]] of a scripted proxy.
-/* static */ JSObject* ScriptedProxyHandler::handlerObject(
-    const JSObject* proxy) {
+/* static */
+JSObject* ScriptedProxyHandler::handlerObject(const JSObject* proxy) {
   MOZ_ASSERT(proxy->as<ProxyObject>().handler() ==
              &ScriptedProxyHandler::singleton);
   return proxy->as<ProxyObject>()
       .reservedSlot(ScriptedProxyHandler::HANDLER_EXTRA)
       .toObjectOrNull();
 }
 
 // ES8 rev 0c1bd3004329336774cbc90de727cd0cf5f11e93
--- a/js/src/shell/OSObject.cpp
+++ b/js/src/shell/OSObject.cpp
@@ -375,18 +375,18 @@ static bool osfile_writeTypedArrayToFile
     JS_ReportErrorUTF8(cx, "can't write %s", filename.get());
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ RCFile* RCFile::create(JSContext* cx, const char* filename,
-                                    const char* mode) {
+/* static */
+RCFile* RCFile::create(JSContext* cx, const char* filename, const char* mode) {
   FILE* fp = fopen(filename, mode);
   if (!fp) {
     return nullptr;
   }
 
   RCFile* file = cx->new_<RCFile>(fp);
   if (!file) {
     fclose(fp);
--- a/js/src/threading/Mutex.cpp
+++ b/js/src/threading/Mutex.cpp
@@ -9,19 +9,21 @@
 #include "jsutil.h"
 
 using namespace js;
 
 #ifdef DEBUG
 
 MOZ_THREAD_LOCAL(js::Mutex::MutexVector*) js::Mutex::HeldMutexStack;
 
-/* static */ bool js::Mutex::Init() { return HeldMutexStack.init(); }
+/* static */
+bool js::Mutex::Init() { return HeldMutexStack.init(); }
 
-/* static */ void js::Mutex::ShutDown() {
+/* static */
+void js::Mutex::ShutDown() {
   js_delete(HeldMutexStack.get());
   HeldMutexStack.set(nullptr);
 }
 
 /* static */ js::Mutex::MutexVector& js::Mutex::heldMutexStack() {
   MOZ_ASSERT(js::IsInitialized());
   auto stack = HeldMutexStack.get();
   if (!stack) {
--- a/js/src/util/StructuredSpewer.cpp
+++ b/js/src/util/StructuredSpewer.cpp
@@ -97,17 +97,18 @@ static bool MatchJSScript(JSScript* scri
                  script->column());
 
   // Trivial containment match.
   char* result = strstr(signature, pattern);
 
   return result != nullptr;
 }
 
-/* static */ bool StructuredSpewer::enabled(JSScript* script) {
+/* static */
+bool StructuredSpewer::enabled(JSScript* script) {
   // We cannot call getenv under record/replay.
   if (mozilla::recordreplay::IsRecordingOrReplaying()) {
     return false;
   }
   static const char* pattern = getenv("SPEW_FILTER");
   if (!pattern || MatchJSScript(script, pattern)) {
     return true;
   }
@@ -134,18 +135,19 @@ void StructuredSpewer::startObject(JSCon
   {
     json.property("filename", script->filename());
     json.property("line", script->lineno());
     json.property("column", script->column());
   }
   json.endObject();
 }
 
-/* static */ void StructuredSpewer::spew(JSContext* cx, SpewChannel channel,
-                                         const char* fmt, ...) {
+/* static */
+void StructuredSpewer::spew(JSContext* cx, SpewChannel channel, const char* fmt,
+                            ...) {
   // Because we don't have a script here, use the singleton's
   // filter to determine if the channel is active.
   if (!cx->spewer().filter().enabled(channel)) {
     return;
   }
 
   if (!cx->spewer().ensureInitializationAttempted()) {
     return;
--- a/js/src/vm/ArgumentsObject.cpp
+++ b/js/src/vm/ArgumentsObject.cpp
@@ -19,23 +19,25 @@
 #include "vm/JSObject-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
 
 using JS::AutoStableStringChars;
 
-/* static */ size_t RareArgumentsData::bytesRequired(size_t numActuals) {
+/* static */
+size_t RareArgumentsData::bytesRequired(size_t numActuals) {
   size_t extraBytes = NumWordsForBitArrayOfLength(numActuals) * sizeof(size_t);
   return offsetof(RareArgumentsData, deletedBits_) + extraBytes;
 }
 
-/* static */ RareArgumentsData* RareArgumentsData::create(
-    JSContext* cx, ArgumentsObject* obj) {
+/* static */
+RareArgumentsData* RareArgumentsData::create(JSContext* cx,
+                                             ArgumentsObject* obj) {
   size_t bytes = RareArgumentsData::bytesRequired(obj->initialLength());
 
   uint8_t* data = AllocateObjectBuffer<uint8_t>(cx, obj, bytes);
   if (!data) {
     return nullptr;
   }
 
   mozilla::PodZero(data, bytes);
@@ -75,32 +77,36 @@ static void CopyStackFrameArguments(cons
   /* Copy arguments. */
   Value* src = frame.argv();
   Value* end = src + totalArgs;
   while (src != end) {
     (dst++)->init(*src++);
   }
 }
 
-/* static */ void ArgumentsObject::MaybeForwardToCallObject(
-    AbstractFramePtr frame, ArgumentsObject* obj, ArgumentsData* data) {
+/* static */
+void ArgumentsObject::MaybeForwardToCallObject(AbstractFramePtr frame,
+                                               ArgumentsObject* obj,
+                                               ArgumentsData* data) {
   JSScript* script = frame.script();
   if (frame.callee()->needsCallObject() && script->argumentsAliasesFormals()) {
     obj->initFixedSlot(MAYBE_CALL_SLOT, ObjectValue(frame.callObj()));
     for (PositionalFormalParameterIter fi(script); fi; fi++) {
       if (fi.closedOver()) {
         data->args[fi.argumentSlot()] = MagicEnvSlotValue(fi.location().slot());
       }
     }
   }
 }
 
-/* static */ void ArgumentsObject::MaybeForwardToCallObject(
-    jit::JitFrameLayout* frame, HandleObject callObj, ArgumentsObject* obj,
-    ArgumentsData* data) {
+/* static */
+void ArgumentsObject::MaybeForwardToCallObject(jit::JitFrameLayout* frame,
+                                               HandleObject callObj,
+                                               ArgumentsObject* obj,
+                                               ArgumentsData* data) {
   JSFunction* callee = jit::CalleeTokenToFunction(frame->calleeToken());
   JSScript* script = callee->nonLazyScript();
   if (callee->needsCallObject() && script->argumentsAliasesFormals()) {
     MOZ_ASSERT(callObj && callObj->is<CallObject>());
     obj->initFixedSlot(MAYBE_CALL_SLOT, ObjectValue(*callObj.get()));
     for (PositionalFormalParameterIter fi(script); fi; fi++) {
       if (fi.closedOver()) {
         data->args[fi.argumentSlot()] = MagicEnvSlotValue(fi.location().slot());
@@ -258,20 +264,19 @@ ArgumentsObject* Realm::getOrCreateArgum
     return nullptr;
   }
 
   obj.set(templateObj);
   return templateObj;
 }
 
 template <typename CopyArgs>
-/* static */ ArgumentsObject* ArgumentsObject::create(JSContext* cx,
-                                                      HandleFunction callee,
-                                                      unsigned numActuals,
-                                                      CopyArgs& copy) {
+/* static */
+ArgumentsObject* ArgumentsObject::create(JSContext* cx, HandleFunction callee,
+                                         unsigned numActuals, CopyArgs& copy) {
   bool mapped = callee->nonLazyScript()->hasMappedArgsObj();
   ArgumentsObject* templateObj =
       cx->realm()->getOrCreateArgumentsTemplateObject(cx, mapped);
   if (!templateObj) {
     return nullptr;
   }
 
   RootedShape shape(cx, templateObj->lastProperty());
@@ -364,19 +369,21 @@ ArgumentsObject* ArgumentsObject::create
   MOZ_ASSERT(jit::CalleeTokenIsFunction(token));
   RootedFunction callee(cx, jit::CalleeTokenToFunction(token));
   RootedObject callObj(
       cx, scopeChain->is<CallObject>() ? scopeChain.get() : nullptr);
   CopyJitFrameArgs copy(frame, callObj);
   return create(cx, callee, frame->numActualArgs(), copy);
 }
 
-/* static */ ArgumentsObject* ArgumentsObject::finishForIonPure(
-    JSContext* cx, jit::JitFrameLayout* frame, JSObject* scopeChain,
-    ArgumentsObject* obj) {
+/* static */
+ArgumentsObject* ArgumentsObject::finishForIonPure(JSContext* cx,
+                                                   jit::JitFrameLayout* frame,
+                                                   JSObject* scopeChain,
+                                                   ArgumentsObject* obj) {
   // JIT code calls this directly (no callVM), because it's faster, so we're
   // not allowed to GC in here.
   AutoUnsafeCallWithABI unsafe;
 
   JSFunction* callee = jit::CalleeTokenToFunction(frame->calleeToken());
   RootedObject callObj(cx, scopeChain->is<CallObject>() ? scopeChain : nullptr);
   CopyJitFrameArgs copy(frame, callObj);
 
@@ -410,20 +417,19 @@ ArgumentsObject* ArgumentsObject::create
     copy.maybeForwardToCallObject(obj, data);
   }
 
   MOZ_ASSERT(obj->initialLength() == numActuals);
   MOZ_ASSERT(!obj->hasOverriddenLength());
   return obj;
 }
 
-/* static */ bool ArgumentsObject::obj_delProperty(JSContext* cx,
-                                                   HandleObject obj,
-                                                   HandleId id,
-                                                   ObjectOpResult& result) {
+/* static */
+bool ArgumentsObject::obj_delProperty(JSContext* cx, HandleObject obj,
+                                      HandleId id, ObjectOpResult& result) {
   ArgumentsObject& argsobj = obj->as<ArgumentsObject>();
   if (JSID_IS_INT(id)) {
     unsigned arg = unsigned(JSID_TO_INT(id));
     if (arg < argsobj.initialLength() && !argsobj.isElementDeleted(arg)) {
       if (!argsobj.markElementDeleted(cx, arg)) {
         return false;
       }
     }
@@ -433,18 +439,19 @@ ArgumentsObject* ArgumentsObject::create
     argsobj.as<MappedArgumentsObject>().markCalleeOverridden();
   } else if (JSID_IS_SYMBOL(id) &&
              JSID_TO_SYMBOL(id) == cx->wellKnownSymbols().iterator) {
     argsobj.markIteratorOverridden();
   }
   return result.succeed();
 }
 
-/* static */ bool ArgumentsObject::obj_mayResolve(const JSAtomState& names,
-                                                  jsid id, JSObject*) {
+/* static */
+bool ArgumentsObject::obj_mayResolve(const JSAtomState& names, jsid id,
+                                     JSObject*) {
   // Arguments might resolve indexes, Symbol.iterator, or length/callee.
   if (JSID_IS_ATOM(id)) {
     JSAtom* atom = JSID_TO_ATOM(id);
     uint32_t index;
     if (atom->isIndex(&index)) {
       return true;
     }
     return atom == names.length || atom == names.callee;
@@ -538,50 +545,50 @@ static bool DefineArgumentsIterator(JSCo
   if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), shName, name, 0,
                                            &val)) {
     return false;
   }
   return NativeDefineDataProperty(cx, argsobj, iteratorId, val,
                                   JSPROP_RESOLVING);
 }
 
-/* static */ bool ArgumentsObject::reifyLength(JSContext* cx,
-                                               Handle<ArgumentsObject*> obj) {
+/* static */
+bool ArgumentsObject::reifyLength(JSContext* cx, Handle<ArgumentsObject*> obj) {
   if (obj->hasOverriddenLength()) {
     return true;
   }
 
   RootedId id(cx, NameToId(cx->names().length));
   RootedValue val(cx, Int32Value(obj->initialLength()));
   if (!NativeDefineDataProperty(cx, obj, id, val, JSPROP_RESOLVING)) {
     return false;
   }
 
   obj->markLengthOverridden();
   return true;
 }
 
-/* static */ bool ArgumentsObject::reifyIterator(JSContext* cx,
-                                                 Handle<ArgumentsObject*> obj) {
+/* static */
+bool ArgumentsObject::reifyIterator(JSContext* cx,
+                                    Handle<ArgumentsObject*> obj) {
   if (obj->hasOverriddenIterator()) {
     return true;
   }
 
   if (!DefineArgumentsIterator(cx, obj)) {
     return false;
   }
 
   obj->markIteratorOverridden();
   return true;
 }
 
-/* static */ bool MappedArgumentsObject::obj_resolve(JSContext* cx,
-                                                     HandleObject obj,
-                                                     HandleId id,
-                                                     bool* resolvedp) {
+/* static */
+bool MappedArgumentsObject::obj_resolve(JSContext* cx, HandleObject obj,
+                                        HandleId id, bool* resolvedp) {
   Rooted<MappedArgumentsObject*> argsobj(cx, &obj->as<MappedArgumentsObject>());
 
   if (JSID_IS_SYMBOL(id) &&
       JSID_TO_SYMBOL(id) == cx->wellKnownSymbols().iterator) {
     if (argsobj->hasOverriddenIterator()) {
       return true;
     }
 
@@ -618,18 +625,18 @@ static bool DefineArgumentsIterator(JSCo
                                     MappedArgSetter, attrs)) {
     return false;
   }
 
   *resolvedp = true;
   return true;
 }
 
-/* static */ bool MappedArgumentsObject::obj_enumerate(JSContext* cx,
-                                                       HandleObject obj) {
+/* static */
+bool MappedArgumentsObject::obj_enumerate(JSContext* cx, HandleObject obj) {
   Rooted<MappedArgumentsObject*> argsobj(cx, &obj->as<MappedArgumentsObject>());
 
   RootedId id(cx);
   bool found;
 
   // Trigger reflection.
   id = NameToId(cx->names().length);
   if (!HasOwnProperty(cx, argsobj, id, &found)) {
@@ -652,19 +659,21 @@ static bool DefineArgumentsIterator(JSCo
       return false;
     }
   }
 
   return true;
 }
 
 // ES 2017 draft 9.4.4.2
-/* static */ bool MappedArgumentsObject::obj_defineProperty(
-    JSContext* cx, HandleObject obj, HandleId id,
-    Handle<PropertyDescriptor> desc, ObjectOpResult& result) {
+/* static */
+bool MappedArgumentsObject::obj_defineProperty(JSContext* cx, HandleObject obj,
+                                               HandleId id,
+                                               Handle<PropertyDescriptor> desc,
+                                               ObjectOpResult& result) {
   // Step 1.
   Rooted<MappedArgumentsObject*> argsobj(cx, &obj->as<MappedArgumentsObject>());
 
   // Steps 2-3.
   bool isMapped = false;
   if (JSID_IS_INT(id)) {
     unsigned arg = unsigned(JSID_TO_INT(id));
     isMapped =
@@ -789,20 +798,19 @@ static bool UnmappedArgSetter(JSContext*
    * simple data property. Note that we rely on ArgumentsObject::obj_delProperty
    * to set the corresponding override-bit.
    */
   ObjectOpResult ignored;
   return NativeDeleteProperty(cx, argsobj, id, ignored) &&
          NativeDefineDataProperty(cx, argsobj, id, v, attrs, result);
 }
 
-/* static */ bool UnmappedArgumentsObject::obj_resolve(JSContext* cx,
-                                                       HandleObject obj,
-                                                       HandleId id,
-                                                       bool* resolvedp) {
+/* static */
+bool UnmappedArgumentsObject::obj_resolve(JSContext* cx, HandleObject obj,
+                                          HandleId id, bool* resolvedp) {
   Rooted<UnmappedArgumentsObject*> argsobj(cx,
                                            &obj->as<UnmappedArgumentsObject>());
 
   if (JSID_IS_SYMBOL(id) &&
       JSID_TO_SYMBOL(id) == cx->wellKnownSymbols().iterator) {
     if (argsobj->hasOverriddenIterator()) {
       return true;
     }
@@ -852,18 +860,18 @@ static bool UnmappedArgSetter(JSContext*
                                     UnmappedArgSetter, attrs)) {
     return false;
   }
 
   *resolvedp = true;
   return true;
 }
 
-/* static */ bool UnmappedArgumentsObject::obj_enumerate(JSContext* cx,
-                                                         HandleObject obj) {
+/* static */
+bool UnmappedArgumentsObject::obj_enumerate(JSContext* cx, HandleObject obj) {
   Rooted<UnmappedArgumentsObject*> argsobj(cx,
                                            &obj->as<UnmappedArgumentsObject>());
 
   RootedId id(cx);
   bool found;
 
   // Trigger reflection.
   id = NameToId(cx->names().length);
@@ -902,17 +910,18 @@ void ArgumentsObject::finalize(FreeOp* f
 void ArgumentsObject::trace(JSTracer* trc, JSObject* obj) {
   ArgumentsObject& argsobj = obj->as<ArgumentsObject>();
   if (ArgumentsData* data =
           argsobj.data()) {  // Template objects have no ArgumentsData.
     TraceRange(trc, data->numArgs, data->begin(), js_arguments_str);
   }
 }
 
-/* static */ size_t ArgumentsObject::objectMoved(JSObject* dst, JSObject* src) {
+/* static */
+size_t ArgumentsObject::objectMoved(JSObject* dst, JSObject* src) {
   ArgumentsObject* ndst = &dst->as<ArgumentsObject>();
   const ArgumentsObject* nsrc = &src->as<ArgumentsObject>();
   MOZ_ASSERT(ndst->data() == nsrc->data());
 
   if (!IsInsideNursery(src)) {
     return 0;
   }
 
--- a/js/src/vm/ArrayBufferObject.cpp
+++ b/js/src/vm/ArrayBufferObject.cpp
@@ -458,18 +458,19 @@ static uint8_t* NewCopiedBufferContents(
   if (dataCopy) {
     if (auto count = buffer->byteLength()) {
       memcpy(dataCopy, buffer->dataPointer(), count);
     }
   }
   return dataCopy;
 }
 
-/* static */ void ArrayBufferObject::detach(JSContext* cx,
-                                            Handle<ArrayBufferObject*> buffer) {
+/* static */
+void ArrayBufferObject::detach(JSContext* cx,
+                               Handle<ArrayBufferObject*> buffer) {
   cx->check(buffer);
   MOZ_ASSERT(!buffer->isPreparedForAsmJS());
 
   // When detaching buffers where we don't know all views, the new data must
   // match the old data. All missing views are typed objects, which do not
   // expect their data to ever change.
 
   // When detaching a buffer with typed object views, any jitcode accessing
@@ -678,17 +679,18 @@ class js::WasmArrayRawBuffer {
       return;
     }
 
     maxSize_ = Some(newMaxSize.value());
   }
 #endif  // WASM_HUGE_MEMORY
 };
 
-/* static */ WasmArrayRawBuffer* WasmArrayRawBuffer::Allocate(
+/* static */
+WasmArrayRawBuffer* WasmArrayRawBuffer::Allocate(
     uint32_t numBytes, const Maybe<uint32_t>& maxSize) {
   MOZ_RELEASE_ASSERT(numBytes <= ArrayBufferObject::MaxBufferByteLength);
 
   size_t mappedSize;
 #ifdef WASM_HUGE_MEMORY
   mappedSize = wasm::HugeMappedSize;
 #else
   mappedSize = wasm::ComputeMappedSize(maxSize.valueOr(numBytes));
@@ -710,17 +712,18 @@ class js::WasmArrayRawBuffer {
 
   uint8_t* base = reinterpret_cast<uint8_t*>(data) + gc::SystemPageSize();
   uint8_t* header = base - sizeof(WasmArrayRawBuffer);
 
   auto rawBuf = new (header) WasmArrayRawBuffer(base, maxSize, mappedSize);
   return rawBuf;
 }
 
-/* static */ void WasmArrayRawBuffer::Release(void* mem) {
+/* static */
+void WasmArrayRawBuffer::Release(void* mem) {
   WasmArrayRawBuffer* header =
       (WasmArrayRawBuffer*)((uint8_t*)mem - sizeof(WasmArrayRawBuffer));
 
   MOZ_RELEASE_ASSERT(header->mappedSize() <= SIZE_MAX - gc::SystemPageSize());
   size_t mappedSizeWithHeader = header->mappedSize() + gc::SystemPageSize();
 
   UnmapBufferMemory(header->basePointer(), mappedSizeWithHeader);
 }
@@ -1024,17 +1027,18 @@ static void CheckStealPreconditions(Hand
                                     JSContext* cx) {
   cx->check(buffer);
 
   MOZ_ASSERT(!buffer->isDetached(), "can't steal from a detached buffer");
   MOZ_ASSERT(!buffer->isPreparedForAsmJS(),
              "asm.js-prepared buffers don't have detachable/stealable data");
 }
 
-/* static */ bool ArrayBufferObject::wasmGrowToSizeInPlace(
+/* static */
+bool ArrayBufferObject::wasmGrowToSizeInPlace(
     uint32_t newSize, HandleArrayBufferObject oldBuf,
     MutableHandleArrayBufferObject newBuf, JSContext* cx) {
   CheckStealPreconditions(oldBuf, cx);
 
   MOZ_ASSERT(oldBuf->isWasm());
 
   // On failure, do not throw and ensure that the original buffer is
   // unmodified and valid. After WasmArrayRawBuffer::growToSizeInPlace(), the
@@ -1068,17 +1072,18 @@ static void CheckStealPreconditions(Hand
   ArrayBufferObject::detach(cx, oldBuf);
 
   // Set |newBuf|'s contents to |oldBuf|'s original contents.
   newBuf->initialize(newSize, oldContents);
   return true;
 }
 
 #ifndef WASM_HUGE_MEMORY
-/* static */ bool ArrayBufferObject::wasmMovingGrowToSize(
+/* static */
+bool ArrayBufferObject::wasmMovingGrowToSize(
     uint32_t newSize, HandleArrayBufferObject oldBuf,
     MutableHandleArrayBufferObject newBuf, JSContext* cx) {
   // On failure, do not throw and ensure that the original buffer is
   // unmodified and valid.
 
   if (newSize > ArrayBufferObject::MaxBufferByteLength) {
     return false;
   }
@@ -1398,17 +1403,18 @@ ArrayBufferObject::extractStructuredClon
       MOZ_ASSERT_UNREACHABLE("bad kind when stealing malloc'd data");
       break;
   }
 
   MOZ_ASSERT_UNREACHABLE("garbage kind computed");
   return BufferContents::createFailed();
 }
 
-/* static */ void ArrayBufferObject::addSizeOfExcludingThis(
+/* static */
+void ArrayBufferObject::addSizeOfExcludingThis(
     JSObject* obj, mozilla::MallocSizeOf mallocSizeOf, JS::ClassInfo* info) {
   ArrayBufferObject& buffer = AsArrayBuffer(obj);
   switch (buffer.bufferKind()) {
     case INLINE_DATA:
       // Inline data's size should be reported by this object's size-class
       // reporting.
       break;
     case MALLOCED:
@@ -1438,34 +1444,37 @@ ArrayBufferObject::extractStructuredClon
     case EXTERNAL:
       MOZ_CRASH("external buffers not currently supported");
       break;
     case BAD1:
       MOZ_CRASH("bad bufferKind()");
   }
 }
 
-/* static */ void ArrayBufferObject::finalize(FreeOp* fop, JSObject* obj) {
+/* static */
+void ArrayBufferObject::finalize(FreeOp* fop, JSObject* obj) {
   obj->as<ArrayBufferObject>().releaseData(fop);
 }
 
-/* static */ void ArrayBufferObject::copyData(
-    Handle<ArrayBufferObject*> toBuffer, uint32_t toIndex,
-    Handle<ArrayBufferObject*> fromBuffer, uint32_t fromIndex, uint32_t count) {
+/* static */
+void ArrayBufferObject::copyData(Handle<ArrayBufferObject*> toBuffer,
+                                 uint32_t toIndex,
+                                 Handle<ArrayBufferObject*> fromBuffer,
+                                 uint32_t fromIndex, uint32_t count) {
   MOZ_ASSERT(toBuffer->byteLength() >= count);
   MOZ_ASSERT(toBuffer->byteLength() >= toIndex + count);
   MOZ_ASSERT(fromBuffer->byteLength() >= fromIndex);
   MOZ_ASSERT(fromBuffer->byteLength() >= fromIndex + count);
 
   memcpy(toBuffer->dataPointer() + toIndex,
          fromBuffer->dataPointer() + fromIndex, count);
 }
 
-/* static */ size_t ArrayBufferObject::objectMoved(JSObject* obj,
-                                                   JSObject* old) {
+/* static */
+size_t ArrayBufferObject::objectMoved(JSObject* obj, JSObject* old) {
   ArrayBufferObject& dst = obj->as<ArrayBufferObject>();
   const ArrayBufferObject& src = old->as<ArrayBufferObject>();
 
   // Fix up possible inline data pointer.
   if (src.hasInlineData()) {
     dst.setFixedSlot(DATA_SLOT, PrivateValue(dst.inlineDataPointer()));
   }
 
@@ -1563,18 +1572,18 @@ InnerViewTable::ViewVector* InnerViewTab
 
 void InnerViewTable::removeViews(ArrayBufferObject* buffer) {
   Map::Ptr p = map.lookup(buffer);
   MOZ_ASSERT(p);
 
   map.remove(p);
 }
 
-/* static */ bool InnerViewTable::sweepEntry(JSObject** pkey,
-                                             ViewVector& views) {
+/* static */
+bool InnerViewTable::sweepEntry(JSObject** pkey, ViewVector& views) {
   if (IsAboutToBeFinalizedUnbarriered(pkey)) {
     return true;
   }
 
   MOZ_ASSERT(!views.empty());
   size_t i = 0;
   while (i < views.length()) {
     if (IsAboutToBeFinalizedUnbarriered(&views[i])) {
--- a/js/src/vm/ArrayBufferViewObject.cpp
+++ b/js/src/vm/ArrayBufferViewObject.cpp
@@ -17,18 +17,18 @@
 
 using namespace js;
 
 /*
  * This method is used to trace TypedArrayObjects and DataViewObjects. We need
  * a custom tracer to move the object's data pointer if its owner was moved and
  * stores its data inline.
  */
-/* static */ void ArrayBufferViewObject::trace(JSTracer* trc,
-                                               JSObject* objArg) {
+/* static */
+void ArrayBufferViewObject::trace(JSTracer* trc, JSObject* objArg) {
   NativeObject* obj = &objArg->as<NativeObject>();
   HeapSlot& bufSlot = obj->getFixedSlotRef(BUFFER_SLOT);
   TraceEdge(trc, &bufSlot, "ArrayBufferViewObject.buffer");
 
   // Update obj's data pointer if it moved.
   if (bufSlot.isObject()) {
     if (IsArrayBuffer(&bufSlot.toObject())) {
       ArrayBufferObject& buf =
@@ -67,17 +67,18 @@ uint8_t* ArrayBufferViewObject::dataPoin
   return static_cast<uint8_t*>(dataPointerUnshared());
 }
 
 void ArrayBufferViewObject::setDataPointerUnshared(uint8_t* data) {
   MOZ_ASSERT(!isSharedMemory());
   setPrivate(data);
 }
 
-/* static */ ArrayBufferObjectMaybeShared* ArrayBufferViewObject::bufferObject(
+/* static */
+ArrayBufferObjectMaybeShared* ArrayBufferViewObject::bufferObject(
     JSContext* cx, Handle<ArrayBufferViewObject*> thisObject) {
   if (thisObject->is<TypedArrayObject>()) {
     Rooted<TypedArrayObject*> typedArray(cx,
                                          &thisObject->as<TypedArrayObject>());
     if (!TypedArrayObject::ensureHasBuffer(cx, typedArray)) {
       return nullptr;
     }
   }
--- a/js/src/vm/AsyncFunction.cpp
+++ b/js/src/vm/AsyncFunction.cpp
@@ -16,18 +16,19 @@
 #include "vm/SelfHosting.h"
 
 #include "vm/JSObject-inl.h"
 
 using namespace js;
 
 using mozilla::Maybe;
 
-/* static */ bool GlobalObject::initAsyncFunction(
-    JSContext* cx, Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initAsyncFunction(JSContext* cx,
+                                     Handle<GlobalObject*> global) {
   if (global->getReservedSlot(ASYNC_FUNCTION_PROTO).isObject()) {
     return true;
   }
 
   RootedObject asyncFunctionProto(
       cx, NewSingletonObjectWithFunctionPrototype(cx, global));
   if (!asyncFunctionProto) {
     return false;
--- a/js/src/vm/AsyncIteration.cpp
+++ b/js/src/vm/AsyncIteration.cpp
@@ -60,18 +60,19 @@ JSObject* js::CreateAsyncFromSyncIterato
   // Step 1 (implicit).
   // Done in bytecode emitted by emitAsyncIterator.
 
   // Steps 2-4.
   return AsyncFromSyncIteratorObject::create(cx, iter, nextMethod);
 }
 
 // Async Iteration proposal 11.1.3.1 steps 2-4.
-/* static */ JSObject* AsyncFromSyncIteratorObject::create(
-    JSContext* cx, HandleObject iter, HandleValue nextMethod) {
+/* static */
+JSObject* AsyncFromSyncIteratorObject::create(JSContext* cx, HandleObject iter,
+                                              HandleValue nextMethod) {
   // Step 2.
   RootedObject proto(cx,
                      GlobalObject::getOrCreateAsyncFromSyncIteratorPrototype(
                          cx, cx->global()));
   if (!proto) {
     return nullptr;
   }
 
@@ -157,18 +158,19 @@ static AsyncGeneratorObject* OrdinaryCre
       return nullptr;
     }
   }
 
   // Step 3.
   return NewObjectWithGivenProto<AsyncGeneratorObject>(cx, proto);
 }
 
-/* static */ AsyncGeneratorObject* AsyncGeneratorObject::create(
-    JSContext* cx, HandleFunction asyncGen) {
+/* static */
+AsyncGeneratorObject* AsyncGeneratorObject::create(JSContext* cx,
+                                                   HandleFunction asyncGen) {
   MOZ_ASSERT(asyncGen->isAsync() && asyncGen->isGenerator());
 
   AsyncGeneratorObject* asyncGenObj =
       OrdinaryCreateFromConstructorAsynGen(cx, asyncGen);
   if (!asyncGenObj) {
     return nullptr;
   }
 
@@ -181,17 +183,18 @@ static AsyncGeneratorObject* OrdinaryCre
   // Step 8.
   asyncGenObj->clearSingleQueueRequest();
 
   asyncGenObj->clearCachedRequest();
 
   return asyncGenObj;
 }
 
-/* static */ AsyncGeneratorRequest* AsyncGeneratorObject::createRequest(
+/* static */
+AsyncGeneratorRequest* AsyncGeneratorObject::createRequest(
     JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj,
     CompletionKind completionKind, HandleValue completionValue,
     Handle<PromiseObject*> promise) {
   if (!asyncGenObj->hasCachedRequest()) {
     return AsyncGeneratorRequest::create(cx, completionKind, completionValue,
                                          promise);
   }
 
@@ -227,43 +230,46 @@ static AsyncGeneratorObject* OrdinaryCre
     return true;
   }
 
   Rooted<ListObject*> queue(cx, asyncGenObj->queue());
   RootedValue requestVal(cx, ObjectValue(*request));
   return queue->append(cx, requestVal);
 }
 
-/* static */ AsyncGeneratorRequest* AsyncGeneratorObject::dequeueRequest(
+/* static */
+AsyncGeneratorRequest* AsyncGeneratorObject::dequeueRequest(
     JSContext* cx, Handle<AsyncGeneratorObject*> asyncGenObj) {
   if (asyncGenObj->isSingleQueue()) {
     AsyncGeneratorRequest* request = asyncGenObj->singleQueueRequest();
     asyncGenObj->clearSingleQueueRequest();
     return request;
   }
 
   Rooted<ListObject*> queue(cx, asyncGenObj->queue());
   return &queue->popFirstAs<AsyncGeneratorRequest>(cx);
 }
 
-/* static */ AsyncGeneratorRequest* AsyncGeneratorObject::peekRequest(
+/* static */
+AsyncGeneratorRequest* AsyncGeneratorObject::peekRequest(
     Handle<AsyncGeneratorObject*> asyncGenObj) {
   if (asyncGenObj->isSingleQueue()) {
     return asyncGenObj->singleQueueRequest();
   }
 
   return &asyncGenObj->queue()->getAs<AsyncGeneratorRequest>(0);
 }
 
 const Class AsyncGeneratorRequest::class_ = {
     "AsyncGeneratorRequest",
     JSCLASS_HAS_RESERVED_SLOTS(AsyncGeneratorRequest::Slots)};
 
 // Async Iteration proposal 11.4.3.1.
-/* static */ AsyncGeneratorRequest* AsyncGeneratorRequest::create(
+/* static */
+AsyncGeneratorRequest* AsyncGeneratorRequest::create(
     JSContext* cx, CompletionKind completionKind, HandleValue completionValue,
     Handle<PromiseObject*> promise) {
   AsyncGeneratorRequest* request =
       NewObjectWithGivenProto<AsyncGeneratorRequest>(cx, nullptr);
   if (!request) {
     return nullptr;
   }
 
--- a/js/src/vm/Compartment.cpp
+++ b/js/src/vm/Compartment.cpp
@@ -400,18 +400,18 @@ void Compartment::traceOutgoingCrossComp
        * We have a cross-compartment wrapper. Its private pointer may
        * point into the compartment being collected, so we should mark it.
        */
       ProxyObject::traceEdgeToTarget(trc, wrapper);
     }
   }
 }
 
-/* static */ void Compartment::traceIncomingCrossCompartmentEdgesForZoneGC(
-    JSTracer* trc) {
+/* static */
+void Compartment::traceIncomingCrossCompartmentEdgesForZoneGC(JSTracer* trc) {
   gcstats::AutoPhase ap(trc->runtime()->gc.stats(),
                         gcstats::PhaseKind::MARK_CCWS);
   MOZ_ASSERT(JS::RuntimeHeapIsMajorCollecting());
   for (CompartmentsIter c(trc->runtime()); !c.done(); c.next()) {
     if (!c->zone()->isCollecting()) {
       c->traceOutgoingCrossCompartmentWrappers(trc);
     }
   }
@@ -442,18 +442,18 @@ void CrossCompartmentKey::trace(JSTracer
       [trc](auto tp) { TraceRoot(trc, tp, "CrossCompartmentKey::debugger"); });
 }
 
 bool CrossCompartmentKey::needsSweep() {
   auto needsSweep = [](auto tp) { return IsAboutToBeFinalizedUnbarriered(tp); };
   return applyToWrapped(needsSweep) || applyToDebugger(needsSweep);
 }
 
-/* static */ void Compartment::fixupCrossCompartmentWrappersAfterMovingGC(
-    JSTracer* trc) {
+/* static */
+void Compartment::fixupCrossCompartmentWrappersAfterMovingGC(JSTracer* trc) {
   MOZ_ASSERT(trc->runtime()->gc.isHeapCompacting());
 
   for (CompartmentsIter comp(trc->runtime()); !comp.done(); comp.next()) {
     // Sweep the wrapper map to update keys (wrapped values) in other
     // compartments that may have been moved.
     comp->sweepCrossCompartmentWrappers();
     // Trace the wrappers in the map to update their cross-compartment edges
     // to wrapped values in other compartments that may have been moved.
--- a/js/src/vm/DateTime.cpp
+++ b/js/src/vm/DateTime.cpp
@@ -515,17 +515,18 @@ bool js::InitDateTimeState() {
     js_delete(DateTimeInfo::instance);
     DateTimeInfo::instance = nullptr;
     return false;
   }
 
   return true;
 }
 
-/* static */ void js::FinishDateTimeState() {
+/* static */
+void js::FinishDateTimeState() {
   js_delete(IcuTimeZoneState);
   IcuTimeZoneState = nullptr;
 
   js_delete(DateTimeInfo::instance);
   DateTimeInfo::instance = nullptr;
 }
 
 void js::ResetTimeZoneInternal(ResetTimeZoneMode mode) {
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -365,18 +365,18 @@ class MOZ_RAII js::LeaveDebuggeeNoExecut
   ~LeaveDebuggeeNoExecute() {
     if (prevLocked_) {
       MOZ_ASSERT(prevLocked_->unlocked_ == this);
       prevLocked_->unlocked_ = nullptr;
     }
   }
 };
 
-/* static */ bool Debugger::slowPathCheckNoExecute(JSContext* cx,
-                                                   HandleScript script) {
+/* static */
+bool Debugger::slowPathCheckNoExecute(JSContext* cx, HandleScript script) {
   MOZ_ASSERT(cx->realm()->isDebuggee());
   MOZ_ASSERT(cx->noExecuteDebuggerTop);
   return EnterDebuggeeNoExecute::reportIfFoundInStack(cx, script);
 }
 
 static inline void NukeDebuggerWrapper(NativeObject* wrapper) {
   // In some OOM failure cases, we need to destroy the edge to the referent,
   // to avoid trying to trace it during untimely collections.
@@ -650,17 +650,18 @@ JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFR
                  unsigned(JSSLOT_DEBUGSCRIPT_OWNER));
 JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFRAME_OWNER) ==
                  unsigned(JSSLOT_DEBUGSOURCE_OWNER));
 JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFRAME_OWNER) ==
                  unsigned(JSSLOT_DEBUGOBJECT_OWNER));
 JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFRAME_OWNER) ==
                  unsigned(DebuggerEnvironment::OWNER_SLOT));
 
-/* static */ Debugger* Debugger::fromChildJSObject(JSObject* obj) {
+/* static */
+Debugger* Debugger::fromChildJSObject(JSObject* obj) {
   MOZ_ASSERT(obj->getClass() == &DebuggerFrame::class_ ||
              obj->getClass() == &DebuggerScript_class ||
              obj->getClass() == &DebuggerSource_class ||
              obj->getClass() == &DebuggerObject::class_ ||
              obj->getClass() == &DebuggerEnvironment::class_);
   JSObject* dbgobj = &obj->as<NativeObject>()
                           .getReservedSlot(JSSLOT_DEBUGOBJECT_OWNER)
                           .toObject();
@@ -783,17 +784,18 @@ bool Debugger::addGeneratorFrame(JSConte
     if (!generatorFrames.relookupOrAdd(p, genObj, frameObj)) {
       ReportOutOfMemory(cx);
       return false;
     }
   }
   return true;
 }
 
-/* static */ bool Debugger::hasLiveHook(GlobalObject* global, Hook which) {
+/* static */
+bool Debugger::hasLiveHook(GlobalObject* global, Hook which) {
   if (GlobalObject::DebuggerVector* debuggers = global->getDebuggers()) {
     for (auto p = debuggers->begin(); p != debuggers->end(); p++) {
       Debugger* dbg = *p;
       if (dbg->enabled && dbg->getHook(which)) {
         return true;
       }
     }
   }
@@ -851,18 +853,19 @@ bool Debugger::hasAnyLiveHooks(JSRuntime
     if (IsMarkedUnbarriered(rt, &key) && frameObj.hasAnyLiveHooks()) {
       return true;
     }
   }
 
   return false;
 }
 
-/* static */ ResumeMode Debugger::slowPathOnEnterFrame(JSContext* cx,
-                                                       AbstractFramePtr frame) {
+/* static */
+ResumeMode Debugger::slowPathOnEnterFrame(JSContext* cx,
+                                          AbstractFramePtr frame) {
   RootedValue rval(cx);
   ResumeMode resumeMode = dispatchHook(cx,
                                        [frame](Debugger* dbg) -> bool {
                                          return dbg->observesFrame(frame) &&
                                                 dbg->observesEnterFrame();
                                        },
                                        [&](Debugger* dbg) -> ResumeMode {
                                          return dbg->fireEnterFrame(cx, &rval);
@@ -886,18 +889,19 @@ bool Debugger::hasAnyLiveHooks(JSRuntime
 
     default:
       MOZ_CRASH("bad Debugger::onEnterFrame resume mode");
   }
 
   return resumeMode;
 }
 
-/* static */ ResumeMode Debugger::slowPathOnResumeFrame(
-    JSContext* cx, AbstractFramePtr frame) {
+/* static */
+ResumeMode Debugger::slowPathOnResumeFrame(JSContext* cx,
+                                           AbstractFramePtr frame) {
   // Don't count on this method to be called every time a generator is
   // resumed! This is called only if the frame's debuggee bit is set,
   // i.e. the script has breakpoints or the frame is stepping.
   MOZ_ASSERT(frame.isGeneratorFrame());
   MOZ_ASSERT(frame.isDebuggee());
 
   Rooted<AbstractGeneratorObject*> genObj(
       cx, GetGeneratorObjectForFrame(cx, frame));
@@ -972,19 +976,19 @@ class MOZ_RAII AutoSetGeneratorRunning {
   }
 };
 
 /*
  * Handle leaving a frame with debuggers watching. |frameOk| indicates whether
  * the frame is exiting normally or abruptly. Set |cx|'s exception and/or
  * |cx->fp()|'s return value, and return a new success value.
  */
-/* static */ bool Debugger::slowPathOnLeaveFrame(JSContext* cx,
-                                                 AbstractFramePtr frame,
-                                                 jsbytecode* pc, bool frameOk) {
+/* static */
+bool Debugger::slowPathOnLeaveFrame(JSContext* cx, AbstractFramePtr frame,
+                                    jsbytecode* pc, bool frameOk) {
   mozilla::DebugOnly<Handle<GlobalObject*>> debuggeeGlobal = cx->global();
 
   // Determine if we are suspending this frame or popping it forever.
   bool suspending = false;
   Rooted<AbstractGeneratorObject*> genObj(cx);
   if (frame.isGeneratorFrame()) {
     // If we're leaving successfully at a yield opcode, we're probably
     // suspending; the `isClosed()` check detects a debugger forced return
@@ -1094,19 +1098,19 @@ class MOZ_RAII AutoSetGeneratorRunning {
       MOZ_ASSERT(!cx->isExceptionPending());
       return false;
 
     default:
       MOZ_CRASH("bad final onLeaveFrame resume mode");
   }
 }
 
-/* static */ bool Debugger::slowPathOnNewGenerator(
-    JSContext* cx, AbstractFramePtr frame,
-    Handle<AbstractGeneratorObject*> genObj) {
+/* static */
+bool Debugger::slowPathOnNewGenerator(JSContext* cx, AbstractFramePtr frame,
+                                      Handle<AbstractGeneratorObject*> genObj) {
   // This is called from JSOP_GENERATOR, after default parameter expressions
   // are evaluated and well after onEnterFrame, so Debugger.Frame objects for
   // `frame` may already have been exposed to debugger code. The
   // AbstractGeneratorObject for this generator call, though, has just been
   // created. It must be associated with any existing Debugger.Frames.
   bool ok = true;
   forEachDebuggerFrame(frame, [&](DebuggerFrame* frameObjPtr) {
     if (!ok) {
@@ -1122,18 +1126,19 @@ class MOZ_RAII AutoSetGeneratorRunning {
       // because we won't pause again with this generator on the stack:
       // the caller will immediately discard `genObj` and unwind `frame`.
       ok = false;
     }
   });
   return ok;
 }
 
-/* static */ ResumeMode Debugger::slowPathOnDebuggerStatement(
-    JSContext* cx, AbstractFramePtr frame) {
+/* static */
+ResumeMode Debugger::slowPathOnDebuggerStatement(JSContext* cx,
+                                                 AbstractFramePtr frame) {
   RootedValue rval(cx);
   ResumeMode resumeMode = dispatchHook(
       cx,
       [](Debugger* dbg) -> bool { return dbg->getHook(OnDebuggerStatement); },
       [&](Debugger* dbg) -> ResumeMode {
         return dbg->fireDebuggerStatement(cx, &rval);
       });
 
@@ -1152,18 +1157,19 @@ class MOZ_RAII AutoSetGeneratorRunning {
 
     default:
       MOZ_CRASH("Invalid onDebuggerStatement resume mode");
   }
 
   return resumeMode;
 }
 
-/* static */ ResumeMode Debugger::slowPathOnExceptionUnwind(
-    JSContext* cx, AbstractFramePtr frame) {
+/* static */
+ResumeMode Debugger::slowPathOnExceptionUnwind(JSContext* cx,
+                                               AbstractFramePtr frame) {
   // Invoking more JS on an over-recursed stack or after OOM is only going
   // to result in more of the same error.
   if (cx->isThrowingOverRecursed() || cx->isThrowingOutOfMemory()) {
     return ResumeMode::Continue;
   }
 
   // The Debugger API mustn't muck with frames from self-hosted scripts.
   if (frame.hasScript() && frame.script()->selfHosted()) {
@@ -1822,20 +1828,20 @@ ResumeMode Debugger::processHandlerResul
     return handleUncaughtException(ar, vp, maybeThisv, frame);
   }
   return leaveDebugger(ar, frame, maybeThisv, CallUncaughtExceptionHook::Yes,
                        resumeMode, vp);
 }
 
 /*** Debuggee completion values *********************************************/
 
-/* static */ void Debugger::resultToCompletion(JSContext* cx, bool ok,
-                                               const Value& rv,
-                                               ResumeMode* resumeMode,
-                                               MutableHandleValue value) {
+/* static */
+void Debugger::resultToCompletion(JSContext* cx, bool ok, const Value& rv,
+                                  ResumeMode* resumeMode,
+                                  MutableHandleValue value) {
   MOZ_ASSERT_IF(ok, !cx->isExceptionPending());
 
   if (ok) {
     *resumeMode = ResumeMode::Return;
     value.set(rv);
   } else if (cx->isExceptionPending()) {
     *resumeMode = ResumeMode::Throw;
     if (!cx->getPendingException(value)) {
@@ -2067,19 +2073,19 @@ void Debugger::fireOnGarbageCollectionHo
   RootedValue rv(cx);
   if (!js::Call(cx, fval, object, dataVal, &rv)) {
     handleUncaughtException(ar);
   }
 }
 
 template <typename HookIsEnabledFun /* bool (Debugger*) */,
           typename FireHookFun /* ResumeMode (Debugger*) */>
-/* static */ ResumeMode Debugger::dispatchHook(JSContext* cx,
-                                               HookIsEnabledFun hookIsEnabled,
-                                               FireHookFun fireHook) {
+/* static */
+ResumeMode Debugger::dispatchHook(JSContext* cx, HookIsEnabledFun hookIsEnabled,
+                                  FireHookFun fireHook) {
   // Determine which debuggers will receive this event, and in what order.
   // Make a copy of the list, since the original is mutable and we will be
   // calling into arbitrary JS.
   //
   // Note: In the general case, 'triggered' contains references to objects in
   // different compartments--every compartment *except* this one.
   AutoValueVector triggered(cx);
   Handle<GlobalObject*> global = cx->global();
@@ -2159,17 +2165,18 @@ void Debugger::slowPathOnNewWasmInstance
   if (resumeMode == ResumeMode::Terminate) {
     cx->clearPendingException();
     return;
   }
 
   MOZ_ASSERT(resumeMode == ResumeMode::Continue);
 }
 
-/* static */ ResumeMode Debugger::onTrap(JSContext* cx, MutableHandleValue vp) {
+/* static */
+ResumeMode Debugger::onTrap(JSContext* cx, MutableHandleValue vp) {
   FrameIter iter(cx);
   JS::AutoSaveExceptionState savedExc(cx);
   Rooted<GlobalObject*> global(cx);
   BreakpointSite* site;
   bool isJS;       // true when iter.hasScript(), false when iter.isWasm()
   jsbytecode* pc;  // valid when isJS == true
   uint32_t bytecodeOffset;  // valid when isJS == false
   if (iter.hasScript()) {
@@ -2268,18 +2275,18 @@ void Debugger::slowPathOnNewWasmInstance
   if (isJS) {
     vp.setInt32(JSOp(*pc));
   } else {
     vp.set(UndefinedValue());
   }
   return ResumeMode::Continue;
 }
 
-/* static */ ResumeMode Debugger::onSingleStep(JSContext* cx,
-                                               MutableHandleValue vp) {
+/* static */
+ResumeMode Debugger::onSingleStep(JSContext* cx, MutableHandleValue vp) {
   FrameIter iter(cx);
 
   // We may be stepping over a JSOP_EXCEPTION, that pushes the context's
   // pending exception for a 'catch' clause to handle. Don't let the onStep
   // handlers mess with that (other than by returning a resumption value).
   JS::AutoSaveExceptionState savedExc(cx);
 
   // Build list of Debugger.Frame instances referring to this frame with
@@ -2455,19 +2462,21 @@ void Debugger::slowPathOnNewGlobalObject
           resumeMode != ResumeMode::Return) {
         break;
       }
     }
   }
   MOZ_ASSERT(!cx->isExceptionPending());
 }
 
-/* static */ bool Debugger::slowPathOnLogAllocationSite(
-    JSContext* cx, HandleObject obj, HandleSavedFrame frame,
-    mozilla::TimeStamp when, GlobalObject::DebuggerVector& dbgs) {
+/* static */
+bool Debugger::slowPathOnLogAllocationSite(JSContext* cx, HandleObject obj,
+                                           HandleSavedFrame frame,
+                                           mozilla::TimeStamp when,
+                                           GlobalObject::DebuggerVector& dbgs) {
   MOZ_ASSERT(!dbgs.empty());
   mozilla::DebugOnly<ReadBarriered<Debugger*>*> begin = dbgs.begin();
 
   // Root all the Debuggers while we're iterating over them;
   // appendAllocationSite calls Compartment::wrap, and thus can GC.
   //
   // SpiderMonkey protocol is generally for the caller to prove that it has
   // rooted the stuff it's asking you to operate on (i.e. by passing a
@@ -2573,18 +2582,19 @@ ResumeMode Debugger::firePromiseHook(JSC
   }
 
   ResumeMode resumeMode =
       ok ? ResumeMode::Continue : handleUncaughtException(ar, vp);
   MOZ_ASSERT(!cx->isExceptionPending());
   return resumeMode;
 }
 
-/* static */ void Debugger::slowPathPromiseHook(
-    JSContext* cx, Hook hook, Handle<PromiseObject*> promise) {
+/* static */
+void Debugger::slowPathPromiseHook(JSContext* cx, Hook hook,
+                                   Handle<PromiseObject*> promise) {
   MOZ_ASSERT(hook == OnNewPromise || hook == OnPromiseSettled);
 
   if (hook == OnPromiseSettled) {
     // We should be in the right compartment, but for simplicity always enter
     // the promise's realm below.
     cx->check(promise);
   }
 
@@ -2745,17 +2755,18 @@ class MOZ_RAII ExecutionObservableScript
     // iter refers to one such, we know we don't match.
     return iter.hasUsableAbstractFramePtr() && !iter.isWasm() &&
            iter.abstractFramePtr().script() == script_;
   }
 
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
-/* static */ bool Debugger::updateExecutionObservabilityOfFrames(
+/* static */
+bool Debugger::updateExecutionObservabilityOfFrames(
     JSContext* cx, const ExecutionObservableSet& obs, IsObserving observing) {
   AutoSuppressProfilerSampling suppressProfilerSampling(cx);
 
   {
     jit::JitContext jctx(cx, nullptr);
     if (!jit::RecompileOnStackBaselineScriptsForDebugMode(cx, obs, observing)) {
       ReportOutOfMemory(cx);
       return false;
@@ -2895,17 +2906,18 @@ static bool UpdateExecutionObservability
       bool enableTrap = observing == Debugger::IsObserving::Observing;
       instance->debug().ensureEnterFrameTrapsState(cx, enableTrap);
     }
   }
 
   return true;
 }
 
-/* static */ bool Debugger::updateExecutionObservabilityOfScripts(
+/* static */
+bool Debugger::updateExecutionObservabilityOfScripts(
     JSContext* cx, const ExecutionObservableSet& obs, IsObserving observing) {
   if (Zone* zone = obs.singleZone()) {
     return UpdateExecutionObservabilityOfScriptsInZone(cx, zone, obs,
                                                        observing);
   }
 
   typedef ExecutionObservableSet::ZoneRange ZoneRange;
   for (ZoneRange r = obs.zones()->all(); !r.empty(); r.popFront()) {
@@ -2914,98 +2926,106 @@ static bool UpdateExecutionObservability
       return false;
     }
   }
 
   return true;
 }
 
 template <typename FrameFn>
-/* static */ void Debugger::forEachDebuggerFrame(AbstractFramePtr frame,
-                                                 FrameFn fn) {
+/* static */
+void Debugger::forEachDebuggerFrame(AbstractFramePtr frame, FrameFn fn) {
   GlobalObject* global = frame.global();
   if (GlobalObject::DebuggerVector* debuggers = global->getDebuggers()) {
     for (auto p = debuggers->begin(); p != debuggers->end(); p++) {
       Debugger* dbg = *p;
       if (FrameMap::Ptr entry = dbg->frames.lookup(frame)) {
         fn(entry->value());
       }
     }
   }
 }
 
-/* static */ bool Debugger::getDebuggerFrames(
-    AbstractFramePtr frame, MutableHandle<DebuggerFrameVector> frames) {
+/* static */
+bool Debugger::getDebuggerFrames(AbstractFramePtr frame,
+                                 MutableHandle<DebuggerFrameVector> frames) {
   bool hadOOM = false;
   forEachDebuggerFrame(frame, [&](DebuggerFrame* frameobj) {
     if (!hadOOM && !frames.append(frameobj)) {
       hadOOM = true;
     }
   });
   return !hadOOM;
 }
 
-/* static */ bool Debugger::updateExecutionObservability(
-    JSContext* cx, ExecutionObservableSet& obs, IsObserving observing) {
+/* static */
+bool Debugger::updateExecutionObservability(JSContext* cx,
+                                            ExecutionObservableSet& obs,
+                                            IsObserving observing) {
   if (!obs.singleZone() && obs.zones()->empty()) {
     return true;
   }
 
   // Invalidate scripts first so we can set the needsArgsObj flag on scripts
   // before patching frames.
   return updateExecutionObservabilityOfScripts(cx, obs, observing) &&
          updateExecutionObservabilityOfFrames(cx, obs, observing);
 }
 
-/* static */ bool Debugger::ensureExecutionObservabilityOfScript(
-    JSContext* cx, JSScript* script) {
+/* static */
+bool Debugger::ensureExecutionObservabilityOfScript(JSContext* cx,
+                                                    JSScript* script) {
   if (script->isDebuggee()) {
     return true;
   }
   ExecutionObservableScript obs(cx, script);
   return updateExecutionObservability(cx, obs, Observing);
 }
 
-/* static */ bool Debugger::ensureExecutionObservabilityOfOsrFrame(
-    JSContext* cx, InterpreterFrame* frame) {
+/* static */
+bool Debugger::ensureExecutionObservabilityOfOsrFrame(JSContext* cx,
+                                                      InterpreterFrame* frame) {
   MOZ_ASSERT(frame->isDebuggee());
   if (frame->script()->hasBaselineScript() &&
       frame->script()->baselineScript()->hasDebugInstrumentation()) {
     return true;
   }
   ExecutionObservableFrame obs(frame);
   return updateExecutionObservabilityOfFrames(cx, obs, Observing);
 }
 
-/* static */ bool Debugger::ensureExecutionObservabilityOfFrame(
-    JSContext* cx, AbstractFramePtr frame) {
+/* static */
+bool Debugger::ensureExecutionObservabilityOfFrame(JSContext* cx,
+                                                   AbstractFramePtr frame) {
   MOZ_ASSERT_IF(frame.hasScript() && frame.script()->isDebuggee(),
                 frame.isDebuggee());
   MOZ_ASSERT_IF(frame.isWasmDebugFrame(), frame.wasmInstance()->debugEnabled());
   if (frame.isDebuggee()) {
     return true;
   }
   ExecutionObservableFrame obs(frame);
   return updateExecutionObservabilityOfFrames(cx, obs, Observing);
 }
 
-/* static */ bool Debugger::ensureExecutionObservabilityOfRealm(JSContext* cx,
-                                                                Realm* realm) {
+/* static */
+bool Debugger::ensureExecutionObservabilityOfRealm(JSContext* cx,
+                                                   Realm* realm) {
   if (realm->debuggerObservesAllExecution()) {
     return true;
   }
   ExecutionObservableRealms obs(cx);
   if (!obs.add(realm)) {
     return false;
   }
   realm->updateDebuggerObservesAllExecution();
   return updateExecutionObservability(cx, obs, Observing);
 }
 
-/* static */ bool Debugger::hookObservesAllExecution(Hook which) {
+/* static */
+bool Debugger::hookObservesAllExecution(Hook which) {
   return which == OnEnterFrame;
 }
 
 Debugger::IsObserving Debugger::observesAllExecution() const {
   if (enabled && !!getHook(OnEnterFrame)) {
     return Observing;
   }
   return NotObserving;
@@ -3117,56 +3137,60 @@ void Debugger::updateObservesAsmJSOnDebu
     }
 
     realm->updateDebuggerObservesAsmJS();
   }
 }
 
 /*** Allocations Tracking ***************************************************/
 
-/* static */ bool Debugger::cannotTrackAllocations(const GlobalObject& global) {
+/* static */
+bool Debugger::cannotTrackAllocations(const GlobalObject& global) {
   auto existingCallback = global.realm()->getAllocationMetadataBuilder();
   return existingCallback && existingCallback != &SavedStacks::metadataBuilder;
 }
 
-/* static */ bool Debugger::isObservedByDebuggerTrackingAllocations(
+/* static */
+bool Debugger::isObservedByDebuggerTrackingAllocations(
     const GlobalObject& debuggee) {
   if (auto* v = debuggee.getDebuggers()) {
     for (auto p = v->begin(); p != v->end(); p++) {
       // Use unbarrieredGet() to prevent triggering read barrier while
       // collecting, this is safe as long as dbg does not escape.
       Debugger* dbg = p->unbarrieredGet();
       if (dbg->trackingAllocationSites && dbg->enabled) {
         return true;
       }
     }
   }
 
   return false;
 }
 
-/* static */ bool Debugger::addAllocationsTracking(
-    JSContext* cx, Handle<GlobalObject*> debuggee) {
+/* static */
+bool Debugger::addAllocationsTracking(JSContext* cx,
+                                      Handle<GlobalObject*> debuggee) {
   // Precondition: the given global object is being observed by at least one
   // Debugger that is tracking allocations.
   MOZ_ASSERT(isObservedByDebuggerTrackingAllocations(*debuggee));
 
   if (Debugger::cannotTrackAllocations(*debuggee)) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_OBJECT_METADATA_CALLBACK_ALREADY_SET);
     return false;
   }
 
   debuggee->realm()->setAllocationMetadataBuilder(
       &SavedStacks::metadataBuilder);
   debuggee->realm()->chooseAllocationSamplingProbability();
   return true;
 }
 
-/* static */ void Debugger::removeAllocationsTracking(GlobalObject& global) {
+/* static */
+void Debugger::removeAllocationsTracking(GlobalObject& global) {
   // If there are still Debuggers that are observing allocations, we cannot
   // remove the metadata callback yet. Recompute the sampling probability
   // based on the remaining debuggers' needs.
   if (isObservedByDebuggerTrackingAllocations(global)) {
     global.realm()->chooseAllocationSamplingProbability();
     return;
   }
 
@@ -3243,17 +3267,18 @@ void Debugger::traceCrossCompartmentEdge
  * persist even when debuggees are removed.
  *
  * This happens during the initial mark phase, not iterative marking, because
  * all the edges being reported here are strong references.
  *
  * This method is also used during compacting GC to update cross compartment
  * pointers into zones that are being compacted.
  */
-/* static */ void Debugger::traceIncomingCrossCompartmentEdges(JSTracer* trc) {
+/* static */
+void Debugger::traceIncomingCrossCompartmentEdges(JSTracer* trc) {
   JSRuntime* rt = trc->runtime();
   gc::State state = rt->gc.state();
   MOZ_ASSERT(state == gc::State::MarkRoots || state == gc::State::Compact);
 
   for (Debugger* dbg : rt->debuggerList()) {
     Zone* zone = MaybeForwarded(dbg->object.get())->zone();
     if (!zone->isCollecting() || state == gc::State::Compact) {
       dbg->traceCrossCompartmentEdges(trc);
@@ -3266,17 +3291,18 @@ void Debugger::traceCrossCompartmentEdge
  *   1. Mark Debugger objects that are unreachable except for debugger hooks
  *      that may yet be called.
  *   2. Mark breakpoint handlers.
  *
  * This happens during the iterative part of the GC mark phase. This method
  * returns true if it has to mark anything; GC calls it repeatedly until it
  * returns false.
  */
-/* static */ bool Debugger::markIteratively(GCMarker* marker) {
+/* static */
+bool Debugger::markIteratively(GCMarker* marker) {
   MOZ_ASSERT(JS::RuntimeHeapIsCollecting(),
              "This method should be called during GC.");
   bool markedAny = false;
 
   // Find all Debugger objects in danger of GC. This code is a little
   // convoluted since the easiest way to find them is via their debuggees.
   JSRuntime* rt = marker->runtime();
   for (RealmsIter r(rt); !r.done(); r.next()) {
@@ -3342,17 +3368,18 @@ void Debugger::traceCrossCompartmentEdge
           }
         }
       }
     }
   }
   return markedAny;
 }
 
-/* static */ void Debugger::traceAllForMovingGC(JSTracer* trc) {
+/* static */
+void Debugger::traceAllForMovingGC(JSTracer* trc) {
   JSRuntime* rt = trc->runtime();
   for (Debugger* dbg : rt->debuggerList()) {
     dbg->traceForMovingGC(trc);
   }
 }
 
 /*
  * Trace all debugger-owned GC things unconditionally. This is used during
@@ -3377,17 +3404,18 @@ void Debugger::traceForMovingGC(JSTracer
         TraceManuallyBarrieredEdge(trc, &bp->asWasm()->wasmInstance,
                                    "breakpoint wasm instance");
         break;
     }
     TraceEdge(trc, &bp->getHandlerRef(), "breakpoint handler");
   }
 }
 
-/* static */ void Debugger::traceObject(JSTracer* trc, JSObject* obj) {
+/* static */
+void Debugger::traceObject(JSTracer* trc, JSObject* obj) {
   if (Debugger* dbg = Debugger::fromJSObject(obj)) {
     dbg->trace(trc);
   }
 }
 
 void Debugger::trace(JSTracer* trc) {
   TraceEdge(trc, &object, "Debugger Object");
 
@@ -3411,17 +3439,18 @@ void Debugger::trace(JSTracer* trc) {
   lazyScripts.trace(trc);
   sources.trace(trc);
   objects.trace(trc);
   environments.trace(trc);
   wasmInstanceScripts.trace(trc);
   wasmInstanceSources.trace(trc);
 }
 
-/* static */ void Debugger::sweepAll(FreeOp* fop) {
+/* static */
+void Debugger::sweepAll(FreeOp* fop) {
   JSRuntime* rt = fop->runtime();
 
   Debugger* dbg = rt->debuggerList().getFirst();
   while (dbg) {
     Debugger* next = dbg->getNext();
 
     // Detach dying debuggers and debuggees from each other. Since this
     // requires access to both objects it must be done before either
@@ -3438,26 +3467,27 @@ void Debugger::trace(JSTracer* trc) {
     if (debuggerDying) {
       fop->delete_(dbg);
     }
 
     dbg = next;
   }
 }
 
-/* static */ void Debugger::detachAllDebuggersFromGlobal(FreeOp* fop,
-                                                         GlobalObject* global) {
+/* static */
+void Debugger::detachAllDebuggersFromGlobal(FreeOp* fop, GlobalObject* global) {
   const GlobalObject::DebuggerVector* debuggers = global->getDebuggers();
   MOZ_ASSERT(!debuggers->empty());
   while (!debuggers->empty()) {
     debuggers->back()->removeDebuggeeGlobal(fop, global, nullptr);
   }
 }
 
-/* static */ bool Debugger::findSweepGroupEdges(Zone* zone) {
+/* static */
+bool Debugger::findSweepGroupEdges(Zone* zone) {
   JSRuntime* rt = zone->runtimeFromMainThread();
   for (Debugger* dbg : rt->debuggerList()) {
     Zone* debuggerZone = dbg->object->zone();
     if (!debuggerZone->isGCMarking()) {
       continue;
     }
 
     if (debuggerZone == zone) {
@@ -3535,25 +3565,25 @@ static Debugger* Debugger_fromThisValue(
   return dbg;
 }
 
 #define THIS_DEBUGGER(cx, argc, vp, fnname, args, dbg)      \
   CallArgs args = CallArgsFromVp(argc, vp);                 \
   Debugger* dbg = Debugger_fromThisValue(cx, args, fnname); \
   if (!dbg) return false
 
-/* static */ bool Debugger::getEnabled(JSContext* cx, unsigned argc,
-                                       Value* vp) {
+/* static */
+bool Debugger::getEnabled(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "get enabled", args, dbg);
   args.rval().setBoolean(dbg->enabled);
   return true;
 }
 
-/* static */ bool Debugger::setEnabled(JSContext* cx, unsigned argc,
-                                       Value* vp) {
+/* static */
+bool Debugger::setEnabled(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "set enabled", args, dbg);
   if (!args.requireAtLeast(cx, "Debugger.set enabled", 1)) {
     return false;
   }
 
   bool wasEnabled = dbg->enabled;
   dbg->enabled = ToBoolean(args[0]);
 
@@ -3600,25 +3630,27 @@ static Debugger* Debugger_fromThisValue(
 
     dbg->updateObservesAsmJSOnDebuggees(dbg->observesAsmJS());
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::getHookImpl(JSContext* cx, CallArgs& args,
-                                        Debugger& dbg, Hook which) {
+/* static */
+bool Debugger::getHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg,
+                           Hook which) {
   MOZ_ASSERT(which >= 0 && which < HookCount);
   args.rval().set(dbg.object->getReservedSlot(JSSLOT_DEBUG_HOOK_START + which));
   return true;
 }
 
-/* static */ bool Debugger::setHookImpl(JSContext* cx, CallArgs& args,
-                                        Debugger& dbg, Hook which) {
+/* static */
+bool Debugger::setHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg,
+                           Hook which) {
   MOZ_ASSERT(which >= 0 && which < HookCount);
   if (!args.requireAtLeast(cx, "Debugger.setHook", 1)) {
     return false;
   }
   if (args[0].isObject()) {
     if (!args[0].toObject().isCallable()) {
       return ReportIsNotFunction(cx, args[0], args.length() - 1);
     }
@@ -3636,96 +3668,96 @@ static Debugger* Debugger_fromThisValue(
       dbg.object->setReservedSlot(slot, oldHook);
       return false;
     }
   }
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::getOnDebuggerStatement(JSContext* cx, unsigned argc,
-                                                   Value* vp) {
+/* static */
+bool Debugger::getOnDebuggerStatement(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(get onDebuggerStatement)", args, dbg);
   return getHookImpl(cx, args, *dbg, OnDebuggerStatement);
 }
 
-/* static */ bool Debugger::setOnDebuggerStatement(JSContext* cx, unsigned argc,
-                                                   Value* vp) {
+/* static */
+bool Debugger::setOnDebuggerStatement(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(set onDebuggerStatement)", args, dbg);
   return setHookImpl(cx, args, *dbg, OnDebuggerStatement);
 }
 
-/* static */ bool Debugger::getOnExceptionUnwind(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool Debugger::getOnExceptionUnwind(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(get onExceptionUnwind)", args, dbg);
   return getHookImpl(cx, args, *dbg, OnExceptionUnwind);
 }
 
-/* static */ bool Debugger::setOnExceptionUnwind(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool Debugger::setOnExceptionUnwind(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(set onExceptionUnwind)", args, dbg);
   return setHookImpl(cx, args, *dbg, OnExceptionUnwind);
 }
 
-/* static */ bool Debugger::getOnNewScript(JSContext* cx, unsigned argc,
-                                           Value* vp) {
+/* static */
+bool Debugger::getOnNewScript(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(get onNewScript)", args, dbg);
   return getHookImpl(cx, args, *dbg, OnNewScript);
 }
 
-/* static */ bool Debugger::setOnNewScript(JSContext* cx, unsigned argc,
-                                           Value* vp) {
+/* static */
+bool Debugger::setOnNewScript(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(set onNewScript)", args, dbg);
   return setHookImpl(cx, args, *dbg, OnNewScript);
 }
 
-/* static */ bool Debugger::getOnNewPromise(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool Debugger::getOnNewPromise(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(get onNewPromise)", args, dbg);
   return getHookImpl(cx, args, *dbg, OnNewPromise);
 }
 
-/* static */ bool Debugger::setOnNewPromise(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool Debugger::setOnNewPromise(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(set onNewPromise)", args, dbg);
   return setHookImpl(cx, args, *dbg, OnNewPromise);
 }
 
-/* static */ bool Debugger::getOnPromiseSettled(JSContext* cx, unsigned argc,
-                                                Value* vp) {
+/* static */
+bool Debugger::getOnPromiseSettled(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(get onPromiseSettled)", args, dbg);
   return getHookImpl(cx, args, *dbg, OnPromiseSettled);
 }
 
-/* static */ bool Debugger::setOnPromiseSettled(JSContext* cx, unsigned argc,
-                                                Value* vp) {
+/* static */
+bool Debugger::setOnPromiseSettled(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(set onPromiseSettled)", args, dbg);
   return setHookImpl(cx, args, *dbg, OnPromiseSettled);
 }
 
-/* static */ bool Debugger::getOnEnterFrame(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool Debugger::getOnEnterFrame(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(get onEnterFrame)", args, dbg);
   return getHookImpl(cx, args, *dbg, OnEnterFrame);
 }
 
-/* static */ bool Debugger::setOnEnterFrame(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool Debugger::setOnEnterFrame(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(set onEnterFrame)", args, dbg);
   return setHookImpl(cx, args, *dbg, OnEnterFrame);
 }
 
-/* static */ bool Debugger::getOnNewGlobalObject(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool Debugger::getOnNewGlobalObject(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "(get onNewGlobalObject)", args, dbg);
   return getHookImpl(cx, args, *dbg, OnNewGlobalObject);
 }
 
-/* static */ bool Debugger::setOnNewGlobalObject(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool Debugger::setOnNewGlobalObject(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "setOnNewGlobalObject", args, dbg);
   RootedObject oldHook(cx, dbg->getHook(OnNewGlobalObject));
 
   if (!setHookImpl(cx, args, *dbg, OnNewGlobalObject)) {
     return false;
   }
 
   // Add or remove ourselves from the runtime's list of Debuggers that care
@@ -3737,50 +3769,54 @@ static Debugger* Debugger_fromThisValue(
     } else if (oldHook && !newHook) {
       cx->runtime()->onNewGlobalObjectWatchers().remove(dbg);
     }
   }
 
   return true;
 }
 
-/* static */ bool Debugger::getUncaughtExceptionHook(JSContext* cx,
-                                                     unsigned argc, Value* vp) {
+/* static */
+bool Debugger::getUncaughtExceptionHook(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "get uncaughtExceptionHook", args, dbg);
   args.rval().setObjectOrNull(dbg->uncaughtExceptionHook);
   return true;
 }
 
-/* static */ bool Debugger::setUncaughtExceptionHook(JSContext* cx,
-                                                     unsigned argc, Value* vp) {
+/* static */
+bool Debugger::setUncaughtExceptionHook(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "set uncaughtExceptionHook", args, dbg);
   if (!args.requireAtLeast(cx, "Debugger.set uncaughtExceptionHook", 1)) {
     return false;
   }
   if (!args[0].isNull() &&
       (!args[0].isObject() || !args[0].toObject().isCallable())) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_ASSIGN_FUNCTION_OR_NULL,
                               "uncaughtExceptionHook");
     return false;
   }
   dbg->uncaughtExceptionHook = args[0].toObjectOrNull();
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::getAllowUnobservedAsmJS(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool Debugger::getAllowUnobservedAsmJS(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "get allowUnobservedAsmJS", args, dbg);
   args.rval().setBoolean(dbg->allowUnobservedAsmJS);
   return true;
 }
 
-/* static */ bool Debugger::setAllowUnobservedAsmJS(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool Debugger::setAllowUnobservedAsmJS(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "set allowUnobservedAsmJS", args, dbg);
   if (!args.requireAtLeast(cx, "Debugger.set allowUnobservedAsmJS", 1)) {
     return false;
   }
   dbg->allowUnobservedAsmJS = ToBoolean(args[0]);
 
   for (WeakGlobalObjectSet::Range r = dbg->debuggees.all(); !r.empty();
        r.popFront()) {
@@ -3788,41 +3824,42 @@ static Debugger* Debugger_fromThisValue(
     Realm* realm = global->realm();
     realm->updateDebuggerObservesAsmJS();
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::getCollectCoverageInfo(JSContext* cx, unsigned argc,
-                                                   Value* vp) {
+/* static */
+bool Debugger::getCollectCoverageInfo(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "get collectCoverageInfo", args, dbg);
   args.rval().setBoolean(dbg->collectCoverageInfo);
   return true;
 }
 
-/* static */ bool Debugger::setCollectCoverageInfo(JSContext* cx, unsigned argc,
-                                                   Value* vp) {
+/* static */
+bool Debugger::setCollectCoverageInfo(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "set collectCoverageInfo", args, dbg);
   if (!args.requireAtLeast(cx, "Debugger.set collectCoverageInfo", 1)) {
     return false;
   }
   dbg->collectCoverageInfo = ToBoolean(args[0]);
 
   IsObserving observing = dbg->collectCoverageInfo ? Observing : NotObserving;
   if (!dbg->updateObservesCoverageOnDebuggees(cx, observing)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::getMemory(JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool Debugger::getMemory(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "get memory", args, dbg);
   Value memoryValue =
       dbg->object->getReservedSlot(JSSLOT_DEBUG_MEMORY_INSTANCE);
 
   if (!memoryValue.isObject()) {
     RootedObject memory(cx, DebuggerMemory::create(cx, dbg));
     if (!memory) {
       return false;
@@ -3878,18 +3915,18 @@ GlobalObject* Debugger::unwrapDebuggeeAr
                               JSMSG_UNEXPECTED_TYPE, "argument",
                               "not a global object");
     return nullptr;
   }
 
   return &obj->as<GlobalObject>();
 }
 
-/* static */ bool Debugger::addDebuggee(JSContext* cx, unsigned argc,
-                                        Value* vp) {
+/* static */
+bool Debugger::addDebuggee(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "addDebuggee", args, dbg);
   if (!args.requireAtLeast(cx, "Debugger.addDebuggee", 1)) {
     return false;
   }
   Rooted<GlobalObject*> global(cx, dbg->unwrapDebuggeeArgument(cx, args[0]));
   if (!global) {
     return false;
   }
@@ -3901,18 +3938,19 @@ GlobalObject* Debugger::unwrapDebuggeeAr
   RootedValue v(cx, ObjectValue(*global));
   if (!dbg->wrapDebuggeeValue(cx, &v)) {
     return false;
   }
   args.rval().set(v);
   return true;
 }
 
-/* static */ bool Debugger::addAllGlobalsAsDebuggees(JSContext* cx,
-                                                     unsigned argc, Value* vp) {
+/* static */
+bool Debugger::addAllGlobalsAsDebuggees(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "addAllGlobalsAsDebuggees", args, dbg);
   for (CompartmentsIter comp(cx->runtime()); !comp.done(); comp.next()) {
     if (comp == dbg->object->compartment()) {
       continue;
     }
     for (RealmsInCompartmentIter r(comp); !r.done(); r.next()) {
       if (r->creationOptions().invisibleToDebugger()) {
         continue;
@@ -3927,18 +3965,18 @@ GlobalObject* Debugger::unwrapDebuggeeAr
       }
     }
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::removeDebuggee(JSContext* cx, unsigned argc,
-                                           Value* vp) {
+/* static */
+bool Debugger::removeDebuggee(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "removeDebuggee", args, dbg);
 
   if (!args.requireAtLeast(cx, "Debugger.removeDebuggee", 1)) {
     return false;
   }
   Rooted<GlobalObject*> global(cx, dbg->unwrapDebuggeeArgument(cx, args[0]));
   if (!global) {
     return false;
@@ -3959,18 +3997,18 @@ GlobalObject* Debugger::unwrapDebuggeeAr
       return false;
     }
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::removeAllDebuggees(JSContext* cx, unsigned argc,
-                                               Value* vp) {
+/* static */
+bool Debugger::removeAllDebuggees(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "removeAllDebuggees", args, dbg);
 
   ExecutionObservableRealms obs(cx);
 
   for (WeakGlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront()) {
     Rooted<GlobalObject*> global(cx, e.front());
     dbg->removeDebuggeeGlobal(cx->runtime()->defaultFreeOp(), global, &e);
 
@@ -3983,32 +4021,32 @@ GlobalObject* Debugger::unwrapDebuggeeAr
   if (!updateExecutionObservability(cx, obs, NotObserving)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool Debugger::hasDebuggee(JSContext* cx, unsigned argc,
-                                        Value* vp) {
+/* static */
+bool Debugger::hasDebuggee(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "hasDebuggee", args, dbg);
   if (!args.requireAtLeast(cx, "Debugger.hasDebuggee", 1)) {
     return false;
   }
   GlobalObject* global = dbg->unwrapDebuggeeArgument(cx, args[0]);
   if (!global) {
     return false;
   }
   args.rval().setBoolean(!!dbg->debuggees.lookup(global));
   return true;
 }
 
-/* static */ bool Debugger::getDebuggees(JSContext* cx, unsigned argc,
-                                         Value* vp) {
+/* static */
+bool Debugger::getDebuggees(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "getDebuggees", args, dbg);
 
   // Obtain the list of debuggees before wrapping each debuggee, as a GC could
   // update the debuggees set while we are iterating it.
   unsigned count = dbg->debuggees.count();
   AutoValueVector debuggees(cx);
   if (!debuggees.resize(count)) {
     return false;
@@ -4034,18 +4072,18 @@ GlobalObject* Debugger::unwrapDebuggeeAr
     }
     arrobj->setDenseElement(i, v);
   }
 
   args.rval().setObject(*arrobj);
   return true;
 }
 
-/* static */ bool Debugger::getNewestFrame(JSContext* cx, unsigned argc,
-                                           Value* vp) {
+/* static */
+bool Debugger::getNewestFrame(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "getNewestFrame", args, dbg);
 
   // Since there may be multiple contexts, use AllFramesIter.
   for (AllFramesIter i(cx); !i.done(); ++i) {
     if (dbg->observesFrame(i)) {
       // Ensure that Ion frames are rematerialized. Only rematerialized
       // Ion frames may be used as AbstractFramePtrs.
       if (i.isIon() && !i.ensureHasRematerializedFrame(cx)) {
@@ -4059,28 +4097,29 @@ GlobalObject* Debugger::unwrapDebuggeeAr
       }
       return dbg->getFrame(cx, iter, args.rval());
     }
   }
   args.rval().setNull();
   return true;
 }
 
-/* static */ bool Debugger::clearAllBreakpoints(JSContext* cx, unsigned argc,
-                                                Value* vp) {
+/* static */
+bool Debugger::clearAllBreakpoints(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "clearAllBreakpoints", args, dbg);
   for (WeakGlobalObjectSet::Range r = dbg->debuggees.all(); !r.empty();
        r.popFront()) {
     r.front()->realm()->clearBreakpointsIn(cx->runtime()->defaultFreeOp(), dbg,
                                            nullptr);
   }
   return true;
 }
 
-/* static */ bool Debugger::construct(JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool Debugger::construct(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   // Check that the arguments, if any, are cross-compartment wrappers.
   for (unsigned i = 0; i < args.length(); i++) {
     JSObject* argobj = NonNullObject(cx, args[i]);
     if (!argobj) {
       return false;
     }
@@ -4976,18 +5015,18 @@ class MOZ_STACK_CLASS Debugger::ScriptQu
     }
 
     if (!wasmInstanceVector.append(instanceObject)) {
       oom = true;
     }
   }
 };
 
-/* static */ bool Debugger::findScripts(JSContext* cx, unsigned argc,
-                                        Value* vp) {
+/* static */
+bool Debugger::findScripts(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "findScripts", args, dbg);
 
   ScriptQuery query(cx, dbg);
 
   if (args.length() >= 1) {
     RootedObject queryObject(cx, NonNullObject(cx, args[0]));
     if (!queryObject || !query.parseQuery(queryObject)) {
       return false;
@@ -5163,18 +5202,18 @@ class MOZ_STACK_CLASS Debugger::SourceQu
 
 static inline DebuggerSourceReferent AsSourceReferent(JSObject* obj) {
   if (obj->is<ScriptSourceObject>()) {
     return AsVariant(&obj->as<ScriptSourceObject>());
   }
   return AsVariant(&obj->as<WasmInstanceObject>());
 }
 
-/* static */ bool Debugger::findSources(JSContext* cx, unsigned argc,
-                                        Value* vp) {
+/* static */
+bool Debugger::findSources(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "findSources", args, dbg);
 
   SourceQuery query(cx, dbg);
   if (!query.findSources()) {
     return false;
   }
 
   Handle<SourceQuery::SourceSet> sources(query.foundSources());
@@ -5417,18 +5456,18 @@ bool Debugger::findObjects(JSContext* cx
     }
     result->setDenseElement(i, debuggeeVal);
   }
 
   args.rval().setObject(*result);
   return true;
 }
 
-/* static */ bool Debugger::findAllGlobals(JSContext* cx, unsigned argc,
-                                           Value* vp) {
+/* static */
+bool Debugger::findAllGlobals(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "findAllGlobals", args, dbg);
 
   AutoObjectVector globals(cx);
 
   {
     // Accumulate the list of globals before wrapping them, because
     // wrapping can GC and collect realms from under us, while iterating.
     JS::AutoCheckCannotGC nogc;
@@ -5472,19 +5511,19 @@ bool Debugger::findObjects(JSContext* cx
       return false;
     }
   }
 
   args.rval().setObject(*result);
   return true;
 }
 
-/* static */ bool Debugger::makeGlobalObjectReference(JSContext* cx,
-                                                      unsigned argc,
-                                                      Value* vp) {
+/* static */
+bool Debugger::makeGlobalObjectReference(JSContext* cx, unsigned argc,
+                                         Value* vp) {
   THIS_DEBUGGER(cx, argc, vp, "makeGlobalObjectReference", args, dbg);
   if (!args.requireAtLeast(cx, "Debugger.makeGlobalObjectReference", 1)) {
     return false;
   }
 
   Rooted<GlobalObject*> global(cx, dbg->unwrapDebuggeeArgument(cx, args[0]));
   if (!global) {
     return false;
@@ -5556,18 +5595,19 @@ bool Debugger::isCompilableUnit(JSContex
 
     cx->clearPendingException();
   }
 
   args.rval().setBoolean(result);
   return true;
 }
 
-/* static */ bool Debugger::recordReplayProcessKind(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool Debugger::recordReplayProcessKind(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   if (mozilla::recordreplay::IsMiddleman()) {
     JSString* str = JS_NewStringCopyZ(cx, "Middleman");
     if (!str) {
       return false;
     }
     args.rval().setString(str);
@@ -7482,20 +7522,19 @@ bool Debugger::observesScript(JSScript* 
 
 bool Debugger::observesWasm(wasm::Instance* instance) const {
   if (!enabled || !instance->debugEnabled()) {
     return false;
   }
   return observesGlobal(&instance->object()->global());
 }
 
-/* static */ bool Debugger::replaceFrameGuts(JSContext* cx,
-                                             AbstractFramePtr from,
-                                             AbstractFramePtr to,
-                                             ScriptFrameIter& iter) {
+/* static */
+bool Debugger::replaceFrameGuts(JSContext* cx, AbstractFramePtr from,
+                                AbstractFramePtr to, ScriptFrameIter& iter) {
   auto removeFromDebuggerFramesOnExit = MakeScopeExit([&] {
     // Remove any remaining old entries on exit, as the 'from' frame will
     // be gone. This is only done in the failure case. On failure, the
     // removeToDebuggerFramesOnExit lambda below will rollback any frames
     // that were replaced, resulting in !frameMaps(to). On success, the
     // range will be empty, as all from Frame.Debugger instances will have
     // been removed.
     MOZ_ASSERT_IF(inFrameMaps(to), !inFrameMaps(from));
@@ -7566,25 +7605,28 @@ bool Debugger::observesWasm(wasm::Instan
   }
 
   // All frames successfuly replaced, cancel the rollback.
   removeToDebuggerFramesOnExit.release();
 
   return true;
 }
 
-/* static */ bool Debugger::inFrameMaps(AbstractFramePtr frame) {
+/* static */
+bool Debugger::inFrameMaps(AbstractFramePtr frame) {
   bool foundAny = false;
   forEachDebuggerFrame(frame,
                        [&](DebuggerFrame* frameobj) { foundAny = true; });
   return foundAny;
 }
 
-/* static */ void Debugger::removeFromFrameMapsAndClearBreakpointsIn(
-    JSContext* cx, AbstractFramePtr frame, bool suspending) {
+/* static */
+void Debugger::removeFromFrameMapsAndClearBreakpointsIn(JSContext* cx,
+                                                        AbstractFramePtr frame,
+                                                        bool suspending) {
   forEachDebuggerFrame(frame, [&](DebuggerFrame* frameobj) {
     FreeOp* fop = cx->runtime()->defaultFreeOp();
     frameobj->freeFrameIterData(fop);
     if (!suspending) {
       DebuggerFrame_maybeDecrementFrameScriptStepModeCount(fop, frame,
                                                            frameobj);
     }
 
@@ -7604,53 +7646,54 @@ bool Debugger::observesWasm(wasm::Instan
   // script is about to be destroyed. Remove any breakpoints in it.
   if (frame.isEvalFrame()) {
     RootedScript script(cx, frame.script());
     script->clearBreakpointsIn(cx->runtime()->defaultFreeOp(), nullptr,
                                nullptr);
   }
 }
 
-/* static */ bool Debugger::handleBaselineOsr(JSContext* cx,
-                                              InterpreterFrame* from,
-                                              jit::BaselineFrame* to) {
+/* static */
+bool Debugger::handleBaselineOsr(JSContext* cx, InterpreterFrame* from,
+                                 jit::BaselineFrame* to) {
   ScriptFrameIter iter(cx);
   MOZ_ASSERT(iter.abstractFramePtr() == to);
   return replaceFrameGuts(cx, from, to, iter);
 }
 
-/* static */ bool Debugger::handleIonBailout(JSContext* cx,
-                                             jit::RematerializedFrame* from,
-                                             jit::BaselineFrame* to) {
+/* static */
+bool Debugger::handleIonBailout(JSContext* cx, jit::RematerializedFrame* from,
+                                jit::BaselineFrame* to) {
   // When we return to a bailed-out Ion real frame, we must update all
   // Debugger.Frames that refer to its inline frames. However, since we
   // can't pop individual inline frames off the stack (we can only pop the
   // real frame that contains them all, as a unit), we cannot assume that
   // the frame we're dealing with is the top frame. Advance the iterator
   // across any inlined frames younger than |to|, the baseline frame
   // reconstructed during bailout from the Ion frame corresponding to
   // |from|.
   ScriptFrameIter iter(cx);
   while (iter.abstractFramePtr() != to) {
     ++iter;
   }
   return replaceFrameGuts(cx, from, to, iter);
 }
 
-/* static */ void Debugger::handleUnrecoverableIonBailoutError(
+/* static */
+void Debugger::handleUnrecoverableIonBailoutError(
     JSContext* cx, jit::RematerializedFrame* frame) {
   // Ion bailout can fail due to overrecursion. In such cases we cannot
   // honor any further Debugger hooks on the frame, and need to ensure that
   // its Debugger.Frame entry is cleaned up.
   removeFromFrameMapsAndClearBreakpointsIn(cx, frame);
 }
 
-/* static */ void Debugger::propagateForcedReturn(JSContext* cx,
-                                                  AbstractFramePtr frame,
-                                                  HandleValue rval) {
+/* static */
+void Debugger::propagateForcedReturn(JSContext* cx, AbstractFramePtr frame,
+                                     HandleValue rval) {
   // Invoking the interrupt handler is considered a step and invokes the
   // youngest frame's onStep handler, if any. However, we cannot handle
   // { return: ... } resumption values straightforwardly from the interrupt
   // handler. Instead, we set the intended return value in the frame's rval
   // slot and set the propagating-forced-return flag on the JSContext.
   //
   // The interrupt handler then returns false with no exception set,
   // signaling an uncatchable exception. In the exception handlers, we then
@@ -8750,62 +8793,63 @@ bool DebuggerFrame::resume(const FrameIt
   return true;
 }
 
 bool DebuggerFrame::hasAnyLiveHooks() const {
   return !getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER).isUndefined() ||
          !getReservedSlot(JSSLOT_DEBUGFRAME_ONPOP_HANDLER).isUndefined();
 }
 
-/* static */ NativeObject* DebuggerFrame::initClass(
-    JSContext* cx, HandleObject dbgCtor, Handle<GlobalObject*> global) {
+/* static */
+NativeObject* DebuggerFrame::initClass(JSContext* cx, HandleObject dbgCtor,
+                                       Handle<GlobalObject*> global) {
   return InitClass(cx, dbgCtor, nullptr, &class_, construct, 0, properties_,
                    methods_, nullptr, nullptr);
 }
 
-/* static */ DebuggerFrame* DebuggerFrame::create(JSContext* cx,
-                                                  HandleObject proto,
-                                                  const FrameIter& iter,
-                                                  HandleNativeObject debugger) {
+/* static */
+DebuggerFrame* DebuggerFrame::create(JSContext* cx, HandleObject proto,
+                                     const FrameIter& iter,
+                                     HandleNativeObject debugger) {
   DebuggerFrame* frame = NewObjectWithGivenProto<DebuggerFrame>(cx, proto);
   if (!frame) {
     return nullptr;
   }
 
   FrameIter::Data* data = iter.copyData();
   if (!data) {
     return nullptr;
   }
   frame->setPrivate(data);
 
   frame->setReservedSlot(JSSLOT_DEBUGFRAME_OWNER, ObjectValue(*debugger));
 
   return frame;
 }
 
-/* static */ bool DebuggerFrame::getCallee(JSContext* cx,
-                                           HandleDebuggerFrame frame,
-                                           MutableHandleDebuggerObject result) {
+/* static */
+bool DebuggerFrame::getCallee(JSContext* cx, HandleDebuggerFrame frame,
+                              MutableHandleDebuggerObject result) {
   MOZ_ASSERT(frame->isLive());
 
   AbstractFramePtr referent = DebuggerFrame::getReferent(frame);
   if (!referent.isFunctionFrame()) {
     result.set(nullptr);
     return true;
   }
 
   Debugger* dbg = frame->owner();
 
   RootedObject callee(cx, referent.callee());
   return dbg->wrapDebuggeeObject(cx, callee, result);
 }
 
-/* static */ bool DebuggerFrame::getIsConstructing(JSContext* cx,
-                                                   HandleDebuggerFrame frame,
-                                                   bool& result) {
+/* static */
+bool DebuggerFrame::getIsConstructing(JSContext* cx, HandleDebuggerFrame frame,
+                                      bool& result) {
   MOZ_ASSERT(frame->isLive());
 
   Maybe<FrameIter> maybeIter;
   if (!DebuggerFrame::getFrameIter(cx, frame, maybeIter)) {
     return false;
   }
   FrameIter& iter = *maybeIter;
 
@@ -8855,19 +8899,19 @@ static void UpdateFrameIterPc(FrameIter&
     MOZ_ASSERT(ionInlineIter.pc() == iter.pc());
 #endif
     return;
   }
 
   iter.updatePcQuadratic();
 }
 
-/* static */ bool DebuggerFrame::getEnvironment(
-    JSContext* cx, HandleDebuggerFrame frame,
-    MutableHandleDebuggerEnvironment result) {
+/* static */
+bool DebuggerFrame::getEnvironment(JSContext* cx, HandleDebuggerFrame frame,
+                                   MutableHandleDebuggerEnvironment result) {
   MOZ_ASSERT(frame->isLive());
 
   Debugger* dbg = frame->owner();
 
   Maybe<FrameIter> maybeIter;
   if (!DebuggerFrame::getFrameIter(cx, frame, maybeIter)) {
     return false;
   }
@@ -8881,24 +8925,25 @@ static void UpdateFrameIterPc(FrameIter&
     if (!env) {
       return false;
     }
   }
 
   return dbg->wrapEnvironment(cx, env, result);
 }
 
-/* static */ bool DebuggerFrame::getIsGenerator(HandleDebuggerFrame frame) {
+/* static */
+bool DebuggerFrame::getIsGenerator(HandleDebuggerFrame frame) {
   AbstractFramePtr referent = DebuggerFrame::getReferent(frame);
   return referent.hasScript() && referent.script()->isGenerator();
 }
 
-/* static */ bool DebuggerFrame::getOffset(JSContext* cx,
-                                           HandleDebuggerFrame frame,
-                                           size_t& result) {
+/* static */
+bool DebuggerFrame::getOffset(JSContext* cx, HandleDebuggerFrame frame,
+                              size_t& result) {
   MOZ_ASSERT(frame->isLive());
 
   Maybe<FrameIter> maybeIter;
   if (!DebuggerFrame::getFrameIter(cx, frame, maybeIter)) {
     return false;
   }
   FrameIter& iter = *maybeIter;
 
@@ -8910,19 +8955,19 @@ static void UpdateFrameIterPc(FrameIter&
     JSScript* script = iter.script();
     UpdateFrameIterPc(iter);
     jsbytecode* pc = iter.pc();
     result = script->pcToOffset(pc);
   }
   return true;
 }
 
-/* static */ bool DebuggerFrame::getOlder(JSContext* cx,
-                                          HandleDebuggerFrame frame,
-                                          MutableHandleDebuggerFrame result) {
+/* static */
+bool DebuggerFrame::getOlder(JSContext* cx, HandleDebuggerFrame frame,
+                             MutableHandleDebuggerFrame result) {
   MOZ_ASSERT(frame->isLive());
 
   Debugger* dbg = frame->owner();
 
   Maybe<FrameIter> maybeIter;
   if (!DebuggerFrame::getFrameIter(cx, frame, maybeIter)) {
     return false;
   }
@@ -8936,19 +8981,19 @@ static void UpdateFrameIterPc(FrameIter&
       return dbg->getFrame(cx, iter, result);
     }
   }
 
   result.set(nullptr);
   return true;
 }
 
-/* static */ bool DebuggerFrame::getThis(JSContext* cx,
-                                         HandleDebuggerFrame frame,
-                                         MutableHandleValue result) {
+/* static */
+bool DebuggerFrame::getThis(JSContext* cx, HandleDebuggerFrame frame,
+                            MutableHandleValue result) {
   MOZ_ASSERT(frame->isLive());
 
   if (!requireScriptReferent(cx, frame)) {
     return false;
   }
 
   Debugger* dbg = frame->owner();
 
@@ -8968,18 +9013,18 @@ static void UpdateFrameIterPc(FrameIter&
                                                   result)) {
       return false;
     }
   }
 
   return dbg->wrapDebuggeeValue(cx, result);
 }
 
-/* static */ DebuggerFrameType DebuggerFrame::getType(
-    HandleDebuggerFrame frame) {
+/* static */
+DebuggerFrameType DebuggerFrame::getType(HandleDebuggerFrame frame) {
   AbstractFramePtr referent = DebuggerFrame::getReferent(frame);
 
   // Indirect eval frames are both isGlobalFrame() and isEvalFrame(), so the
   // order of checks here is significant.
   if (referent.isEvalFrame()) {
     return DebuggerFrameType::Eval;
   } else if (referent.isGlobalFrame()) {
     return DebuggerFrameType::Global;
@@ -8988,17 +9033,18 @@ static void UpdateFrameIterPc(FrameIter&
   } else if (referent.isModuleFrame()) {
     return DebuggerFrameType::Module;
   } else if (referent.isWasmDebugFrame()) {
     return DebuggerFrameType::WasmCall;
   }
   MOZ_CRASH("Unknown frame type");
 }
 
-/* static */ DebuggerFrameImplementation DebuggerFrame::getImplementation(
+/* static */
+DebuggerFrameImplementation DebuggerFrame::getImplementation(
     HandleDebuggerFrame frame) {
   AbstractFramePtr referent = DebuggerFrame::getReferent(frame);
 
   if (referent.isBaselineFrame()) {
     return DebuggerFrameImplementation::Baseline;
   } else if (referent.isRematerializedFrame()) {
     return DebuggerFrameImplementation::Ion;
   } else if (referent.isWasmDebugFrame()) {
@@ -9007,19 +9053,19 @@ static void UpdateFrameIterPc(FrameIter&
   return DebuggerFrameImplementation::Interpreter;
 }
 
 /*
  * If succesful, transfers the ownership of the given `handler` to this
  * Debugger.Frame. Note that on failure, the ownership of `handler` is not
  * transferred, and the caller is responsible for cleaning it up.
  */
-/* static */ bool DebuggerFrame::setOnStepHandler(JSContext* cx,
-                                                  HandleDebuggerFrame frame,
-                                                  OnStepHandler* handler) {
+/* static */
+bool DebuggerFrame::setOnStepHandler(JSContext* cx, HandleDebuggerFrame frame,
+                                     OnStepHandler* handler) {
   MOZ_ASSERT(frame->isLive());
 
   OnStepHandler* prior = frame->onStepHandler();
   if (prior && handler != prior) {
     prior->drop();
   }
 
   AbstractFramePtr referent = DebuggerFrame::getReferent(frame);
@@ -9061,19 +9107,19 @@ static void UpdateFrameIterPc(FrameIter&
   }
 
   // Now that the step mode switch has succeeded, we can install the handler.
   frame->setReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER,
                          handler ? PrivateValue(handler) : UndefinedValue());
   return true;
 }
 
-/* static */ bool DebuggerFrame::getArguments(
-    JSContext* cx, HandleDebuggerFrame frame,
-    MutableHandleDebuggerArguments result) {
+/* static */
+bool DebuggerFrame::getArguments(JSContext* cx, HandleDebuggerFrame frame,
+                                 MutableHandleDebuggerArguments result) {
   Value argumentsv = frame->getReservedSlot(JSSLOT_DEBUGFRAME_ARGUMENTS);
   if (!argumentsv.isUndefined()) {
     result.set(argumentsv.isObject()
                    ? &argumentsv.toObject().as<DebuggerArguments>()
                    : nullptr);
     return true;
   }
 
@@ -9258,39 +9304,39 @@ static bool DebuggerGenericEval(JSContex
       cx, env, frame, chars,
       options.filename() ? options.filename() : "debugger eval code",
       options.lineno(), &rval);
   Debugger::resultToCompletion(cx, ok, rval, &resumeMode, value);
   ar.reset();
   return dbg->wrapDebuggeeValue(cx, value);
 }
 
-/* static */ bool DebuggerFrame::eval(JSContext* cx, HandleDebuggerFrame frame,
-                                      mozilla::Range<const char16_t> chars,
-                                      HandleObject bindings,
-                                      const EvalOptions& options,
-                                      ResumeMode& resumeMode,
-                                      MutableHandleValue value) {
+/* static */
+bool DebuggerFrame::eval(JSContext* cx, HandleDebuggerFrame frame,
+                         mozilla::Range<const char16_t> chars,
+                         HandleObject bindings, const EvalOptions& options,
+                         ResumeMode& resumeMode, MutableHandleValue value) {
   MOZ_ASSERT(frame->isLive());
 
   Debugger* dbg = frame->owner();
 
   Maybe<FrameIter> maybeIter;
   if (!DebuggerFrame::getFrameIter(cx, frame, maybeIter)) {
     return false;
   }
   FrameIter& iter = *maybeIter;
 
   UpdateFrameIterPc(iter);
 
   return DebuggerGenericEval(cx, chars, bindings, options, resumeMode, value,
                              dbg, nullptr, &iter);
 }
 
-/* static */ bool DebuggerFrame::isLive() const { return !!getPrivate(); }
+/* static */
+bool DebuggerFrame::isLive() const { return !!getPrivate(); }
 
 OnStepHandler* DebuggerFrame::onStepHandler() const {
   Value value = getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER);
   return value.isUndefined() ? nullptr
                              : static_cast<OnStepHandler*>(value.toPrivate());
 }
 
 OnPopHandler* DebuggerFrame::onPopHandler() const {
@@ -9321,31 +9367,32 @@ static bool DebuggerFrame_requireLive(JS
 
   return true;
 }
 
 FrameIter::Data* DebuggerFrame::frameIterData() const {
   return static_cast<FrameIter::Data*>(getPrivate());
 }
 
-/* static */ AbstractFramePtr DebuggerFrame::getReferent(
-    HandleDebuggerFrame frame) {
+/* static */
+AbstractFramePtr DebuggerFrame::getReferent(HandleDebuggerFrame frame) {
   FrameIter iter(*frame->frameIterData());
   return iter.abstractFramePtr();
 }
 
-/* static */ bool DebuggerFrame::getFrameIter(JSContext* cx,
-                                              HandleDebuggerFrame frame,
-                                              Maybe<FrameIter>& result) {
+/* static */
+bool DebuggerFrame::getFrameIter(JSContext* cx, HandleDebuggerFrame frame,
+                                 Maybe<FrameIter>& result) {
   result.emplace(*frame->frameIterData());
   return true;
 }
 
-/* static */ bool DebuggerFrame::requireScriptReferent(
-    JSContext* cx, HandleDebuggerFrame frame) {
+/* static */
+bool DebuggerFrame::requireScriptReferent(JSContext* cx,
+                                          HandleDebuggerFrame frame) {
   AbstractFramePtr referent = DebuggerFrame::getReferent(frame);
   if (!referent.hasScript()) {
     RootedValue frameobj(cx, ObjectValue(*frame));
     ReportValueError(cx, JSMSG_DEBUG_BAD_REFERENT, JSDVG_SEARCH_STACK, frameobj,
                      nullptr, "a script frame");
     return false;
   }
   return true;
@@ -9449,18 +9496,18 @@ static DebuggerFrame* DebuggerFrame_chec
                             DebuggerFrame_checkThis(cx, args, fnname, true)); \
   if (!frame) return false;
 
 #define THIS_FRAME(cx, argc, vp, fnname, args, thisobj, iter, frame) \
   THIS_DEBUGGER_FRAME(cx, argc, vp, fnname, args, thisobj);          \
   FrameIter iter(*thisobj->frameIterData());                         \
   AbstractFramePtr frame = iter.abstractFramePtr()
 
-/* static */ bool DebuggerFrame::typeGetter(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool DebuggerFrame::typeGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get type", args, frame);
 
   DebuggerFrameType type = DebuggerFrame::getType(frame);
 
   JSString* str;
   switch (type) {
     case DebuggerFrameType::Eval:
       str = cx->names().eval;
@@ -9480,19 +9527,19 @@ static DebuggerFrame* DebuggerFrame_chec
     default:
       MOZ_CRASH("bad DebuggerFrameType value");
   }
 
   args.rval().setString(str);
   return true;
 }
 
-/* static */ bool DebuggerFrame::implementationGetter(JSContext* cx,
-                                                      unsigned argc,
-                                                      Value* vp) {
+/* static */
+bool DebuggerFrame::implementationGetter(JSContext* cx, unsigned argc,
+                                         Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get implementation", args, frame);
 
   DebuggerFrameImplementation implementation =
       DebuggerFrame::getImplementation(frame);
 
   const char* s;
   switch (implementation) {
     case DebuggerFrameImplementation::Baseline:
@@ -9515,72 +9562,73 @@ static DebuggerFrame* DebuggerFrame_chec
   if (!str) {
     return false;
   }
 
   args.rval().setString(str);
   return true;
 }
 
-/* static */ bool DebuggerFrame::environmentGetter(JSContext* cx, unsigned argc,
-                                                   Value* vp) {
+/* static */
+bool DebuggerFrame::environmentGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get environment", args, frame);
 
   RootedDebuggerEnvironment result(cx);
   if (!DebuggerFrame::getEnvironment(cx, frame, &result)) {
     return false;
   }
 
   args.rval().setObject(*result);
   return true;
 }
 
-/* static */ bool DebuggerFrame::calleeGetter(JSContext* cx, unsigned argc,
-                                              Value* vp) {
+/* static */
+bool DebuggerFrame::calleeGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get callee", args, frame);
 
   RootedDebuggerObject result(cx);
   if (!DebuggerFrame::getCallee(cx, frame, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
-/* static */ bool DebuggerFrame::generatorGetter(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool DebuggerFrame::generatorGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get callee", args, frame);
 
   args.rval().setBoolean(DebuggerFrame::getIsGenerator(frame));
   return true;
 }
 
-/* static */ bool DebuggerFrame::constructingGetter(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerFrame::constructingGetter(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get callee", args, frame);
 
   bool result;
   if (!DebuggerFrame::getIsConstructing(cx, frame, result)) {
     return false;
   }
 
   args.rval().setBoolean(result);
   return true;
 }
 
-/* static */ bool DebuggerFrame::thisGetter(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool DebuggerFrame::thisGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get this", args, frame);
 
   return DebuggerFrame::getThis(cx, frame, args.rval());
 }
 
-/* static */ bool DebuggerFrame::olderGetter(JSContext* cx, unsigned argc,
-                                             Value* vp) {
+/* static */
+bool DebuggerFrame::olderGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get older", args, frame);
 
   RootedDebuggerFrame result(cx);
   if (!DebuggerFrame::getOlder(cx, frame, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
@@ -9651,18 +9699,19 @@ static bool DebuggerArguments_getArg(JSC
 
   if (!Debugger::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, &arg)) {
     return false;
   }
   args.rval().set(arg);
   return true;
 }
 
-/* static */ DebuggerArguments* DebuggerArguments::create(
-    JSContext* cx, HandleObject proto, HandleDebuggerFrame frame) {
+/* static */
+DebuggerArguments* DebuggerArguments::create(JSContext* cx, HandleObject proto,
+                                             HandleDebuggerFrame frame) {
   AbstractFramePtr referent = DebuggerFrame::getReferent(frame);
 
   Rooted<DebuggerArguments*> obj(
       cx, NewObjectWithGivenProto<DebuggerArguments>(cx, proto));
   if (!obj) {
     return nullptr;
   }
 
@@ -9690,18 +9739,18 @@ static bool DebuggerArguments_getArg(JSC
       return nullptr;
     }
     getobj->setExtendedSlot(0, Int32Value(i));
   }
 
   return obj;
 }
 
-/* static */ bool DebuggerFrame::argumentsGetter(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool DebuggerFrame::argumentsGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get arguments", args, frame);
 
   RootedDebuggerArguments result(cx);
   if (!DebuggerFrame::getArguments(cx, frame, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
@@ -9727,60 +9776,60 @@ static bool DebuggerFrame_getScript(JSCo
     }
   }
 
   MOZ_ASSERT(scriptObject);
   args.rval().setObject(*scriptObject);
   return true;
 }
 
-/* static */ bool DebuggerFrame::offsetGetter(JSContext* cx, unsigned argc,
-                                              Value* vp) {
+/* static */
+bool DebuggerFrame::offsetGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get offset", args, frame);
 
   size_t result;
   if (!DebuggerFrame::getOffset(cx, frame, result)) {
     return false;
   }
 
   args.rval().setNumber(double(result));
   return true;
 }
 
-/* static */ bool DebuggerFrame::liveGetter(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool DebuggerFrame::liveGetter(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   RootedDebuggerFrame frame(
       cx, DebuggerFrame_checkThis(cx, args, "get live", false));
   if (!frame) {
     return false;
   }
 
   args.rval().setBoolean(frame->isLive());
   return true;
 }
 
 static bool IsValidHook(const Value& v) {
   return v.isUndefined() || (v.isObject() && v.toObject().isCallable());
 }
 
-/* static */ bool DebuggerFrame::onStepGetter(JSContext* cx, unsigned argc,
-                                              Value* vp) {
+/* static */
+bool DebuggerFrame::onStepGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get onStep", args, frame);
 
   OnStepHandler* handler = frame->onStepHandler();
   RootedValue value(
       cx, handler ? ObjectOrNullValue(handler->object()) : UndefinedValue());
   MOZ_ASSERT(IsValidHook(value));
   args.rval().set(value);
   return true;
 }
 
-/* static */ bool DebuggerFrame::onStepSetter(JSContext* cx, unsigned argc,
-                                              Value* vp) {
+/* static */
+bool DebuggerFrame::onStepSetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "set onStep", args, frame);
   if (!args.requireAtLeast(cx, "Debugger.Frame.set onStep", 1)) {
     return false;
   }
   if (!IsValidHook(args[0])) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_NOT_CALLABLE_OR_UNDEFINED);
     return false;
@@ -9798,30 +9847,30 @@ static bool IsValidHook(const Value& v) 
     handler->drop();
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerFrame::onPopGetter(JSContext* cx, unsigned argc,
-                                             Value* vp) {
+/* static */
+bool DebuggerFrame::onPopGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "get onPop", args, frame);
 
   OnPopHandler* handler = frame->onPopHandler();
   RootedValue value(
       cx, handler ? ObjectValue(*handler->object()) : UndefinedValue());
   MOZ_ASSERT(IsValidHook(value));
   args.rval().set(value);
   return true;
 }
 
-/* static */ bool DebuggerFrame::onPopSetter(JSContext* cx, unsigned argc,
-                                             Value* vp) {
+/* static */
+bool DebuggerFrame::onPopSetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "set onPop", args, frame);
   if (!args.requireAtLeast(cx, "Debugger.Frame.set onPop", 1)) {
     return false;
   }
   if (!IsValidHook(args[0])) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_NOT_CALLABLE_OR_UNDEFINED);
     return false;
@@ -9836,18 +9885,18 @@ static bool IsValidHook(const Value& v) 
   }
 
   frame->setOnPopHandler(handler);
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerFrame::evalMethod(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool DebuggerFrame::evalMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "eval", args, frame);
   if (!args.requireAtLeast(cx, "Debugger.Frame.prototype.eval", 1)) {
     return false;
   }
 
   AutoStableStringChars stableChars(cx);
   if (!ValueToStableChars(cx, "Debugger.Frame.prototype.eval", args[0],
                           stableChars)) {
@@ -9865,19 +9914,19 @@ static bool IsValidHook(const Value& v) 
   if (!DebuggerFrame::eval(cx, frame, chars, nullptr, options, resumeMode,
                            &value)) {
     return false;
   }
 
   return frame->owner()->newCompletionValue(cx, resumeMode, value, args.rval());
 }
 
-/* static */ bool DebuggerFrame::evalWithBindingsMethod(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp) {
+/* static */
+bool DebuggerFrame::evalWithBindingsMethod(JSContext* cx, unsigned argc,
+                                           Value* vp) {
   THIS_DEBUGGER_FRAME(cx, argc, vp, "evalWithBindings", args, frame);
   if (!args.requireAtLeast(cx, "Debugger.Frame.prototype.evalWithBindings",
                            2)) {
     return false;
   }
 
   AutoStableStringChars stableChars(cx);
   if (!ValueToStableChars(cx, "Debugger.Frame.prototype.evalWithBindings",
@@ -9901,18 +9950,18 @@ static bool IsValidHook(const Value& v) 
   if (!DebuggerFrame::eval(cx, frame, chars, bindings, options, resumeMode,
                            &value)) {
     return false;
   }
 
   return frame->owner()->newCompletionValue(cx, resumeMode, value, args.rval());
 }
 
-/* static */ bool DebuggerFrame::construct(JSContext* cx, unsigned argc,
-                                           Value* vp) {
+/* static */
+bool DebuggerFrame::construct(JSContext* cx, unsigned argc, Value* vp) {
   JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR,
                             "Debugger.Frame");
   return false;
 }
 
 const JSPropertySpec DebuggerFrame::properties_[] = {
     JS_PSG("arguments", DebuggerFrame::argumentsGetter, 0),
     JS_PSG("callee", DebuggerFrame::calleeGetter, 0),
@@ -10022,152 +10071,153 @@ static DebuggerObject* DebuggerObject_ch
   if (!obj->is<PromiseObject>()) {                                            \
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,                   \
                               JSMSG_NOT_EXPECTED_TYPE, "Debugger", "Promise", \
                               obj->getClass()->name);                         \
     return false;                                                             \
   }                                                                           \
   Rooted<PromiseObject*> promise(cx, &obj->as<PromiseObject>());
 
-/* static */ bool DebuggerObject::construct(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool DebuggerObject::construct(JSContext* cx, unsigned argc, Value* vp) {
   JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR,
                             "Debugger.Object");
   return false;
 }
 
-/* static */ bool DebuggerObject::callableGetter(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool DebuggerObject::callableGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get callable", args, object)
 
   args.rval().setBoolean(object->isCallable());
   return true;
 }
 
-/* static */ bool DebuggerObject::isBoundFunctionGetter(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp) {
+/* static */
+bool DebuggerObject::isBoundFunctionGetter(JSContext* cx, unsigned argc,
+                                           Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get isBoundFunction", args, object)
 
   if (!object->isDebuggeeFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   args.rval().setBoolean(object->isBoundFunction());
   return true;
 }
 
-/* static */ bool DebuggerObject::isArrowFunctionGetter(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp) {
+/* static */
+bool DebuggerObject::isArrowFunctionGetter(JSContext* cx, unsigned argc,
+                                           Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get isArrowFunction", args, object)
 
   if (!object->isDebuggeeFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   args.rval().setBoolean(object->isArrowFunction());
   return true;
 }
 
-/* static */ bool DebuggerObject::isAsyncFunctionGetter(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp) {
+/* static */
+bool DebuggerObject::isAsyncFunctionGetter(JSContext* cx, unsigned argc,
+                                           Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get isAsyncFunction", args, object)
 
   if (!object->isDebuggeeFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   args.rval().setBoolean(object->isAsyncFunction());
   return true;
 }
 
-/* static */ bool DebuggerObject::isGeneratorFunctionGetter(JSContext* cx,
-                                                            unsigned argc,
-                                                            Value* vp) {
+/* static */
+bool DebuggerObject::isGeneratorFunctionGetter(JSContext* cx, unsigned argc,
+                                               Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get isGeneratorFunction", args, object)
 
   if (!object->isDebuggeeFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   args.rval().setBoolean(object->isGeneratorFunction());
   return true;
 }
 
-/* static */ bool DebuggerObject::protoGetter(JSContext* cx, unsigned argc,
-                                              Value* vp) {
+/* static */
+bool DebuggerObject::protoGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get proto", args, object)
 
   RootedDebuggerObject result(cx);
   if (!DebuggerObject::getPrototypeOf(cx, object, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::classGetter(JSContext* cx, unsigned argc,
-                                              Value* vp) {
+/* static */
+bool DebuggerObject::classGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get class", args, object)
 
   RootedString result(cx);
   if (!DebuggerObject::getClassName(cx, object, &result)) {
     return false;
   }
 
   args.rval().setString(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::nameGetter(JSContext* cx, unsigned argc,
-                                             Value* vp) {
+/* static */
+bool DebuggerObject::nameGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get name", args, object)
 
   if (!object->isFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   RootedString result(cx, object->name(cx));
   if (result) {
     args.rval().setString(result);
   } else {
     args.rval().setUndefined();
   }
   return true;
 }
 
-/* static */ bool DebuggerObject::displayNameGetter(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::displayNameGetter(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get displayName", args, object)
 
   if (!object->isFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   RootedString result(cx, object->displayName(cx));
   if (result) {
     args.rval().setString(result);
   } else {
     args.rval().setUndefined();
   }
   return true;
 }
 
-/* static */ bool DebuggerObject::parameterNamesGetter(JSContext* cx,
-                                                       unsigned argc,
-                                                       Value* vp) {
+/* static */
+bool DebuggerObject::parameterNamesGetter(JSContext* cx, unsigned argc,
+                                          Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get parameterNames", args, object)
 
   if (!object->isDebuggeeFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   Rooted<StringVector> names(cx, StringVector(cx));
@@ -10190,18 +10240,18 @@ static DebuggerObject* DebuggerObject_ch
     }
     obj->setDenseElement(i, v);
   }
 
   args.rval().setObject(*obj);
   return true;
 }
 
-/* static */ bool DebuggerObject::scriptGetter(JSContext* cx, unsigned argc,
-                                               Value* vp) {
+/* static */
+bool DebuggerObject::scriptGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, "get script", args, dbg, obj);
 
   if (!obj->is<JSFunction>()) {
     args.rval().setUndefined();
     return true;
   }
 
   RootedFunction fun(cx, &obj->as<JSFunction>());
@@ -10225,18 +10275,19 @@ static DebuggerObject* DebuggerObject_ch
   if (!scriptObject) {
     return false;
   }
 
   args.rval().setObject(*scriptObject);
   return true;
 }
 
-/* static */ bool DebuggerObject::environmentGetter(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::environmentGetter(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, "get environment", args, dbg,
                                   obj);
 
   // Don't bother switching compartments just to check obj's type and get its
   // env.
   if (!obj->is<JSFunction>()) {
     args.rval().setUndefined();
     return true;
@@ -10261,50 +10312,50 @@ static DebuggerObject* DebuggerObject_ch
     if (!env) {
       return false;
     }
   }
 
   return dbg->wrapEnvironment(cx, env, args.rval());
 }
 
-/* static */ bool DebuggerObject::boundTargetFunctionGetter(JSContext* cx,
-                                                            unsigned argc,
-                                                            Value* vp) {
+/* static */
+bool DebuggerObject::boundTargetFunctionGetter(JSContext* cx, unsigned argc,
+                                               Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get boundTargetFunction", args, object)
 
   if (!object->isDebuggeeFunction() || !object->isBoundFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   RootedDebuggerObject result(cx);
   if (!DebuggerObject::getBoundTargetFunction(cx, object, &result)) {
     return false;
   }
 
   args.rval().setObject(*result);
   return true;
 }
 
-/* static */ bool DebuggerObject::boundThisGetter(JSContext* cx, unsigned argc,
-                                                  Value* vp) {
+/* static */
+bool DebuggerObject::boundThisGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get boundThis", args, object)
 
   if (!object->isDebuggeeFunction() || !object->isBoundFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   return DebuggerObject::getBoundThis(cx, object, args.rval());
 }
 
-/* static */ bool DebuggerObject::boundArgumentsGetter(JSContext* cx,
-                                                       unsigned argc,
-                                                       Value* vp) {
+/* static */
+bool DebuggerObject::boundArgumentsGetter(JSContext* cx, unsigned argc,
+                                          Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get boundArguments", args, object)
 
   if (!object->isDebuggeeFunction() || !object->isBoundFunction()) {
     args.rval().setUndefined();
     return true;
   }
 
   Rooted<ValueVector> result(cx, ValueVector(cx));
@@ -10317,127 +10368,130 @@ static DebuggerObject* DebuggerObject_ch
   if (!obj) {
     return false;
   }
 
   args.rval().setObject(*obj);
   return true;
 }
 
-/* static */ bool DebuggerObject::allocationSiteGetter(JSContext* cx,
-                                                       unsigned argc,
-                                                       Value* vp) {
+/* static */
+bool DebuggerObject::allocationSiteGetter(JSContext* cx, unsigned argc,
+                                          Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get allocationSite", args, object)
 
   RootedObject result(cx);
   if (!DebuggerObject::getAllocationSite(cx, object, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
 // Returns the "name" field (see js.msg), which may be used as a unique
 // identifier, for any error object with a JSErrorReport or undefined
 // if the object has no JSErrorReport.
-/* static */ bool DebuggerObject::errorMessageNameGetter(JSContext* cx,
-                                                         unsigned argc,
-                                                         Value* vp) {
+/* static */
+bool DebuggerObject::errorMessageNameGetter(JSContext* cx, unsigned argc,
+                                            Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get errorMessageName", args, object)
 
   RootedString result(cx);
   if (!DebuggerObject::getErrorMessageName(cx, object, &result)) {
     return false;
   }
 
   if (result) {
     args.rval().setString(result);
   } else {
     args.rval().setUndefined();
   }
   return true;
 }
 
-/* static */ bool DebuggerObject::errorNotesGetter(JSContext* cx, unsigned argc,
-                                                   Value* vp) {
+/* static */
+bool DebuggerObject::errorNotesGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get errorNotes", args, object)
 
   return DebuggerObject::getErrorNotes(cx, object, args.rval());
 }
 
-/* static */ bool DebuggerObject::errorLineNumberGetter(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp) {
+/* static */
+bool DebuggerObject::errorLineNumberGetter(JSContext* cx, unsigned argc,
+                                           Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get errorLineNumber", args, object)
 
   return DebuggerObject::getErrorLineNumber(cx, object, args.rval());
 }
 
-/* static */ bool DebuggerObject::errorColumnNumberGetter(JSContext* cx,
-                                                          unsigned argc,
-                                                          Value* vp) {
+/* static */
+bool DebuggerObject::errorColumnNumberGetter(JSContext* cx, unsigned argc,
+                                             Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get errorColumnNumber", args, object)
 
   return DebuggerObject::getErrorColumnNumber(cx, object, args.rval());
 }
 
-/* static */ bool DebuggerObject::isProxyGetter(JSContext* cx, unsigned argc,
-                                                Value* vp) {
+/* static */
+bool DebuggerObject::isProxyGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get isProxy", args, object)
 
   args.rval().setBoolean(object->isScriptedProxy());
   return true;
 }
 
-/* static */ bool DebuggerObject::proxyTargetGetter(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::proxyTargetGetter(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get proxyTarget", args, object)
 
   if (!object->isScriptedProxy()) {
     args.rval().setUndefined();
     return true;
   }
 
   Rooted<DebuggerObject*> result(cx);
   if (!DebuggerObject::getScriptedProxyTarget(cx, object, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::proxyHandlerGetter(JSContext* cx,
-                                                     unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::proxyHandlerGetter(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get proxyHandler", args, object)
 
   if (!object->isScriptedProxy()) {
     args.rval().setUndefined();
     return true;
   }
   Rooted<DebuggerObject*> result(cx);
   if (!DebuggerObject::getScriptedProxyHandler(cx, object, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::isPromiseGetter(JSContext* cx, unsigned argc,
-                                                  Value* vp) {
+/* static */
+bool DebuggerObject::isPromiseGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get isPromise", args, object)
 
   args.rval().setBoolean(object->isPromise());
   return true;
 }
 
-/* static */ bool DebuggerObject::promiseStateGetter(JSContext* cx,
-                                                     unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::promiseStateGetter(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get promiseState", args, object);
 
   if (!DebuggerObject::requirePromise(cx, object)) {
     return false;
   }
 
   RootedValue result(cx);
   switch (object->promiseState()) {
@@ -10451,107 +10505,108 @@ static DebuggerObject* DebuggerObject_ch
       result.setString(cx->names().rejected);
       break;
   }
 
   args.rval().set(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::promiseValueGetter(JSContext* cx,
-                                                     unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::promiseValueGetter(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get promiseValue", args, object);
 
   if (!DebuggerObject::requirePromise(cx, object)) {
     return false;
   }
 
   if (object->promiseState() != JS::PromiseState::Fulfilled) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_DEBUG_PROMISE_NOT_FULFILLED);
     return false;
   }
 
   return DebuggerObject::getPromiseValue(cx, object, args.rval());
   ;
 }
 
-/* static */ bool DebuggerObject::promiseReasonGetter(JSContext* cx,
-                                                      unsigned argc,
-                                                      Value* vp) {
+/* static */
+bool DebuggerObject::promiseReasonGetter(JSContext* cx, unsigned argc,
+                                         Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get promiseReason", args, object);
 
   if (!DebuggerObject::requirePromise(cx, object)) {
     return false;
   }
 
   if (object->promiseState() != JS::PromiseState::Rejected) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_DEBUG_PROMISE_NOT_REJECTED);
     return false;
   }
 
   return DebuggerObject::getPromiseReason(cx, object, args.rval());
   ;
 }
 
-/* static */ bool DebuggerObject::promiseLifetimeGetter(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp) {
+/* static */
+bool DebuggerObject::promiseLifetimeGetter(JSContext* cx, unsigned argc,
+                                           Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get promiseLifetime", args, object);
 
   if (!DebuggerObject::requirePromise(cx, object)) {
     return false;
   }
 
   args.rval().setNumber(object->promiseLifetime());
   return true;
 }
 
-/* static */ bool DebuggerObject::promiseTimeToResolutionGetter(JSContext* cx,
-                                                                unsigned argc,
-                                                                Value* vp) {
+/* static */
+bool DebuggerObject::promiseTimeToResolutionGetter(JSContext* cx, unsigned argc,
+                                                   Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "get promiseTimeToResolution", args, object);
 
   if (!DebuggerObject::requirePromise(cx, object)) {
     return false;
   }
 
   if (object->promiseState() == JS::PromiseState::Pending) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_DEBUG_PROMISE_NOT_RESOLVED);
     return false;
   }
 
   args.rval().setNumber(object->promiseTimeToResolution());
   return true;
 }
 
-/* static */ bool DebuggerObject::promiseAllocationSiteGetter(JSContext* cx,
-                                                              unsigned argc,
-                                                              Value* vp) {
+/* static */
+bool DebuggerObject::promiseAllocationSiteGetter(JSContext* cx, unsigned argc,
+                                                 Value* vp) {
   THIS_DEBUGOBJECT_PROMISE(cx, argc, vp, "get promiseAllocationSite", args,
                            refobj);
 
   RootedObject allocSite(cx, promise->allocationSite());
   if (!allocSite) {
     args.rval().setNull();
     return true;
   }
 
   if (!cx->compartment()->wrap(cx, &allocSite)) {
     return false;
   }
   args.rval().set(ObjectValue(*allocSite));
   return true;
 }
 
-/* static */ bool DebuggerObject::promiseResolutionSiteGetter(JSContext* cx,
-                                                              unsigned argc,
-                                                              Value* vp) {
+/* static */
+bool DebuggerObject::promiseResolutionSiteGetter(JSContext* cx, unsigned argc,
+                                                 Value* vp) {
   THIS_DEBUGOBJECT_PROMISE(cx, argc, vp, "get promiseResolutionSite", args,
                            refobj);
 
   if (promise->state() == JS::PromiseState::Pending) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_DEBUG_PROMISE_NOT_RESOLVED);
     return false;
   }
@@ -10564,27 +10619,27 @@ static DebuggerObject* DebuggerObject_ch
 
   if (!cx->compartment()->wrap(cx, &resolutionSite)) {
     return false;
   }
   args.rval().set(ObjectValue(*resolutionSite));
   return true;
 }
 
-/* static */ bool DebuggerObject::promiseIDGetter(JSContext* cx, unsigned argc,
-                                                  Value* vp) {
+/* static */
+bool DebuggerObject::promiseIDGetter(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT_PROMISE(cx, argc, vp, "get promiseID", args, refobj);
 
   args.rval().setNumber(double(promise->getID()));
   return true;
 }
 
-/* static */ bool DebuggerObject::promiseDependentPromisesGetter(JSContext* cx,
-                                                                 unsigned argc,
-                                                                 Value* vp) {
+/* static */
+bool DebuggerObject::promiseDependentPromisesGetter(JSContext* cx,
+                                                    unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT_OWNER_PROMISE(cx, argc, vp, "get promiseDependentPromises",
                                  args, dbg, refobj);
 
   Rooted<GCVector<Value>> values(cx, GCVector<Value>(cx));
   {
     JSAutoRealm ar(cx, promise);
     if (!promise->dependentPromises(cx, &values)) {
       return false;
@@ -10603,44 +10658,45 @@ static DebuggerObject* DebuggerObject_ch
   }
   if (!promises) {
     return false;
   }
   args.rval().setObject(*promises);
   return true;
 }
 
-/* static */ bool DebuggerObject::isExtensibleMethod(JSContext* cx,
-                                                     unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::isExtensibleMethod(JSContext* cx, unsigned argc,
+                                        Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "isExtensible", args, object)
 
   bool result;
   if (!DebuggerObject::isExtensible(cx, object, result)) {
     return false;
   }
 
   args.rval().setBoolean(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::isSealedMethod(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool DebuggerObject::isSealedMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "isSealed", args, object)
 
   bool result;
   if (!DebuggerObject::isSealed(cx, object, result)) {
     return false;
   }
 
   args.rval().setBoolean(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::isFrozenMethod(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool DebuggerObject::isFrozenMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "isFrozen", args, object)
 
   bool result;
   if (!DebuggerObject::isFrozen(cx, object, result)) {
     return false;
   }
 
   args.rval().setBoolean(result);
@@ -10669,112 +10725,112 @@ static JSObject* IdVectorToArray(JSConte
       MOZ_ASSERT_UNREACHABLE(
           "IdVector must contain only string, int, and Symbol jsids");
     }
   }
 
   return NewDenseCopiedArray(cx, vals.length(), vals.begin());
 }
 
-/* static */ bool DebuggerObject::getOwnPropertyNamesMethod(JSContext* cx,
-                                                            unsigned argc,
-                                                            Value* vp) {
+/* static */
+bool DebuggerObject::getOwnPropertyNamesMethod(JSContext* cx, unsigned argc,
+                                               Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "getOwnPropertyNames", args, object)
 
   Rooted<IdVector> ids(cx, IdVector(cx));
   if (!DebuggerObject::getOwnPropertyNames(cx, object, &ids)) {
     return false;
   }
 
   RootedObject obj(cx, IdVectorToArray(cx, ids));
   if (!obj) {
     return false;
   }
 
   args.rval().setObject(*obj);
   return true;
 }
 
-/* static */ bool DebuggerObject::getOwnPropertySymbolsMethod(JSContext* cx,
-                                                              unsigned argc,
-                                                              Value* vp) {
+/* static */
+bool DebuggerObject::getOwnPropertySymbolsMethod(JSContext* cx, unsigned argc,
+                                                 Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "getOwnPropertySymbols", args, object)
 
   Rooted<IdVector> ids(cx, IdVector(cx));
   if (!DebuggerObject::getOwnPropertySymbols(cx, object, &ids)) {
     return false;
   }
 
   RootedObject obj(cx, IdVectorToArray(cx, ids));
   if (!obj) {
     return false;
   }
 
   args.rval().setObject(*obj);
   return true;
 }
 
-/* static */ bool DebuggerObject::getOwnPropertyDescriptorMethod(JSContext* cx,
-                                                                 unsigned argc,
-                                                                 Value* vp) {
+/* static */
+bool DebuggerObject::getOwnPropertyDescriptorMethod(JSContext* cx,
+                                                    unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "getOwnPropertyDescriptor", args, object)
 
   RootedId id(cx);
   if (!ValueToId<CanGC>(cx, args.get(0), &id)) {
     return false;
   }
 
   Rooted<PropertyDescriptor> desc(cx);
   if (!DebuggerObject::getOwnPropertyDescriptor(cx, object, id, &desc)) {
     return false;
   }
 
   return JS::FromPropertyDescriptor(cx, desc, args.rval());
 }
 
-/* static */ bool DebuggerObject::preventExtensionsMethod(JSContext* cx,
-                                                          unsigned argc,
-                                                          Value* vp) {
+/* static */
+bool DebuggerObject::preventExtensionsMethod(JSContext* cx, unsigned argc,
+                                             Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "preventExtensions", args, object)
 
   if (!DebuggerObject::preventExtensions(cx, object)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerObject::sealMethod(JSContext* cx, unsigned argc,
-                                             Value* vp) {
+/* static */
+bool DebuggerObject::sealMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "seal", args, object)
 
   if (!DebuggerObject::seal(cx, object)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerObject::freezeMethod(JSContext* cx, unsigned argc,
-                                               Value* vp) {
+/* static */
+bool DebuggerObject::freezeMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "freeze", args, object)
 
   if (!DebuggerObject::freeze(cx, object)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerObject::definePropertyMethod(JSContext* cx,
-                                                       unsigned argc,
-                                                       Value* vp) {
+/* static */
+bool DebuggerObject::definePropertyMethod(JSContext* cx, unsigned argc,
+                                          Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "defineProperty", args, object)
   if (!args.requireAtLeast(cx, "Debugger.Object.defineProperty", 2)) {
     return false;
   }
 
   RootedId id(cx);
   if (!ValueToId<CanGC>(cx, args[0], &id)) {
     return false;
@@ -10788,19 +10844,19 @@ static JSObject* IdVectorToArray(JSConte
   if (!DebuggerObject::defineProperty(cx, object, id, desc)) {
     return false;
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerObject::definePropertiesMethod(JSContext* cx,
-                                                         unsigned argc,
-                                                         Value* vp) {
+/* static */
+bool DebuggerObject::definePropertiesMethod(JSContext* cx, unsigned argc,
+                                            Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "defineProperties", args, object);
   if (!args.requireAtLeast(cx, "Debugger.Object.defineProperties", 1)) {
     return false;
   }
 
   RootedValue arg(cx, args[0]);
   RootedObject props(cx, ToObject(cx, arg));
   if (!props) {
@@ -10823,37 +10879,37 @@ static JSObject* IdVectorToArray(JSConte
   args.rval().setUndefined();
   return true;
 }
 
 /*
  * This does a non-strict delete, as a matter of API design. The case where the
  * property is non-configurable isn't necessarily exceptional here.
  */
-/* static */ bool DebuggerObject::deletePropertyMethod(JSContext* cx,
-                                                       unsigned argc,
-                                                       Value* vp) {
+/* static */
+bool DebuggerObject::deletePropertyMethod(JSContext* cx, unsigned argc,
+                                          Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "deleteProperty", args, object)
 
   RootedId id(cx);
   if (!ValueToId<CanGC>(cx, args.get(0), &id)) {
     return false;
   }
 
   ObjectOpResult result;
   if (!DebuggerObject::deleteProperty(cx, object, id, result)) {
     return false;
   }
 
   args.rval().setBoolean(result.ok());
   return true;
 }
 
-/* static */ bool DebuggerObject::callMethod(JSContext* cx, unsigned argc,
-                                             Value* vp) {
+/* static */
+bool DebuggerObject::callMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "call", callArgs, object);
 
   RootedValue thisv(cx, callArgs.get(0));
 
   Rooted<ValueVector> args(cx, ValueVector(cx));
   if (callArgs.length() >= 2) {
     if (!args.growBy(callArgs.length() - 1)) {
       return false;
@@ -10861,18 +10917,19 @@ static JSObject* IdVectorToArray(JSConte
     for (size_t i = 1; i < callArgs.length(); ++i) {
       args[i - 1].set(callArgs[i]);
     }
   }
 
   return object->call(cx, object, thisv, args, callArgs.rval());
 }
 
-/* static */ bool DebuggerObject::getPropertyMethod(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::getPropertyMethod(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "getProperty", args, object)
 
   RootedId id(cx);
   if (!ValueToId<CanGC>(cx, args.get(0), &id)) {
     return false;
   }
 
   RootedValue receiver(cx,
@@ -10880,18 +10937,19 @@ static JSObject* IdVectorToArray(JSConte
 
   if (!DebuggerObject::getProperty(cx, object, id, receiver, args.rval())) {
     return false;
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::setPropertyMethod(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::setPropertyMethod(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "setProperty", args, object)
 
   RootedId id(cx);
   if (!ValueToId<CanGC>(cx, args.get(0), &id)) {
     return false;
   }
 
   RootedValue value(cx, args.get(1));
@@ -10902,18 +10960,18 @@ static JSObject* IdVectorToArray(JSConte
   if (!DebuggerObject::setProperty(cx, object, id, value, receiver,
                                    args.rval())) {
     return false;
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::applyMethod(JSContext* cx, unsigned argc,
-                                              Value* vp) {
+/* static */
+bool DebuggerObject::applyMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "apply", callArgs, object);
 
   RootedValue thisv(cx, callArgs.get(0));
 
   Rooted<ValueVector> args(cx, ValueVector(cx));
   if (callArgs.length() >= 2 && !callArgs[1].isNullOrUndefined()) {
     if (!callArgs[1].isObject()) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
@@ -10940,19 +10998,19 @@ static JSObject* IdVectorToArray(JSConte
 static void EnterDebuggeeObjectRealm(JSContext* cx, Maybe<AutoRealm>& ar,
                                      JSObject* referent) {
   // |referent| may be a cross-compartment wrapper and CCWs normally
   // shouldn't be used with AutoRealm, but here we use an arbitrary realm for
   // now because we don't really have another option.
   ar.emplace(cx, referent->maybeCCWRealm()->maybeGlobal());
 }
 
-/* static */ bool DebuggerObject::asEnvironmentMethod(JSContext* cx,
-                                                      unsigned argc,
-                                                      Value* vp) {
+/* static */
+bool DebuggerObject::asEnvironmentMethod(JSContext* cx, unsigned argc,
+                                         Value* vp) {
   THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, "asEnvironment", args, dbg,
                                   referent);
   if (!RequireGlobalObject(cx, args.thisv(), referent)) {
     return false;
   }
 
   Rooted<Env*> env(cx);
   {
@@ -10965,18 +11023,20 @@ static void EnterDebuggeeObjectRealm(JSC
 
   return dbg->wrapEnvironment(cx, env, args.rval());
 }
 
 // Lookup a binding on the referent's global scope and change it to undefined
 // if it is an uninitialized lexical, otherwise do nothing. The method's
 // JavaScript return value is true _only_ when an uninitialized lexical has been
 // altered, otherwise it is false.
-/* static */ bool DebuggerObject::forceLexicalInitializationByNameMethod(
-    JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::forceLexicalInitializationByNameMethod(JSContext* cx,
+                                                            unsigned argc,
+                                                            Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "forceLexicalInitializationByName", args,
                    object)
   if (!args.requireAtLeast(
           cx, "Debugger.Object.prototype.forceLexicalInitializationByName",
           1)) {
     return false;
   }
 
@@ -10994,19 +11054,19 @@ static void EnterDebuggeeObjectRealm(JSC
                                                         result)) {
     return false;
   }
 
   args.rval().setBoolean(result);
   return true;
 }
 
-/* static */ bool DebuggerObject::executeInGlobalMethod(JSContext* cx,
-                                                        unsigned argc,
-                                                        Value* vp) {
+/* static */
+bool DebuggerObject::executeInGlobalMethod(JSContext* cx, unsigned argc,
+                                           Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "executeInGlobal", args, object);
   if (!args.requireAtLeast(cx, "Debugger.Object.prototype.executeInGlobal",
                            1)) {
     return false;
   }
 
   if (!DebuggerObject::requireGlobal(cx, object)) {
     return false;
@@ -11030,18 +11090,20 @@ static void EnterDebuggeeObjectRealm(JSC
                                        resumeMode, &value)) {
     return false;
   }
 
   return object->owner()->newCompletionValue(cx, resumeMode, value,
                                              args.rval());
 }
 
-/* static */ bool DebuggerObject::executeInGlobalWithBindingsMethod(
-    JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool DebuggerObject::executeInGlobalWithBindingsMethod(JSContext* cx,
+                                                       unsigned argc,
+                                                       Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "executeInGlobalWithBindings", args, object);
   if (!args.requireAtLeast(
           cx, "Debugger.Object.prototype.executeInGlobalWithBindings", 2)) {
     return false;
   }
 
   if (!DebuggerObject::requireGlobal(cx, object)) {
     return false;
@@ -11071,44 +11133,44 @@ static void EnterDebuggeeObjectRealm(JSC
                                        resumeMode, &value)) {
     return false;
   }
 
   return object->owner()->newCompletionValue(cx, resumeMode, value,
                                              args.rval());
 }
 
-/* static */ bool DebuggerObject::makeDebuggeeValueMethod(JSContext* cx,
-                                                          unsigned argc,
-                                                          Value* vp) {
+/* static */
+bool DebuggerObject::makeDebuggeeValueMethod(JSContext* cx, unsigned argc,
+                                             Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "makeDebuggeeValue", args, object);
   if (!args.requireAtLeast(cx, "Debugger.Object.prototype.makeDebuggeeValue",
                            1)) {
     return false;
   }
 
   return DebuggerObject::makeDebuggeeValue(cx, object, args[0], args.rval());
 }
 
-/* static */ bool DebuggerObject::unsafeDereferenceMethod(JSContext* cx,
-                                                          unsigned argc,
-                                                          Value* vp) {
+/* static */
+bool DebuggerObject::unsafeDereferenceMethod(JSContext* cx, unsigned argc,
+                                             Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "unsafeDereference", args, object);
 
   RootedObject result(cx);
   if (!DebuggerObject::unsafeDereference(cx, object, &result)) {
     return false;
   }
 
   args.rval().setObject(*result);
   return true;
 }
 
-/* static */ bool DebuggerObject::unwrapMethod(JSContext* cx, unsigned argc,
-                                               Value* vp) {
+/* static */
+bool DebuggerObject::unwrapMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGOBJECT(cx, argc, vp, "unwrap", args, object);
 
   RootedDebuggerObject result(cx);
   if (!DebuggerObject::unwrap(cx, object, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
@@ -11184,37 +11246,40 @@ const JSFunctionSpec DebuggerObject::met
     JS_FN("executeInGlobal", DebuggerObject::executeInGlobalMethod, 1, 0),
     JS_FN("executeInGlobalWithBindings",
           DebuggerObject::executeInGlobalWithBindingsMethod, 2, 0),
     JS_FN("makeDebuggeeValue", DebuggerObject::makeDebuggeeValueMethod, 1, 0),
     JS_FN("unsafeDereference", DebuggerObject::unsafeDereferenceMethod, 0, 0),
     JS_FN("unwrap", DebuggerObject::unwrapMethod, 0, 0),
     JS_FS_END};
 
-/* static */ NativeObject* DebuggerObject::initClass(
-    JSContext* cx, Handle<GlobalObject*> global, HandleObject debugCtor) {
+/* static */
+NativeObject* DebuggerObject::initClass(JSContext* cx,
+                                        Handle<GlobalObject*> global,
+                                        HandleObject debugCtor) {
   RootedNativeObject objectProto(
       cx, InitClass(cx, debugCtor, nullptr, &class_, construct, 0, properties_,
                     methods_, nullptr, nullptr));
 
   if (!objectProto) {
     return nullptr;
   }
 
   if (!DefinePropertiesAndFunctions(cx, objectProto, promiseProperties_,
                                     nullptr)) {
     return nullptr;
   }
 
   return objectProto;
 }
 
-/* static */ DebuggerObject* DebuggerObject::create(
-    JSContext* cx, HandleObject proto, HandleObject referent,
-    HandleNativeObject debugger) {
+/* static */
+DebuggerObject* DebuggerObject::create(JSContext* cx, HandleObject proto,
+                                       HandleObject referent,
+                                       HandleNativeObject debugger) {
   NewObjectKind newKind =
       IsInsideNursery(referent) ? GenericObject : TenuredObject;
   DebuggerObject* obj =
       NewObjectWithGivenProto<DebuggerObject>(cx, proto, newKind);
   if (!obj) {
     return nullptr;
   }
 
@@ -11272,19 +11337,19 @@ bool DebuggerObject::isPromise() const {
     if (!referent) {
       return false;
     }
   }
 
   return referent->is<PromiseObject>();
 }
 
-/* static */ bool DebuggerObject::getClassName(JSContext* cx,
-                                               HandleDebuggerObject object,
-                                               MutableHandleString result) {
+/* static */
+bool DebuggerObject::getClassName(JSContext* cx, HandleDebuggerObject object,
+                                  MutableHandleString result) {
   RootedObject referent(cx, object->referent());
 
   const char* className;
   {
     Maybe<AutoRealm> ar;
     EnterDebuggeeObjectRealm(cx, ar, referent);
     className = GetObjectClassName(cx, referent);
   }
@@ -11325,19 +11390,20 @@ JS::PromiseState DebuggerObject::promise
 double DebuggerObject::promiseLifetime() const { return promise()->lifetime(); }
 
 double DebuggerObject::promiseTimeToResolution() const {
   MOZ_ASSERT(promiseState() != JS::PromiseState::Pending);
 
   return promise()->timeToResolution();
 }
 
-/* static */ bool DebuggerObject::getParameterNames(
-    JSContext* cx, HandleDebuggerObject object,
-    MutableHandle<StringVector> result) {
+/* static */
+bool DebuggerObject::getParameterNames(JSContext* cx,
+                                       HandleDebuggerObject object,
+                                       MutableHandle<StringVector> result) {
   MOZ_ASSERT(object->isDebuggeeFunction());
 
   RootedFunction referent(cx, &object->referent()->as<JSFunction>());
 
   if (!result.growBy(referent->nargs())) {
     return false;
   }
   if (referent->isInterpreted()) {
@@ -11363,43 +11429,45 @@ double DebuggerObject::promiseTimeToReso
     for (size_t i = 0; i < referent->nargs(); i++) {
       result[i].set(nullptr);
     }
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::getBoundTargetFunction(
+/* static */
+bool DebuggerObject::getBoundTargetFunction(
     JSContext* cx, HandleDebuggerObject object,
     MutableHandleDebuggerObject result) {
   MOZ_ASSERT(object->isBoundFunction());
 
   RootedFunction referent(cx, &object->referent()->as<JSFunction>());
   Debugger* dbg = object->owner();
 
   RootedObject target(cx, referent->getBoundFunctionTarget());
   return dbg->wrapDebuggeeObject(cx, target, result);
 }
 
-/* static */ bool DebuggerObject::getBoundThis(JSContext* cx,
-                                               HandleDebuggerObject object,
-                                               MutableHandleValue result) {
+/* static */
+bool DebuggerObject::getBoundThis(JSContext* cx, HandleDebuggerObject object,
+                                  MutableHandleValue result) {
   MOZ_ASSERT(object->isBoundFunction());
 
   RootedFunction referent(cx, &object->referent()->as<JSFunction>());
   Debugger* dbg = object->owner();
 
   result.set(referent->getBoundFunctionThis());
   return dbg->wrapDebuggeeValue(cx, result);
 }
 
-/* static */ bool DebuggerObject::getBoundArguments(
-    JSContext* cx, HandleDebuggerObject object,
-    MutableHandle<ValueVector> result) {
+/* static */
+bool DebuggerObject::getBoundArguments(JSContext* cx,
+                                       HandleDebuggerObject object,
+                                       MutableHandle<ValueVector> result) {
   MOZ_ASSERT(object->isBoundFunction());
 
   RootedFunction referent(cx, &object->referent()->as<JSFunction>());
   Debugger* dbg = object->owner();
 
   size_t length = referent->getBoundFunctionArgumentCount();
   if (!result.resize(length)) {
     return false;
@@ -11408,42 +11476,45 @@ double DebuggerObject::promiseTimeToReso
     result[i].set(referent->getBoundFunctionArgument(i));
     if (!dbg->wrapDebuggeeValue(cx, result[i])) {
       return false;
     }
   }
   return true;
 }
 
-/* static */ SavedFrame* Debugger::getObjectAllocationSite(JSObject& obj) {
+/* static */
+SavedFrame* Debugger::getObjectAllocationSite(JSObject& obj) {
   JSObject* metadata = GetAllocationMetadata(&obj);
   if (!metadata) {
     return nullptr;
   }
 
   MOZ_ASSERT(!metadata->is<WrapperObject>());
   return metadata->is<SavedFrame>() ? &metadata->as<SavedFrame>() : nullptr;
 }
 
-/* static */ bool DebuggerObject::getAllocationSite(
-    JSContext* cx, HandleDebuggerObject object, MutableHandleObject result) {
+/* static */
+bool DebuggerObject::getAllocationSite(JSContext* cx,
+                                       HandleDebuggerObject object,
+                                       MutableHandleObject result) {
   RootedObject referent(cx, object->referent());
 
   RootedObject allocSite(cx, Debugger::getObjectAllocationSite(*referent));
   if (!cx->compartment()->wrap(cx, &allocSite)) {
     return false;
   }
 
   result.set(allocSite);
   return true;
 }
 
-/* static */ bool DebuggerObject::getErrorReport(JSContext* cx,
-                                                 HandleObject maybeError,
-                                                 JSErrorReport*& report) {
+/* static */
+bool DebuggerObject::getErrorReport(JSContext* cx, HandleObject maybeError,
+                                    JSErrorReport*& report) {
   JSObject* obj = maybeError;
   if (IsCrossCompartmentWrapper(obj)) {
     /* We only care about Error objects, so CheckedUnwrapStatic is OK. */
     obj = CheckedUnwrapStatic(obj);
   }
 
   if (!obj) {
     ReportAccessDenied(cx);
@@ -11454,18 +11525,20 @@ double DebuggerObject::promiseTimeToReso
     report = nullptr;
     return true;
   }
 
   report = obj->as<ErrorObject>().getErrorReport();
   return true;
 }
 
-/* static */ bool DebuggerObject::getErrorMessageName(
-    JSContext* cx, HandleDebuggerObject object, MutableHandleString result) {
+/* static */
+bool DebuggerObject::getErrorMessageName(JSContext* cx,
+                                         HandleDebuggerObject object,
+                                         MutableHandleString result) {
   RootedObject referent(cx, object->referent());
   JSErrorReport* report;
   if (!getErrorReport(cx, referent, report)) {
     return false;
   }
 
   if (!report) {
     result.set(nullptr);
@@ -11482,19 +11555,19 @@ double DebuggerObject::promiseTimeToReso
   RootedString str(cx, JS_NewStringCopyZ(cx, efs->name));
   if (!str) {
     return false;
   }
   result.set(str);
   return true;
 }
 
-/* static */ bool DebuggerObject::getErrorNotes(JSContext* cx,
-                                                HandleDebuggerObject object,
-                                                MutableHandleValue result) {
+/* static */
+bool DebuggerObject::getErrorNotes(JSContext* cx, HandleDebuggerObject object,
+                                   MutableHandleValue result) {
   RootedObject referent(cx, object->referent());
   JSErrorReport* report;
   if (!getErrorReport(cx, referent, report)) {
     return false;
   }
 
   if (!report) {
     result.setUndefined();
@@ -11508,107 +11581,112 @@ double DebuggerObject::promiseTimeToReso
 
   if (!cx->compartment()->wrap(cx, &errorNotesArray)) {
     return false;
   }
   result.setObject(*errorNotesArray);
   return true;
 }
 
-/* static */ bool DebuggerObject::getErrorLineNumber(
-    JSContext* cx, HandleDebuggerObject object, MutableHandleValue result) {
+/* static */
+bool DebuggerObject::getErrorLineNumber(JSContext* cx,
+                                        HandleDebuggerObject object,
+                                        MutableHandleValue result) {
   RootedObject referent(cx, object->referent());
   JSErrorReport* report;
   if (!getErrorReport(cx, referent, report)) {
     return false;
   }
 
   if (!report) {
     result.setUndefined();
     return true;
   }
 
   result.setNumber(report->lineno);
   return true;
 }
 
-/* static */ bool DebuggerObject::getErrorColumnNumber(
-    JSContext* cx, HandleDebuggerObject object, MutableHandleValue result) {
+/* static */
+bool DebuggerObject::getErrorColumnNumber(JSContext* cx,
+                                          HandleDebuggerObject object,
+                                          MutableHandleValue result) {
   RootedObject referent(cx, object->referent());
   JSErrorReport* report;
   if (!getErrorReport(cx, referent, report)) {
     return false;
   }
 
   if (!report) {
     result.setUndefined();
     return true;
   }
 
   result.setNumber(report->column);
   return true;
 }
 
-/* static */ bool DebuggerObject::getPromiseValue(JSContext* cx,
-                                                  HandleDebuggerObject object,
-                                                  MutableHandleValue result) {
+/* static */
+bool DebuggerObject::getPromiseValue(JSContext* cx, HandleDebuggerObject object,
+                                     MutableHandleValue result) {
   MOZ_ASSERT(object->promiseState() == JS::PromiseState::Fulfilled);
 
   result.set(object->promise()->value());
   return object->owner()->wrapDebuggeeValue(cx, result);
 }
 
-/* static */ bool DebuggerObject::getPromiseReason(JSContext* cx,
-                                                   HandleDebuggerObject object,
-                                                   MutableHandleValue result) {
+/* static */
+bool DebuggerObject::getPromiseReason(JSContext* cx,
+                                      HandleDebuggerObject object,
+                                      MutableHandleValue result) {
   MOZ_ASSERT(object->promiseState() == JS::PromiseState::Rejected);
 
   result.set(object->promise()->reason());
   return object->owner()->wrapDebuggeeValue(cx, result);
 }
 
-/* static */ bool DebuggerObject::isExtensible(JSContext* cx,
-                                               HandleDebuggerObject object,
-                                               bool& result) {
+/* static */
+bool DebuggerObject::isExtensible(JSContext* cx, HandleDebuggerObject object,
+                                  bool& result) {
   RootedObject referent(cx, object->referent());
 
   Maybe<AutoRealm> ar;
   EnterDebuggeeObjectRealm(cx, ar, referent);
 
   ErrorCopier ec(ar);
   return IsExtensible(cx, referent, &result);
 }
 
-/* static */ bool DebuggerObject::isSealed(JSContext* cx,
-                                           HandleDebuggerObject object,
-                                           bool& result) {
+/* static */
+bool DebuggerObject::isSealed(JSContext* cx, HandleDebuggerObject object,
+                              bool& result) {
   RootedObject referent(cx, object->referent());
 
   Maybe<AutoRealm> ar;
   EnterDebuggeeObjectRealm(cx, ar, referent);
 
   ErrorCopier ec(ar);
   return TestIntegrityLevel(cx, referent, IntegrityLevel::Sealed, &result);
 }
 
-/* static */ bool DebuggerObject::isFrozen(JSContext* cx,
-                                           HandleDebuggerObject object,
-                                           bool& result) {
+/* static */
+bool DebuggerObject::isFrozen(JSContext* cx, HandleDebuggerObject object,
+                              bool& result) {
   RootedObject referent(cx, object->referent());
 
   Maybe<AutoRealm> ar;
   EnterDebuggeeObjectRealm(cx, ar, referent);
 
   ErrorCopier ec(ar);
   return TestIntegrityLevel(cx, referent, IntegrityLevel::Frozen, &result);
 }
 
-/* static */ bool DebuggerObject::getPrototypeOf(
-    JSContext* cx, HandleDebuggerObject object,
-    MutableHandleDebuggerObject result) {
+/* static */
+bool DebuggerObject::getPrototypeOf(JSContext* cx, HandleDebuggerObject object,
+                                    MutableHandleDebuggerObject result) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   RootedObject proto(cx);
   {
     Maybe<AutoRealm> ar;
     EnterDebuggeeObjectRealm(cx, ar, referent);
     if (!GetPrototype(cx, referent, &proto)) {
@@ -11619,19 +11697,20 @@ double DebuggerObject::promiseTimeToReso
   if (!proto) {
     result.set(nullptr);
     return true;
   }
 
   return dbg->wrapDebuggeeObject(cx, proto, result);
 }
 
-/* static */ bool DebuggerObject::getOwnPropertyNames(
-    JSContext* cx, HandleDebuggerObject object,
-    MutableHandle<IdVector> result) {
+/* static */
+bool DebuggerObject::getOwnPropertyNames(JSContext* cx,
+                                         HandleDebuggerObject object,
+                                         MutableHandle<IdVector> result) {
   RootedObject referent(cx, object->referent());
 
   AutoIdVector ids(cx);
   {
     Maybe<AutoRealm> ar;
     EnterDebuggeeObjectRealm(cx, ar, referent);
 
     ErrorCopier ec(ar);
@@ -11642,19 +11721,20 @@ double DebuggerObject::promiseTimeToReso
 
   for (size_t i = 0; i < ids.length(); i++) {
     cx->markId(ids[i]);
   }
 
   return result.append(ids.begin(), ids.end());
 }
 
-/* static */ bool DebuggerObject::getOwnPropertySymbols(
-    JSContext* cx, HandleDebuggerObject object,
-    MutableHandle<IdVector> result) {
+/* static */
+bool DebuggerObject::getOwnPropertySymbols(JSContext* cx,
+                                           HandleDebuggerObject object,
+                                           MutableHandle<IdVector> result) {
   RootedObject referent(cx, object->referent());
 
   AutoIdVector ids(cx);
   {
     Maybe<AutoRealm> ar;
     EnterDebuggeeObjectRealm(cx, ar, referent);
 
     ErrorCopier ec(ar);
@@ -11667,17 +11747,18 @@ double DebuggerObject::promiseTimeToReso
 
   for (size_t i = 0; i < ids.length(); i++) {
     cx->markId(ids[i]);
   }
 
   return result.append(ids.begin(), ids.end());
 }
 
-/* static */ bool DebuggerObject::getOwnPropertyDescriptor(
+/* static */
+bool DebuggerObject::getOwnPropertyDescriptor(
     JSContext* cx, HandleDebuggerObject object, HandleId id,
     MutableHandle<PropertyDescriptor> desc) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   // Bug: This can cause the debuggee to run!
   {
     Maybe<AutoRealm> ar;
@@ -11715,52 +11796,54 @@ double DebuggerObject::promiseTimeToReso
     // Avoid tripping same-compartment assertions in
     // JS::FromPropertyDescriptor().
     desc.object().set(object);
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::preventExtensions(
-    JSContext* cx, HandleDebuggerObject object) {
+/* static */
+bool DebuggerObject::preventExtensions(JSContext* cx,
+                                       HandleDebuggerObject object) {
   RootedObject referent(cx, object->referent());
 
   Maybe<AutoRealm> ar;
   EnterDebuggeeObjectRealm(cx, ar, referent);
 
   ErrorCopier ec(ar);
   return PreventExtensions(cx, referent);
 }
 
-/* static */ bool DebuggerObject::seal(JSContext* cx,
-                                       HandleDebuggerObject object) {
+/* static */
+bool DebuggerObject::seal(JSContext* cx, HandleDebuggerObject object) {
   RootedObject referent(cx, object->referent());
 
   Maybe<AutoRealm> ar;
   EnterDebuggeeObjectRealm(cx, ar, referent);
 
   ErrorCopier ec(ar);
   return SetIntegrityLevel(cx, referent, IntegrityLevel::Sealed);
 }
 
-/* static */ bool DebuggerObject::freeze(JSContext* cx,
-                                         HandleDebuggerObject object) {
+/* static */
+bool DebuggerObject::freeze(JSContext* cx, HandleDebuggerObject object) {
   RootedObject referent(cx, object->referent());
 
   Maybe<AutoRealm> ar;
   EnterDebuggeeObjectRealm(cx, ar, referent);
 
   ErrorCopier ec(ar);
   return SetIntegrityLevel(cx, referent, IntegrityLevel::Frozen);
 }
 
-/* static */ bool DebuggerObject::defineProperty(
-    JSContext* cx, HandleDebuggerObject object, HandleId id,
-    Handle<PropertyDescriptor> desc_) {
+/* static */
+bool DebuggerObject::defineProperty(JSContext* cx, HandleDebuggerObject object,
+                                    HandleId id,
+                                    Handle<PropertyDescriptor> desc_) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   Rooted<PropertyDescriptor> desc(cx, desc_);
   if (!dbg->unwrapPropertyDescriptor(cx, referent, &desc)) {
     return false;
   }
   JS_TRY_OR_RETURN_FALSE(cx, CheckPropertyDescriptorAccessors(cx, desc));
@@ -11776,19 +11859,21 @@ double DebuggerObject::promiseTimeToReso
   ErrorCopier ec(ar);
   if (!DefineProperty(cx, referent, id, desc)) {
     return false;
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::defineProperties(
-    JSContext* cx, HandleDebuggerObject object, Handle<IdVector> ids,
-    Handle<PropertyDescriptorVector> descs_) {
+/* static */
+bool DebuggerObject::defineProperties(JSContext* cx,
+                                      HandleDebuggerObject object,
+                                      Handle<IdVector> ids,
+                                      Handle<PropertyDescriptorVector> descs_) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   Rooted<PropertyDescriptorVector> descs(cx, PropertyDescriptorVector(cx));
   if (!descs.append(descs_.begin(), descs_.end())) {
     return false;
   }
   for (size_t i = 0; i < descs.length(); i++) {
@@ -11813,36 +11898,34 @@ double DebuggerObject::promiseTimeToReso
     if (!DefineProperty(cx, referent, ids[i], descs[i])) {
       return false;
     }
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::deleteProperty(JSContext* cx,
-                                                 HandleDebuggerObject object,
-                                                 HandleId id,
-                                                 ObjectOpResult& result) {
+/* static */
+bool DebuggerObject::deleteProperty(JSContext* cx, HandleDebuggerObject object,
+                                    HandleId id, ObjectOpResult& result) {
   RootedObject referent(cx, object->referent());
 
   Maybe<AutoRealm> ar;
   EnterDebuggeeObjectRealm(cx, ar, referent);
 
   cx->markId(id);
 
   ErrorCopier ec(ar);
   return DeleteProperty(cx, referent, id, result);
 }
 
-/* static */ bool DebuggerObject::getProperty(JSContext* cx,
-                                              HandleDebuggerObject object,
-                                              HandleId id,
-                                              HandleValue receiver_,
-                                              MutableHandleValue result) {
+/* static */
+bool DebuggerObject::getProperty(JSContext* cx, HandleDebuggerObject object,
+                                 HandleId id, HandleValue receiver_,
+                                 MutableHandleValue result) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   // Unwrap Debugger.Objects. This happens in the debugger's compartment since
   // that is where any exceptions must be reported.
   RootedValue receiver(cx, receiver_);
   if (!dbg->unwrapDebuggeeValue(cx, &receiver)) {
     return false;
@@ -11861,21 +11944,21 @@ double DebuggerObject::promiseTimeToReso
 
   LeaveDebuggeeNoExecute nnx(cx);
 
   bool ok = GetProperty(cx, referent, receiver, id, result);
 
   return dbg->receiveCompletionValue(ar, ok, result, result);
 }
 
-/* static */ bool DebuggerObject::setProperty(JSContext* cx,
-                                              HandleDebuggerObject object,
-                                              HandleId id, HandleValue value_,
-                                              HandleValue receiver_,
-                                              MutableHandleValue result) {
+/* static */
+bool DebuggerObject::setProperty(JSContext* cx, HandleDebuggerObject object,
+                                 HandleId id, HandleValue value_,
+                                 HandleValue receiver_,
+                                 MutableHandleValue result) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   // Unwrap Debugger.Objects. This happens in the debugger's compartment since
   // that is where any exceptions must be reported.
   RootedValue value(cx, value_);
   RootedValue receiver(cx, receiver_);
   if (!dbg->unwrapDebuggeeValue(cx, &value) ||
@@ -11899,21 +11982,20 @@ double DebuggerObject::promiseTimeToReso
 
   ObjectOpResult opResult;
   bool ok = SetProperty(cx, referent, id, value, receiver, opResult);
 
   result.setBoolean(ok && opResult.reallyOk());
   return dbg->receiveCompletionValue(ar, ok, result, result);
 }
 
-/* static */ bool DebuggerObject::call(JSContext* cx,
-                                       HandleDebuggerObject object,
-                                       HandleValue thisv_,
-                                       Handle<ValueVector> args,
-                                       MutableHandleValue result) {
+/* static */
+bool DebuggerObject::call(JSContext* cx, HandleDebuggerObject object,
+                          HandleValue thisv_, Handle<ValueVector> args,
+                          MutableHandleValue result) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   if (!referent->isCallable()) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_INCOMPATIBLE_PROTO, "Debugger.Object",
                               "call", referent->getClass()->name);
     return false;
@@ -11968,17 +12050,18 @@ double DebuggerObject::promiseTimeToReso
 
       ok = js::Call(cx, calleev, thisv, invokeArgs, result);
     }
   }
 
   return dbg->receiveCompletionValue(ar, ok, result, result);
 }
 
-/* static */ bool DebuggerObject::forceLexicalInitializationByName(
+/* static */
+bool DebuggerObject::forceLexicalInitializationByName(
     JSContext* cx, HandleDebuggerObject object, HandleId id, bool& result) {
   if (!JSID_IS_STRING(id)) {
     JS_ReportErrorNumberASCII(
         cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE,
         "Debugger.Object.prototype.forceLexicalInitializationByName", "string",
         InformalValueTypeName(IdToValue(id)));
     return false;
   }
@@ -12005,35 +12088,38 @@ double DebuggerObject::promiseTimeToReso
                                                 UndefinedValue());
       result = true;
     }
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::executeInGlobal(
-    JSContext* cx, HandleDebuggerObject object,
-    mozilla::Range<const char16_t> chars, HandleObject bindings,
-    const EvalOptions& options, ResumeMode& resumeMode,
-    MutableHandleValue value) {
+/* static */
+bool DebuggerObject::executeInGlobal(JSContext* cx, HandleDebuggerObject object,
+                                     mozilla::Range<const char16_t> chars,
+                                     HandleObject bindings,
+                                     const EvalOptions& options,
+                                     ResumeMode& resumeMode,
+                                     MutableHandleValue value) {
   MOZ_ASSERT(object->isGlobal());
 
   Rooted<GlobalObject*> referent(cx, &object->referent()->as<GlobalObject>());
   Debugger* dbg = object->owner();
 
   RootedObject globalLexical(cx, &referent->lexicalEnvironment());
   return DebuggerGenericEval(cx, chars, bindings, options, resumeMode, value,
                              dbg, globalLexical, nullptr);
 }
 
-/* static */ bool DebuggerObject::makeDebuggeeValue(JSContext* cx,
-                                                    HandleDebuggerObject object,
-                                                    HandleValue value_,
-                                                    MutableHandleValue result) {
+/* static */
+bool DebuggerObject::makeDebuggeeValue(JSContext* cx,
+                                       HandleDebuggerObject object,
+                                       HandleValue value_,
+                                       MutableHandleValue result) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   RootedValue value(cx, value_);
 
   // Non-objects are already debuggee values.
   if (value.isObject()) {
     // Enter this Debugger.Object's referent's compartment, and wrap the
@@ -12052,34 +12138,36 @@ double DebuggerObject::promiseTimeToReso
       return false;
     }
   }
 
   result.set(value);
   return true;
 }
 
-/* static */ bool DebuggerObject::unsafeDereference(
-    JSContext* cx, HandleDebuggerObject object, MutableHandleObject result) {
+/* static */
+bool DebuggerObject::unsafeDereference(JSContext* cx,
+                                       HandleDebuggerObject object,
+                                       MutableHandleObject result) {
   RootedObject referent(cx, object->referent());
 
   if (!cx->compartment()->wrap(cx, &referent)) {
     return false;
   }
 
   // Wrapping should return the WindowProxy.
   MOZ_ASSERT(!IsWindow(referent));
 
   result.set(referent);
   return true;
 }
 
-/* static */ bool DebuggerObject::unwrap(JSContext* cx,
-                                         HandleDebuggerObject object,
-                                         MutableHandleDebuggerObject result) {
+/* static */
+bool DebuggerObject::unwrap(JSContext* cx, HandleDebuggerObject object,
+                            MutableHandleDebuggerObject result) {
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
 
   RootedObject unwrapped(cx, UnwrapOneChecked(referent));
   if (!unwrapped) {
     result.set(nullptr);
     return true;
   }
@@ -12091,18 +12179,18 @@ double DebuggerObject::promiseTimeToReso
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_DEBUG_INVISIBLE_COMPARTMENT);
     return false;
   }
 
   return dbg->wrapDebuggeeObject(cx, unwrapped, result);
 }
 
-/* static */ bool DebuggerObject::requireGlobal(JSContext* cx,
-                                                HandleDebuggerObject object) {
+/* static */
+bool DebuggerObject::requireGlobal(JSContext* cx, HandleDebuggerObject object) {
   if (!object->isGlobal()) {
     RootedObject referent(cx, object->referent());
 
     const char* isWrapper = "";
     const char* isWindowProxy = "";
 
     // Help the poor programmer by pointing out wrappers around globals...
     if (referent->is<WrapperObject>()) {
@@ -12125,18 +12213,19 @@ double DebuggerObject::promiseTimeToReso
                        nullptr, "a global object");
     }
     return false;
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::requirePromise(JSContext* cx,
-                                                 HandleDebuggerObject object) {
+/* static */
+bool DebuggerObject::requirePromise(JSContext* cx,
+                                    HandleDebuggerObject object) {
   RootedObject referent(cx, object->referent());
 
   if (IsCrossCompartmentWrapper(referent)) {
     /* We only care about promises, so CheckedUnwrapStatic is OK. */
     referent = CheckedUnwrapStatic(referent);
     if (!referent) {
       ReportAccessDenied(cx);
       return false;
@@ -12148,31 +12237,33 @@ double DebuggerObject::promiseTimeToReso
                               JSMSG_NOT_EXPECTED_TYPE, "Debugger", "Promise",
                               object->getClass()->name);
     return false;
   }
 
   return true;
 }
 
-/* static */ bool DebuggerObject::getScriptedProxyTarget(
+/* static */
+bool DebuggerObject::getScriptedProxyTarget(
     JSContext* cx, HandleDebuggerObject object,
     MutableHandleDebuggerObject result) {
   MOZ_ASSERT(object->isScriptedProxy());
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
   RootedObject unwrapped(cx, js::GetProxyTargetObject(referent));
   if (!unwrapped) {
     result.set(nullptr);
     return true;
   }
   return dbg->wrapDebuggeeObject(cx, unwrapped, result);
 }
 
-/* static */ bool DebuggerObject::getScriptedProxyHandler(
+/* static */
+bool DebuggerObject::getScriptedProxyHandler(
     JSContext* cx, HandleDebuggerObject object,
     MutableHandleDebuggerObject result) {
   MOZ_ASSERT(object->isScriptedProxy());
   RootedObject referent(cx, object->referent());
   Debugger* dbg = object->owner();
   RootedObject unwrapped(cx, ScriptedProxyHandler::handlerObject(referent));
   if (!unwrapped) {
     result.set(nullptr);
@@ -12235,18 +12326,18 @@ static DebuggerEnvironment* DebuggerEnvi
 }
 
 #define THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, fnname, args, environment) \
   CallArgs args = CallArgsFromVp(argc, vp);                                \
   Rooted<DebuggerEnvironment*> environment(                                \
       cx, DebuggerEnvironment_checkThis(cx, args, fnname, false));         \
   if (!environment) return false;
 
-/* static */ bool DebuggerEnvironment::construct(JSContext* cx, unsigned argc,
-                                                 Value* vp) {
+/* static */
+bool DebuggerEnvironment::construct(JSContext* cx, unsigned argc, Value* vp) {
   JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR,
                             "Debugger.Environment");
   return false;
 }
 
 static bool IsDeclarative(Env* env) {
   return env->is<DebugEnvironmentProxy>() &&
          env->as<DebugEnvironmentProxy>().isForDeclarative();
@@ -12284,35 +12375,37 @@ bool DebuggerEnvironment::typeGetter(JSC
   if (!str) {
     return false;
   }
 
   args.rval().setString(str);
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::parentGetter(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerEnvironment::parentGetter(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get type", args, environment);
 
   if (!environment->requireDebuggee(cx)) {
     return false;
   }
 
   RootedDebuggerEnvironment result(cx);
   if (!environment->getParent(cx, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::objectGetter(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerEnvironment::objectGetter(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get type", args, environment);
 
   if (!environment->requireDebuggee(cx)) {
     return false;
   }
 
   if (environment->type() == DebuggerEnvironmentType::Declarative) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
@@ -12324,54 +12417,55 @@ bool DebuggerEnvironment::typeGetter(JSC
   if (!environment->getObject(cx, &result)) {
     return false;
   }
 
   args.rval().setObject(*result);
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::calleeGetter(JSContext* cx,
-                                                    unsigned argc, Value* vp) {
+/* static */
+bool DebuggerEnvironment::calleeGetter(JSContext* cx, unsigned argc,
+                                       Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get callee", args, environment);
 
   if (!environment->requireDebuggee(cx)) {
     return false;
   }
 
   RootedDebuggerObject result(cx);
   if (!environment->getCallee(cx, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::inspectableGetter(JSContext* cx,
-                                                         unsigned argc,
-                                                         Value* vp) {
+/* static */
+bool DebuggerEnvironment::inspectableGetter(JSContext* cx, unsigned argc,
+                                            Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get inspectable", args, environment);
 
   args.rval().setBoolean(environment->isDebuggee());
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::optimizedOutGetter(JSContext* cx,
-                                                          unsigned argc,
-                                                          Value* vp) {
+/* static */
+bool DebuggerEnvironment::optimizedOutGetter(JSContext* cx, unsigned argc,
+                                             Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get optimizedOut", args,
                             environment);
 
   args.rval().setBoolean(environment->isOptimized());
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::namesMethod(JSContext* cx, unsigned argc,
-                                                   Value* vp) {
+/* static */
+bool DebuggerEnvironment::namesMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "names", args, environment);
 
   if (!environment->requireDebuggee(cx)) {
     return false;
   }
 
   Rooted<IdVector> ids(cx, IdVector(cx));
   if (!DebuggerEnvironment::getNames(cx, environment, &ids)) {
@@ -12382,18 +12476,18 @@ bool DebuggerEnvironment::typeGetter(JSC
   if (!obj) {
     return false;
   }
 
   args.rval().setObject(*obj);
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::findMethod(JSContext* cx, unsigned argc,
-                                                  Value* vp) {
+/* static */
+bool DebuggerEnvironment::findMethod(JSContext* cx, unsigned argc, Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "find", args, environment);
   if (!args.requireAtLeast(cx, "Debugger.Environment.find", 1)) {
     return false;
   }
 
   if (!environment->requireDebuggee(cx)) {
     return false;
   }
@@ -12407,19 +12501,19 @@ bool DebuggerEnvironment::typeGetter(JSC
   if (!DebuggerEnvironment::find(cx, environment, id, &result)) {
     return false;
   }
 
   args.rval().setObjectOrNull(result);
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::getVariableMethod(JSContext* cx,
-                                                         unsigned argc,
-                                                         Value* vp) {
+/* static */
+bool DebuggerEnvironment::getVariableMethod(JSContext* cx, unsigned argc,
+                                            Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "getVariable", args, environment);
   if (!args.requireAtLeast(cx, "Debugger.Environment.getVariable", 1)) {
     return false;
   }
 
   if (!environment->requireDebuggee(cx)) {
     return false;
   }
@@ -12427,19 +12521,19 @@ bool DebuggerEnvironment::typeGetter(JSC
   RootedId id(cx);
   if (!ValueToIdentifier(cx, args[0], &id)) {
     return false;
   }
 
   return DebuggerEnvironment::getVariable(cx, environment, id, args.rval());
 }
 
-/* static */ bool DebuggerEnvironment::setVariableMethod(JSContext* cx,
-                                                         unsigned argc,
-                                                         Value* vp) {
+/* static */
+bool DebuggerEnvironment::setVariableMethod(JSContext* cx, unsigned argc,
+                                            Value* vp) {
   THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "setVariable", args, environment);
   if (!args.requireAtLeast(cx, "Debugger.Environment.setVariable", 2)) {
     return false;
   }
 
   if (!environment->requireDebuggee(cx)) {
     return false;
   }
@@ -12480,40 +12574,45 @@ const JSPropertySpec DebuggerEnvironment
 
 const JSFunctionSpec DebuggerEnvironment::methods_[] = {
     JS_FN("names", DebuggerEnvironment::namesMethod, 0, 0),
     JS_FN("find", DebuggerEnvironment::findMethod, 1, 0),
     JS_FN("getVariable", DebuggerEnvironment::getVariableMethod, 1, 0),
     JS_FN("setVariable", DebuggerEnvironment::setVariableMethod, 2, 0),
     JS_FS_END};
 
-/* static */ NativeObject* DebuggerEnvironment::initClass(
-    JSContext* cx, HandleObject dbgCtor, Handle<GlobalObject*> global) {
+/* static */
+NativeObject* DebuggerEnvironment::initClass(JSContext* cx,
+                                             HandleObject dbgCtor,
+                                             Handle<GlobalObject*> global) {
   return InitClass(cx, dbgCtor, nullptr, &DebuggerEnvironment::class_,
                    construct, 0, properties_, methods_, nullptr, nullptr);
 }
 
-/* static */ DebuggerEnvironment* DebuggerEnvironment::create(
-    JSContext* cx, HandleObject proto, HandleObject referent,
-    HandleNativeObject debugger) {
+/* static */
+DebuggerEnvironment* DebuggerEnvironment::create(JSContext* cx,
+                                                 HandleObject proto,
+                                                 HandleObject referent,
+                                                 HandleNativeObject debugger) {
   NewObjectKind newKind =
       IsInsideNursery(referent) ? GenericObject : TenuredObject;
   DebuggerEnvironment* obj =
       NewObjectWithGivenProto<DebuggerEnvironment>(cx, proto, newKind);
   if (!obj) {
     return nullptr;
   }
 
   obj->setPrivateGCThing(referent);
   obj->setReservedSlot(OWNER_SLOT, ObjectValue(*debugger));
 
   return obj;
 }
 
-/* static */ DebuggerEnvironmentType DebuggerEnvironment::type() const {
+/* static */
+DebuggerEnvironmentType DebuggerEnvironment::type() const {
   // Don't bother switching compartments just to check env's type.
   if (IsDeclarative(referent())) {
     return DebuggerEnvironmentType::Declarative;
   }
   if (IsDebugEnvironmentWrapper<WithEnvironmentObject>(referent())) {
     return DebuggerEnvironmentType::With;
   }
   return DebuggerEnvironmentType::Object;
@@ -12586,19 +12685,20 @@ bool DebuggerEnvironment::isDebuggee() c
   return owner()->observesGlobal(&referent()->nonCCWGlobal());
 }
 
 bool DebuggerEnvironment::isOptimized() const {
   return referent()->is<DebugEnvironmentProxy>() &&
          referent()->as<DebugEnvironmentProxy>().isOptimizedOut();
 }
 
-/* static */ bool DebuggerEnvironment::getNames(
-    JSContext* cx, HandleDebuggerEnvironment environment,
-    MutableHandle<IdVector> result) {
+/* static */
+bool DebuggerEnvironment::getNames(JSContext* cx,
+                                   HandleDebuggerEnvironment environment,
+                                   MutableHandle<IdVector> result) {
   MOZ_ASSERT(environment->isDebuggee());
 
   Rooted<Env*> referent(cx, environment->referent());
 
   AutoIdVector ids(cx);
   {
     Maybe<AutoRealm> ar;
     ar.emplace(cx, referent);
@@ -12617,19 +12717,21 @@ bool DebuggerEnvironment::isOptimized() 
         return false;
       }
     }
   }
 
   return true;
 }
 
-/* static */ bool DebuggerEnvironment::find(
-    JSContext* cx, HandleDebuggerEnvironment environment, HandleId id,
-    MutableHandleDebuggerEnvironment result) {
+/* static */
+bool DebuggerEnvironment::find(JSContext* cx,
+                               HandleDebuggerEnvironment environment,
+                               HandleId id,
+                               MutableHandleDebuggerEnvironment result) {
   MOZ_ASSERT(environment->isDebuggee());
 
   Rooted<Env*> env(cx, environment->referent());
   Debugger* dbg = environment->owner();
 
   {
     Maybe<AutoRealm> ar;
     ar.emplace(cx, env);
@@ -12652,19 +12754,20 @@ bool DebuggerEnvironment::isOptimized() 
   if (!env) {
     result.set(nullptr);
     return true;
   }
 
   return dbg->wrapEnvironment(cx, env, result);
 }
 
-/* static */ bool DebuggerEnvironment::getVariable(
-    JSContext* cx, HandleDebuggerEnvironment environment, HandleId id,
-    MutableHandleValue result) {
+/* static */
+bool DebuggerEnvironment::getVariable(JSContext* cx,
+                                      HandleDebuggerEnvironment environment,
+                                      HandleId id, MutableHandleValue result) {
   MOZ_ASSERT(environment->isDebuggee());
 
   Rooted<Env*> referent(cx, environment->referent());
   Debugger* dbg = environment->owner();
 
   {
     Maybe<AutoRealm> ar;
     ar.emplace(cx, referent);
@@ -12708,19 +12811,20 @@ bool DebuggerEnvironment::isOptimized() 
     if (obj->is<JSFunction>() &&
         IsInternalFunctionObject(obj->as<JSFunction>()))
       result.setMagic(JS_OPTIMIZED_OUT);
   }
 
   return dbg->wrapDebuggeeValue(cx, result);
 }
 
-/* static */ bool DebuggerEnvironment::setVariable(
-    JSContext* cx, HandleDebuggerEnvironment environment, HandleId id,
-    HandleValue value_) {
+/* static */
+bool DebuggerEnvironment::setVariable(JSContext* cx,
+                                      HandleDebuggerEnvironment environment,
+                                      HandleId id, HandleValue value_) {
   MOZ_ASSERT(environment->isDebuggee());
 
   Rooted<Env*> referent(cx, environment->referent());
   Debugger* dbg = environment->owner();
 
   RootedValue value(cx, value_);
   if (!dbg->unwrapDebuggeeValue(cx, &value)) {
     return false;
@@ -12937,18 +13041,19 @@ JS_PUBLIC_API bool JS::dbg::GetDebuggeeG
        r.popFront()) {
     vector.infallibleAppend(static_cast<JSObject*>(r.front()));
   }
 
   return true;
 }
 
 #ifdef DEBUG
-/* static */ bool Debugger::isDebuggerCrossCompartmentEdge(
-    JSObject* obj, const gc::Cell* target) {
+/* static */
+bool Debugger::isDebuggerCrossCompartmentEdge(JSObject* obj,
+                                              const gc::Cell* target) {
   MOZ_ASSERT(target);
 
   auto cls = obj->getClass();
   const gc::Cell* referent = nullptr;
   if (cls == &DebuggerScript_class) {
     referent = GetScriptReferentCell(obj);
   } else if (cls == &DebuggerSource_class) {
     referent = GetSourceReferentRawObject(obj);
--- a/js/src/vm/DebuggerMemory.cpp
+++ b/js/src/vm/DebuggerMemory.cpp
@@ -30,18 +30,18 @@
 #include "vm/Debugger-inl.h"
 #include "vm/NativeObject-inl.h"
 
 using namespace js;
 
 using mozilla::Maybe;
 using mozilla::Nothing;
 
-/* static */ DebuggerMemory* DebuggerMemory::create(JSContext* cx,
-                                                    Debugger* dbg) {
+/* static */
+DebuggerMemory* DebuggerMemory::create(JSContext* cx, Debugger* dbg) {
   Value memoryProtoValue =
       dbg->object->getReservedSlot(Debugger::JSSLOT_DEBUG_MEMORY_PROTO);
   RootedObject memoryProto(cx, &memoryProtoValue.toObject());
   Rooted<DebuggerMemory*> memory(
       cx, NewObjectWithGivenProto<DebuggerMemory>(cx, memoryProto));
   if (!memory) {
     return nullptr;
   }
@@ -53,29 +53,29 @@ using mozilla::Nothing;
   return memory;
 }
 
 Debugger* DebuggerMemory::getDebugger() {
   const Value& dbgVal = getReservedSlot(JSSLOT_DEBUGGER);
   return Debugger::fromJSObject(&dbgVal.toObject());
 }
 
-/* static */ bool DebuggerMemory::construct(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool DebuggerMemory::construct(JSContext* cx, unsigned argc, Value* vp) {
   JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR,
                             "Debugger.Source");
   return false;
 }
 
 /* static */ const Class DebuggerMemory::class_ = {
     "Memory", JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_COUNT)};
 
-/* static */ DebuggerMemory* DebuggerMemory::checkThis(JSContext* cx,
-                                                       CallArgs& args,
-                                                       const char* fnName) {
+/* static */
+DebuggerMemory* DebuggerMemory::checkThis(JSContext* cx, CallArgs& args,
+                                          const char* fnName) {
   const Value& thisValue = args.thisv();
 
   if (!thisValue.isObject()) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_NOT_NONNULL_OBJECT,
                               InformalValueTypeName(thisValue));
     return nullptr;
   }
@@ -122,19 +122,19 @@ Debugger* DebuggerMemory::getDebugger() 
   Rooted<DebuggerMemory*> memory(cx, checkThis(cx, args, fnName)); \
   if (!memory) return false
 
 static bool undefined(CallArgs& args) {
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerMemory::setTrackingAllocationSites(JSContext* cx,
-                                                             unsigned argc,
-                                                             Value* vp) {
+/* static */
+bool DebuggerMemory::setTrackingAllocationSites(JSContext* cx, unsigned argc,
+                                                Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(set trackingAllocationSites)", args,
                        memory);
   if (!args.requireAtLeast(cx, "(set trackingAllocationSites)", 1)) {
     return false;
   }
 
   Debugger* dbg = memory->getDebugger();
   bool enabling = ToBoolean(args[0]);
@@ -156,28 +156,28 @@ static bool undefined(CallArgs& args) {
     }
   } else {
     dbg->removeAllocationsTrackingForAllDebuggees();
   }
 
   return undefined(args);
 }
 
-/* static */ bool DebuggerMemory::getTrackingAllocationSites(JSContext* cx,
-                                                             unsigned argc,
-                                                             Value* vp) {
+/* static */
+bool DebuggerMemory::getTrackingAllocationSites(JSContext* cx, unsigned argc,
+                                                Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(get trackingAllocationSites)", args,
                        memory);
   args.rval().setBoolean(memory->getDebugger()->trackingAllocationSites);
   return true;
 }
 
-/* static */ bool DebuggerMemory::drainAllocationsLog(JSContext* cx,
-                                                      unsigned argc,
-                                                      Value* vp) {
+/* static */
+bool DebuggerMemory::drainAllocationsLog(JSContext* cx, unsigned argc,
+                                         Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "drainAllocationsLog", args, memory);
   Debugger* dbg = memory->getDebugger();
 
   if (!dbg->trackingAllocationSites) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_NOT_TRACKING_ALLOCATIONS,
                               "drainAllocationsLog");
     return false;
@@ -251,28 +251,28 @@ static bool undefined(CallArgs& args) {
     dbg->allocationsLog.popFront();
   }
 
   dbg->allocationsLogOverflowed = false;
   args.rval().setObject(*result);
   return true;
 }
 
-/* static */ bool DebuggerMemory::getMaxAllocationsLogLength(JSContext* cx,
-                                                             unsigned argc,
-                                                             Value* vp) {
+/* static */
+bool DebuggerMemory::getMaxAllocationsLogLength(JSContext* cx, unsigned argc,
+                                                Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(get maxAllocationsLogLength)", args,
                        memory);
   args.rval().setInt32(memory->getDebugger()->maxAllocationsLogLength);
   return true;
 }
 
-/* static */ bool DebuggerMemory::setMaxAllocationsLogLength(JSContext* cx,
-                                                             unsigned argc,
-                                                             Value* vp) {
+/* static */
+bool DebuggerMemory::setMaxAllocationsLogLength(JSContext* cx, unsigned argc,
+                                                Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(set maxAllocationsLogLength)", args,
                        memory);
   if (!args.requireAtLeast(cx, "(set maxAllocationsLogLength)", 1)) {
     return false;
   }
 
   int32_t max;
   if (!ToInt32(cx, args[0], &max)) {
@@ -292,26 +292,30 @@ static bool undefined(CallArgs& args) {
   while (dbg->allocationsLog.length() > dbg->maxAllocationsLogLength) {
     dbg->allocationsLog.popFront();
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerMemory::getAllocationSamplingProbability(
-    JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool DebuggerMemory::getAllocationSamplingProbability(JSContext* cx,
+                                                      unsigned argc,
+                                                      Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(get allocationSamplingProbability)",
                        args, memory);
   args.rval().setDouble(memory->getDebugger()->allocationSamplingProbability);
   return true;
 }
 
-/* static */ bool DebuggerMemory::setAllocationSamplingProbability(
-    JSContext* cx, unsigned argc, Value* vp) {
+/* static */
+bool DebuggerMemory::setAllocationSamplingProbability(JSContext* cx,
+                                                      unsigned argc,
+                                                      Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(set allocationSamplingProbability)",
                        args, memory);
   if (!args.requireAtLeast(cx, "(set allocationSamplingProbability)", 1)) {
     return false;
   }
 
   double probability;
   if (!ToNumber(cx, args[0], &probability)) {
@@ -339,36 +343,36 @@ static bool undefined(CallArgs& args) {
       }
     }
   }
 
   args.rval().setUndefined();
   return true;
 }
 
-/* static */ bool DebuggerMemory::getAllocationsLogOverflowed(JSContext* cx,
-                                                              unsigned argc,
-                                                              Value* vp) {
+/* static */
+bool DebuggerMemory::getAllocationsLogOverflowed(JSContext* cx, unsigned argc,
+                                                 Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(get allocationsLogOverflowed)", args,
                        memory);
   args.rval().setBoolean(memory->getDebugger()->allocationsLogOverflowed);
   return true;
 }
 
-/* static */ bool DebuggerMemory::getOnGarbageCollection(JSContext* cx,
-                                                         unsigned argc,
-                                                         Value* vp) {
+/* static */
+bool DebuggerMemory::getOnGarbageCollection(JSContext* cx, unsigned argc,
+                                            Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(get onGarbageCollection)", args, memory);
   return Debugger::getHookImpl(cx, args, *memory->getDebugger(),
                                Debugger::OnGarbageCollection);
 }
 
-/* static */ bool DebuggerMemory::setOnGarbageCollection(JSContext* cx,
-                                                         unsigned argc,
-                                                         Value* vp) {
+/* static */
+bool DebuggerMemory::setOnGarbageCollection(JSContext* cx, unsigned argc,
+                                            Value* vp) {
   THIS_DEBUGGER_MEMORY(cx, argc, vp, "(set onGarbageCollection)", args, memory);
   return Debugger::setHookImpl(cx, args, *memory->getDebugger(),
                                Debugger::OnGarbageCollection);
 }
 
 /* Debugger.Memory.prototype.takeCensus */
 
 JS_PUBLIC_API void JS::dbg::SetDebuggerMallocSizeOf(
--- a/js/src/vm/EnvironmentObject.cpp
+++ b/js/src/vm/EnvironmentObject.cpp
@@ -221,19 +221,21 @@ CallObject* CallObject::createHollowForD
   return callobj;
 }
 
 const Class CallObject::class_ = {
     "Call", JSCLASS_HAS_RESERVED_SLOTS(CallObject::RESERVED_SLOTS)};
 
 /*****************************************************************************/
 
-/* static */ VarEnvironmentObject* VarEnvironmentObject::create(
-    JSContext* cx, HandleShape shape, HandleObject enclosing,
-    gc::InitialHeap heap) {
+/* static */
+VarEnvironmentObject* VarEnvironmentObject::create(JSContext* cx,
+                                                   HandleShape shape,
+                                                   HandleObject enclosing,
+                                                   gc::InitialHeap heap) {
   MOZ_ASSERT(shape->getObjectClass() == &class_);
 
   RootedObjectGroup group(
       cx, ObjectGroup::defaultNewGroup(cx, &class_, TaggedProto(nullptr)));
   if (!group) {
     return nullptr;
   }
 
@@ -249,18 +251,20 @@ const Class CallObject::class_ = {
   MOZ_ASSERT(!env->inDictionaryMode());
   MOZ_ASSERT(env->isDelegate());
 
   env->initEnclosingEnvironment(enclosing);
 
   return env;
 }
 
-/* static */ VarEnvironmentObject* VarEnvironmentObject::create(
-    JSContext* cx, HandleScope scope, AbstractFramePtr frame) {
+/* static */
+VarEnvironmentObject* VarEnvironmentObject::create(JSContext* cx,
+                                                   HandleScope scope,
+                                                   AbstractFramePtr frame) {
 #ifdef DEBUG
   if (frame.isEvalFrame()) {
     MOZ_ASSERT(scope->is<EvalScope>() && scope == frame.script()->bodyScope());
     MOZ_ASSERT_IF(frame.isInterpreterFrame(),
                   cx->interpreterFrame() == frame.asInterpreterFrame());
     MOZ_ASSERT_IF(frame.isInterpreterFrame(),
                   cx->interpreterRegs().pc == frame.script()->code());
   } else {
@@ -278,17 +282,18 @@ const Class CallObject::class_ = {
   VarEnvironmentObject* env = create(cx, shape, envChain, heap);
   if (!env) {
     return nullptr;
   }
   env->initScope(scope);
   return env;
 }
 
-/* static */ VarEnvironmentObject* VarEnvironmentObject::createHollowForDebug(
+/* static */
+VarEnvironmentObject* VarEnvironmentObject::createHollowForDebug(
     JSContext* cx, Handle<VarScope*> scope) {
   MOZ_ASSERT(!scope->hasEnvironment());
 
   RootedShape shape(cx, VarScope::getEmptyEnvironmentShape(cx));
   if (!shape) {
     return nullptr;
   }
 
@@ -341,17 +346,18 @@ const ClassOps ModuleEnvironmentObject::
 const Class ModuleEnvironmentObject::class_ = {
     "ModuleEnvironmentObject",
     JSCLASS_HAS_RESERVED_SLOTS(ModuleEnvironmentObject::RESERVED_SLOTS),
     &ModuleEnvironmentObject::classOps_,
     JS_NULL_CLASS_SPEC,
     JS_NULL_CLASS_EXT,
     &ModuleEnvironmentObject::objectOps_};
 
-/* static */ ModuleEnvironmentObject* ModuleEnvironmentObject::create(
+/* static */
+ModuleEnvironmentObject* ModuleEnvironmentObject::create(
     JSContext* cx, HandleModuleObject module) {
   RootedScript script(cx, module->script());
   RootedShape shape(cx,
                     script->bodyScope()->as<ModuleScope>().environmentShape());
   MOZ_ASSERT(shape->getObjectClass() == &class_);
 
   RootedObjectGroup group(
       cx, ObjectGroup::defaultNewGroup(cx, &class_, TaggedProto(nullptr)));
@@ -430,17 +436,18 @@ bool ModuleEnvironmentObject::lookupImpo
   return importBindings().lookup(name, envOut, shapeOut);
 }
 
 void ModuleEnvironmentObject::fixEnclosingEnvironmentAfterCompartmentMerge(
     GlobalObject& global) {
   setEnclosingEnvironment(&global.lexicalEnvironment());
 }
 
-/* static */ bool ModuleEnvironmentObject::lookupProperty(
+/* static */
+bool ModuleEnvironmentObject::lookupProperty(
     JSContext* cx, HandleObject obj, HandleId id, MutableHandleObject objp,
     MutableHandle<PropertyResult> propp) {
   const IndirectBindingMap& bindings =
       obj->as<ModuleEnvironmentObject>().importBindings();
   Shape* shape;
   ModuleEnvironmentObject* env;
   if (bindings.lookup(id, &env, &shape)) {
     objp.set(env);
@@ -452,59 +459,60 @@ void ModuleEnvironmentObject::fixEnclosi
   if (!NativeLookupOwnProperty<CanGC>(cx, target, id, propp)) {
     return false;
   }
 
   objp.set(obj);
   return true;
 }
 
-/* static */ bool ModuleEnvironmentObject::hasProperty(JSContext* cx,
-                                                       HandleObject obj,
-                                                       HandleId id,
-                                                       bool* foundp) {
+/* static */
+bool ModuleEnvironmentObject::hasProperty(JSContext* cx, HandleObject obj,
+                                          HandleId id, bool* foundp) {
   if (obj->as<ModuleEnvironmentObject>().importBindings().has(id)) {
     *foundp = true;
     return true;
   }
 
   RootedNativeObject self(cx, &obj->as<NativeObject>());
   return NativeHasProperty(cx, self, id, foundp);
 }
 
-/* static */ bool ModuleEnvironmentObject::getProperty(JSContext* cx,
-                                                       HandleObject obj,
-                                                       HandleValue receiver,
-                                                       HandleId id,
-                                                       MutableHandleValue vp) {
+/* static */
+bool ModuleEnvironmentObject::getProperty(JSContext* cx, HandleObject obj,
+                                          HandleValue receiver, HandleId id,
+                                          MutableHandleValue vp) {
   const IndirectBindingMap& bindings =
       obj->as<ModuleEnvironmentObject>().importBindings();
   Shape* shape;
   ModuleEnvironmentObject* env;
   if (bindings.lookup(id, &env, &shape)) {
     vp.set(env->getSlot(shape->slot()));
     return true;
   }
 
   RootedNativeObject self(cx, &obj->as<NativeObject>());
   return NativeGetProperty(cx, self, receiver, id, vp);
 }
 
-/* static */ bool ModuleEnvironmentObject::setProperty(
-    JSContext* cx, HandleObject obj, HandleId id, HandleValue v,
-    HandleValue receiver, JS::ObjectOpResult& result) {
+/* static */
+bool ModuleEnvironmentObject::setProperty(JSContext* cx, HandleObject obj,
+                                          HandleId id, HandleValue v,
+                                          HandleValue receiver,
+                                          JS::ObjectOpResult& result) {
   RootedModuleEnvironmentObject self(cx, &obj->as<ModuleEnvironmentObject>());
   if (self->importBindings().has(id)) {
     return result.failReadOnly();
   }
 
   return NativeSetProperty<Qualified>(cx, self, id, v, receiver, result);
 }
 
-/* static */ bool ModuleEnvironmentObject::getOwnPropertyDescriptor(
+/* static */
+bool ModuleEnvironmentObject::getOwnPropertyDescriptor(
     JSContext* cx, HandleObject obj, HandleId id,
     MutableHandle<PropertyDescriptor> desc) {
   const IndirectBindingMap& bindings =
       obj->as<ModuleEnvironmentObject>().importBindings();
   Shape* shape;
   ModuleEnvironmentObject* env;
   if (bindings.lookup(id, &env, &shape)) {
     desc.setAttributes(JSPROP_ENUMERATE | JSPROP_PERMANENT);
@@ -514,24 +522,27 @@ void ModuleEnvironmentObject::fixEnclosi
     desc.assertComplete();
     return true;
   }
 
   RootedNativeObject self(cx, &obj->as<NativeObject>());
   return NativeGetOwnPropertyDescriptor(cx, self, id, desc);
 }
 
-/* static */ bool ModuleEnvironmentObject::deleteProperty(
-    JSContext* cx, HandleObject obj, HandleId id, ObjectOpResult& result) {
+/* static */
+bool ModuleEnvironmentObject::deleteProperty(JSContext* cx, HandleObject obj,
+                                             HandleId id,
+                                             ObjectOpResult& result) {
   return result.failCantDelete();
 }
 
-/* static */ bool ModuleEnvironmentObject::newEnumerate(
-    JSContext* cx, HandleObject obj, AutoIdVector& properties,
-    bool enumerableOnly) {
+/* static */
+bool ModuleEnvironmentObject::newEnumerate(JSContext* cx, HandleObject obj,
+                                           AutoIdVector& properties,
+                                           bool enumerableOnly) {
   RootedModuleEnvironmentObject self(cx, &obj->as<ModuleEnvironmentObject>());
   const IndirectBindingMap& bs(self->importBindings());
 
   MOZ_ASSERT(properties.length() == 0);
   size_t count = bs.count() + self->slotSpan() - RESERVED_SLOTS;
   if (!properties.reserve(count)) {
     ReportOutOfMemory(cx);
     return false;
@@ -548,17 +559,18 @@ void ModuleEnvironmentObject::fixEnclosi
 }
 
 /*****************************************************************************/
 
 const Class WasmInstanceEnvironmentObject::class_ = {
     "WasmInstance",
     JSCLASS_HAS_RESERVED_SLOTS(WasmInstanceEnvironmentObject::RESERVED_SLOTS)};
 
-/* static */ WasmInstanceEnvironmentObject*
+/* static */
+WasmInstanceEnvironmentObject*
 WasmInstanceEnvironmentObject::createHollowForDebug(
     JSContext* cx, Handle<WasmInstanceScope*> scope) {
   RootedObjectGroup group(
       cx, ObjectGroup::defaultNewGroup(cx, &class_, TaggedProto(nullptr)));
   if (!group) {
     return nullptr;
   }
 
@@ -584,20 +596,19 @@ WasmInstanceEnvironmentObject::createHol
 }
 
 /*****************************************************************************/
 
 const Class WasmFunctionCallObject::class_ = {
     "WasmCall",
     JSCLASS_HAS_RESERVED_SLOTS(WasmFunctionCallObject::RESERVED_SLOTS)};
 
-/* static */ WasmFunctionCallObject*
-WasmFunctionCallObject::createHollowForDebug(JSContext* cx,
-                                             HandleObject enclosing,
-                                             Handle<WasmFunctionScope*> scope) {
+/* static */
+WasmFunctionCallObject* WasmFunctionCallObject::createHollowForDebug(
+    JSContext* cx, HandleObject enclosing, Handle<WasmFunctionScope*> scope) {
   RootedObjectGroup group(
       cx, ObjectGroup::defaultNewGroup(cx, &class_, TaggedProto(nullptr)));
   if (!group) {
     return nullptr;
   }
 
   RootedShape shape(cx, scope->getEmptyEnvironmentShape(cx));
   if (!shape) {
@@ -787,17 +798,18 @@ static const ObjectOps WithEnvironmentOb
 const Class WithEnvironmentObject::class_ = {
     "With",
     JSCLASS_HAS_RESERVED_SLOTS(WithEnvironmentObject::RESERVED_SLOTS),
     JS_NULL_CLASS_OPS,
     JS_NULL_CLASS_SPEC,
     JS_NULL_CLASS_EXT,
     &WithEnvironmentObjectOps};
 
-/* static */ NonSyntacticVariablesObject* NonSyntacticVariablesObject::create(
+/* static */
+NonSyntacticVariablesObject* NonSyntacticVariablesObject::create(
     JSContext* cx) {
   Rooted<NonSyntacticVariablesObject*> obj(
       cx, NewObjectWithNullTaggedProto<NonSyntacticVariablesObject>(
               cx, TenuredObject, BaseShape::DELEGATE));
   if (!obj) {
     return nullptr;
   }
 
@@ -857,20 +869,20 @@ bool js::CreateNonSyntacticEnvironmentCh
     scope.set(&cx->global()->emptyGlobalScope());
   }
 
   return true;
 }
 
 /*****************************************************************************/
 
-/* static */ LexicalEnvironmentObject*
-LexicalEnvironmentObject::createTemplateObject(JSContext* cx, HandleShape shape,
-                                               HandleObject enclosing,
-                                               gc::InitialHeap heap) {
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::createTemplateObject(
+    JSContext* cx, HandleShape shape, HandleObject enclosing,
+    gc::InitialHeap heap) {
   MOZ_ASSERT(shape->getObjectClass() == &LexicalEnvironmentObject::class_);
 
   RootedObjectGroup group(
       cx, ObjectGroup::defaultNewGroup(cx, &LexicalEnvironmentObject::class_,
                                        TaggedProto(nullptr)));
   if (!group) {
     return nullptr;
   }
@@ -890,17 +902,18 @@ LexicalEnvironmentObject::createTemplate
 
   if (enclosing) {
     env->initEnclosingEnvironment(enclosing);
   }
 
   return env;
 }
 
-/* static */ LexicalEnvironmentObject* LexicalEnvironmentObject::create(
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::create(
     JSContext* cx, Handle<LexicalScope*> scope, HandleObject enclosing,
     gc::InitialHeap heap) {
   cx->check(enclosing);
   MOZ_ASSERT(scope->hasEnvironment());
 
   RootedShape shape(cx, scope->environmentShape());
   LexicalEnvironmentObject* env =
       createTemplateObject(cx, shape, enclosing, heap);
@@ -914,23 +927,25 @@ LexicalEnvironmentObject::createTemplate
   for (uint32_t slot = JSSLOT_FREE(&class_); slot <= lastSlot; slot++) {
     env->initSlot(slot, MagicValue(JS_UNINITIALIZED_LEXICAL));
   }
 
   env->initScopeUnchecked(scope);
   return env;
 }
 
-/* static */ LexicalEnvironmentObject* LexicalEnvironmentObject::create(
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::create(
     JSContext* cx, Handle<LexicalScope*> scope, AbstractFramePtr frame) {
   RootedObject enclosing(cx, frame.environmentChain());
   return create(cx, scope, enclosing, gc::DefaultHeap);
 }
 
-/* static */ LexicalEnvironmentObject* LexicalEnvironmentObject::createGlobal(
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::createGlobal(
     JSContext* cx, Handle<GlobalObject*> global) {
   MOZ_ASSERT(global);
 
   RootedShape shape(cx, LexicalScope::getEmptyExtensibleEnvironmentShape(cx));
   if (!shape) {
     return nullptr;
   }
 
@@ -944,20 +959,19 @@ LexicalEnvironmentObject::createTemplate
   if (!JSObject::setSingleton(cx, env)) {
     return nullptr;
   }
 
   env->initThisValue(global);
   return env;
 }
 
-/* static */ LexicalEnvironmentObject*
-LexicalEnvironmentObject::createNonSyntactic(JSContext* cx,
-                                             HandleObject enclosing,
-                                             HandleObject thisv) {
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::createNonSyntactic(
+    JSContext* cx, HandleObject enclosing, HandleObject thisv) {
   MOZ_ASSERT(enclosing);
   MOZ_ASSERT(!IsSyntacticEnvironment(enclosing));
 
   RootedShape shape(cx, LexicalScope::getEmptyExtensibleEnvironmentShape(cx));
   if (!shape) {
     return nullptr;
   }
 
@@ -968,19 +982,19 @@ LexicalEnvironmentObject::createNonSynta
     return nullptr;
   }
 
   env->initThisValue(thisv);
 
   return env;
 }
 
-/* static */ LexicalEnvironmentObject*
-LexicalEnvironmentObject::createHollowForDebug(JSContext* cx,
-                                               Handle<LexicalScope*> scope) {
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::createHollowForDebug(
+    JSContext* cx, Handle<LexicalScope*> scope) {
   MOZ_ASSERT(!scope->hasEnvironment());
 
   RootedShape shape(cx, LexicalScope::getEmptyExtensibleEnvironmentShape(cx));
   if (!shape) {
     return nullptr;
   }
 
   // This environment's enclosing link is never used: the
@@ -1007,17 +1021,18 @@ LexicalEnvironmentObject::createHollowFo
                           JSObject::GENERATE_SHAPE)) {
     return nullptr;
   }
 
   env->initScopeUnchecked(scope);
   return env;
 }
 
-/* static */ LexicalEnvironmentObject* LexicalEnvironmentObject::clone(
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::clone(
     JSContext* cx, Handle<LexicalEnvironmentObject*> env) {
   Rooted<LexicalScope*> scope(cx, &env->scope());
   RootedObject enclosing(cx, &env->enclosingEnvironment());
   Rooted<LexicalEnvironmentObject*> copy(
       cx, create(cx, scope, enclosing, gc::DefaultHeap));
   if (!copy) {
     return nullptr;
   }
@@ -1027,17 +1042,18 @@ LexicalEnvironmentObject::createHollowFo
   MOZ_ASSERT(env->slotSpan() == copy->slotSpan());
   for (uint32_t i = JSSLOT_FREE(&class_); i < copy->slotSpan(); i++) {
     copy->setSlot(i, env->getSlot(i));
   }
 
   return copy;
 }
 
-/* static */ LexicalEnvironmentObject* LexicalEnvironmentObject::recreate(
+/* static */
+LexicalEnvironmentObject* LexicalEnvironmentObject::recreate(
     JSContext* cx, Handle<LexicalEnvironmentObject*> env) {
   Rooted<LexicalScope*> scope(cx, &env->scope());
   RootedObject enclosing(cx, &env->enclosingEnvironment());
   return create(cx, scope, enclosing, gc::DefaultHeap);
 }
 
 bool LexicalEnvironmentObject::isExtensible() const {
   return NativeObject::isExtensible();
@@ -1063,19 +1079,22 @@ void LexicalEnvironmentObject::setWindow
 const Class LexicalEnvironmentObject::class_ = {
     "LexicalEnvironment",
     JSCLASS_HAS_RESERVED_SLOTS(LexicalEnvironmentObject::RESERVED_SLOTS),
     JS_NULL_CLASS_OPS,
     JS_NULL_CLASS_SPEC,
     JS_NULL_CLASS_EXT,
     JS_NULL_OBJECT_OPS};
 
-/* static */ NamedLambdaObject* NamedLambdaObject::create(
-    JSContext* cx, HandleFunction callee, HandleFunction func,
-    HandleObject enclosing, gc::InitialHeap heap) {
+/* static */
+NamedLambdaObject* NamedLambdaObject::create(JSContext* cx,
+                                             HandleFunction callee,
+                                             HandleFunction func,
+                                             HandleObject enclosing,
+                                             gc::InitialHeap heap) {
   MOZ_ASSERT(callee->isNamedLambda());
   RootedScope scope(cx, callee->nonLazyScript()->maybeNamedLambdaScope());
   MOZ_ASSERT(scope && scope->environmentShape());
   MOZ_ASSERT(scope->environmentShape()->slot() == lambdaSlot());
   MOZ_ASSERT(!scope->environmentShape()->writable());
 
 #ifdef DEBUG
   // There should be exactly one binding in the named lambda scope.
@@ -1089,34 +1108,38 @@ const Class LexicalEnvironmentObject::cl
   if (!obj) {
     return nullptr;
   }
 
   obj->initFixedSlot(lambdaSlot(), ObjectValue(*func));
   return static_cast<NamedLambdaObject*>(obj);
 }
 
-/* static */ NamedLambdaObject* NamedLambdaObject::createTemplateObject(
+/* static */
+NamedLambdaObject* NamedLambdaObject::createTemplateObject(
     JSContext* cx, HandleFunction callee, gc::InitialHeap heap) {
   return create(cx, callee, callee, nullptr, heap);
 }
 
-/* static */ NamedLambdaObject* NamedLambdaObject::create(
-    JSContext* cx, AbstractFramePtr frame) {
+/* static */
+NamedLambdaObject* NamedLambdaObject::create(JSContext* cx,
+                                             AbstractFramePtr frame) {
   RootedFunction fun(cx, frame.callee());
   RootedObject enclosing(cx, frame.environmentChain());
   return create(cx, fun, fun, enclosing, gc::DefaultHeap);
 }
 
-/* static */ size_t NamedLambdaObject::lambdaSlot() {
+/* static */
+size_t NamedLambdaObject::lambdaSlot() {
   // Named lambda environments have exactly one name.
   return JSSLOT_FREE(&LexicalEnvironmentObject::class_);
 }
 
-/* static */ RuntimeLexicalErrorObject* RuntimeLexicalErrorObject::create(
+/* static */
+RuntimeLexicalErrorObject* RuntimeLexicalErrorObject::create(
     JSContext* cx, HandleObject enclosing, unsigned errorNumber) {
   RuntimeLexicalErrorObject* obj =
       NewObjectWithNullTaggedProto<RuntimeLexicalErrorObject>(
           cx, GenericObject, BaseShape::DELEGATE);
   if (!obj) {
     return nullptr;
   }
   obj->initEnclosingEnvironment(enclosing);
@@ -1337,22 +1360,24 @@ bool EnvironmentIter::hasNonSyntacticEnv
   if (si_.kind() == ScopeKind::NonSyntactic) {
     MOZ_ASSERT_IF(env_->is<WithEnvironmentObject>(),
                   !env_->as<WithEnvironmentObject>().isSyntactic());
     return env_->is<EnvironmentObject>();
   }
   return false;
 }
 
-/* static */ HashNumber MissingEnvironmentKey::hash(MissingEnvironmentKey ek) {
+/* static */
+HashNumber MissingEnvironmentKey::hash(MissingEnvironmentKey ek) {
   return size_t(ek.frame_.raw()) ^ size_t(ek.scope_);
 }
 
-/* static */ bool MissingEnvironmentKey::match(MissingEnvironmentKey ek1,
-                                               MissingEnvironmentKey ek2) {
+/* static */
+bool MissingEnvironmentKey::match(MissingEnvironmentKey ek1,
+                                  MissingEnvironmentKey ek2) {
   return ek1.frame_ == ek2.frame_ && ek1.scope_ == ek2.scope_;
 }
 
 bool LiveEnvironmentVal::needsSweep() {
   if (scope_) {
     MOZ_ALWAYS_FALSE(IsAboutToBeFinalized(&scope_));
   }
   return false;
@@ -2330,18 +2355,20 @@ class DebugEnvironmentProxyHandler : pub
 template <>
 bool JSObject::is<js::DebugEnvironmentProxy>() const {
   return IsDerivedProxyObject(this, &DebugEnvironmentProxyHandler::singleton);
 }
 
 const char DebugEnvironmentProxyHandler::family = 0;
 const DebugEnvironmentProxyHandler DebugEnvironmentProxyHandler::singleton;
 
-/* static */ DebugEnvironmentProxy* DebugEnvironmentProxy::create(
-    JSContext* cx, EnvironmentObject& env, HandleObject enclosing) {
+/* static */
+DebugEnvironmentProxy* DebugEnvironmentProxy::create(JSContext* cx,
+                                                     EnvironmentObject& env,
+                                                     HandleObject enclosing) {
   MOZ_ASSERT(env.realm() == cx->realm());
   MOZ_ASSERT(!enclosing->is<EnvironmentObject>());
 
   RootedValue priv(cx, ObjectValue(env));
   JSObject* obj = NewProxyObject(cx, &DebugEnvironmentProxyHandler::singleton,
                                  priv, nullptr /* proto */);
   if (!obj) {
     return nullptr;
@@ -2375,17 +2402,18 @@ void DebugEnvironmentProxy::initSnapshot
 bool DebugEnvironmentProxy::isForDeclarative() const {
   EnvironmentObject& e = environment();
   return e.is<CallObject>() || e.is<VarEnvironmentObject>() ||
          e.is<ModuleEnvironmentObject>() ||
          e.is<WasmInstanceEnvironmentObject>() ||
          e.is<WasmFunctionCallObject>() || e.is<LexicalEnvironmentObject>();
 }
 
-/* static */ bool DebugEnvironmentProxy::getMaybeSentinelValue(
+/* static */
+bool DebugEnvironmentProxy::getMaybeSentinelValue(
     JSContext* cx, Handle<DebugEnvironmentProxy*> env, HandleId id,
     MutableHandleValue vp) {
   return DebugEnvironmentProxyHandler::singleton.getMaybeSentinelValue(cx, env,
                                                                        id, vp);
 }
 
 bool DebugEnvironmentProxy::isFunctionEnvironmentWithThis() {
   return DebugEnvironmentProxyHandler::isFunctionEnvironmentWithThis(
@@ -2511,32 +2539,34 @@ DebugEnvironments* DebugEnvironments::en
   if (!debugEnvs) {
     return nullptr;
   }
 
   realm->debugEnvsRef() = std::move(debugEnvs);
   return realm->debugEnvs();
 }
 
-/* static */ DebugEnvironmentProxy* DebugEnvironments::hasDebugEnvironment(
+/* static */
+DebugEnvironmentProxy* DebugEnvironments::hasDebugEnvironment(
     JSContext* cx, EnvironmentObject& env) {
   DebugEnvironments* envs = env.realm()->debugEnvs();
   if (!envs) {
     return nullptr;
   }
 
   if (JSObject* obj = envs->proxiedEnvs.lookup(&env)) {
     MOZ_ASSERT(CanUseDebugEnvironmentMaps(cx));
     return &obj->as<DebugEnvironmentProxy>();
   }
 
   return nullptr;
 }
 
-/* static */ bool DebugEnvironments::addDebugEnvironment(
+/* static */
+bool DebugEnvironments::addDebugEnvironment(
     JSContext* cx, Handle<EnvironmentObject*> env,
     Handle<DebugEnvironmentProxy*> debugEnv) {
   MOZ_ASSERT(cx->realm() == env->realm());
   MOZ_ASSERT(cx->realm() == debugEnv->nonCCWRealm());
 
   if (!CanUseDebugEnvironmentMaps(cx)) {
     return true;
   }
@@ -2544,34 +2574,36 @@ DebugEnvironments* DebugEnvironments::en
   DebugEnvironments* envs = ensureRealmData(cx);
   if (!envs) {
     return false;
   }
 
   return envs->proxiedEnvs.add(cx, env, debugEnv);
 }
 
-/* static */ DebugEnvironmentProxy* DebugEnvironments::hasDebugEnvironment(
+/* static */
+DebugEnvironmentProxy* DebugEnvironments::hasDebugEnvironment(
     JSContext* cx, const EnvironmentIter& ei) {
   MOZ_ASSERT(!ei.hasSyntacticEnvironment());
 
   DebugEnvironments* envs = cx->realm()->debugEnvs();
   if (!envs) {
     return nullptr;
   }
 
   if (MissingEnvironmentMap::Ptr p =
           envs->missingEnvs.lookup(MissingEnvironmentKey(ei))) {
     MOZ_ASSERT(CanUseDebugEnvironmentMaps(cx));
     return p->value();
   }
   return nullptr;
 }
 
-/* static */ bool DebugEnvironments::addDebugEnvironment(
+/* static */
+bool DebugEnvironments::addDebugEnvironment(
     JSContext* cx, const EnvironmentIter& ei,
     Handle<DebugEnvironmentProxy*> debugEnv) {
   MOZ_ASSERT(!ei.hasSyntacticEnvironment());
   MOZ_ASSERT(cx->realm() == debugEnv->nonCCWRealm());
   // Generators should always have environments.
   MOZ_ASSERT_IF(
       ei.scope().is<FunctionScope>(),
       !ei.scope().as<FunctionScope>().canonicalFunction()->isGenerator() &&
@@ -2602,17 +2634,18 @@ DebugEnvironments* DebugEnvironments::en
       ReportOutOfMemory(cx);
       return false;
     }
   }
 
   return true;
 }
 
-/* static */ void DebugEnvironments::takeFrameSnapshot(
+/* static */
+void DebugEnvironments::takeFrameSnapshot(
     JSContext* cx, Handle<DebugEnvironmentProxy*> debugEnv,
     AbstractFramePtr frame) {
   /*
    * When the JS stack frame is popped, the values of unaliased variables
    * are lost. If there is any debug env referring to this environment, save a
    * copy of the unaliased variables' values in an array for later debugger
    * access via DebugEnvironmentProxy::handleUnaliasedAccess.
    *
@@ -2712,18 +2745,18 @@ DebugEnvironments* DebugEnvironments::en
     MOZ_ASSERT(cx->isThrowingOutOfMemory() || cx->isThrowingOverRecursed());
     cx->clearPendingException();
     return;
   }
 
   debugEnv->initSnapshot(*snapshot);
 }
 
-/* static */ void DebugEnvironments::onPopCall(JSContext* cx,
-                                               AbstractFramePtr frame) {
+/* static */
+void DebugEnvironments::onPopCall(JSContext* cx, AbstractFramePtr frame) {
   cx->check(frame);
 
   DebugEnvironments* envs = cx->realm()->debugEnvs();
   if (!envs) {
     return;
   }
 
   Rooted<DebugEnvironmentProxy*> debugEnv(cx, nullptr);
@@ -2927,18 +2960,19 @@ LiveEnvironmentVal* DebugEnvironments::h
 
   if (LiveEnvironmentMap::Ptr p = envs->liveEnvs.lookup(&env)) {
     return &p->value();
   }
 
   return nullptr;
 }
 
-/* static */ void DebugEnvironments::unsetPrevUpToDateUntil(
-    JSContext* cx, AbstractFramePtr until) {
+/* static */
+void DebugEnvironments::unsetPrevUpToDateUntil(JSContext* cx,
+                                               AbstractFramePtr until) {
   // This are two exceptions where fp->prevUpToDate() is cleared without
   // popping the frame. When a frame is rematerialized or has its
   // debuggeeness toggled off->on, all frames younger than the frame must
   // have their prevUpToDate set to false. This is because unrematerialized
   // Ion frames and non-debuggee frames are skipped by updateLiveEnvironments.
   // If in the future a frame suddenly gains a usable AbstractFramePtr via
   // rematerialization or becomes a debuggee, the prevUpToDate invariant
   // will no longer hold for older frames on its stack.
@@ -2955,19 +2989,19 @@ LiveEnvironmentVal* DebugEnvironments::h
     if (frame.realm() != cx->realm()) {
       continue;
     }
 
     frame.unsetPrevUpToDate();
   }
 }
 
-/* static */ void DebugEnvironments::forwardLiveFrame(JSContext* cx,
-                                                      AbstractFramePtr from,
-                                                      AbstractFramePtr to) {
+/* static */
+void DebugEnvironments::forwardLiveFrame(JSContext* cx, AbstractFramePtr from,
+                                         AbstractFramePtr to) {
   DebugEnvironments* envs = cx->realm()->debugEnvs();
   if (!envs) {
     return;
   }
 
   for (MissingEnvironmentMap::Enum e(envs->missingEnvs); !e.empty();
        e.popFront()) {
     MissingEnvironmentKey key = e.front().key();
@@ -2980,18 +3014,18 @@ LiveEnvironmentVal* DebugEnvironments::h
   for (LiveEnvironmentMap::Enum e(envs->liveEnvs); !e.empty(); e.popFront()) {
     LiveEnvironmentVal& val = e.front().value();
     if (val.frame() == from) {
       val.updateFrame(to);
     }
   }
 }
 
-/* static */ void DebugEnvironments::traceLiveFrame(JSTracer* trc,
-                                                    AbstractFramePtr frame) {
+/* static */
+void DebugEnvironments::traceLiveFrame(JSTracer* trc, AbstractFramePtr frame) {
   for (MissingEnvironmentMap::Enum e(missingEnvs); !e.empty(); e.popFront()) {
     if (e.front().key().frame() == frame) {
       TraceEdge(trc, &e.front().value(), "debug-env-live-frame-missing-env");
     }
   }
 }
 
 /*****************************************************************************/
--- a/js/src/vm/ErrorObject.cpp
+++ b/js/src/vm/ErrorObject.cpp
@@ -21,40 +21,39 @@
 
 #include "vm/JSObject-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/SavedStacks-inl.h"
 #include "vm/Shape-inl.h"
 
 using namespace js;
 
-/* static */ Shape* js::ErrorObject::assignInitialShape(
-    JSContext* cx, Handle<ErrorObject*> obj) {
+/* static */
+Shape* js::ErrorObject::assignInitialShape(JSContext* cx,
+                                           Handle<ErrorObject*> obj) {
   MOZ_ASSERT(obj->empty());
 
   if (!NativeObject::addDataProperty(cx, obj, cx->names().fileName,
                                      FILENAME_SLOT, 0)) {
     return nullptr;
   }
   if (!NativeObject::addDataProperty(cx, obj, cx->names().lineNumber,
                                      LINENUMBER_SLOT, 0)) {
     return nullptr;
   }
   return NativeObject::addDataProperty(cx, obj, cx->names().columnNumber,
                                        COLUMNNUMBER_SLOT, 0);
 }
 
-/* static */ bool js::ErrorObject::init(JSContext* cx, Handle<ErrorObject*> obj,
-                                        JSExnType type,
-                                        UniquePtr<JSErrorReport> errorReport,
-                                        HandleString fileName,
-                                        HandleObject stack, uint32_t sourceId,
-                                        uint32_t lineNumber,
-                                        uint32_t columnNumber,
-                                        HandleString message) {
+/* static */
+bool js::ErrorObject::init(JSContext* cx, Handle<ErrorObject*> obj,
+                           JSExnType type, UniquePtr<JSErrorReport> errorReport,
+                           HandleString fileName, HandleObject stack,
+                           uint32_t sourceId, uint32_t lineNumber,
+                           uint32_t columnNumber, HandleString message) {
   AssertObjectIsSavedFrameOrWrapper(cx, stack);
   cx->check(obj, stack);
 
   // Null out early in case of error, for exn_finalize's sake.
   obj->initReservedSlot(ERROR_REPORT_SLOT, PrivateValue(nullptr));
 
   if (!EmptyShape::ensureInitialCustomShape<ErrorObject>(cx, obj)) {
     return false;
@@ -109,22 +108,24 @@ using namespace js;
     MOZ_RELEASE_ASSERT(timeWarpTarget <
                        uint64_t(DOUBLE_INTEGRAL_PRECISION_LIMIT));
     obj->initReservedSlot(TIME_WARP_SLOT, DoubleValue(timeWarpTarget));
   }
 
   return true;
 }
 
-/* static */ ErrorObject* js::ErrorObject::create(
-    JSContext* cx, JSExnType errorType, HandleObject stack,
-    HandleString fileName, uint32_t sourceId,
-    uint32_t lineNumber, uint32_t columnNumber,
-    UniquePtr<JSErrorReport> report, HandleString message,
-    HandleObject protoArg /* = nullptr */) {
+/* static */
+ErrorObject* js::ErrorObject::create(JSContext* cx, JSExnType errorType,
+                                     HandleObject stack, HandleString fileName,
+                                     uint32_t sourceId, uint32_t lineNumber,
+                                     uint32_t columnNumber,
+                                     UniquePtr<JSErrorReport> report,
+                                     HandleString message,
+                                     HandleObject protoArg /* = nullptr */) {
   AssertObjectIsSavedFrameOrWrapper(cx, stack);
 
   RootedObject proto(cx, protoArg);
   if (!proto) {
     proto = GlobalObject::getOrCreateCustomErrorPrototype(cx, cx->global(),
                                                           errorType);
     if (!proto) {
       return nullptr;
@@ -239,25 +240,25 @@ static bool FindErrorInstanceOrPrototype
   }
 
   result.set(target);
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool IsObject(HandleValue v) { return v.isObject(); }
 
-/* static */ bool js::ErrorObject::getStack(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool js::ErrorObject::getStack(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   // We accept any object here, because of poor-man's subclassing of Error.
   return CallNonGenericMethod<IsObject, getStack_impl>(cx, args);
 }
 
-/* static */ bool js::ErrorObject::getStack_impl(JSContext* cx,
-                                                 const CallArgs& args) {
+/* static */
+bool js::ErrorObject::getStack_impl(JSContext* cx, const CallArgs& args) {
   RootedObject thisObj(cx, &args.thisv().toObject());
 
   RootedObject obj(cx);
   if (!FindErrorInstanceOrPrototype(cx, thisObj, &obj)) {
     return false;
   }
 
   if (!obj->is<ErrorObject>()) {
@@ -293,25 +294,25 @@ static MOZ_ALWAYS_INLINE bool IsObject(H
     RootedString stringified(cx, rval.toString());
     stackString = ConcatStrings<CanGC>(cx, stringified, stackString);
   }
 
   args.rval().setString(stackString);
   return true;
 }
 
-/* static */ bool js::ErrorObject::setStack(JSContext* cx, unsigned argc,
-                                            Value* vp) {
+/* static */
+bool js::ErrorObject::setStack(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
   // We accept any object here, because of poor-man's subclassing of Error.
   return CallNonGenericMethod<IsObject, setStack_impl>(cx, args);
 }
 
-/* static */ bool js::ErrorObject::setStack_impl(JSContext* cx,
-                                                 const CallArgs& args) {
+/* static */
+bool js::ErrorObject::setStack_impl(JSContext* cx, const CallArgs& args) {
   RootedObject thisObj(cx, &args.thisv().toObject());
 
   if (!args.requireAtLeast(cx, "(set stack)", 1)) {
     return false;
   }
   RootedValue val(cx, args[0]);
 
   return DefineDataProperty(cx, thisObj, cx->names().stack, val);
--- a/js/src/vm/GeckoProfiler.cpp
+++ b/js/src/vm/GeckoProfiler.cpp
@@ -427,18 +427,18 @@ JS_FRIEND_API jsbytecode* ProfilingStack
   if (pcOffsetIfJS_ == NullPCOffset) {
     return nullptr;
   }
 
   JSScript* script = this->script();
   return script ? script->offsetToPC(pcOffsetIfJS_) : nullptr;
 }
 
-/* static */ int32_t ProfilingStackFrame::pcToOffset(JSScript* aScript,
-                                                     jsbytecode* aPc) {
+/* static */
+int32_t ProfilingStackFrame::pcToOffset(JSScript* aScript, jsbytecode* aPc) {
   return aPc ? aScript->pcToOffset(aPc) : NullPCOffset;
 }
 
 void ProfilingStackFrame::setPC(jsbytecode* pc) {
   MOZ_ASSERT(isJsFrame());
   JSScript* script = this->script();
   MOZ_ASSERT(
       script);  // This should not be called while profiling is suppressed.
--- a/js/src/vm/GeneratorObject.cpp
+++ b/js/src/vm/GeneratorObject.cpp
@@ -234,18 +234,18 @@ JSObject* js::NewSingletonObjectWithFunc
     return nullptr;
   }
   if (!JSObject::setDelegate(cx, obj)) {
     return nullptr;
   }
   return obj;
 }
 
-/* static */ bool GlobalObject::initGenerators(JSContext* cx,
-                                               Handle<GlobalObject*> global) {
+/* static */
+bool GlobalObject::initGenerators(JSContext* cx, Handle<GlobalObject*> global) {
   if (global->getReservedSlot(GENERATOR_OBJECT_PROTO).isObject()) {
     return true;
   }
 
   RootedObject iteratorProto(
       cx, GlobalObject::getOrCreateIteratorPrototype(cx, global));
   if (!iteratorProto) {
     return false;
--- a/js/src/vm/GlobalObject.cpp
+++ b/js/src/vm/GlobalObject.cpp
@@ -83,18 +83,18 @@ JS_FRIEND_API const js::Class* js::Proto
 // sensitive.
 TypedObjectModuleObject& js::GlobalObject::getTypedObjectModule() const {
   Value v = getConstructor(JSProto_TypedObject);
   // only gets called from contexts where TypedObject must be initialized
   MOZ_ASSERT(v.isObject());
   return v.toObject().as<TypedObjectModuleObject>();
 }
 
-/* static */ bool GlobalObject::skipDeselectedConstructor(JSContext* cx,
-                                                          JSProtoKey key) {
+/* static */
+bool GlobalObject::skipDeselectedConstructor(JSContext* cx, JSProtoKey key) {
   switch (key) {
     case JSProto_WebAssembly:
       return !wasm::HasSupport(cx);
 
     case JSProto_ReadableStream:
     case JSProto_ReadableStreamDefaultReader:
     case JSProto_ReadableStreamDefaultController:
     case JSProto_ReadableByteStreamController:
@@ -109,20 +109,20 @@ TypedObjectModuleObject& js::GlobalObjec
     case JSProto_Atomics:
     case JSProto_SharedArrayBuffer:
       return !cx->realm()->creationOptions().getSharedMemoryAndAtomicsEnabled();
     default:
       return false;
   }
 }
 
-/* static*/ bool GlobalObject::resolveConstructor(JSContext* cx,
-                                                  Handle<GlobalObject*> global,
-                                                  JSProtoKey key,
-                                                  IfClassIsDisabled mode) {
+/* static*/
+bool GlobalObject::resolveConstructor(JSContext* cx,
+                                      Handle<GlobalObject*> global,
+                                      JSProtoKey key, IfClassIsDisabled mode) {
   MOZ_ASSERT(key != JSProto_Null);
   MOZ_ASSERT(!global->isStandardClassResolved(key));
   MOZ_ASSERT(cx->compartment() == global->compartment());
 
   // |global| must be same-compartment but make sure we're in its realm: the
   // code below relies on this.
   AutoRealm ar(cx, global);
 
@@ -311,36 +311,38 @@ TypedObjectModuleObject& js::GlobalObjec
 //
 // We could also do this in |FinishObjectClassInit| to trim the global
 // resolve hook.  Unfortunately, |ToWindowProxyIfWindow| doesn't work then:
 // the browser's |nsGlobalWindow::SetNewDocument| invokes Object init
 // *before* it sets the global's WindowProxy using |js::SetWindowProxy|.
 //
 // Refactoring global object creation code to support this approach is a
 // challenge for another day.
-/* static */ bool GlobalObject::maybeResolveGlobalThis(
-    JSContext* cx, Handle<GlobalObject*> global, bool* resolved) {
+/* static */
+bool GlobalObject::maybeResolveGlobalThis(JSContext* cx,
+                                          Handle<GlobalObject*> global,
+                                          bool* resolved) {
   if (global->getSlot(GLOBAL_THIS_RESOLVED).isUndefined()) {
     RootedValue v(cx, ObjectValue(*ToWindowProxyIfWindow(global)));
     if (!DefineDataProperty(cx, global, cx->names().globalThis, v,
                             JSPROP_RESOLVING)) {
       return false;
     }
 
     *resolved = true;
     global->setSlot(GLOBAL_THIS_RESOLVED, BooleanValue(true));
   }
 
   return true;
 }
 
-/* static */ JSObject* GlobalObject::createObject(JSContext* cx,
-                                                  Handle<GlobalObject*> global,
-                                                  unsigned slot,
-                                                  ObjectInitOp init) {
+/* static */
+JSObject* GlobalObject::createObject(JSContext* cx,
+                                     Handle<GlobalObject*> global,
+                                     unsigned slot, ObjectInitOp init) {
   if (global->zone()->createdForHelperThread()) {
     return createOffThreadObject(cx, global, slot);
   }