indent js draft
authorSylvestre Ledru <sledru@mozilla.com>
Fri, 24 Feb 2017 09:56:12 +0100
changeset 489669 a902510561e752b603045b94fe96356835fcd07e
parent 489668 cbb8fdf1daf98a15f7d57f6b08d273bdf96aa1a0
child 489670 0bef48d2d1938fdcae5371c724a718ffea33f697
push id46877
push userbmo:sledru@mozilla.com
push dateSat, 25 Feb 2017 15:06:04 +0000
milestone54.0a1
indent js MozReview-Commit-ID: 3gHZS7Nnmp8
js/src/NamespaceImports.h
js/src/builtin/AtomicsObject.cpp
js/src/builtin/AtomicsObject.h
js/src/builtin/DataViewObject.cpp
js/src/builtin/DataViewObject.h
js/src/builtin/Eval.cpp
js/src/builtin/Eval.h
js/src/builtin/Intl.cpp
js/src/builtin/Intl.h
js/src/builtin/IntlTimeZoneData.h
js/src/builtin/MapObject.cpp
js/src/builtin/MapObject.h
js/src/builtin/ModuleObject.cpp
js/src/builtin/ModuleObject.h
js/src/builtin/Object.cpp
js/src/builtin/Object.h
js/src/builtin/Profilers.cpp
js/src/builtin/Profilers.h
js/src/builtin/Promise.cpp
js/src/builtin/Promise.h
js/src/builtin/Reflect.cpp
js/src/builtin/Reflect.h
js/src/builtin/ReflectParse.cpp
js/src/builtin/RegExp.cpp
js/src/builtin/RegExp.h
js/src/builtin/SIMD.cpp
js/src/builtin/SIMD.h
js/src/builtin/SelfHostingDefines.h
js/src/builtin/SymbolObject.cpp
js/src/builtin/SymbolObject.h
js/src/builtin/TestingFunctions.cpp
js/src/builtin/TestingFunctions.h
js/src/builtin/TypedObject.cpp
js/src/builtin/TypedObject.h
js/src/builtin/TypedObjectConstants.h
js/src/builtin/WeakMapObject.cpp
js/src/builtin/WeakSetObject.cpp
js/src/ctypes/CTypes.cpp
js/src/ctypes/CTypes.h
js/src/ctypes/Library.cpp
js/src/ctypes/Library.h
js/src/ctypes/libffi/include/ffi_common.h
js/src/ctypes/libffi/src/aarch64/ffitarget.h
js/src/ctypes/libffi/src/alpha/ffitarget.h
js/src/ctypes/libffi/src/arc/ffitarget.h
js/src/ctypes/libffi/src/arm/ffitarget.h
js/src/ctypes/libffi/src/avr32/ffitarget.h
js/src/ctypes/libffi/src/bfin/ffitarget.h
js/src/ctypes/libffi/src/cris/ffitarget.h
js/src/ctypes/libffi/src/frv/ffitarget.h
js/src/ctypes/libffi/src/ia64/ffitarget.h
js/src/ctypes/libffi/src/ia64/ia64_flags.h
js/src/ctypes/libffi/src/m32r/ffitarget.h
js/src/ctypes/libffi/src/m68k/ffitarget.h
js/src/ctypes/libffi/src/m88k/ffitarget.h
js/src/ctypes/libffi/src/metag/ffitarget.h
js/src/ctypes/libffi/src/microblaze/ffitarget.h
js/src/ctypes/libffi/src/mips/ffitarget.h
js/src/ctypes/libffi/src/moxie/ffitarget.h
js/src/ctypes/libffi/src/nios2/ffitarget.h
js/src/ctypes/libffi/src/pa/ffitarget.h
js/src/ctypes/libffi/src/powerpc/asm.h
js/src/ctypes/libffi/src/powerpc/ffi_powerpc.h
js/src/ctypes/libffi/src/powerpc/ffitarget.h
js/src/ctypes/libffi/src/s390/ffitarget.h
js/src/ctypes/libffi/src/sh/ffitarget.h
js/src/ctypes/libffi/src/sh64/ffitarget.h
js/src/ctypes/libffi/src/sparc/ffitarget.h
js/src/ctypes/libffi/src/tile/ffitarget.h
js/src/ctypes/libffi/src/vax/ffitarget.h
js/src/ctypes/libffi/src/x86/ffitarget.h
js/src/ctypes/libffi/src/xtensa/ffitarget.h
js/src/ctypes/libffi/testsuite/libffi.call/ffitest.h
js/src/ctypes/typedefs.h
js/src/devtools/Instruments.cpp
js/src/devtools/Instruments.h
js/src/devtools/gctrace/gcstats.cpp
js/src/devtools/rootAnalysis/t/exceptions/source.cpp
js/src/devtools/rootAnalysis/t/hazards/source.cpp
js/src/devtools/rootAnalysis/t/sixgill-tree/source.cpp
js/src/devtools/rootAnalysis/t/suppression/source.cpp
js/src/devtools/sharkctl.cpp
js/src/devtools/sharkctl.h
js/src/devtools/vprof/vprof.cpp
js/src/devtools/vprof/vprof.h
js/src/ds/BitArray.h
js/src/ds/Fifo.h
js/src/ds/FixedSizeHash.h
js/src/ds/IdValuePair.h
js/src/ds/InlineTable.h
js/src/ds/LifoAlloc.cpp
js/src/ds/LifoAlloc.h
js/src/ds/MemoryProtectionExceptionHandler.cpp
js/src/ds/OrderedHashTable.h
js/src/ds/PageProtectingVector.h
js/src/ds/PriorityQueue.h
js/src/ds/Sort.h
js/src/ds/SplayTree.h
js/src/ds/TraceableFifo.h
js/src/editline/editline.h
js/src/editline/unix.h
js/src/frontend/BytecodeCompiler.cpp
js/src/frontend/BytecodeCompiler.h
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/BytecodeEmitter.h
js/src/frontend/FoldConstants.cpp
js/src/frontend/FoldConstants.h
js/src/frontend/FullParseHandler.h
js/src/frontend/NameAnalysisTypes.h
js/src/frontend/NameCollections.h
js/src/frontend/NameFunctions.cpp
js/src/frontend/ParseNode.cpp
js/src/frontend/ParseNode.h
js/src/frontend/Parser.cpp
js/src/frontend/Parser.h
js/src/frontend/ReservedWords.h
js/src/frontend/SharedContext.h
js/src/frontend/SourceNotes.h
js/src/frontend/SyntaxParseHandler.h
js/src/frontend/TokenKind.h
js/src/frontend/TokenStream.cpp
js/src/frontend/TokenStream.h
js/src/gc/Allocator.cpp
js/src/gc/Allocator.h
js/src/gc/AtomMarking.cpp
js/src/gc/AtomMarking.h
js/src/gc/Barrier.cpp
js/src/gc/Barrier.h
js/src/gc/FindSCCs.h
js/src/gc/GCInternals.h
js/src/gc/GCRuntime.h
js/src/gc/GCTrace.cpp
js/src/gc/GCTrace.h
js/src/gc/GCTraceFormat.h
js/src/gc/Heap.h
js/src/gc/Iteration.cpp
js/src/gc/Marking.cpp
js/src/gc/Marking.h
js/src/gc/Memory.cpp
js/src/gc/Memory.h
js/src/gc/Nursery-inl.h
js/src/gc/Nursery.cpp
js/src/gc/Nursery.h
js/src/gc/NurseryAwareHashMap.h
js/src/gc/Policy.h
js/src/gc/RootMarking.cpp
js/src/gc/Rooting.h
js/src/gc/Statistics.cpp
js/src/gc/Statistics.h
js/src/gc/StoreBuffer.cpp
js/src/gc/StoreBuffer.h
js/src/gc/Tracer.cpp
js/src/gc/Tracer.h
js/src/gc/Verifier.cpp
js/src/gc/Zone.cpp
js/src/gc/Zone.h
js/src/gc/ZoneGroup.cpp
js/src/gc/ZoneGroup.h
js/src/gdb/gdb-tests.cpp
js/src/gdb/gdb-tests.h
js/src/gdb/tests/test-ExecutableAllocator.cpp
js/src/gdb/tests/test-GCCellPtr.cpp
js/src/gdb/tests/test-Interpreter.cpp
js/src/gdb/tests/test-JSObject.cpp
js/src/gdb/tests/test-JSString.cpp
js/src/gdb/tests/test-JSSymbol.cpp
js/src/gdb/tests/test-Root.cpp
js/src/gdb/tests/test-asmjs.cpp
js/src/gdb/tests/test-jsid.cpp
js/src/gdb/tests/test-jsval.cpp
js/src/gdb/tests/test-prettyprinters.cpp
js/src/gdb/tests/test-unwind.cpp
js/src/gdb/tests/typedef-printers.cpp
js/src/irregexp/NativeRegExpMacroAssembler.cpp
js/src/irregexp/NativeRegExpMacroAssembler.h
js/src/irregexp/RegExpAST.cpp
js/src/irregexp/RegExpAST.h
js/src/irregexp/RegExpBytecode.h
js/src/irregexp/RegExpCharacters-inl.h
js/src/irregexp/RegExpCharacters.cpp
js/src/irregexp/RegExpCharacters.h
js/src/irregexp/RegExpEngine.cpp
js/src/irregexp/RegExpEngine.h
js/src/irregexp/RegExpInterpreter.cpp
js/src/irregexp/RegExpMacroAssembler.cpp
js/src/irregexp/RegExpMacroAssembler.h
js/src/irregexp/RegExpParser.cpp
js/src/irregexp/RegExpParser.h
js/src/irregexp/RegExpStack.cpp
js/src/irregexp/RegExpStack.h
js/src/jit/AliasAnalysis.cpp
js/src/jit/AliasAnalysisShared.cpp
js/src/jit/AliasAnalysisShared.h
js/src/jit/AlignmentMaskAnalysis.h
js/src/jit/AtomicOp.h
js/src/jit/AtomicOperations.h
js/src/jit/BacktrackingAllocator.cpp
js/src/jit/BacktrackingAllocator.h
js/src/jit/Bailouts.cpp
js/src/jit/Bailouts.h
js/src/jit/BaselineBailouts.cpp
js/src/jit/BaselineCacheIRCompiler.cpp
js/src/jit/BaselineCacheIRCompiler.h
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineCompiler.h
js/src/jit/BaselineDebugModeOSR.cpp
js/src/jit/BaselineDebugModeOSR.h
js/src/jit/BaselineFrame-inl.h
js/src/jit/BaselineFrame.cpp
js/src/jit/BaselineFrame.h
js/src/jit/BaselineFrameInfo.cpp
js/src/jit/BaselineFrameInfo.h
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineIC.h
js/src/jit/BaselineICList.h
js/src/jit/BaselineInspector.cpp
js/src/jit/BaselineInspector.h
js/src/jit/BaselineJIT.cpp
js/src/jit/BaselineJIT.h
js/src/jit/BitSet.h
js/src/jit/BytecodeAnalysis.cpp
js/src/jit/BytecodeAnalysis.h
js/src/jit/C1Spewer.cpp
js/src/jit/C1Spewer.h
js/src/jit/CacheIR.cpp
js/src/jit/CacheIR.h
js/src/jit/CacheIRCompiler.cpp
js/src/jit/CacheIRCompiler.h
js/src/jit/CacheIRSpewer.cpp
js/src/jit/CacheIRSpewer.h
js/src/jit/CodeGenerator.cpp
js/src/jit/CodeGenerator.h
js/src/jit/CompactBuffer.h
js/src/jit/CompileInfo-inl.h
js/src/jit/CompileInfo.h
js/src/jit/CompileWrappers.cpp
js/src/jit/CompileWrappers.h
js/src/jit/Disassembler.cpp
js/src/jit/Disassembler.h
js/src/jit/EagerSimdUnbox.cpp
js/src/jit/EdgeCaseAnalysis.cpp
js/src/jit/EdgeCaseAnalysis.h
js/src/jit/EffectiveAddressAnalysis.cpp
js/src/jit/EffectiveAddressAnalysis.h
js/src/jit/ExecutableAllocator.cpp
js/src/jit/ExecutableAllocator.h
js/src/jit/FixedList.h
js/src/jit/FlowAliasAnalysis.cpp
js/src/jit/FlowAliasAnalysis.h
js/src/jit/FoldLinearArithConstants.cpp
js/src/jit/ICStubSpace.h
js/src/jit/InlinableNatives.h
js/src/jit/InlineList.h
js/src/jit/InstructionReordering.cpp
js/src/jit/Ion.cpp
js/src/jit/Ion.h
js/src/jit/IonAnalysis.cpp
js/src/jit/IonAnalysis.h
js/src/jit/IonBuilder.cpp
js/src/jit/IonBuilder.h
js/src/jit/IonCacheIRCompiler.cpp
js/src/jit/IonCaches.cpp
js/src/jit/IonCaches.h
js/src/jit/IonCode.h
js/src/jit/IonControlFlow.cpp
js/src/jit/IonControlFlow.h
js/src/jit/IonIC.cpp
js/src/jit/IonIC.h
js/src/jit/IonOptimizationLevels.cpp
js/src/jit/IonOptimizationLevels.h
js/src/jit/IonTypes.h
js/src/jit/JSONPrinter.h
js/src/jit/JSONSpewer.cpp
js/src/jit/JSONSpewer.h
js/src/jit/JitAllocPolicy.h
js/src/jit/JitCommon.h
js/src/jit/JitCompartment.h
js/src/jit/JitFrameIterator-inl.h
js/src/jit/JitFrameIterator.h
js/src/jit/JitFrames-inl.h
js/src/jit/JitFrames.cpp
js/src/jit/JitFrames.h
js/src/jit/JitOptions.cpp
js/src/jit/JitOptions.h
js/src/jit/JitSpewer.cpp
js/src/jit/JitSpewer.h
js/src/jit/JitcodeMap.cpp
js/src/jit/JitcodeMap.h
js/src/jit/LICM.cpp
js/src/jit/LICM.h
js/src/jit/LIR.cpp
js/src/jit/LIR.h
js/src/jit/LOpcodes.h
js/src/jit/Label.h
js/src/jit/Linker.cpp
js/src/jit/Linker.h
js/src/jit/LoopUnroller.cpp
js/src/jit/Lowering.cpp
js/src/jit/Lowering.h
js/src/jit/MCallOptimize.cpp
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jit/MIRGenerator.h
js/src/jit/MIRGraph.cpp
js/src/jit/MIRGraph.h
js/src/jit/MOpcodes.h
js/src/jit/MacroAssembler-inl.h
js/src/jit/MacroAssembler.cpp
js/src/jit/MacroAssembler.h
js/src/jit/MoveEmitter.h
js/src/jit/MoveResolver.cpp
js/src/jit/MoveResolver.h
js/src/jit/OptimizationTracking.cpp
js/src/jit/OptimizationTracking.h
js/src/jit/PcScriptCache.h
js/src/jit/PerfSpewer.cpp
js/src/jit/PerfSpewer.h
js/src/jit/ProcessExecutableMemory.cpp
js/src/jit/ProcessExecutableMemory.h
js/src/jit/RangeAnalysis.cpp
js/src/jit/RangeAnalysis.h
js/src/jit/Recover.cpp
js/src/jit/Recover.h
js/src/jit/RegisterAllocator.cpp
js/src/jit/RegisterAllocator.h
js/src/jit/RegisterSets.h
js/src/jit/Registers.h
js/src/jit/RematerializedFrame.cpp
js/src/jit/RematerializedFrame.h
js/src/jit/Safepoints.cpp
js/src/jit/Safepoints.h
js/src/jit/ScalarReplacement.cpp
js/src/jit/SharedIC.cpp
js/src/jit/SharedIC.h
js/src/jit/SharedICHelpers.h
js/src/jit/SharedICList.h
js/src/jit/SharedICRegisters.h
js/src/jit/Sink.cpp
js/src/jit/Snapshots.cpp
js/src/jit/Snapshots.h
js/src/jit/StackSlotAllocator.h
js/src/jit/StupidAllocator.cpp
js/src/jit/StupidAllocator.h
js/src/jit/TypePolicy.cpp
js/src/jit/TypePolicy.h
js/src/jit/TypedObjectPrediction.cpp
js/src/jit/TypedObjectPrediction.h
js/src/jit/VMFunctions.cpp
js/src/jit/VMFunctions.h
js/src/jit/ValueNumbering.cpp
js/src/jit/ValueNumbering.h
js/src/jit/WasmBCE.cpp
js/src/jit/WasmBCE.h
js/src/jit/arm/Architecture-arm.cpp
js/src/jit/arm/Architecture-arm.h
js/src/jit/arm/Assembler-arm.cpp
js/src/jit/arm/Assembler-arm.h
js/src/jit/arm/AtomicOperations-arm.h
js/src/jit/arm/Bailouts-arm.cpp
js/src/jit/arm/BaselineIC-arm.cpp
js/src/jit/arm/CodeGenerator-arm.cpp
js/src/jit/arm/CodeGenerator-arm.h
js/src/jit/arm/LIR-arm.h
js/src/jit/arm/LOpcodes-arm.h
js/src/jit/arm/Lowering-arm.cpp
js/src/jit/arm/Lowering-arm.h
js/src/jit/arm/MacroAssembler-arm-inl.h
js/src/jit/arm/MacroAssembler-arm.cpp
js/src/jit/arm/MacroAssembler-arm.h
js/src/jit/arm/MoveEmitter-arm.cpp
js/src/jit/arm/MoveEmitter-arm.h
js/src/jit/arm/SharedIC-arm.cpp
js/src/jit/arm/SharedICHelpers-arm.h
js/src/jit/arm/SharedICRegisters-arm.h
js/src/jit/arm/Simulator-arm.cpp
js/src/jit/arm/Simulator-arm.h
js/src/jit/arm/Trampoline-arm.cpp
js/src/jit/arm/disasm/Constants-arm.cpp
js/src/jit/arm/disasm/Constants-arm.h
js/src/jit/arm/disasm/Disasm-arm.cpp
js/src/jit/arm/disasm/Disasm-arm.h
js/src/jit/arm/llvm-compiler-rt/assembly.h
js/src/jit/arm64/Architecture-arm64.h
js/src/jit/arm64/Assembler-arm64.cpp
js/src/jit/arm64/Assembler-arm64.h
js/src/jit/arm64/AtomicOperations-arm64.h
js/src/jit/arm64/Bailouts-arm64.cpp
js/src/jit/arm64/BaselineCompiler-arm64.h
js/src/jit/arm64/BaselineIC-arm64.cpp
js/src/jit/arm64/CodeGenerator-arm64.cpp
js/src/jit/arm64/CodeGenerator-arm64.h
js/src/jit/arm64/LIR-arm64.h
js/src/jit/arm64/LOpcodes-arm64.h
js/src/jit/arm64/Lowering-arm64.cpp
js/src/jit/arm64/Lowering-arm64.h
js/src/jit/arm64/MacroAssembler-arm64-inl.h
js/src/jit/arm64/MacroAssembler-arm64.cpp
js/src/jit/arm64/MacroAssembler-arm64.h
js/src/jit/arm64/MoveEmitter-arm64.cpp
js/src/jit/arm64/MoveEmitter-arm64.h
js/src/jit/arm64/SharedIC-arm64.cpp
js/src/jit/arm64/SharedICHelpers-arm64.h
js/src/jit/arm64/Trampoline-arm64.cpp
js/src/jit/arm64/vixl/Assembler-vixl.cpp
js/src/jit/arm64/vixl/Assembler-vixl.h
js/src/jit/arm64/vixl/CompilerIntrinsics-vixl.h
js/src/jit/arm64/vixl/Constants-vixl.h
js/src/jit/arm64/vixl/Cpu-vixl.cpp
js/src/jit/arm64/vixl/Cpu-vixl.h
js/src/jit/arm64/vixl/Debugger-vixl.cpp
js/src/jit/arm64/vixl/Debugger-vixl.h
js/src/jit/arm64/vixl/Decoder-vixl.cpp
js/src/jit/arm64/vixl/Decoder-vixl.h
js/src/jit/arm64/vixl/Disasm-vixl.cpp
js/src/jit/arm64/vixl/Disasm-vixl.h
js/src/jit/arm64/vixl/Globals-vixl.h
js/src/jit/arm64/vixl/Instructions-vixl.cpp
js/src/jit/arm64/vixl/Instructions-vixl.h
js/src/jit/arm64/vixl/Instrument-vixl.cpp
js/src/jit/arm64/vixl/Instrument-vixl.h
js/src/jit/arm64/vixl/Logic-vixl.cpp
js/src/jit/arm64/vixl/MacroAssembler-vixl.cpp
js/src/jit/arm64/vixl/MacroAssembler-vixl.h
js/src/jit/arm64/vixl/MozAssembler-vixl.cpp
js/src/jit/arm64/vixl/MozBaseAssembler-vixl.h
js/src/jit/arm64/vixl/MozInstructions-vixl.cpp
js/src/jit/arm64/vixl/MozSimulator-vixl.cpp
js/src/jit/arm64/vixl/Platform-vixl.h
js/src/jit/arm64/vixl/Simulator-Constants-vixl.h
js/src/jit/arm64/vixl/Simulator-vixl.cpp
js/src/jit/arm64/vixl/Simulator-vixl.h
js/src/jit/arm64/vixl/Utils-vixl.cpp
js/src/jit/arm64/vixl/Utils-vixl.h
js/src/jit/mips-shared/Architecture-mips-shared.cpp
js/src/jit/mips-shared/Architecture-mips-shared.h
js/src/jit/mips-shared/Assembler-mips-shared.cpp
js/src/jit/mips-shared/Assembler-mips-shared.h
js/src/jit/mips-shared/AtomicOperations-mips-shared.h
js/src/jit/mips-shared/Bailouts-mips-shared.cpp
js/src/jit/mips-shared/BaselineCompiler-mips-shared.cpp
js/src/jit/mips-shared/CodeGenerator-mips-shared.cpp
js/src/jit/mips-shared/CodeGenerator-mips-shared.h
js/src/jit/mips-shared/LIR-mips-shared.h
js/src/jit/mips-shared/Lowering-mips-shared.cpp
js/src/jit/mips-shared/Lowering-mips-shared.h
js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
js/src/jit/mips-shared/MacroAssembler-mips-shared.h
js/src/jit/mips-shared/MoveEmitter-mips-shared.cpp
js/src/jit/mips-shared/MoveEmitter-mips-shared.h
js/src/jit/mips-shared/SharedICHelpers-mips-shared.h
js/src/jit/mips32/Architecture-mips32.cpp
js/src/jit/mips32/Architecture-mips32.h
js/src/jit/mips32/Assembler-mips32.cpp
js/src/jit/mips32/Assembler-mips32.h
js/src/jit/mips32/Bailouts-mips32.cpp
js/src/jit/mips32/Bailouts-mips32.h
js/src/jit/mips32/BaselineCompiler-mips32.cpp
js/src/jit/mips32/BaselineIC-mips32.cpp
js/src/jit/mips32/CodeGenerator-mips32.cpp
js/src/jit/mips32/CodeGenerator-mips32.h
js/src/jit/mips32/LIR-mips32.h
js/src/jit/mips32/LOpcodes-mips32.h
js/src/jit/mips32/Lowering-mips32.cpp
js/src/jit/mips32/Lowering-mips32.h
js/src/jit/mips32/MacroAssembler-mips32-inl.h
js/src/jit/mips32/MacroAssembler-mips32.cpp
js/src/jit/mips32/MacroAssembler-mips32.h
js/src/jit/mips32/MoveEmitter-mips32.cpp
js/src/jit/mips32/MoveEmitter-mips32.h
js/src/jit/mips32/SharedIC-mips32.cpp
js/src/jit/mips32/Simulator-mips32.cpp
js/src/jit/mips32/Simulator-mips32.h
js/src/jit/mips32/Trampoline-mips32.cpp
js/src/jit/mips64/Architecture-mips64.cpp
js/src/jit/mips64/Architecture-mips64.h
js/src/jit/mips64/Assembler-mips64.cpp
js/src/jit/mips64/Assembler-mips64.h
js/src/jit/mips64/Bailouts-mips64.cpp
js/src/jit/mips64/Bailouts-mips64.h
js/src/jit/mips64/BaselineCompiler-mips64.cpp
js/src/jit/mips64/BaselineIC-mips64.cpp
js/src/jit/mips64/CodeGenerator-mips64.cpp
js/src/jit/mips64/CodeGenerator-mips64.h
js/src/jit/mips64/LIR-mips64.h
js/src/jit/mips64/LOpcodes-mips64.h
js/src/jit/mips64/Lowering-mips64.cpp
js/src/jit/mips64/Lowering-mips64.h
js/src/jit/mips64/MacroAssembler-mips64-inl.h
js/src/jit/mips64/MacroAssembler-mips64.cpp
js/src/jit/mips64/MacroAssembler-mips64.h
js/src/jit/mips64/MoveEmitter-mips64.cpp
js/src/jit/mips64/MoveEmitter-mips64.h
js/src/jit/mips64/SharedIC-mips64.cpp
js/src/jit/mips64/Simulator-mips64.cpp
js/src/jit/mips64/Simulator-mips64.h
js/src/jit/mips64/Trampoline-mips64.cpp
js/src/jit/none/Architecture-none.h
js/src/jit/none/AtomicOperations-none.h
js/src/jit/none/AtomicOperations-ppc.h
js/src/jit/none/AtomicOperations-sparc.h
js/src/jit/none/CodeGenerator-none.h
js/src/jit/none/LIR-none.h
js/src/jit/none/Lowering-none.h
js/src/jit/none/MacroAssembler-none.h
js/src/jit/none/SharedICHelpers-none.h
js/src/jit/none/SharedICRegisters-none.h
js/src/jit/none/Trampoline-none.cpp
js/src/jit/shared/Architecture-shared.h
js/src/jit/shared/Assembler-shared.h
js/src/jit/shared/BaselineCompiler-shared.cpp
js/src/jit/shared/BaselineCompiler-shared.h
js/src/jit/shared/CodeGenerator-shared-inl.h
js/src/jit/shared/CodeGenerator-shared.cpp
js/src/jit/shared/CodeGenerator-shared.h
js/src/jit/shared/IonAssemblerBuffer.h
js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
js/src/jit/shared/LIR-shared.h
js/src/jit/shared/LOpcodes-shared.h
js/src/jit/shared/Lowering-shared-inl.h
js/src/jit/shared/Lowering-shared.cpp
js/src/jit/shared/Lowering-shared.h
js/src/jit/x64/Assembler-x64.cpp
js/src/jit/x64/Assembler-x64.h
js/src/jit/x64/Bailouts-x64.cpp
js/src/jit/x64/BaseAssembler-x64.h
js/src/jit/x64/BaselineIC-x64.cpp
js/src/jit/x64/CodeGenerator-x64.cpp
js/src/jit/x64/CodeGenerator-x64.h
js/src/jit/x64/LIR-x64.h
js/src/jit/x64/LOpcodes-x64.h
js/src/jit/x64/Lowering-x64.cpp
js/src/jit/x64/Lowering-x64.h
js/src/jit/x64/MacroAssembler-x64-inl.h
js/src/jit/x64/MacroAssembler-x64.cpp
js/src/jit/x64/MacroAssembler-x64.h
js/src/jit/x64/SharedIC-x64.cpp
js/src/jit/x64/SharedICHelpers-x64.h
js/src/jit/x64/SharedICRegisters-x64.h
js/src/jit/x64/Trampoline-x64.cpp
js/src/jit/x86-shared/Architecture-x86-shared.cpp
js/src/jit/x86-shared/Architecture-x86-shared.h
js/src/jit/x86-shared/Assembler-x86-shared.cpp
js/src/jit/x86-shared/Assembler-x86-shared.h
js/src/jit/x86-shared/AssemblerBuffer-x86-shared.cpp
js/src/jit/x86-shared/AssemblerBuffer-x86-shared.h
js/src/jit/x86-shared/AtomicOperations-x86-shared.h
js/src/jit/x86-shared/BaseAssembler-x86-shared.h
js/src/jit/x86-shared/BaselineCompiler-x86-shared.cpp
js/src/jit/x86-shared/BaselineIC-x86-shared.cpp
js/src/jit/x86-shared/CodeGenerator-x86-shared.cpp
js/src/jit/x86-shared/CodeGenerator-x86-shared.h
js/src/jit/x86-shared/Constants-x86-shared.h
js/src/jit/x86-shared/Disassembler-x86-shared.cpp
js/src/jit/x86-shared/Encoding-x86-shared.h
js/src/jit/x86-shared/LIR-x86-shared.h
js/src/jit/x86-shared/Lowering-x86-shared.cpp
js/src/jit/x86-shared/Lowering-x86-shared.h
js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
js/src/jit/x86-shared/MacroAssembler-x86-shared.cpp
js/src/jit/x86-shared/MacroAssembler-x86-shared.h
js/src/jit/x86-shared/MoveEmitter-x86-shared.cpp
js/src/jit/x86-shared/MoveEmitter-x86-shared.h
js/src/jit/x86-shared/Patching-x86-shared.h
js/src/jit/x86/Assembler-x86.cpp
js/src/jit/x86/Assembler-x86.h
js/src/jit/x86/Bailouts-x86.cpp
js/src/jit/x86/BaseAssembler-x86.h
js/src/jit/x86/BaselineIC-x86.cpp
js/src/jit/x86/CodeGenerator-x86.cpp
js/src/jit/x86/CodeGenerator-x86.h
js/src/jit/x86/LIR-x86.h
js/src/jit/x86/LOpcodes-x86.h
js/src/jit/x86/Lowering-x86.cpp
js/src/jit/x86/Lowering-x86.h
js/src/jit/x86/MacroAssembler-x86-inl.h
js/src/jit/x86/MacroAssembler-x86.cpp
js/src/jit/x86/MacroAssembler-x86.h
js/src/jit/x86/SharedIC-x86.cpp
js/src/jit/x86/SharedICHelpers-x86.h
js/src/jit/x86/SharedICRegisters-x86.h
js/src/jit/x86/Trampoline-x86.cpp
js/src/jsalloc.h
js/src/jsapi-tests/selfTest.cpp
js/src/jsapi-tests/testAddPropertyPropcache.cpp
js/src/jsapi-tests/testArgumentsObject.cpp
js/src/jsapi-tests/testArrayBuffer.cpp
js/src/jsapi-tests/testArrayBufferView.cpp
js/src/jsapi-tests/testAssemblerBuffer.cpp
js/src/jsapi-tests/testBug604087.cpp
js/src/jsapi-tests/testCallArgs.cpp
js/src/jsapi-tests/testCallNonGenericMethodOnProxy.cpp
js/src/jsapi-tests/testChromeBuffer.cpp
js/src/jsapi-tests/testClassGetter.cpp
js/src/jsapi-tests/testCloneScript.cpp
js/src/jsapi-tests/testDebugger.cpp
js/src/jsapi-tests/testDeepFreeze.cpp
js/src/jsapi-tests/testDefineGetterSetterNonEnumerable.cpp
js/src/jsapi-tests/testDefineProperty.cpp
js/src/jsapi-tests/testDefinePropertyIgnoredAttributes.cpp
js/src/jsapi-tests/testEnclosingFunction.cpp
js/src/jsapi-tests/testErrorCopying.cpp
js/src/jsapi-tests/testExternalArrayBuffer.cpp
js/src/jsapi-tests/testExternalStrings.cpp
js/src/jsapi-tests/testFindSCCs.cpp
js/src/jsapi-tests/testForceLexicalInitialization.cpp
js/src/jsapi-tests/testFreshGlobalEvalRedefinition.cpp
js/src/jsapi-tests/testFunctionBinding.cpp
js/src/jsapi-tests/testGCAllocator.cpp
js/src/jsapi-tests/testGCExactRooting.cpp
js/src/jsapi-tests/testGCFinalizeCallback.cpp
js/src/jsapi-tests/testGCGrayMarking.cpp
js/src/jsapi-tests/testGCHeapPostBarriers.cpp
js/src/jsapi-tests/testGCHooks.cpp
js/src/jsapi-tests/testGCMarking.cpp
js/src/jsapi-tests/testGCOutOfMemory.cpp
js/src/jsapi-tests/testGCStoreBufferRemoval.cpp
js/src/jsapi-tests/testGCWeakCache.cpp
js/src/jsapi-tests/testGCWeakRef.cpp
js/src/jsapi-tests/testGetPropertyDescriptor.cpp
js/src/jsapi-tests/testHashTable.cpp
js/src/jsapi-tests/testIndexToString.cpp
js/src/jsapi-tests/testIntTypesABI.cpp
js/src/jsapi-tests/testIntern.cpp
js/src/jsapi-tests/testIntlAvailableLocales.cpp
js/src/jsapi-tests/testIteratorObject.cpp
js/src/jsapi-tests/testJSEvaluateScript.cpp
js/src/jsapi-tests/testJitMacroAssembler.cpp
js/src/jsapi-tests/testJitMinimalFunc.h
js/src/jsapi-tests/testJitMoveEmitterCycles-mips32.cpp
js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
js/src/jsapi-tests/testJitRValueAlloc.cpp
js/src/jsapi-tests/testJitRangeAnalysis.cpp
js/src/jsapi-tests/testJitRegisterSet.cpp
js/src/jsapi-tests/testLookup.cpp
js/src/jsapi-tests/testLooselyEqual.cpp
js/src/jsapi-tests/testMappedArrayBuffer.cpp
js/src/jsapi-tests/testMutedErrors.cpp
js/src/jsapi-tests/testNewObject.cpp
js/src/jsapi-tests/testOOM.cpp
js/src/jsapi-tests/testObjectEmulatingUndefined.cpp
js/src/jsapi-tests/testParseJSON.cpp
js/src/jsapi-tests/testPersistentRooted.cpp
js/src/jsapi-tests/testPreserveJitCode.cpp
js/src/jsapi-tests/testPrintf.cpp
js/src/jsapi-tests/testPrivateGCThingValue.cpp
js/src/jsapi-tests/testProfileStrings.cpp
js/src/jsapi-tests/testPropCache.cpp
js/src/jsapi-tests/testResolveRecursion.cpp
js/src/jsapi-tests/testSavedStacks.cpp
js/src/jsapi-tests/testScriptInfo.cpp
js/src/jsapi-tests/testScriptObject.cpp
js/src/jsapi-tests/testSetProperty.cpp
js/src/jsapi-tests/testSetPropertyIgnoringNamedGetter.cpp
js/src/jsapi-tests/testSharedImmutableStringsCache.cpp
js/src/jsapi-tests/testStructuredClone.cpp
js/src/jsapi-tests/testThreadingConditionVariable.cpp
js/src/jsapi-tests/testThreadingExclusiveData.cpp
js/src/jsapi-tests/testThreadingThread.cpp
js/src/jsapi-tests/testTypedArrays.cpp
js/src/jsapi-tests/testUbiNode.cpp
js/src/jsapi-tests/testUncaughtSymbol.cpp
js/src/jsapi-tests/testValueABI.cpp
js/src/jsapi-tests/testWasmLEB128.cpp
js/src/jsapi-tests/testWeakMap.cpp
js/src/jsapi-tests/testXDR.cpp
js/src/jsapi-tests/tests.cpp
js/src/jsapi-tests/tests.h
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsarray.cpp
js/src/jsarray.h
js/src/jsatom.cpp
js/src/jsatom.h
js/src/jsatominlines.h
js/src/jsbool.cpp
js/src/jsclist.h
js/src/jscntxt.cpp
js/src/jscntxt.h
js/src/jscntxtinlines.h
js/src/jscompartment.cpp
js/src/jscompartment.h
js/src/jscompartmentinlines.h
js/src/jscpucfg.h
js/src/jsdate.cpp
js/src/jsdate.h
js/src/jsdtoa.cpp
js/src/jsdtoa.h
js/src/jsexn.cpp
js/src/jsexn.h
js/src/jsfriendapi.cpp
js/src/jsfriendapi.h
js/src/jsfun.cpp
js/src/jsfun.h
js/src/jsfuninlines.h
js/src/jsgc.cpp
js/src/jsgc.h
js/src/jsgcinlines.h
js/src/jshashutil.h
js/src/jsiter.cpp
js/src/jsiter.h
js/src/jslibmath.h
js/src/jsmath.cpp
js/src/jsmath.h
js/src/jsnativestack.cpp
js/src/jsnspr.h
js/src/jsnum.cpp
js/src/jsnum.h
js/src/jsobj.cpp
js/src/jsobj.h
js/src/jsobjinlines.h
js/src/json.cpp
js/src/json.h
js/src/jsopcode.cpp
js/src/jsopcode.h
js/src/jsopcodeinlines.h
js/src/jsprf.h
js/src/jspropertytree.cpp
js/src/jspropertytree.h
js/src/jsprototypes.h
js/src/jspubtd.h
js/src/jsscript.cpp
js/src/jsscript.h
js/src/jsscriptinlines.h
js/src/jsstr.cpp
js/src/jsstr.h
js/src/jstypes.h
js/src/jsutil.cpp
js/src/jsutil.h
js/src/jsversion.h
js/src/jswatchpoint.cpp
js/src/jswatchpoint.h
js/src/jsweakmap.cpp
js/src/jsweakmap.h
js/src/jswin.h
js/src/jswrapper.h
js/src/perf/jsperf.cpp
js/src/perf/jsperf.h
js/src/perf/pm_linux.cpp
js/src/perf/pm_stub.cpp
js/src/proxy/BaseProxyHandler.cpp
js/src/proxy/CrossCompartmentWrapper.cpp
js/src/proxy/DeadObjectProxy.cpp
js/src/proxy/DeadObjectProxy.h
js/src/proxy/OpaqueCrossCompartmentWrapper.cpp
js/src/proxy/Proxy.cpp
js/src/proxy/Proxy.h
js/src/proxy/ScriptedProxyHandler.cpp
js/src/proxy/ScriptedProxyHandler.h
js/src/proxy/SecurityWrapper.cpp
js/src/proxy/Wrapper.cpp
js/src/shell/OSObject.cpp
js/src/shell/OSObject.h
js/src/shell/js.cpp
js/src/shell/jsoptparse.cpp
js/src/shell/jsoptparse.h
js/src/shell/jsshell.cpp
js/src/shell/jsshell.h
js/src/tests/style/BadIncludes.h
js/src/tests/style/BadIncludesOrder-inl.h
js/src/tests/style/HeaderCycleB4-inl.h
js/src/threading/ConditionVariable.h
js/src/threading/CpuCount.h
js/src/threading/ExclusiveData.h
js/src/threading/LockGuard.h
js/src/threading/Mutex.cpp
js/src/threading/Mutex.h
js/src/threading/ProtectedData.cpp
js/src/threading/ProtectedData.h
js/src/threading/Thread.h
js/src/threading/posix/Thread.cpp
js/src/threading/windows/Thread.cpp
js/src/vm/ArgumentsObject.cpp
js/src/vm/ArgumentsObject.h
js/src/vm/ArrayBufferObject.cpp
js/src/vm/ArrayBufferObject.h
js/src/vm/ArrayObject-inl.h
js/src/vm/ArrayObject.h
js/src/vm/AsyncFunction.cpp
js/src/vm/AsyncFunction.h
js/src/vm/BooleanObject.h
js/src/vm/Caches-inl.h
js/src/vm/Caches.cpp
js/src/vm/Caches.h
js/src/vm/CallNonGenericMethod.cpp
js/src/vm/CharacterEncoding.cpp
js/src/vm/CodeCoverage.cpp
js/src/vm/CodeCoverage.h
js/src/vm/CommonPropertyNames.h
js/src/vm/Compression.cpp
js/src/vm/Compression.h
js/src/vm/DateObject.h
js/src/vm/DateTime.cpp
js/src/vm/DateTime.h
js/src/vm/Debugger-inl.h
js/src/vm/Debugger.cpp
js/src/vm/Debugger.h
js/src/vm/DebuggerMemory.cpp
js/src/vm/DebuggerMemory.h
js/src/vm/EnvironmentObject-inl.h
js/src/vm/EnvironmentObject.cpp
js/src/vm/EnvironmentObject.h
js/src/vm/ErrorObject.cpp
js/src/vm/ErrorObject.h
js/src/vm/GeckoProfiler.cpp
js/src/vm/GeckoProfiler.h
js/src/vm/GeneratorObject.cpp
js/src/vm/GeneratorObject.h
js/src/vm/GlobalObject.cpp
js/src/vm/GlobalObject.h
js/src/vm/HelperThreads.cpp
js/src/vm/HelperThreads.h
js/src/vm/Id.cpp
js/src/vm/Initialization.cpp
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.cpp
js/src/vm/Interpreter.h
js/src/vm/JSONParser.cpp
js/src/vm/JSONParser.h
js/src/vm/MallocProvider.h
js/src/vm/MatchPairs.h
js/src/vm/MemoryMetrics.cpp
js/src/vm/Monitor.h
js/src/vm/MutexIDs.h
js/src/vm/NativeObject-inl.h
js/src/vm/NativeObject.cpp
js/src/vm/NativeObject.h
js/src/vm/NumberObject.h
js/src/vm/ObjectGroup-inl.h
js/src/vm/ObjectGroup.cpp
js/src/vm/ObjectGroup.h
js/src/vm/Opcodes.h
js/src/vm/PIC.cpp
js/src/vm/PIC.h
js/src/vm/PosixNSPR.cpp
js/src/vm/PosixNSPR.h
js/src/vm/Printer.cpp
js/src/vm/Printer.h
js/src/vm/Probes-inl.h
js/src/vm/Probes.cpp
js/src/vm/Probes.h
js/src/vm/ProxyObject.cpp
js/src/vm/ProxyObject.h
js/src/vm/ReceiverGuard.cpp
js/src/vm/ReceiverGuard.h
js/src/vm/RegExpObject.cpp
js/src/vm/RegExpObject.h
js/src/vm/RegExpStatics.cpp
js/src/vm/RegExpStatics.h
js/src/vm/RegExpStaticsObject.h
js/src/vm/Runtime.cpp
js/src/vm/Runtime.h
js/src/vm/SavedFrame.h
js/src/vm/SavedStacks.cpp
js/src/vm/SavedStacks.h
js/src/vm/Scope.cpp
js/src/vm/Scope.h
js/src/vm/SelfHosting.cpp
js/src/vm/SelfHosting.h
js/src/vm/Shape-inl.h
js/src/vm/Shape.cpp
js/src/vm/Shape.h
js/src/vm/ShapedObject.h
js/src/vm/SharedArrayObject.cpp
js/src/vm/SharedArrayObject.h
js/src/vm/SharedImmutableStringsCache-inl.h
js/src/vm/SharedImmutableStringsCache.cpp
js/src/vm/SharedImmutableStringsCache.h
js/src/vm/SharedMem.h
js/src/vm/Stack-inl.h
js/src/vm/Stack.cpp
js/src/vm/Stack.h
js/src/vm/Stopwatch.cpp
js/src/vm/Stopwatch.h
js/src/vm/String-inl.h
js/src/vm/String.cpp
js/src/vm/String.h
js/src/vm/StringBuffer.cpp
js/src/vm/StringBuffer.h
js/src/vm/StringObject.h
js/src/vm/StructuredClone.cpp
js/src/vm/Symbol.cpp
js/src/vm/Symbol.h
js/src/vm/TaggedProto.cpp
js/src/vm/TaggedProto.h
js/src/vm/Time.cpp
js/src/vm/Time.h
js/src/vm/TraceLogging.cpp
js/src/vm/TraceLogging.h
js/src/vm/TraceLoggingGraph.cpp
js/src/vm/TraceLoggingGraph.h
js/src/vm/TraceLoggingTypes.cpp
js/src/vm/TraceLoggingTypes.h
js/src/vm/TypeInference-inl.h
js/src/vm/TypeInference.cpp
js/src/vm/TypeInference.h
js/src/vm/TypedArrayObject-inl.h
js/src/vm/TypedArrayObject.cpp
js/src/vm/TypedArrayObject.h
js/src/vm/UbiNode.cpp
js/src/vm/UbiNodeCensus.cpp
js/src/vm/UbiNodeShortestPaths.cpp
js/src/vm/UnboxedObject-inl.h
js/src/vm/UnboxedObject.cpp
js/src/vm/UnboxedObject.h
js/src/vm/Unicode.cpp
js/src/vm/Unicode.h
js/src/vm/UnicodeNonBMP.h
js/src/vm/Value.cpp
js/src/vm/WeakMapPtr.cpp
js/src/vm/Xdr.cpp
js/src/vm/Xdr.h
js/src/vtune/VTuneWrapper.cpp
js/src/vtune/VTuneWrapper.h
js/src/vtune/disable_warnings.h
js/src/vtune/ittnotify.h
js/src/vtune/ittnotify_config.h
js/src/vtune/ittnotify_static.h
js/src/vtune/ittnotify_types.h
js/src/vtune/jitprofiling.h
js/src/vtune/legacy/ittnotify.h
js/src/wasm/AsmJS.cpp
js/src/wasm/AsmJS.h
js/src/wasm/WasmAST.h
js/src/wasm/WasmBaselineCompile.cpp
js/src/wasm/WasmBinaryConstants.h
js/src/wasm/WasmBinaryIterator.cpp
js/src/wasm/WasmBinaryIterator.h
js/src/wasm/WasmBinaryToAST.cpp
js/src/wasm/WasmBinaryToAST.h
js/src/wasm/WasmBinaryToExperimentalText.cpp
js/src/wasm/WasmBinaryToExperimentalText.h
js/src/wasm/WasmBinaryToText.cpp
js/src/wasm/WasmBinaryToText.h
js/src/wasm/WasmCode.cpp
js/src/wasm/WasmCode.h
js/src/wasm/WasmCompartment.cpp
js/src/wasm/WasmCompartment.h
js/src/wasm/WasmCompile.h
js/src/wasm/WasmDebugFrame.cpp
js/src/wasm/WasmDebugFrame.h
js/src/wasm/WasmFrameIterator.cpp
js/src/wasm/WasmFrameIterator.h
js/src/wasm/WasmGenerator.cpp
js/src/wasm/WasmGenerator.h
js/src/wasm/WasmInstance.cpp
js/src/wasm/WasmInstance.h
js/src/wasm/WasmIonCompile.cpp
js/src/wasm/WasmJS.cpp
js/src/wasm/WasmJS.h
js/src/wasm/WasmModule.cpp
js/src/wasm/WasmModule.h
js/src/wasm/WasmSerialize.h
js/src/wasm/WasmSignalHandlers.cpp
js/src/wasm/WasmSignalHandlers.h
js/src/wasm/WasmStubs.cpp
js/src/wasm/WasmStubs.h
js/src/wasm/WasmTable.cpp
js/src/wasm/WasmTable.h
js/src/wasm/WasmTextToBinary.cpp
js/src/wasm/WasmTextUtils.cpp
js/src/wasm/WasmTextUtils.h
js/src/wasm/WasmTypes.cpp
js/src/wasm/WasmTypes.h
js/src/wasm/WasmValidate.cpp
js/src/wasm/WasmValidate.h
--- a/js/src/NamespaceImports.h
+++ b/js/src/NamespaceImports.h
@@ -33,28 +33,30 @@ class UTF8CharsZ;
 class AutoValueVector;
 class AutoIdVector;
 class AutoObjectVector;
 
 using ValueVector = JS::GCVector<JS::Value>;
 using IdVector = JS::GCVector<jsid>;
 using ScriptVector = JS::GCVector<JSScript*>;
 
