Bug 525063 - Backing out js/src/ for violation of committing guideliens. CLOSED TREE
authorTristan Bourvon <tbourvon@mozilla.com>
Wed, 11 Apr 2018 23:19:53 +0200
changeset 412830 6ff8aaef28669cc3945291a182232680481256da
parent 412829 f041c724fb809d3c927000e38bf67034d3a3930e
child 412857 1a9a362b9288cb36b4bf3f3b04550e9586474617
push id102018
push usertristanbourvon@gmail.com
push dateWed, 11 Apr 2018 21:20:36 +0000
treeherdermozilla-inbound@6ff8aaef2866 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs525063
milestone61.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 525063 - Backing out js/src/ for violation of committing guideliens. CLOSED TREE
js/src/builtin/Array.h
js/src/ds/InlineTable.h
js/src/ds/OrderedHashTable.h
js/src/frontend/BinSource.h
js/src/frontend/BinTokenReaderTester.cpp
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/NameCollections.h
js/src/frontend/Parser.cpp
js/src/frontend/TokenStream.h
js/src/gc/Heap.h
js/src/gc/Nursery.cpp
js/src/gc/Rooting.h
js/src/gc/Statistics.cpp
js/src/gc/Statistics.h
js/src/irregexp/RegExpEngine.cpp
js/src/irregexp/RegExpEngine.h
js/src/jit/BacktrackingAllocator.h
js/src/jit/BaselineFrameInfo.h
js/src/jit/BaselineJIT.cpp
js/src/jit/BytecodeAnalysis.cpp
js/src/jit/CodeGenerator.cpp
js/src/jit/CompileInfo.h
js/src/jit/Ion.cpp
js/src/jit/IonBuilder.cpp
js/src/jit/IonCode.h
js/src/jit/IonControlFlow.cpp
js/src/jit/IonOptimizationLevels.h
js/src/jit/JitCompartment.h
js/src/jit/JitFrames.cpp
js/src/jit/JitFrames.h
js/src/jit/JitcodeMap.h
js/src/jit/LIR.h
js/src/jit/MIRGraph.cpp
js/src/jit/MacroAssembler.cpp
js/src/jit/MoveResolver.cpp
js/src/jit/MoveResolver.h
js/src/jit/OptimizationTracking.h
js/src/jit/RangeAnalysis.cpp
js/src/jit/RegisterSets.h
js/src/jit/RematerializedFrame.cpp
js/src/jit/Safepoints.cpp
js/src/jit/ScalarReplacement.cpp
js/src/jit/StupidAllocator.h
js/src/jit/TypedObjectPrediction.h
js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
js/src/jit/shared/Lowering-shared.h
js/src/jit/x64/Assembler-x64.cpp
js/src/jit/x64/Bailouts-x64.cpp
js/src/jsapi-tests/testPrivateGCThingValue.cpp
js/src/jsapi-tests/tests.h
js/src/jsapi.cpp
js/src/jsfriendapi.h
js/src/vm/ArrayBufferObject.h
js/src/vm/BytecodeUtil.h
js/src/vm/Caches.h
js/src/vm/Compression.cpp
js/src/vm/Debugger.cpp
js/src/vm/JSCompartment.h
js/src/vm/JSScript.cpp
js/src/vm/JSScript.h
js/src/vm/ObjectGroup.h
js/src/vm/RegExpShared.h
js/src/vm/Scope.cpp
js/src/vm/Scope.h
js/src/vm/Shape.h
js/src/vm/Stack.cpp
js/src/vm/StructuredClone.cpp
js/src/vm/SymbolType.h
js/src/vm/TraceLogging.h
js/src/vm/TraceLoggingGraph.h
js/src/vm/TraceLoggingTypes.h
js/src/wasm/AsmJS.cpp
js/src/wasm/WasmBaselineCompile.cpp
js/src/wasm/WasmBinaryIterator.h
js/src/wasm/WasmFrameIter.cpp
js/src/wasm/WasmFrameIter.h
js/src/wasm/WasmJS.cpp
js/src/wasm/WasmTextToBinary.cpp
js/src/wasm/WasmTypes.h
--- a/js/src/builtin/Array.h
+++ b/js/src/builtin/Array.h
@@ -259,23 +259,17 @@ class MOZ_NON_TEMPORARY_CLASS ArraySpeci
     // Reset the cache.
     void reset();
 
     // Check if the global array-related objects have not been messed with
     // in a way that would disable this cache.
     bool isArrayStateStillSane();
 
   public:
