--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -269,17 +269,17 @@ class Node {
     }
     template<typename T>
     Node &operator=(const Rooted<T *> &root) {
         construct(root.get());
         return *this;
     }
 
     // Constructors accepting SpiderMonkey's other generic-pointer-ish types.
-    Node(JS::HandleValue value);
+    explicit Node(JS::HandleValue value);
     Node(JSGCTraceKind kind, void *ptr);
 
     // copy construction and copy assignment just use memcpy, since we know
     // instances contain nothing but a vtable pointer and a data pointer.
     //
     // To be completely correct, concrete classes could provide a virtual
     // 'construct' member function, which we could invoke on rhs to construct an
     // instance in our storage. But this is good enough; there's no need to jump

--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -2064,17 +2064,17 @@ IsSimdAvailable(JSContext *cx, unsigned 
     return true;
 }
 
 static bool
 ByteSize(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     mozilla::MallocSizeOf mallocSizeOf = cx->runtime()->debuggerMallocSizeOf;
-    JS::ubi::Node node = args.get(0);
+    JS::ubi::Node node(args.get(0));
     if (node)
         args.rval().set(NumberValue(node.size(mallocSizeOf)));
     else
         args.rval().setUndefined();
     return true;
 }
 
 static const JSFunctionSpecWithHelp TestingFunctions[] = {

--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -8763,17 +8763,17 @@ CodeGenerator::visitProfilerStackOp(LPro
     }
 }
 
 class OutOfLineIsCallable : public OutOfLineCodeBase<CodeGenerator>
 {
     LIsCallable *ins_;
 
   public:
-    OutOfLineIsCallable(LIsCallable *ins)
+    explicit OutOfLineIsCallable(LIsCallable *ins)
       : ins_(ins)
     { }
 
     bool accept(CodeGenerator *codegen) {
         return codegen->visitOutOfLineIsCallable(this);
     }
     LIsCallable *ins() const {
         return ins_;

--- a/js/src/jit/LIR-Common.h
+++ b/js/src/jit/LIR-Common.h
@@ -141,17 +141,17 @@ class LSimdSplatX4 : public LInstruction
     MSimdSplatX4 *mir() const {
         return mir_->toSimdSplatX4();
     }
 };
 
 class LSimdExtractElementBase : public LInstructionHelper<1, 1, 0>
 {
   protected:
-    LSimdExtractElementBase(const LAllocation &base) {
+    explicit LSimdExtractElementBase(const LAllocation &base) {
         setOperand(0, base);
     }
 
   public:
     const LAllocation *getBase() {
         return getOperand(0);
     }
     SimdLane lane() const {
@@ -159,26 +159,26 @@ class LSimdExtractElementBase : public L
     }
 };
 
 // Extracts an element from a given SIMD int32x4 lane.
 class LSimdExtractElementI : public LSimdExtractElementBase
 {
   public:
     LIR_HEADER(SimdExtractElementI);
-    LSimdExtractElementI(const LAllocation &base)
+    explicit LSimdExtractElementI(const LAllocation &base)
       : LSimdExtractElementBase(base)
     {}
 };
 // Extracts an element from a given SIMD float32x4 lane.
 class LSimdExtractElementF : public LSimdExtractElementBase
 {
   public:
     LIR_HEADER(SimdExtractElementF);
-    LSimdExtractElementF(const LAllocation &base)
+    explicit LSimdExtractElementF(const LAllocation &base)
       : LSimdExtractElementBase(base)
     {}
 };
 
 class LSimdInsertElementBase : public LInstructionHelper<1, 2, 0>
 {
   protected:
     LSimdInsertElementBase(const LAllocation &vec, const LAllocation &val)

--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -9894,17 +9894,17 @@ class MIteratorMore
     MDefinition *iterator() const {
         return getOperand(0);
     }
 };
 
 class MIsNoIter
   : public MUnaryInstruction
 {
-    MIsNoIter(MDefinition *def)
+    explicit MIsNoIter(MDefinition *def)
       : MUnaryInstruction(def)
     {
         setResultType(MIRType_Boolean);
         setMovable();
     }
 
   public:
     INSTRUCTION_HEADER(IsNoIter)

--- a/js/src/jsproxy.h
+++ b/js/src/jsproxy.h
@@ -383,17 +383,17 @@ inline bool
 IsScriptedProxy(JSObject *obj)
 {
     return IsProxy(obj) && GetProxyHandler(obj)->isScripted();
 }
 
 class MOZ_STACK_CLASS ProxyOptions {
   protected:
     /* protected constructor for subclass */
-    ProxyOptions(bool singletonArg)
+    explicit ProxyOptions(bool singletonArg)
       : singleton_(singletonArg),
         clasp_(ProxyClassPtr)
     {}
 
   public:
     ProxyOptions() : singleton_(false),
                      clasp_(ProxyClassPtr)
     {}