-template<typename K, typename V> class AutoHashMapRooter;
-template<typename T> class AutoHashSetRooter;
+template<typename K, typename V>
+class AutoHashMapRooter;
+template<typename T>
+class AutoHashSetRooter;
 
 class MOZ_STACK_CLASS SourceBufferHolder;
 
 class HandleValueArray;
 
 class ObjectOpResult;
 class PropertyResult;
 
 class Symbol;
-enum class SymbolCode: uint32_t;
+enum class SymbolCode : uint32_t;
 
 } // namespace JS
 
 // Do the importing.
 namespace js {
 
 using JS::Value;
 using JS::BooleanValue;
--- a/js/src/builtin/AtomicsObject.cpp
+++ b/js/src/builtin/AtomicsObject.cpp
@@ -64,20 +64,17 @@
 #include "vm/Time.h"
 #include "vm/TypedArrayObject.h"
 #include "wasm/WasmInstance.h"
 
 #include "jsobjinlines.h"
 
 using namespace js;
 
-const Class AtomicsObject::class_ = {
-    "Atomics",
-    JSCLASS_HAS_CACHED_PROTO(JSProto_Atomics)
-};
+const Class AtomicsObject::class_ = { "Atomics", JSCLASS_HAS_CACHED_PROTO(JSProto_Atomics) };
 
 static bool
 ReportBadArrayType(JSContext* cx)
 {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_ATOMICS_BAD_ARRAY);
     return false;
 }
 
