Bug 1054334 - SpiderMonkey: Delete unneeded semicolons r=nbp
authorDan Gohman <sunfish@mozilla.com>
Mon, 18 Aug 2014 12:20:39 -0700
changeset 200190 e682602319bee1e5a04ca985288b0b54336e80fc
parent 200189 a6dba0eca333b4f09597e6c463fb8648a54557f2
child 200191 80db0e307d6d9f4eb42fd26e3e4236d9040edf68
push id27337
push useremorley@mozilla.com
push dateTue, 19 Aug 2014 12:40:34 +0000
treeherdermozilla-central@a38daccaa557 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersnbp
bugs1054334
milestone34.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1054334 - SpiderMonkey: Delete unneeded semicolons r=nbp
js/public/ProfilingStack.h
js/public/UbiNode.h
js/public/WeakMapPtr.h
js/src/builtin/SIMD.cpp
js/src/ctypes/CTypes.cpp
js/src/jit/BaselineBailouts.cpp
js/src/jit/RangeAnalysis.cpp
js/src/jit/shared/IonAssemblerBuffer.h
js/src/jsapi-tests/testPersistentRooted.cpp
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsarray.cpp
js/src/jsfriendapi.h
js/src/jsgc.cpp
js/src/jsproxy.cpp
js/src/jsproxy.h
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.cpp
js/xpconnect/src/xpcprivate.h
--- a/js/public/ProfilingStack.h
+++ b/js/public/ProfilingStack.h
@@ -87,17 +87,17 @@ class ProfileEntry
     // All of these methods are marked with the 'volatile' keyword because SPS's
     // representation of the stack is stored such that all ProfileEntry
     // instances are volatile. These methods would not be available unless they
     // were marked as volatile as well.
 
     bool isCpp() const volatile { return hasFlag(IS_CPP_ENTRY); }
     bool isJs() const volatile { return !isCpp(); }
 
