Bug 1508255 - Truncate '***' lines in js/src comments r=jandem
authorTed Campbell <tcampbell@mozilla.com>
Tue, 20 Nov 2018 10:07:16 +0000
changeset 503668 cf2b7ca307b68da20bfdd196e8dc1a4e99e62a2d
parent 503667 c86b9e22b393d97c6d4e4dc0fc33bc6cd3c2172c
child 503669 ba2da67c9e7e7541e4be66e5841c3a115c31ba1e
push id10290
push userffxbld-merge
push dateMon, 03 Dec 2018 16:23:23 +0000
treeherdermozilla-beta@700bed2445e6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjandem
bugs1508255
milestone65.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 1508255 - Truncate '***' lines in js/src comments r=jandem Depends on D12385 Differential Revision: https://phabricator.services.mozilla.com/D12386
js/src/builtin/MapObject.cpp
js/src/builtin/Reflect.cpp
js/src/builtin/Stream.cpp
js/src/gc/Marking.cpp
js/src/gc/Tracer.cpp
js/src/jsapi.cpp
js/src/jsapi.h
js/src/vm/Debugger.cpp
js/src/vm/Debugger.h
js/src/vm/EnvironmentObject.h
js/src/vm/Iteration.cpp
js/src/vm/JSObject.cpp
js/src/vm/JSObject.h
js/src/vm/NativeObject.cpp
js/src/vm/NativeObject.h
js/src/vm/ObjectOperations.h
js/src/vm/StringType.cpp
js/src/vm/StringType.h
js/src/vm/UbiNodeCensus.cpp
--- a/js/src/builtin/MapObject.cpp
+++ b/js/src/builtin/MapObject.cpp
@@ -24,17 +24,17 @@
 using namespace js;
 
 using mozilla::IsNaN;
 using mozilla::NumberEqualsInt32;
 
 using JS::DoubleNaNValue;
 
 