@@ -93,18 +90,17 @@ ReportOutOfRange(JSContext* cx)
 static bool
 ReportCannotWait(JSContext* cx)
 {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_ATOMICS_WAIT_NOT_ALLOWED);
     return false;
 }
 
 static bool
-GetSharedTypedArray(JSContext* cx, HandleValue v,
-                    MutableHandle<TypedArrayObject*> viewp)
+GetSharedTypedArray(JSContext* cx, HandleValue v, MutableHandle<TypedArrayObject*> viewp)
 {
     if (!v.isObject())
         return ReportBadArrayType(cx);
     if (!v.toObject().is<TypedArrayObject>())
         return ReportBadArrayType(cx);
     viewp.set(&v.toObject().as<TypedArrayObject>());
     if (!viewp->isSharedMemory())
         return ReportBadArrayType(cx);
@@ -119,66 +115,70 @@ GetTypedArrayIndex(JSContext* cx, Handle
         return false;
     if (index >= view->length())
         return ReportOutOfRange(cx);
     *offset = uint32_t(index);
     return true;
 }
 
 static int32_t
-CompareExchange(Scalar::Type viewType, int32_t oldCandidate, int32_t newCandidate,
-                SharedMem<void*> viewData, uint32_t offset, bool* badArrayType = nullptr)
+CompareExchange(Scalar::Type viewType,
+                int32_t oldCandidate,
+                int32_t newCandidate,
+                SharedMem<void*> viewData,
+                uint32_t offset,
+                bool* badArrayType = nullptr)
 {
     switch (viewType) {
-      case Scalar::Int8: {
-        int8_t oldval = (int8_t)oldCandidate;
-        int8_t newval = (int8_t)newCandidate;
-        oldval = jit::AtomicOperations::compareExchangeSeqCst(viewData.cast<int8_t*>() + offset,
-                                                              oldval, newval);
-        return oldval;
-      }
-      case Scalar::Uint8: {
-        uint8_t oldval = (uint8_t)oldCandidate;
-        uint8_t newval = (uint8_t)newCandidate;
-        oldval = jit::AtomicOperations::compareExchangeSeqCst(viewData.cast<uint8_t*>() + offset,
-                                                              oldval, newval);
-        return oldval;
-      }
-      case Scalar::Int16: {
-        int16_t oldval = (int16_t)oldCandidate;
-        int16_t newval = (int16_t)newCandidate;
-        oldval = jit::AtomicOperations::compareExchangeSeqCst(viewData.cast<int16_t*>() + offset,
-                                                              oldval, newval);
-        return oldval;
-      }
-      case Scalar::Uint16: {
-        uint16_t oldval = (uint16_t)oldCandidate;
-        uint16_t newval = (uint16_t)newCandidate;
-        oldval = jit::AtomicOperations::compareExchangeSeqCst(viewData.cast<uint16_t*>() + offset,
-                                                              oldval, newval);
-        return oldval;
-      }
-      case Scalar::Int32: {
-        int32_t oldval = oldCandidate;
-        int32_t newval = newCandidate;
-        oldval = jit::AtomicOperations::compareExchangeSeqCst(viewData.cast<int32_t*>() + offset,
-                                                              oldval, newval);
-        return oldval;
-      }
-      case Scalar::Uint32: {
-        uint32_t oldval = (uint32_t)oldCandidate;
-        uint32_t newval = (uint32_t)newCandidate;
-        oldval = jit::AtomicOperations::compareExchangeSeqCst(viewData.cast<uint32_t*>() + offset,
-                                                              oldval, newval);
-        return (int32_t)oldval;
-      }
-      default:
-        if (badArrayType)
-            *badArrayType = true;
-        return 0;
+        case Scalar::Int8: {
+            int8_t oldval = (int8_t)oldCandidate;
+            int8_t newval = (int8_t)newCandidate;
+            oldval = jit::AtomicOperations::compareExchangeSeqCst(
+              viewData.cast<int8_t*>() + offset, oldval, newval);
+            return oldval;
+        }
+        case Scalar::Uint8: {
+            uint8_t oldval = (uint8_t)oldCandidate;
+            uint8_t newval = (uint8_t)newCandidate;
+            oldval = jit::AtomicOperations::compareExchangeSeqCst(
+              viewData.cast<uint8_t*>() + offset, oldval, newval);
+            return oldval;
+        }
+        case Scalar::Int16: {
+            int16_t oldval = (int16_t)oldCandidate;
+            int16_t newval = (int16_t)newCandidate;
+            oldval = jit::AtomicOperations::compareExchangeSeqCst(
+              viewData.cast<int16_t*>() + offset, oldval, newval);
+            return oldval;
+        }
+        case Scalar::Uint16: {
+            uint16_t oldval = (uint16_t)oldCandidate;
+            uint16_t newval = (uint16_t)newCandidate;
+            oldval = jit::AtomicOperations::compareExchangeSeqCst(
+              viewData.cast<uint16_t*>() + offset, oldval, newval);
+            return oldval;
+        }
+        case Scalar::Int32: {
+            int32_t oldval = oldCandidate;
+            int32_t newval = newCandidate;
+            oldval = jit::AtomicOperations::compareExchangeSeqCst(
+              viewData.cast<int32_t*>() + offset, oldval, newval);
+            return oldval;
+        }
+        case Scalar::Uint32: {
+            uint32_t oldval = (uint32_t)oldCandidate;
+            uint32_t newval = (uint32_t)newCandidate;
+            oldval = jit::AtomicOperations::compareExchangeSeqCst(
+              viewData.cast<uint32_t*>() + offset, oldval, newval);
+            return (int32_t)oldval;
+        }
+        default:
+            if (badArrayType)
+                *badArrayType = true;
+            return 0;
     }
 }
 
 bool
 js::atomics_compareExchange(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     HandleValue objv = args.get(0);
@@ -196,18 +196,18 @@ js::atomics_compareExchange(JSContext* c
     int32_t oldCandidate;
     if (!ToInt32(cx, oldv, &oldCandidate))
         return false;
     int32_t newCandidate;
     if (!ToInt32(cx, newv, &newCandidate))
         return false;
 
     bool badType = false;
-    int32_t result = CompareExchange(view->type(), oldCandidate, newCandidate,
-                                     view->viewDataShared(), offset, &badType);
+    int32_t result = CompareExchange(
+      view->type(), oldCandidate, newCandidate, view->viewDataShared(), offset, &badType);
 
     if (badType)
         return ReportBadArrayType(cx);
 
     if (view->type() == Scalar::Uint32)
         r.setNumber((double)(uint32_t)result);
     else
         r.setInt32(result);
@@ -226,104 +226,108 @@ js::atomics_load(JSContext* cx, unsigned
     if (!GetSharedTypedArray(cx, objv, &view))
         return false;
     uint32_t offset;
     if (!GetTypedArrayIndex(cx, idxv, view, &offset))
         return false;
 
     SharedMem<void*> viewData = view->viewDataShared();
     switch (view->type()) {
-      case Scalar::Uint8: {
-        uint8_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint8_t*>() + offset);
-        r.setInt32(v);
-        return true;
-      }
-      case Scalar::Int8: {
-        int8_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint8_t*>() + offset);
-        r.setInt32(v);
-        return true;
-      }
-      case Scalar::Int16: {
-        int16_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<int16_t*>() + offset);
-        r.setInt32(v);
-        return true;
-      }
-      case Scalar::Uint16: {
-        uint16_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint16_t*>() + offset);
-        r.setInt32(v);
-        return true;
-      }
-      case Scalar::Int32: {
-        int32_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<int32_t*>() + offset);
-        r.setInt32(v);
-        return true;
-      }
-      case Scalar::Uint32: {
-        uint32_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint32_t*>() + offset);
-        r.setNumber(v);
-        return true;
-      }
-      default:
-        return ReportBadArrayType(cx);
+        case Scalar::Uint8: {
+            uint8_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint8_t*>() + offset);
+            r.setInt32(v);
+            return true;
+        }
+        case Scalar::Int8: {
+            int8_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint8_t*>() + offset);
+            r.setInt32(v);
+            return true;
+        }
+        case Scalar::Int16: {
+            int16_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<int16_t*>() + offset);
+            r.setInt32(v);
+            return true;
+        }
+        case Scalar::Uint16: {
+            uint16_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint16_t*>() + offset);
+            r.setInt32(v);
+            return true;
+        }
+        case Scalar::Int32: {
+            int32_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<int32_t*>() + offset);
+            r.setInt32(v);
+            return true;
+        }
+        case Scalar::Uint32: {
+            uint32_t v = jit::AtomicOperations::loadSeqCst(viewData.cast<uint32_t*>() + offset);
+            r.setNumber(v);
+            return true;
+        }
+        default:
+            return ReportBadArrayType(cx);
     }
 }
 