-    bool isCopyLabel() const volatile { return hasFlag(FRAME_LABEL_COPY); };
+    bool isCopyLabel() const volatile { return hasFlag(FRAME_LABEL_COPY); }
 
     void setLabel(const char *aString) volatile { string = aString; }
     const char *label() const volatile { return string; }
 
     void setJsFrame(JSScript *aScript, jsbytecode *aPc) volatile {
         flags_ = 0;
         spOrScript = aScript;
         setPC(aPc);
--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -401,17 +401,17 @@ class Edge {
 class EdgeRange {
   protected:
     // The current front edge of this range, or nullptr if this range is empty.
     Edge *front_;
 
     EdgeRange() : front_(nullptr) { }
 
   public:
-    virtual ~EdgeRange() { };
+    virtual ~EdgeRange() { }
 
     // True if there are no more edges in this range.
     bool empty() const { return !front_; }
 
     // The front edge of this range. This is owned by the EdgeRange, and is
     // only guaranteed to live until the next call to popFront, or until
     // the EdgeRange is destructed.
     const Edge &front() { return *front_; }
@@ -439,33 +439,33 @@ class TracerConcrete : public Base {
     JSCompartment *compartment() const MOZ_OVERRIDE { return nullptr; }
 
   protected:
     explicit TracerConcrete(Referent *ptr) : Base(ptr) { }
     Referent &get() const { return *static_cast<Referent *>(ptr); }
 
   public:
     static const jschar concreteTypeName[];
-    static void construct(void *storage, Referent *ptr) { new (storage) TracerConcrete(ptr); };
+    static void construct(void *storage, Referent *ptr) { new (storage) TracerConcrete(ptr); }
 };
 
 // For JS_TraceChildren-based types that have a 'compartment' method.
 template<typename Referent>
 class TracerConcreteWithCompartment : public TracerConcrete<Referent> {
     typedef TracerConcrete<Referent> TracerBase;
     JSCompartment *compartment() const MOZ_OVERRIDE {
         return TracerBase::get().compartment();
     }
 
     TracerConcreteWithCompartment(Referent *ptr) : TracerBase(ptr) { }
 
   public:
     static void construct(void *storage, Referent *ptr) {
         new (storage) TracerConcreteWithCompartment(ptr);
-    };
+    }
 };
 
 template<> struct Concrete<JSObject> : TracerConcreteWithCompartment<JSObject> { };
 template<> struct Concrete<JSString> : TracerConcrete<JSString> { };
 template<> struct Concrete<JS::Symbol> : TracerConcrete<JS::Symbol> { };
 template<> struct Concrete<JSScript> : TracerConcreteWithCompartment<JSScript> { };
 template<> struct Concrete<js::LazyScript> : TracerConcrete<js::LazyScript> { };
 template<> struct Concrete<js::jit::JitCode> : TracerConcrete<js::jit::JitCode> { };
--- a/js/public/WeakMapPtr.h
+++ b/js/public/WeakMapPtr.h
@@ -18,19 +18,19 @@ namespace JS {
 //
 // The supported template specializations are enumerated in WeakMapPtr.cpp. If
 // you want to use this class for a different key/value combination, add it to
 // the list and the compiler will generate the relevant machinery.
 template <typename K, typename V>
 class JS_PUBLIC_API(WeakMapPtr)
 {
   public:
-    WeakMapPtr() : ptr(nullptr) {};
+    WeakMapPtr() : ptr(nullptr) {}
     bool init(JSContext *cx);
-    bool initialized() { return ptr != nullptr; };
+    bool initialized() { return ptr != nullptr; }
     void destroy();
     virtual ~WeakMapPtr() { MOZ_ASSERT(!initialized()); }
     void trace(JSTracer *tracer);
 
     V lookup(const K &key);
     bool put(JSContext *cx, const K &key, const V &value);
 
     static void keyMarkCallback(JSTracer *trc, K key, void *data);
--- a/js/src/builtin/SIMD.cpp
+++ b/js/src/builtin/SIMD.cpp
@@ -685,17 +685,17 @@ FuncShuffle(JSContext *cx, unsigned argc
     const int32_t MAX_MASK_VALUE = int32_t(pow(double(V::lanes), double(V::lanes))) - 1;
     JS_ASSERT(MAX_MASK_VALUE > 0);
 
     Elem result[V::lanes];
     if (args.length() == 2) {
         if (!IsVectorObject<V>(args[0]) || !args[1].isInt32())
             return ErrorBadArgs(cx);
 
-        Elem *val = TypedObjectMemory<Elem *>(args[0]);;
+        Elem *val = TypedObjectMemory<Elem *>(args[0]);
         int32_t maskArg;
         if (!ToInt32(cx, args[1], &maskArg))
             return false;
         if (maskArg < 0 || maskArg > MAX_MASK_VALUE)
             return ErrorBadArgs(cx);
 
         for (unsigned i = 0; i < V::lanes; i++)
             result[i] = val[(maskArg >> (i * SELECT_SHIFT)) & SELECT_MASK];
@@ -729,17 +729,17 @@ Int32x4BinaryScalar(JSContext *cx, unsig
     CallArgs args = CallArgsFromVp(argc, vp);
     if (args.length() != 2)
         return ErrorBadArgs(cx);
 
     int32_t result[4];
     if (!IsVectorObject<Int32x4>(args[0]) || !args[1].isNumber())
         return ErrorBadArgs(cx);
 
-    int32_t *val = TypedObjectMemory<int32_t *>(args[0]);;
+    int32_t *val = TypedObjectMemory<int32_t *>(args[0]);
     int32_t bits;
     if (!ToInt32(cx, args[1], &bits))
         return false;
 
     for (unsigned i = 0; i < 4; i++)
         result[i] = Op::apply(val[i], bits);
     return StoreResult<Int32x4>(cx, args, result);
 }
--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -4424,17 +4424,17 @@ ArrayType::GetSafeLength(JSObject* obj, 
   JS_ASSERT(CType::IsCType(obj));
   JS_ASSERT(CType::GetTypeCode(obj) == TYPE_array);
 
   jsval length = JS_GetReservedSlot(obj, SLOT_LENGTH);
 
   // The "length" property can be an int, a double, or JSVAL_VOID
   // (for arrays of undefined length), and must always fit in a size_t.
   if (length.isInt32()) {
-    *result = length.toInt32();;
+    *result = length.toInt32();
     return true;
   }
   if (length.isDouble()) {
     *result = Convert<size_t>(length.toDouble());
     return true;
   }
 
   JS_ASSERT(length.isUndefined());
@@ -4450,17 +4450,17 @@ ArrayType::GetLength(JSObject* obj)
   jsval length = JS_GetReservedSlot(obj, SLOT_LENGTH);
 
   JS_ASSERT(!length.isUndefined());
 
   // The "length" property can be an int, a double, or JSVAL_VOID
   // (for arrays of undefined length), and must always fit in a size_t.
   // For callers who know it can never be JSVAL_VOID, return a size_t directly.
   if (length.isInt32())
-    return length.toInt32();;
+    return length.toInt32();
   return Convert<size_t>(length.toDouble());
 }
 
 ffi_type*
 ArrayType::BuildFFIType(JSContext* cx, JSObject* obj)
 {
   JS_ASSERT(CType::IsCType(obj));
   JS_ASSERT(CType::GetTypeCode(obj) == TYPE_array);
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -74,17 +74,17 @@ class BufferPointer
  */
 struct BaselineStackBuilder
 {
     IonBailoutIterator &iter_;
     IonJSFrameLayout *frame_;
 
     static size_t HeaderSize() {
         return AlignBytes(sizeof(BaselineBailoutInfo), sizeof(void *));
-    };
+    }
     size_t bufferTotal_;
     size_t bufferAvail_;
     size_t bufferUsed_;
     uint8_t *buffer_;
     BaselineBailoutInfo *header_;
 
     size_t framePushed_;
 
--- a/js/src/jit/RangeAnalysis.cpp
+++ b/js/src/jit/RangeAnalysis.cpp
@@ -672,23 +672,23 @@ Range::or_(TempAllocator &alloc, const R
     // When one operand is always 0 or always -1, it's a special case where we
     // can compute a fully precise result. Handling these up front also
     // protects the code below from calling CountLeadingZeroes32 with a zero
     // operand or from shifting an int32_t by 32.
     if (lhs->lower() == lhs->upper()) {
         if (lhs->lower() == 0)
             return new(alloc) Range(*rhs);
         if (lhs->lower() == -1)
-            return new(alloc) Range(*lhs);;
+            return new(alloc) Range(*lhs);
     }
     if (rhs->lower() == rhs->upper()) {
         if (rhs->lower() == 0)
             return new(alloc) Range(*lhs);
         if (rhs->lower() == -1)
-            return new(alloc) Range(*rhs);;
+            return new(alloc) Range(*rhs);
     }
 
     // The code below uses CountLeadingZeroes32, which has undefined behavior
     // if its operand is 0. We rely on the code above to protect it.
     JS_ASSERT_IF(lhs->lower() >= 0, lhs->upper() != 0);
     JS_ASSERT_IF(rhs->lower() >= 0, rhs->upper() != 0);
     JS_ASSERT_IF(lhs->upper() < 0, lhs->lower() != -1);
     JS_ASSERT_IF(rhs->upper() < 0, rhs->lower() != -1);
--- a/js/src/jit/shared/IonAssemblerBuffer.h
+++ b/js/src/jit/shared/IonAssemblerBuffer.h
@@ -45,17 +45,17 @@ class BufferOffset
     }
 
     explicit BufferOffset(Label *l) : offset(l->offset()) {
     }
     explicit BufferOffset(RepatchLabel *l) : offset(l->offset()) {
     }
 
     BufferOffset() : offset(INT_MIN) {}
-    bool assigned() const { return offset != INT_MIN; };
+    bool assigned() const { return offset != INT_MIN; }
 };
 
 template<int SliceSize>
 struct BufferSlice {
   protected:
     BufferSlice<SliceSize> *prev_;
     BufferSlice<SliceSize> *next_;
     // How much data has been added to the current node.
@@ -273,17 +273,17 @@ struct AssemblerBuffer
         explicit AssemblerBufferInstIterator(BufferOffset off, AssemblerBuffer_ *buff)
             : bo(off), m_buffer(buff)
         {
         }
         Inst *next() {
             Inst *i = m_buffer->getInst(bo);
             bo = BufferOffset(bo.getOffset() + i->size());
             return cur();
-        };
+        }
         Inst *cur() {
             return m_buffer->getInst(bo);
         }
     };
   public:
     LifoAlloc lifoAlloc_;
 };
 
--- a/js/src/jsapi-tests/testPersistentRooted.cpp
+++ b/js/src/jsapi-tests/testPersistentRooted.cpp
@@ -36,17 +36,17 @@ const JSClass BarkWhenTracedClass::class
   nullptr,
   nullptr,
   trace
 };
 
 struct Kennel {
     PersistentRootedObject obj;
     explicit Kennel(JSContext *cx) : obj(cx) { }
-    Kennel(JSContext *cx, const HandleObject &woof) : obj(cx, woof) { };
+    Kennel(JSContext *cx, const HandleObject &woof) : obj(cx, woof) { }
 };
 
 // A function for allocating a Kennel and a barker. Only allocating
 // PersistentRooteds on the heap, and in this function, helps ensure that the
 // conservative GC doesn't find stray references to the barker. Ugh.
 MOZ_NEVER_INLINE static Kennel *
 Allocate(JSContext *cx)
 {
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -1146,18 +1146,18 @@ JS_InitStandardClasses(JSContext *cx, Ha
     return GlobalObject::initStandardClasses(cx, global);
 }
 
 #define EAGER_ATOM(name)            NAME_OFFSET(name)
 
 typedef struct JSStdName {
     size_t      atomOffset;     /* offset of atom pointer in JSAtomState */
     JSProtoKey  key;
-    bool isDummy() const { return key == JSProto_Null; };
-    bool isSentinel() const { return key == JSProto_LIMIT; };
+    bool isDummy() const { return key == JSProto_Null; }
+    bool isSentinel() const { return key == JSProto_LIMIT; }
 } JSStdName;
 
 static const JSStdName*
 LookupStdName(JSRuntime *rt, HandleString name, const JSStdName *table)
 {
     MOZ_ASSERT(name->isAtom());
     for (unsigned i = 0; !table[i].isSentinel(); i++) {
         if (table[i].isDummy())
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -1315,18 +1315,18 @@ class JSAutoRequest
     }
 
   protected:
     JSContext *mContext;
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
 #if 0
   private:
-    static void *operator new(size_t) CPP_THROW_NEW { return 0; };
-    static void operator delete(void *, size_t) { };
+    static void *operator new(size_t) CPP_THROW_NEW { return 0; }
+    static void operator delete(void *, size_t) { }
 #endif
 };
 
 class JSAutoCheckRequest
 {
   public:
     explicit JSAutoCheckRequest(JSContext *cx
                                 MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
@@ -2513,21 +2513,21 @@ class JS_PUBLIC_API(CompartmentOptions)
     class Override {
       public:
         Override() : mode_(Default) {}
 
         bool get(bool defaultValue) const {
             if (mode_ == Default)
                 return defaultValue;
             return mode_ == ForceTrue;
-        };
+        }
 
         void set(bool overrideValue) {
             mode_ = overrideValue ? ForceTrue : ForceFalse;
-        };
+        }
 
         void reset() {
             mode_ = Default;
         }
 
       private:
         enum Mode {
             Default,
@@ -2605,17 +2605,17 @@ class JS_PUBLIC_API(CompartmentOptions)
     CompartmentOptions &setZone(ZoneSpecifier spec);
     CompartmentOptions &setSameZoneAs(JSObject *obj);
 
     void setSingletonsAsValues() {
         singletonsAsTemplates_ = false;
     }
     bool getSingletonsAsTemplates() const {
         return singletonsAsTemplates_;
-    };
+    }
 
     // A null add-on ID means that the compartment is not associated with an
     // add-on.
     JSAddonId *addonIdOrNull() const { return addonId_; }
     CompartmentOptions &setAddonId(JSAddonId *id) {
         addonId_ = id;
         return *this;
     }
--- a/js/src/jsarray.cpp
+++ b/js/src/jsarray.cpp
@@ -942,17 +942,17 @@ struct EmptySeparatorOp
 {
     bool operator()(JSContext *, StringBuffer &sb) { return true; }
 };
 
 template <typename CharT>
 struct CharSeparatorOp
 {
     const CharT sep;
-    explicit CharSeparatorOp(CharT sep) : sep(sep) {};
+    explicit CharSeparatorOp(CharT sep) : sep(sep) {}
     bool operator()(JSContext *, StringBuffer &sb) { return sb.append(sep); }
 };
 
 struct StringSeparatorOp
 {
     HandleLinearString sep;
 
     explicit StringSeparatorOp(HandleLinearString sep) : sep(sep) {}
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -1284,17 +1284,17 @@ class MOZ_STACK_CLASS AutoStableStringCh
     };
     enum State { Uninitialized, Latin1, TwoByte };
     State state_;
     bool ownsChars_;
 
   public:
     explicit AutoStableStringChars(JSContext *cx)
       : s_(cx), state_(Uninitialized), ownsChars_(false)
-    {};
+    {}
     ~AutoStableStringChars();
 
     bool init(JSContext *cx, JSString *s);
 
     /* Like init(), but Latin1 chars are inflated to TwoByte. */
     bool initTwoByte(JSContext *cx, JSString *s);
 
     bool isLatin1() const { return state_ == Latin1; }
@@ -2374,17 +2374,17 @@ SetDefaultJSContextCallback(JSRuntime *r
  * to a non-null value, the assertSameCompartment machinery does double-
  * duty (in debug builds) to verify that it matches the cx being used.
  */
 #ifdef DEBUG
 JS_FRIEND_API(void)
 Debug_SetActiveJSContext(JSRuntime *rt, JSContext *cx);
 #else
 inline void
-Debug_SetActiveJSContext(JSRuntime *rt, JSContext *cx) {};
+Debug_SetActiveJSContext(JSRuntime *rt, JSContext *cx) {}
 #endif
 
 
 enum CTypesActivityType {
     CTYPES_CALL_BEGIN,
     CTYPES_CALL_END,
     CTYPES_CALLBACK_BEGIN,
     CTYPES_CALLBACK_END
--- a/js/src/jsgc.cpp
+++ b/js/src/jsgc.cpp
@@ -6318,17 +6318,17 @@ JS::AutoAssertOnGC::AutoAssertOnGC()
          * GC's from off-thread will always assert, so off-thread is implicitly
          * AutoAssertOnGC. We still need to allow AutoAssertOnGC to be used in
          * code that works from both threads, however. We also use this to
          * annotate the off thread run loops.
          */
         JSRuntime *runtime = data->runtimeIfOnOwnerThread();
         if (runtime) {
             gc = &runtime->gc;
-            gcNumber = gc->gcNumber();;
+            gcNumber = gc->gcNumber();
             gc->enterUnsafeRegion();
         }
     }
 }
 
 JS::AutoAssertOnGC::AutoAssertOnGC(JSRuntime *rt)
   : gc(&rt->gc), gcNumber(rt->gc.gcNumber())
 {
--- a/js/src/jsproxy.cpp
+++ b/js/src/jsproxy.cpp
@@ -1861,17 +1861,17 @@ ScriptedDirectProxyHandler::has(JSContex
         ObjectOrNullValue(target),
         value
     };
     RootedValue trapResult(cx);
     if (!Invoke(cx, ObjectValue(*handler), trap, ArrayLength(argv), argv, &trapResult))
         return false;
 
     // step 9
-    bool success = ToBoolean(trapResult);;
+    bool success = ToBoolean(trapResult);
 
     // step 11
     if (!success) {
         Rooted<PropertyDescriptor> desc(cx);
         if (!GetOwnPropertyDescriptor(cx, target, id, &desc))
             return false;
 
         if (desc.object()) {
--- a/js/src/jsproxy.h
+++ b/js/src/jsproxy.h
@@ -496,17 +496,17 @@ class JS_FRIEND_API(AutoEnterPolicy)
 
   protected:
     // no-op constructor for subclass
     AutoEnterPolicy()
 #ifdef JS_DEBUG
         : context(nullptr)
         , enteredAction(BaseProxyHandler::NONE)
 #endif
-        {};
+        {}
     void reportErrorIfExceptionIsNotPending(JSContext *cx, jsid id);
     bool allow;
     bool rv;
 
 #ifdef JS_DEBUG
     JSContext *context;
     mozilla::Maybe<HandleObject> enteredProxy;
     mozilla::Maybe<HandleId> enteredId;
@@ -548,17 +548,17 @@ class JS_FRIEND_API(AutoWaivePolicy) {
 
 #ifdef JS_DEBUG
 extern JS_FRIEND_API(void)
 assertEnteredPolicy(JSContext *cx, JSObject *obj, jsid id,
                     BaseProxyHandler::Action act);
 #else
 inline void assertEnteredPolicy(JSContext *cx, JSObject *obj, jsid id,
                                 BaseProxyHandler::Action act)
-{};
+{}
 #endif
 
 } /* namespace js */
 
 extern JS_FRIEND_API(JSObject *)
 js_InitProxyClass(JSContext *cx, JS::HandleObject obj);
 
 #endif /* jsproxy_h */
--- a/js/src/vm/Interpreter-inl.h
+++ b/js/src/vm/Interpreter-inl.h
@@ -557,17 +557,17 @@ ProcessCallSiteObjOperation(JSContext *c
                 JSString *l = lhs.toString(), *r = rhs.toString();            \
                 int32_t result;                                               \
                 if (!CompareStrings(cx, l, r, &result))                       \
                     return false;                                             \
                 *res = result OP 0;                                           \
             } else {                                                          \
                 double l, r;                                                  \
                 if (!ToNumber(cx, lhs, &l) || !ToNumber(cx, rhs, &r))         \
-                    return false;;                                            \
+                    return false;                                             \
                 *res = (l OP r);                                              \
             }                                                                 \
         }                                                                     \
         return true;                                                          \
     JS_END_MACRO
 
 static MOZ_ALWAYS_INLINE bool
 LessThanOperation(JSContext *cx, MutableHandleValue lhs, MutableHandleValue rhs, bool *res) {
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -1988,17 +1988,17 @@ CASE(JSOP_SETCONST)
     rval = REGS.sp[-1];
 
     RootedObject &obj = rootObject0;
     obj = &REGS.fp()->varObj();
 
     if (!SetConstOperation(cx, obj, name, rval))
         goto error;
 }
-END_CASE(JSOP_SETCONST);
+END_CASE(JSOP_SETCONST)
 
 CASE(JSOP_BINDGNAME)
     PUSH_OBJECT(REGS.fp()->global());
 END_CASE(JSOP_BINDGNAME)
 
 CASE(JSOP_BINDINTRINSIC)
     PUSH_OBJECT(*cx->global()->intrinsicsHolder());
 END_CASE(JSOP_BINDINTRINSIC)
@@ -3101,17 +3101,17 @@ CASE(JSOP_MUTATEPROTO)
         bool succeeded;
         if (!JSObject::setProto(cx, obj, newProto, &succeeded))
             goto error;
         MOZ_ASSERT(succeeded);
     }
 
     REGS.sp--;
 }
-END_CASE(JSOP_MUTATEPROTO);
+END_CASE(JSOP_MUTATEPROTO)
 
 CASE(JSOP_INITPROP)
 {
     /* Load the property's initial value into rval. */
     JS_ASSERT(REGS.stackDepth() >= 2);
     RootedValue &rval = rootValue0;
     rval = REGS.sp[-1];
 
@@ -3125,17 +3125,17 @@ CASE(JSOP_INITPROP)
     RootedId &id = rootId0;
     id = NameToId(name);
 
     if (!DefineNativeProperty(cx, obj, id, rval, nullptr, nullptr, JSPROP_ENUMERATE))
         goto error;
 
     REGS.sp--;
 }
-END_CASE(JSOP_INITPROP);
+END_CASE(JSOP_INITPROP)
 
 CASE(JSOP_INITELEM)
 {
     JS_ASSERT(REGS.stackDepth() >= 3);
     HandleValue val = REGS.stackHandleAt(-1);
     HandleValue id = REGS.stackHandleAt(-2);
 
     RootedObject &obj = rootObject0;
--- a/js/xpconnect/src/xpcprivate.h
+++ b/js/xpconnect/src/xpcprivate.h
@@ -2877,17 +2877,17 @@ public:
     JSContext *GetSafeJSContext();
     bool HasJSContext(JSContext *cx);
 
     const InfallibleTArray<XPCJSContextInfo>* GetStack()
     { return &mStack; }
 
 private:
     friend class mozilla::dom::danger::AutoCxPusher;
-    friend bool xpc::PushJSContextNoScriptContext(JSContext *aCx);;
+    friend bool xpc::PushJSContextNoScriptContext(JSContext *aCx);
     friend void xpc::PopJSContextNoScriptContext();
 
     // We make these private so that stack manipulation can only happen
     // through one of the above friends.
     JSContext *Pop();
     bool Push(JSContext *cx);
 
     AutoInfallibleTArray<XPCJSContextInfo, 16> mStack;
@@ -3461,49 +3461,49 @@ protected:
 class MOZ_STACK_CLASS CreateObjectInOptions : public OptionsBase {
 public:
     explicit CreateObjectInOptions(JSContext *cx = xpc_GetSafeJSContext(),
                                    JSObject* options = nullptr)
         : OptionsBase(cx, options)
         , defineAs(cx, JSID_VOID)
     { }
 
-    virtual bool Parse() { return ParseId("defineAs", &defineAs); };
+    virtual bool Parse() { return ParseId("defineAs", &defineAs); }
 
     JS::RootedId defineAs;
 };
 
 class MOZ_STACK_CLASS ExportFunctionOptions : public OptionsBase {
 public:
     explicit ExportFunctionOptions(JSContext *cx = xpc_GetSafeJSContext(),
                                    JSObject* options = nullptr)
         : OptionsBase(cx, options)
         , defineAs(cx, JSID_VOID)
     { }
 
     virtual bool Parse() {
         return ParseId("defineAs", &defineAs);
-    };
+    }
 
     JS::RootedId defineAs;
 };
 
 class MOZ_STACK_CLASS StackScopedCloneOptions : public OptionsBase {
 public:
     explicit StackScopedCloneOptions(JSContext *cx = xpc_GetSafeJSContext(),
                                      JSObject* options = nullptr)
         : OptionsBase(cx, options)
         , wrapReflectors(false)
         , cloneFunctions(false)
     { }
 
     virtual bool Parse() {
         return ParseBoolean("wrapReflectors", &wrapReflectors) &&
                ParseBoolean("cloneFunctions", &cloneFunctions);
-    };
+    }
 
     // When a reflector is encountered, wrap it rather than aborting the clone.
     bool wrapReflectors;
 
     // When a function is encountered, clone it (exportFunction-style) rather than
     // aborting the clone.
     bool cloneFunctions;
 };