-/*** HashableValue *******************************************************************************/
+/*** HashableValue **********************************************************/
 
 bool
 HashableValue::setValue(JSContext* cx, HandleValue v)
 {
     if (v.isString()) {
         // Atomize so that hash() and operator==() are fast and infallible.
         JSString* str = AtomizeString(cx, v.toString(), DoNotPinAtom);
         if (!str) {
@@ -133,17 +133,17 @@ HashableValue
 HashableValue::trace(JSTracer* trc) const
 {
     HashableValue hv(*this);
     TraceEdge(trc, &hv.value, "key");
     return hv;
 }
 
 
-/*** MapIterator *********************************************************************************/
+/*** MapIterator ************************************************************/
 
 namespace {
 
 } /* anonymous namespace */
 
 static const ClassOps MapIteratorObjectClassOps = {
     nullptr, /* addProperty */
     nullptr, /* delProperty */
@@ -405,17 +405,17 @@ MapIteratorObject::createResultPair(JSCo
 
     // See comments in MapIteratorObject::next.
     AddTypePropertyId(cx, resultPairObj, JSID_VOID, TypeSet::UnknownType());
 
     return resultPairObj;
 }
 
 
-/*** Map *****************************************************************************************/
+/*** Map ********************************************************************/
 
 const ClassOps MapObject::classOps_ = {
     nullptr, // addProperty
     nullptr, // delProperty
     nullptr, // enumerate
     nullptr, // newEnumerate
     nullptr, // resolve
     nullptr, // mayResolve
@@ -1032,17 +1032,17 @@ MapObject::clear(JSContext* cx, HandleOb
     if (!map.clear()) {
         ReportOutOfMemory(cx);
         return false;
     }
     return true;
 }
 
 
-/*** SetIterator *********************************************************************************/
+/*** SetIterator ************************************************************/
 
 static const ClassOps SetIteratorObjectClassOps = {
     nullptr, /* addProperty */
     nullptr, /* delProperty */
     nullptr, /* enumerate */
     nullptr, /* newEnumerate */
     nullptr, /* resolve */
     nullptr, /* mayResolve */
@@ -1263,17 +1263,17 @@ SetIteratorObject::createResult(JSContex
 
     // See comments in SetIteratorObject::next.
     AddTypePropertyId(cx, resultObj, JSID_VOID, TypeSet::UnknownType());
 
     return resultObj;
 }
 
 
-/*** Set *****************************************************************************************/
+/*** Set ********************************************************************/
 
 const ClassOps SetObject::classOps_ = {
     nullptr, // addProperty
     nullptr, // delProperty
     nullptr, // enumerate
     nullptr, // newEnumerate
     nullptr, // resolve
     nullptr, // mayResolve
@@ -1744,17 +1744,17 @@ SetObject::clear_impl(JSContext *cx, con
 
 bool
 SetObject::clear(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     return CallNonGenericMethod(cx, is, clear_impl, args);
 }
 
-/*** JS static utility functions *********************************************/
+/*** JS static utility functions ********************************************/
 
 static bool
 forEach(const char* funcName, JSContext *cx, HandleObject obj, HandleValue callbackFn, HandleValue thisArg)
 {
     CHECK_THREAD(cx);
 
     RootedId forEachId(cx, NameToId(cx->names().forEach));
     RootedFunction forEachFunc(cx, JS::GetSelfHostedFunction(cx, funcName, forEachId, 2));
@@ -1835,17 +1835,17 @@ CallObjFunc(bool(*ObjFunc)(JSContext* cx
     if (obj != unwrappedObj) {
         if (!JS_WrapValue(cx, rval)) {
             return false;
         }
     }
     return true;
 }
 
-/*** JS public APIs **********************************************************/
+/*** JS public APIs *********************************************************/
 
 JS_PUBLIC_API JSObject*
 JS::NewMapObject(JSContext* cx)
 {
     return MapObject::create(cx);
 }
 
 JS_PUBLIC_API uint32_t
--- a/js/src/builtin/Reflect.cpp
+++ b/js/src/builtin/Reflect.cpp
@@ -13,17 +13,17 @@
 #include "vm/JSContext.h"
 #include "vm/Stack.h"
 
 #include "vm/Interpreter-inl.h"
 
 using namespace js;
 
 
-/*** Reflect methods *****************************************************************************/
+/*** Reflect methods ********************************************************/
 
 /* ES6 26.1.4 Reflect.deleteProperty (target, propertyKey) */
 static bool
 Reflect_deleteProperty(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     // Step 1.
@@ -212,17 +212,17 @@ static const JSFunctionSpec methods[] = 
     JS_FN("ownKeys", Reflect_ownKeys, 1, 0),
     JS_FN("preventExtensions", Reflect_preventExtensions, 1, 0),
     JS_FN("set", Reflect_set, 3, 0),
     JS_FN("setPrototypeOf", Reflect_setPrototypeOf, 2, 0),
     JS_FS_END
 };
 
 
-/*** Setup **************************************************************************************/
+/*** Setup ******************************************************************/
 
 JSObject*
 js::InitReflect(JSContext* cx, Handle<GlobalObject*> global)
 {
     RootedObject proto(cx, GlobalObject::getOrCreateObjectPrototype(cx, global));
     if (!proto) {
         return nullptr;
     }
--- a/js/src/builtin/Stream.cpp
+++ b/js/src/builtin/Stream.cpp
@@ -515,17 +515,17 @@ const Class cls::class_ = { \
 const Class cls::protoClass_ = { \
     "object", \
     JSCLASS_HAS_CACHED_PROTO(JSProto_##cls), \
     JS_NULL_CLASS_OPS, \
     &cls::classSpec_ \
 };
 
 
-/*** 3.2. Class ReadableStream *******************************************************************/
+/*** 3.2. Class ReadableStream **********************************************/
 
 /**
  * Streams spec, 3.2.3., steps 1-4.
  */
 ReadableStream*
 ReadableStream::createStream(JSContext* cx, HandleObject proto /* = nullptr */)
 {
     Rooted<ReadableStream*> stream(cx, NewObjectWithClassProto<ReadableStream>(cx, proto));
@@ -866,17 +866,17 @@ static const JSFunctionSpec ReadableStre
 static const JSPropertySpec ReadableStream_properties[] = {
     JS_PSG("locked", ReadableStream_locked, 0),
     JS_PS_END
 };
 
 CLASS_SPEC(ReadableStream, 0, SlotCount, 0, 0, JS_NULL_CLASS_OPS);
 
 
-/*** 3.3. General readable stream abstract operations ********************************************/
+/*** 3.3. General readable stream abstract operations ***********************/
 
 // Streams spec, 3.3.1. AcquireReadableStreamBYOBReader ( stream )
 // Always inlined.
 
 // Streams spec, 3.3.2. AcquireReadableStreamDefaultReader ( stream )
 // Always inlined. See CreateReadableStreamDefaultReader.
 
 // Streams spec, 3.3.3. CreateReadableStream ( startAlgorithm, pullAlgorithm, cancelAlgorithm [, highWaterMark [, sizeAlgorithm ] ] )
@@ -1302,17 +1302,17 @@ ReadableStreamTee(JSContext* cx,
         return false;
     }
 
     // Step 19: Return « branch1, branch2 ».
     return true;
 }
 
 
-/*** 3.4. The interface between readable streams and controllers *********************************/
+/*** 3.4. The interface between readable streams and controllers ************/
 
 inline static MOZ_MUST_USE bool
 AppendToListAtSlot(JSContext* cx,
                    HandleNativeObject unwrappedContainer,
                    uint32_t slot,
                    HandleObject obj);
 
 /**
@@ -1743,17 +1743,17 @@ ReadableStreamHasDefaultReader(JSContext
         return false;
     }
 
     *result = unwrappedReader->is<ReadableStreamDefaultReader>();
     return true;
 }
 
 
-/*** 3.5. Class ReadableStreamDefaultReader ******************************************************/
+/*** 3.5. Class ReadableStreamDefaultReader *********************************/
 
 static MOZ_MUST_USE bool
 ReadableStreamReaderGenericInitialize(JSContext* cx,
                                       Handle<ReadableStreamReader*> reader,
                                       Handle<ReadableStream*> unwrappedStream,
                                       ForAuthorCodeBool forAuthorCode);
 
 /**
@@ -1980,17 +1980,17 @@ static const JSPropertySpec ReadableStre
 const Class ReadableStreamReader::class_ = {
     "ReadableStreamReader"
 };
 
 CLASS_SPEC(ReadableStreamDefaultReader, 1, SlotCount, ClassSpec::DontDefineConstructor, 0,
            JS_NULL_CLASS_OPS);
 
 
-/*** 3.7. Readable stream reader abstract operations *********************************************/
+/*** 3.7. Readable stream reader abstract operations ************************/
 
 // Streams spec, 3.7.1. IsReadableStreamDefaultReader ( x )
 // Implemented via is<ReadableStreamDefaultReader>()
 
 // Streams spec, 3.7.2. IsReadableStreamBYOBReader ( x )
 // Implemented via is<ReadableStreamBYOBReader>()
 
 /**
@@ -2197,17 +2197,17 @@ ReadableStreamDefaultReaderRead(JSContex
     MOZ_ASSERT(unwrappedStream->readable());
 
     // Step 8: Return ! stream.[[readableStreamController]].[[PullSteps]]().
     Rooted<ReadableStreamController*> unwrappedController(cx, unwrappedStream->controller());
     return ReadableStreamControllerPullSteps(cx, unwrappedController);
 }
 
 
-/*** 3.8. Class ReadableStreamDefaultController **************************************************/
+/*** 3.8. Class ReadableStreamDefaultController *****************************/
 
 inline static MOZ_MUST_USE bool
 ReadableStreamControllerCallPullIfNeeded(JSContext* cx,
                                          Handle<ReadableStreamController*> unwrappedController);
 
 /**
  * Streams spec, 3.8.3, step 11.a.
  * and
@@ -2738,17 +2738,17 @@ ReadableStreamDefaultControllerPullSteps
         return nullptr;
     }
 
     // Step 5: Return pendingPromise.
     return pendingPromise;
 }
 
 
-/*** 3.9. Readable stream default controller abstract operations *********************************/
+/*** 3.9. Readable stream default controller abstract operations ************/
 
 // Streams spec, 3.9.1. IsReadableStreamDefaultController ( x )
 // Implemented via is<ReadableStreamDefaultController>()
 
 /**
  * Streams spec, 3.9.2 and 3.12.3. step 7:
  * Upon fulfillment of pullPromise,
  */
@@ -3129,17 +3129,17 @@ ReadableStreamControllerGetDesiredSizeUn
     MOZ_ASSERT(!(stream->errored() || stream->closed()));
 #endif // DEBUG
 
     // Step 5: Return controller.[[strategyHWM]] − controller.[[queueTotalSize]].
     return controller->strategyHWM() - controller->queueTotalSize();
 }
 
 
-/*** 3.10. Class ReadableByteStreamController ****************************************************/
+/*** 3.10. Class ReadableByteStreamController *******************************/
 
 #if 0 // disable user-defined byte streams
 
 /**
  * Streams spec, 3.10.3 new ReadableByteStreamController ( stream, underlyingSource,
  *                                                         highWaterMark )
  * Steps 3 - 16.
  *
@@ -3575,17 +3575,17 @@ ReadableStreamControllerPullSteps(JSCont
     }
 
     Rooted<ReadableByteStreamController*> unwrappedByteController(cx,
         &unwrappedController->as<ReadableByteStreamController>());
     return ReadableByteStreamControllerPullSteps(cx, unwrappedByteController);
 }
 
 
-/*** 3.12. Readable stream BYOB controller abstract operations ***********************************/
+/*** 3.12. Readable stream BYOB controller abstract operations **************/
 
 // Streams spec, 3.12.1. IsReadableStreamBYOBRequest ( x )
 // Implemented via is<ReadableStreamBYOBRequest>()
 
 // Streams spec, 3.12.2. IsReadableByteStreamController ( x )
 // Implemented via is<ReadableByteStreamController>()
 
 // Streams spec, 3.12.3. ReadableByteStreamControllerCallPullIfNeeded ( controller )
@@ -3742,17 +3742,17 @@ ReadableByteStreamControllerInvalidateBY
 
     return true;
 }
 
 // Streams spec, 3.12.25. ReadableByteStreamControllerShouldCallPull ( controller )
 // Unified with 3.9.3 above.
 
 
-/*** 6.1. Queuing strategies *********************************************************************/
+/*** 6.1. Queuing strategies ************************************************/
 
 // Streams spec, 6.1.2.2. new ByteLengthQueuingStrategy({ highWaterMark })
 bool
 js::ByteLengthQueuingStrategy::constructor(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     RootedObject strategy(cx, NewBuiltinClassInstance<ByteLengthQueuingStrategy>(cx));
@@ -3848,17 +3848,17 @@ static const JSFunctionSpec CountQueuing
     JS_FS_END
 };
 
 CLASS_SPEC(CountQueuingStrategy, 1, 0, 0, 0, JS_NULL_CLASS_OPS);
 
 #undef CLASS_SPEC
 
 
-/*** 6.2. Queue-with-sizes operations ************************************************************/
+/*** 6.2. Queue-with-sizes operations ***************************************/
 
 /**
  * Streams spec, 6.2.1. DequeueValue ( container ) nothrow
  */
 inline static MOZ_MUST_USE bool
 DequeueValue(JSContext* cx, Handle<ReadableStreamController*> unwrappedContainer, MutableHandleValue chunk)
 {
     // Step 1: Assert: container has [[queue]] and [[queueTotalSize]] internal
@@ -3968,17 +3968,17 @@ ResetQueue(JSContext* cx, Handle<Readabl
 
     // Step 3: Set container.[[queueTotalSize]] to 0.
     unwrappedContainer->setQueueTotalSize(0);
 
     return true;
 }
 
 
-/*** 6.3. Miscellaneous operations ***************************************************************/
+/*** 6.3. Miscellaneous operations ******************************************/
 
 /**
  * Appends the given |obj| to the given list |container|'s list.
  */
 inline static MOZ_MUST_USE bool
 AppendToListAtSlot(JSContext* cx,
                    HandleNativeObject unwrappedContainer,
                    uint32_t slot,
@@ -4087,17 +4087,17 @@ ValidateAndNormalizeQueuingStrategy(JSCo
         return false;
     }
 
     // Step 3: Return Record {[[size]]: size, [[highWaterMark]]: highWaterMark}.
     return true;
 }
 
 
-/*** API entry points ****************************************************************************/
+/*** API entry points *******************************************************/
 
 JS_FRIEND_API JSObject*
 js::UnwrapReadableStream(JSObject* obj)
 {
     if (JSObject* unwrapped = CheckedUnwrap(obj)) {
         return unwrapped->is<ReadableStream>() ? unwrapped : nullptr;
     }
     return nullptr;
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -118,17 +118,17 @@ using mozilla::PodCopy;
 //   Legend:                                                                                    //
 //     ------  Direct calls                                                                     //
 //     . . .   Static dispatch                                                                  //
 //     ======  Dispatch through a manual stack.                                                 //
 //                                                                                              //
 /* clang-format on */
 
 
-/*** Tracing Invariants **************************************************************************/
+/*** Tracing Invariants *****************************************************/
 
 #if defined(DEBUG)
 template<typename T>
 static inline bool
 IsThingPoisoned(T* thing)
 {
     const uint8_t poisonBytes[] = {
         JS_FRESH_NURSERY_PATTERN,
@@ -393,17 +393,17 @@ js::gc::AssertRootMarkingPhase(JSTracer*
 {
     MOZ_ASSERT_IF(trc->isMarkingTracer(),
                   trc->runtime()->gc.state() == State::NotActive ||
                   trc->runtime()->gc.state() == State::MarkRoots);
 }
 #endif
 
 
-/*** Tracing Interface ***************************************************************************/
+/*** Tracing Interface ******************************************************/
 
 template <typename T> T DoCallback(JS::CallbackTracer* trc, T* thingp, const char* name);
 template <typename T> void DoMarking(GCMarker* gcmarker, T* thing);
 template <typename T> void DoMarking(GCMarker* gcmarker, const T& thing);
 template <typename T> void NoteWeakEdge(GCMarker* gcmarker, T** thingp);
 template <typename T> void NoteWeakEdge(GCMarker* gcmarker, T* thingp);
 
 template <typename T>
@@ -594,17 +594,17 @@ js::gc::TraceRangeInternal(JSTracer* trc
         if (InternalBarrierMethods<T>::isMarkable(vec[i])) {
             TraceEdgeInternal(trc, &vec[i], name);
         }
         ++index;
     }
 }
 
 
-/*** GC Marking Interface *************************************************************************/
+/*** GC Marking Interface ***************************************************/
 
 namespace js {
 
 typedef bool HasNoImplicitEdgesType;
 
 template <typename T>
 struct ImplicitEdgeHolderType {
     typedef HasNoImplicitEdgesType Type;
@@ -957,17 +957,17 @@ js::GCMarker::mark(T* thing)
     if (!TypeParticipatesInCC<T>::value) {
         return cell->markIfUnmarked(MarkColor::Black);
     }
 
     return cell->markIfUnmarked(markColor());
 }
 
 
-/*** Inline, Eager GC Marking *********************************************************************/
+/*** Inline, Eager GC Marking ***********************************************/
 
 // Each of the eager, inline marking paths is directly preceeded by the
 // out-of-line, generic tracing code for comparison. Both paths must end up
 // traversing equivalent subgraphs.
 
 void
 LazyScript::traceChildren(JSTracer* trc)
 {
@@ -1617,17 +1617,17 @@ VisitTraceList(F f, const int32_t* trace
     traceList++;
     while (*traceList != -1) {
         f(reinterpret_cast<Value*>(memory + *traceList), std::forward<Args>(args)...);
         traceList++;
     }
 }
 
 
-/*** Mark-stack Marking ***************************************************************************/
+/*** Mark-stack Marking *****************************************************/
 
 bool
 GCMarker::markUntilBudgetExhaused(SliceBudget& budget)
 {
 #ifdef DEBUG
     MOZ_ASSERT(!strictCompartmentChecking);
     strictCompartmentChecking = true;
     auto acc = mozilla::MakeScopeExit([&] {strictCompartmentChecking = false;});
@@ -2009,17 +2009,17 @@ GCMarker::restoreValueArray(const MarkSt
             start = end = vp;
         }
     }
 
     return MarkStack::ValueArray(obj, start, end);
 }
 
 
-/*** Mark Stack ***********************************************************************************/
+/*** Mark Stack *************************************************************/
 
 static_assert(sizeof(MarkStack::TaggedPtr) == sizeof(uintptr_t),
               "A TaggedPtr should be the same size as a pointer");
 static_assert(sizeof(MarkStack::ValueArray) == sizeof(MarkStack::SavedValueArray),
               "ValueArray and SavedValueArray should be the same size");
 static_assert((sizeof(MarkStack::ValueArray) % sizeof(uintptr_t)) == 0,
               "ValueArray and SavedValueArray should be multiples of the pointer size");
 
@@ -2461,17 +2461,17 @@ MarkStackIter::saveValueArray(const Mark
 
     MarkStack::TaggedPtr* ptr = &stack_.stack()[pos_ - ValueArrayWords];
     auto dest = reinterpret_cast<MarkStack::SavedValueArray*>(ptr);
     *dest = savedArray;
     MOZ_ASSERT(peekTag() == MarkStack::SavedValueArrayTag);
 }
 
 
-/*** GCMarker *************************************************************************************/
+/*** GCMarker ***************************************************************/
 
 /*
  * ExpandWeakMaps: the GC is recomputing the liveness of WeakMap entries by
  * expanding each live WeakMap into its constituent key->value edges, a table
  * of which will be consulted in a later phase whenever marking a potential
  * key.
  */
 GCMarker::GCMarker(JSRuntime* rt)
@@ -2724,17 +2724,17 @@ GCMarker::sizeOfExcludingThis(mozilla::M
     size_t size = stack.sizeOfExcludingThis(mallocSizeOf);
     for (ZonesIter zone(runtime(), WithAtoms); !zone.done(); zone.next()) {
         size += zone->gcGrayRoots().sizeOfExcludingThis(mallocSizeOf);
     }
     return size;
 }
 
 
-/*** Tenuring Tracer *****************************************************************************/
+/*** Tenuring Tracer ********************************************************/
 
 namespace js {
 template <typename T>
 void
 TenuringTracer::traverse(T** tp)
 {
 }
 
@@ -3319,17 +3319,17 @@ js::TenuringTracer::moveStringToTenured(
             nursery().removeMallocedBuffer(chars);
         }
     }
 
     return size;
 }
 
 
-/*** IsMarked / IsAboutToBeFinalized **************************************************************/
+/*** IsMarked / IsAboutToBeFinalized ****************************************/
 
 template <typename T>
 static inline void
 CheckIsMarkedThing(T* thingp)
 {
 #define IS_SAME_TYPE_OR(name, type, _) mozilla::IsSame<type*, T>::value ||
     static_assert(
             JS_FOR_EACH_TRACEKIND(IS_SAME_TYPE_OR)
@@ -3499,17 +3499,17 @@ FOR_EACH_PUBLIC_TAGGED_GC_POINTER_TYPE(I
 
 #undef INSTANTIATE_INTERNAL_MARKING_FUNCTIONS_FROM_TRACEKIND
 #undef INSTANTIATE_INTERNAL_MARKING_FUNCTIONS
 
 } /* namespace gc */
 } /* namespace js */
 
 
-/*** Cycle Collector Barrier Implementation *******************************************************/
+/*** Cycle Collector Barrier Implementation *********************************/
 
 /*
  * The GC and CC are run independently. Consequently, the following sequence of
  * events can occur:
  * 1. GC runs and marks an object gray.
  * 2. The mutator runs (specifically, some C++ code with access to gray
  *    objects) and creates a pointer from a JS root or other black object to
  *    the gray object. If we re-ran a GC at this point, the object would now be
--- a/js/src/gc/Tracer.cpp
+++ b/js/src/gc/Tracer.cpp
@@ -35,17 +35,17 @@ using mozilla::DebugOnly;
 
 namespace js {
 template<typename T>
 void
 CheckTracedThing(JSTracer* trc, T thing);
 } // namespace js
 
 
-/*** Callback Tracer Dispatch ********************************************************************/
+/*** Callback Tracer Dispatch ***********************************************/
 
 template <typename T>
 T
 DoCallback(JS::CallbackTracer* trc, T* thingp, const char* name)
 {
     CheckTracedThing(trc, *thingp);
     JS::AutoTracingName ctx(trc, name);
     trc->dispatchToOnEdge(thingp);
@@ -110,17 +110,17 @@ JS::CallbackTracer::getTracingEdgeName(c
     if (contextIndex_ != InvalidIndex) {
         snprintf(buffer, bufferSize, "%s[%zu]", contextName_, contextIndex_);
         return;
     }
     snprintf(buffer, bufferSize, "%s", contextName_);
 }
 
 
-/*** Public Tracing API **************************************************************************/
+/*** Public Tracing API *****************************************************/
 
 JS_PUBLIC_API void
 JS::TraceChildren(JSTracer* trc, GCCellPtr thing)
 {
     js::TraceChildren(trc, thing.asCell(), thing.kind());
 }
 
 struct TraceChildrenFunctor {
@@ -176,17 +176,17 @@ JS::TraceIncomingCCWs(JSTracer* trc, con
             mozilla::DebugOnly<const CrossCompartmentKey> prior = e.front().key();
             e.front().mutableKey().applyToWrapped(TraceIncomingFunctor(trc, compartments));
             MOZ_ASSERT(e.front().key() == prior);
         }
     }
 }
 
 
-/*** Cycle Collector Helpers **********************************************************************/
+/*** Cycle Collector Helpers ************************************************/
 
 // This function is used by the Cycle Collector (CC) to trace through -- or in
 // CC parlance, traverse -- a Shape tree. The CC does not care about Shapes or
 // BaseShapes, only the JSObjects held live by them. Thus, we walk the Shape
 // lineage, but only report non-Shape things. This effectively makes the entire
 // shape lineage into a single node in the CC, saving tremendous amounts of
 // space and time in its algorithms.
 //
@@ -293,17 +293,17 @@ gc::TraceCycleCollectorChildren(JS::Call
 
     while (!groupTracer.worklist.empty()) {
         ObjectGroup* innerGroup = groupTracer.worklist.popCopy();
         innerGroup->traceChildren(&groupTracer);
     }
 }
 
 
-/*** Traced Edge Printer *************************************************************************/
+/*** Traced Edge Printer ****************************************************/
 
 static size_t
 CountDecimalDigits(size_t num)
 {
     size_t numDigits = 0;
     do {
         num /= 10;
         numDigits++;
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -2019,17 +2019,17 @@ JS_IsNative(JSObject* obj)
 JS_PUBLIC_API void
 JS::AssertObjectBelongsToCurrentThread(JSObject* obj)
 {
     JSRuntime* rt = obj->compartment()->runtimeFromAnyThread();
     MOZ_RELEASE_ASSERT(CurrentThreadCanAccessRuntime(rt));
 }
 
 
-/*** Standard internal methods *******************************************************************/
+/*** Standard internal methods **********************************************/
 
 JS_PUBLIC_API bool
 JS_GetPrototype(JSContext* cx, HandleObject obj, MutableHandleObject result)
 {
     cx->check(obj);
     return GetPrototype(cx, obj, result);
 }
 
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -1883,17 +1883,17 @@ JS_DeepFreezeObject(JSContext* cx, JS::H
 
 /**
  * Freezes an object; see ES5's Object.freeze(obj) method.
  */
 extern JS_PUBLIC_API bool
 JS_FreezeObject(JSContext* cx, JS::Handle<JSObject*> obj);
 
 
-/*** Property descriptors ************************************************************************/
+/*** Property descriptors ***************************************************/
 
 namespace JS {
 
 struct JS_PUBLIC_API PropertyDescriptor {
     JSObject* obj;
     unsigned attrs;
     JSGetterOp getter;
     JSSetterOp setter;
@@ -2155,17 +2155,17 @@ ObjectToCompletePropertyDescriptor(JSCon
 extern JS_PUBLIC_API bool
 FromPropertyDescriptor(JSContext* cx,
                        JS::Handle<JS::PropertyDescriptor> desc,
                        JS::MutableHandleValue vp);
 
 } // namespace JS
 
 
-/*** Standard internal methods ********************************************************************
+/*** Standard internal methods **********************************************
  *
  * The functions below are the fundamental operations on objects.
  *
  * ES6 specifies 14 internal methods that define how objects behave.  The
  * standard is actually quite good on this topic, though you may have to read
  * it a few times. See ES6 sections 6.1.7.2 and 6.1.7.3.
  *
  * When 'obj' is an ordinary object, these functions have boring standard
@@ -2736,17 +2736,17 @@ Construct(JSContext* cx, JS::HandleValue
 /**
  * Invoke a constructor, like the JS expression `new ctor(...args)`. Returns
  * the new object, or null on error.
  */
 extern JS_PUBLIC_API JSObject*
 JS_New(JSContext* cx, JS::HandleObject ctor, const JS::HandleValueArray& args);
 
 
-/*** Other property-defining functions ***********************************************************/
+/*** Other property-defining functions **************************************/
 
 extern JS_PUBLIC_API JSObject*
 JS_DefineObject(JSContext* cx, JS::HandleObject obj, const char* name,
                 const JSClass* clasp = nullptr, unsigned attrs = 0);
 
 extern JS_PUBLIC_API bool
 JS_DefineConstDoubles(JSContext* cx, JS::HandleObject obj, const JSConstDoubleSpec* cds);
 
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -70,17 +70,17 @@ using mozilla::MakeScopeExit;
 using mozilla::Maybe;
 using mozilla::Some;
 using mozilla::Nothing;
 using mozilla::AsVariant;
 using mozilla::TimeDuration;
 using mozilla::TimeStamp;
 
 
-/*** Forward declarations, ClassOps and Classes **************************************************/
+/*** Forward declarations, ClassOps and Classes *****************************/
 
 static void DebuggerFrame_finalize(FreeOp* fop, JSObject* obj);
 static void DebuggerFrame_trace(JSTracer* trc, JSObject* obj);
 static void DebuggerEnv_trace(JSTracer* trc, JSObject* obj);
 static void DebuggerObject_trace(JSTracer* trc, JSObject* obj);
 static void DebuggerScript_trace(JSTracer* trc, JSObject* obj);
 static void DebuggerSource_trace(JSTracer* trc, JSObject* obj);
 
@@ -227,17 +227,17 @@ static const ClassOps DebuggerSource_cla
 static const Class DebuggerSource_class = {
     "Source",
     JSCLASS_HAS_PRIVATE |
     JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGSOURCE_COUNT),
     &DebuggerSource_classOps
 };
 
 
-/*** Utils ***************************************************************************************/
+/*** Utils ******************************************************************/
 
 /*
  * If fun is an interpreted function, remove any async function/generator
  * wrapper and return the underlying scripted function. Otherwise, return fun
  * unchanged.
  *
  * Async functions are implemented as native functions wrapped around a scripted
  * function. JSScripts hold ordinary inner JSFunctions in their object arrays,
@@ -559,17 +559,17 @@ RequireGlobalObject(JSContext* cx, Handl
         }
         return false;
     }
 
     return true;
 }
 
 
-/*** Breakpoints *********************************************************************************/
+/*** Breakpoints ************************************************************/
 
 BreakpointSite::BreakpointSite(Type type)
   : type_(type), enabledCount(0)
 {
 }
 
 void
 BreakpointSite::inc(FreeOp* fop)
@@ -690,17 +690,17 @@ WasmBreakpointSite::recompile(FreeOp* fo
 void
 WasmBreakpointSite::destroyIfEmpty(FreeOp* fop)
 {
     if (isEmpty()) {
         debug->destroyBreakpointSite(fop, offset);
     }
 }
 
-/*** Debugger hook dispatch **********************************************************************/
+/*** Debugger hook dispatch *************************************************/
 
 Debugger::Debugger(JSContext* cx, NativeObject* dbg)
   : object(dbg),
     debuggees(cx->zone()),
     uncaughtExceptionHook(nullptr),
     enabled(true),
     allowUnobservedAsmJS(false),
     collectCoverageInfo(false),
@@ -1592,17 +1592,17 @@ Debugger::unwrapPropertyDescriptor(JSCon
         }
         desc.setSetterObject(set);
     }
 
     return true;
 }
 
 
-/*** Debuggee resumption values and debugger error handling **************************************/
+/*** Debuggee resumption values and debugger error handling *****************/
 
 static bool
 GetResumptionProperty(JSContext* cx, HandleObject obj, HandlePropertyName name, ResumeMode namedMode,
                       ResumeMode& resumeMode, MutableHandleValue vp, int* hits)
 {
     bool found;
     if (!HasProperty(cx, obj, name, &found)) {
         return false;
@@ -1897,17 +1897,17 @@ Debugger::processHandlerResult(Maybe<Aut
     ResumeMode resumeMode = ResumeMode::Continue;
     if (!ParseResumptionValue(cx, rootRv, resumeMode, vp)) {
         return handleUncaughtException(ar, vp, maybeThisv, frame);
     }
     return leaveDebugger(ar, frame, maybeThisv, CallUncaughtExceptionHook::Yes, resumeMode, vp);
 }
 
 
-/*** Debuggee completion values ******************************************************************/
+/*** Debuggee completion values *********************************************/
 
 /* static */ void
 Debugger::resultToCompletion(JSContext* cx, bool ok, const Value& rv,
                              ResumeMode* resumeMode, MutableHandleValue value)
 {
     MOZ_ASSERT_IF(ok, !cx->isExceptionPending());
 
     if (ok) {
@@ -1977,17 +1977,17 @@ Debugger::receiveCompletionValue(Maybe<A
     RootedValue value(cx);
     resultToCompletion(cx, ok, val, &resumeMode, &value);
     ar.reset();
     return wrapDebuggeeValue(cx, &value) &&
            newCompletionValue(cx, resumeMode, value, vp);
 }
 
 
-/*** Firing debugger hooks ***********************************************************************/
+/*** Firing debugger hooks **************************************************/
 
 static bool
 CallMethodIfPresent(JSContext* cx, HandleObject obj, const char* name, size_t argc, Value* argv,
                     MutableHandleValue rval)
 {
     rval.setUndefined();
     JSAtom* atom = Atomize(cx, name, strlen(name));
     if (!atom) {
@@ -2658,17 +2658,17 @@ Debugger::slowPathPromiseHook(JSContext*
     }
 
     // Promise hooks are infallible and we ignore errors from uncaught
     // exceptions by design.
     MOZ_ASSERT(resumeMode == ResumeMode::Continue);
 }
 
 
-/*** Debugger code invalidation for observing execution ******************************************/
+/*** Debugger code invalidation for observing execution *********************/
 
 class MOZ_RAII ExecutionObservableRealms : public Debugger::ExecutionObservableSet
 {
     HashSet<Realm*> realms_;
     HashSet<Zone*> zones_;
 
   public:
     explicit ExecutionObservableRealms(JSContext* cx
@@ -3194,17 +3194,17 @@ Debugger::updateObservesAsmJSOnDebuggees
             continue;
         }
 
         realm->updateDebuggerObservesAsmJS();
     }
 }
 
 
-/*** Allocations Tracking *************************************************************************/
+/*** Allocations Tracking ***************************************************/
 
 /* static */ bool
 Debugger::cannotTrackAllocations(const GlobalObject& global)
 {
     auto existingCallback = global.realm()->getAllocationMetadataBuilder();
     return existingCallback && existingCallback != &SavedStacks::metadataBuilder;
 }
 
@@ -3290,17 +3290,17 @@ Debugger::removeAllocationsTrackingForAl
         Debugger::removeAllocationsTracking(*r.front().get());
     }
 
     allocationsLog.clear();
 }
 
 
 
-/*** Debugger JSObjects **************************************************************************/
+/*** Debugger JSObjects *****************************************************/
 
 void
 Debugger::traceCrossCompartmentEdges(JSTracer* trc)
 {
     generatorFrames.traceCrossCompartmentEdges<DebuggerFrame_trace>(trc);
     objects.traceCrossCompartmentEdges<DebuggerObject_trace>(trc);
     environments.traceCrossCompartmentEdges<DebuggerEnv_trace>(trc);
     scripts.traceCrossCompartmentEdges<DebuggerScript_trace>(trc);
@@ -5788,17 +5788,17 @@ const JSFunctionSpec Debugger::methods[]
 };
 
 const JSFunctionSpec Debugger::static_methods[] {
     JS_FN("isCompilableUnit", Debugger::isCompilableUnit, 1, 0),
     JS_FN("recordReplayProcessKind", Debugger::recordReplayProcessKind, 0, 0),
     JS_FS_END
 };
 
-/*** Debugger.Script *****************************************************************************/
+/*** Debugger.Script ********************************************************/
 
 // Get the Debugger.Script referent as bare Cell. This should only be used for
 // GC operations like tracing. Please use GetScriptReferent below.
 static inline gc::Cell*
 GetScriptReferentCell(JSObject* obj)
 {
     MOZ_ASSERT(obj->getClass() == &DebuggerScript_class);
     return static_cast<gc::Cell*>(obj->as<NativeObject>().getPrivate());
@@ -7772,17 +7772,17 @@ static const JSFunctionSpec DebuggerScri
     JS_FN("clearBreakpoint", DebuggerScript_clearBreakpoint, 1, 0),
     JS_FN("clearAllBreakpoints", DebuggerScript_clearAllBreakpoints, 0, 0),
     JS_FN("isInCatchScope", DebuggerScript_isInCatchScope, 1, 0),
     JS_FN("getOffsetsCoverage", DebuggerScript_getOffsetsCoverage, 0, 0),
     JS_FS_END
 };
 
 
-/*** Debugger.Source *****************************************************************************/
+/*** Debugger.Source ********************************************************/
 
 // For internal use only.
 static inline NativeObject*
 GetSourceReferentRawObject(JSObject* obj)
 {
     MOZ_ASSERT(obj->getClass() == &DebuggerSource_class);
     return static_cast<NativeObject*>(obj->as<NativeObject>().getPrivate());
 }
@@ -8365,17 +8365,17 @@ static const JSPropertySpec DebuggerSour
     JS_PS_END
 };
 
 static const JSFunctionSpec DebuggerSource_methods[] = {
     JS_FS_END
 };
 
 
-/*** Debugger.Frame ******************************************************************************/
+/*** Debugger.Frame *********************************************************/
 
 ScriptedOnStepHandler::ScriptedOnStepHandler(JSObject* object)
   : object_(object)
 {
     MOZ_ASSERT(object_->isCallable());
 }
 
 JSObject*
@@ -9683,17 +9683,17 @@ const JSPropertySpec DebuggerFrame::prop
 
 const JSFunctionSpec DebuggerFrame::methods_[] = {
     JS_FN("eval", DebuggerFrame::evalMethod, 1, 0),
     JS_FN("evalWithBindings", DebuggerFrame::evalWithBindingsMethod, 1, 0),
     JS_FS_END
 };
 
 
-/*** Debugger.Object *****************************************************************************/
+/*** Debugger.Object ********************************************************/
 
 void
 DebuggerObject_trace(JSTracer* trc, JSObject* obj)
 {
     // There is a barrier on private pointers, so the Unbarriered marking
     // is okay.
     if (JSObject* referent = (JSObject*) obj->as<NativeObject>().getPrivate()) {
         TraceManuallyBarrieredCrossCompartmentEdge(trc, obj, &referent,
@@ -11977,17 +11977,17 @@ DebuggerObject::getScriptedProxyHandler(
     if(!unwrapped) {
         result.set(nullptr);
         return true;
     }
     return dbg->wrapDebuggeeObject(cx, unwrapped, result);
 }
 
 
-/*** Debugger.Environment ************************************************************************/
+/*** Debugger.Environment ***************************************************/
 
 void
 DebuggerEnv_trace(JSTracer* trc, JSObject* obj)
 {
     // There is a barrier on private pointers, so the Unbarriered marking
     // is okay.
     if (Env* referent = (JSObject*) obj->as<NativeObject>().getPrivate()) {
         TraceManuallyBarrieredCrossCompartmentEdge(trc, obj, &referent,
@@ -12573,17 +12573,17 @@ DebuggerEnvironment::setVariable(JSConte
             return false;
         }
     }
 
     return true;
 }
 
 
-/*** JS::dbg::Builder ****************************************************************************/
+/*** JS::dbg::Builder *******************************************************/
 
 Builder::Builder(JSContext* cx, js::Debugger* debugger)
   : debuggerObject(cx, debugger->toJSObject().get()),
     debugger(debugger)
 { }
 
 
 #if DEBUG
@@ -12650,32 +12650,32 @@ Builder::newObject(JSContext* cx)
 
     RootedPlainObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx));
 
     // If the allocation failed, this will return a false Object, as the spec promises.
     return Object(cx, *this, obj);
 }
 
 
-/*** JS::dbg::AutoEntryMonitor ******************************************************************/
+/*** JS::dbg::AutoEntryMonitor **********************************************/
 
 AutoEntryMonitor::AutoEntryMonitor(JSContext* cx)
   : cx_(cx),
     savedMonitor_(cx->entryMonitor)
 {
     cx->entryMonitor = this;
 }
 
 AutoEntryMonitor::~AutoEntryMonitor()
 {
     cx_->entryMonitor = savedMonitor_;
 }
 
 
-/*** Glue ****************************************************************************************/
+/*** Glue *******************************************************************/
 
 extern JS_PUBLIC_API bool
 JS_DefineDebuggerObject(JSContext* cx, HandleObject obj)
 {
     RootedNativeObject
         objProto(cx),
         debugCtor(cx),
         debugProto(cx),
@@ -12831,17 +12831,17 @@ js::CheckDebuggeeThing(JSObject* obj, bo
 {
     if (Realm* realm = JS::GetObjectRealmOrNull(obj)) {
         CheckDebuggeeThingRealm(realm, invisibleOk);
     }
 }
 #endif // DEBUG
 
 
-/*** JS::dbg::GarbageCollectionEvent **************************************************************/
+/*** JS::dbg::GarbageCollectionEvent ****************************************/
 
 namespace JS {
 namespace dbg {
 
 /* static */ GarbageCollectionEvent::Ptr
 GarbageCollectionEvent::Create(JSRuntime* rt, ::js::gcstats::Statistics& stats, uint64_t gcNumber)
 {
     auto data = MakeUnique<GarbageCollectionEvent>(gcNumber);
--- a/js/src/vm/Debugger.h
+++ b/js/src/vm/Debugger.h
@@ -935,17 +935,17 @@ class Debugger : private mozilla::Linked
 
     Zone* zone() const { return toJSObject()->zone(); }
 
     bool hasMemory() const;
     DebuggerMemory& memory() const;
 
     WeakGlobalObjectSet::Range allDebuggees() const { return debuggees.all(); }
 
-    /*********************************** Methods for interaction with the GC. */
+    /*** Methods for interaction with the GC. *******************************/
 
     /*
      * A Debugger object is live if:
      *   * the Debugger JSObject is live (Debugger::trace handles this case); OR
      *   * it is in the middle of dispatching an event (the event dispatching
      *     code roots it in this case); OR
      *   * it is enabled, and it is debugging at least one live compartment,
      *     and at least one of the following is true:
@@ -1061,17 +1061,17 @@ class Debugger : private mozilla::Linked
     // this is *not* equivalent to the promise resolution (ie, the promise's fate
     // getting locked in) because you can resolve a promise with another pending
     // promise, in which case neither promise has settled yet.
     //
     // This should never be called on the same promise more than once, because a
     // promise can only make the transition from unsettled to settled once.
     static inline void onPromiseSettled(JSContext* cx, Handle<PromiseObject*> promise);
 
-    /************************************* Functions for use by Debugger.cpp. */
+    /*** Functions for use by Debugger.cpp. *********************************/
 
     inline bool observesEnterFrame() const;
     inline bool observesNewScript() const;
     inline bool observesNewGlobalObject() const;
     inline bool observesGlobal(GlobalObject* global) const;
     bool observesFrame(AbstractFramePtr frame) const;
     bool observesFrame(const FrameIter& iter) const;
     bool observesScript(JSScript* script) const;
--- a/js/src/vm/EnvironmentObject.h
+++ b/js/src/vm/EnvironmentObject.h
@@ -35,20 +35,20 @@ EnvironmentCoordinateToEnvironmentShape(
 extern PropertyName*
 EnvironmentCoordinateName(EnvironmentCoordinateNameCache& cache, JSScript* script, jsbytecode* pc);
 
 // Return the function script accessed by the given ALIASEDVAR op, or nullptr.
 extern JSScript*
 EnvironmentCoordinateFunctionScript(JSScript* script, jsbytecode* pc);
 
 
-/*** Environment objects *****************************************************/
+/*** Environment objects ****************************************************/
 
 
-/*** Environment objects *****************************************************/
+/*** Environment objects ****************************************************/
 
 // clang-format off
 /*
  * [SMDOC] Environment Objects
  *
  * About environments
  * ------------------
  *
@@ -691,17 +691,17 @@ class RuntimeLexicalErrorObject : public
                                              unsigned errorNumber);
 
     unsigned errorNumber() {
         return getReservedSlot(ERROR_SLOT).toInt32();
     }
 };
 
 
-/*****************************************************************************/
+/****************************************************************************/
 
 // A environment iterator describes the active environments starting from an
 // environment, scope pair. This pair may be derived from the current point of
 // execution in a frame. If derived in such a fashion, the EnvironmentIter
 // tracks whether the current scope is within the extent of this initial
 // frame.  Here, "frame" means a single activation of: a function, eval, or
 // global code.
 class MOZ_RAII EnvironmentIter
@@ -877,17 +877,17 @@ class LiveEnvironmentVal
     Scope* scope() const { return scope_; }
 
     void updateFrame(AbstractFramePtr frame) { frame_ = frame; }
 
     bool needsSweep();
 };
 
 
-/*****************************************************************************/
+/****************************************************************************/
 
 /*
  * Debug environment objects
  *
  * The debugger effectively turns every opcode into a potential direct eval.
  * Naively, this would require creating a EnvironmentObject for every
  * call/block scope and using JSOP_GETALIASEDVAR for every access. To optimize
  * this, the engine assumes there is no debugger and optimizes scope access
--- a/js/src/vm/Iteration.cpp
+++ b/js/src/vm/Iteration.cpp
@@ -1110,17 +1110,17 @@ Realm::createIterResultTemplateObject(JS
     MOZ_ASSERT(shape->previous()->slot() == Realm::IterResultObjectValueSlot &&
                shape->previous()->propidRef() == NameToId(cx->names().value));
     MOZ_ASSERT(shape->slot() == Realm::IterResultObjectDoneSlot &&
                shape->propidRef() == NameToId(cx->names().done));
 
     return templateObject;
 }
 
-/*** Iterator objects ****************************************************************************/
+/*** Iterator objects *******************************************************/
 
 size_t
 PropertyIteratorObject::sizeOfMisc(mozilla::MallocSizeOf mallocSizeOf) const
 {
     return mallocSizeOf(getPrivate());
 }
 
 void
--- a/js/src/vm/JSObject.cpp
+++ b/js/src/vm/JSObject.cpp
@@ -286,17 +286,17 @@ js::Throw(JSContext* cx, HandleId id, un
     } else {
         JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, errorNumber, bytes.get());
     }
 
     return false;
 }
 
 
-/*** PropertyDescriptor operations and DefineProperties ******************************************/
+/*** PropertyDescriptor operations and DefineProperties *********************/
 
 static const char js_getter_str[] = "getter";
 static const char js_setter_str[] = "setter";
 
 static Result<>
 CheckCallable(JSContext* cx, JSObject* obj, const char* fieldName)
 {
     if (obj && !obj->isCallable()) {
@@ -491,17 +491,17 @@ js::ReadPropertyDescriptors(JSContext* c
             !descs.append(desc))
         {
             return false;
         }
     }
     return true;
 }
 
-/*** Seal and freeze *****************************************************************************/
+/*** Seal and freeze ********************************************************/
 
 static unsigned
 GetSealedOrFrozenAttributes(unsigned attrs, IntegrityLevel level)
 {
     // Make all attributes permanent; if freezing, make data attributes
     // read-only.
     if (level == IntegrityLevel::Frozen && !(attrs & (JSPROP_GETTER | JSPROP_SETTER))) {
         return JSPROP_PERMANENT | JSPROP_READONLY;
@@ -2869,17 +2869,17 @@ js::GetPrototypeIfOrdinary(JSContext* cx
         return js::Proxy::getPrototypeIfOrdinary(cx, obj, isOrdinary, protop);
     }
 
     *isOrdinary = true;
     protop.set(obj->staticPrototype());
     return true;
 }
 
-/*** ES6 standard internal methods ***************************************************************/
+/*** ES6 standard internal methods ******************************************/
 
 bool
 js::SetPrototype(JSContext* cx, HandleObject obj, HandleObject proto, JS::ObjectOpResult& result)
 {
     // The proxy trap subsystem fully handles prototype-setting for proxies
     // with dynamic [[Prototype]]s.
     if (obj->hasDynamicPrototype()) {
         MOZ_ASSERT(obj->is<ProxyObject>());
@@ -3151,17 +3151,17 @@ js::DefineDataElement(JSContext* cx, Han
 {
     RootedId id(cx);
     if (!IndexToId(cx, index, &id)) {
         return false;
     }
     return DefineDataProperty(cx, obj, id, value, attrs);
 }
 
-/*** SpiderMonkey nonstandard internal methods ***************************************************/
+/*** SpiderMonkey nonstandard internal methods ******************************/
 
 // Mark an object as having an immutable prototype
 //
 // NOTE: This does not correspond to the SetImmutablePrototype ECMAScript
 //       method.
 bool
 js::SetImmutablePrototype(JSContext* cx, HandleObject obj, bool* succeeded)
 {
@@ -3245,17 +3245,17 @@ js::DefineFunctions(JSContext* cx, Handl
         if (!DefineFunctionFromSpec(cx, obj, fs, fs->flags, intrinsic)) {
             return false;
         }
     }
     return true;
 }
 
 
-/*** ToPrimitive *************************************************************/
+/*** ToPrimitive ************************************************************/
 
 /*
  * Gets |obj[id]|.  If that value's not callable, returns true and stores an
  * object value in *vp.  If it's callable, calls it with no arguments and |obj|
  * as |this|, returning the result in *vp.
  *
  * This is a mini-abstraction for ES6 draft rev 36 (2015 Mar 17),
  * 7.1.1, second algorithm (OrdinaryToPrimitive), steps 5.a-c.
@@ -3663,17 +3663,17 @@ GetObjectSlotNameFunctor::operator()(JS:
         } else if (JSID_IS_SYMBOL(propid)) {
             snprintf(buf, bufsize, "**SYMBOL KEY**");
         } else {
             snprintf(buf, bufsize, "**FINALIZED ATOM KEY**");
         }
     }
 }
 
-/*** Debugging routines **************************************************************************/
+/*** Debugging routines *****************************************************/
 
 #if defined(DEBUG) || defined(JS_JITSPEW)
 
 /*
  * Routines to print out values during debugging.  These are FRIEND_API to help
  * the debugger find them and to support temporarily hacking js::Dump* calls
  * into other code.
  */
--- a/js/src/vm/JSObject.h
+++ b/js/src/vm/JSObject.h
@@ -28,17 +28,17 @@ namespace js {
 using PropertyDescriptorVector = JS::GCVector<JS::PropertyDescriptor>;
 class GCMarker;
 class Nursery;
 
 namespace gc {
 class RelocationOverlay;
 } // namespace gc
 
-/******************************************************************************/
+/****************************************************************************/
 
 class GlobalObject;
 class NewObjectCache;
 
 enum class IntegrityLevel {
     Sealed,
     Frozen
 };
--- a/js/src/vm/NativeObject.cpp
+++ b/js/src/vm/NativeObject.cpp
@@ -1202,17 +1202,17 @@ js::NativeLookupOwnProperty(JSContext* c
 template bool
 js::NativeLookupOwnProperty<CanGC>(JSContext* cx, HandleNativeObject obj, HandleId id,
                                    MutableHandle<PropertyResult> propp);
 
 template bool
 js::NativeLookupOwnProperty<NoGC>(JSContext* cx, NativeObject* const& obj, const jsid& id,
                                   FakeMutableHandle<PropertyResult> propp);
 
-/*** [[DefineOwnProperty]] ***********************************************************************/
+/*** [[DefineOwnProperty]] **************************************************/
 
 static MOZ_ALWAYS_INLINE bool
 CallAddPropertyHook(JSContext* cx, HandleNativeObject obj, HandleId id, HandleValue value)
 {
     JSAddPropertyOp addProperty = obj->getClass()->getAddProperty();
     if (MOZ_UNLIKELY(addProperty)) {
         MOZ_ASSERT(!cx->helperThread());
 
@@ -2167,17 +2167,17 @@ js::AddOrUpdateSparseElementHelper(JSCon
     // We don't know exactly what this object looks like, hit the slowpath.
     RootedValue receiver(cx, ObjectValue(*obj));
     JS::ObjectOpResult result;
     return SetProperty(cx, obj, id, v, receiver, result) &&
            result.checkStrictErrorOrWarning(cx, obj, id, strict);
 }
 
 
-/*** [[HasProperty]] *****************************************************************************/
+/*** [[HasProperty]] ********************************************************/
 
 // ES6 draft rev31 9.1.7.1 OrdinaryHasProperty
 bool
 js::NativeHasProperty(JSContext* cx, HandleNativeObject obj, HandleId id, bool* foundp)
 {
     RootedNativeObject pobj(cx, obj);
     Rooted<PropertyResult> prop(cx);
 
@@ -2223,17 +2223,17 @@ js::NativeHasProperty(JSContext* cx, Han
             return HasProperty(cx, protoRoot, id, foundp);
         }
 
         pobj = &proto->as<NativeObject>();
     }
 }
 
 
-/*** [[GetOwnPropertyDescriptor]] ****************************************************************/
+/*** [[GetOwnPropertyDescriptor]] *******************************************/
 
 bool
 js::NativeGetOwnPropertyDescriptor(JSContext* cx, HandleNativeObject obj, HandleId id,
                                    MutableHandle<PropertyDescriptor> desc)
 {
     Rooted<PropertyResult> prop(cx);
     if (!NativeLookupOwnProperty<CanGC>(cx, obj, id, &prop)) {
         return false;
@@ -2286,17 +2286,17 @@ js::NativeGetOwnPropertyDescriptor(JSCon
     }
 
     desc.object().set(obj);
     desc.assertComplete();
     return true;
 }
 
 
-/*** [[Get]] *************************************************************************************/
+/*** [[Get]] ****************************************************************/
 
 static inline bool
 CallGetter(JSContext* cx, HandleObject obj, HandleValue receiver, HandleShape shape,
            MutableHandleValue vp)
 {
     MOZ_ASSERT(!shape->hasDefaultGetter());
 
     if (shape->hasGetterValue()) {
@@ -2697,17 +2697,17 @@ js::GetNameBoundInEnvironment(JSContext*
     RootedValue receiver(cx, ObjectValue(*env));
     if (env->getOpsGetProperty()) {
         return GeneralizedGetProperty(cx, env, id, receiver, NameLookup, vp);
     }
     return NativeGetPropertyInline<CanGC>(cx, env.as<NativeObject>(), receiver, id, NameLookup, vp);
 }
 
 
-/*** [[Set]] *************************************************************************************/
+/*** [[Set]] ****************************************************************/
 
 static bool
 MaybeReportUndeclaredVarAssignment(JSContext* cx, HandleId id)
 {
     unsigned flags;
     {
         jsbytecode* pc;
         JSScript* script = cx->currentScript(&pc, JSContext::AllowCrossRealm::Allow);
@@ -3103,17 +3103,17 @@ js::NativeSetElement(JSContext* cx, Hand
 {
     RootedId id(cx);
     if (!IndexToId(cx, index, &id)) {
         return false;
     }
     return NativeSetProperty<Qualified>(cx, obj, id, v, receiver, result);
 }
 
-/*** [[Delete]] **********************************************************************************/
+/*** [[Delete]] *************************************************************/
 
 // ES6 draft rev31 9.1.10 [[Delete]]
 bool
 js::NativeDeleteProperty(JSContext* cx, HandleNativeObject obj, HandleId id,
                          ObjectOpResult& result)
 {
     // Steps 2-3.
     Rooted<PropertyResult> prop(cx);
--- a/js/src/vm/NativeObject.h
+++ b/js/src/vm/NativeObject.h
@@ -1548,17 +1548,17 @@ NativeObject::privateWriteBarrierPre(voi
 {
     JS::shadow::Zone* shadowZone = this->shadowZoneFromAnyThread();
     if (shadowZone->needsIncrementalBarrier() && *oldval && getClass()->hasTrace()) {
         getClass()->doTrace(shadowZone->barrierTracer(), this);
     }
 }
 
 
-/*** Standard internal methods *******************************************************************/
+/*** Standard internal methods **********************************************/
 
 /*
  * These functions should follow the algorithms in ES6 draft rev 29 section 9.1
  * ("Ordinary Object Internal Methods"). It's an ongoing project.
  *
  * Many native objects are not "ordinary" in ES6, so these functions also have
  * to serve some of the special needs of Functions (9.2, 9.3, 9.4.1), Arrays
  * (9.4.2), Strings (9.4.3), and so on.
@@ -1651,17 +1651,17 @@ NativeSetProperty(JSContext* cx, HandleN
 extern bool
 NativeSetElement(JSContext* cx, HandleNativeObject obj, uint32_t index, HandleValue v,
                  HandleValue receiver, ObjectOpResult& result);
 
 extern bool
 NativeDeleteProperty(JSContext* cx, HandleNativeObject obj, HandleId id, ObjectOpResult& result);
 
 
-/*** SpiderMonkey nonstandard internal methods ***************************************************/
+/*** SpiderMonkey nonstandard internal methods ******************************/
 
 template <AllowGC allowGC>
 extern bool
 NativeLookupOwnProperty(JSContext* cx,
                         typename MaybeRooted<NativeObject*, allowGC>::HandleType obj,
                         typename MaybeRooted<jsid, allowGC>::HandleType id,
                         typename MaybeRooted<PropertyResult, allowGC>::MutableHandleType propp);
 
--- a/js/src/vm/ObjectOperations.h
+++ b/js/src/vm/ObjectOperations.h
@@ -245,17 +245,17 @@ PutProperty(JSContext* cx, JS::Handle<JS
 inline bool
 DeleteProperty(JSContext* cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
                JS::ObjectOpResult& result);
 
 inline bool
 DeleteElement(JSContext* cx, JS::Handle<JSObject*> obj, uint32_t index,
               JS::ObjectOpResult& result);
 
-/*** SpiderMonkey nonstandard internal methods ***************************************************/
+/*** SpiderMonkey nonstandard internal methods ******************************/
 
 /**
  * If |obj| (underneath any functionally-transparent wrapper proxies) has as
  * its [[GetPrototypeOf]] trap the ordinary [[GetPrototypeOf]] behavior defined
  * for ordinary objects, set |*isOrdinary = true| and store |obj|'s prototype
  * in |result|.  Otherwise set |*isOrdinary = false|.  In case of error, both
  * outparams have unspecified value.
  */
--- a/js/src/vm/StringType.cpp
+++ b/js/src/vm/StringType.cpp
@@ -2160,17 +2160,17 @@ JSString::fillWithRepresentatives(JSCont
     }
 
     MOZ_ASSERT(index == 44);
 
     return true;
 }
 
 
-/*** Conversions *********************************************************************************/
+/*** Conversions ************************************************************/
 
 UniqueChars
 js::EncodeLatin1(JSContext* cx, JSString* str)
 {
     JSLinearString* linear = str->ensureLinear(cx);
     if (!linear) {
         return nullptr;
     }
--- a/js/src/vm/StringType.h
+++ b/js/src/vm/StringType.h
@@ -1685,17 +1685,17 @@ HasSubstringAt(JSLinearString* text, JSL
  * Computes |str|'s substring for the range [beginInt, beginInt + lengthInt).
  * Negative, overlarge, swapped, etc. |beginInt| and |lengthInt| are forbidden
  * and constitute API misuse.
  */
 JSString*
 SubstringKernel(JSContext* cx, HandleString str, int32_t beginInt, int32_t lengthInt);
 
 
-/*** Conversions *********************************************************************************/
+/*** Conversions ************************************************************/
 
 /*
  * Convert a string to a printable C string.
  *
  * Asserts if the input contains any non-ASCII characters.
  */
 UniqueChars
 EncodeAscii(JSContext* cx, JSString* str);
--- a/js/src/vm/UbiNodeCensus.cpp
+++ b/js/src/vm/UbiNodeCensus.cpp
@@ -29,17 +29,17 @@ CountDeleter::operator()(CountBase* ptr)
     }
 
     // Downcast to our true type and destruct, as guided by our CountType
     // pointer.
     ptr->destruct();
     js_free(ptr);
 }
 
-/*** Count Types ***********************************************************************************/
+/*** Count Types ************************************************************/
 
 // The simplest type: just count everything.
 class SimpleCount : public CountType {
 
     struct Count : CountBase {
         size_t totalBytes_;
 
         explicit Count(SimpleCount& count)
@@ -1129,17 +1129,17 @@ ByFilename::report(JSContext* cx, CountB
         return false;
     }
 
     report.setObject(*obj);
     return true;
 }
 
 
-/*** Census Handler *******************************************************************************/
+/*** Census Handler *********************************************************/
 
 JS_PUBLIC_API bool
 CensusHandler::operator() (BreadthFirst<CensusHandler>& traversal,
                            Node origin, const Edge& edge,
                            NodeData* referentData, bool first)
 {
     // We're only interested in the first time we reach edge.referent, not
     // in every edge arriving at that node.
@@ -1165,17 +1165,17 @@ CensusHandler::operator() (BreadthFirst<
         return rootCount->count(mallocSizeOf, referent);
     }
 
     traversal.abandonReferent();
     return true;
 }
 
 
-/*** Parsing Breakdowns ***************************************************************************/
+/*** Parsing Breakdowns *****************************************************/
 
 static CountTypePtr
 ParseChildBreakdown(JSContext* cx, HandleObject breakdown, PropertyName* prop)
 {
     RootedValue v(cx);
     if (!GetProperty(cx, breakdown, breakdown, prop, &v)) {
         return nullptr;
     }