-enum XchgStoreOp {
+enum XchgStoreOp
+{
     DoExchange,
     DoStore
 };
 
 template<XchgStoreOp op>
 static int32_t
-ExchangeOrStore(Scalar::Type viewType, int32_t numberValue, SharedMem<void*> viewData,
-                uint32_t offset, bool* badArrayType = nullptr)
+ExchangeOrStore(Scalar::Type viewType,
+                int32_t numberValue,
+                SharedMem<void*> viewData,
+                uint32_t offset,
+                bool* badArrayType = nullptr)
 {
-#define INT_OP(ptr, value)                                         \
-    JS_BEGIN_MACRO                                                 \
-    if (op == DoStore)                                             \
-        jit::AtomicOperations::storeSeqCst(ptr, value);            \
-    else                                                           \
-        value = jit::AtomicOperations::exchangeSeqCst(ptr, value); \
+#define INT_OP(ptr, value)                                                                        \
+    JS_BEGIN_MACRO                                                                                \
+    if (op == DoStore)                                                                            \
+        jit::AtomicOperations::storeSeqCst(ptr, value);                                           \
+    else                                                                                          \
+        value = jit::AtomicOperations::exchangeSeqCst(ptr, value);                                \
     JS_END_MACRO
 
     switch (viewType) {
-      case Scalar::Int8: {
-        int8_t value = (int8_t)numberValue;
-        INT_OP(viewData.cast<int8_t*>() + offset, value);
-        return value;
-      }
-      case Scalar::Uint8: {
-        uint8_t value = (uint8_t)numberValue;
-        INT_OP(viewData.cast<uint8_t*>() + offset, value);
-        return value;
-      }
-      case Scalar::Int16: {
-        int16_t value = (int16_t)numberValue;
-        INT_OP(viewData.cast<int16_t*>() + offset, value);
-        return value;
-      }
-      case Scalar::Uint16: {
-        uint16_t value = (uint16_t)numberValue;
-        INT_OP(viewData.cast<uint16_t*>() + offset, value);
-        return value;
-      }
-      case Scalar::Int32: {
-        int32_t value = numberValue;
-        INT_OP(viewData.cast<int32_t*>() + offset, value);
-        return value;
-      }
-      case Scalar::Uint32: {
-        uint32_t value = (uint32_t)numberValue;
-        INT_OP(viewData.cast<uint32_t*>() + offset, value);
-        return (int32_t)value;
-      }
-      default:
-        if (badArrayType)
-            *badArrayType = true;
-        return 0;
+        case Scalar::Int8: {
+            int8_t value = (int8_t)numberValue;
+            INT_OP(viewData.cast<int8_t*>() + offset, value);
+            return value;
+        }
+        case Scalar::Uint8: {
+            uint8_t value = (uint8_t)numberValue;
+            INT_OP(viewData.cast<uint8_t*>() + offset, value);
+            return value;
+        }
+        case Scalar::Int16: {
+            int16_t value = (int16_t)numberValue;
+            INT_OP(viewData.cast<int16_t*>() + offset, value);
+            return value;
+        }
+        case Scalar::Uint16: {
+            uint16_t value = (uint16_t)numberValue;
+            INT_OP(viewData.cast<uint16_t*>() + offset, value);
+            return value;
+        }
+        case Scalar::Int32: {
+            int32_t value = numberValue;
+            INT_OP(viewData.cast<int32_t*>() + offset, value);
+            return value;
+        }
+        case Scalar::Uint32: {
+            uint32_t value = (uint32_t)numberValue;
+            INT_OP(viewData.cast<uint32_t*>() + offset, value);
+            return (int32_t)value;
+        }
+        default:
+            if (badArrayType)
+                *badArrayType = true;
+            return 0;
     }
 #undef INT_OP
 }
 
 template<XchgStoreOp op>
 static bool
 ExchangeOrStore(JSContext* cx, unsigned argc, Value* vp)
 {
@@ -339,18 +343,18 @@ ExchangeOrStore(JSContext* cx, unsigned 
     uint32_t offset;
     if (!GetTypedArrayIndex(cx, idxv, view, &offset))
         return false;
     double integerValue;
     if (!ToInteger(cx, valv, &integerValue))
         return false;
 
     bool badType = false;
-    int32_t result = ExchangeOrStore<op>(view->type(), JS::ToInt32(integerValue),
-                                         view->viewDataShared(), offset, &badType);
+    int32_t result = ExchangeOrStore<op>(
+      view->type(), JS::ToInt32(integerValue), view->viewDataShared(), offset, &badType);
 
     if (badType)
         return ReportBadArrayType(cx);
 
     if (op == DoStore)
         r.setNumber(integerValue);
     else if (view->type() == Scalar::Uint32)
         r.setNumber((double)(uint32_t)result);
@@ -368,133 +372,136 @@ js::atomics_store(JSContext* cx, unsigne
 bool
 js::atomics_exchange(JSContext* cx, unsigned argc, Value* vp)
 {
     return ExchangeOrStore<DoExchange>(cx, argc, vp);
 }
 
 template<typename T>
 static bool
-AtomicsBinop(JSContext* cx, HandleValue objv, HandleValue idxv, HandleValue valv,
+AtomicsBinop(JSContext* cx,
+             HandleValue objv,
+             HandleValue idxv,
+             HandleValue valv,
              MutableHandleValue r)
 {
     Rooted<TypedArrayObject*> view(cx, nullptr);
     if (!GetSharedTypedArray(cx, objv, &view))
         return false;
     uint32_t offset;
     if (!GetTypedArrayIndex(cx, idxv, view, &offset))
         return false;
     int32_t numberValue;
     if (!ToInt32(cx, valv, &numberValue))
         return false;
 
     SharedMem<void*> viewData = view->viewDataShared();
     switch (view->type()) {
-      case Scalar::Int8: {
-        int8_t v = (int8_t)numberValue;
-        r.setInt32(T::operate(viewData.cast<int8_t*>() + offset, v));
-        return true;
-      }
-      case Scalar::Uint8: {
-        uint8_t v = (uint8_t)numberValue;
-        r.setInt32(T::operate(viewData.cast<uint8_t*>() + offset, v));
-        return true;
-      }
-      case Scalar::Int16: {
-        int16_t v = (int16_t)numberValue;
-        r.setInt32(T::operate(viewData.cast<int16_t*>() + offset, v));
-        return true;
-      }
-      case Scalar::Uint16: {
-        uint16_t v = (uint16_t)numberValue;
-        r.setInt32(T::operate(viewData.cast<uint16_t*>() + offset, v));
-        return true;
-      }
-      case Scalar::Int32: {
-        int32_t v = numberValue;
-        r.setInt32(T::operate(viewData.cast<int32_t*>() + offset, v));
-        return true;
-      }
-      case Scalar::Uint32: {
-        uint32_t v = (uint32_t)numberValue;
-        r.setNumber((double)T::operate(viewData.cast<uint32_t*>() + offset, v));
-        return true;
-      }
-      default:
-        return ReportBadArrayType(cx);
+        case Scalar::Int8: {
+            int8_t v = (int8_t)numberValue;
+            r.setInt32(T::operate(viewData.cast<int8_t*>() + offset, v));
+            return true;
+        }
+        case Scalar::Uint8: {
+            uint8_t v = (uint8_t)numberValue;
+            r.setInt32(T::operate(viewData.cast<uint8_t*>() + offset, v));
+            return true;
+        }
+        case Scalar::Int16: {
+            int16_t v = (int16_t)numberValue;
+            r.setInt32(T::operate(viewData.cast<int16_t*>() + offset, v));
+            return true;
+        }
+        case Scalar::Uint16: {
+            uint16_t v = (uint16_t)numberValue;
+            r.setInt32(T::operate(viewData.cast<uint16_t*>() + offset, v));
+            return true;
+        }
+        case Scalar::Int32: {
+            int32_t v = numberValue;
+            r.setInt32(T::operate(viewData.cast<int32_t*>() + offset, v));
+            return true;
+        }
+        case Scalar::Uint32: {
+            uint32_t v = (uint32_t)numberValue;
+            r.setNumber((double)T::operate(viewData.cast<uint32_t*>() + offset, v));
+            return true;
+        }
+        default:
+            return ReportBadArrayType(cx);
     }
 }
 
-#define INTEGRAL_TYPES_FOR_EACH(NAME) \
-    static int8_t operate(SharedMem<int8_t*> addr, int8_t v) { return NAME(addr, v); } \
-    static uint8_t operate(SharedMem<uint8_t*> addr, uint8_t v) { return NAME(addr, v); } \
-    static int16_t operate(SharedMem<int16_t*> addr, int16_t v) { return NAME(addr, v); } \
-    static uint16_t operate(SharedMem<uint16_t*> addr, uint16_t v) { return NAME(addr, v); } \
-    static int32_t operate(SharedMem<int32_t*> addr, int32_t v) { return NAME(addr, v); } \
+#define INTEGRAL_TYPES_FOR_EACH(NAME)                                                             \
+    static int8_t operate(SharedMem<int8_t*> addr, int8_t v) { return NAME(addr, v); }            \
+    static uint8_t operate(SharedMem<uint8_t*> addr, uint8_t v) { return NAME(addr, v); }         \
+    static int16_t operate(SharedMem<int16_t*> addr, int16_t v) { return NAME(addr, v); }         \
+    static uint16_t operate(SharedMem<uint16_t*> addr, uint16_t v) { return NAME(addr, v); }      \
+    static int32_t operate(SharedMem<int32_t*> addr, int32_t v) { return NAME(addr, v); }         \
     static uint32_t operate(SharedMem<uint32_t*> addr, uint32_t v) { return NAME(addr, v); }
 
 class PerformAdd
 {
-public:
+  public:
     INTEGRAL_TYPES_FOR_EACH(jit::AtomicOperations::fetchAddSeqCst)
     static int32_t perform(int32_t x, int32_t y) { return x + y; }
 };
 
 bool
 js::atomics_add(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     return AtomicsBinop<PerformAdd>(cx, args.get(0), args.get(1), args.get(2), args.rval());
 }
 
 class PerformSub
 {
-public:
+  public:
     INTEGRAL_TYPES_FOR_EACH(jit::AtomicOperations::fetchSubSeqCst)
     static int32_t perform(int32_t x, int32_t y) { return x - y; }
 };
 
 bool
 js::atomics_sub(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     return AtomicsBinop<PerformSub>(cx, args.get(0), args.get(1), args.get(2), args.rval());
 }
 
 class PerformAnd
 {
-public:
+  public:
     INTEGRAL_TYPES_FOR_EACH(jit::AtomicOperations::fetchAndSeqCst)
     static int32_t perform(int32_t x, int32_t y) { return x & y; }
 };
 
 bool
 js::atomics_and(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     return AtomicsBinop<PerformAnd>(cx, args.get(0), args.get(1), args.get(2), args.rval());
 }
 
 class PerformOr
 {
-public:
+  public:
     INTEGRAL_TYPES_FOR_EACH(jit::AtomicOperations::fetchOrSeqCst)
     static int32_t perform(int32_t x, int32_t y) { return x | y; }
 };
 
 bool
 js::atomics_or(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     return AtomicsBinop<PerformOr>(cx, args.get(0), args.get(1), args.get(2), args.rval());
 }
 
 class PerformXor
 {
-public:
+  public:
     INTEGRAL_TYPES_FOR_EACH(jit::AtomicOperations::fetchXorSeqCst)
     static int32_t perform(int32_t x, int32_t y) { return x ^ y; }
 };
 
 bool
 js::atomics_xor(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
@@ -537,164 +544,168 @@ js::atomics_add_asm_callout(wasm::Instan
 {
     SharedMem<void*> heap = instance->memoryBase().cast<void*>();
     size_t heapLength = instance->memoryLength();
 
     if (size_t(offset) >= heapLength)
         return 0;
 
     switch (Scalar::Type(vt)) {
-      case Scalar::Int8:
-        return PerformAdd::operate(heap.cast<int8_t*>() + offset, value);
-      case Scalar::Uint8:
-        return PerformAdd::operate(heap.cast<uint8_t*>() + offset, value);
-      case Scalar::Int16:
-        return PerformAdd::operate(heap.cast<int16_t*>() + (offset >> 1), value);
-      case Scalar::Uint16:
-        return PerformAdd::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
-      default:
-        MOZ_CRASH("Invalid size");
+        case Scalar::Int8:
+            return PerformAdd::operate(heap.cast<int8_t*>() + offset, value);
+        case Scalar::Uint8:
+            return PerformAdd::operate(heap.cast<uint8_t*>() + offset, value);
+        case Scalar::Int16:
+            return PerformAdd::operate(heap.cast<int16_t*>() + (offset >> 1), value);
+        case Scalar::Uint16:
+            return PerformAdd::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
+        default:
+            MOZ_CRASH("Invalid size");
     }
 }
 
 int32_t
 js::atomics_sub_asm_callout(wasm::Instance* instance, int32_t vt, int32_t offset, int32_t value)
 {
     SharedMem<void*> heap = instance->memoryBase().cast<void*>();
     size_t heapLength = instance->memoryLength();
 
     if (size_t(offset) >= heapLength)
         return 0;
 
     switch (Scalar::Type(vt)) {
-      case Scalar::Int8:
-        return PerformSub::operate(heap.cast<int8_t*>() + offset, value);
-      case Scalar::Uint8:
-        return PerformSub::operate(heap.cast<uint8_t*>() + offset, value);
-      case Scalar::Int16:
-        return PerformSub::operate(heap.cast<int16_t*>() + (offset >> 1), value);
-      case Scalar::Uint16:
-        return PerformSub::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
-      default:
-        MOZ_CRASH("Invalid size");
+        case Scalar::Int8:
+            return PerformSub::operate(heap.cast<int8_t*>() + offset, value);
+        case Scalar::Uint8:
+            return PerformSub::operate(heap.cast<uint8_t*>() + offset, value);
+        case Scalar::Int16:
+            return PerformSub::operate(heap.cast<int16_t*>() + (offset >> 1), value);
+        case Scalar::Uint16:
+            return PerformSub::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
+        default:
+            MOZ_CRASH("Invalid size");
     }
 }
 
 int32_t
 js::atomics_and_asm_callout(wasm::Instance* instance, int32_t vt, int32_t offset, int32_t value)
 {
     SharedMem<void*> heap = instance->memoryBase().cast<void*>();
     size_t heapLength = instance->memoryLength();
 
     if (size_t(offset) >= heapLength)
         return 0;
 
     switch (Scalar::Type(vt)) {
-      case Scalar::Int8:
-        return PerformAnd::operate(heap.cast<int8_t*>() + offset, value);
-      case Scalar::Uint8:
-        return PerformAnd::operate(heap.cast<uint8_t*>() + offset, value);
-      case Scalar::Int16:
-        return PerformAnd::operate(heap.cast<int16_t*>() + (offset >> 1), value);
-      case Scalar::Uint16:
-        return PerformAnd::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
-      default:
-        MOZ_CRASH("Invalid size");
+        case Scalar::Int8:
+            return PerformAnd::operate(heap.cast<int8_t*>() + offset, value);
+        case Scalar::Uint8:
+            return PerformAnd::operate(heap.cast<uint8_t*>() + offset, value);
+        case Scalar::Int16:
+            return PerformAnd::operate(heap.cast<int16_t*>() + (offset >> 1), value);
+        case Scalar::Uint16:
+            return PerformAnd::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
+        default:
+            MOZ_CRASH("Invalid size");
     }
 }
 
 int32_t
 js::atomics_or_asm_callout(wasm::Instance* instance, int32_t vt, int32_t offset, int32_t value)
 {
     SharedMem<void*> heap = instance->memoryBase().cast<void*>();
     size_t heapLength = instance->memoryLength();
 
     if (size_t(offset) >= heapLength)
         return 0;
 
     switch (Scalar::Type(vt)) {
-      case Scalar::Int8:
-        return PerformOr::operate(heap.cast<int8_t*>() + offset, value);
-      case Scalar::Uint8:
-        return PerformOr::operate(heap.cast<uint8_t*>() + offset, value);
-      case Scalar::Int16:
-        return PerformOr::operate(heap.cast<int16_t*>() + (offset >> 1), value);
-      case Scalar::Uint16:
-        return PerformOr::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
-      default:
-        MOZ_CRASH("Invalid size");
+        case Scalar::Int8:
+            return PerformOr::operate(heap.cast<int8_t*>() + offset, value);
+        case Scalar::Uint8:
+            return PerformOr::operate(heap.cast<uint8_t*>() + offset, value);
+        case Scalar::Int16:
+            return PerformOr::operate(heap.cast<int16_t*>() + (offset >> 1), value);
+        case Scalar::Uint16:
+            return PerformOr::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
+        default:
+            MOZ_CRASH("Invalid size");
     }
 }
 
 int32_t
 js::atomics_xor_asm_callout(wasm::Instance* instance, int32_t vt, int32_t offset, int32_t value)
 {
     SharedMem<void*> heap = instance->memoryBase().cast<void*>();
     size_t heapLength = instance->memoryLength();
 
     if (size_t(offset) >= heapLength)
         return 0;
 
     switch (Scalar::Type(vt)) {
-      case Scalar::Int8:
-        return PerformXor::operate(heap.cast<int8_t*>() + offset, value);
-      case Scalar::Uint8:
-        return PerformXor::operate(heap.cast<uint8_t*>() + offset, value);
-      case Scalar::Int16:
-        return PerformXor::operate(heap.cast<int16_t*>() + (offset >> 1), value);
-      case Scalar::Uint16:
-        return PerformXor::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
-      default:
-        MOZ_CRASH("Invalid size");
+        case Scalar::Int8:
+            return PerformXor::operate(heap.cast<int8_t*>() + offset, value);
+        case Scalar::Uint8:
+            return PerformXor::operate(heap.cast<uint8_t*>() + offset, value);
+        case Scalar::Int16:
+            return PerformXor::operate(heap.cast<int16_t*>() + (offset >> 1), value);
+        case Scalar::Uint16:
+            return PerformXor::operate(heap.cast<uint16_t*>() + (offset >> 1), value);
+        default:
+            MOZ_CRASH("Invalid size");
     }
 }
 
 int32_t
 js::atomics_xchg_asm_callout(wasm::Instance* instance, int32_t vt, int32_t offset, int32_t value)
 {
     SharedMem<void*> heap = instance->memoryBase().cast<void*>();
     size_t heapLength = instance->memoryLength();
 
     if (size_t(offset) >= heapLength)
         return 0;
 
     switch (Scalar::Type(vt)) {
-      case Scalar::Int8:
-        return ExchangeOrStore<DoExchange>(Scalar::Int8, value, heap, offset);
-      case Scalar::Uint8:
-        return ExchangeOrStore<DoExchange>(Scalar::Uint8, value, heap, offset);
-      case Scalar::Int16:
-        return ExchangeOrStore<DoExchange>(Scalar::Int16, value, heap, offset>>1);
-      case Scalar::Uint16:
-        return ExchangeOrStore<DoExchange>(Scalar::Uint16, value, heap, offset>>1);
-      default:
-        MOZ_CRASH("Invalid size");
+        case Scalar::Int8:
+            return ExchangeOrStore<DoExchange>(Scalar::Int8, value, heap, offset);
+        case Scalar::Uint8:
+            return ExchangeOrStore<DoExchange>(Scalar::Uint8, value, heap, offset);
+        case Scalar::Int16:
+            return ExchangeOrStore<DoExchange>(Scalar::Int16, value, heap, offset >> 1);
+        case Scalar::Uint16:
+            return ExchangeOrStore<DoExchange>(Scalar::Uint16, value, heap, offset >> 1);
+        default:
+            MOZ_CRASH("Invalid size");
     }
 }
 
 int32_t
-js::atomics_cmpxchg_asm_callout(wasm::Instance* instance, int32_t vt, int32_t offset, int32_t oldval, int32_t newval)
+js::atomics_cmpxchg_asm_callout(wasm::Instance* instance,
+                                int32_t vt,
+                                int32_t offset,
+                                int32_t oldval,
+                                int32_t newval)
 {
     SharedMem<void*> heap = instance->memoryBase().cast<void*>();
     size_t heapLength = instance->memoryLength();
 
     if (size_t(offset) >= heapLength)
         return 0;
 
     switch (Scalar::Type(vt)) {
-      case Scalar::Int8:
-        return CompareExchange(Scalar::Int8, oldval, newval, heap, offset);
-      case Scalar::Uint8:
-        return CompareExchange(Scalar::Uint8, oldval, newval, heap, offset);
-      case Scalar::Int16:
-        return CompareExchange(Scalar::Int16, oldval, newval, heap, offset>>1);
-      case Scalar::Uint16:
-        return CompareExchange(Scalar::Uint16, oldval, newval, heap, offset>>1);
-      default:
-        MOZ_CRASH("Invalid size");
+        case Scalar::Int8:
+            return CompareExchange(Scalar::Int8, oldval, newval, heap, offset);
+        case Scalar::Uint8:
+            return CompareExchange(Scalar::Uint8, oldval, newval, heap, offset);
+        case Scalar::Int16:
+            return CompareExchange(Scalar::Int16, oldval, newval, heap, offset >> 1);
+        case Scalar::Uint16:
+            return CompareExchange(Scalar::Uint16, oldval, newval, heap, offset >> 1);
+        default:
+            MOZ_CRASH("Invalid size");
     }
 }
 
 namespace js {
 
 // Represents one waiting worker.
 //
 // The type is declared opaque in SharedArrayObject.h.  Instances of
@@ -707,44 +718,43 @@ namespace js {
 // The list is circular, so the 'lower_pri' field of the lowest priority
 // node points to the first node in the list.  The list has no dedicated
 // header node.
 
 class FutexWaiter
 {
   public:
     FutexWaiter(uint32_t offset, JSContext* cx)
-      : offset(offset),
-        cx(cx),
-        lower_pri(nullptr),
-        back(nullptr)
+      : offset(offset)
+      , cx(cx)
+      , lower_pri(nullptr)
+      , back(nullptr)
     {
     }
 
-    uint32_t    offset;                 // int32 element index within the SharedArrayBuffer
-    JSContext* cx;                      // The waiting thread
-    FutexWaiter* lower_pri;             // Lower priority nodes in circular doubly-linked list of waiters
-    FutexWaiter* back;                  // Other direction
+    uint32_t offset;        // int32 element index within the SharedArrayBuffer
+    JSContext* cx;          // The waiting thread
+    FutexWaiter* lower_pri; // Lower priority nodes in circular doubly-linked list of waiters
+    FutexWaiter* back;      // Other direction
 };
 
 class AutoLockFutexAPI
 {
     // We have to wrap this in a Maybe because of the way loading
     // mozilla::Atomic pointers works.
     mozilla::Maybe<js::UniqueLock<js::Mutex>> unique_;
 
   public:
-    AutoLockFutexAPI() {
+    AutoLockFutexAPI()
+    {
         js::Mutex* lock = FutexThread::lock_;
         unique_.emplace(*lock);
     }
 
-    ~AutoLockFutexAPI() {
-        unique_.reset();
-    }
+    ~AutoLockFutexAPI() { unique_.reset(); }
 
     js::UniqueLock<js::Mutex>& unique() { return *unique_; }
 };
 
 } // namespace js
 
 bool
 js::atomics_wait(JSContext* cx, unsigned argc, Value* vp)
@@ -806,22 +816,22 @@ js::atomics_wait(JSContext* cx, unsigned
         w.lower_pri = w.back = &w;
         sarb->setWaiters(&w);
     }
 
     FutexThread::WaitResult result = FutexThread::FutexOK;
     bool retval = cx->fx.wait(cx, lock.unique(), timeout, &result);
     if (retval) {
         switch (result) {
-          case FutexThread::FutexOK:
-            r.setString(cx->names().futexOK);
-            break;
-          case FutexThread::FutexTimedOut:
-            r.setString(cx->names().futexTimedOut);
-            break;
+            case FutexThread::FutexOK:
+                r.setString(cx->names().futexOK);
+                break;
+            case FutexThread::FutexTimedOut:
+                r.setString(cx->names().futexTimedOut);
+                break;
         }
     }
 
     if (w.lower_pri == &w) {
         sarb->setWaiters(nullptr);
     } else {
         w.lower_pri->back = w.back;
         w.back->lower_pri = w.lower_pri;
@@ -916,19 +926,19 @@ js::FutexThread::unlock()
 {
     // Load the atomic pointer.
     js::Mutex* lock = lock_;
 
     lock->unlock();
 }
 
 js::FutexThread::FutexThread()
-  : cond_(nullptr),
-    state_(Idle),
-    canWait_(false)
+  : cond_(nullptr)
+  , state_(Idle)
+  , canWait_(false)
 {
 }
 
 bool
 js::FutexThread::initInstance()
 {
     MOZ_ASSERT(lock_);
     cond_ = js_new<js::ConditionVariable>();
@@ -946,47 +956,46 @@ bool
 js::FutexThread::isWaiting()
 {
     // When a worker is awoken for an interrupt it goes into state
     // WaitingNotifiedForInterrupt for a short time before it actually
     // wakes up and goes into WaitingInterrupted.  In those states the
     // worker is still waiting, and if an explicit wake arrives the
     // worker transitions to Woken.  See further comments in
     // FutexThread::wait().
-    return state_ == Waiting || state_ == WaitingInterrupted || state_ == WaitingNotifiedForInterrupt;
+    return state_ == Waiting || state_ == WaitingInterrupted ||
+           state_ == WaitingNotifiedForInterrupt;
 }
 
 bool
-js::FutexThread::wait(JSContext* cx, js::UniqueLock<js::Mutex>& locked,
-                       mozilla::Maybe<mozilla::TimeDuration>& timeout, WaitResult* result)
+js::FutexThread::wait(JSContext* cx,
+                      js::UniqueLock<js::Mutex>& locked,
+                      mozilla::Maybe<mozilla::TimeDuration>& timeout,
+                      WaitResult* result)
 {
     MOZ_ASSERT(&cx->fx == this);
     MOZ_ASSERT(cx->fx.canWait());
     MOZ_ASSERT(state_ == Idle || state_ == WaitingInterrupted);
 
     // Disallow waiting when a runtime is processing an interrupt.
     // See explanation below.
 
     if (state_ == WaitingInterrupted) {
         UnlockGuard<Mutex> unlock(locked);
         JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_ATOMICS_WAIT_NOT_ALLOWED);
         return false;
     }
 
     // Go back to Idle after returning.
-    auto onFinish = mozilla::MakeScopeExit([&] {
-        state_ = Idle;
-    });
+    auto onFinish = mozilla::MakeScopeExit([&] { state_ = Idle; });
 
     const bool isTimed = timeout.isSome();
 
-    auto finalEnd = timeout.map([](mozilla::TimeDuration& timeout) {
-        return mozilla::TimeStamp::Now() + timeout;
-    });
-
+    auto finalEnd = timeout.map(
+      [](mozilla::TimeDuration& timeout) { return mozilla::TimeStamp::Now() + timeout; });
 
     // 4000s is about the longest timeout slice that is guaranteed to
     // work cross-platform.
     auto maxSlice = mozilla::TimeDuration::FromSeconds(4000.0);
 
     for (;;) {
         // If we are doing a timed wait, calculate the end time for this wait
         // slice.
@@ -1001,142 +1010,142 @@ js::FutexThread::wait(JSContext* cx, js:
 
         if (isTimed) {
             mozilla::Unused << cond_->wait_until(locked, *sliceEnd);
         } else {
             cond_->wait(locked);
         }
 
         switch (state_) {
-          case FutexThread::Waiting:
-            // Timeout or spurious wakeup.
-            if (isTimed) {
-                auto now = mozilla::TimeStamp::Now();
-                if (now >= *finalEnd) {
-                    *result = FutexTimedOut;
+            case FutexThread::Waiting:
+                // Timeout or spurious wakeup.
+                if (isTimed) {
+                    auto now = mozilla::TimeStamp::Now();
+                    if (now >= *finalEnd) {
+                        *result = FutexTimedOut;
+                        return true;
+                    }
+                }
+                break;
+
+            case FutexThread::Woken:
+                *result = FutexOK;
+                return true;
+
+            case FutexThread::WaitingNotifiedForInterrupt:
+                // The interrupt handler may reenter the engine.  In that case
+                // there are two complications:
+                //
+                // - The waiting thread is not actually waiting on the
+                //   condition variable so we have to record that it
+                //   should be woken when the interrupt handler returns.
+                //   To that end, we flag the thread as interrupted around
+                //   the interrupt and check state_ when the interrupt
+                //   handler returns.  A wake() call that reaches the
+                //   runtime during the interrupt sets state_ to Woken.
+                //
+                // - It is in principle possible for wait() to be
+                //   reentered on the same thread/runtime and waiting on the
+                //   same location and to yet again be interrupted and enter
+                //   the interrupt handler.  In this case, it is important
+                //   that when another agent wakes waiters, all waiters using
+                //   the same runtime on the same location are woken in LIFO
+                //   order; FIFO may be the required order, but FIFO would
+                //   fail to wake up the innermost call.  Interrupts are
+                //   outside any spec anyway.  Also, several such suspended
+                //   waiters may be woken at a time.
+                //
+                //   For the time being we disallow waiting from within code
+                //   that runs from within an interrupt handler; this may
+                //   occasionally (very rarely) be surprising but is
+                //   expedient.  Other solutions exist, see bug #1131943.  The
+                //   code that performs the check is above, at the head of
+                //   this function.
+
+                state_ = WaitingInterrupted;
+                {
+                    UnlockGuard<Mutex> unlock(locked);
+                    if (!cx->handleInterrupt())
+                        return false;
+                }
+                if (state_ == Woken) {
+                    *result = FutexOK;
                     return true;
                 }
-            }
-            break;
-
-          case FutexThread::Woken:
-            *result = FutexOK;
-            return true;
+                break;
 
-          case FutexThread::WaitingNotifiedForInterrupt:
-            // The interrupt handler may reenter the engine.  In that case
-            // there are two complications:
-            //
-            // - The waiting thread is not actually waiting on the
-            //   condition variable so we have to record that it
-            //   should be woken when the interrupt handler returns.
-            //   To that end, we flag the thread as interrupted around
-            //   the interrupt and check state_ when the interrupt
-            //   handler returns.  A wake() call that reaches the
-            //   runtime during the interrupt sets state_ to Woken.
-            //
-            // - It is in principle possible for wait() to be
-            //   reentered on the same thread/runtime and waiting on the
-            //   same location and to yet again be interrupted and enter
-            //   the interrupt handler.  In this case, it is important
-            //   that when another agent wakes waiters, all waiters using
-            //   the same runtime on the same location are woken in LIFO
-            //   order; FIFO may be the required order, but FIFO would
-            //   fail to wake up the innermost call.  Interrupts are
-            //   outside any spec anyway.  Also, several such suspended
-            //   waiters may be woken at a time.
-            //
-            //   For the time being we disallow waiting from within code
-            //   that runs from within an interrupt handler; this may
-            //   occasionally (very rarely) be surprising but is
-            //   expedient.  Other solutions exist, see bug #1131943.  The
-            //   code that performs the check is above, at the head of
-            //   this function.
-
-            state_ = WaitingInterrupted;
-            {
-                UnlockGuard<Mutex> unlock(locked);
-                if (!cx->handleInterrupt())
-                    return false;
-            }
-            if (state_ == Woken) {
-                *result = FutexOK;
-                return true;
-            }
-            break;
-
-          default:
-            MOZ_CRASH("Bad FutexState in wait()");
+            default:
+                MOZ_CRASH("Bad FutexState in wait()");
         }
     }
 }
 
 void
 js::FutexThread::wake(WakeReason reason)
 {
     MOZ_ASSERT(isWaiting());
 
-    if ((state_ == WaitingInterrupted || state_ == WaitingNotifiedForInterrupt) && reason == WakeExplicit) {
+    if ((state_ == WaitingInterrupted || state_ == WaitingNotifiedForInterrupt) &&
+        reason == WakeExplicit) {
         state_ = Woken;
         return;
     }
     switch (reason) {
-      case WakeExplicit:
-        state_ = Woken;
-        break;
-      case WakeForJSInterrupt:
-        if (state_ == WaitingNotifiedForInterrupt)
-            return;
-        state_ = WaitingNotifiedForInterrupt;
-        break;
-      default:
-        MOZ_CRASH("bad WakeReason in FutexThread::wake()");
+        case WakeExplicit:
+            state_ = Woken;
+            break;
+        case WakeForJSInterrupt:
+            if (state_ == WaitingNotifiedForInterrupt)
+                return;
+            state_ = WaitingNotifiedForInterrupt;
+            break;
+        default:
+            MOZ_CRASH("bad WakeReason in FutexThread::wake()");
     }
     cond_->notify_all();
 }
 
 const JSFunctionSpec AtomicsMethods[] = {
-    JS_INLINABLE_FN("compareExchange",    atomics_compareExchange,    4,0, AtomicsCompareExchange),
-    JS_INLINABLE_FN("load",               atomics_load,               2,0, AtomicsLoad),
-    JS_INLINABLE_FN("store",              atomics_store,              3,0, AtomicsStore),
-    JS_INLINABLE_FN("exchange",           atomics_exchange,           3,0, AtomicsExchange),
-    JS_INLINABLE_FN("add",                atomics_add,                3,0, AtomicsAdd),
-    JS_INLINABLE_FN("sub",                atomics_sub,                3,0, AtomicsSub),
-    JS_INLINABLE_FN("and",                atomics_and,                3,0, AtomicsAnd),
-    JS_INLINABLE_FN("or",                 atomics_or,                 3,0, AtomicsOr),
-    JS_INLINABLE_FN("xor",                atomics_xor,                3,0, AtomicsXor),
-    JS_INLINABLE_FN("isLockFree",         atomics_isLockFree,         1,0, AtomicsIsLockFree),
-    JS_FN("wait",                         atomics_wait,               4,0),
-    JS_FN("wake",                         atomics_wake,               3,0),
+    JS_INLINABLE_FN("compareExchange", atomics_compareExchange, 4, 0, AtomicsCompareExchange),
+    JS_INLINABLE_FN("load", atomics_load, 2, 0, AtomicsLoad),
+    JS_INLINABLE_FN("store", atomics_store, 3, 0, AtomicsStore),
+    JS_INLINABLE_FN("exchange", atomics_exchange, 3, 0, AtomicsExchange),
+    JS_INLINABLE_FN("add", atomics_add, 3, 0, AtomicsAdd),
+    JS_INLINABLE_FN("sub", atomics_sub, 3, 0, AtomicsSub),
+    JS_INLINABLE_FN("and", atomics_and, 3, 0, AtomicsAnd),
+    JS_INLINABLE_FN("or", atomics_or, 3, 0, AtomicsOr),
+    JS_INLINABLE_FN("xor", atomics_xor, 3, 0, AtomicsXor),
+    JS_INLINABLE_FN("isLockFree", atomics_isLockFree, 1, 0, AtomicsIsLockFree),
+    JS_FN("wait", atomics_wait, 4, 0),
+    JS_FN("wake", atomics_wake, 3, 0),
     JS_FS_END
 };
 
 JSObject*
 AtomicsObject::initClass(JSContext* cx, Handle<GlobalObject*> global)
 {
     // Create Atomics Object.
     RootedObject objProto(cx, GlobalObject::getOrCreateObjectPrototype(cx, global));
     if (!objProto)
         return nullptr;
-    RootedObject Atomics(cx, NewObjectWithGivenProto(cx, &AtomicsObject::class_, objProto,
-                                                     SingletonObject));
+    RootedObject Atomics(
+      cx, NewObjectWithGivenProto(cx, &AtomicsObject::class_, objProto, SingletonObject));
     if (!Atomics)
         return nullptr;
 
     if (!JS_DefineFunctions(cx, Atomics, AtomicsMethods))
         return nullptr;
     if (!DefineToStringTag(cx, Atomics, cx->names().Atomics))
         return nullptr;
 
     RootedValue AtomicsValue(cx, ObjectValue(*Atomics));
 
     // Everything is set up, install Atomics on the global object.
-    if (!DefineProperty(cx, global, cx->names().Atomics, AtomicsValue, nullptr, nullptr,
-                        JSPROP_RESOLVING))
-    {
+    if (!DefineProperty(
+          cx, global, cx->names().Atomics, AtomicsValue, nullptr, nullptr, JSPROP_RESOLVING)) {
         return nullptr;
     }
 
     global->setConstructor(JSProto_Atomics, AtomicsValue);
     return Atomics;
 }
 
 JSObject*
--- a/js/src/builtin/AtomicsObject.h
+++ b/js/src/builtin/AtomicsObject.h
@@ -20,79 +20,108 @@ namespace js {
 class AtomicsObject : public JSObject
 {
   public:
     static const Class class_;
     static JSObject* initClass(JSContext* cx, Handle<GlobalObject*> global);
     static MOZ_MUST_USE bool toString(JSContext* cx, unsigned int argc, Value* vp);
 };
 
-MOZ_MUST_USE bool atomics_compareExchange(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_exchange(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_load(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_store(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_add(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_sub(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_and(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_or(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_xor(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_isLockFree(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_wait(JSContext* cx, unsigned argc, Value* vp);
-MOZ_MUST_USE bool atomics_wake(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_compareExchange(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_exchange(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_load(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_store(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_add(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_sub(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_and(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_or(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_xor(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_isLockFree(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_wait(JSContext* cx, unsigned argc, Value* vp);
+MOZ_MUST_USE bool
+atomics_wake(JSContext* cx, unsigned argc, Value* vp);
 
 /* asm.js callouts */
-namespace wasm { class Instance; }
-int32_t atomics_add_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
-int32_t atomics_sub_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
-int32_t atomics_and_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
-int32_t atomics_or_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
-int32_t atomics_xor_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
-int32_t atomics_cmpxchg_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t oldval, int32_t newval);
-int32_t atomics_xchg_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
+namespace wasm {
+class Instance;
+}
+int32_t
+atomics_add_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
+int32_t
+atomics_sub_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
+int32_t
+atomics_and_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
+int32_t
+atomics_or_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
+int32_t
+atomics_xor_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
+int32_t
+atomics_cmpxchg_asm_callout(wasm::Instance* i,
+                            int32_t vt,
+                            int32_t offset,
+                            int32_t oldval,
+                            int32_t newval);
+int32_t
+atomics_xchg_asm_callout(wasm::Instance* i, int32_t vt, int32_t offset, int32_t value);
 
 class FutexThread
 {
     friend class AutoLockFutexAPI;
 
-public:
+  public:
     static MOZ_MUST_USE bool initialize();
     static void destroy();
 
     static void lock();
     static void unlock();
 
     FutexThread();
     MOZ_MUST_USE bool initInstance();
     void destroyInstance();
 
     // Parameters to wake().
-    enum WakeReason {
-        WakeExplicit,           // Being asked to wake up by another thread
-        WakeForJSInterrupt      // Interrupt requested
+    enum WakeReason
+    {
+        WakeExplicit,      // Being asked to wake up by another thread
+        WakeForJSInterrupt // Interrupt requested
     };
 
     // Result code from wait().
-    enum WaitResult {
+    enum WaitResult
+    {
         FutexOK,
         FutexTimedOut
     };
 
     // Block the calling thread and wait.
     //
     // The futex lock must be held around this call.
     //
     // The timeout is the number of milliseconds, with fractional
     // times allowed; specify mozilla::Nothing() for an indefinite
     // wait.
     //
     // wait() will not wake up spuriously.  It will return true and
     // set *result to a return code appropriate for
     // Atomics.wait() on success, and return false on error.
-    MOZ_MUST_USE bool wait(JSContext* cx, js::UniqueLock<js::Mutex>& locked,
-                           mozilla::Maybe<mozilla::TimeDuration>& timeout, WaitResult* result);
+    MOZ_MUST_USE bool wait(JSContext* cx,
+                           js::UniqueLock<js::Mutex>& locked,
+                           mozilla::Maybe<mozilla::TimeDuration>& timeout,
+                           WaitResult* result);
 
     // Wake the thread this is associated with.
     //
     // The futex lock must be held around this call.  (The sleeping
     // thread will not wake up until the caller of Atomics.wake()
     // releases the lock.)
     //
     // If the thread is not waiting then this method does nothing.
@@ -106,26 +135,23 @@ public:
     // with WaitingNotifiedForInterrupt; in the latter case the caller
     // of wait() must handle the interrupt.
     void wake(WakeReason reason);
 
     bool isWaiting();
 
     // If canWait() returns false (the default) then wait() is disabled
     // on the thread to which the FutexThread belongs.
-    bool canWait() {
-        return canWait_;
-    }
+    bool canWait() { return canWait_; }
 
-    void setCanWait(bool flag) {
-        canWait_ = flag;
-    }
+    void setCanWait(bool flag) { canWait_ = flag; }
 
   private:
-    enum FutexState {
+    enum FutexState
+    {
         Idle,                        // We are not waiting or woken
         Waiting,                     // We are waiting, nothing has happened yet
         WaitingNotifiedForInterrupt, // We are waiting, but have been interrupted,
                                      //   and have not yet started running the
                                      //   interrupt handler
         WaitingInterrupted,          // We are waiting, but have been interrupted
                                      //   and are running the interrupt handler
         Woken                        // Woken by a script call to Atomics.wake
@@ -146,11 +172,11 @@ public:
 
     // A flag that controls whether waiting is allowed.
     ThreadLocalData<bool> canWait_;
 };
 
 JSObject*
 InitAtomicsClass(JSContext* cx, HandleObject obj);
 
-}  /* namespace js */
+} /* namespace js */
 
 #endif /* builtin_AtomicsObject_h */
--- a/js/src/builtin/DataViewObject.cpp
+++ b/js/src/builtin/DataViewObject.cpp
@@ -12,17 +12,17 @@
 #include <string.h>
 
 #include "jsapi.h"
 #include "jsarray.h"
 #include "jscntxt.h"
 #include "jsnum.h"
 #include "jsobj.h"
 #ifdef XP_WIN
-# include "jswin.h"
+#include "jswin.h"
 #endif
 #include "jswrapper.h"
 
 #include "jit/AtomicOperations.h"
 #include "js/Conversions.h"
 #include "vm/ArrayBufferObject.h"
 #include "vm/GlobalObject.h"
 #include "vm/Interpreter.h"
@@ -50,18 +50,21 @@ DataViewNewObjectKind(JSContext* cx, uin
     jsbytecode* pc;
     JSScript* script = cx->currentScript(&pc);
     if (script && ObjectGroup::useSingletonForAllocationSite(script, pc, &DataViewObject::class_))
         return SingletonObject;
     return GenericObject;
 }
 
 DataViewObject*
-DataViewObject::create(JSContext* cx, uint32_t byteOffset, uint32_t byteLength,
-                       Handle<ArrayBufferObjectMaybeShared*> arrayBuffer, JSObject* protoArg)
+DataViewObject::create(JSContext* cx,
+                       uint32_t byteOffset,
+                       uint32_t byteLength,
+                       Handle<ArrayBufferObjectMaybeShared*> arrayBuffer,
+                       JSObject* protoArg)
 {
     if (arrayBuffer->isDetached()) {
         JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_TYPED_ARRAY_DETACHED);
         return nullptr;
     }
 
     MOZ_ASSERT(byteOffset <= INT32_MAX);
     MOZ_ASSERT(byteLength <= INT32_MAX);
@@ -76,19 +79,18 @@ DataViewObject::create(JSContext* cx, ui
         return nullptr;
 
     if (!proto) {
         if (byteLength >= TypedArrayObject::SINGLETON_BYTE_LENGTH) {
             MOZ_ASSERT(obj->isSingleton());
         } else {
             jsbytecode* pc;
             RootedScript script(cx, cx->currentScript(&pc));
-            if (script && !ObjectGroup::setAllocationSiteObjectGroup(cx, script, pc, obj,
-                                                                     newKind == SingletonObject))
-            {
+            if (script && !ObjectGroup::setAllocationSiteObjectGroup(
+                            cx, script, pc, obj, newKind == SingletonObject)) {
                 return nullptr;
             }
         }
     }
 
     // Caller should have established these preconditions, and no
     // (non-self-hosted) JS code has had an opportunity to run so nothing can
     // have invalidated them.
@@ -139,23 +141,31 @@ DataViewObject::create(JSContext* cx, ui
     }
 
     return &dvobj;
 }
 
 // ES2017 draft rev 931261ecef9b047b14daacf82884134da48dfe0f
 // 24.3.2.1 DataView (extracted part of the main algorithm)
 bool
-DataViewObject::getAndCheckConstructorArgs(JSContext* cx, HandleObject bufobj, const CallArgs& args,
-                                           uint32_t* byteOffsetPtr, uint32_t* byteLengthPtr)
+DataViewObject::getAndCheckConstructorArgs(JSContext* cx,
+                                           HandleObject bufobj,
+                                           const CallArgs& args,
+                                           uint32_t* byteOffsetPtr,
+                                           uint32_t* byteLengthPtr)
 {
     // Step 3.
     if (!IsArrayBufferMaybeShared(bufobj)) {
-        JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE,
-                                  "DataView", "ArrayBuffer", bufobj->getClass()->name);
+        JS_ReportErrorNumberASCII(cx,
+                                  GetErrorMessage,
+                                  nullptr,
+                                  JSMSG_NOT_EXPECTED_TYPE,
+                                  "DataView",
+                                  "ArrayBuffer",
+                                  bufobj->getClass()->name);
         return false;
     }
     Rooted<ArrayBufferObjectMaybeShared*> buffer(cx, &AsArrayBufferMaybeShared(bufobj));
 
     // Step 4.
     uint64_t offset;
     if (!ToIndex(cx, args.get(1), &offset))
         return false;
@@ -178,24 +188,23 @@ DataViewObject::getAndCheckConstructorAr
 
     // Step 8.a
     uint64_t viewByteLength = bufferByteLength - offset;
     if (args.hasDefined(2)) {
         // Step 9.a.
         if (!ToIndex(cx, args.get(2), &viewByteLength))
             return false;
 
-
         MOZ_ASSERT(offset + viewByteLength >= offset,
                    "can't overflow: both numbers are less than DOUBLE_INTEGRAL_PRECISION_LIMIT");
 
         // Step 9.b.
         if (offset + viewByteLength > bufferByteLength) {
-            JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
-                                      JSMSG_ARG_INDEX_OUT_OF_RANGE, "2");
+            JS_ReportErrorNumberASCII(
+              cx, GetErrorMessage, nullptr, JSMSG_ARG_INDEX_OUT_OF_RANGE, "2");
             return false;
         }
     }
     MOZ_ASSERT(viewByteLength <= INT32_MAX);
 
     *byteOffsetPtr = AssertedCast<uint32_t>(offset);
     *byteLengthPtr = AssertedCast<uint32_t>(viewByteLength);
     return true;
@@ -309,25 +318,26 @@ DataViewObject::construct(JSContext* cx,
     if (!GetFirstArgumentAsObject(cx, args, "DataView constructor", &bufobj))
         return false;
 
     if (bufobj->is<WrapperObject>())
         return constructWrapped(cx, bufobj, args);
     return constructSameCompartment(cx, bufobj, args);
 }
 
-template <typename NativeType>
+template<typename NativeType>
 /* static */ SharedMem<uint8_t*>
-DataViewObject::getDataPointer(JSContext* cx, Handle<DataViewObject*> obj, uint64_t offset,
+DataViewObject::getDataPointer(JSContext* cx,
+                               Handle<DataViewObject*> obj,
+                               uint64_t offset,
                                bool* isSharedMemory)
 {
     const size_t TypeSize = sizeof(NativeType);
     if (offset > UINT32_MAX - TypeSize || offset + TypeSize > obj->byteLength()) {
-        JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_ARG_INDEX_OUT_OF_RANGE,
-                                  "1");
+        JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_ARG_INDEX_OUT_OF_RANGE, "1");
         return SharedMem<uint8_t*>::unshared(nullptr);
     }
 
     MOZ_ASSERT(offset < UINT32_MAX);
     *isSharedMemory = obj->isSharedMemory();
     return obj->dataPointerEither().cast<uint8_t*>() + uint32_t(offset);
 }
 
@@ -351,39 +361,73 @@ static inline uint16_t
 swapBytes(uint16_t x)
 {
     return ((x & 0xff) << 8) | (x >> 8);
 }
 
 static inline uint32_t
 swapBytes(uint32_t x)
 {
-    return ((x & 0xff) << 24) |
-           ((x & 0xff00) << 8) |
-           ((x & 0xff0000) >> 8) |
+    return ((x & 0xff) << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) |
            ((x & 0xff000000) >> 24);
 }
 
 static inline uint64_t
 swapBytes(uint64_t x)
 {
     uint32_t a = x & UINT32_MAX;
     uint32_t b = x >> 32;
     return (uint64_t(swapBytes(a)) << 32) | swapBytes(b);
 }
 
-template <typename DataType> struct DataToRepType { typedef DataType result; };
-template <> struct DataToRepType<int8_t>   { typedef uint8_t result; };
-template <> struct DataToRepType<uint8_t>  { typedef uint8_t result; };
-template <> struct DataToRepType<int16_t>  { typedef uint16_t result; };
-template <> struct DataToRepType<uint16_t> { typedef uint16_t result; };
-template <> struct DataToRepType<int32_t>  { typedef uint32_t result; };
-template <> struct DataToRepType<uint32_t> { typedef uint32_t result; };
-template <> struct DataToRepType<float>    { typedef uint32_t result; };
-template <> struct DataToRepType<double>   { typedef uint64_t result; };
+template<typename DataType>
+struct DataToRepType
+{
+    typedef DataType result;
+};
+template<>
+struct DataToRepType<int8_t>
+{
+    typedef uint8_t result;
+};
+template<>
+struct DataToRepType<uint8_t>
+{
+    typedef uint8_t result;
+};
+template<>
+struct DataToRepType<int16_t>
+{
+    typedef uint16_t result;
+};
+template<>
+struct DataToRepType<uint16_t>
+{
+    typedef uint16_t result;
+};
+template<>
+struct DataToRepType<int32_t>
+{
+    typedef uint32_t result;
+};
+template<>
+struct DataToRepType<uint32_t>
+{
+    typedef uint32_t result;
+};
+template<>
+struct DataToRepType<float>
+{
+    typedef uint32_t result;
+};
+template<>
+struct DataToRepType<double>
+{
+    typedef uint64_t result;
+};
 
 static inline void
 Memcpy(uint8_t* dest, uint8_t* src, size_t nbytes)
 {
     memcpy(dest, src, nbytes);
 }
 
 static inline void
@@ -393,44 +437,48 @@ Memcpy(uint8_t* dest, SharedMem<uint8_t*
 }
 
 static inline void
 Memcpy(SharedMem<uint8_t*> dest, uint8_t* src, size_t nbytes)
 {
     jit::AtomicOperations::memcpySafeWhenRacy(dest, src, nbytes);
 }
 
-template <typename DataType, typename BufferPtrType>
+template<typename DataType, typename BufferPtrType>
 struct DataViewIO
 {
     typedef typename DataToRepType<DataType>::result ReadWriteType;
 
     static void fromBuffer(DataType* dest, BufferPtrType unalignedBuffer, bool wantSwap)
     {
-        MOZ_ASSERT((reinterpret_cast<uintptr_t>(dest) & (Min<size_t>(MOZ_ALIGNOF(void*), sizeof(DataType)) - 1)) == 0);
-        Memcpy((uint8_t*) dest, unalignedBuffer, sizeof(ReadWriteType));
+        MOZ_ASSERT((reinterpret_cast<uintptr_t>(dest) &
+                    (Min<size_t>(MOZ_ALIGNOF(void*), sizeof(DataType)) - 1)) == 0);
+        Memcpy((uint8_t*)dest, unalignedBuffer, sizeof(ReadWriteType));
         if (wantSwap) {
             ReadWriteType* rwDest = reinterpret_cast<ReadWriteType*>(dest);
             *rwDest = swapBytes(*rwDest);
         }
     }
 
     static void toBuffer(BufferPtrType unalignedBuffer, const DataType* src, bool wantSwap)
     {
-        MOZ_ASSERT((reinterpret_cast<uintptr_t>(src) & (Min<size_t>(MOZ_ALIGNOF(void*), sizeof(DataType)) - 1)) == 0);
+        MOZ_ASSERT((reinterpret_cast<uintptr_t>(src) &
+                    (Min<size_t>(MOZ_ALIGNOF(void*), sizeof(DataType)) - 1)) == 0);
         ReadWriteType temp = *reinterpret_cast<const ReadWriteType*>(src);
         if (wantSwap)
             temp = swapBytes(temp);
-        Memcpy(unalignedBuffer, (uint8_t*) &temp, sizeof(ReadWriteType));
+        Memcpy(unalignedBuffer, (uint8_t*)&temp, sizeof(ReadWriteType));
     }
 };
 
 template<typename NativeType>
 /* static */ bool
-DataViewObject::read(JSContext* cx, Handle<DataViewObject*> obj, const CallArgs& args,
+DataViewObject::read(JSContext* cx,
+                     Handle<DataViewObject*> obj,
+                     const CallArgs& args,
                      NativeType* val)
 {
     // Steps 1-2. done by the caller
     // Step 3. unnecessary assert
 
     // Step 4.
     uint64_t getIndex;
     if (!ToIndex(cx, args.get(0), &getIndex))
@@ -442,58 +490,58 @@ DataViewObject::read(JSContext* cx, Hand
     // Steps 6-7.
     if (obj->arrayBufferEither().isDetached()) {
         JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_TYPED_ARRAY_DETACHED);
         return false;
     }
 
     // Steps 8-12.
     bool isSharedMemory;
-    SharedMem<uint8_t*> data = DataViewObject::getDataPointer<NativeType>(cx, obj, getIndex,
-                                                                          &isSharedMemory);
+    SharedMem<uint8_t*> data =
+      DataViewObject::getDataPointer<NativeType>(cx, obj, getIndex, &isSharedMemory);
     if (!data)
         return false;
 
     // Step 13.
     if (isSharedMemory) {
-        DataViewIO<NativeType, SharedMem<uint8_t*>>::fromBuffer(val, data,
-                                                                needToSwapBytes(isLittleEndian));
+        DataViewIO<NativeType, SharedMem<uint8_t*>>::fromBuffer(
+          val, data, needToSwapBytes(isLittleEndian));
     } else {
-        DataViewIO<NativeType, uint8_t*>::fromBuffer(val, data.unwrapUnshared(),
-                                                     needToSwapBytes(isLittleEndian));
+        DataViewIO<NativeType, uint8_t*>::fromBuffer(
+          val, data.unwrapUnshared(), needToSwapBytes(isLittleEndian));
     }
     return true;
 }
 
-template <typename NativeType>
+template<typename NativeType>
 static inline bool
 WebIDLCast(JSContext* cx, HandleValue value, NativeType* out)
 {
     int32_t temp;
     if (!ToInt32(cx, value, &temp))
         return false;
     // Technically, the behavior of assigning an out of range value to a signed
     // variable is undefined. In practice, compilers seem to do what we want
     // without issuing any warnings.
     *out = static_cast<NativeType>(temp);
     return true;
 }
 
-template <>
+template<>
 inline bool
 WebIDLCast<float>(JSContext* cx, HandleValue value, float* out)
 {
     double temp;
     if (!ToNumber(cx, value, &temp))
         return false;
     *out = static_cast<float>(temp);
     return true;
 }
 
-template <>
+template<>
 inline bool
 WebIDLCast<double>(JSContext* cx, HandleValue value, double* out)
 {
     return ToNumber(cx, value, out);
 }
 
 template<typename NativeType>
 /* static */ bool
@@ -524,28 +572,28 @@ DataViewObject::write(JSContext* cx, Han
     // Steps 7-8.
     if (obj->arrayBufferEither().isDetached()) {
         JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_TYPED_ARRAY_DETACHED);
         return false;
     }
 
     // Steps 9-13.
     bool isSharedMemory;
-    SharedMem<uint8_t*> data = DataViewObject::getDataPointer<NativeType>(cx, obj, getIndex,
-                                                                          &isSharedMemory);
+    SharedMem<uint8_t*> data =
+      DataViewObject::getDataPointer<NativeType>(cx, obj, getIndex, &isSharedMemory);
     if (!data)
         return false;
 
     // Step 14.
     if (isSharedMemory) {
-        DataViewIO<NativeType, SharedMem<uint8_t*>>::toBuffer(data, &value,
-                                                              needToSwapBytes(isLittleEndian));
+        DataViewIO<NativeType, SharedMem<uint8_t*>>::toBuffer(
+          data, &value, needToSwapBytes(isLittleEndian));
     } else {
-        DataViewIO<NativeType, uint8_t*>::toBuffer(data.unwrapUnshared(), &value,
-                                                   needToSwapBytes(isLittleEndian));
+        DataViewIO<NativeType, uint8_t*>::toBuffer(
+          data.unwrapUnshared(), &value, needToSwapBytes(isLittleEndian));
     }
     return true;
 }
 
 bool
 DataViewObject::getInt8Impl(JSContext* cx, const CallArgs& args)
 {
     MOZ_ASSERT(is(args.thisv()));
@@ -870,17 +918,16 @@ DataViewObject::setFloat64Impl(JSContext
 
 bool
 DataViewObject::fun_setFloat64(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     return CallNonGenericMethod<is, setFloat64Impl>(cx, args);
 }
 
-
 bool
 DataViewObject::bufferGetterImpl(JSContext* cx, const CallArgs& args)
 {
     Rooted<DataViewObject*> thisView(cx, &args.thisv().toObject().as<DataViewObject>());
     args.rval().set(DataViewObject::bufferValue(thisView));
     return true;
 }
 
@@ -916,79 +963,74 @@ DataViewObject::byteOffsetGetterImpl(JSC
 
 bool
 DataViewObject::byteOffsetGetter(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     return CallNonGenericMethod<is, byteOffsetGetterImpl>(cx, args);
 }
 
-const Class DataViewObject::protoClass_ = {
-    js_Object_str,
-    JSCLASS_HAS_CACHED_PROTO(JSProto_DataView),
-    JS_NULL_CLASS_OPS,
-    &DataViewObject::classSpec_
-};
+const Class DataViewObject::protoClass_ = { js_Object_str,
+                                            JSCLASS_HAS_CACHED_PROTO(JSProto_DataView),
+                                            JS_NULL_CLASS_OPS,
+                                            &DataViewObject::classSpec_ };
 
 JSObject*
 DataViewObject::CreatePrototype(JSContext* cx, JSProtoKey key)
 {
     return GlobalObject::createBlankPrototype(cx, cx->global(), &DataViewObject::protoClass_);
 }
 
-static const ClassOps DataViewObjectClassOps = {
-    nullptr, /* addProperty */
-    nullptr, /* delProperty */
-    nullptr, /* getProperty */
-    nullptr, /* setProperty */
-    nullptr, /* enumerate */
-    nullptr, /* resolve */
-    nullptr, /* mayResolve */
-    nullptr, /* finalize */
-    nullptr, /* call */
-    nullptr, /* hasInstance */
-    nullptr, /* construct */
-    ArrayBufferViewObject::trace
-};
+static const ClassOps DataViewObjectClassOps = { nullptr, /* addProperty */
+                                                 nullptr, /* delProperty */
+                                                 nullptr, /* getProperty */
+                                                 nullptr, /* setProperty */
+                                                 nullptr, /* enumerate */
+                                                 nullptr, /* resolve */
+                                                 nullptr, /* mayResolve */
+                                                 nullptr, /* finalize */
+                                                 nullptr, /* call */
+                                                 nullptr, /* hasInstance */
+                                                 nullptr, /* construct */
+                                                 ArrayBufferViewObject::trace };
 
 const ClassSpec DataViewObject::classSpec_ = {
     GenericCreateConstructor<DataViewObject::construct, 3, gc::AllocKind::FUNCTION>,
     DataViewObject::CreatePrototype,
     nullptr,
     nullptr,
     DataViewObject::methods,
     DataViewObject::properties,
 };
 
 const Class DataViewObject::class_ = {
     "DataView",
-    JSCLASS_HAS_PRIVATE |
-    JSCLASS_HAS_RESERVED_SLOTS(TypedArrayObject::RESERVED_SLOTS) |
-    JSCLASS_HAS_CACHED_PROTO(JSProto_DataView),
+    JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(TypedArrayObject::RESERVED_SLOTS) |
+      JSCLASS_HAS_CACHED_PROTO(JSProto_DataView),
     &DataViewObjectClassOps,
     &DataViewObject::classSpec_
 };
 
 const JSFunctionSpec DataViewObject::methods[] = {
-    JS_FN("getInt8",    DataViewObject::fun_getInt8,      1,0),
-    JS_FN("getUint8",   DataViewObject::fun_getUint8,     1,0),
-    JS_FN("getInt16",   DataViewObject::fun_getInt16,     1,0),
-    JS_FN("getUint16",  DataViewObject::fun_getUint16,    1,0),
-    JS_FN("getInt32",   DataViewObject::fun_getInt32,     1,0),
-    JS_FN("getUint32",  DataViewObject::fun_getUint32,    1,0),
-    JS_FN("getFloat32", DataViewObject::fun_getFloat32,   1,0),
-    JS_FN("getFloat64", DataViewObject::fun_getFloat64,   1,0),
-    JS_FN("setInt8",    DataViewObject::fun_setInt8,      2,0),
-    JS_FN("setUint8",   DataViewObject::fun_setUint8,     2,0),
-    JS_FN("setInt16",   DataViewObject::fun_setInt16,     2,0),
-    JS_FN("setUint16",  DataViewObject::fun_setUint16,    2,0),
-    JS_FN("setInt32",   DataViewObject::fun_setInt32,     2,0),
-    JS_FN("setUint32",  DataViewObject::fun_setUint32,    2,0),
-    JS_FN("setFloat32", DataViewObject::fun_setFloat32,   2,0),
-    JS_FN("setFloat64", DataViewObject::fun_setFloat64,   2,0),
+    JS_FN("getInt8", DataViewObject::fun_getInt8, 1, 0),
+    JS_FN("getUint8", DataViewObject::fun_getUint8, 1, 0),
+    JS_FN("getInt16", DataViewObject::fun_getInt16, 1, 0),
+    JS_FN("getUint16", DataViewObject::fun_getUint16, 1, 0),
+    JS_FN("getInt32", DataViewObject::fun_getInt32, 1, 0),
+    JS_FN("getUint32", DataViewObject::fun_getUint32, 1, 0),
+    JS_FN("getFloat32", DataViewObject::fun_getFloat32, 1, 0),
+    JS_FN("getFloat64", DataViewObject::fun_getFloat64, 1, 0),
+    JS_FN("setInt8", DataViewObject::fun_setInt8, 2, 0),
+    JS_FN("setUint8", DataViewObject::fun_setUint8, 2, 0),
+    JS_FN("setInt16", DataViewObject::fun_setInt16, 2, 0),
+    JS_FN("setUint16", DataViewObject::fun_setUint16, 2, 0),
+    JS_FN("setInt32", DataViewObject::fun_setInt32, 2, 0),
+    JS_FN("setUint32", DataViewObject::fun_setUint32, 2, 0),
+    JS_FN("setFloat32", DataViewObject::fun_setFloat32, 2, 0),
+    JS_FN("setFloat64", DataViewObject::fun_setFloat64, 2, 0),
     JS_FS_END
 };
 
 const JSPropertySpec DataViewObject::properties[] = {
     JS_PSG("buffer", DataViewObject::bufferGetter, 0),
     JS_PSG("byteLength", DataViewObject::byteLengthGetter, 0),
     JS_PSG("byteOffset", DataViewObject::byteOffsetGetter, 0),
     JS_STRING_SYM_PS(toStringTag, "DataView", JSPROP_READONLY),
--- a/js/src/builtin/DataViewObject.h
+++ b/js/src/builtin/DataViewObject.h
@@ -27,88 +27,102 @@ namespace js {
 class DataViewObject : public NativeObject
 {
   private:
     static const Class protoClass_;
     static const ClassSpec classSpec_;
 
     static JSObject* CreatePrototype(JSContext* cx, JSProtoKey key);
 
-    static bool is(HandleValue v) {
-        return v.isObject() && v.toObject().hasClass(&class_);
-    }
+    static bool is(HandleValue v) { return v.isObject() && v.toObject().hasClass(&class_); }
 
-    template <typename NativeType>
-    static SharedMem<uint8_t*>
-    getDataPointer(JSContext* cx, Handle<DataViewObject*> obj, uint64_t offset, bool* isSharedMemory);
+    template<typename NativeType>
+    static SharedMem<uint8_t*> getDataPointer(JSContext* cx,
+                                              Handle<DataViewObject*> obj,
+                                              uint64_t offset,
+                                              bool* isSharedMemory);
 
     static bool bufferGetterImpl(JSContext* cx, const CallArgs& args);
     static bool bufferGetter(JSContext* cx, unsigned argc, Value* vp);
 
     static bool byteLengthGetterImpl(JSContext* cx, const CallArgs& args);
     static bool byteLengthGetter(JSContext* cx, unsigned argc, Value* vp);
 
     static bool byteOffsetGetterImpl(JSContext* cx, const CallArgs& args);
     static bool byteOffsetGetter(JSContext* cx, unsigned argc, Value* vp);
 
-    static bool
-    getAndCheckConstructorArgs(JSContext* cx, HandleObject bufobj, const CallArgs& args,
-                               uint32_t* byteOffset, uint32_t* byteLength);
+    static bool getAndCheckConstructorArgs(JSContext* cx,
+                                           HandleObject bufobj,
+                                           const CallArgs& args,
+                                           uint32_t* byteOffset,
+                                           uint32_t* byteLength);
     static bool constructSameCompartment(JSContext* cx, HandleObject bufobj, const CallArgs& args);
     static bool constructWrapped(JSContext* cx, HandleObject bufobj, const CallArgs& args);
 
-    static DataViewObject*
-    create(JSContext* cx, uint32_t byteOffset, uint32_t byteLength,
-           Handle<ArrayBufferObjectMaybeShared*> arrayBuffer, JSObject* proto);
+    static DataViewObject* create(JSContext* cx,
+                                  uint32_t byteOffset,
+                                  uint32_t byteLength,
+                                  Handle<ArrayBufferObjectMaybeShared*> arrayBuffer,
+                                  JSObject* proto);
 
   public:
     static const Class class_;
 
-    static Value byteOffsetValue(DataViewObject* view) {
+    static Value byteOffsetValue(DataViewObject* view)
+    {
         Value v = view->getFixedSlot(TypedArrayObject::BYTEOFFSET_SLOT);
         MOZ_ASSERT(v.toInt32() >= 0);
         return v;
     }
 
-    static Value byteLengthValue(DataViewObject* view) {
+    static Value byteLengthValue(DataViewObject* view)
+    {
         Value v = view->getFixedSlot(TypedArrayObject::LENGTH_SLOT);
         MOZ_ASSERT(v.toInt32() >= 0);
         return v;
     }
 
-    static Value bufferValue(DataViewObject* view) {
+    static Value bufferValue(DataViewObject* view)
+    {
         return view->getFixedSlot(TypedArrayObject::BUFFER_SLOT);
     }
 
-    uint32_t byteOffset() const {
+    uint32_t byteOffset() const
+    {
         return byteOffsetValue(const_cast<DataViewObject*>(this)).toInt32();
     }
 
-    uint32_t byteLength() const {
+    uint32_t byteLength() const
+    {
         return byteLengthValue(const_cast<DataViewObject*>(this)).toInt32();
     }
 
-    ArrayBufferObjectMaybeShared& arrayBufferEither() const {
-        return bufferValue(
-            const_cast<DataViewObject*>(this)).toObject().as<ArrayBufferObjectMaybeShared>();
+    ArrayBufferObjectMaybeShared& arrayBufferEither() const
+    {
+        return bufferValue(const_cast<DataViewObject*>(this))
+          .toObject()
+          .as<ArrayBufferObjectMaybeShared>();
     }
 
-    SharedMem<void*> dataPointerEither() const {
-        void *p = getPrivate();
+    SharedMem<void*> dataPointerEither() const
+    {
+        void* p = getPrivate();
         if (isSharedMemory())
             return SharedMem<void*>::shared(p);
         return SharedMem<void*>::unshared(p);
     }
 
-    void* dataPointerUnshared() const {
+    void* dataPointerUnshared() const
+    {
         MOZ_ASSERT(!isSharedMemory());
         return getPrivate();
     }
 
-    void* dataPointerShared() const {
+    void* dataPointerShared() const
+    {
         MOZ_ASSERT(isSharedMemory());
         return getPrivate();
     }
 
     static bool construct(JSContext* cx, unsigned argc, Value* vp);
 
     static bool getInt8Impl(JSContext* cx, const CallArgs& args);
     static bool fun_getInt8(JSContext* cx, unsigned argc, Value* vp);
@@ -156,17 +170,19 @@ class DataViewObject : public NativeObje
     static bool fun_setFloat32(JSContext* cx, unsigned argc, Value* vp);
 
     static bool setFloat64Impl(JSContext* cx, const CallArgs& args);
     static bool fun_setFloat64(JSContext* cx, unsigned argc, Value* vp);
 
     static bool initClass(JSContext* cx);
     static void notifyBufferDetached(JSObject* view);
     template<typename NativeType>
-    static bool read(JSContext* cx, Handle<DataViewObject*> obj, const CallArgs& args,
+    static bool read(JSContext* cx,
+                     Handle<DataViewObject*> obj,
+                     const CallArgs& args,
                      NativeType* val);
     template<typename NativeType>
     static bool write(JSContext* cx, Handle<DataViewObject*> obj, const CallArgs& args);
 
     void notifyBufferDetached(void* newData);
 
   private:
     static const JSFunctionSpec methods[];
--- a/js/src/builtin/Eval.cpp
+++ b/js/src/builtin/Eval.cpp
@@ -38,64 +38,66 @@ AssertInnerizedEnvironmentChain(JSContex
 #endif
 }
 
 static bool
 IsEvalCacheCandidate(JSScript* script)
 {
     // Make sure there are no inner objects which might use the wrong parent
     // and/or call scope by reusing the previous eval's script.
-    return script->isDirectEvalInFunction() &&
-           !script->hasSingletons() &&
-           !script->hasObjects();
+    return script->isDirectEvalInFunction() && !script->hasSingletons() && !script->hasObjects();
 }
 
 /* static */ HashNumber
 EvalCacheHashPolicy::hash(const EvalCacheLookup& l)
 {
     AutoCheckCannotGC nogc;
     uint32_t hash = l.str->hasLatin1Chars()
-                    ? HashString(l.str->latin1Chars(nogc), l.str->length())
-                    : HashString(l.str->twoByteChars(nogc), l.str->length());
+                      ? HashString(l.str->latin1Chars(nogc), l.str->length())
+                      : HashString(l.str->twoByteChars(nogc), l.str->length());
     return AddToHash(hash, l.callerScript.get(), l.version, l.pc);
 }
 
 /* static */ bool
 EvalCacheHashPolicy::match(const EvalCacheEntry& cacheEntry, const EvalCacheLookup& l)
 {
     JSScript* script = cacheEntry.script;
 
     MOZ_ASSERT(IsEvalCacheCandidate(script));
 
-    return EqualStrings(cacheEntry.str, l.str) &&
-           cacheEntry.callerScript == l.callerScript &&
-           script->getVersion() == l.version &&
-           cacheEntry.pc == l.pc;
+    return EqualStrings(cacheEntry.str, l.str) && cacheEntry.callerScript == l.callerScript &&
+           script->getVersion() == l.version && cacheEntry.pc == l.pc;
 }
 
 // Add the script to the eval cache when EvalKernel is finished
 class EvalScriptGuard
 {
     JSContext* cx_;
     Rooted<JSScript*> script_;
 
     /* These fields are only valid if lookup_.str is non-nullptr. */
     EvalCacheLookup lookup_;
     mozilla::Maybe<DependentAddPtr<EvalCache>> p_;
 
     RootedLinearString lookupStr_;
 
   public:
     explicit EvalScriptGuard(JSContext* cx)
-        : cx_(cx), script_(cx), lookup_(cx), lookupStr_(cx) {}
+      : cx_(cx)
+      , script_(cx)
+      , lookup_(cx)
+      , lookupStr_(cx)
+    {
+    }
 
-    ~EvalScriptGuard() {
+    ~EvalScriptGuard()
+    {
         if (script_ && !cx_->isExceptionPending()) {
             script_->cacheForEval();
-            EvalCacheEntry cacheEntry = {lookupStr_, script_, lookup_.callerScript, lookup_.pc};
+            EvalCacheEntry cacheEntry = { lookupStr_, script_, lookup_.callerScript, lookup_.pc };
             lookup_.str = lookupStr_;
             if (lookup_.str && IsEvalCacheCandidate(script_)) {
                 // Ignore failure to add cache entry.
                 if (!p_->add(cx_, cx_->caches().evalCache, lookup_, cacheEntry))
                     cx_->recoverFromOutOfMemory();
             }
         }
     }
@@ -110,87 +112,86 @@ class EvalScriptGuard
         p_.emplace(cx_, cx_->caches().evalCache, lookup_);
         if (*p_) {
             script_ = (*p_)->script;
             p_->remove(cx_, cx_->caches().evalCache, lookup_);
             script_->uncacheForEval();
         }
     }
 
-    void setNewScript(JSScript* script) {
+    void setNewScript(JSScript* script)
+    {
         // JSScript::initFromEmitter has already called js_CallNewScriptHook.
         MOZ_ASSERT(!script_ && script);
         script_ = script;
         script_->setActiveEval();
     }
 
-    bool foundScript() {
-        return !!script_;
-    }
+    bool foundScript() { return !!script_; }
 
-    HandleScript script() {
+    HandleScript script()
+    {
         MOZ_ASSERT(script_);
         return script_;
     }
 };
 
-enum EvalJSONResult {
+enum EvalJSONResult
+{
     EvalJSON_Failure,
     EvalJSON_Success,
     EvalJSON_NotJSON
 };
 
-template <typename CharT>
+template<typename CharT>
 static bool
 EvalStringMightBeJSON(const mozilla::Range<const CharT> chars)
 {
     // If the eval string starts with '(' or '[' and ends with ')' or ']', it may be JSON.
     // Try the JSON parser first because it's much faster.  If the eval string
     // isn't JSON, JSON parsing will probably fail quickly, so little time
     // will be lost.
     size_t length = chars.length();
-    if (length > 2 &&
-        ((chars[0] == '[' && chars[length - 1] == ']') ||
-         (chars[0] == '(' && chars[length - 1] == ')')))
-    {
+    if (length > 2 && ((chars[0] == '[' && chars[length - 1] == ']') ||
+                       (chars[0] == '(' && chars[length - 1] == ')'))) {
         // Remarkably, JavaScript syntax is not a superset of JSON syntax:
         // strings in JavaScript cannot contain the Unicode line and paragraph
         // terminator characters U+2028 and U+2029, but strings in JSON can.
         // Rather than force the JSON parser to handle this quirk when used by
         // eval, we simply don't use the JSON parser when either character
         // appears in the provided string.  See bug 657367.
         if (sizeof(CharT) > 1) {
-            for (RangedPtr<const CharT> cp = chars.begin() + 1, end = chars.end() - 1;
-                 cp < end;
-                 cp++)
-            {
+            for (RangedPtr<const CharT> cp = chars.begin() + 1, end = chars.end() - 1; cp < end;
+                 cp++) {
                 char16_t c = *cp;
                 if (c == 0x2028 || c == 0x2029)
                     return false;
             }
         }
 
         return true;
     }
     return false;
 }
 
-template <typename CharT>
+template<typename CharT>
 static EvalJSONResult
-ParseEvalStringAsJSON(JSContext* cx, const mozilla::Range<const CharT> chars, MutableHandleValue rval)
+ParseEvalStringAsJSON(JSContext* cx,
+                      const mozilla::Range<const CharT> chars,
+                      MutableHandleValue rval)
 {
     size_t len = chars.length();
     MOZ_ASSERT((chars[0] == '(' && chars[len - 1] == ')') ||
                (chars[0] == '[' && chars[len - 1] == ']'));
 
-    auto jsonChars = (chars[0] == '[')
-                     ? chars
-                     : mozilla::Range<const CharT>(chars.begin().get() + 1U, len - 2);
+    auto jsonChars =
+      (chars[0] == '[') ? chars : mozilla::Range<const CharT>(chars.begin().get() + 1U, len - 2);
 
-    Rooted<JSONParser<CharT>> parser(cx, JSONParser<CharT>(cx, jsonChars, JSONParserBase::NoError));
+    Rooted<JSONParser<CharT>> parser(cx,
+                                     JSONParser<CharT>(cx, jsonChars, JSONParserBase::NoError));
     if (!parser.parse(rval))
         return EvalJSON_Failure;
 
     return rval.isUndefined() ? EvalJSON_NotJSON : EvalJSON_Success;
 }
 
 static EvalJSONResult
 TryEvalJSON(JSContext* cx, JSLinearString* str, MutableHandleValue rval)
@@ -204,34 +205,42 @@ TryEvalJSON(JSContext* cx, JSLinearStrin
         if (!EvalStringMightBeJSON(str->twoByteRange(nogc)))
             return EvalJSON_NotJSON;
     }
 
     AutoStableStringChars linearChars(cx);
     if (!linearChars.init(cx, str))
         return EvalJSON_Failure;
 
-    return linearChars.isLatin1()
-           ? ParseEvalStringAsJSON(cx, linearChars.latin1Range(), rval)
-           : ParseEvalStringAsJSON(cx, linearChars.twoByteRange(), rval);
+    return linearChars.isLatin1() ? ParseEvalStringAsJSON(cx, linearChars.latin1Range(), rval)
+                                  : ParseEvalStringAsJSON(cx, linearChars.twoByteRange(), rval);
 }
 
-enum EvalType { DIRECT_EVAL, INDIRECT_EVAL };
+enum EvalType
+{
+    DIRECT_EVAL,
+    INDIRECT_EVAL
+};
 
 // Common code implementing direct and indirect eval.
 //
 // Evaluate call.argv[2], if it is a string, in the context of the given calling
 // frame, with the provided scope chain, with the semantics of either a direct
 // or indirect eval (see ES5 10.4.2).  If this is an indirect eval, env
 // must be a global object.
 //
 // On success, store the completion value in call.rval and return true.
 static bool
-EvalKernel(JSContext* cx, HandleValue v, EvalType evalType, AbstractFramePtr caller,
-           HandleObject env, jsbytecode* pc, MutableHandleValue vp)
+EvalKernel(JSContext* cx,
+           HandleValue v,
+           EvalType evalType,
+           AbstractFramePtr caller,
+           HandleObject env,
+           jsbytecode* pc,
+           MutableHandleValue vp)
 {
     MOZ_ASSERT((evalType == INDIRECT_EVAL) == !caller);
     MOZ_ASSERT((evalType == INDIRECT_EVAL) == !pc);
     MOZ_ASSERT_IF(evalType == INDIRECT_EVAL, IsGlobalLexicalEnvironment(env));
     AssertInnerizedEnvironmentChain(cx, *env);
 
     Rooted<GlobalObject*> envGlobal(cx, &env->global());
     if (!GlobalObject::isRuntimeCodeGenEnabled(cx, envGlobal)) {
@@ -269,75 +278,80 @@ EvalKernel(JSContext* cx, HandleValue v,
         esg.lookupInEvalCache(linearStr, callerScript, pc);
 
     if (!esg.foundScript()) {
         RootedScript maybeScript(cx);
         unsigned lineno;
         const char* filename;
         bool mutedErrors;
         uint32_t pcOffset;
-        DescribeScriptedCallerForCompilation(cx, &maybeScript, &filename, &lineno, &pcOffset,
+        DescribeScriptedCallerForCompilation(cx,
+                                             &maybeScript,
+                                             &filename,
+                                             &lineno,
+                                             &pcOffset,
                                              &mutedErrors,
-                                             evalType == DIRECT_EVAL
-                                             ? CALLED_FROM_JSOP_EVAL
-                                             : NOT_CALLED_FROM_JSOP_EVAL);
+                                             evalType == DIRECT_EVAL ? CALLED_FROM_JSOP_EVAL
+                                                                     : NOT_CALLED_FROM_JSOP_EVAL);
 
         const char* introducerFilename = filename;
         if (maybeScript && maybeScript->scriptSource()->introducerFilename())
             introducerFilename = maybeScript->scriptSource()->introducerFilename();
 
         RootedScope enclosing(cx);
         if (evalType == DIRECT_EVAL)
             enclosing = callerScript->innermostScope(pc);
         else
             enclosing = &cx->global()->emptyGlobalScope();
 
         CompileOptions options(cx);
         options.setIsRunOnce(true)
-               .setNoScriptRval(false)
-               .setMutedErrors(mutedErrors)
-               .maybeMakeStrictMode(evalType == DIRECT_EVAL && IsStrictEvalPC(pc));
+          .setNoScriptRval(false)
+          .setMutedErrors(mutedErrors)
+          .maybeMakeStrictMode(evalType == DIRECT_EVAL && IsStrictEvalPC(pc));
 
         if (introducerFilename) {
             options.setFileAndLine(filename, 1);
             options.setIntroductionInfo(introducerFilename, "eval", lineno, maybeScript, pcOffset);
         } else {
             options.setFileAndLine("eval", 1);
             options.setIntroductionType("eval");
         }
 
         AutoStableStringChars linearChars(cx);
         if (!linearChars.initTwoByte(cx, linearStr))
             return false;
 
         const char16_t* chars = linearChars.twoByteRange().begin().get();
         SourceBufferHolder::Ownership ownership = linearChars.maybeGiveOwnershipToCaller()
-                                                  ? SourceBufferHolder::GiveOwnership
-                                                  : SourceBufferHolder::NoOwnership;
+                                                    ? SourceBufferHolder::GiveOwnership
+                                                    : SourceBufferHolder::NoOwnership;
         SourceBufferHolder srcBuf(chars, linearStr->length(), ownership);
-        JSScript* compiled = frontend::CompileEvalScript(cx, cx->tempLifoAlloc(),
-                                                         env, enclosing,
-                                                         options, srcBuf);
+        JSScript* compiled =
+          frontend::CompileEvalScript(cx, cx->tempLifoAlloc(), env, enclosing, options, srcBuf);
         if (!compiled)
             return false;
 
         esg.setNewScript(compiled);
     }
 
     // Look up the newTarget from the frame iterator.
     Value newTargetVal = NullValue();
-    return ExecuteKernel(cx, esg.script(), *env, newTargetVal,
-                         NullFramePtr() /* evalInFrame */, vp.address());
+    return ExecuteKernel(
+      cx, esg.script(), *env, newTargetVal, NullFramePtr() /* evalInFrame */, vp.address());
 }
 
 bool
 js::DirectEvalStringFromIon(JSContext* cx,
-                            HandleObject env, HandleScript callerScript,
-                            HandleValue newTargetValue, HandleString str,
-                            jsbytecode* pc, MutableHandleValue vp)
+                            HandleObject env,
+                            HandleScript callerScript,
+                            HandleValue newTargetValue,
+                            HandleString str,
+                            jsbytecode* pc,
+                            MutableHandleValue vp)
 {
     AssertInnerizedEnvironmentChain(cx, *env);
 
     Rooted<GlobalObject*> envGlobal(cx, &env->global());
     if (!GlobalObject::isRuntimeCodeGenEnabled(cx, envGlobal)) {
         JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CSP_BLOCKED_EVAL);
         return false;
     }
@@ -357,100 +371,99 @@ js::DirectEvalStringFromIon(JSContext* c
     esg.lookupInEvalCache(linearStr, callerScript, pc);
 
     if (!esg.foundScript()) {
         RootedScript maybeScript(cx);
         const char* filename;
         unsigned lineno;
         bool mutedErrors;
         uint32_t pcOffset;
-        DescribeScriptedCallerForCompilation(cx, &maybeScript, &filename, &lineno, &pcOffset,
-                                             &mutedErrors, CALLED_FROM_JSOP_EVAL);
+        DescribeScriptedCallerForCompilation(
+          cx, &maybeScript, &filename, &lineno, &pcOffset, &mutedErrors, CALLED_FROM_JSOP_EVAL);
 
         const char* introducerFilename = filename;
         if (maybeScript && maybeScript->scriptSource()->introducerFilename())
             introducerFilename = maybeScript->scriptSource()->introducerFilename();
 
         RootedScope enclosing(cx, callerScript->innermostScope(pc));
 
         CompileOptions options(cx);
         options.setIsRunOnce(true)
-               .setNoScriptRval(false)
-               .setMutedErrors(mutedErrors)
-               .maybeMakeStrictMode(IsStrictEvalPC(pc));
+          .setNoScriptRval(false)
+          .setMutedErrors(mutedErrors)
+          .maybeMakeStrictMode(IsStrictEvalPC(pc));
 
         if (introducerFilename) {
             options.setFileAndLine(filename, 1);
             options.setIntroductionInfo(introducerFilename, "eval", lineno, maybeScript, pcOffset);
         } else {
             options.setFileAndLine("eval", 1);
             options.setIntroductionType("eval");
         }
 
         AutoStableStringChars linearChars(cx);
         if (!linearChars.initTwoByte(cx, linearStr))
             return false;
 
         const char16_t* chars = linearChars.twoByteRange().begin().get();
         SourceBufferHolder::Ownership ownership = linearChars.maybeGiveOwnershipToCaller()
-                                                  ? SourceBufferHolder::GiveOwnership
-                                                  : SourceBufferHolder::NoOwnership;
+                                                    ? SourceBufferHolder::GiveOwnership
+                                                    : SourceBufferHolder::NoOwnership;
         SourceBufferHolder srcBuf(chars, linearStr->length(), ownership);
-        JSScript* compiled = frontend::CompileEvalScript(cx, cx->tempLifoAlloc(),
-                                                         env, enclosing,
-                                                         options, srcBuf);
+        JSScript* compiled =
+          frontend::CompileEvalScript(cx, cx->tempLifoAlloc(), env, enclosing, options, srcBuf);
         if (!compiled)
             return false;
 
         esg.setNewScript(compiled);
     }
 
-    return ExecuteKernel(cx, esg.script(), *env, newTargetValue,
-                         NullFramePtr() /* evalInFrame */, vp.address());
+    return ExecuteKernel(
+      cx, esg.script(), *env, newTargetValue, NullFramePtr() /* evalInFrame */, vp.address());
 }
 
 bool
 js::IndirectEval(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     Rooted<GlobalObject*> global(cx, &args.callee().global());
     RootedObject globalLexical(cx, &global->lexicalEnvironment());
 
     // Note we'll just pass |undefined| here, then return it directly (or throw
     // if runtime codegen is disabled), if no argument is provided.