Bug 1508605 - Change some comments from /* */ to // to avoid clang-format issues. r=tcampbell
authorJan de Mooij <jdemooij@mozilla.com>
Tue, 20 Nov 2018 14:47:07 +0000
changeset 447321 5bad4fe7108eda1ca69c5f5aac82b4042c874deb
parent 447320 f198bf91320bf774f2c9f204c426ac0c2da95aa2
child 447322 4b0554a10847e9a879ab193bf16a3bbdaa8e69d4
push id110028
push usershindli@mozilla.com
push dateTue, 20 Nov 2018 21:50:36 +0000
treeherdermozilla-inbound@772005147068 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerstcampbell
bugs1508605
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 1508605 - Change some comments from /* */ to // to avoid clang-format issues. r=tcampbell Differential Revision: https://phabricator.services.mozilla.com/D12416
js/src/builtin/Array.h
js/src/builtin/ReflectParse.cpp
js/src/builtin/RegExp.cpp
js/src/builtin/RegExp.h
js/src/builtin/String.cpp
js/src/builtin/String.h
js/src/builtin/TypedObject.h
js/src/frontend/NameFunctions.cpp
js/src/frontend/Parser.h
js/src/gc/FindSCCs.h
js/src/gc/GC.cpp
js/src/gc/GCRuntime.h
js/src/gc/Heap.h
js/src/gc/Memory.cpp
js/src/gc/Nursery.cpp
js/src/gc/Nursery.h
js/src/gc/ObjectKind-inl.h
js/src/gc/Rooting.h
js/src/gc/WeakMap-inl.h
js/src/gc/WeakMap.h
js/src/jit/InlineList.h
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsfriendapi.h
js/src/jsnum.cpp
js/src/shell/js.cpp
js/src/shell/jsoptparse.cpp
js/src/vm/ArrayBufferObject-inl.h
js/src/vm/BytecodeUtil.h
js/src/vm/Caches.h
js/src/vm/Debugger.cpp
js/src/vm/Debugger.h
js/src/vm/EnvironmentObject.h
js/src/vm/GeckoProfiler.cpp
js/src/vm/Interpreter.cpp
js/src/vm/Iteration.cpp
js/src/vm/JSContext.h
js/src/vm/JSFunction.h
js/src/vm/JSObject.cpp
js/src/vm/NativeObject.cpp
js/src/vm/NativeObject.h
js/src/vm/RegExpObject.h
js/src/vm/Runtime.cpp
js/src/vm/Shape.h
js/src/vm/Stack.h
js/src/vm/StringType.h
js/src/vm/TypeInference.cpp
js/src/vm/TypeSet.h
--- a/js/src/builtin/Array.h
+++ b/js/src/builtin/Array.h
@@ -40,52 +40,49 @@ IdIsIndex(jsid id, uint32_t* indexp)
         return false;
     }
 
     return js::StringIsArrayIndex(atom, indexp);
 }
 
 // The methods below only create dense boxed arrays.
 
-/* Create a dense array with no capacity allocated, length set to 0. */
+// Create a dense array with no capacity allocated, length set to 0.
 extern ArrayObject * JS_FASTCALL
 NewDenseEmptyArray(JSContext* cx, HandleObject proto = nullptr,
                    NewObjectKind newKind = GenericObject);
 
-/*
- * Create a dense array with a set length, but without allocating space for the
- * contents. This is useful, e.g., when accepting length from the user.
- */
+// Create a dense array with a set length, but without allocating space for the
+// contents. This is useful, e.g., when accepting length from the user.
 extern ArrayObject * JS_FASTCALL
 NewDenseUnallocatedArray(JSContext* cx, uint32_t length, HandleObject proto = nullptr,
                          NewObjectKind newKind = GenericObject);
 
-/*
- * Create a dense array with length and capacity == |length|, initialized length set to 0,
- * but with only |EagerAllocationMaxLength| elements allocated.
- */
+// Create a dense array with length and capacity == |length|, initialized length
+// set to 0, but with only |EagerAllocationMaxLength| elements allocated.
 extern ArrayObject * JS_FASTCALL
 NewDensePartlyAllocatedArray(JSContext* cx, uint32_t length, HandleObject proto = nullptr,
                              NewObjectKind newKind = GenericObject);
 
-/* Create a dense array with length and capacity == 'length', initialized length set to 0. */
+// Create a dense array with length and capacity == 'length', initialized length
+// set to 0.
 extern ArrayObject * JS_FASTCALL
 NewDenseFullyAllocatedArray(JSContext* cx, uint32_t length, HandleObject proto = nullptr,
                             NewObjectKind newKind = GenericObject);
 
-/* Create a dense array from the given array values, which must be rooted */
+// Create a dense array from the given array values, which must be rooted.
 extern ArrayObject*
 NewDenseCopiedArray(JSContext* cx, uint32_t length, const Value* values,
                     HandleObject proto = nullptr, NewObjectKind newKind = GenericObject);
 
-/* Create a dense array based on templateObject with the given length. */
+// Create a dense array based on templateObject with the given length.
 extern ArrayObject*
 NewDenseFullyAllocatedArrayWithTemplate(JSContext* cx, uint32_t length, JSObject* templateObject);
 
-/* Create a dense array with the same copy-on-write elements as another object. */
+// Create a dense array with the same copy-on-write elements as another object.
 extern ArrayObject*
 NewDenseCopyOnWriteArray(JSContext* cx, HandleArrayObject templateObject, gc::InitialHeap heap);
 
 extern ArrayObject*
 NewFullyAllocatedArrayTryUseGroup(JSContext* cx, HandleObjectGroup group, size_t length,
                                   NewObjectKind newKind = GenericObject);
 
 extern ArrayObject*
--- a/js/src/builtin/ReflectParse.cpp
+++ b/js/src/builtin/ReflectParse.cpp
@@ -443,17 +443,18 @@ class NodeBuilder
         /*
          * Bug 575416: instead of Atomize, lookup constant atoms in tbl file
          */
         RootedAtom atom(cx, Atomize(cx, name, strlen(name)));
         if (!atom) {
             return false;
         }
 
-        /* Represent "no node" as null and ensure users are not exposed to magic values. */
+        // Represent "no node" as null and ensure users are not exposed to magic
+        // values.
         RootedValue optVal(cx, val.isMagic(JS_SERIALIZE_NO_NODE) ? NullValue() : val);
         return DefineDataProperty(cx, obj, atom->asPropertyName(), optVal);
     }
 
     MOZ_MUST_USE bool newNodeLoc(TokenPos* pos, MutableHandleValue dst);
 
     MOZ_MUST_USE bool setNodeLoc(HandleObject node, TokenPos* pos);
 