-    ArraySpeciesLookup()
-      : arrayProto_{ nullptr }
-      , arrayConstructor_{ nullptr }
-      , arrayConstructorShape_{ nullptr }
-      , arrayProtoShape_{ nullptr }
-      , arrayProtoConstructorSlot_{} /* FIXME: initialize state_ */
-    {
+    ArraySpeciesLookup() {
         reset();
     }
 
     // Try to optimize the @@species lookup for an array.
     bool tryOptimizeArray(JSContext* cx, ArrayObject* array);
 
     // Purge the cache and all info associated with it.
     void purge() {
--- a/js/src/ds/InlineTable.h
+++ b/js/src/ds/InlineTable.h
@@ -113,36 +113,32 @@ class InlineTable
 
       protected:
         MOZ_INIT_OUTSIDE_CTOR Entry        entry_;
         MOZ_INIT_OUTSIDE_CTOR TablePtr     tablePtr_;
         MOZ_INIT_OUTSIDE_CTOR InlineEntry* inlPtr_;
         MOZ_INIT_OUTSIDE_CTOR bool         isInlinePtr_;
 
         explicit Ptr(TablePtr p)
-          : entry_(p.found() ? &*p : nullptr)
-          , tablePtr_(p)
-          , inlPtr_{ nullptr }
-          , isInlinePtr_(false)
+          : entry_(p.found() ? &*p : nullptr),
+            tablePtr_(p),
+            isInlinePtr_(false)
         { }
 
         explicit Ptr(InlineEntry* inlineEntry)
           : entry_(inlineEntry),
             inlPtr_(inlineEntry),
             isInlinePtr_(true)
         { }
 
         void operator==(const Ptr& other);
 
       public:
         // Leaves Ptr uninitialized.
-        Ptr()
-          : inlPtr_{ nullptr }
-          , isInlinePtr_{ false }
-        {
+        Ptr() {
 #ifdef DEBUG
             inlPtr_ = (InlineEntry*) 0xbad;
             isInlinePtr_ = true;
 #endif
         }
 
         // Default copy constructor works for this structure.
 
@@ -193,31 +189,23 @@ class InlineTable
         AddPtr(InlineEntry* ptr, bool found)
           : entry_(ptr),
             inlAddPtr_(ptr),
             isInlinePtr_(true),
             inlPtrFound_(found)
         {}
 
         explicit AddPtr(const TableAddPtr& p)
-          : entry_(p.found() ? &*p : nullptr)
-          , tableAddPtr_(p)
-          , inlAddPtr_{ nullptr }
-          , isInlinePtr_(false)
-          , inlPtrFound_{ false }
-        {
-        }
+          : entry_(p.found() ? &*p : nullptr),
+            tableAddPtr_(p),
+            isInlinePtr_(false)
+        { }
 
       public:
-        AddPtr()
-          : inlAddPtr_{ nullptr }
-          , isInlinePtr_{ false }
-          , inlPtrFound_{ false }
-        {
-        }
+        AddPtr() {}
 
         bool found() const {
             return isInlinePtr_ ? inlPtrFound_ : tableAddPtr_.found();
         }
 
         explicit operator bool() const {
             return found();
         }
--- a/js/src/ds/OrderedHashTable.h
+++ b/js/src/ds/OrderedHashTable.h
@@ -97,26 +97,23 @@ class OrderedHashTable
         for (Range* r = nurseryRanges; r; r = next) {
             next = r->next;
             f(r, arg);
         }
     }
 
   public:
     OrderedHashTable(AllocPolicy& ap, mozilla::HashCodeScrambler hcs)
-      : hashTable(nullptr)
-      , data(nullptr)
-      , dataLength(0)
-      , dataCapacity{}
-      , liveCount{}
-      , hashShift{}
-      , ranges(nullptr)
-      , nurseryRanges(nullptr)
-      , alloc(ap)
-      , hcs(hcs)
+      : hashTable(nullptr),
+        data(nullptr),
+        dataLength(0),
+        ranges(nullptr),
+        nurseryRanges(nullptr),
+        alloc(ap),
+        hcs(hcs)
     {}
 
     MOZ_MUST_USE bool init() {
         MOZ_ASSERT(!hashTable, "init must be called at most once");
 
         uint32_t buckets = initialBuckets();
         Data** tableAlloc = alloc.template pod_malloc<Data*>(buckets);
         if (!tableAlloc)
--- a/js/src/frontend/BinSource.h
+++ b/js/src/frontend/BinSource.h
@@ -51,19 +51,19 @@ class BinASTParser : private JS::AutoGCR
         , options_(options)
         , cx_(cx)
         , alloc_(alloc)
         , nodeAlloc_(cx, alloc)
         , keepAtoms_(cx)
         , parseContext_(nullptr)
         , usedNames_(usedNames)
         , factory_(cx, alloc, nullptr, SourceKind::Binary)
-    /* FIXME: initialize variableDeclarationKind_ */ {
-        cx_->frontendCollectionPool().addActiveCompilation();
-        tempPoolMark_ = alloc.mark();
+    {
+         cx_->frontendCollectionPool().addActiveCompilation();
+         tempPoolMark_ = alloc.mark();
     }
     ~BinASTParser()
     {
         alloc_.release(tempPoolMark_);
 
         /*
          * The parser can allocate enormous amounts of memory for large functions.
          * Eagerly free the memory now (which otherwise won't be freed until the
--- a/js/src/frontend/BinTokenReaderTester.cpp
+++ b/js/src/frontend/BinTokenReaderTester.cpp
@@ -12,34 +12,30 @@
 namespace js {
 namespace frontend {
 
 using BinFields = BinTokenReaderTester::BinFields;
 using AutoList = BinTokenReaderTester::AutoList;
 using AutoTaggedTuple = BinTokenReaderTester::AutoTaggedTuple;
 using AutoTuple = BinTokenReaderTester::AutoTuple;
 
-BinTokenReaderTester::BinTokenReaderTester(JSContext* cx,
-                                           const uint8_t* start,
-                                           const size_t length)
-  : cx_(cx)
-  , poisoned_{ false }
-  , start_(start)
-  , current_(start)
-  , stop_(start + length)
-  , latestKnownGoodPos_(0)
+BinTokenReaderTester::BinTokenReaderTester(JSContext* cx, const uint8_t* start, const size_t length)
+    : cx_(cx)
+    , start_(start)
+    , current_(start)
+    , stop_(start + length)
+    , latestKnownGoodPos_(0)
 { }
 
 BinTokenReaderTester::BinTokenReaderTester(JSContext* cx, const Vector<uint8_t>& chars)
-  : cx_(cx)
-  , poisoned_{ false }
-  , start_(chars.begin())
-  , current_(chars.begin())
-  , stop_(chars.end())
-  , latestKnownGoodPos_(0)
+    : cx_(cx)
+    , start_(chars.begin())
+    , current_(chars.begin())
+    , stop_(chars.end())
+    , latestKnownGoodPos_(0)
 { }
 
 bool
 BinTokenReaderTester::raiseError(const char* description)
 {
     MOZ_ASSERT(!cx_->isExceptionPending());
     TokenPos pos = this->pos();
     JS_ReportErrorASCII(cx_, "BinAST parsing error: %s at offsets %u => %u",
@@ -440,18 +436,17 @@ BinTokenReaderTester::pos(size_t start)
 
 void
 BinTokenReaderTester::AutoBase::init()
 {
     initialized_ = true;
 }
 
 BinTokenReaderTester::AutoBase::AutoBase(BinTokenReaderTester& reader)
-  : initialized_{ false }
-  , reader_(reader)
+    : reader_(reader)
 { }
 
 BinTokenReaderTester::AutoBase::~AutoBase()
 {
     // By now, the `AutoBase` must have been deinitialized by calling `done()`.
     // The only case in which we can accept not calling `done()` is if we have
     // bailed out because of an error.
     MOZ_ASSERT_IF(initialized_, reader_.cx_->isExceptionPending());
@@ -462,20 +457,18 @@ BinTokenReaderTester::AutoBase::checkPos
 {
     if (reader_.current_ != expectedEnd)
         return reader_.raiseError("Caller did not consume the expected set of bytes");
 
     return true;
 }
 
 BinTokenReaderTester::AutoList::AutoList(BinTokenReaderTester& reader)
-  : AutoBase(reader)
-  , expectedEnd_{ nullptr }
-{
-}
+    : AutoBase(reader)
+{ }
 
 void
 BinTokenReaderTester::AutoList::init(const uint8_t* expectedEnd)
 {
     AutoBase::init();
     this->expectedEnd_ = expectedEnd;
 }
 
--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -1569,28 +1569,25 @@ class MOZ_STACK_CLASS TryEmitter
     bool hasCatch() const {
         return kind_ == TryCatch || kind_ == TryCatchFinally;
     }
     bool hasFinally() const {
         return kind_ == TryCatchFinally || kind_ == TryFinally;
     }
 
   public:
-    TryEmitter(BytecodeEmitter* bce,
-               Kind kind,
-               ShouldUseRetVal retValKind = UseRetVal,
+    TryEmitter(BytecodeEmitter* bce, Kind kind, ShouldUseRetVal retValKind = UseRetVal,
                ShouldUseControl controlKind = UseControl)
-      : bce_(bce)
-      , kind_(kind)
-      , retValKind_(retValKind)
-      , depth_(0)
-      , noteIndex_(0)
-      , tryStart_(0)
-      , tryEnd_{}
-      , state_(Start)
+      : bce_(bce),
+        kind_(kind),
+        retValKind_(retValKind),
+        depth_(0),
+        noteIndex_(0),
+        tryStart_(0),
+        state_(Start)
     {
         if (controlKind == UseControl)
             controlInfo_.emplace(bce_, hasFinally() ? StatementKind::Finally : StatementKind::Try);
         finallyStart_.offset = 0;
     }
 
     bool emitJumpOverCatchAndFinally() {
         if (!bce_->emitJump(JSOP_GOTO, &catchAndFinallyJump_))
@@ -2140,54 +2137,50 @@ class ForOfLoopControl : public LoopCont
                 return false;
         }
 
         return true;
     }
 };
 
 BytecodeEmitter::BytecodeEmitter(BytecodeEmitter* parent,
-                                 const EitherParser<FullParseHandler>& parser,
-                                 SharedContext* sc,
-                                 HandleScript script,
-                                 Handle<LazyScript*> lazyScript,
-                                 uint32_t lineNum,
-                                 EmitterMode emitterMode)
-  : sc(sc)
-  , cx(sc->context)
-  , parent(parent)
-  , script(cx, script)
-  , lazyScript(cx, lazyScript)
-  , prologue(cx, lineNum)
-  , main(cx, lineNum)
-  , current(&main)
-  , parser(parser)
-  , atomIndices(cx->frontendCollectionPool())
-  , firstLine(lineNum)
-  , maxFixedSlots(0)
-  , maxStackDepth(0)
-  , stackDepth(0)
-  , emitLevel(0)
-  , bodyScopeIndex(UINT32_MAX)
-  , varEmitterScope(nullptr)
-  , innermostNestableControl(nullptr)
-  , innermostEmitterScope(nullptr)
-  , innermostTDZCheckCache(nullptr)
-  , constList(cx)
-  , scopeList(cx)
-  , tryNoteList(cx)
-  , scopeNoteList(cx)
-  , yieldAndAwaitOffsetList(cx)
-  , typesetCount(0)
-  , hasSingletons(false)
-  , hasTryFinally(false)
-  , emittingRunOnceLambda(false)
-  , emitterMode(emitterMode)
-  , functionBodyEndPos{}
-  , functionBodyEndPosSet(false)
+                                 const EitherParser<FullParseHandler>& parser, SharedContext* sc,
+                                 HandleScript script, Handle<LazyScript*> lazyScript,
+                                 uint32_t lineNum, EmitterMode emitterMode)
+  : sc(sc),
+    cx(sc->context),
+    parent(parent),
+    script(cx, script),
+    lazyScript(cx, lazyScript),
+    prologue(cx, lineNum),
+    main(cx, lineNum),
+    current(&main),
+    parser(parser),
+    atomIndices(cx->frontendCollectionPool()),
+    firstLine(lineNum),
+    maxFixedSlots(0),
+    maxStackDepth(0),
+    stackDepth(0),
+    emitLevel(0),
+    bodyScopeIndex(UINT32_MAX),
+    varEmitterScope(nullptr),
+    innermostNestableControl(nullptr),
+    innermostEmitterScope(nullptr),
+    innermostTDZCheckCache(nullptr),
+    constList(cx),
+    scopeList(cx),
+    tryNoteList(cx),
+    scopeNoteList(cx),
+    yieldAndAwaitOffsetList(cx),
+    typesetCount(0),
+    hasSingletons(false),
+    hasTryFinally(false),
+    emittingRunOnceLambda(false),
+    emitterMode(emitterMode),
+    functionBodyEndPosSet(false)
 {
     MOZ_ASSERT_IF(emitterMode == LazyFunction, lazyScript);
 }
 
 BytecodeEmitter::BytecodeEmitter(BytecodeEmitter* parent,
                                  const EitherParser<FullParseHandler>& parser, SharedContext* sc,
                                  HandleScript script, Handle<LazyScript*> lazyScript,
                                  TokenPos bodyPosition, EmitterMode emitterMode)
--- a/js/src/frontend/NameCollections.h
+++ b/js/src/frontend/NameCollections.h
@@ -108,19 +108,17 @@ struct RecyclableAtomMapValueWrapper
         uint64_t dummy;
     };
 
     static void assertInvariant() {
         static_assert(sizeof(Wrapped) <= sizeof(uint64_t),
                       "Can only recycle atom maps with values smaller than uint64");
     }
 
-    RecyclableAtomMapValueWrapper()
-      : dummy{}
-    {
+    RecyclableAtomMapValueWrapper() {
         assertInvariant();
     }
 
     MOZ_IMPLICIT RecyclableAtomMapValueWrapper(Wrapped w)
       : wrapped(w)
     {
         assertInvariant();
     }
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -839,27 +839,25 @@ ParserBase::~ParserBase()
      * Eagerly free the memory now (which otherwise won't be freed until the
      * next GC) to avoid unnecessary OOMs.
      */
     alloc.freeAllIfHugeAndUnused();
 
     context->frontendCollectionPool().removeActiveCompilation();
 }
 
-template<class ParseHandler>
-PerHandlerParser<ParseHandler>::PerHandlerParser(JSContext* cx,
-                                                 LifoAlloc& alloc,
+template <class ParseHandler>
+PerHandlerParser<ParseHandler>::PerHandlerParser(JSContext* cx, LifoAlloc& alloc,
                                                  const ReadOnlyCompileOptions& options,
-                                                 bool foldConstants,
-                                                 UsedNameTracker& usedNames,
+                                                 bool foldConstants, UsedNameTracker& usedNames,
                                                  LazyScript* lazyOuterFunction)
-  : ParserBase(cx, alloc, options, foldConstants, usedNames)
-  , handler(cx, alloc, lazyOuterFunction)
-  , internalSyntaxParser_{ nullptr }
-{
+  : ParserBase(cx, alloc, options, foldConstants, usedNames),
+    handler(cx, alloc, lazyOuterFunction)
+{
+
 }
 
 template <class ParseHandler, typename CharT>
 GeneralParser<ParseHandler, CharT>::GeneralParser(JSContext* cx, LifoAlloc& alloc,
                                                   const ReadOnlyCompileOptions& options,
                                                   const CharT* chars, size_t length,
                                                   bool foldConstants,
                                                   UsedNameTracker& usedNames,
--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -188,21 +188,17 @@ struct KeywordInfo;
 
 namespace js {
 namespace frontend {
 
 struct TokenPos {
     uint32_t    begin;  // Offset of the token's first char.
     uint32_t    end;    // Offset of 1 past the token's last char.
 
-    TokenPos()
-      : begin{}
-      , end{}
-    {
-    }
+    TokenPos() {}
     TokenPos(uint32_t begin, uint32_t end) : begin(begin), end(end) {}
 
     // Return a TokenPos that covers left, right, and anything in between.
     static TokenPos box(const TokenPos& left, const TokenPos& right) {
         MOZ_ASSERT(left.begin <= left.end);
         MOZ_ASSERT(left.end <= right.begin);
         MOZ_ASSERT(right.begin <= right.end);
         return TokenPos(left.begin, right.end);
--- a/js/src/gc/Heap.h
+++ b/js/src/gc/Heap.h
@@ -482,28 +482,22 @@ FreeSpan::checkRange(uintptr_t first, ui
  * The tail of the chunk info is shared between all chunks in the system, both
  * nursery and tenured. This structure is locatable from any GC pointer by
  * aligning to 1MiB.
  */
 struct ChunkTrailer
 {
     // Construct a Nursery ChunkTrailer.
     ChunkTrailer(JSRuntime* rt, StoreBuffer* sb)
-      : location(ChunkLocation::Nursery)
-      , padding{}
-      , storeBuffer(sb)
-      , runtime(rt)
+      : location(ChunkLocation::Nursery), storeBuffer(sb), runtime(rt)
     {}
 
     // Construct a Tenured heap ChunkTrailer.
     explicit ChunkTrailer(JSRuntime* rt)
-      : location(ChunkLocation::TenuredHeap)
-      , padding{}
-      , storeBuffer(nullptr)
-      , runtime(rt)
+      : location(ChunkLocation::TenuredHeap), storeBuffer(nullptr), runtime(rt)
     {}
 
   public:
     // The index of the chunk in the nursery, or LocationTenuredHeap.
     ChunkLocation   location;
     uint32_t        padding;
 
     // The store buffer for pointers from tenured things to things in this
--- a/js/src/gc/Nursery.cpp
+++ b/js/src/gc/Nursery.cpp
@@ -128,17 +128,16 @@ js::Nursery::Nursery(JSRuntime* rt)
   , chunkCountLimit_(0)
   , timeInChunkAlloc_(0)
   , previousPromotionRate_(0)
   , profileThreshold_(0)
   , enableProfiling_(false)
   , canAllocateStrings_(false)
   , reportTenurings_(0)
   , minorGCTriggerReason_(JS::gcreason::NO_REASON)
-  , previousGC{}
   , freeMallocedBuffersTask(nullptr)
 #ifdef JS_GC_ZEAL
   , lastCanary_(nullptr)
 #endif
 {
     const char* env = getenv("MOZ_NURSERY_STRINGS");
     if (env && *env)
         canAllocateStrings_ = (*env == '1');
--- a/js/src/gc/Rooting.h
+++ b/js/src/gc/Rooting.h
@@ -128,20 +128,17 @@ class FakeMutableHandle : public js::Mut
         *ptr = v;
     }
 
     DECLARE_POINTER_CONSTREF_OPS(T);
     DECLARE_NONPOINTER_ACCESSOR_METHODS(*ptr);
     DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODS(*ptr);
 
   private:
-    FakeMutableHandle()
-      : ptr{ nullptr }
-    {
-    }
+    FakeMutableHandle() {}
     DELETE_ASSIGNMENT_OPS(FakeMutableHandle, T);
 
     T* ptr;
 };
 
 template <typename T> class MaybeRooted<T, NoGC>
 {
   public:
--- a/js/src/gc/Statistics.cpp
+++ b/js/src/gc/Statistics.cpp
@@ -690,33 +690,29 @@ Statistics::formatJsonPhaseTimes(const P
     for (auto phase : AllPhases()) {
         TimeDuration ownTime = phaseTimes[phase];
         if (!ownTime.IsZero())
             json.property(phases[phase].path, ownTime, JSONPrinter::MILLISECONDS);
     }
 }
 
 Statistics::Statistics(JSRuntime* rt)
-  : runtime(rt)
-  , fp(nullptr)
-  , gckind{ GC_NORMAL }
-  , nonincrementalReason_(gc::AbortReason::None)
-  , preBytes(0)
-  , thresholdTriggered(false)
-  , triggerAmount(0.0)
-  , triggerThreshold(0.0)
-  , startingMinorGCNumber{}
-  , startingMajorGCNumber{}
-  , startingSliceNumber{}
-  , maxPauseInInterval(0)
-  , sliceCallback(nullptr)
-  , nurseryCollectionCallback(nullptr)
-  , aborted(false)
-  , enableProfiling_(false)
-  , sliceCount_(0)
+  : runtime(rt),
+    fp(nullptr),
+    nonincrementalReason_(gc::AbortReason::None),
+    preBytes(0),
+    thresholdTriggered(false),
+    triggerAmount(0.0),
+    triggerThreshold(0.0),
+    maxPauseInInterval(0),
+    sliceCallback(nullptr),
+    nurseryCollectionCallback(nullptr),
+    aborted(false),
+    enableProfiling_(false),
+    sliceCount_(0)
 {
     for (auto& count : counts)
         count = 0;
     PodZero(&totalTimes_);
 
     MOZ_ALWAYS_TRUE(phaseStack.reserve(MAX_PHASE_NESTING));
     MOZ_ALWAYS_TRUE(suspendedPhases.reserve(MAX_SUSPENDED_PHASES));
 
--- a/js/src/gc/Statistics.h
+++ b/js/src/gc/Statistics.h
@@ -213,31 +213,25 @@ struct Statistics
     TimeDuration clearMaxGCPauseAccumulator();
     TimeDuration getMaxGCPauseSinceClear();
 
     PhaseKind currentPhaseKind() const;
 
     static const size_t MAX_SUSPENDED_PHASES = MAX_PHASE_NESTING * 3;
 
     struct SliceData {
-        SliceData(SliceBudget budget,
-                  JS::gcreason::Reason reason,
-                  TimeStamp start,
-                  size_t startFaults,
-                  gc::State initialState)
-          : budget(budget)
-          , reason(reason)
-          , initialState(initialState)
-          , finalState(gc::State::NotActive)
-          , resetReason(gc::AbortReason::None)
-          , start(start)
-          , startFaults(startFaults)
-          , endFaults{}
-        {
-        }
+        SliceData(SliceBudget budget, JS::gcreason::Reason reason,
+                  TimeStamp start, size_t startFaults, gc::State initialState)
+          : budget(budget), reason(reason),
+            initialState(initialState),
+            finalState(gc::State::NotActive),
+            resetReason(gc::AbortReason::None),
+            start(start),
+            startFaults(startFaults)
+        {}
 
         SliceBudget budget;
         JS::gcreason::Reason reason;
         gc::State initialState, finalState;
         gc::AbortReason resetReason;
         TimeStamp start, end;
         size_t startFaults, endFaults;
         PhaseTimeTable phaseTimes;
--- a/js/src/irregexp/RegExpEngine.cpp
+++ b/js/src/irregexp/RegExpEngine.cpp
@@ -1641,35 +1641,29 @@ IsLatin1Equivalent(char16_t c, RegExpCom
 
     char16_t converted = ConvertNonLatin1ToLatin1(c, compiler->unicode());
 
     return converted != 0 && converted <= kMaxOneByteCharCode;
 }
 
 // Attempts to compile the regexp using an Irregexp code generator.  Returns
 // a fixed array or a null handle depending on whether it succeeded.
-RegExpCompiler::RegExpCompiler(JSContext* cx,
-                               LifoAlloc* alloc,
-                               int capture_count,
-                               bool ignore_case,
-                               bool latin1,
-                               bool match_only,
-                               bool unicode)
-  : next_register_(2 * (capture_count + 1))
-  , recursion_depth_(0)
-  , macro_assembler_{ nullptr }
-  , ignore_case_(ignore_case)
-  , latin1_(latin1)
-  , match_only_(match_only)
-  , unicode_(unicode)
-  , reg_exp_too_big_(false)
-  , current_expansion_factor_(1)
-  , frequency_collator_()
-  , cx_(cx)
-  , alloc_(alloc)
+RegExpCompiler::RegExpCompiler(JSContext* cx, LifoAlloc* alloc, int capture_count,
+                               bool ignore_case, bool latin1, bool match_only, bool unicode)
+  : next_register_(2 * (capture_count + 1)),
+    recursion_depth_(0),
+    ignore_case_(ignore_case),
+    latin1_(latin1),
+    match_only_(match_only),
+    unicode_(unicode),
+    reg_exp_too_big_(false),
+    current_expansion_factor_(1),
+    frequency_collator_(),
+    cx_(cx),
+    alloc_(alloc)
 {
     accept_ = alloc->newInfallible<EndNode>(alloc, EndNode::ACCEPT);
     MOZ_ASSERT(next_register_ - 1 <= RegExpMacroAssembler::kMaxRegister);
 }
 
 RegExpCode
 RegExpCompiler::Assemble(JSContext* cx,
                          RegExpMacroAssembler* assembler,
--- a/js/src/irregexp/RegExpEngine.h
+++ b/js/src/irregexp/RegExpEngine.h
@@ -680,19 +680,18 @@ class ActionNode : public SeqRegExpNode
         STORE_POSITION,
         BEGIN_SUBMATCH,
         POSITIVE_SUBMATCH_SUCCESS,
         EMPTY_MATCH_CHECK,
         CLEAR_CAPTURES
     };
 
     ActionNode(ActionType action_type, RegExpNode* on_success)
-      : SeqRegExpNode(on_success)
-      , data_{}
-      , action_type_(action_type)
+      : SeqRegExpNode(on_success),
+        action_type_(action_type)
     {}
 
     static ActionNode* SetRegister(int reg, int val, RegExpNode* on_success);
     static ActionNode* IncrementRegister(int reg, RegExpNode* on_success);
     static ActionNode* StorePosition(int reg,
                                      bool is_capture,
                                      RegExpNode* on_success);
     static ActionNode* ClearCaptures(Interval range, RegExpNode* on_success);
--- a/js/src/jit/BacktrackingAllocator.h
+++ b/js/src/jit/BacktrackingAllocator.h
@@ -526,21 +526,16 @@ class VirtualRegister
     // be introduced before the definition that relaxes the policy.
     bool mustCopyInput_;
 
     void operator=(const VirtualRegister&) = delete;
     VirtualRegister(const VirtualRegister&) = delete;
 
   public:
     explicit VirtualRegister()
-      : ins_{ nullptr }
-      , def_{ nullptr }
-      , isTemp_{ false }
-      , usedByPhi_{ false }
-      , mustCopyInput_{ false }
     {
         // Note: This class is zeroed before it is constructed.
     }
 
     void init(LNode* ins, LDefinition* def, bool isTemp) {
         MOZ_ASSERT(!ins_);
         ins_ = ins;
         def_ = def;
--- a/js/src/jit/BaselineFrameInfo.h
+++ b/js/src/jit/BaselineFrameInfo.h
@@ -51,18 +51,20 @@ class StackValue
     enum Kind {
         Constant,
         Register,
         Stack,
         LocalSlot,
         ArgSlot,
         ThisSlot,
         EvalNewTargetSlot
+#ifdef DEBUG
         // In debug builds, assert Kind is initialized.
         , Uninitialized
+#endif
     };
 
   private:
     Kind kind_;
 
     union {
         struct {
             JS::UninitializedValue v;
@@ -98,18 +100,20 @@ class StackValue
     bool isKnownBoolean() const {
         return hasKnownType(JSVAL_TYPE_BOOLEAN);
     }
     JSValueType knownType() const {
         MOZ_ASSERT(hasKnownType());
         return knownType_;
     }
     void reset() {
+#ifdef DEBUG
         kind_ = Uninitialized;
         knownType_ = JSVAL_TYPE_UNKNOWN;
+#endif
     }
     Value constant() const {
         MOZ_ASSERT(kind_ == Constant);
         return data.constant.v.asValueRef();
     }
     ValueOperand reg() const {
         MOZ_ASSERT(kind_ == Register);
         return *data.reg.reg.addr();
--- a/js/src/jit/BaselineJIT.cpp
+++ b/js/src/jit/BaselineJIT.cpp
@@ -53,55 +53,41 @@ void
 ICStubSpace::freeAllAfterMinorGC(Zone* zone)
 {
     if (zone->isAtomsZone())
         MOZ_ASSERT(allocator_.isEmpty());
     else
         zone->runtimeFromActiveCooperatingThread()->gc.freeAllLifoBlocksAfterMinorGC(&allocator_);
 }
 
-BaselineScript::BaselineScript(uint32_t prologueOffset,
-                               uint32_t epilogueOffset,
+BaselineScript::BaselineScript(uint32_t prologueOffset, uint32_t epilogueOffset,
                                uint32_t profilerEnterToggleOffset,
                                uint32_t profilerExitToggleOffset,
                                uint32_t postDebugPrologueOffset)
-  : method_(nullptr)
-  , templateEnv_(nullptr)
-  , fallbackStubSpace_()
-  , dependentWasmImports_(nullptr)
-  , prologueOffset_(prologueOffset)
-  , epilogueOffset_(epilogueOffset)
-  , profilerEnterToggleOffset_(profilerEnterToggleOffset)
-  , profilerExitToggleOffset_(profilerExitToggleOffset)
-  ,
+  : method_(nullptr),
+    templateEnv_(nullptr),
+    fallbackStubSpace_(),
+    dependentWasmImports_(nullptr),
+    prologueOffset_(prologueOffset),
+    epilogueOffset_(epilogueOffset),
+    profilerEnterToggleOffset_(profilerEnterToggleOffset),
+    profilerExitToggleOffset_(profilerExitToggleOffset),
 #ifdef JS_TRACE_LOGGING
 # ifdef DEBUG
-  traceLoggerScriptsEnabled_(false)
-  , traceLoggerEngineEnabled_(false)
-  ,
+    traceLoggerScriptsEnabled_(false),
+    traceLoggerEngineEnabled_(false),
 # endif
-  traceLoggerScriptEvent_()
-  ,
+    traceLoggerScriptEvent_(),
 #endif
-  postDebugPrologueOffset_(postDebugPrologueOffset)
-  , flags_(0)
-  , icEntriesOffset_{}
-  , icEntries_{}
-  , pcMappingIndexOffset_{}
-  , pcMappingIndexEntries_{}
-  , pcMappingOffset_{}
-  , pcMappingSize_{}
-  , bytecodeTypeMapOffset_{}
-  , yieldEntriesOffset_{}
-  , traceLoggerToggleOffsetsOffset_{}
-  , numTraceLoggerToggleOffsets_{}
-  , inlinedBytecodeLength_(0)
-  , maxInliningDepth_(UINT8_MAX)
-  , pendingBuilder_(nullptr)
-  , controlFlowGraph_(nullptr)
+    postDebugPrologueOffset_(postDebugPrologueOffset),
+    flags_(0),
+    inlinedBytecodeLength_(0),
+    maxInliningDepth_(UINT8_MAX),
+    pendingBuilder_(nullptr),
+    controlFlowGraph_(nullptr)
 { }
 
 static bool
 CheckFrame(InterpreterFrame* fp)
 {
     if (fp->isDebuggerEvalFrame()) {
         // Debugger eval-in-frame. These are likely short-running scripts so
         // don't bother compiling them for now.
--- a/js/src/jit/BytecodeAnalysis.cpp
+++ b/js/src/jit/BytecodeAnalysis.cpp
@@ -11,20 +11,19 @@
 
 #include "vm/BytecodeUtil-inl.h"
 #include "vm/JSScript-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
 BytecodeAnalysis::BytecodeAnalysis(TempAllocator& alloc, JSScript* script)
-  : script_(script)
-  , infos_(alloc)
-  , usesEnvironmentChain_(false)
-  , hasTryFinally_{ false }
+  : script_(script),
+    infos_(alloc),
+    usesEnvironmentChain_(false)
 {
 }
 
 // Bytecode range containing only catch or finally code.
 struct CatchFinallyRange
 {
     uint32_t start; // Inclusive.
     uint32_t end;   // Exclusive.
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -659,20 +659,20 @@ class OutOfLineTestObject : public OutOf
     Label* ifDoesntEmulateUndefined_;
 
 #ifdef DEBUG
     bool initialized() { return ifEmulatesUndefined_ != nullptr; }
 #endif
 
   public:
     OutOfLineTestObject()
-      : ifEmulatesUndefined_{ nullptr }
-      , ifDoesntEmulateUndefined_{ nullptr }
-    {
-    }
+#ifdef DEBUG
+      : ifEmulatesUndefined_(nullptr), ifDoesntEmulateUndefined_(nullptr)
+#endif
+    { }
 
     void accept(CodeGenerator* codegen) final {
         MOZ_ASSERT(initialized());
         codegen->emitOOLTestObject(objreg_, ifEmulatesUndefined_, ifDoesntEmulateUndefined_,
                                    scratch_);
     }
 
     // Specify the register where the object to be tested is found, labels to
--- a/js/src/jit/CompileInfo.h
+++ b/js/src/jit/CompileInfo.h
@@ -245,25 +245,20 @@ class CompileInfo
         }
 
         // If the script uses an environment in body, the environment chain
         // will need to be observable.
         needsBodyEnvironmentObject_ = script->needsBodyEnvironment();
     }
 
     explicit CompileInfo(unsigned nlocals)
-      : script_(nullptr)
-      , fun_(nullptr)
-      , osrPc_(nullptr)
-      , analysisMode_(Analysis_None)
-      , scriptNeedsArgsObj_(false)
-      , hadOverflowBailout_{ false }
-      , mayReadFrameArgsDirectly_(false)
-      , inlineScriptTree_(nullptr)
-      , needsBodyEnvironmentObject_(false)
+      : script_(nullptr), fun_(nullptr), osrPc_(nullptr),
+        analysisMode_(Analysis_None), scriptNeedsArgsObj_(false),
+        mayReadFrameArgsDirectly_(false), inlineScriptTree_(nullptr),
+        needsBodyEnvironmentObject_(false)
     {
         nimplicit_ = 0;
         nargs_ = 0;
         nlocals_ = nlocals;
         nstack_ = 1;  /* For FunctionCompiler::pushPhiInput/popPhiOutput */
         nslots_ = nlocals_ + nstack_;
     }
 
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -384,17 +384,16 @@ void
 JSContext::freeOsrTempData()
 {
     js_free(osrTempData_);
     osrTempData_ = nullptr;
 }
 
 JitCompartment::JitCompartment()
   : stubCodes_(nullptr)
-  , stringsCanBeInNursery{ false }
 {
 }
 
 JitCompartment::~JitCompartment()
 {
     js_delete(stubCodes_);
 }
 
@@ -819,54 +818,48 @@ JitCode::finalize(FreeOp* fop)
     // memory instead.
     if (!PerfEnabled())
         pool_->release(headerSize_ + bufferSize_, CodeKind(kind_));
 
     pool_ = nullptr;
 }
 
 IonScript::IonScript(IonCompilationId compilationId)
-  : method_(nullptr)
-  , osrPc_(nullptr)
-  , osrEntryOffset_(0)
-  , skipArgCheckEntryOffset_(0)
-  , invalidateEpilogueOffset_(0)
-  , invalidateEpilogueDataOffset_(0)
-  , numBailouts_(0)
-  , hasProfilingInstrumentation_(false)
-  , recompiling_(false)
-  , runtimeData_(0)
-  , runtimeSize_(0)
-  , icIndex_(0)
-  , icEntries_(0)
-  , safepointIndexOffset_(0)
-  , safepointIndexEntries_(0)
-  , safepointsStart_(0)
-  , safepointsSize_(0)
-  , frameSlots_(0)
-  , argumentSlots_{}
-  , frameSize_(0)
-  , bailoutTable_(0)
-  , bailoutEntries_(0)
-  , osiIndexOffset_(0)
-  , osiIndexEntries_(0)
-  , snapshots_(0)
-  , snapshotsListSize_(0)
-  , snapshotsRVATableSize_(0)
-  , recovers_{}
-  , recoversSize_{}
-  , constantTable_(0)
-  , constantEntries_(0)
-  , sharedStubList_{}
-  , sharedStubEntries_{}
-  , invalidationCount_(0)
-  , compilationId_(compilationId)
-  , optimizationLevel_{ OptimizationLevel::Normal }
-  , osrPcMismatchCounter_(0)
-  , fallbackStubSpace_()
+  : method_(nullptr),
+    osrPc_(nullptr),
+    osrEntryOffset_(0),
+    skipArgCheckEntryOffset_(0),
+    invalidateEpilogueOffset_(0),
+    invalidateEpilogueDataOffset_(0),
+    numBailouts_(0),
+    hasProfilingInstrumentation_(false),
+    recompiling_(false),
+    runtimeData_(0),
+    runtimeSize_(0),
+    icIndex_(0),
+    icEntries_(0),
+    safepointIndexOffset_(0),
+    safepointIndexEntries_(0),
+    safepointsStart_(0),
+    safepointsSize_(0),
+    frameSlots_(0),
+    frameSize_(0),
+    bailoutTable_(0),
+    bailoutEntries_(0),
+    osiIndexOffset_(0),
+    osiIndexEntries_(0),
+    snapshots_(0),
+    snapshotsListSize_(0),
+    snapshotsRVATableSize_(0),
+    constantTable_(0),
+    constantEntries_(0),
+    invalidationCount_(0),
+    compilationId_(compilationId),
+    osrPcMismatchCounter_(0),
+    fallbackStubSpace_()
 {
 }
 
 IonScript*
 IonScript::New(JSContext* cx, IonCompilationId compilationId,
                uint32_t frameSlots, uint32_t argumentSlots, uint32_t frameSize,
                size_t snapshotsListSize, size_t snapshotsRVATableSize,
                size_t recoversSize, size_t bailoutEntries,
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -110,73 +110,63 @@ jit::NewBaselineFrameInspector(TempAlloc
     for (size_t i = 0; i < frame->numValueSlots(); i++) {
         TypeSet::Type type = TypeSet::GetMaybeUntrackedValueType(*frame->valueSlot(i));
         inspector->varTypes.infallibleAppend(type);
     }
 
     return inspector;
 }
 
-IonBuilder::IonBuilder(JSContext* analysisContext,
-                       CompileCompartment* comp,
-                       const JitCompileOptions& options,
-                       TempAllocator* temp,
-                       MIRGraph* graph,
-                       CompilerConstraintList* constraints,
-                       BaselineInspector* inspector,
-                       CompileInfo* info,
+IonBuilder::IonBuilder(JSContext* analysisContext, CompileCompartment* comp,
+                       const JitCompileOptions& options, TempAllocator* temp,
+                       MIRGraph* graph, CompilerConstraintList* constraints,
+                       BaselineInspector* inspector, CompileInfo* info,
                        const OptimizationInfo* optimizationInfo,
-                       BaselineFrameInspector* baselineFrame,
-                       size_t inliningDepth,
+                       BaselineFrameInspector* baselineFrame, size_t inliningDepth,
                        uint32_t loopDepth)
-  : MIRGenerator(comp, options, temp, graph, info, optimizationInfo)
-  , backgroundCodegen_(nullptr)
-  , actionableAbortScript_(nullptr)
-  , actionableAbortPc_(nullptr)
-  , actionableAbortMessage_(nullptr)
-  , rootList_(nullptr)
-  , analysisContext(analysisContext)
-  , baselineFrame_(baselineFrame)
-  , constraints_(constraints)
-  , thisTypes(nullptr)
-  , argTypes(nullptr)
-  , typeArray(nullptr)
-  , typeArrayHint(0)
-  , bytecodeTypeMap(nullptr)
-  , current{ nullptr }
-  , loopDepth_(loopDepth)
-  , blockWorklist(*temp)
-  , cfgCurrent(nullptr)
-  , cfg(nullptr)
-  , trackedOptimizationSites_(*temp)
-  , lexicalCheck_(nullptr)
-  , callerResumePoint_(nullptr)
-  , callerBuilder_(nullptr)
-  , iterators_(*temp)
-  , loopHeaders_(*temp)
-  , loopHeaderStack_(*temp)
-  ,
+  : MIRGenerator(comp, options, temp, graph, info, optimizationInfo),
+    backgroundCodegen_(nullptr),
+    actionableAbortScript_(nullptr),
+    actionableAbortPc_(nullptr),
+    actionableAbortMessage_(nullptr),
+    rootList_(nullptr),
+    analysisContext(analysisContext),
+    baselineFrame_(baselineFrame),
+    constraints_(constraints),
+    thisTypes(nullptr),
+    argTypes(nullptr),
+    typeArray(nullptr),
+    typeArrayHint(0),
+    bytecodeTypeMap(nullptr),
+    loopDepth_(loopDepth),
+    blockWorklist(*temp),
+    cfgCurrent(nullptr),
+    cfg(nullptr),
+    trackedOptimizationSites_(*temp),
+    lexicalCheck_(nullptr),
+    callerResumePoint_(nullptr),
+    callerBuilder_(nullptr),
+    iterators_(*temp),
+    loopHeaders_(*temp),
+    loopHeaderStack_(*temp),
 #ifdef DEBUG
-  cfgLoopHeaderStack_(*temp)
-  ,
+    cfgLoopHeaderStack_(*temp),
 #endif
-  inspector(inspector)
-  , inliningDepth_(inliningDepth)
-  , inlinedBytecodeLength_(0)
-  , numLoopRestarts_(0)
-  , failedBoundsCheck_(info->script()->failedBoundsCheck())
-  , failedShapeGuard_(info->script()->failedShapeGuard())
-  , failedLexicalCheck_(info->script()->failedLexicalCheck())
-  ,
+    inspector(inspector),
+    inliningDepth_(inliningDepth),
+    inlinedBytecodeLength_(0),
+    numLoopRestarts_(0),
+    failedBoundsCheck_(info->script()->failedBoundsCheck()),
+    failedShapeGuard_(info->script()->failedShapeGuard()),
+    failedLexicalCheck_(info->script()->failedLexicalCheck()),
 #ifdef DEBUG
-  hasLazyArguments_(false)
-  ,
+    hasLazyArguments_(false),
 #endif
-  inlineCallInfo_(nullptr)
-  , maybeFallbackFunctionGetter_(nullptr)
+    inlineCallInfo_(nullptr),
+    maybeFallbackFunctionGetter_(nullptr)
 {
     script_ = info->script();
     scriptHasIonScript_ = script_->hasIonScript();
     pc = info->startPC();
 
     MOZ_ASSERT(script()->hasBaselineScript() == (info->analysisMode() != Analysis_ArgumentsUsage));
     MOZ_ASSERT(!!analysisContext == (info->analysisMode() == Analysis_DefiniteProperties));
     MOZ_ASSERT(script_->nTypeSets() < UINT16_MAX);
--- a/js/src/jit/IonCode.h
+++ b/js/src/jit/IonCode.h
@@ -65,29 +65,19 @@ class JitCode : public gc::TenuredCell
     uint8_t headerSize_ : 5;          // Number of bytes allocated before codeStart.
     uint8_t kind_ : 3;                // jit::CodeKind, for the memory reporters.
     bool invalidated_ : 1;            // Whether the code object has been invalidated.
                                       // This is necessary to prevent GC tracing.
     bool hasBytecodeMap_ : 1;         // Whether the code object has been registered with
                                       // native=>bytecode mapping tables.
 
     JitCode()
-      : code_(nullptr)
-      , pool_(nullptr)
-      , bufferSize_{}
-      , insnSize_{}
-      , dataSize_{}
-      , jumpRelocTableBytes_{}
-      , dataRelocTableBytes_{}
-      , headerSize_{ '\0' }
-      , kind_{ '\0' }
-      , invalidated_{ false }
-      , hasBytecodeMap_{ false }
-    {
-    }
+      : code_(nullptr),
+        pool_(nullptr)
+    { }
     JitCode(uint8_t* code, uint32_t bufferSize, uint32_t headerSize, ExecutablePool* pool,
             CodeKind kind)
       : code_(code),
         pool_(pool),
         bufferSize_(bufferSize),
         insnSize_(0),
         dataSize_(0),
         jumpRelocTableBytes_(0),
--- a/js/src/jit/IonControlFlow.cpp
+++ b/js/src/jit/IonControlFlow.cpp
@@ -8,27 +8,26 @@
 
 #include "mozilla/DebugOnly.h"
 
 using namespace js;
 using namespace js::jit;
 using mozilla::DebugOnly;
 
 ControlFlowGenerator::ControlFlowGenerator(TempAllocator& temp, JSScript* script)
-  : script(script)
-  , current(nullptr)
-  , pc{ nullptr }
-  , alloc_(temp)
-  , blocks_(temp)
-  , cfgStack_(temp)
-  , loops_(temp)
-  , switches_(temp)
-  , labels_(temp)
-  , aborted_(false)
-  , checkedTryFinally_(false)
+  : script(script),
+    current(nullptr),
+    alloc_(temp),
+    blocks_(temp),
+    cfgStack_(temp),
+    loops_(temp),
+    switches_(temp),
+    labels_(temp),
+    aborted_(false),
+    checkedTryFinally_(false)
 { }
 
 static inline int32_t
 GetJumpOffset(jsbytecode* pc)
 {
     MOZ_ASSERT(CodeSpec[JSOp(*pc)].type() == JOF_JUMP);
     return GET_JUMP_OFFSET(pc);
 }
--- a/js/src/jit/IonOptimizationLevels.h
+++ b/js/src/jit/IonOptimizationLevels.h
@@ -145,47 +145,17 @@ class OptimizationInfo
     double inliningWarmUpThresholdFactor_;
 
     // How many invocations or loop iterations are needed before a function
     // is hot enough to recompile the outerScript to inline that function,
     // as a multiplication of inliningWarmUpThreshold.
     uint32_t inliningRecompileThresholdFactor_;
 
     OptimizationInfo()
-      : level_{ OptimizationLevel::Normal }
-      , eaa_{ false }
-      , ama_{ false }
-      , edgeCaseAnalysis_{ false }
-      , eliminateRedundantChecks_{ false }
-      , inlineInterpreted_{ false }
-      , inlineNative_{ false }
-      , eagerSimdUnbox_{ false }
-      , gvn_{ false }
-      , licm_{ false }
-      , rangeAnalysis_{ false }
-      , loopUnrolling_{ false }
-      , reordering_{ false }
-      , autoTruncate_{ false }
-      , sincos_{ false }
-      , sink_{ false }
-      , registerAllocator_{ static_cast<IonRegisterAllocator>(0) }
-      , inlineMaxBytecodePerCallSiteHelperThread_{}
-      , inlineMaxBytecodePerCallSiteActiveCooperatingThread_{}
-      , inlineMaxCalleeInlinedBytecodeLength_{}
-      , inlineMaxTotalBytecodeLength_{}
-      , inliningMaxCallerBytecodeLength_{}
-      , maxInlineDepth_{}
-      , scalarReplacement_{ false }
-      , smallFunctionMaxInlineDepth_{}
-      , compilerWarmUpThreshold_{}
-      , compilerSmallFunctionWarmUpThreshold_{}
-      , inliningWarmUpThresholdFactor_{ 0.0 }
-      , inliningRecompileThresholdFactor_{}
-    {
-    }
+    { }
 
     void initNormalOptimizationInfo();
     void initWasmOptimizationInfo();
 
     OptimizationLevel level() const {
         return level_;
     }
 
--- a/js/src/jit/JitCompartment.h
+++ b/js/src/jit/JitCompartment.h
@@ -25,28 +25,19 @@
 namespace js {
 namespace jit {
 
 class FrameSizeClass;
 
 struct EnterJitData
 {
     explicit EnterJitData(JSContext* cx)
-      : jitcode{ nullptr }
-      , osrFrame{ nullptr }
-      , calleeToken{ nullptr }
-      , maxArgv{ nullptr }
-      , maxArgc{}
-      , numActualArgs{}
-      , osrNumStackValues{}
-      , envChain(cx)
-      , result(cx)
-      , constructing{ false }
-    {
-    }
+      : envChain(cx),
+        result(cx)
+    {}
 
     uint8_t* jitcode;
     InterpreterFrame* osrFrame;
 
     void* calleeToken;
 
     Value* maxArgv;
     unsigned maxArgc;
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -1505,22 +1505,21 @@ SnapshotIterator::SnapshotIterator(const
     fp_(iter.jsFrame()),
     machine_(machineState),
     ionScript_(iter.ionScript()),
     instructionResults_(nullptr)
 {
 }
 
 SnapshotIterator::SnapshotIterator()
-  : snapshot_(nullptr, 0, 0, 0)
-  , recover_(snapshot_, nullptr, 0)
-  , fp_(nullptr)
-  , machine_{ nullptr }
-  , ionScript_(nullptr)
-  , instructionResults_(nullptr)
+  : snapshot_(nullptr, 0, 0, 0),
+    recover_(snapshot_, nullptr, 0),
+    fp_(nullptr),
+    ionScript_(nullptr),
+    instructionResults_(nullptr)
 {
 }
 
 int32_t
 SnapshotIterator::readOuterNumActualArgs() const
 {
     return fp_->numActualArgs();
 }
@@ -2020,34 +2019,30 @@ SnapshotIterator::maybeReadAllocByIndex(
 
     while (moreAllocations())
         skip();
 
     return s;
 }
 
 InlineFrameIterator::InlineFrameIterator(JSContext* cx, const JSJitFrameIter* iter)
-  : calleeTemplate_(cx)
-  , calleeRVA_()
-  , script_(cx)
-  , pc_{ nullptr }
-  , numActualArgs_{}
+  : calleeTemplate_(cx),
+    calleeRVA_(),
+    script_(cx)
 {
     resetOn(iter);
 }
 
 InlineFrameIterator::InlineFrameIterator(JSContext* cx, const InlineFrameIterator* iter)
-  : frame_(iter ? iter->frame_ : nullptr)
-  , framesRead_(0)
-  , frameCount_(iter ? iter->frameCount_ : UINT32_MAX)
-  , calleeTemplate_(cx)
-  , calleeRVA_()
-  , script_(cx)
-  , pc_{ nullptr }
-  , numActualArgs_{}
+  : frame_(iter ? iter->frame_ : nullptr),
+    framesRead_(0),
+    frameCount_(iter ? iter->frameCount_ : UINT32_MAX),
+    calleeTemplate_(cx),
+    calleeRVA_(),
+    script_(cx)
 {
     if (frame_) {
         machine_ = iter->machine_;
         start_ = SnapshotIterator(*frame_, &machine_);
 
         // findNextFrame will iterate to the next frame and init. everything.
         // Therefore to settle on the same frame, we report one frame less readed.
         framesRead_ = iter->framesRead_ - 1;
--- a/js/src/jit/JitFrames.h
+++ b/js/src/jit/JitFrames.h
@@ -226,19 +226,17 @@ class FrameSizeClass
 {
     uint32_t class_;
 
     explicit FrameSizeClass(uint32_t class_) : class_(class_)
     { }
 
   public:
     FrameSizeClass()
-      : class_{}
-    {
-    }
+    { }
 
     static FrameSizeClass None() {
         return FrameSizeClass(NO_FRAME_SIZE_CLASS_ID);
     }
     static FrameSizeClass FromClass(uint32_t class_) {
         return FrameSizeClass(class_);
     }
 
--- a/js/src/jit/JitcodeMap.h
+++ b/js/src/jit/JitcodeMap.h
@@ -563,17 +563,16 @@ class JitcodeGlobalEntry
         // When doing queries on the SplayTree for particular addresses,
         // the query addresses are representd using a QueryEntry.
         QueryEntry query_;
     };
 
   public:
     JitcodeGlobalEntry()
       : tower_(nullptr)
-      , base_{}
     {
         base_.init();
     }
 
     explicit JitcodeGlobalEntry(const IonEntry& ion)
       : JitcodeGlobalEntry()
     {
         ion_ = ion;
--- a/js/src/jit/LIR.h
+++ b/js/src/jit/LIR.h
@@ -1459,38 +1459,31 @@ class LSnapshot : public TempObject
 
 struct SafepointSlotEntry {
     // Flag indicating whether this is a slot in the stack or argument space.
     uint32_t stack:1;
 
     // Byte offset of the slot, as in LStackSlot or LArgument.
     uint32_t slot:31;
 
-    SafepointSlotEntry()
-      : stack{}
-      , slot{}
-    {
-    }
+    SafepointSlotEntry() { }
     SafepointSlotEntry(bool stack, uint32_t slot)
       : stack(stack), slot(slot)
     { }
     explicit SafepointSlotEntry(const LAllocation* a)
       : stack(a->isStackSlot()), slot(a->memorySlot())
     { }
 };
 
 struct SafepointNunboxEntry {
     uint32_t typeVreg;
     LAllocation type;
     LAllocation payload;
 
-    SafepointNunboxEntry()
-      : typeVreg{}
-    {
-    }
+    SafepointNunboxEntry() { }
     SafepointNunboxEntry(uint32_t typeVreg, LAllocation type, LAllocation payload)
       : typeVreg(typeVreg), type(type), payload(payload)
     { }
 };
 
 class LSafepoint : public TempObject
 {
     typedef SafepointSlotEntry SlotEntry;
--- a/js/src/jit/MIRGraph.cpp
+++ b/js/src/jit/MIRGraph.cpp
@@ -478,43 +478,41 @@ MBasicBlock::New(MIRGraph& graph, const 
         if (!block->predecessors_.append(pred))
             return nullptr;
     }
 
     return block;
 }
 
 MBasicBlock::MBasicBlock(MIRGraph& graph, const CompileInfo& info, BytecodeSite* site, Kind kind)
-  : unreachable_(false)
-  , specialized_(false)
-  , graph_(graph)
-  , info_(info)
-  , predecessors_(graph.alloc())
-  , stackPosition_(info_.firstStackSlot())
-  , id_{}
-  , domIndex_{}
-  , numDominated_(0)
-  , pc_(site->pc())
-  , lir_(nullptr)
-  , callerResumePoint_(nullptr)
-  , entryResumePoint_(nullptr)
-  , outerResumePoint_(nullptr)
-  , successorWithPhis_(nullptr)
-  , positionInPhiSuccessor_(0)
-  , loopDepth_(0)
-  , kind_(kind)
-  , mark_(false)
-  , immediatelyDominated_(graph.alloc())
-  , immediateDominator_(nullptr)
-  , trackedSite_(site)
-  , hitCount_(0)
-  , hitState_(HitState::NotDefined)
-#if defined(JS_ION_PERF) || defined(DEBUG)
-  , lineno_(0u)
-  , columnIndex_(0u)
+  : unreachable_(false),
+    specialized_(false),
+    graph_(graph),
+    info_(info),
+    predecessors_(graph.alloc()),
+    stackPosition_(info_.firstStackSlot()),
+    numDominated_(0),
+    pc_(site->pc()),
+    lir_(nullptr),
+    callerResumePoint_(nullptr),
+    entryResumePoint_(nullptr),
+    outerResumePoint_(nullptr),
+    successorWithPhis_(nullptr),
+    positionInPhiSuccessor_(0),
+    loopDepth_(0),
+    kind_(kind),
+    mark_(false),
+    immediatelyDominated_(graph.alloc()),
+    immediateDominator_(nullptr),
+    trackedSite_(site),
+    hitCount_(0),
+    hitState_(HitState::NotDefined)
+#if defined (JS_ION_PERF)
+    , lineno_(0u),
+    columnIndex_(0u)
 #endif
 {
 }
 
 bool
 MBasicBlock::init()
 {
     return slots_.init(graph_.alloc(), info_.nslots());
--- a/js/src/jit/MacroAssembler.cpp
+++ b/js/src/jit/MacroAssembler.cpp
@@ -2793,46 +2793,40 @@ MacroAssembler::alignJitStackBasedOnNArg
     } else {
         andToStackPtr(Imm32(~(JitStackAlignment - 1)));
     }
 }
 
 // ===============================================================
 
 MacroAssembler::MacroAssembler(JSContext* cx)
-  : framePushed_(0)
-  ,
+  : framePushed_(0),
 #ifdef DEBUG
-  inCall_(false)
-  ,
+    inCall_(false),
 #endif
-  dynamicAlignment_{ false }
-  , emitProfilingInstrumentation_(false)
+    emitProfilingInstrumentation_(false)
 {
     jitContext_.emplace(cx, (js::jit::TempAllocator*)nullptr);
     alloc_.emplace(cx);
     moveResolver_.setAllocator(*jitContext_->temp);
 #if defined(JS_CODEGEN_ARM)
     initWithAllocator();
     m_buffer.id = GetJitContext()->getNextAssemblerId();
 #elif defined(JS_CODEGEN_ARM64)
     initWithAllocator();
     armbuffer_.id = GetJitContext()->getNextAssemblerId();
 #endif
 }
 
 MacroAssembler::MacroAssembler()
-  : framePushed_(0)
-  ,
+  : framePushed_(0),
 #ifdef DEBUG
-  inCall_(false)
-  ,
+    inCall_(false),
 #endif
-  dynamicAlignment_{ false }
-  , emitProfilingInstrumentation_(false)
+    emitProfilingInstrumentation_(false)
 {
     JitContext* jcx = GetJitContext();
 
     if (!jcx->temp) {
         JSContext* cx = jcx->cx;
         MOZ_ASSERT(cx);
         alloc_.emplace(cx);
     }
@@ -2844,24 +2838,21 @@ MacroAssembler::MacroAssembler()
     m_buffer.id = jcx->getNextAssemblerId();
 #elif defined(JS_CODEGEN_ARM64)
     initWithAllocator();
     armbuffer_.id = jcx->getNextAssemblerId();
 #endif
 }
 
 MacroAssembler::MacroAssembler(WasmToken, TempAllocator& alloc)
-  : framePushed_(0)
-  ,
+  : framePushed_(0),
 #ifdef DEBUG
-  inCall_(false)
-  ,
+    inCall_(false),
 #endif
-  dynamicAlignment_{ false }
-  , emitProfilingInstrumentation_(false)
+    emitProfilingInstrumentation_(false)
 {
     moveResolver_.setAllocator(alloc);
 
 #if defined(JS_CODEGEN_ARM)
     initWithAllocator();
     m_buffer.id = 0;
 #elif defined(JS_CODEGEN_ARM64)
     initWithAllocator();
--- a/js/src/jit/MoveResolver.cpp
+++ b/js/src/jit/MoveResolver.cpp
@@ -10,17 +10,16 @@
 
 #include "jit/MacroAssembler.h"
 #include "jit/RegisterSets.h"
 
 using namespace js;
 using namespace js::jit;
 
 MoveOperand::MoveOperand(MacroAssembler& masm, const ABIArg& arg)
-  : disp_{}
 {
     switch (arg.kind()) {
       case ABIArg::GPR:
         kind_ = REG;
         code_ = arg.gpr().code();
         break;
 #ifdef JS_CODEGEN_REGISTER_PAIR
       case ABIArg::GPR_PAIR:
--- a/js/src/jit/MoveResolver.h
+++ b/js/src/jit/MoveResolver.h
@@ -41,33 +41,21 @@ class MoveOperand
 
   private:
     Kind kind_;
     uint32_t code_;
     int32_t disp_;
 
   public:
     MoveOperand()
-      : kind_{ static_cast<Kind>(0) }
-      , code_{}
-      , disp_{}
-    {
-    }
-    explicit MoveOperand(Register reg)
-      : kind_(REG)
-      , code_(reg.code())
-      , disp_{}
-    {
-    }
-    explicit MoveOperand(FloatRegister reg)
-      : kind_(FLOAT_REG)
-      , code_(reg.code())
-      , disp_{}
-    {
-    }
+    { }
+    explicit MoveOperand(Register reg) : kind_(REG), code_(reg.code())
+    { }
+    explicit MoveOperand(FloatRegister reg) : kind_(FLOAT_REG), code_(reg.code())
+    { }
     MoveOperand(Register reg, int32_t disp, Kind kind = MEMORY)
         : kind_(kind),
         code_(reg.code()),
         disp_(disp)
     {
         MOZ_ASSERT(isMemoryOrEffectiveAddress());
 
         // With a zero offset, this is a plain reg-to-reg move.
@@ -215,24 +203,17 @@ class MoveOp
     //       INT32 move a -> b
     //     GENERAL move b -> a
     // the move resolver starts by copying b into a temporary location, so that
     // the last move can read it. This copy needs to use use type GENERAL.
     Type endCycleType_;
 
   public:
     MoveOp()
-      : cycleBegin_{ false }
-      , cycleEnd_{ false }
-      , cycleBeginSlot_{}
-      , cycleEndSlot_{}
-      , type_{ GENERAL }
-      , endCycleType_{ GENERAL }
-    {
-    }
+    { }
     MoveOp(const MoveOperand& from, const MoveOperand& to, Type type)
       : from_(from),
         to_(to),
         cycleBegin_(false),
         cycleEnd_(false),
         cycleBeginSlot_(-1),
         cycleEndSlot_(-1),
         type_(type),
--- a/js/src/jit/OptimizationTracking.h
+++ b/js/src/jit/OptimizationTracking.h
@@ -448,22 +448,19 @@ struct IonTrackedTypeWithAddendum
         struct {
             JSScript* script;
             uint32_t offset;
         };
         JSFunction* constructor;
     };
 
     explicit IonTrackedTypeWithAddendum(TypeSet::Type type)
-      : type(type)
-      , hasAddendum(HasNothing)
-      , script{ nullptr }
-      , offset{}
-    {
-    }
+      : type(type),
+        hasAddendum(HasNothing)
+    { }
 
     IonTrackedTypeWithAddendum(TypeSet::Type type, JSScript* script, uint32_t offset)
       : type(type),
         hasAddendum(HasAllocationSite),
         script(script),
         offset(offset)
     { }
 
--- a/js/src/jit/RangeAnalysis.cpp
+++ b/js/src/jit/RangeAnalysis.cpp
@@ -580,25 +580,18 @@ Range::unionWith(const Range* other)
 
     rawInitialize(newLower, newHasInt32LowerBound, newUpper, newHasInt32UpperBound,
                   newCanHaveFractionalPart,
                   newMayIncludeNegativeZero,
                   newExponent);
 }
 
 Range::Range(const MDefinition* def)
-  : lower_{}
-  , upper_{}
-  , hasInt32LowerBound_{ false }
-  , hasInt32UpperBound_{ false }
-  , canHaveFractionalPart_{ static_cast<FractionalPartFlag>(false) }
-  , canBeNegativeZero_{ static_cast<NegativeZeroFlag>(false) }
-  , max_exponent_{}
-  , symbolicLower_(nullptr)
-  , symbolicUpper_(nullptr)
+  : symbolicLower_(nullptr),
+    symbolicUpper_(nullptr)
 {
     if (const Range* other = def->range()) {
         // The instruction has range information; use it.
         *this = *other;
 
         // Simulate the effect of converting the value to its type.
         // Note: we cannot clamp here, since ranges aren't allowed to shrink
         // and truncation can increase range again. So doing wrapAround to
--- a/js/src/jit/RegisterSets.h
+++ b/js/src/jit/RegisterSets.h
@@ -248,20 +248,19 @@ class ConstantOrRegister
         return data.reg;
     }
     void setDataReg(const TypedOrValueRegister& reg) {
         MOZ_ASSERT(!constant());
         data.reg = reg;
     }
 
   public:
+
     ConstantOrRegister()
-      : constant_{ false }
-    {
-    }
+    {}
 
     MOZ_IMPLICIT ConstantOrRegister(const Value& value)
       : constant_(true)
     {
         setDataValue(value);
     }
 
     MOZ_IMPLICIT ConstantOrRegister(TypedOrValueRegister reg)
--- a/js/src/jit/RematerializedFrame.cpp
+++ b/js/src/jit/RematerializedFrame.cpp
@@ -25,33 +25,27 @@ struct CopyValueToRematerializedFrame
       : slots(slots)
     { }
 
     void operator()(const Value& v) {
         *slots++ = v;
     }
 };
 
-RematerializedFrame::RematerializedFrame(JSContext* cx,
-                                         uint8_t* top,
-                                         unsigned numActualArgs,
-                                         InlineFrameIterator& iter,
-                                         MaybeReadFallback& fallback)
-  : prevUpToDate_(false)
-  , isDebuggee_(iter.script()->isDebuggee())
-  , hasInitialEnv_{ false }
-  , isConstructing_(iter.isConstructing())
-  , hasCachedSavedFrame_(false)
-  , top_(top)
-  , pc_(iter.pc())
-  , frameNo_(iter.frameNo())
-  , numActualArgs_(numActualArgs)
-  , script_(iter.script())
-  , envChain_{ nullptr }
-  , argsObj_{ nullptr }
+RematerializedFrame::RematerializedFrame(JSContext* cx, uint8_t* top, unsigned numActualArgs,
+                                         InlineFrameIterator& iter, MaybeReadFallback& fallback)
+  : prevUpToDate_(false),
+    isDebuggee_(iter.script()->isDebuggee()),
+    isConstructing_(iter.isConstructing()),
+    hasCachedSavedFrame_(false),
+    top_(top),
+    pc_(iter.pc()),
+    frameNo_(iter.frameNo()),
+    numActualArgs_(numActualArgs),
+    script_(iter.script())
 {
     if (iter.isFunctionFrame())
         callee_ = iter.callee(fallback);
     else
         callee_ = nullptr;
 
     CopyValueToRematerializedFrame op(slots_);
     iter.readFrameArgsAndLocals(cx, op, op, &envChain_, &hasInitialEnv_, &returnValue_,
--- a/js/src/jit/Safepoints.cpp
+++ b/js/src/jit/Safepoints.cpp
@@ -388,22 +388,19 @@ SafepointWriter::encode(LSafepoint* safe
 void
 SafepointWriter::endEntry()
 {
     JitSpew(JitSpew_Safepoints, "    -- entry ended at %d", uint32_t(stream_.length()));
 }
 
 SafepointReader::SafepointReader(IonScript* script, const SafepointIndex* si)
   : stream_(script->safepoints() + si->safepointOffset(),
-            script->safepoints() + script->safepointsSize())
-  , frameSlots_((script->frameSlots() / sizeof(intptr_t)) + 1)
-  , // Stack slot counts are inclusive.
-  argumentSlots_(script->argumentSlots() / sizeof(intptr_t))
-  , nunboxSlotsRemaining_{}
-  , slotsOrElementsSlotsRemaining_{}
+            script->safepoints() + script->safepointsSize()),
+    frameSlots_((script->frameSlots() / sizeof(intptr_t)) + 1), // Stack slot counts are inclusive.
+    argumentSlots_(script->argumentSlots() / sizeof(intptr_t))
 {
     osiCallPointOffset_ = stream_.readUnsigned();
 
     // gcSpills is a subset of allGprSpills.
     allGprSpills_ = GeneralRegisterSet(ReadRegisterMask(stream_));
     if (allGprSpills_.empty()) {
         gcSpills_ = allGprSpills_;
         valueSpills_ = allGprSpills_;
--- a/js/src/jit/ScalarReplacement.cpp
+++ b/js/src/jit/ScalarReplacement.cpp
@@ -368,23 +368,22 @@ class ObjectMemoryView : public MDefinit
     void storeOffset(MInstruction* ins, size_t offset, MDefinition* value);
     void loadOffset(MInstruction* ins, size_t offset);
     void visitObjectGuard(MInstruction* ins, MDefinition* operand);
 };
 
 const char* ObjectMemoryView::phaseName = "Scalar Replacement of Object";
 
 ObjectMemoryView::ObjectMemoryView(TempAllocator& alloc, MInstruction* obj)
-  : alloc_(alloc)
-  , undefinedVal_{ nullptr }
-  , obj_(obj)
-  , startBlock_(obj->block())
-  , state_(nullptr)
-  , lastResumePoint_(nullptr)
-  , oom_(false)
+  : alloc_(alloc),
+    obj_(obj),
+    startBlock_(obj->block()),
+    state_(nullptr),
+    lastResumePoint_(nullptr),
+    oom_(false)
 {
     // Annotate snapshots RValue such that we recover the store first.
     obj_->setIncompleteObject();
 
     // Annotate the instruction such that we do not replace it by a
     // Magic(JS_OPTIMIZED_OUT) in case of removed uses.
     obj_->setImplicitlyUsedUnchecked();
 }
--- a/js/src/jit/StupidAllocator.h
+++ b/js/src/jit/StupidAllocator.h
@@ -49,17 +49,16 @@ class StupidAllocator : public RegisterA
     typedef uint32_t RegisterIndex;
 
     // Information about each virtual register.
     Vector<LDefinition*, 0, SystemAllocPolicy> virtualRegisters;
 
   public:
     StupidAllocator(MIRGenerator* mir, LIRGenerator* lir, LIRGraph& graph)
       : RegisterAllocator(mir, lir, graph)
-      , registerCount{}
     {
     }
 
     MOZ_MUST_USE bool go();
 
   private:
     MOZ_MUST_USE bool init();
 
--- a/js/src/jit/TypedObjectPrediction.h
+++ b/js/src/jit/TypedObjectPrediction.h
@@ -113,19 +113,17 @@ class TypedObjectPrediction {
                              size_t* index) const;
 
   public:
 
     ///////////////////////////////////////////////////////////////////////////
     // Constructing a prediction. Generally, you start with an empty
     // prediction and invoke addDescr() repeatedly.
 
-    TypedObjectPrediction()
-      : data_{}
-    {
+    TypedObjectPrediction() {
         kind_ = Empty;
     }
 
     explicit TypedObjectPrediction(const TypeDescr& descr) {
         setDescr(descr);
     }
 
     TypedObjectPrediction(const StructTypeDescr& descr, size_t fields) {
--- a/js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
+++ b/js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
@@ -238,17 +238,16 @@ class BranchDeadlineSet
             earliest_ = deadline;
             earliestRange_ = rangeIdx;
         }
         return true;
     }
 
   public:
     explicit BranchDeadlineSet(LifoAlloc& alloc)
-      : earliestRange_{}
     {
         // Manually construct vectors in the uninitialized aligned storage.
         // This is because C++ arrays can otherwise only be constructed with
         // the default constructor.
         for (unsigned r = 0; r < NumRanges; r++)
             new (&vectorForRange(r)) RangeVector(alloc);
     }
 
--- a/js/src/jit/shared/Lowering-shared.h
+++ b/js/src/jit/shared/Lowering-shared.h
@@ -29,23 +29,22 @@ class LIRGeneratorShared
     MIRGraph& graph;
     LIRGraph& lirGraph_;
     LBlock* current;
     MResumePoint* lastResumePoint_;
     LRecoverInfo* cachedRecoverInfo_;
     LOsiPoint* osiPoint_;
 
     LIRGeneratorShared(MIRGenerator* gen, MIRGraph& graph, LIRGraph& lirGraph)
-      : gen(gen)
-      , graph(graph)
-      , lirGraph_(lirGraph)
-      , current{ nullptr }
-      , lastResumePoint_(nullptr)
-      , cachedRecoverInfo_(nullptr)
-      , osiPoint_(nullptr)
+      : gen(gen),
+        graph(graph),
+        lirGraph_(lirGraph),
+        lastResumePoint_(nullptr),
+        cachedRecoverInfo_(nullptr),
+        osiPoint_(nullptr)
     { }
 
     MIRGenerator* mir() {
         return gen;
     }
 
     // Needed to capture the abort error out of the visitInstruction methods.
     bool errored() {
--- a/js/src/jit/x64/Assembler-x64.cpp
+++ b/js/src/jit/x64/Assembler-x64.cpp
@@ -258,18 +258,16 @@ class RelocationIterator
     CompactBufferReader reader_;
     uint32_t tableStart_;
     uint32_t offset_;
     uint32_t extOffset_;
 
   public:
     explicit RelocationIterator(CompactBufferReader& reader)
       : reader_(reader)
-      , offset_{}
-      , extOffset_{}
     {
         tableStart_ = reader_.readFixedUint32_t();
     }
 
     bool read() {
         if (!reader_.more())
             return false;
         offset_ = reader_.readUnsigned();
--- a/js/src/jit/x64/Bailouts-x64.cpp
+++ b/js/src/jit/x64/Bailouts-x64.cpp
@@ -40,35 +40,34 @@ class BailoutStack
 
 } // namespace jit
 } // namespace js
 
 #if defined(_WIN32)
 # pragma pack(pop)
 #endif
 
-BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator& activations, BailoutStack* bailout)
+BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator& activations,
+                                   BailoutStack* bailout)
   : machine_(bailout->machineState())
-  , activation_{ nullptr }
 {
     uint8_t* sp = bailout->parentStackPointer();
     framePointer_ = sp + bailout->frameSize();
     topFrameSize_ = framePointer_ - sp;
 
     JSScript* script = ScriptFromCalleeToken(((JitFrameLayout*) framePointer_)->calleeToken());
     topIonScript_ = script->ionScript();
 
     attachOnJitActivation(activations);
     snapshotOffset_ = bailout->snapshotOffset();
 }
 
 BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator& activations,
                                    InvalidationBailoutStack* bailout)
   : machine_(bailout->machine())
-  , activation_{ nullptr }
 {
     framePointer_ = (uint8_t*) bailout->fp();
     topFrameSize_ = framePointer_ - bailout->sp();
     topIonScript_ = bailout->ionScript();
     attachOnJitActivation(activations);
 
     uint8_t* returnAddressToFp_ = bailout->osiPointReturnAddress();
     const OsiIndex* osiIndex = topIonScript_->getOsiIndex(returnAddressToFp_);
--- a/js/src/jsapi-tests/testPrivateGCThingValue.cpp
+++ b/js/src/jsapi-tests/testPrivateGCThingValue.cpp
@@ -18,20 +18,18 @@ class TestTracer : public JS::CallbackTr
     }
 
   public:
     js::gc::Cell* expectedCell;
     JS::TraceKind expectedKind;
     bool found;
 
     explicit TestTracer(JSContext* cx)
-      : JS::CallbackTracer(cx)
-      , expectedCell{ nullptr }
-      , expectedKind{ static_cast<JS::TraceKind>(0) }
-      , found(false)
+      : JS::CallbackTracer(cx),
+        found(false)
     { }
 };
 
 static const JSClass TestClass = {
     "TestClass",
     JSCLASS_HAS_RESERVED_SLOTS(1)
 };
 
--- a/js/src/jsapi-tests/tests.h
+++ b/js/src/jsapi-tests/tests.h
@@ -485,21 +485,17 @@ class RefCountedData {
  */
 class AutoLeaveZeal
 {
     JSContext* cx_;
     uint32_t zealBits_;
     uint32_t frequency_;
 
   public:
-    explicit AutoLeaveZeal(JSContext* cx)
-      : cx_(cx)
-      , zealBits_{}
-      , frequency_{}
-    {
+    explicit AutoLeaveZeal(JSContext* cx) : cx_(cx) {
         uint32_t dummy;
         JS_GetGCZealBits(cx_, &zealBits_, &frequency_, &dummy);
         JS_SetGCZeal(cx_, 0, 0);
         JS::PrepareForFullGC(cx_);
         JS::GCForReason(cx_, GC_SHRINK, JS::gcreason::DEBUG_GC);
     }
     ~AutoLeaveZeal() {
         JS_SetGCZeal(cx_, 0, 0);
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -6901,21 +6901,17 @@ JS::AutoSaveExceptionState::~AutoSaveExc
             context->overRecursed_ = wasOverRecursed;
             context->throwing = true;
             context->unwrappedException() = exceptionValue;
         }
     }
 }
 
 struct JSExceptionState {
-    explicit JSExceptionState(JSContext* cx)
-      : throwing{ false }
-      , exception(cx)
-    {
-    }
+    explicit JSExceptionState(JSContext* cx) : exception(cx) {}
     bool throwing;
     PersistentRootedValue exception;
 };
 
 JS_PUBLIC_API(JSExceptionState*)
 JS_SaveExceptionState(JSContext* cx)
 {
     JSExceptionState* state;
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -1447,19 +1447,17 @@ class MOZ_STACK_CLASS JS_FRIEND_API(Auto
         const JS::Latin1Char* latin1Chars_;
     };
     mozilla::Maybe<Vector<uint8_t, InlineCapacity>> ownChars_;
     enum State { Uninitialized, Latin1, TwoByte };
     State state_;
 
   public:
     explicit AutoStableStringChars(JSContext* cx)
-      : s_(cx)
-      , twoByteChars_{ nullptr }
-      , state_(Uninitialized)
+      : s_(cx), state_(Uninitialized)
     {}
 
     MOZ_MUST_USE
     bool init(JSContext* cx, JSString* s);
 
     /* Like init(), but Latin1 chars are inflated to TwoByte. */
     MOZ_MUST_USE
     bool initTwoByte(JSContext* cx, JSString* s);
--- a/js/src/vm/ArrayBufferObject.h
+++ b/js/src/vm/ArrayBufferObject.h
@@ -508,20 +508,17 @@ ArrayBufferObjectMaybeShared& AsArrayBuf
 ArrayBufferObjectMaybeShared& AsArrayBufferMaybeShared(JSObject* obj);
 
 extern uint32_t JS_FASTCALL
 ClampDoubleToUint8(const double x);
 
 struct uint8_clamped {
     uint8_t val;
 
-    uint8_clamped()
-      : val{ '\0' }
-    {
-    }
+    uint8_clamped() { }
     uint8_clamped(const uint8_clamped& other) : val(other.val) { }
 
     // invoke our assignment helpers for constructor conversion
     explicit uint8_clamped(uint8_t x)    { *this = x; }
     explicit uint8_clamped(uint16_t x)   { *this = x; }
     explicit uint8_clamped(uint32_t x)   { *this = x; }
     explicit uint8_clamped(int8_t x)     { *this = x; }
     explicit uint8_clamped(int16_t x)    { *this = x; }
--- a/js/src/vm/BytecodeUtil.h
+++ b/js/src/vm/BytecodeUtil.h
@@ -468,20 +468,17 @@ class SrcNoteLineScanner
      * Is the current op the first one after a line change directive? Note that
      * multiple ops may be "first" if a line directive is used to return to a
      * previous line (eg, with a for loop increment expression.)
      */
     bool lineHeader;
 
   public:
     SrcNoteLineScanner(jssrcnote* sn, uint32_t lineno)
-      : offset(0)
-      , sn(sn)
-      , lineno(lineno)
-      , lineHeader{ false }
+        : offset(0), sn(sn), lineno(lineno)
     {
     }
 
     /*
      * This is called repeatedly with always-advancing relpc values. The src
      * notes are tuples of <PC offset from prev src note, type, args>. Scan
      * through, updating the lineno, until the next src note is for a later
      * bytecode.
--- a/js/src/vm/Caches.h
+++ b/js/src/vm/Caches.h
@@ -73,22 +73,17 @@ struct EvalCacheEntry
     // then.
     bool needsSweep() {
         return !str->isTenured();
     }
 };
 
 struct EvalCacheLookup
 {
-    explicit EvalCacheLookup(JSContext* cx)
-      : str(cx)
-      , callerScript(cx)
-      , pc{ nullptr }
-    {
-    }
+    explicit EvalCacheLookup(JSContext* cx) : str(cx), callerScript(cx) {}
     RootedLinearString str;
     RootedScript callerScript;
     jsbytecode* pc;
 };
 
 struct EvalCacheHashPolicy
 {
     typedef EvalCacheLookup Lookup;
--- a/js/src/vm/Compression.cpp
+++ b/js/src/vm/Compression.cpp
@@ -32,23 +32,16 @@ zlib_free(void* cx, void* addr)
 Compressor::Compressor(const unsigned char* inp, size_t inplen)
     : inp(inp),
       inplen(inplen),
       initialized(false),
       finished(false),
       currentChunkSize(0),
       chunkOffsets()
 {
-    this->zs.total_in = {};
-    this->zs.total_out = {};
-    this->zs.msg = { nullptr };
-    this->zs.state = { nullptr };
-    this->zs.data_type = {};
-    this->zs.adler = {};
-    this->zs.reserved = {};
     MOZ_ASSERT(inplen > 0);
     zs.opaque = nullptr;
     zs.next_in = (Bytef*)inp;
     zs.avail_in = 0;
     zs.next_out = nullptr;
     zs.avail_out = 0;
     zs.zalloc = zlib_alloc;
     zs.zfree = zlib_free;
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -4218,34 +4218,29 @@ static inline DebuggerSourceReferent Get
 /*
  * A class for parsing 'findScripts' query arguments and searching for
  * scripts that match the criteria they represent.
  */
 class MOZ_STACK_CLASS Debugger::ScriptQuery
 {
   public:
     /* Construct a ScriptQuery to use matching scripts for |dbg|. */
-    ScriptQuery(JSContext* cx, Debugger* dbg)
-      : cx(cx)
-      , debugger(dbg)
-      , iterMarker(&cx->runtime()->gc)
-      , compartments(cx->zone())
-      , url(cx)
-      , displayURLString(cx)
-      , hasSource(false)
-      , source(cx, AsVariant(static_cast<ScriptSourceObject*>(nullptr)))
-      , hasLine{ false }
-      , line{}
-      , innermost{ false }
-      , innermostForCompartment(cx->zone())
-      , vector(cx, ScriptVector(cx))
-      , wasmInstanceVector(cx, WasmInstanceObjectVector(cx))
-      , oom{ false }
-    {
-    }
+    ScriptQuery(JSContext* cx, Debugger* dbg):
+        cx(cx),
+        debugger(dbg),
+        iterMarker(&cx->runtime()->gc),
+        compartments(cx->zone()),
+        url(cx),
+        displayURLString(cx),
+        hasSource(false),
+        source(cx, AsVariant(static_cast<ScriptSourceObject*>(nullptr))),
+        innermostForCompartment(cx->zone()),
+        vector(cx, ScriptVector(cx)),
+        wasmInstanceVector(cx, WasmInstanceObjectVector(cx))
+    {}
 
     /*
      * Initialize this ScriptQuery. Raise an error and return false if we
      * haven't enough memory.
      */
     bool init() {
         if (!compartments.init() ||
             !innermostForCompartment.init())
@@ -5431,21 +5426,17 @@ DebuggerScript_getStartLine(JSContext* c
     return true;
 }
 
 struct DebuggerScriptGetLineCountMatcher
 {
     JSContext* cx_;
     double totalLines;
 
-    explicit DebuggerScriptGetLineCountMatcher(JSContext* cx)
-      : cx_(cx)
-      , totalLines{ 0.0 }
-    {
-    }
+    explicit DebuggerScriptGetLineCountMatcher(JSContext* cx) : cx_(cx) {}
     using ReturnType = bool;
 
     ReturnType match(HandleScript script) {
         totalLines = double(GetScriptLineExtent(script));
         return true;
     }
     ReturnType match(Handle<WasmInstanceObject*> wasmInstance) {
         uint32_t result;
@@ -6659,22 +6650,17 @@ DebuggerScript_clearAllBreakpoints(JSCon
 
 class DebuggerScriptIsInCatchScopeMatcher
 {
     JSContext* cx_;
     size_t offset_;
     bool isInCatch_;
 
   public:
-    explicit DebuggerScriptIsInCatchScopeMatcher(JSContext* cx, size_t offset)
-      : cx_(cx)
-      , offset_(offset)
-      , isInCatch_{ false }
-    {
-    }
+    explicit DebuggerScriptIsInCatchScopeMatcher(JSContext* cx, size_t offset) : cx_(cx), offset_(offset) { }
     using ReturnType = bool;
 
     inline bool isInCatch() const { return isInCatch_; }
 
     ReturnType match(HandleScript script) {
         if (!EnsureScriptOffsetIsValid(cx_, script, offset_))
             return false;
 
--- a/js/src/vm/JSCompartment.h
+++ b/js/src/vm/JSCompartment.h
@@ -52,22 +52,17 @@ struct NativeIterator;
  * is erroneously included in the measurement; see bug 562553.
  */
 class DtoaCache {
     double       d;
     int          base;
     JSFlatString* s;      // if s==nullptr, d and base are not valid
 
   public:
-    DtoaCache()
-      : d{ 0.0 }
-      , base{}
-      , s(nullptr)
-    {
-    }
+    DtoaCache() : s(nullptr) {}
     void purge() { s = nullptr; }
 
     JSFlatString* lookup(int base, double d) {
         return this->s && base == this->base && d == this->d ? this->s : nullptr;
     }
 
     void cache(int base, double d, JSFlatString* s) {
         this->base = base;
@@ -308,19 +303,17 @@ class WrapperMap
         }
 
         Enum(WrapperMap& m, const CompartmentFilter& f, SkipStrings s = WithStrings) :
                 filter(&f), skipStrings(s) {
             outer.emplace(m.map);
             goToNext();
         }
 
-        Enum(WrapperMap& m, JSCompartment* target)
-          : filter{ nullptr } /* FIXME: initialize skipStrings */
-        {
+        Enum(WrapperMap& m, JSCompartment* target) {
             // Leave the outer map as nothing and only iterate the inner map we
             // find here.
             auto p = m.map.lookup(target);
             if (p)
                 inner.emplace(p->value());
         }
 
         bool empty() const {
--- a/js/src/vm/JSScript.cpp
+++ b/js/src/vm/JSScript.cpp
@@ -1622,24 +1622,20 @@ ScriptSource::chunkChars(JSContext* cx, 
     const char16_t* ret = decompressed.get();
     if (!cx->caches().uncompressedSourceCache.put(ssc, Move(decompressed), holder)) {
         JS_ReportOutOfMemory(cx);
         return nullptr;
     }
     return ret;
 }
 
-ScriptSource::PinnedChars::PinnedChars(JSContext* cx,
-                                       ScriptSource* source,
+ScriptSource::PinnedChars::PinnedChars(JSContext* cx, ScriptSource* source,
                                        UncompressedSourceCache::AutoHoldEntry& holder,
-                                       size_t begin,
-                                       size_t len)
-  : stack_{ nullptr }
-  , prev_{ nullptr }
-  , source_(source)
+                                       size_t begin, size_t len)
+  : source_(source)
 {
     chars_ = source->chars(cx, holder, begin, len);
     if (chars_) {
         stack_ = &source->pinnedCharsStack_;
         prev_ = *stack_;
         *stack_ = this;
     }
 }
--- a/js/src/vm/JSScript.h
+++ b/js/src/vm/JSScript.h
@@ -2039,19 +2039,18 @@ class JSScript : public js::gc::TenuredC
 
     class AutoDelazify
     {
         JS::RootedScript script_;
         JSContext* cx_;
         bool oldDoNotRelazify_;
       public:
         explicit AutoDelazify(JSContext* cx, JS::HandleFunction fun = nullptr)
-          : script_(cx)
-          , cx_(cx)
-          , oldDoNotRelazify_{ false }
+            : script_(cx)
+            , cx_(cx)
         {
             holdScript(fun);
         }
 
         ~AutoDelazify()
         {
             dropScript();
         }
--- a/js/src/vm/ObjectGroup.h
+++ b/js/src/vm/ObjectGroup.h
@@ -592,21 +592,17 @@ class ObjectGroupCompartment
 
     // Cache for defaultNewGroup. Purged on GC.
     class DefaultNewGroupCache
     {
         ObjectGroup* group_;
         JSObject* associated_;
 
       public:
-        DefaultNewGroupCache()
-          : associated_{ nullptr }
-        {
-            purge();
-        }
+        DefaultNewGroupCache() { purge(); }
 
         void purge() {
             group_ = nullptr;
         }
         void put(ObjectGroup* group, JSObject* associated) {
             group_ = group;
             associated_ = associated;
         }
--- a/js/src/vm/RegExpShared.h
+++ b/js/src/vm/RegExpShared.h
@@ -229,21 +229,17 @@ class RegExpShared : public gc::TenuredC
 };
 
 class RegExpZone
 {
     struct Key {
         JSAtom* atom;
         uint16_t flag;
 
-        Key()
-          : atom{ nullptr }
-          , flag{}
-        {
-        }
+        Key() {}
         Key(JSAtom* atom, RegExpFlag flag)
           : atom(atom), flag(flag)
         { }
         MOZ_IMPLICIT Key(const ReadBarriered<RegExpShared*>& shared)
           : atom(shared.unbarrieredGet()->getSource()),
             flag(shared.unbarrieredGet()->getFlags())
         { }
 
--- a/js/src/vm/Scope.cpp
+++ b/js/src/vm/Scope.cpp
@@ -1351,27 +1351,16 @@ ScopeIter::ScopeIter(JSScript* script)
 
 bool
 ScopeIter::hasSyntacticEnvironment() const
 {
     return scope()->hasEnvironment() && scope()->kind() != ScopeKind::NonSyntactic;
 }
 
 BindingIter::BindingIter(Scope* scope)
-  : positionalFormalStart_{}
-  , nonPositionalFormalStart_{}
-  , topLevelFunctionStart_{}
-  , varStart_{}
-  , letStart_{}
-  , constStart_{}
-  , flags_{ '\0' }
-  , argumentSlot_{}
-  , frameSlot_{}
-  , environmentSlot_{}
-  , names_{ nullptr }
 {
     switch (scope->kind()) {
       case ScopeKind::Lexical:
       case ScopeKind::SimpleCatch:
       case ScopeKind::Catch:
         init(scope->as<LexicalScope>().data(),
              scope->as<LexicalScope>().firstFrameSlot(), 0);
         break;
--- a/js/src/vm/Scope.h
+++ b/js/src/vm/Scope.h
@@ -1218,141 +1218,43 @@ class BindingIter
                 increment();
         }
     }
 
   public:
     explicit BindingIter(Scope* scope);
     explicit BindingIter(JSScript* script);
 
-    BindingIter(LexicalScope::Data& data, uint32_t firstFrameSlot, bool isNamedLambda)
-      : positionalFormalStart_{}
-      , nonPositionalFormalStart_{}
-      , topLevelFunctionStart_{}
-      , varStart_{}
-      , letStart_{}
-      , constStart_{}
-      , length_{}
-      , index_{}
-      , flags_{ '\0' }
-      , argumentSlot_{}
-      , frameSlot_{}
-      , environmentSlot_{}
-      , names_{ nullptr }
-    {
+    BindingIter(LexicalScope::Data& data, uint32_t firstFrameSlot, bool isNamedLambda) {
         init(data, firstFrameSlot, isNamedLambda ? IsNamedLambda : 0);
     }
 
-    BindingIter(FunctionScope::Data& data, bool hasParameterExprs)
-      : positionalFormalStart_{}
-      , nonPositionalFormalStart_{}
-      , topLevelFunctionStart_{}
-      , varStart_{}
-      , letStart_{}
-      , constStart_{}
-      , length_{}
-      , index_{}
-      , flags_{ '\0' }
-      , argumentSlot_{}
-      , frameSlot_{}
-      , environmentSlot_{}
-      , names_{ nullptr }
-    {
+    BindingIter(FunctionScope::Data& data, bool hasParameterExprs) {
         init(data,
              IgnoreDestructuredFormalParameters |
              (hasParameterExprs ? HasFormalParameterExprs : 0));
     }
 
-    BindingIter(VarScope::Data& data, uint32_t firstFrameSlot)
-      : positionalFormalStart_{}
-      , nonPositionalFormalStart_{}
-      , topLevelFunctionStart_{}
-      , varStart_{}
-      , letStart_{}
-      , constStart_{}
-      , length_{}
-      , index_{}
-      , flags_{ '\0' }
-      , argumentSlot_{}
-      , frameSlot_{}
-      , environmentSlot_{}
-      , names_{ nullptr }
-    {
+    BindingIter(VarScope::Data& data, uint32_t firstFrameSlot) {
         init(data, firstFrameSlot);
     }
 
-    explicit BindingIter(GlobalScope::Data& data)
-      : positionalFormalStart_{}
-      , nonPositionalFormalStart_{}
-      , topLevelFunctionStart_{}
-      , varStart_{}
-      , letStart_{}
-      , constStart_{}
-      , length_{}
-      , index_{}
-      , flags_{ '\0' }
-      , argumentSlot_{}
-      , frameSlot_{}
-      , environmentSlot_{}
-      , names_{ nullptr }
-    {
+    explicit BindingIter(GlobalScope::Data& data) {
         init(data);
     }
 
-    explicit BindingIter(ModuleScope::Data& data)
-      : positionalFormalStart_{}
-      , nonPositionalFormalStart_{}
-      , topLevelFunctionStart_{}
-      , varStart_{}
-      , letStart_{}
-      , constStart_{}
-      , length_{}
-      , index_{}
-      , flags_{ '\0' }
-      , argumentSlot_{}
-      , frameSlot_{}
-      , environmentSlot_{}
-      , names_{ nullptr }
-    {
+    explicit BindingIter(ModuleScope::Data& data) {
         init(data);
     }
 
-    explicit BindingIter(WasmFunctionScope::Data& data)
-      : positionalFormalStart_{}
-      , nonPositionalFormalStart_{}
-      , topLevelFunctionStart_{}
-      , varStart_{}
-      , letStart_{}
-      , constStart_{}
-      , length_{}
-      , index_{}
-      , flags_{ '\0' }
-      , argumentSlot_{}
-      , frameSlot_{}
-      , environmentSlot_{}
-      , names_{ nullptr }
-    {
+    explicit BindingIter(WasmFunctionScope::Data& data) {
         init(data);
     }
 
-    BindingIter(EvalScope::Data& data, bool strict)
-      : positionalFormalStart_{}
-      , nonPositionalFormalStart_{}
-      , topLevelFunctionStart_{}
-      , varStart_{}
-      , letStart_{}
-      , constStart_{}
-      , length_{}
-      , index_{}
-      , flags_{ '\0' }
-      , argumentSlot_{}
-      , frameSlot_{}
-      , environmentSlot_{}
-      , names_{ nullptr }
-    {
+    BindingIter(EvalScope::Data& data, bool strict) {
         init(data, strict);
     }
 
     explicit BindingIter(const BindingIter& bi) = default;
 
     bool done() const {
         return index_ == length_;
     }
--- a/js/src/vm/Shape.h
+++ b/js/src/vm/Shape.h
@@ -1533,24 +1533,24 @@ class MutableWrappedPtrOperations<StackS
     void updateGetterSetter(GetterOp rawGetter, SetterOp rawSetter) {
         ss().updateGetterSetter(rawGetter, rawSetter);
     }
     void setSlot(uint32_t slot) { ss().setSlot(slot); }
     void setBase(UnownedBaseShape* base) { ss().base = base; }
     void setAttrs(uint8_t attrs) { ss().attrs = attrs; }
 };
 
-inline Shape::Shape(const StackShape& other, uint32_t nfixed)
-  : base_(other.base)
-  , propid_(other.propid)
-  , slotInfo(other.maybeSlot() | (nfixed << FIXED_SLOTS_SHIFT))
-  , attrs(other.attrs)
-  , flags(other.flags)
-  , parent(nullptr)
-  , listp{ nullptr }
+inline
+Shape::Shape(const StackShape& other, uint32_t nfixed)
+  : base_(other.base),
+    propid_(other.propid),
+    slotInfo(other.maybeSlot() | (nfixed << FIXED_SLOTS_SHIFT)),
+    attrs(other.attrs),
+    flags(other.flags),
+    parent(nullptr)
 {
 #ifdef DEBUG
     gc::AllocKind allocKind = getAllocKind();
     MOZ_ASSERT_IF(other.isAccessorShape(), allocKind == gc::AllocKind::ACCESSOR_SHAPE);
     MOZ_ASSERT_IF(allocKind == gc::AllocKind::SHAPE, !other.isAccessorShape());
 #endif
 
     MOZ_ASSERT_IF(!isEmptyShape(), AtomIsMarked(zone(), propid()));
@@ -1565,24 +1565,24 @@ class NurseryShapesRef : public gc::Buff
 {
     Zone* zone_;
 
   public:
     explicit NurseryShapesRef(Zone* zone) : zone_(zone) {}
     void trace(JSTracer* trc) override;
 };
 
-inline Shape::Shape(UnownedBaseShape* base, uint32_t nfixed)
-  : base_(base)
-  , propid_(JSID_EMPTY)
-  , slotInfo(SHAPE_INVALID_SLOT | (nfixed << FIXED_SLOTS_SHIFT))
-  , attrs(0)
-  , flags(0)
-  , parent(nullptr)
-  , listp{ nullptr }
+inline
+Shape::Shape(UnownedBaseShape* base, uint32_t nfixed)
+  : base_(base),
+    propid_(JSID_EMPTY),
+    slotInfo(SHAPE_INVALID_SLOT | (nfixed << FIXED_SLOTS_SHIFT)),
+    attrs(0),
+    flags(0),
+    parent(nullptr)
 {
     MOZ_ASSERT(base);
     kids.setNull();
 }
 
 inline GetterOp
 Shape::getter() const
 {
--- a/js/src/vm/Stack.cpp
+++ b/js/src/vm/Stack.cpp
@@ -1509,30 +1509,25 @@ ActivationEntryMonitor::ActivationEntryM
         else
             entryMonitor_->Entry(cx_, jit::CalleeTokenToScript(entryToken), stack, asyncCause);
     }
 }
 
 /*****************************************************************************/
 
 jit::JitActivation::JitActivation(JSContext* cx)
-  : Activation(cx, Jit)
-  , packedExitFP_(nullptr)
-  , encodedWasmExitReason_(0)
-  , prevJitActivation_(cx->jitActivation)
-  , rematerializedFrames_(nullptr)
-  , ionRecovery_(cx)
-  , bailoutData_(nullptr)
-  , lastProfilingFrame_(nullptr)
-  , lastProfilingCallSite_(nullptr)
-#ifdef CHECK_OSIPOINT_REGISTERS
-  , checkRegs_
-{
-}
-#endif
+  : Activation(cx, Jit),
+    packedExitFP_(nullptr),
+    encodedWasmExitReason_(0),
+    prevJitActivation_(cx->jitActivation),
+    rematerializedFrames_(nullptr),
+    ionRecovery_(cx),
+    bailoutData_(nullptr),
+    lastProfilingFrame_(nullptr),
+    lastProfilingCallSite_(nullptr)
 {
     cx->jitActivation = this;
     registerProfiling();
 }
 
 jit::JitActivation::~JitActivation()
 {
     if (isProfiling())
--- a/js/src/vm/StructuredClone.cpp
+++ b/js/src/vm/StructuredClone.cpp
@@ -376,29 +376,21 @@ class SCInput {
     JSContext* cx;
     BufferIterator point;
 };
 
 } // namespace js
 
 struct JSStructuredCloneReader {
   public:
-    explicit JSStructuredCloneReader(SCInput& in,
-                                     JS::StructuredCloneScope scope,
+    explicit JSStructuredCloneReader(SCInput& in, JS::StructuredCloneScope scope,
                                      const JSStructuredCloneCallbacks* cb,
                                      void* cbClosure)
-      : in(in)
-      , allowedScope(scope)
-      , storedScope{ static_cast<JS::StructuredCloneScope>(0) }
-      , objs(in.context())
-      , allObjs(in.context())
-      , callbacks(cb)
-      , closure(cbClosure)
-    {
-    }
+        : in(in), allowedScope(scope), objs(in.context()), allObjs(in.context()),
+          callbacks(cb), closure(cbClosure) { }
 
     SCInput& input() { return in; }
     bool read(MutableHandleValue vp);
 
   private:
     JSContext* context() { return in.context(); }
 
     bool readHeader();
--- a/js/src/vm/SymbolType.h
+++ b/js/src/vm/SymbolType.h
@@ -41,20 +41,17 @@ class Symbol : public js::gc::TenuredCel
     JSAtom* description_;
 
     // The minimum allocation size is sizeof(JSString): 16 bytes on 32-bit
     // architectures and 24 bytes on 64-bit.  A size_t of padding makes Symbol
     // the minimum size on both.
     size_t unused_;
 
     Symbol(SymbolCode code, js::HashNumber hash, JSAtom* desc)
-      : code_(code)
-      , hash_(hash)
-      , description_(desc)
-      , unused_{}
+        : code_(code), hash_(hash), description_(desc)
     {
         // Silence warnings about unused_ being... unused.
         (void)unused_;
     }
 
     Symbol(const Symbol&) = delete;
     void operator=(const Symbol&) = delete;
 
--- a/js/src/vm/TraceLogging.h
+++ b/js/src/vm/TraceLogging.h
@@ -566,36 +566,34 @@ class MOZ_RAII AutoTraceLog
     } payload;
     bool isEvent;
     bool executed;
     AutoTraceLog* prev;
 
   public:
     AutoTraceLog(TraceLoggerThread* logger,
                  const TraceLoggerEvent& event MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
-      : logger(logger)
-      , isEvent(true)
-      , executed(false)
-      , prev{ nullptr }
+      : logger(logger),
+        isEvent(true),
+        executed(false)
     {
         MOZ_GUARD_OBJECT_NOTIFIER_INIT;
         payload.event = &event;
         if (logger) {
             logger->startEvent(event);
 
             prev = logger->top;
             logger->top = this;
         }
     }
 
     AutoTraceLog(TraceLoggerThread* logger, TraceLoggerTextId id MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
-      : logger(logger)
-      , isEvent(false)
-      , executed(false)
-      , prev{ nullptr }
+      : logger(logger),
+        isEvent(false),
+        executed(false)
     {
         MOZ_GUARD_OBJECT_NOTIFIER_INIT;
         payload.id = id;
         if (logger) {
             logger->startEvent(id);
 
             prev = logger->top;
             logger->top = this;
--- a/js/src/vm/TraceLoggingGraph.h
+++ b/js/src/vm/TraceLoggingGraph.h
@@ -125,22 +125,17 @@ class TraceLoggerGraph
         {
             start_ = start;
             stop_ = stop;
             u.s.textId_ = textId;
             u.s.hasChildren_ = hasChildren;
             nextId_ = nextId;
         }
         TreeEntry()
-          : start_{}
-          , stop_{}
-          , u{}
-          , nextId_{}
-        {
-        }
+        { }
         uint64_t start() {
             return start_;
         }
         uint64_t stop() {
             return stop_;
         }
         uint32_t textId() {
             return u.s.textId_;
--- a/js/src/vm/TraceLoggingTypes.h
+++ b/js/src/vm/TraceLoggingTypes.h
@@ -156,22 +156,19 @@ class ContinuousSpace {
     T* data_;
     uint32_t size_;
     uint32_t capacity_;
 
     // The maximum number of bytes of RAM a continuous space structure can take.
     static const uint32_t LIMIT = 200 * 1024 * 1024;
 
   public:
-    ContinuousSpace()
-      : data_(nullptr)
-      , size_{}
-      , capacity_{}
-    {
-    }
+    ContinuousSpace ()
+     : data_(nullptr)
+    { }
 
     bool init() {
         capacity_ = 64;
         size_ = 0;
         data_ = (T*) js_malloc(capacity_ * sizeof(T));
         if (!data_)
             return false;
 
--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -132,39 +132,33 @@ class AsmJSGlobal
     struct CacheablePod {
         Which which_;
         union V {
             struct {
                 VarInitKind initKind_;
                 union U {
                     ValType importType_;
                     Val val_;
-                    U()
-                      : importType_{ static_cast<ValType>(0) }
-                    {
-                    }
+                    U() {}
                 } u;
             } var;
             uint32_t ffiIndex_;
             Scalar::Type viewType_;
             AsmJSMathBuiltinFunction mathBuiltinFunc_;
             AsmJSAtomicsBuiltinFunction atomicsBuiltinFunc_;
             SimdType simdCtorType_;
             struct {
                 SimdType type_;
                 SimdOperation which_;
             } simdOp;
             struct {
                 ConstantKind kind_;
                 double value_;
             } constant;
-            V()
-              : ffiIndex_{}
-            {
-            }
+            V() {}
         } u;
     } pod;
     CacheableChars field_;
 
     friend class ModuleValidator;
 
   public:
     AsmJSGlobal() = default;
@@ -336,21 +330,20 @@ struct js::AsmJSMetadata : Metadata, Asm
     uint32_t srcEndBeforeCurly() const {
         return srcStart + srcLength;
     }
     uint32_t srcEndAfterCurly() const {
         return srcStart + srcLengthWithRightBrace;
     }
 
     AsmJSMetadata()
-      : Metadata(ModuleKind::AsmJS)
-      , cacheResult(CacheResult::Miss)
-      , toStringStart{}
-      , srcStart(0)
-      , strict(false)
+      : Metadata(ModuleKind::AsmJS),
+        cacheResult(CacheResult::Miss),
+        srcStart(0),
+        strict(false)
     {}
     ~AsmJSMetadata() override {}
 
     const AsmJSExport& lookupAsmJSExport(uint32_t funcIndex) const {
         // The AsmJSExportVector isn't stored in sorted order so do a linear
         // search. This is for the super-cold and already-expensive toString()
         // path and the number of exports is generally small.
         for (const AsmJSExport& exp : asmJSExports) {
@@ -1581,21 +1574,17 @@ class MOZ_STACK_CLASS ModuleValidator
         enum Kind { Function, Constant };
         Kind kind;
 
         union {
             double cst;
             AsmJSMathBuiltinFunction func;
         } u;
 
-        MathBuiltin()
-          : kind(Kind(-1))
-          , u{}
-        {
-        }
+        MathBuiltin() : kind(Kind(-1)) {}
         explicit MathBuiltin(double cst) : kind(Constant) {
             u.cst = cst;
         }
         explicit MathBuiltin(AsmJSMathBuiltinFunction func) : kind(Function) {
             u.func = func;
         }
     };
 
--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -948,26 +948,24 @@ using ScratchI8 = ScratchI32;
 
 // BaseLocalIter iterates over a vector of types of locals and provides offsets
 // from the Frame address for those locals, and associated data.
 //
 // The implementation of BaseLocalIter is the property of the BaseStackFrame.
 // But it is also exposed for eg the debugger to use.
 
 BaseLocalIter::BaseLocalIter(const ValTypeVector& locals, size_t argsLength, bool debugEnabled)
-  : locals_(locals)
-  , argsLength_(argsLength)
-  , argsRange_(locals.begin(), argsLength)
-  , argsIter_(argsRange_)
-  , index_(0)
-  , localSize_(debugEnabled ? DebugFrame::offsetOfFrame() : 0)
-  , reservedSize_(localSize_)
-  , frameOffset_{}
-  , mirType_{ MIRType::Undefined }
-  , done_(false)
+  : locals_(locals),
+    argsLength_(argsLength),
+    argsRange_(locals.begin(), argsLength),
+    argsIter_(argsRange_),
+    index_(0),
+    localSize_(debugEnabled ? DebugFrame::offsetOfFrame() : 0),
+    reservedSize_(localSize_),
+    done_(false)
 {
     MOZ_ASSERT(argsLength <= locals.length());
     settle();
 }
 
 int32_t
 BaseLocalIter::pushLocal(size_t nbytes)
 {
--- a/js/src/wasm/WasmBinaryIterator.h
+++ b/js/src/wasm/WasmBinaryIterator.h
@@ -171,20 +171,17 @@ Classify(OpBytes op);
 template <typename Value>
 struct LinearMemoryAddress
 {
     Value base;
     uint32_t offset;
     uint32_t align;
 
     LinearMemoryAddress()
-      : offset{}
-      , align{}
-    {
-    }
+    {}
     LinearMemoryAddress(Value base, uint32_t offset, uint32_t align)
       : base(base), offset(offset), align(align)
     {}
 };
 
 template <typename ControlItem>
 class ControlStackEntry
 {
--- a/js/src/wasm/WasmFrameIter.cpp
+++ b/js/src/wasm/WasmFrameIter.cpp
@@ -29,24 +29,23 @@ using namespace js::wasm;
 
 using mozilla::DebugOnly;
 using mozilla::Maybe;
 
 /*****************************************************************************/
 // WasmFrameIter implementation
 
 WasmFrameIter::WasmFrameIter(JitActivation* activation, wasm::Frame* fp)
-  : activation_(activation)
-  , code_(nullptr)
-  , codeRange_(nullptr)
-  , lineOrBytecode_(0)
-  , fp_(fp ? fp : activation->wasmExitFP())
-  , unwoundIonCallerFP_(nullptr)
-  , unwind_(Unwind::False)
-  , unwoundAddressOfReturnAddress_{ nullptr }
+  : activation_(activation),
+    code_(nullptr),
+    codeRange_(nullptr),
+    lineOrBytecode_(0),
+    fp_(fp ? fp : activation->wasmExitFP()),
+    unwoundIonCallerFP_(nullptr),
+    unwind_(Unwind::False)
 {
     MOZ_ASSERT(fp_);
 
     // When the stack is captured during a trap (viz., to create the .stack
     // for an Error object), use the pc/bytecode information captured by the
     // signal handler in the runtime.
 
     if (activation->isWasmTrapping()) {
--- a/js/src/wasm/WasmFrameIter.h
+++ b/js/src/wasm/WasmFrameIter.h
@@ -92,20 +92,17 @@ enum class SymbolicAddress;
 // An ExitReason describes the possible reasons for leaving compiled wasm
 // code or the state of not having left compiled wasm code
 // (ExitReason::None). It is either a known reason, or a enumeration to a native
 // function that is used for better display in the profiler.
 class ExitReason
 {
     uint32_t payload_;
 
-    ExitReason()
-      : payload_{}
-    {
-    }
+    ExitReason() {}
 
   public:
     enum class Fixed : uint32_t
     {
         None,            // default state, the pc is in wasm code
         FakeInterpEntry, // slow-path entry call from C++ WasmCall()
         ImportJit,       // fast-path call directly into JIT code
         ImportInterp,    // slow-path call into C++ Invoke()
--- a/js/src/wasm/WasmJS.cpp
+++ b/js/src/wasm/WasmJS.cpp
@@ -2818,31 +2818,28 @@ class CompileStreamTask : public Promise
         return module_
                ? Resolve(cx, *module_, promise, instantiate_, importObj_)
                : streamError_
                  ? RejectWithErrorNumber(cx, *streamError_, promise)
                  : Reject(cx, *compileArgs_, Move(compileError_), promise);
     }
 
   public:
-    CompileStreamTask(JSContext* cx,
-                      Handle<PromiseObject*> promise,
-                      CompileArgs& compileArgs,
-                      bool instantiate,
+    CompileStreamTask(JSContext* cx, Handle<PromiseObject*> promise,
+                      CompileArgs& compileArgs, bool instantiate,
                       HandleObject importObj)
-      : PromiseHelperTask(cx, promise)
-      , compileArgs_(&compileArgs)
-      , instantiate_(instantiate)
-      , importObj_(cx, importObj)
-      , streamState_(mutexid::WasmStreamStatus, Env)
-      , codeSection_{}
-      , codeStreamEnd_(nullptr)
-      , exclusiveCodeStreamEnd_(mutexid::WasmCodeStreamEnd, nullptr)
-      , exclusiveTailBytes_(mutexid::WasmTailBytesPtr, nullptr)
-      , streamFailed_(false)
+      : PromiseHelperTask(cx, promise),
+        compileArgs_(&compileArgs),
+        instantiate_(instantiate),
+        importObj_(cx, importObj),
+        streamState_(mutexid::WasmStreamStatus, Env),
+        codeStreamEnd_(nullptr),
+        exclusiveCodeStreamEnd_(mutexid::WasmCodeStreamEnd, nullptr),
+        exclusiveTailBytes_(mutexid::WasmTailBytesPtr, nullptr),
+        streamFailed_(false)
     {
         MOZ_ASSERT_IF(importObj_, instantiate_);
     }
 };
 
 // A short-lived object that captures the arguments of a
 // WebAssembly.{compileStreaming,instantiateStreaming} while waiting for
 // the Promise<Response> to resolve to a (hopefully) Promise.
--- a/js/src/wasm/WasmTextToBinary.cpp
+++ b/js/src/wasm/WasmTextToBinary.cpp
@@ -154,20 +154,19 @@ class WasmToken
   public:
     WasmToken()
       : kind_(Kind::Invalid),
         begin_(nullptr),
         end_(nullptr),
         u()
     { }
     WasmToken(Kind kind, const char16_t* begin, const char16_t* end)
-      : kind_(kind)
-      , begin_(begin)
-      , end_(end)
-      , u{}
+      : kind_(kind),
+        begin_(begin),
+        end_(end)
     {
         MOZ_ASSERT(kind_ != Error);
         MOZ_ASSERT(kind_ != Invalid);
         MOZ_ASSERT((kind == EndOfFile) == (begin == end));
     }
     explicit WasmToken(uint32_t index, const char16_t* begin, const char16_t* end)
       : kind_(Index),
         begin_(begin),
@@ -238,22 +237,20 @@ class WasmToken
         end_(end)
     {
         MOZ_ASSERT(begin != end);
         MOZ_ASSERT(kind_ == AtomicCmpXchg || kind_ == AtomicLoad || kind_ == AtomicRMW ||
                    kind_ == AtomicStore || kind_ == Wait || kind_ == Wake);
         u.threadOp_ = op;
     }
     explicit WasmToken(const char16_t* begin)
-      : kind_(Error)
-      , begin_(begin)
-      , end_(begin)
-      , u{}
-    {
-    }
+      : kind_(Error),
+        begin_(begin),
+        end_(begin)
+    {}
     Kind kind() const {
         MOZ_ASSERT(kind_ != Kind::Invalid);
         return kind_;
     }
     const char16_t* begin() const {
         return begin_;
     }
     const char16_t* end() const {
--- a/js/src/wasm/WasmTypes.h
+++ b/js/src/wasm/WasmTypes.h
@@ -464,20 +464,17 @@ class Val
         uint32_t i32_;
         uint64_t i64_;
         float f32_;
         double f64_;
         I8x16 i8x16_;
         I16x8 i16x8_;
         I32x4 i32x4_;
         F32x4 f32x4_;
-        U()
-          : i32_{}
-        {
-        }
+        U() {}
     } u;
 
   public:
     Val() = default;
 
     explicit Val(uint32_t i32) : type_(ValType::I32) { u.i32_ = i32; }
     explicit Val(uint64_t i64) : type_(ValType::I64) { u.i64_ = i64; }
 
@@ -604,20 +601,17 @@ class InitExpr
   private:
     Kind kind_;
     union U {
         Val val_;
         struct {
             uint32_t index_;
             ValType type_;
         } global;
-        U()
-          : global{}
-        {
-        }
+        U() {}
     } u;
 
   public:
     InitExpr() = default;
 
     explicit InitExpr(Val val) : kind_(Kind::Constant) {
         u.val_ = val;
     }
@@ -730,20 +724,17 @@ class GlobalDesc
     union V {
         struct {
             union U {
                 InitExpr initial_;
                 struct {
                     ValType type_;
                     uint32_t index_;
                 } import;
-                U()
-                  : import{}
-                {
-                }
+                U() {}
             } val;
             unsigned offset_;
             bool isMutable_;
             bool isWasm_;
             bool isExport_;
         } var;
         Val cst_;
         V() {}
@@ -1316,21 +1307,17 @@ class CallSiteDesc
     enum Kind {
         Func,       // pc-relative call to a specific function
         Dynamic,    // dynamic callee called via register
         Symbolic,   // call to a single symbolic callee
         EnterFrame, // call to a enter frame handler
         LeaveFrame, // call to a leave frame handler
         Breakpoint  // call to instruction breakpoint
     };
-    CallSiteDesc()
-      : lineOrBytecode_{}
-      , kind_{}
-    {
-    }
+    CallSiteDesc() {}
     explicit CallSiteDesc(Kind kind)
       : lineOrBytecode_(0), kind_(kind)
     {
         MOZ_ASSERT(kind == Kind(kind_));
     }
     CallSiteDesc(uint32_t lineOrBytecode, Kind kind)
       : lineOrBytecode_(lineOrBytecode), kind_(kind)
     {
@@ -1341,20 +1328,17 @@ class CallSiteDesc
     Kind kind() const { return Kind(kind_); }
 };
 
 class CallSite : public CallSiteDesc
 {
     uint32_t returnAddressOffset_;
 
   public:
-    CallSite()
-      : returnAddressOffset_{}
-    {
-    }
+    CallSite() {}
 
     CallSite(CallSiteDesc desc, uint32_t returnAddressOffset)
       : CallSiteDesc(desc),
         returnAddressOffset_(returnAddressOffset)
     { }
 
     void offsetBy(int32_t delta) { returnAddressOffset_ += delta; }
     uint32_t returnAddressOffset() const { return returnAddressOffset_; }
@@ -1719,35 +1703,32 @@ class CalleeDesc
         // Like Builtin, but automatically passes Instance* as first argument.
         BuiltinInstanceMethod
     };
 
   private:
     // which_ shall be initialized in the static constructors
     MOZ_INIT_OUTSIDE_CTOR Which which_;
     union U {
-        U()
-          : funcIndex_{}
-        {
-        }
+        U() {}
         uint32_t funcIndex_;
         struct {
             uint32_t globalDataOffset_;
         } import;
         struct {
             uint32_t globalDataOffset_;
             uint32_t minLength_;
             bool external_;
             SigIdDesc sigId_;
         } table;
         SymbolicAddress builtin_;
     } u;
 
   public:
-    CalleeDesc() /* FIXME: initialize which_ */ {}
+    CalleeDesc() {}
     static CalleeDesc function(uint32_t funcIndex) {
         CalleeDesc c;
         c.which_ = Func;
         c.u.funcIndex_ = funcIndex;
         return c;
     }
     static CalleeDesc import(uint32_t globalDataOffset) {
         CalleeDesc c;