@@ -3650,17 +3651,18 @@ ASTSerializer::functionArgs(ParseNode* p
     return true;
 }
 
 bool
 ASTSerializer::functionBody(ParseNode* pn, TokenPos* pos, MutableHandleValue dst)
 {
     NodeVector elts(cx);
 
-    /* We aren't sure how many elements there are up front, so we'll check each append. */
+    // We aren't sure how many elements there are up front, so we'll check each
+    // append.
     for (ParseNode* next = pn; next; next = next->pn_next) {
         RootedValue child(cx);
         if (!sourceElement(next, &child) || !elts.append(child)) {
             return false;
         }
     }
 
     return builder.blockStatement(elts, pos, dst);
--- a/js/src/builtin/RegExp.cpp
+++ b/js/src/builtin/RegExp.cpp
@@ -45,73 +45,74 @@ js::CreateRegExpMatchResult(JSContext* c
      *
      * Array contents:
      *  0:              matched string
      *  1..pairCount-1: paren matches
      *  input:          input string
      *  index:          start index for the match
      */
 
-    /* Get the templateObject that defines the shape and type of the output object */
+    // Get the templateObject that defines the shape and type of the output
+    // object.
     JSObject* templateObject = cx->realm()->regExps.getOrCreateMatchResultTemplateObject(cx);
     if (!templateObject) {
         return false;
     }
 
     size_t numPairs = matches.length();
     MOZ_ASSERT(numPairs > 0);
 
-    /* Step 17. */
+    // Step 17.
     RootedArrayObject arr(cx, NewDenseFullyAllocatedArrayWithTemplate(cx, numPairs, templateObject));
     if (!arr) {
         return false;
     }
 
-    /* Steps 22-24.
-     * Store a Value for each pair. */
+    // Steps 22-24.
+    // Store a Value for each pair.
     for (size_t i = 0; i < numPairs; i++) {
         const MatchPair& pair = matches[i];
 
         if (pair.isUndefined()) {
-            MOZ_ASSERT(i != 0); /* Since we had a match, first pair must be present. */
+            MOZ_ASSERT(i != 0); // Since we had a match, first pair must be present.
             arr->setDenseInitializedLength(i + 1);
             arr->initDenseElement(i, UndefinedValue());
         } else {
             JSLinearString* str = NewDependentString(cx, input, pair.start, pair.length());
             if (!str) {
                 return false;
             }
             arr->setDenseInitializedLength(i + 1);
             arr->initDenseElement(i, StringValue(str));
         }
     }
 
-    /* Step 20 (reordered).
-     * Set the |index| property. */
+    // Step 20 (reordered).
+    // Set the |index| property.
     arr->setSlot(RegExpRealm::MatchResultObjectIndexSlot, Int32Value(matches[0].start));
 
-    /* Step 21 (reordered).
-     * Set the |input| property. */
+    // Step 21 (reordered).
+    // Set the |input| property.
     arr->setSlot(RegExpRealm::MatchResultObjectInputSlot, StringValue(input));
 
 #ifdef DEBUG
     RootedValue test(cx);
     RootedId id(cx, NameToId(cx->names().index));
     if (!NativeGetProperty(cx, arr, id, &test)) {
         return false;
     }
     MOZ_ASSERT(test == arr->getSlot(RegExpRealm::MatchResultObjectIndexSlot));
     id = NameToId(cx->names().input);
     if (!NativeGetProperty(cx, arr, id, &test)) {
         return false;
     }
     MOZ_ASSERT(test == arr->getSlot(RegExpRealm::MatchResultObjectInputSlot));
 #endif
 
-    /* Step 25. */
+    // Step 25.
     rval.setObject(*arr);
     return true;
 }
 
 static int32_t
 CreateRegExpSearchResult(const MatchPairs& matches)
 {
     /* Fit the start and limit of match into a int32_t. */
--- a/js/src/builtin/RegExp.h
+++ b/js/src/builtin/RegExp.h
@@ -26,17 +26,17 @@ InitRegExpClass(JSContext* cx, HandleObj
  * |input| may be nullptr if there is no JSString corresponding to
  * |chars| and |length|.
  */
 MOZ_MUST_USE bool
 ExecuteRegExpLegacy(JSContext* cx, RegExpStatics* res, Handle<RegExpObject*> reobj,
                     HandleLinearString input, size_t* lastIndex, bool test,
                     MutableHandleValue rval);
 
-/* Translation from MatchPairs to a JS array in regexp_exec()'s output format. */
+// Translation from MatchPairs to a JS array in regexp_exec()'s output format.
 MOZ_MUST_USE bool
 CreateRegExpMatchResult(JSContext* cx, HandleString input, const MatchPairs& matches,
                         MutableHandleValue rval);
 
 extern MOZ_MUST_USE bool
 RegExpMatcher(JSContext* cx, unsigned argc, Value* vp);
 
 extern MOZ_MUST_USE bool
--- a/js/src/builtin/String.cpp
+++ b/js/src/builtin/String.cpp
@@ -2789,31 +2789,32 @@ BuildFlatRopeReplacement(JSContext* cx, 
 template <typename CharT>
 static bool
 AppendDollarReplacement(StringBuffer& newReplaceChars, size_t firstDollarIndex,
                         size_t matchStart, size_t matchLimit, JSLinearString* text,
                         const CharT* repChars, size_t repLength)
 {
     MOZ_ASSERT(firstDollarIndex < repLength);
 
-    /* Move the pre-dollar chunk in bulk. */
+    // Move the pre-dollar chunk in bulk.
     newReplaceChars.infallibleAppend(repChars, firstDollarIndex);
 
-    /* Move the rest char-by-char, interpreting dollars as we encounter them. */
+    // Move the rest char-by-char, interpreting dollars as we encounter them.
     const CharT* repLimit = repChars + repLength;
     for (const CharT* it = repChars + firstDollarIndex; it < repLimit; ++it) {
         if (*it != '$' || it == repLimit - 1) {
             if (!newReplaceChars.append(*it)) {
                 return false;
             }
             continue;
         }
 
         switch (*(it + 1)) {
-          case '$': /* Eat one of the dollars. */
+          case '$':
+            // Eat one of the dollars.
             if (!newReplaceChars.append(*it)) {
                 return false;
             }
             break;
           case '&':
             if (!newReplaceChars.appendSubstring(text, matchStart, matchLimit - matchStart)) {
                 return false;
             }
@@ -2823,23 +2824,25 @@ AppendDollarReplacement(StringBuffer& ne
                 return false;
             }
             break;
           case '\'':
             if (!newReplaceChars.appendSubstring(text, matchLimit, text->length() - matchLimit)) {
                 return false;
             }
             break;
-          default: /* The dollar we saw was not special (no matter what its mother told it). */
+          default:
+            // The dollar we saw was not special (no matter what its mother told
+            // it).
             if (!newReplaceChars.append(*it)) {
                 return false;
             }
             continue;
         }
-        ++it; /* We always eat an extra char in the above switch. */
+        ++it; // We always eat an extra char in the above switch.
     }
 
     return true;
 }
 
 /*
  * Perform a linear-scan dollar substitution on the replacement text.
  */
@@ -4279,35 +4282,36 @@ static bool
 BuildFlatMatchArray(JSContext* cx, HandleString str, HandleString pattern, int32_t match,
                     MutableHandleValue rval)
 {
     if (match < 0) {
         rval.setNull();
         return true;
     }
 
-    /* Get the templateObject that defines the shape and type of the output object */
+    // Get the templateObject that defines the shape and type of the output
+    // object.
     JSObject* templateObject = cx->realm()->regExps.getOrCreateMatchResultTemplateObject(cx);
     if (!templateObject) {
         return false;
     }
 
     RootedArrayObject arr(cx, NewDenseFullyAllocatedArrayWithTemplate(cx, 1, templateObject));
     if (!arr) {
         return false;
     }
 
-    /* Store a Value for each pair. */
+    // Store a Value for each pair.
     arr->setDenseInitializedLength(1);
     arr->initDenseElement(0, StringValue(pattern));
 
-    /* Set the |index| property. (TemplateObject positions it in slot 0) */
+    // Set the |index| property. (TemplateObject positions it in slot 0).
     arr->setSlot(0, Int32Value(match));
 
-    /* Set the |input| property. (TemplateObject positions it in slot 1) */
+    // Set the |input| property. (TemplateObject positions it in slot 1).
     arr->setSlot(1, StringValue(str));
 
 #ifdef DEBUG
     RootedValue test(cx);
     RootedId id(cx, NameToId(cx->names().index));
     if (!NativeGetProperty(cx, arr, id, &test)) {
         return false;
     }
--- a/js/src/builtin/String.h
+++ b/js/src/builtin/String.h
@@ -37,17 +37,17 @@ extern bool
 str_fromCharCode_one_arg(JSContext* cx, HandleValue code, MutableHandleValue rval);
 
 extern bool
 str_fromCodePoint(JSContext* cx, unsigned argc, Value* vp);
 
 extern bool
 str_fromCodePoint_one_arg(JSContext* cx, HandleValue code, MutableHandleValue rval);
 
-/* String methods exposed so they can be installed in the self-hosting global. */
+// String methods exposed so they can be installed in the self-hosting global.
 
 extern bool
 str_includes(JSContext* cx, unsigned argc, Value* vp);
 
 extern bool
 str_indexOf(JSContext* cx, unsigned argc, Value* vp);
 
 extern bool
--- a/js/src/builtin/TypedObject.h
+++ b/js/src/builtin/TypedObject.h
@@ -842,17 +842,18 @@ MOZ_MUST_USE bool ObjectIsOpaqueTypedObj
 
 /*
  * Usage: ObjectIsTransparentTypedObject(obj)
  *
  * True if `obj` is a transparent typed object.
  */
 MOZ_MUST_USE bool ObjectIsTransparentTypedObject(JSContext* cx, unsigned argc, Value* vp);
 
-/* Predicates on type descriptor objects.  In all cases, 'obj' must be a type descriptor. */
+// Predicates on type descriptor objects.  In all cases, 'obj' must be a type
+// descriptor.
 
 MOZ_MUST_USE bool TypeDescrIsSimpleType(JSContext*, unsigned argc, Value* vp);
 
 MOZ_MUST_USE bool TypeDescrIsArrayType(JSContext*, unsigned argc, Value* vp);
 
 /*
  * Usage: TypedObjectIsAttached(obj)
  *
--- a/js/src/frontend/NameFunctions.cpp
+++ b/js/src/frontend/NameFunctions.cpp
@@ -60,17 +60,17 @@ class NameResolver
 
     /* Append a number to buf. */
     bool appendNumber(double n) {
         char number[30];
         int digits = SprintfLiteral(number, "%g", n);
         return buf->append(number, digits);
     }
 
-    /* Append "[<n>]" to buf, referencing a property named by a numeric literal. */
+    // Append "[<n>]" to buf, referencing a property named by a numeric literal.
     bool appendNumericPropertyReference(double n) {
         return buf->append("[") && appendNumber(n) && buf->append(']');
     }
 
     /*
      * Walk over the given ParseNode, attempting to convert it to a stringified
      * name that respresents where the function is being assigned to.
      *
--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -258,17 +258,17 @@ class MOZ_STACK_CLASS ParserBase
 
     ScriptSource*       ss;
 
     RootedScriptSourceObject sourceObject;
 
     /* Root atoms and objects allocated for the parsed tree. */
     AutoKeepAtoms       keepAtoms;
 
-    /* Perform constant-folding; must be true when interfacing with the emitter. */
+    // Perform constant-folding; must be true when interfacing with the emitter.
     const bool          foldConstants:1;
 
   protected:
 #if DEBUG
     /* Our fallible 'checkOptions' member function has been called. */
     bool checkOptionsCalled:1;
 #endif
 
--- a/js/src/gc/FindSCCs.h
+++ b/js/src/gc/FindSCCs.h
@@ -144,17 +144,18 @@ class ComponentFinder
             cur->gcLowLink = Min(cur->gcLowLink, w->gcDiscoveryTime);
         }
     }
 
   private:
     /* Constant used to indicate an unprocessed vertex. */
     static const unsigned Undefined = 0;
 
-    /* Constant used to indicate an processed vertex that is no longer on the stack. */
+    // Constant used to indicate an processed vertex that is no longer on the
+    // stack.
     static const unsigned Finished = (unsigned)-1;
 
     void processNode(Node* v) {
         v->gcDiscoveryTime = clock;
         v->gcLowLink = clock;
         ++clock;
 
         v->gcNextGraphNode = stack;
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -1382,37 +1382,35 @@ GCRuntime::init(uint32_t maxbytes, uint3
     }
 
     return true;
 }
 
 void
 GCRuntime::finish()
 {
-    /* Wait for nursery background free to end and disable it to release memory. */
+    // Wait for nursery background free to end and disable it to release memory.
     if (nursery().isEnabled()) {
         nursery().waitBackgroundFreeEnd();
         nursery().disable();
     }
 
-    /*
-     * Wait until the background finalization and allocation stops and the
-     * helper thread shuts down before we forcefully release any remaining GC
-     * memory.
-     */
+    // Wait until the background finalization and allocation stops and the
+    // helper thread shuts down before we forcefully release any remaining GC
+    // memory.
     sweepTask.join();
     allocTask.cancelAndWait();
     decommitTask.cancelAndWait();
 
 #ifdef JS_GC_ZEAL
-    /* Free memory associated with GC verification. */
+    // Free memory associated with GC verification.
     finishVerifier();
 #endif
 
-    /* Delete all remaining zones. */
+    // Delete all remaining zones.
     if (rt->gcInitialized) {
         AutoSetThreadIsSweeping threadIsSweeping;
         for (ZonesIter zone(rt, WithAtoms); !zone.done(); zone.next()) {
             for (CompartmentsInZoneIter comp(zone); !comp.done(); comp.next()) {
                 for (RealmsInCompartmentIter realm(comp); !realm.done(); realm.next()) {
                     js_delete(realm.get());
                 }
                 comp->realms().clear();
@@ -5624,50 +5622,47 @@ js::NotifyGCPostSwap(JSObject* a, JSObje
     }
 }
 
 IncrementalProgress
 GCRuntime::endMarkingSweepGroup(FreeOp* fop, SliceBudget& budget)
 {
     gcstats::AutoPhase ap(stats(), gcstats::PhaseKind::SWEEP_MARK);
 
-    /*
-     * Mark any incoming black pointers from previously swept compartments
-     * whose referents are not marked. This can occur when gray cells become
-     * black by the action of UnmarkGray.
-     */
+    // Mark any incoming black pointers from previously swept compartments
+    // whose referents are not marked. This can occur when gray cells become
+    // black by the action of UnmarkGray.
     markIncomingCrossCompartmentPointers(MarkColor::Black);
     markWeakReferencesInCurrentGroup(gcstats::PhaseKind::SWEEP_MARK_WEAK);
 
-    /*
-     * Change state of current group to MarkGray to restrict marking to this
-     * group.  Note that there may be pointers to the atoms zone, and
-     * these will be marked through, as they are not marked with
-     * TraceCrossCompartmentEdge.
-     */
+    // Change state of current group to MarkGray to restrict marking to this
+    // group.  Note that there may be pointers to the atoms zone, and
+    // these will be marked through, as they are not marked with
+    // TraceCrossCompartmentEdge.
     for (SweepGroupZonesIter zone(rt); !zone.done(); zone.next()) {
         zone->changeGCState(Zone::Mark, Zone::MarkGray);
     }
     marker.setMarkColorGray();
 
-    /* Mark incoming gray pointers from previously swept compartments. */
+    // Mark incoming gray pointers from previously swept compartments.
     markIncomingCrossCompartmentPointers(MarkColor::Gray);
 
-    /* Mark gray roots and mark transitively inside the current compartment group. */
+    // Mark gray roots and mark transitively inside the current compartment
+    // group.
     markGrayReferencesInCurrentGroup(gcstats::PhaseKind::SWEEP_MARK_GRAY);
     markWeakReferencesInCurrentGroup(gcstats::PhaseKind::SWEEP_MARK_GRAY_WEAK);
 
-    /* Restore marking state. */
+    // Restore marking state.
     for (SweepGroupZonesIter zone(rt); !zone.done(); zone.next()) {
         zone->changeGCState(Zone::MarkGray, Zone::Mark);
     }
     MOZ_ASSERT(marker.isDrained());
     marker.setMarkColorBlack();
 
-    /* We must not yield after this point before we start sweeping the group. */
+    // We must not yield after this point before we start sweeping the group.
     safeToYield = false;
 
     return Finished;
 }
 
 // Causes the given WeakCache to be swept when run.
 class ImmediateSweepWeakCacheTask : public GCParallelTaskHelper<ImmediateSweepWeakCacheTask>
 {
@@ -7493,17 +7488,17 @@ GCRuntime::incrementalSlice(SliceBudget&
             break;
         }
 
         MOZ_FALLTHROUGH;
 
       case State::Mark:
         AutoGCRooter::traceAllWrappers(rt->mainContextFromOwnThread(), &marker);
 
-        /* If we needed delayed marking for gray roots, then collect until done. */
+        // If we needed delayed marking for gray roots, then collect until done.
         if (isIncremental && !hasValidGrayRootsBuffer()) {
             budget.makeUnlimited();
             isIncremental = false;
             stats().nonincremental(AbortReason::GrayRootBufferingFailed);
         }
 
         if (markUntilBudgetExhaused(budget, gcstats::PhaseKind::MARK) == NotFinished) {
             break;
--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -845,17 +845,17 @@ class GCRuntime
 #ifdef JS_GC_ZEAL
     /* Whether to pay attention the zeal settings in this incremental slice. */
     MainThreadData<bool> useZeal;
 #endif
 
     /* Indicates that the last incremental slice exhausted the mark stack. */
     MainThreadData<bool> lastMarkSlice;
 
-    /* Whether it's currently safe to yield to the mutator in an incremental GC. */
+    // Whether it's currently safe to yield to the mutator in an incremental GC.
     MainThreadData<bool> safeToYield;
 
     /* Whether any sweeping will take place in the separate GC helper thread. */
     MainThreadData<bool> sweepOnBackgroundThread;
 
     /* Singly linked list of zones to be swept in the background. */
     HelperThreadLockData<ZoneList> backgroundSweepZones;
 
--- a/js/src/gc/Heap.h
+++ b/js/src/gc/Heap.h
@@ -53,17 +53,17 @@ struct Chunk;
  * estimated lifetime or lifetime requirements of objects allocated from that
  * site.
  */
 enum InitialHeap : uint8_t {
     DefaultHeap,
     TenuredHeap
 };
 
-/* Cells are aligned to CellAlignShift, so the largest tagged null pointer is: */
+// Cells are aligned to CellAlignShift, so the largest tagged null pointer is:
 const uintptr_t LargestTaggedNullCellPointer = (1 << CellAlignShift) - 1;
 
 /*
  * The minimum cell size ends up as twice the cell alignment because the mark
  * bitmap contains one bit per CellBytesPerMarkBit bytes (which is equal to
  * CellAlignBytes) and we need two mark bits per cell.
  */
 const size_t MarkBitsPerCell = 2;
@@ -513,17 +513,18 @@ struct ChunkTrailer
 
     // Provide quick access to the runtime from absolutely anywhere.
     JSRuntime*      runtime;
 };
 
 static_assert(sizeof(ChunkTrailer) == ChunkTrailerSize,
               "ChunkTrailer size must match the API defined size.");
 
-/* The chunk header (located at the end of the chunk to preserve arena alignment). */
+// The chunk header (located at the end of the chunk to preserve arena
+// alignment).
 struct ChunkInfo
 {
     void init() {
         next = prev = nullptr;
     }
 
   private:
     friend class ChunkPool;
--- a/js/src/gc/Memory.cpp
+++ b/js/src/gc/Memory.cpp
@@ -127,17 +127,17 @@ MapAlignedPages(size_t size, size_t alig
     MOZ_ASSERT(size >= allocGranularity);
     MOZ_ASSERT(size % alignment == 0);
     MOZ_ASSERT(size % pageSize == 0);
     MOZ_ASSERT_IF(alignment < allocGranularity, allocGranularity % alignment == 0);
     MOZ_ASSERT_IF(alignment > allocGranularity, alignment % allocGranularity == 0);
 
     void* p = MapMemory(size, MEM_COMMIT | MEM_RESERVE);
 
-    /* Special case: If we want allocation alignment, no further work is needed. */
+    // Special case: If we want allocation alignment, no further work is needed.
     if (alignment == allocGranularity) {
         return p;
     }
 
     if (OffsetFromAligned(p, alignment) == 0) {
         return p;
     }
 
--- a/js/src/gc/Nursery.cpp
+++ b/js/src/gc/Nursery.cpp
@@ -308,58 +308,58 @@ js::Nursery::leaveZealMode() {
         setStartPosition();
     }
 }
 #endif // JS_GC_ZEAL
 
 JSObject*
 js::Nursery::allocateObject(JSContext* cx, size_t size, size_t nDynamicSlots, const js::Class* clasp)
 {
-    /* Ensure there's enough space to replace the contents with a RelocationOverlay. */
+    // Ensure there's enough space to replace the contents with a
+    // RelocationOverlay.
     MOZ_ASSERT(size >= sizeof(RelocationOverlay));
 
-    /* Sanity check the finalizer. */
+    // Sanity check the finalizer.
     MOZ_ASSERT_IF(clasp->hasFinalize(), CanNurseryAllocateFinalizedClass(clasp) ||
                                         clasp->isProxy());
 
-    /* Make the object allocation. */
+    // Make the object allocation.
     JSObject* obj = static_cast<JSObject*>(allocate(size));
     if (!obj) {
         return nullptr;
     }
 
-    /* If we want external slots, add them. */
+    // If we want external slots, add them.
     HeapSlot* slots = nullptr;
     if (nDynamicSlots) {
         MOZ_ASSERT(clasp->isNative());
         slots = static_cast<HeapSlot*>(allocateBuffer(cx->zone(), nDynamicSlots * sizeof(HeapSlot)));
         if (!slots) {
-            /*
-             * It is safe to leave the allocated object uninitialized, since we
-             * do not visit unallocated things in the nursery.
-             */
+            // It is safe to leave the allocated object uninitialized, since we
+            // do not visit unallocated things in the nursery.
             return nullptr;
         }
     }
 
-    /* Store slots pointer directly in new object. If no dynamic slots were
-     * requested, caller must initialize slots_ field itself as needed. We
-     * don't know if the caller was a native object or not. */
+    // Store slots pointer directly in new object. If no dynamic slots were
+    // requested, caller must initialize slots_ field itself as needed. We
+    // don't know if the caller was a native object or not.
     if (nDynamicSlots) {
         static_cast<NativeObject*>(obj)->initSlots(slots);
     }
 
     gcTracer.traceNurseryAlloc(obj, size);
     return obj;
 }
 
 Cell*
 js::Nursery::allocateString(Zone* zone, size_t size, AllocKind kind)
 {
-    /* Ensure there's enough space to replace the contents with a RelocationOverlay. */
+    // Ensure there's enough space to replace the contents with a
+    // RelocationOverlay.
     MOZ_ASSERT(size >= sizeof(RelocationOverlay));
 
     size_t allocSize = JS_ROUNDUP(sizeof(StringLayout) - 1 + size, CellAlignBytes);
     auto header = static_cast<StringLayout*>(allocate(allocSize));
     if (!header) {
         return nullptr;
     }
     header->zone = zone;
--- a/js/src/gc/Nursery.h
+++ b/js/src/gc/Nursery.h
@@ -460,17 +460,17 @@ class Nursery
     /*
      * The set of externally malloced buffers potentially kept live by objects
      * stored in the nursery. Any external buffers that do not belong to a
      * tenured thing at the end of a minor GC must be freed.
      */
     typedef HashSet<void*, PointerHasher<void*>, SystemAllocPolicy> MallocedBuffersSet;
     MallocedBuffersSet mallocedBuffers;
 
-    /* A task structure used to free the malloced bufers on a background thread. */
+    // A task structure used to free the malloced bufers on a background thread.
     struct FreeMallocedBuffersTask;
     FreeMallocedBuffersTask* freeMallocedBuffersTask;
 
     /*
      * During a collection most hoisted slot and element buffers indicate their
      * new location with a forwarding pointer at the base. This does not work
      * for buffers whose length is less than pointer width, or when different
      * buffers might overlap each other. For these, an entry in the following
--- a/js/src/gc/ObjectKind-inl.h
+++ b/js/src/gc/ObjectKind-inl.h
@@ -113,17 +113,18 @@ GetGCObjectKindForBytes(size_t nbytes)
     MOZ_ASSERT(nbytes <= dataSlots * sizeof(Value));
     return GetGCObjectKind(dataSlots);
 }
 
 /* Get the number of fixed slots and initial capacity associated with a kind. */
 static inline size_t
 GetGCKindSlots(AllocKind thingKind)
 {
-    /* Using a switch in hopes that thingKind will usually be a compile-time constant. */
+    // Using a switch in hopes that thingKind will usually be a compile-time
+    // constant.
     switch (thingKind) {
       case AllocKind::FUNCTION:
       case AllocKind::OBJECT0:
       case AllocKind::OBJECT0_BACKGROUND:
         return 0;
       case AllocKind::FUNCTION_EXTENDED:
       case AllocKind::OBJECT2:
       case AllocKind::OBJECT2_BACKGROUND:
--- a/js/src/gc/Rooting.h
+++ b/js/src/gc/Rooting.h
@@ -81,17 +81,20 @@ typedef JS::Rooted<DebuggerObject*>     
 typedef JS::Rooted<Scope*>                  RootedScope;
 typedef JS::Rooted<ModuleObject*>           RootedModuleObject;
 
 typedef JS::GCVector<JSFunction*>   FunctionVector;
 typedef JS::GCVector<PropertyName*> PropertyNameVector;
 typedef JS::GCVector<Shape*>        ShapeVector;
 typedef JS::GCVector<JSString*>     StringVector;
 
-/** Interface substitute for Rooted<T> which does not root the variable's memory. */
+/**
+ * Interface substitute for Rooted<T> which does not root the variable's
+ * memory.
+ */
 template <typename T>
 class MOZ_RAII FakeRooted : public RootedBase<T, FakeRooted<T>>
 {
   public:
     using ElementType = T;
 
     template <typename CX>
     explicit FakeRooted(CX* cx) : ptr(JS::SafelyInitialized<T>()) {}
@@ -109,17 +112,20 @@ class MOZ_RAII FakeRooted : public Roote
 
     void set(const T& value) {
         ptr = value;
     }
 
     FakeRooted(const FakeRooted&) = delete;
 };
 
-/** Interface substitute for MutableHandle<T> which is not required to point to rooted memory. */
+/**
+ * Interface substitute for MutableHandle<T> which is not required to point to
+ * rooted memory.
+ */
 template <typename T>
 class FakeMutableHandle : public js::MutableHandleBase<T, FakeMutableHandle<T>>
 {
   public:
     using ElementType = T;
 
     MOZ_IMPLICIT FakeMutableHandle(T* t) {
         ptr = t;
--- a/js/src/gc/WeakMap-inl.h
+++ b/js/src/gc/WeakMap-inl.h
@@ -239,17 +239,17 @@ WeakMap<K, V>::sweep()
 
 #if DEBUG
     // Once we've swept, all remaining edges should stay within the known-live
     // part of the graph.
     assertEntriesNotAboutToBeFinalized();
 #endif
 }
 
-/* memberOf can be nullptr, which means that the map is not part of a JSObject. */
+// memberOf can be nullptr, which means that the map is not part of a JSObject.
 template <class K, class V>
 void
 WeakMap<K, V>::traceMappings(WeakMapTracer* tracer)
 {
     for (Range r = Base::all(); !r.empty(); r.popFront()) {
         gc::Cell* key = gc::ToMarkable(r.front().key());
         gc::Cell* value = gc::ToMarkable(r.front().value());
         if (key && value) {
--- a/js/src/gc/WeakMap.h
+++ b/js/src/gc/WeakMap.h
@@ -178,17 +178,18 @@ class WeakMap : public HashMap<Key, Valu
 
     void sweep() override;
 
     void clearAndCompact() override {
         Base::clear();
         Base::compact();
     }
 
-    /* memberOf can be nullptr, which means that the map is not part of a JSObject. */
+    // memberOf can be nullptr, which means that the map is not part of a
+    // JSObject.
     void traceMappings(WeakMapTracer* tracer) override;
 
   protected:
 #if DEBUG
     void assertEntriesNotAboutToBeFinalized();
 #endif
 };
 
--- a/js/src/jit/InlineList.h
+++ b/js/src/jit/InlineList.h
@@ -484,20 +484,19 @@ class InlineListReverseIterator
     bool operator ==(const InlineListReverseIterator<T>& where) const {
         return iter == where.iter;
     }
 
   private:
     Node* iter;
 };
 
-/* This list type is more or less exactly an InlineForwardList without a sentinel
- * node. It is useful in cases where you are doing algorithms that deal with many
- * merging singleton lists, rather than often empty ones.
- */
+// This list type is more or less exactly an InlineForwardList without a
+// sentinel node. It is useful in cases where you are doing algorithms that deal
+// with many merging singleton lists, rather than often empty ones.
 template <typename T> class InlineConcatListIterator;
 template <typename T>
 class InlineConcatList
 {
   private:
     typedef InlineConcatList<T> Node;
 
     InlineConcatList<T>* thisFromConstructor() {
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -3113,30 +3113,31 @@ DeepFreezeSlot(JSContext* cx, const Valu
 
 JS_PUBLIC_API bool
 JS_DeepFreezeObject(JSContext* cx, HandleObject obj)
 {
     AssertHeapIsIdle();
     CHECK_THREAD(cx);
     cx->check(obj);
 
-    /* Assume that non-extensible objects are already deep-frozen, to avoid divergence. */
+    // Assume that non-extensible objects are already deep-frozen, to avoid
+    // divergence.
     bool extensible;
     if (!IsExtensible(cx, obj, &extensible)) {
         return false;
     }
     if (!extensible) {
         return true;
     }
 
     if (!FreezeObject(cx, obj)) {
         return false;
     }
 
-    /* Walk slots in obj and if any value is a non-null object, seal it. */
+    // Walk slots in obj and if any value is a non-null object, seal it.
     if (obj->isNative()) {
         RootedNativeObject nobj(cx, &obj->as<NativeObject>());
         for (uint32_t i = 0, n = nobj->slotSpan(); i < n; ++i) {
             if (!DeepFreezeSlot(cx, nobj->getSlot(i))) {
                 return false;
             }
         }
         for (uint32_t i = 0, n = nobj->getDenseInitializedLength(); i < n; ++i) {
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -1861,17 +1861,20 @@ JS_IsNative(JSObject* obj);
 
 /**
  * Unlike JS_NewObject, JS_NewObjectWithGivenProto does not compute a default
  * proto. If proto is nullptr, the JS object will have `null` as [[Prototype]].
  */
 extern JS_PUBLIC_API JSObject*
 JS_NewObjectWithGivenProto(JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
 
-/** Creates a new plain object, like `new Object()`, with Object.prototype as [[Prototype]]. */
+/**
+ * Creates a new plain object, like `new Object()`, with Object.prototype as
+ * [[Prototype]].
+ */
 extern JS_PUBLIC_API JSObject*
 JS_NewPlainObject(JSContext* cx);
 
 /**
  * Freeze obj, and all objects it refers to, recursively. This will not recurse
  * through non-extensible objects, on the assumption that those are already
  * deep-frozen.
  */
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -2549,17 +2549,18 @@ static MOZ_ALWAYS_INLINE jsid
 NON_INTEGER_ATOM_TO_JSID(JSString* atom)
 {
     MOZ_ASSERT(((size_t)atom & JSID_TYPE_MASK) == 0);
     jsid id = JSID_FROM_BITS((size_t)atom | JSID_TYPE_STRING);
     MOZ_ASSERT(js::detail::IdMatchesAtom(id, atom));
     return id;
 }
 
-/* All strings stored in jsids are atomized, but are not necessarily property names. */
+// All strings stored in jsids are atomized, but are not necessarily property
+// names.
 static MOZ_ALWAYS_INLINE bool
 JSID_IS_ATOM(jsid id)
 {
     return JSID_IS_STRING(id);
 }
 
 static MOZ_ALWAYS_INLINE bool
 JSID_IS_ATOM(jsid id, JSAtom* atom)
--- a/js/src/jsnum.cpp
+++ b/js/src/jsnum.cpp
@@ -1325,20 +1325,18 @@ js::InitNumberClass(JSContext* cx, Handl
     if (!ctor) {
         return nullptr;
     }
 
     if (!LinkConstructorAndPrototype(cx, ctor, numberProto)) {
         return nullptr;
     }
 
-    /*
-     * Our NaN must be one particular canonical value, because we rely on NaN
-     * encoding for our value representation.  See Value.h.
-     */
+    // Our NaN must be one particular canonical value, because we rely on NaN
+    // encoding for our value representation.  See Value.h.
     static const JSConstDoubleSpec number_constants[] = {
         // clang-format off
         {"NaN",               GenericNaN()               },
         {"POSITIVE_INFINITY", mozilla::PositiveInfinity<double>() },
         {"NEGATIVE_INFINITY", mozilla::NegativeInfinity<double>() },
         {"MAX_VALUE",         1.7976931348623157E+308    },
         {"MIN_VALUE",         MinNumberValue<double>()   },
         /* ES6 (April 2014 draft) 20.1.2.6 */
@@ -1346,61 +1344,62 @@ js::InitNumberClass(JSContext* cx, Handl
         /* ES6 (April 2014 draft) 20.1.2.10 */
         {"MIN_SAFE_INTEGER", -9007199254740991,          },
         /* ES6 (May 2013 draft) 15.7.3.7 */
         {"EPSILON", 2.2204460492503130808472633361816e-16},
         {0,0}
         // clang-format on
     };
 
-    /* Add numeric constants (MAX_VALUE, NaN, &c.) to the Number constructor. */
+    // Add numeric constants (MAX_VALUE, NaN, &c.) to the Number constructor.
     if (!JS_DefineConstDoubles(cx, ctor, number_constants)) {
         return nullptr;
     }
 
     if (!DefinePropertiesAndFunctions(cx, ctor, nullptr, number_static_methods)) {
         return nullptr;
     }
 
     if (!DefinePropertiesAndFunctions(cx, numberProto, nullptr, number_methods)) {
         return nullptr;
     }
 
     if (!JS_DefineFunctions(cx, global, number_functions)) {
         return nullptr;
     }
 
-    /* Number.parseInt should be the same function object as global parseInt. */
+    // Number.parseInt should be the same function object as global parseInt.
     RootedId parseIntId(cx, NameToId(cx->names().parseInt));
     JSFunction* parseInt = DefineFunction(cx, global, parseIntId, num_parseInt, 2,
                                           JSPROP_RESOLVING);
     if (!parseInt) {
         return nullptr;
     }
     RootedValue parseIntValue(cx, ObjectValue(*parseInt));
     if (!DefineDataProperty(cx, ctor, parseIntId, parseIntValue, 0)) {
         return nullptr;
     }
 
-    /* Number.parseFloat should be the same function object as global parseFloat. */
+    // Number.parseFloat should be the same function object as global
+    // parseFloat.
     RootedId parseFloatId(cx, NameToId(cx->names().parseFloat));
     JSFunction* parseFloat = DefineFunction(cx, global, parseFloatId, num_parseFloat, 1,
                                             JSPROP_RESOLVING);
     if (!parseFloat) {
         return nullptr;
     }
     RootedValue parseFloatValue(cx, ObjectValue(*parseFloat));
     if (!DefineDataProperty(cx, ctor, parseFloatId, parseFloatValue, 0)) {
         return nullptr;
     }
 
     RootedValue valueNaN(cx, cx->runtime()->NaNValue);
     RootedValue valueInfinity(cx, cx->runtime()->positiveInfinityValue);
 
-    /* ES5 15.1.1.1, 15.1.1.2 */
+    // ES5 15.1.1.1, 15.1.1.2
     if (!NativeDefineDataProperty(cx, global, cx->names().NaN, valueNaN,
                                   JSPROP_PERMANENT | JSPROP_READONLY | JSPROP_RESOLVING) ||
         !NativeDefineDataProperty(cx, global, cx->names().Infinity, valueInfinity,
                                   JSPROP_PERMANENT | JSPROP_READONLY | JSPROP_RESOLVING))
     {
         return nullptr;
     }
 
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -9871,17 +9871,18 @@ dom_constructor(JSContext* cx, unsigned 
 
     args.rval().setObject(*domObj);
     return true;
 }
 
 static bool
 InstanceClassHasProtoAtDepth(const Class* clasp, uint32_t protoID, uint32_t depth)
 {
-    /* There's only a single (fake) DOM object in the shell, so just return true. */
+    // There's only a single (fake) DOM object in the shell, so just return
+    // true.
     return true;
 }
 
 class ScopedFileDesc
 {
     intptr_t fd_;
   public:
     enum LockType { READ_LOCK, WRITE_LOCK };
--- a/js/src/shell/jsoptparse.cpp
+++ b/js/src/shell/jsoptparse.cpp
@@ -360,31 +360,33 @@ OptionParser::handleArg(size_t argc, cha
 
     switch (arg->kind) {
       case OptionKindString:
         arg->asStringOption()->value = argv[*i];
         nextArgument += 1;
         return Okay;
       case OptionKindMultiString:
       {
-        /* Don't advance the next argument -- there can only be one (final) variadic argument. */
+        // Don't advance the next argument -- there can only be one (final)
+        // variadic argument.
         StringArg value(argv[*i], *i);
         return arg->asMultiStringOption()->strings.append(value) ? Okay : Fail;
       }
       default:
         MOZ_CRASH("unhandled argument kind");
     }
 }
 
 OptionParser::Result
 OptionParser::parseArgs(int inputArgc, char** argv)
 {
     MOZ_ASSERT(inputArgc >= 0);
     size_t argc = inputArgc;
-    /* Permit a "no more options" capability, like |--| offers in many shell interfaces. */
+    // Permit a "no more options" capability, like |--| offers in many shell
+    // interfaces.
     bool optionsAllowed = true;
 
     for (size_t i = 1; i < argc; ++i) {
         char* arg = argv[i];
         Result r;
         /* Note: solo dash option is actually a 'stdin' argument. */
         if (arg[0] == '-' && arg[1] != '\0' && optionsAllowed) {
             /* Option. */
--- a/js/src/vm/ArrayBufferObject-inl.h
+++ b/js/src/vm/ArrayBufferObject-inl.h
@@ -2,17 +2,18 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef vm_ArrayBufferObject_inl_h
 #define vm_ArrayBufferObject_inl_h
 
-/* Utilities and common inline code for ArrayBufferObject and SharedArrayBufferObject */
+// Utilities and common inline code for ArrayBufferObject and
+// SharedArrayBufferObject.
 
 #include "vm/ArrayBufferObject.h"
 
 #include "js/Value.h"
 
 #include "vm/SharedArrayObject.h"
 #include "vm/SharedMem.h"
 
--- a/js/src/vm/BytecodeUtil.h
+++ b/js/src/vm/BytecodeUtil.h
@@ -250,17 +250,18 @@ GET_UINT32_INDEX(const jsbytecode* pc)
 }
 
 static MOZ_ALWAYS_INLINE void
 SET_UINT32_INDEX(jsbytecode* pc, uint32_t index)
 {
     SET_UINT32(pc, index);
 }
 
-/* Index limit is determined by SN_4BYTE_OFFSET_FLAG, see frontend/BytecodeEmitter.h. */
+// Index limit is determined by SN_4BYTE_OFFSET_FLAG, see
+// frontend/BytecodeEmitter.h.
 static const unsigned INDEX_LIMIT_LOG2  = 31;
 static const uint32_t INDEX_LIMIT       = uint32_t(1) << INDEX_LIMIT_LOG2;
 
 static inline jsbytecode
 ARGC_HI(uint16_t argc)
 {
     return UINT16_HI(argc);
 }
--- a/js/src/vm/Caches.h
+++ b/js/src/vm/Caches.h
@@ -203,17 +203,18 @@ class NewObjectCache
         uintptr_t hash = (uintptr_t(clasp) ^ uintptr_t(key)) + size_t(kind);
         return hash % mozilla::ArrayLength(entries);
     }
 
     bool lookup(const Class* clasp, gc::Cell* key, gc::AllocKind kind, EntryIndex* pentry) {
         *pentry = makeIndex(clasp, key, kind);
         Entry* entry = &entries[*pentry];
 
-        /* N.B. Lookups with the same clasp/key but different kinds map to different entries. */
+        // N.B. Lookups with the same clasp/key but different kinds map to
+        // different entries.
         return entry->clasp == clasp && entry->key == key;
     }
 
     void fill(EntryIndex entry_, const Class* clasp, gc::Cell* key, gc::AllocKind kind,
               NativeObject* obj) {
         MOZ_ASSERT(unsigned(entry_) < mozilla::ArrayLength(entries));
         MOZ_ASSERT(entry_ == makeIndex(clasp, key, kind));
         Entry* entry = &entries[entry_];
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -9325,17 +9325,18 @@ DebuggerFrame::olderGetter(JSContext* cx
     if (!DebuggerFrame::getOlder(cx, frame, &result)) {
         return false;
     }
 
     args.rval().setObjectOrNull(result);
     return true;
 }
 
-/* The getter used for each element of frame.arguments. See DebuggerFrame_getArguments. */
+// The getter used for each element of frame.arguments.
+// See DebuggerFrame_getArguments.
 static bool
 DebuggerArguments_getArg(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     int32_t i = args.callee().as<JSFunction>().getExtendedSlot(0).toInt32();
 
     // Check that the this value is an Arguments object.
     RootedObject argsobj(cx, NonNullObject(cx, args.thisv()));
--- a/js/src/vm/Debugger.h
+++ b/js/src/vm/Debugger.h
@@ -146,26 +146,27 @@ class DebuggerWeakMap : private WeakMap<
 
     explicit DebuggerWeakMap(JSContext* cx)
         : Base(cx),
           zoneCounts(cx->zone()),
           compartment(cx->compartment())
     { }
 
   public:
-    /* Expose those parts of HashMap public interface that are used by Debugger methods. */
+    // Expose those parts of HashMap public interface that are used by Debugger
+    // methods.
 
     typedef typename Base::Entry Entry;
     typedef typename Base::Ptr Ptr;
     typedef typename Base::AddPtr AddPtr;
     typedef typename Base::Range Range;
     typedef typename Base::Enum Enum;
     typedef typename Base::Lookup Lookup;
 
-    /* Expose WeakMap public interface */
+    // Expose WeakMap public interface.
 
     using Base::lookup;
     using Base::lookupForAdd;
     using Base::remove;
     using Base::all;
     using Base::trace;
 
     template<typename KeyInput, typename ValueInput>
@@ -580,38 +581,39 @@ class Debugger : private mozilla::Linked
     typedef DebuggerWeakMap<JSScript*> ScriptWeakMap;
     ScriptWeakMap scripts;
 
     using LazyScriptWeakMap = DebuggerWeakMap<LazyScript*>;
     LazyScriptWeakMap lazyScripts;
 
     using LazyScriptVector = JS::GCVector<LazyScript*>;
 
-    /* The map from debuggee source script objects to their Debugger.Source instances. */
+    // The map from debuggee source script objects to their Debugger.Source
+    // instances.
     typedef DebuggerWeakMap<JSObject*, true> SourceWeakMap;
     SourceWeakMap sources;
 
-    /* The map from debuggee objects to their Debugger.Object instances. */
+    // The map from debuggee objects to their Debugger.Object instances.
     typedef DebuggerWeakMap<JSObject*> ObjectWeakMap;
     ObjectWeakMap objects;
 
-    /* The map from debuggee Envs to Debugger.Environment instances. */
+    // The map from debuggee Envs to Debugger.Environment instances.
     ObjectWeakMap environments;
 
-    /* The map from WasmInstanceObjects to synthesized Debugger.Script instances. */
+    // The map from WasmInstanceObjects to synthesized Debugger.Script
+    // instances.
     typedef DebuggerWeakMap<WasmInstanceObject*> WasmInstanceWeakMap;
     WasmInstanceWeakMap wasmInstanceScripts;
 
-    /* The map from WasmInstanceObjects to synthesized Debugger.Source instances. */
+    // The map from WasmInstanceObjects to synthesized Debugger.Source
+    // instances.
     WasmInstanceWeakMap wasmInstanceSources;
 
-    /*
-     * Keep track of tracelogger last drained identifiers to know if there are
-     * lost events.
-     */
+    // Keep track of tracelogger last drained identifiers to know if there are
+    // lost events.
 #ifdef NIGHTLY_BUILD
     uint32_t traceLoggerLastDrainedSize;
     uint32_t traceLoggerLastDrainedIteration;
 #endif
     uint32_t traceLoggerScriptedCallsLastDrainedSize;
     uint32_t traceLoggerScriptedCallsLastDrainedIteration;
 
     class QueryBase;
--- a/js/src/vm/EnvironmentObject.h
+++ b/js/src/vm/EnvironmentObject.h
@@ -26,21 +26,21 @@ typedef Handle<ModuleObject*> HandleModu
 
 /*
  * Return a shape representing the static scope containing the variable
  * accessed by the ALIASEDVAR op at 'pc'.
  */
 extern Shape*
 EnvironmentCoordinateToEnvironmentShape(JSScript* script, jsbytecode* pc);
 
-/* Return the name being accessed by the given ALIASEDVAR op. */
+// Return the name being accessed by the given ALIASEDVAR op.
 extern PropertyName*
 EnvironmentCoordinateName(EnvironmentCoordinateNameCache& cache, JSScript* script, jsbytecode* pc);
 
-/* Return the function script accessed by the given ALIASEDVAR op, or nullptr. */
+// Return the function script accessed by the given ALIASEDVAR op, or nullptr.
 extern JSScript*
 EnvironmentCoordinateFunctionScript(JSScript* script, jsbytecode* pc);
 
 
 /*** Environment objects *****************************************************/
 
 
 /*** Environment objects *****************************************************/
--- a/js/src/vm/GeckoProfiler.cpp
+++ b/js/src/vm/GeckoProfiler.cpp
@@ -120,19 +120,18 @@ GeckoProfilerRuntime::enable(bool enable
 
     /* Toggle Gecko Profiler-related jumps on baseline jitcode.
      * The call to |ReleaseAllJITCode| above will release most baseline jitcode, but not
      * jitcode for scripts with active frames on the stack.  These scripts need to have
      * their profiler state toggled so they behave properly.
      */
     jit::ToggleBaselineProfiling(rt, enabled);
 
-    /* Update lastProfilingFrame to point to the top-most JS jit-frame currently on
-     * stack.
-     */
+    // Update lastProfilingFrame to point to the top-most JS jit-frame currently
+    // on stack.
     if (cx->jitActivation) {
         // Walk through all activations, and set their lastProfilingFrame appropriately.
         if (enabled) {
             Activation* act = cx->activation();
             void* lastProfilingFrame = GetTopProfilingJitFrame(act);
 
             jit::JitActivation* jitActivation = cx->jitActivation;
             while (jitActivation) {
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -2687,17 +2687,17 @@ CASE(JSOP_BINDNAME)
     ReservedRooted<JSObject*> envChain(&rootObject0);
     if (op == JSOP_BINDNAME || script->hasNonSyntacticScope()) {
         envChain.set(REGS.fp()->environmentChain());
     } else {
         envChain.set(&REGS.fp()->global().lexicalEnvironment());
     }
     ReservedRooted<PropertyName*> name(&rootName0, script->getName(REGS.pc));
 
-    /* Assigning to an undeclared name adds a property to the global object. */
+    // Assigning to an undeclared name adds a property to the global object.
     ReservedRooted<JSObject*> env(&rootObject1);
     if (!LookupNameUnqualified(cx, name, envChain, &env)) {
         goto error;
     }
 
     PUSH_OBJECT(*env);
 
     static_assert(JSOP_BINDNAME_LENGTH == JSOP_BINDGNAME_LENGTH,
--- a/js/src/vm/Iteration.cpp
+++ b/js/src/vm/Iteration.cpp
@@ -185,35 +185,37 @@ static bool
 EnumerateNativeProperties(JSContext* cx, HandleNativeObject pobj, unsigned flags,
                           MutableHandle<IdSet> visited, AutoIdVector* props,
                           Handle<UnboxedPlainObject*> unboxed = nullptr)
 {
     bool enumerateSymbols;
     if (flags & JSITER_SYMBOLSONLY) {
         enumerateSymbols = true;
     } else {
-        /* Collect any dense elements from this object. */
+        // Collect any dense elements from this object.
         size_t firstElemIndex = props->length();
         size_t initlen = pobj->getDenseInitializedLength();
         const Value* vp = pobj->getDenseElements();
         bool hasHoles = false;
         for (size_t i = 0; i < initlen; ++i, ++vp) {
             if (vp->isMagic(JS_ELEMENTS_HOLE)) {
                 hasHoles = true;
             } else {
-                /* Dense arrays never get so large that i would not fit into an integer id. */
+                // Dense arrays never get so large that i would not fit into an
+                // integer id.
                 if (!Enumerate<CheckForDuplicates>(cx, pobj, INT_TO_JSID(i),
                                                    /* enumerable = */ true, flags, visited, props))
                 {
                     return false;
                 }
             }
         }
 
-        /* Collect any typed array or shared typed array elements from this object. */
+        // Collect any typed array or shared typed array elements from this
+        // object.
         if (pobj->is<TypedArrayObject>()) {
             size_t len = pobj->as<TypedArrayObject>().length();
             for (size_t i = 0; i < len; i++) {
                 if (!Enumerate<CheckForDuplicates>(cx, pobj, INT_TO_JSID(i),
                                                    /* enumerable = */ true, flags, visited, props))
                 {
                     return false;
                 }
@@ -588,17 +590,18 @@ js::GetPropertyKeys(JSContext* cx, Handl
     return Snapshot(cx, obj,
                     flags & (JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS | JSITER_SYMBOLSONLY),
                     props);
 }
 
 static inline void
 RegisterEnumerator(ObjectRealm& realm, NativeIterator* ni)
 {
-    /* Register non-escaping native enumerators (for-in) with the current context. */
+    // Register non-escaping native enumerators (for-in) with the current
+    // context.
     ni->link(realm.enumerators);
 
     MOZ_ASSERT(!ni->isActive());
     ni->markActive();
 }
 
 static PropertyIteratorObject*
 NewPropertyIteratorObject(JSContext* cx)
--- a/js/src/vm/JSContext.h
+++ b/js/src/vm/JSContext.h
@@ -868,17 +868,18 @@ struct JSContext : public JS::RootingCon
     }
     void* addressOfJitStackLimit() {
         return &jitStackLimit;
     }
     void* addressOfJitStackLimitNoInterrupt() {
         return &jitStackLimitNoInterrupt;
     }
 
-    /* Futex state, used by Atomics.wait() and Atomics.wake() on the Atomics object */
+    // Futex state, used by Atomics.wait() and Atomics.wake() on the Atomics
+    // object.
     js::FutexThread fx;
 
     // Buffer for OSR from baseline to Ion. To avoid holding on to this for
     // too long, it's also freed in EnterBaseline (after returning from JIT code).
     js::ThreadData<uint8_t*> osrTempData_;
 
     uint8_t* allocateOsrTempData(size_t size);
     void freeOsrTempData();
--- a/js/src/vm/JSFunction.h
+++ b/js/src/vm/JSFunction.h
@@ -921,36 +921,31 @@ ThrowTypeErrorBehavior(JSContext* cx);
  * Most functions do not have these extensions, but enough do that efficient
  * storage is required (no malloc'ed reserved slots).
  */
 class FunctionExtended : public JSFunction
 {
   public:
     static const unsigned NUM_EXTENDED_SLOTS = 2;
 
-    /* Arrow functions store their lexical new.target in the first extended slot. */
+    // Arrow functions store their lexical new.target in the first extended
+    // slot.
     static const unsigned ARROW_NEWTARGET_SLOT = 0;
 
     static const unsigned METHOD_HOMEOBJECT_SLOT = 0;
 
-    /*
-     * Exported asm.js/wasm functions store their WasmInstanceObject in the
-     * first slot.
-     */
+    // Exported asm.js/wasm functions store their WasmInstanceObject in the
+    // first slot.
     static const unsigned WASM_INSTANCE_SLOT = 0;
 
-    /*
-     * wasm/asm.js exported functions store the wasm::TlsData pointer of their
-     * instance.
-     */
+    // wasm/asm.js exported functions store the wasm::TlsData pointer of their
+    // instance.
     static const unsigned WASM_TLSDATA_SLOT = 1;
 
-    /*
-     * asm.js module functions store their WasmModuleObject in the first slot.
-     */
+    // asm.js module functions store their WasmModuleObject in the first slot.
     static const unsigned ASMJS_MODULE_SLOT = 0;
 
 
     static inline size_t offsetOfExtendedSlot(unsigned which) {
         MOZ_ASSERT(which < NUM_EXTENDED_SLOTS);
         return offsetof(FunctionExtended, extendedSlots) + which * sizeof(GCPtrValue);
     }
     static inline size_t offsetOfArrowNewTargetSlot() {
--- a/js/src/vm/JSObject.cpp
+++ b/js/src/vm/JSObject.cpp
@@ -496,17 +496,18 @@ js::ReadPropertyDescriptors(JSContext* c
     return true;
 }
 
 /*** Seal and freeze *****************************************************************************/
 
 static unsigned
 GetSealedOrFrozenAttributes(unsigned attrs, IntegrityLevel level)
 {
-    /* Make all attributes permanent; if freezing, make data attributes read-only. */
+    // 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;
     }
     return JSPROP_PERMANENT;
 }
 
 /* ES6 draft rev 29 (6 Dec 2014) 7.3.13. */
 bool
--- a/js/src/vm/NativeObject.cpp
+++ b/js/src/vm/NativeObject.cpp
@@ -2500,17 +2500,18 @@ GetNonexistentProperty(JSContext* cx, Ha
     if (!bytes) {
         return false;
     }
 
     return JS_ReportErrorFlagsAndNumberUTF8(cx, flags, GetErrorMessage, nullptr,
                                             JSMSG_UNDEFINED_PROP, bytes.get());
 }
 
-/* The NoGC version of GetNonexistentProperty, present only to make types line up. */
+// The NoGC version of GetNonexistentProperty, present only to make types line
+// up.
 bool
 GetNonexistentProperty(JSContext* cx, const jsid& id, IsNameLookup nameLookup,
                        FakeMutableHandle<Value> vp)
 {
     return false;
 }
 
 static inline bool
--- a/js/src/vm/NativeObject.h
+++ b/js/src/vm/NativeObject.h
@@ -1113,17 +1113,18 @@ class NativeObject : public ShapedObject
         initSlot(index, v);
     }
 
     MOZ_ALWAYS_INLINE void setReservedSlot(uint32_t index, const Value& v) {
         MOZ_ASSERT(index < JSSLOT_FREE(getClass()));
         setSlot(index, v);
     }
 
-    /* For slots which are known to always be fixed, due to the way they are allocated. */
+    // For slots which are known to always be fixed, due to the way they are
+    // allocated.
 
     HeapSlot& getFixedSlotRef(uint32_t slot) {
         MOZ_ASSERT(slotIsFixed(slot));
         return fixedSlots()[slot];
     }
 
     const Value& getFixedSlot(uint32_t slot) const {
         MOZ_ASSERT(slotIsFixed(slot));
--- a/js/src/vm/RegExpObject.h
+++ b/js/src/vm/RegExpObject.h
@@ -194,17 +194,18 @@ class RegExpObject : public NativeObject
  * Parse regexp flags. Report an error and return false if an invalid
  * sequence of flags is encountered (repeat/invalid flag).
  *
  * N.B. flagStr must be rooted.
  */
 bool
 ParseRegExpFlags(JSContext* cx, JSString* flagStr, RegExpFlag* flagsOut);
 
-/* Assuming GetBuiltinClass(obj) is ESClass::RegExp, return a RegExpShared for obj. */
+// Assuming GetBuiltinClass(obj) is ESClass::RegExp, return a RegExpShared for
+// obj.
 inline RegExpShared*
 RegExpToShared(JSContext* cx, HandleObject obj)
 {
     if (obj->is<RegExpObject>()) {
         return RegExpObject::getShared(cx, obj.as<RegExpObject>());
     }
 
     return Proxy::regexp_toShared(cx, obj);
--- a/js/src/vm/Runtime.cpp
+++ b/js/src/vm/Runtime.cpp
@@ -227,17 +227,18 @@ JSRuntime::init(JSContext* cx, uint32_t 
 
     UniquePtr<Zone> atomsZone = MakeUnique<Zone>(this);
     if (!atomsZone || !atomsZone->init(true)) {
         return false;
     }
 
     gc.atomsZone = atomsZone.release();
 
-    /* The garbage collector depends on everything before this point being initialized. */
+    // The garbage collector depends on everything before this point being
+    // initialized.
     gcInitialized = true;
 
     if (!InitRuntimeNumberState(this)) {
         return false;
     }
 
     js::ResetTimeZoneInternal(ResetTimeZoneMode::DontResetIfOffsetUnchanged);
 
--- a/js/src/vm/Shape.h
+++ b/js/src/vm/Shape.h
@@ -353,30 +353,29 @@ class ShapeTable {
         entryCount_++;
         MOZ_ASSERT(entryCount_ + removedCount_ <= capacity());
     }
     void incRemovedCount() {
         removedCount_++;
         MOZ_ASSERT(entryCount_ + removedCount_ <= capacity());
     }
 
-    /* By definition, hashShift = HASH_BITS - log2(capacity). */
+    // By definition, hashShift = HASH_BITS - log2(capacity).
     uint32_t capacity() const { return JS_BIT(HASH_BITS - hashShift_); }
 
-    /* Whether we need to grow.  We want to do this if the load factor is >= 0.75 */
+    // Whether we need to grow.  We want to do this if the load factor
+    // is >= 0.75
     bool needsToGrow() const {
         uint32_t size = capacity();
         return entryCount_ + removedCount_ >= size - (size >> 2);
     }
 
-    /*
-     * Try to grow the table.  On failure, reports out of memory on cx
-     * and returns false.  This will make any extant pointers into the
-     * table invalid.  Don't call this unless needsToGrow() is true.
-     */
+    // Try to grow the table.  On failure, reports out of memory on cx
+    // and returns false.  This will make any extant pointers into the
+    // table invalid.  Don't call this unless needsToGrow() is true.
     bool grow(JSContext* cx);
 };
 
 // Ensures no shape tables are purged in the current zone.
 class MOZ_RAII AutoKeepShapeTables
 {
     JSContext* cx_;
     bool prev_;
@@ -775,17 +774,18 @@ class Shape : public gc::TenuredCell
     static inline Shape* searchNoHashify(Shape* start, jsid id);
 
     void removeFromDictionary(NativeObject* obj);
     void insertIntoDictionary(GCPtrShape* dictp);
 
     inline void initDictionaryShape(const StackShape& child, uint32_t nfixed,
                                     GCPtrShape* dictp);
 
-    /* Replace the base shape of the last shape in a non-dictionary lineage with base. */
+    // Replace the base shape of the last shape in a non-dictionary lineage with
+    // base.
     static Shape* replaceLastProperty(JSContext* cx, StackBaseShape& base,
                                       TaggedProto proto, HandleShape shape);
 
     /*
      * This function is thread safe if every shape in the lineage of |shape|
      * is thread local, which is the case when we clone the entire shape
      * lineage in preparation for converting an object to dictionary mode.
      */
--- a/js/src/vm/Stack.h
+++ b/js/src/vm/Stack.h
@@ -2300,17 +2300,17 @@ class NonBuiltinFrameIter : public Frame
 
     NonBuiltinFrameIter& operator++() {
         FrameIter::operator++();
         settle();
         return *this;
     }
 };
 
-/* A filtering of the ScriptFrameIter to only stop at non-self-hosted scripts. */
+// A filtering of the ScriptFrameIter to only stop at non-self-hosted scripts.
 class NonBuiltinScriptFrameIter : public ScriptFrameIter
 {
     void settle();
 
   public:
     explicit NonBuiltinScriptFrameIter(JSContext* cx,
                                        ScriptFrameIter::DebuggerEvalOption debuggerEvalOption =
                                        ScriptFrameIter::FOLLOW_DEBUGGER_EVAL_PREV_LINK)
--- a/js/src/vm/StringType.h
+++ b/js/src/vm/StringType.h
@@ -1161,18 +1161,18 @@ class JSFatInlineString : public JSInlin
                                               -1 /* null terminator */;
 
     template <typename CharT>
     inline CharT* init(size_t length);
 
     template<typename CharT>
     static bool lengthFits(size_t length);
 
-    /* Only called by the GC for strings with the AllocKind::FAT_INLINE_STRING kind. */
-
+    // Only called by the GC for strings with the AllocKind::FAT_INLINE_STRING
+    // kind.
     MOZ_ALWAYS_INLINE void finalize(js::FreeOp* fop);
 };
 
 static_assert(sizeof(JSFatInlineString) % js::gc::CellAlignBytes == 0,
               "fat inline strings shouldn't waste space up to the next cell "
               "boundary");
 
 class JSExternalString : public JSLinearString
@@ -1187,33 +1187,29 @@ class JSExternalString : public JSLinear
     static inline JSExternalString* new_(JSContext* cx, const char16_t* chars, size_t length,
                                          const JSStringFinalizer* fin);
 
     const JSStringFinalizer* externalFinalizer() const {
         MOZ_ASSERT(JSString::isExternal());
         return d.s.u3.externalFinalizer;
     }
 
-    /*
-     * External chars are never allocated inline or in the nursery, so we can
-     * safely expose this without requiring an AutoCheckCannotGC argument.
-     */
+    // External chars are never allocated inline or in the nursery, so we can
+    // safely expose this without requiring an AutoCheckCannotGC argument.
     const char16_t* twoByteChars() const {
         return rawTwoByteChars();
     }
 
-    /* Only called by the GC for strings with the AllocKind::EXTERNAL_STRING kind. */
-
+    // Only called by the GC for strings with the AllocKind::EXTERNAL_STRING
+    // kind.
     inline void finalize(js::FreeOp* fop);
 
-    /*
-     * Free the external chars and allocate a new buffer, converting this to a
-     * flat string (which still lives in an AllocKind::EXTERNAL_STRING
-     * arena).
-     */
+    // Free the external chars and allocate a new buffer, converting this to a
+    // flat string (which still lives in an AllocKind::EXTERNAL_STRING
+    // arena).
     JSFlatString* ensureFlat(JSContext* cx);
 
 #if defined(DEBUG) || defined(JS_JITSPEW)
     void dumpRepresentation(js::GenericPrinter& out, int indent) const;
 #endif
 };
 
 static_assert(sizeof(JSExternalString) == sizeof(JSString),
--- a/js/src/vm/TypeInference.cpp
+++ b/js/src/vm/TypeInference.cpp
@@ -3716,17 +3716,18 @@ js::TypeMonitorResult(JSContext* cx, JSS
     InferSpew(ISpewOps, "bytecodeType: %p %05zu: %s",
               script, script->pcToOffset(pc), TypeSet::TypeString(type).get());
     types->addType(sweep, cx, type);
 }
 
 void
 js::TypeMonitorResult(JSContext* cx, JSScript* script, jsbytecode* pc, const js::Value& rval)
 {
-    /* Allow the non-TYPESET scenario to simplify stubs used in compound opcodes. */
+    // Allow the non-TYPESET scenario to simplify stubs used in compound
+    // opcodes.
     if (!(CodeSpec[*pc].format & JOF_TYPESET)) {
         return;
     }
 
     if (!script->hasBaselineScript()) {
         return;
     }
 
--- a/js/src/vm/TypeSet.h
+++ b/js/src/vm/TypeSet.h
@@ -470,20 +470,24 @@ class TypeSet
         return flags & TYPE_FLAG_NON_CONSTANT_PROPERTY;
     }
     bool definiteProperty() const { return flags & TYPE_FLAG_DEFINITE_MASK; }
     unsigned definiteSlot() const {
         MOZ_ASSERT(definiteProperty());
         return (flags >> TYPE_FLAG_DEFINITE_SHIFT) - 1;
     }
 
-    /* Join two type sets into a new set. The result should not be modified further. */
+    // Join two type sets into a new set. The result should not be modified
+    // further.
     static TemporaryTypeSet* unionSets(TypeSet* a, TypeSet* b, LifoAlloc* alloc);
-    /* Return the intersection of the 2 TypeSets. The result should not be modified further */
+
+    // Return the intersection of the 2 TypeSets. The result should not be
+    // modified further.
     static TemporaryTypeSet* intersectSets(TemporaryTypeSet* a, TemporaryTypeSet* b, LifoAlloc* alloc);
+
     /*
      * Returns a copy of TypeSet a excluding/removing the types in TypeSet b.
      * TypeSet b can only contain primitives or be any object. No support for
      * specific objects. The result should not be modified further.
      */
     static TemporaryTypeSet* removeSet(TemporaryTypeSet* a, TemporaryTypeSet* b, LifoAlloc* alloc);
 
     /* Add a type to this set using the specified allocator. */
@@ -866,36 +870,36 @@ class TemporaryTypeSet : public TypeSet
     /*
      * Get the typed array type of all objects in this set, or Scalar::MaxTypedArrayViewType.
      * If there is such a common type and sharedness is not nullptr then
      * *sharedness is set to what we know about the sharedness of the memory.
      */
     Scalar::Type getTypedArrayType(CompilerConstraintList* constraints,
                                    TypedArraySharedness* sharedness = nullptr);
 
-    /* Whether all objects have JSCLASS_IS_DOMJSCLASS set. */
+    // Whether all objects have JSCLASS_IS_DOMJSCLASS set.
     bool isDOMClass(CompilerConstraintList* constraints, DOMObjectKind* kind);
 
-    /* Whether clasp->isCallable() is true for one or more objects in this set. */
+    // Whether clasp->isCallable() is true for one or more objects in this set.
     bool maybeCallable(CompilerConstraintList* constraints);
 
-    /* Whether clasp->emulatesUndefined() is true for one or more objects in this set. */
+    // Whether clasp->emulatesUndefined() is true for one or more objects in
+    // this set.
     bool maybeEmulatesUndefined(CompilerConstraintList* constraints);
 
-    /* Get the single value which can appear in this type set, otherwise nullptr. */
+    // Get the single value which can appear in this type set, otherwise
+    // nullptr.
     JSObject* maybeSingleton();
     ObjectKey* maybeSingleObject();
 
-    /* Whether any objects in the type set needs a barrier on id. */
+    // Whether any objects in the type set needs a barrier on id.
     bool propertyNeedsBarrier(CompilerConstraintList* constraints, jsid id);
 
-    /*
-     * Whether this set contains all types in other, except (possibly) the
-     * specified type.
-     */
+    // Whether this set contains all types in other, except (possibly) the
+    // specified type.
     bool filtersType(const TemporaryTypeSet* other, Type type) const;
 
     enum DoubleConversion
     {
         /* All types in the set should use eager double conversion. */
         AlwaysConvertToDoubles,
 
         /* Some types in the set should use eager double conversion. */