wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 895322 - Part 1: Replace the usages of MOZ_STATIC_ASSERT with C++11 static_assert; r=Waldo

Browse Source 
This patch was mostly generated by running the following scripts on the codebase, with some
manual changes made afterwards:

# static_assert.sh
#!/bin/bash
# Command to convert an NSPR integer type to the equivalent standard integer type

function convert() {
echo "Converting $1 to $2..."
find . ! -wholename "*nsprpub*" \
       ! -wholename "*security/nss*" \
       ! -wholename "*/.hg*" \
       ! -wholename "obj-ff-dbg*" \
       ! -name nsXPCOMCID.h \
       ! -name prtypes.h \
         -type f \
      \( -iname "*.cpp" \
         -o -iname "*.h" \
         -o -iname "*.cc" \
         -o -iname "*.mm" \) | \
    xargs -n 1 `dirname $0`/assert_replacer.py #sed -i -e "s/\b$1\b/$2/g"
}

convert MOZ_STATIC_ASSERT static_assert
hg rev --no-backup mfbt/Assertions.h \
                   media/webrtc/signaling/src/sipcc/core/includes/ccapi.h \
                   modules/libmar/src/mar_private.h \
                   modules/libmar/src/mar.h


# assert_replacer.py
#!/usr/bin/python

import sys
import re

pattern = re.compile(r"\bMOZ_STATIC_ASSERT\b")

def replaceInPlace(fname):
  print fname
  f = open(fname, "rw+")
  lines = f.readlines()
  for i in range(0, len(lines)):
    while True:
      index = re.search(pattern, lines[i])
      if index != None:
        index = index.start()
        lines[i] = lines[i][0:index] + "static_assert" + lines[i][index+len("MOZ_STATIC_ASSERT"):]
        for j in range(i + 1, len(lines)):
          if lines[j].find("                 ", index) == index:
            lines[j] = lines[j][0:index] + lines[j][index+4:]
          else:
            break
      else:
        break
  f.seek(0, 0)
  f.truncate()
  f.write("".join(lines))
  f.close()

argc = len(sys.argv)
for i in range(1, argc):
  replaceInPlace(sys.argv[i])

--HG--
extra : rebase_source : 4b4a4047d82f2c205b9fad8d56dfc3f1afc0b045
This commit is contained in:
Ehsan Akhgari 2013-07-18 13:59:53 -04:00
parent 97899ea185
commit 5ee21d6d3f
111 changed files with 573 additions and 574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
accessible/src/base/RoleAsserts.cpp
View File

@ -12,7 +12,7 @@
using namespace mozilla::a11y; using namespace mozilla::a11y;
#define ROLE(geckoRole, stringRole, atkRole, macRole, msaaRole, ia2Role, nameRule) \ #define ROLE(geckoRole, stringRole, atkRole, macRole, msaaRole, ia2Role, nameRule) \
MOZ_STATIC_ASSERT(static_cast<uint32_t>(roles::geckoRole) \ static_assert(static_cast<uint32_t>(roles::geckoRole) \
== static_cast<uint32_t>(nsIAccessibleRole::ROLE_ ## geckoRole), \ == static_cast<uint32_t>(nsIAccessibleRole::ROLE_ ## geckoRole), \
"internal and xpcom roles differ!"); "internal and xpcom roles differ!");
#include "RoleMap.h" #include "RoleMap.h"

8
accessible/src/generic/Accessible.cpp
View File

@ -3353,13 +3353,13 @@ Accessible::GetLevelInternal()
void void
Accessible::StaticAsserts() const Accessible::StaticAsserts() const
{ {
MOZ_STATIC_ASSERT(eLastChildrenFlag <= (2 << kChildrenFlagsBits) - 1, static_assert(eLastChildrenFlag <= (2 << kChildrenFlagsBits) - 1,
"Accessible::mChildrenFlags was oversized by eLastChildrenFlag!"); "Accessible::mChildrenFlags was oversized by eLastChildrenFlag!");
MOZ_STATIC_ASSERT(eLastStateFlag <= (2 << kStateFlagsBits) - 1, static_assert(eLastStateFlag <= (2 << kStateFlagsBits) - 1,
"Accessible::mStateFlags was oversized by eLastStateFlag!"); "Accessible::mStateFlags was oversized by eLastStateFlag!");
MOZ_STATIC_ASSERT(eLastAccType <= (2 << kTypeBits) - 1, static_assert(eLastAccType <= (2 << kTypeBits) - 1,
"Accessible::mType was oversized by eLastAccType!"); "Accessible::mType was oversized by eLastAccType!");
MOZ_STATIC_ASSERT(eLastAccGenericType <= (2 << kGenericTypesBits) - 1, static_assert(eLastAccGenericType <= (2 << kGenericTypesBits) - 1,
"Accessible::mGenericType was oversized by eLastAccGenericType!"); "Accessible::mGenericType was oversized by eLastAccGenericType!");
} }

2
accessible/src/windows/msaa/AccessibleWrap.cpp
View File

@ -1617,7 +1617,7 @@ AccessibleWrap::HandleAccEvent(AccEvent* aEvent)
uint32_t eventType = aEvent->GetEventType(); uint32_t eventType = aEvent->GetEventType();
MOZ_STATIC_ASSERT(sizeof(gWinEventMap)/sizeof(gWinEventMap[0]) == nsIAccessibleEvent::EVENT_LAST_ENTRY, static_assert(sizeof(gWinEventMap)/sizeof(gWinEventMap[0]) == nsIAccessibleEvent::EVENT_LAST_ENTRY,
"MSAA event map skewed"); "MSAA event map skewed");
NS_ENSURE_TRUE(eventType > 0 && eventType < ArrayLength(gWinEventMap), NS_ERROR_FAILURE); NS_ENSURE_TRUE(eventType > 0 && eventType < ArrayLength(gWinEventMap), NS_ERROR_FAILURE);

2
caps/src/nsScriptSecurityManager.cpp
View File

@ -2322,7 +2322,7 @@ nsScriptSecurityManager::nsScriptSecurityManager(void)
mIsJavaScriptEnabled(false), mIsJavaScriptEnabled(false),
mPolicyPrefsChanged(true) mPolicyPrefsChanged(true)
{ {
MOZ_STATIC_ASSERT(sizeof(intptr_t) == sizeof(void*), static_assert(sizeof(intptr_t) == sizeof(void*),
"intptr_t and void* have different lengths on this platform. " "intptr_t and void* have different lengths on this platform. "
"This may cause a security failure with the SecurityLevel union."); "This may cause a security failure with the SecurityLevel union.");
} }

2
content/base/src/nsMixedContentBlocker.cpp
View File

@ -237,7 +237,7 @@ nsMixedContentBlocker::ShouldLoad(uint32_t aContentType,
// amplifies these concerns. // amplifies these concerns.
MOZ_STATIC_ASSERT(TYPE_DATAREQUEST == TYPE_XMLHTTPREQUEST, static_assert(TYPE_DATAREQUEST == TYPE_XMLHTTPREQUEST,
"TYPE_DATAREQUEST is not a synonym for " "TYPE_DATAREQUEST is not a synonym for "
"TYPE_XMLHTTPREQUEST"); "TYPE_XMLHTTPREQUEST");

2
content/base/src/nsXMLHttpRequest.cpp
View File

@ -865,7 +865,7 @@ void
nsXMLHttpRequest::StaticAssertions() nsXMLHttpRequest::StaticAssertions()
{ {
#define ASSERT_ENUM_EQUAL(_lc, _uc) \ #define ASSERT_ENUM_EQUAL(_lc, _uc) \
MOZ_STATIC_ASSERT(\ static_assert(\
static_cast<int>(XMLHttpRequestResponseType::_lc) \ static_cast<int>(XMLHttpRequestResponseType::_lc) \
== XML_HTTP_RESPONSE_TYPE_ ## _uc, \ == XML_HTTP_RESPONSE_TYPE_ ## _uc, \
#_uc " should match") #_uc " should match")

2
content/canvas/compiledtest/TestWebGLElementArrayCache.cpp
View File

@ -128,7 +128,7 @@ template<typename T>
void CheckUintOverflow() void CheckUintOverflow()
{ {
// This test is only for integer types smaller than uint32_t // This test is only for integer types smaller than uint32_t
MOZ_STATIC_ASSERT(sizeof(T) < sizeof(uint32_t), "This test is only for integer types \ static_assert(sizeof(T) < sizeof(uint32_t), "This test is only for integer types \
smaller than uint32_t"); smaller than uint32_t");
const size_t numElems = 64; // should be significantly larger than tree leaf size to const size_t numElems = 64; // should be significantly larger than tree leaf size to

4
content/media/AudioSampleFormat.h
View File

@ -157,8 +157,8 @@ inline const void*
AddAudioSampleOffset(const void* aBase, AudioSampleFormat aFormat, AddAudioSampleOffset(const void* aBase, AudioSampleFormat aFormat,
int32_t aOffset) int32_t aOffset)
{ {
MOZ_STATIC_ASSERT(AUDIO_FORMAT_S16 == 0, "Bad constant"); static_assert(AUDIO_FORMAT_S16 == 0, "Bad constant");
MOZ_STATIC_ASSERT(AUDIO_FORMAT_FLOAT32 == 1, "Bad constant"); static_assert(AUDIO_FORMAT_FLOAT32 == 1, "Bad constant");
NS_ASSERTION(aFormat == AUDIO_FORMAT_S16 || aFormat == AUDIO_FORMAT_FLOAT32, NS_ASSERTION(aFormat == AUDIO_FORMAT_S16 || aFormat == AUDIO_FORMAT_FLOAT32,
"Unknown format"); "Unknown format");

4
content/media/webaudio/WebAudioUtils.h
View File

@ -184,9 +184,9 @@ struct WebAudioUtils {
{ {
using namespace std; using namespace std;
MOZ_STATIC_ASSERT((mozilla::IsIntegral<IntType>::value == true), static_assert(mozilla::IsIntegral<IntType>::value == true,
"IntType must be an integral type"); "IntType must be an integral type");
MOZ_STATIC_ASSERT((mozilla::IsFloatingPoint<FloatType>::value == true), static_assert(mozilla::IsFloatingPoint<FloatType>::value == true,
"FloatType must be a floating point type"); "FloatType must be a floating point type");
if (f != f) { if (f != f) {

2
content/media/webaudio/compiledtest/TestAudioEventTimeline.cpp
View File

@ -140,7 +140,7 @@ void TestSpecExample()
void TestInvalidEvents() void TestInvalidEvents()
{ {
MOZ_STATIC_ASSERT(numeric_limits<float>::has_quiet_NaN, "Platform must have a quiet NaN"); static_assert(numeric_limits<float>::has_quiet_NaN, "Platform must have a quiet NaN");
const float NaN = numeric_limits<float>::quiet_NaN(); const float NaN = numeric_limits<float>::quiet_NaN();
const float Infinity = numeric_limits<float>::infinity(); const float Infinity = numeric_limits<float>::infinity();
Timeline timeline(10.0f); Timeline timeline(10.0f);

2
content/svg/content/src/SVGFEMorphologyElement.cpp
View File

@ -156,7 +156,7 @@ DoMorphology(nsSVGFilterInstance* instance,
int32_t rx, int32_t rx,
int32_t ry) int32_t ry)
{ {
MOZ_STATIC_ASSERT(Operator == SVG_OPERATOR_ERODE || static_assert(Operator == SVG_OPERATOR_ERODE ||
Operator == SVG_OPERATOR_DILATE, Operator == SVG_OPERATOR_DILATE,
"unexpected morphology operator"); "unexpected morphology operator");

2
dom/audiochannel/AudioChannelAgent.cpp
View File

@ -61,7 +61,7 @@ AudioChannelAgent::InitInternal(int32_t aChannelType,
{ {
// We syncd the enum of channel type between nsIAudioChannelAgent.idl and // We syncd the enum of channel type between nsIAudioChannelAgent.idl and
// AudioChannelCommon.h the same. // AudioChannelCommon.h the same.
MOZ_STATIC_ASSERT(static_cast<AudioChannelType>(AUDIO_AGENT_CHANNEL_NORMAL) == static_assert(static_cast<AudioChannelType>(AUDIO_AGENT_CHANNEL_NORMAL) ==
AUDIO_CHANNEL_NORMAL && AUDIO_CHANNEL_NORMAL &&
static_cast<AudioChannelType>(AUDIO_AGENT_CHANNEL_CONTENT) == static_cast<AudioChannelType>(AUDIO_AGENT_CHANNEL_CONTENT) ==
AUDIO_CHANNEL_CONTENT && AUDIO_CHANNEL_CONTENT &&

4
dom/base/nsDOMClassInfo.cpp
View File

@ -1220,7 +1220,7 @@ nsDOMClassInfo::Init()
{ {
/* Errors that can trigger early returns are done first, /* Errors that can trigger early returns are done first,
otherwise nsDOMClassInfo is left in a half inited state. */ otherwise nsDOMClassInfo is left in a half inited state. */
MOZ_STATIC_ASSERT(sizeof(uintptr_t) == sizeof(void*), static_assert(sizeof(uintptr_t) == sizeof(void*),
"BAD! You'll need to adjust the size of uintptr_t to the " "BAD! You'll need to adjust the size of uintptr_t to the "
"size of a pointer on your platform."); "size of a pointer on your platform.");
@ -1686,7 +1686,7 @@ nsDOMClassInfo::Init()
DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULPopupElement) DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULPopupElement)
DOM_CLASSINFO_MAP_END DOM_CLASSINFO_MAP_END
MOZ_STATIC_ASSERT(MOZ_ARRAY_LENGTH(sClassInfoData) == eDOMClassInfoIDCount, static_assert(MOZ_ARRAY_LENGTH(sClassInfoData) == eDOMClassInfoIDCount,
"The number of items in sClassInfoData doesn't match the " "The number of items in sClassInfoData doesn't match the "
"number of nsIDOMClassInfo ID's, this is bad! Fix it!"); "number of nsIDOMClassInfo ID's, this is bad! Fix it!");

4
dom/bindings/BindingUtils.cpp
View File

@ -1985,13 +1985,13 @@ ConvertJSValueToByteString(JSContext* cx, JS::Handle<JS::Value> v,
// The largest unsigned 64 bit number (18,446,744,073,709,551,615) has // The largest unsigned 64 bit number (18,446,744,073,709,551,615) has
// 20 digits, plus one more for the null terminator. // 20 digits, plus one more for the null terminator.
char index[21]; char index[21];
MOZ_STATIC_ASSERT(sizeof(size_t) <= 8, "index array too small"); static_assert(sizeof(size_t) <= 8, "index array too small");
PR_snprintf(index, sizeof(index), "%d", i); PR_snprintf(index, sizeof(index), "%d", i);
// A jschar is 16 bits long. The biggest unsigned 16 bit // A jschar is 16 bits long. The biggest unsigned 16 bit
// number (65,535) has 5 digits, plus one more for the null // number (65,535) has 5 digits, plus one more for the null
// terminator. // terminator.
char badChar[6]; char badChar[6];
MOZ_STATIC_ASSERT(sizeof(jschar) <= 2, "badChar array too small"); static_assert(sizeof(jschar) <= 2, "badChar array too small");
PR_snprintf(badChar, sizeof(badChar), "%d", chars[i]); PR_snprintf(badChar, sizeof(badChar), "%d", chars[i]);
ThrowErrorMessage(cx, MSG_INVALID_BYTESTRING, index, badChar); ThrowErrorMessage(cx, MSG_INVALID_BYTESTRING, index, badChar);
return false; return false;

12
dom/bindings/BindingUtils.h
View File

@ -131,7 +131,7 @@ IsDOMIfaceAndProtoClass(const js::Class* clasp)
return IsDOMIfaceAndProtoClass(Jsvalify(clasp)); return IsDOMIfaceAndProtoClass(Jsvalify(clasp));
} }
MOZ_STATIC_ASSERT(DOM_OBJECT_SLOT == js::PROXY_PRIVATE_SLOT, static_assert(DOM_OBJECT_SLOT == js::PROXY_PRIVATE_SLOT,
"js::PROXY_PRIVATE_SLOT doesn't match DOM_OBJECT_SLOT. " "js::PROXY_PRIVATE_SLOT doesn't match DOM_OBJECT_SLOT. "
"Expect bad things"); "Expect bad things");
template <class T> template <class T>
@ -269,7 +269,7 @@ UnwrapObject(JSContext* cx, JSObject* obj, U& value)
// The items in the protoAndIfaceArray are indexed by the prototypes::id::ID and // The items in the protoAndIfaceArray are indexed by the prototypes::id::ID and
// constructors::id::ID enums, in that order. The end of the prototype objects // constructors::id::ID enums, in that order. The end of the prototype objects
// should be the start of the interface objects. // should be the start of the interface objects.
MOZ_STATIC_ASSERT((size_t)constructors::id::_ID_Start == static_assert((size_t)constructors::id::_ID_Start ==
(size_t)prototypes::id::_ID_Count, (size_t)prototypes::id::_ID_Count,
"Overlapping or discontiguous indexes."); "Overlapping or discontiguous indexes.");
const size_t kProtoAndIfaceCacheCount = constructors::id::_ID_Count; const size_t kProtoAndIfaceCacheCount = constructors::id::_ID_Count;
@ -1527,15 +1527,15 @@ private:
class DepedentStringAsserter : public nsDependentString { class DepedentStringAsserter : public nsDependentString {
public: public:
static void StaticAsserts() { static void StaticAsserts() {
MOZ_STATIC_ASSERT(sizeof(FakeDependentString) == sizeof(nsDependentString), static_assert(sizeof(FakeDependentString) == sizeof(nsDependentString),
"Must have right object size"); "Must have right object size");
MOZ_STATIC_ASSERT(offsetof(FakeDependentString, mData) == static_assert(offsetof(FakeDependentString, mData) ==
offsetof(DepedentStringAsserter, mData), offsetof(DepedentStringAsserter, mData),
"Offset of mData should match"); "Offset of mData should match");
MOZ_STATIC_ASSERT(offsetof(FakeDependentString, mLength) == static_assert(offsetof(FakeDependentString, mLength) ==
offsetof(DepedentStringAsserter, mLength), offsetof(DepedentStringAsserter, mLength),
"Offset of mLength should match"); "Offset of mLength should match");
MOZ_STATIC_ASSERT(offsetof(FakeDependentString, mFlags) == static_assert(offsetof(FakeDependentString, mFlags) ==
offsetof(DepedentStringAsserter, mFlags), offsetof(DepedentStringAsserter, mFlags),
"Offset of mFlags should match"); "Offset of mFlags should match");
} }

2
dom/bindings/DOMJSClass.h
View File

@ -50,7 +50,7 @@ class nsCycleCollectionParticipant;
// slot for the unforgeable holder is needed. // slot for the unforgeable holder is needed.
#define DOM_INTERFACE_PROTO_SLOTS_BASE (DOM_XRAY_EXPANDO_SLOT + 1) #define DOM_INTERFACE_PROTO_SLOTS_BASE (DOM_XRAY_EXPANDO_SLOT + 1)
MOZ_STATIC_ASSERT(DOM_PROTO_INSTANCE_CLASS_SLOT != DOM_XRAY_EXPANDO_SLOT, static_assert(DOM_PROTO_INSTANCE_CLASS_SLOT != DOM_XRAY_EXPANDO_SLOT,
"Interface prototype object use both of these, so they must " "Interface prototype object use both of these, so they must "
"not be the same slot."); "not be the same slot.");

4
dom/bindings/PrimitiveConversions.h
View File

@ -224,7 +224,7 @@ template<typename T>
inline bool inline bool
PrimitiveConversionTraits_EnforceRange(JSContext* cx, const double& d, T* retval) PrimitiveConversionTraits_EnforceRange(JSContext* cx, const double& d, T* retval)
{ {
MOZ_STATIC_ASSERT(std::numeric_limits<T>::is_integer, static_assert(std::numeric_limits<T>::is_integer,
"This can only be applied to integers!"); "This can only be applied to integers!");
if (!mozilla::IsFinite(d)) { if (!mozilla::IsFinite(d)) {
@ -252,7 +252,7 @@ template<typename T>
inline bool inline bool
PrimitiveConversionTraits_Clamp(JSContext* cx, const double& d, T* retval) PrimitiveConversionTraits_Clamp(JSContext* cx, const double& d, T* retval)
{ {
MOZ_STATIC_ASSERT(std::numeric_limits<T>::is_integer, static_assert(std::numeric_limits<T>::is_integer,
"This can only be applied to integers!"); "This can only be applied to integers!");
if (mozilla::IsNaN(d)) { if (mozilla::IsNaN(d)) {

2
dom/bluetooth/linux/BluetoothDBusService.cpp
View File

@ -795,7 +795,7 @@ static DBusCallback sBluetoothDBusPropCallbacks[] =
GetDevicePropertiesCallback GetDevicePropertiesCallback
}; };
MOZ_STATIC_ASSERT( static_assert(
sizeof(sBluetoothDBusPropCallbacks) == sizeof(sBluetoothDBusIfaces), sizeof(sBluetoothDBusPropCallbacks) == sizeof(sBluetoothDBusIfaces),
"DBus Property callback array and DBus interface array must be same size"); "DBus Property callback array and DBus interface array must be same size");

2
dom/indexedDB/IDBCursor.cpp
View File

@ -32,7 +32,7 @@
USING_INDEXEDDB_NAMESPACE USING_INDEXEDDB_NAMESPACE
using namespace mozilla::dom::indexedDB::ipc; using namespace mozilla::dom::indexedDB::ipc;
MOZ_STATIC_ASSERT(sizeof(size_t) >= sizeof(IDBCursor::Direction), static_assert(sizeof(size_t) >= sizeof(IDBCursor::Direction),
"Relying on conversion between size_t and " "Relying on conversion between size_t and "
"IDBCursor::Direction"); "IDBCursor::Direction");

6
dom/indexedDB/IDBObjectStore.cpp
View File

@ -1331,7 +1331,7 @@ bool
IDBObjectStore::ReadFileHandle(JSStructuredCloneReader* aReader, IDBObjectStore::ReadFileHandle(JSStructuredCloneReader* aReader,
FileHandleData* aRetval) FileHandleData* aRetval)
{ {
MOZ_STATIC_ASSERT(SCTAG_DOM_FILEHANDLE == 0xFFFF8004, static_assert(SCTAG_DOM_FILEHANDLE == 0xFFFF8004,
"Update me!"); "Update me!");
MOZ_ASSERT(aReader && aRetval); MOZ_ASSERT(aReader && aRetval);
@ -1356,7 +1356,7 @@ IDBObjectStore::ReadBlobOrFile(JSStructuredCloneReader* aReader,
uint32_t aTag, uint32_t aTag,
BlobOrFileData* aRetval) BlobOrFileData* aRetval)
{ {
MOZ_STATIC_ASSERT(SCTAG_DOM_BLOB == 0xFFFF8001 && static_assert(SCTAG_DOM_BLOB == 0xFFFF8001 &&
SCTAG_DOM_FILE_WITHOUT_LASTMODIFIEDDATE == 0xFFFF8002 && SCTAG_DOM_FILE_WITHOUT_LASTMODIFIEDDATE == 0xFFFF8002 &&
SCTAG_DOM_FILE == 0xFFFF8005, SCTAG_DOM_FILE == 0xFFFF8005,
"Update me!"); "Update me!");
@ -1417,7 +1417,7 @@ IDBObjectStore::StructuredCloneReadCallback(JSContext* aCx,
{ {
// We need to statically assert that our tag values are what we expect // We need to statically assert that our tag values are what we expect
// so that if people accidentally change them they notice. // so that if people accidentally change them they notice.
MOZ_STATIC_ASSERT(SCTAG_DOM_BLOB == 0xFFFF8001 && static_assert(SCTAG_DOM_BLOB == 0xFFFF8001 &&
SCTAG_DOM_FILE_WITHOUT_LASTMODIFIEDDATE == 0xFFFF8002 && SCTAG_DOM_FILE_WITHOUT_LASTMODIFIEDDATE == 0xFFFF8002 &&
SCTAG_DOM_FILEHANDLE == 0xFFFF8004 && SCTAG_DOM_FILEHANDLE == 0xFFFF8004 &&
SCTAG_DOM_FILE == 0xFFFF8005, SCTAG_DOM_FILE == 0xFFFF8005,

2
dom/indexedDB/Key.cpp
View File

@ -106,7 +106,7 @@ Key::EncodeJSValInternal(JSContext* aCx, const jsval aVal,
{ {
NS_ENSURE_TRUE(aRecursionDepth < MaxRecursionDepth, NS_ERROR_DOM_INDEXEDDB_DATA_ERR); NS_ENSURE_TRUE(aRecursionDepth < MaxRecursionDepth, NS_ERROR_DOM_INDEXEDDB_DATA_ERR);
MOZ_STATIC_ASSERT(eMaxType * MaxArrayCollapse < 256, static_assert(eMaxType * MaxArrayCollapse < 256,
"Unable to encode jsvals."); "Unable to encode jsvals.");
if (JSVAL_IS_STRING(aVal)) { if (JSVAL_IS_STRING(aVal)) {

8
dom/indexedDB/OpenDatabaseHelper.cpp
View File

@ -34,7 +34,7 @@ namespace {
// If JS_STRUCTURED_CLONE_VERSION changes then we need to update our major // If JS_STRUCTURED_CLONE_VERSION changes then we need to update our major
// schema version. // schema version.
MOZ_STATIC_ASSERT(JS_STRUCTURED_CLONE_VERSION == 2, static_assert(JS_STRUCTURED_CLONE_VERSION == 2,
"Need to update the major schema version."); "Need to update the major schema version.");
// Major schema version. Bump for almost everything. // Major schema version. Bump for almost everything.
@ -47,9 +47,9 @@ const uint32_t kMinorSchemaVersion = 0;
// The schema version we store in the SQLite database is a (signed) 32-bit // The schema version we store in the SQLite database is a (signed) 32-bit
// integer. The major version is left-shifted 4 bits so the max value is // integer. The major version is left-shifted 4 bits so the max value is
// 0xFFFFFFF. The minor version occupies the lower 4 bits and its max is 0xF. // 0xFFFFFFF. The minor version occupies the lower 4 bits and its max is 0xF.
MOZ_STATIC_ASSERT(kMajorSchemaVersion <= 0xFFFFFFF, static_assert(kMajorSchemaVersion <= 0xFFFFFFF,
"Major version needs to fit in 28 bits."); "Major version needs to fit in 28 bits.");
MOZ_STATIC_ASSERT(kMinorSchemaVersion <= 0xF, static_assert(kMinorSchemaVersion <= 0xF,
"Minor version needs to fit in 4 bits."); "Minor version needs to fit in 4 bits.");
inline inline
@ -1981,7 +1981,7 @@ OpenDatabaseHelper::CreateDatabaseConnection(
} }
else { else {
// This logic needs to change next time we change the schema! // This logic needs to change next time we change the schema!
MOZ_STATIC_ASSERT(kSQLiteSchemaVersion == int32_t((14 << 4) + 0), static_assert(kSQLiteSchemaVersion == int32_t((14 << 4) + 0),
"Need upgrade code from schema version increase."); "Need upgrade code from schema version increase.");
while (schemaVersion != kSQLiteSchemaVersion) { while (schemaVersion != kSQLiteSchemaVersion) {

2
dom/ipc/Blob.cpp
View File

@ -364,7 +364,7 @@ inline
already_AddRefed<nsIDOMBlob> already_AddRefed<nsIDOMBlob>
GetBlobFromParams(const SlicedBlobConstructorParams& aParams) GetBlobFromParams(const SlicedBlobConstructorParams& aParams)
{ {
MOZ_STATIC_ASSERT(ActorFlavor == mozilla::dom::ipc::Parent, static_assert(ActorFlavor == mozilla::dom::ipc::Parent,
"No other flavor is supported here!"); "No other flavor is supported here!");
BlobParent* actor = BlobParent* actor =

6
dom/plugins/base/nsPluginTags.cpp
View File

@ -383,9 +383,9 @@ nsPluginTag::GetPluginState()
void void
nsPluginTag::SetPluginState(PluginState state) nsPluginTag::SetPluginState(PluginState state)
{ {
MOZ_STATIC_ASSERT((uint32_t)nsPluginTag::ePluginState_Disabled == nsIPluginTag::STATE_DISABLED, "nsPluginTag::ePluginState_Disabled must match nsIPluginTag::STATE_DISABLED"); static_assert((uint32_t)nsPluginTag::ePluginState_Disabled == nsIPluginTag::STATE_DISABLED, "nsPluginTag::ePluginState_Disabled must match nsIPluginTag::STATE_DISABLED");
MOZ_STATIC_ASSERT((uint32_t)nsPluginTag::ePluginState_Clicktoplay == nsIPluginTag::STATE_CLICKTOPLAY, "nsPluginTag::ePluginState_Clicktoplay must match nsIPluginTag::STATE_CLICKTOPLAY"); static_assert((uint32_t)nsPluginTag::ePluginState_Clicktoplay == nsIPluginTag::STATE_CLICKTOPLAY, "nsPluginTag::ePluginState_Clicktoplay must match nsIPluginTag::STATE_CLICKTOPLAY");
MOZ_STATIC_ASSERT((uint32_t)nsPluginTag::ePluginState_Enabled == nsIPluginTag::STATE_ENABLED, "nsPluginTag::ePluginState_Enabled must match nsIPluginTag::STATE_ENABLED"); static_assert((uint32_t)nsPluginTag::ePluginState_Enabled == nsIPluginTag::STATE_ENABLED, "nsPluginTag::ePluginState_Enabled must match nsIPluginTag::STATE_ENABLED");
SetEnabledState((uint32_t)state); SetEnabledState((uint32_t)state);
} }

2
dom/quota/QuotaManager.cpp
View File

@ -483,7 +483,7 @@ QuotaManager::Init()
mCheckQuotaHelpers.Init(); mCheckQuotaHelpers.Init();
mLiveStorages.Init(); mLiveStorages.Init();
MOZ_STATIC_ASSERT(Client::IDB == 0 && Client::TYPE_MAX == 1, static_assert(Client::IDB == 0 && Client::TYPE_MAX == 1,
"Fix the registration!"); "Fix the registration!");
NS_ASSERTION(mClients.Capacity() == Client::TYPE_MAX, NS_ASSERTION(mClients.Capacity() == Client::TYPE_MAX,

2
dom/src/storage/DOMStorageDBThread.cpp
View File

@ -677,7 +677,7 @@ DOMStorageDBThread::TimeUntilFlush()
return 0; // Do it now regardless the timeout. return 0; // Do it now regardless the timeout.
} }
MOZ_STATIC_ASSERT(PR_INTERVAL_NO_TIMEOUT != 0, static_assert(PR_INTERVAL_NO_TIMEOUT != 0,
"PR_INTERVAL_NO_TIMEOUT must be non-zero"); "PR_INTERVAL_NO_TIMEOUT must be non-zero");
if (!mDirtyEpoch) { if (!mDirtyEpoch) {

4
dom/workers/RuntimeService.cpp
View File

@ -67,7 +67,7 @@ using mozilla::Preferences;
// The maximum number of threads to use for workers, overridable via pref. // The maximum number of threads to use for workers, overridable via pref.
#define MAX_WORKERS_PER_DOMAIN 10 #define MAX_WORKERS_PER_DOMAIN 10
MOZ_STATIC_ASSERT(MAX_WORKERS_PER_DOMAIN >= 1, static_assert(MAX_WORKERS_PER_DOMAIN >= 1,
"We should allow at least one worker per domain."); "We should allow at least one worker per domain.");
// The default number of seconds that close handlers will be allowed to run for // The default number of seconds that close handlers will be allowed to run for
@ -156,7 +156,7 @@ const char* gStringChars[] = {
// thread. // thread.
}; };
MOZ_STATIC_ASSERT(NS_ARRAY_LENGTH(gStringChars) == ID_COUNT, static_assert(NS_ARRAY_LENGTH(gStringChars) == ID_COUNT,
"gStringChars should have the right length."); "gStringChars should have the right length.");
class LiteralRebindingCString : public nsDependentCString class LiteralRebindingCString : public nsDependentCString

2
gfx/2d/convolver.h
View File

@ -74,7 +74,7 @@ class ConvolutionFilter1D {
// The cast relies on Fixed being a short, implying that on // The cast relies on Fixed being a short, implying that on
// the platforms we care about all (16) bits will fit into // the platforms we care about all (16) bits will fit into
// the mantissa of a (32-bit) float. // the mantissa of a (32-bit) float.
MOZ_STATIC_ASSERT(sizeof(Fixed) == 2, static_assert(sizeof(Fixed) == 2,
"fixed type should fit in float mantissa"); "fixed type should fit in float mantissa");
float raw = static_cast<float>(x); float raw = static_cast<float>(x);
return ldexpf(raw, -kShiftBits); return ldexpf(raw, -kShiftBits);

2
gfx/layers/ipc/ShadowLayerUtils.h
View File

@ -58,7 +58,7 @@ struct ParamTraits<mozilla::gl::GLContext::SharedTextureShareType>
static void Write(Message* msg, const paramType& param) static void Write(Message* msg, const paramType& param)
{ {
MOZ_STATIC_ASSERT(sizeof(paramType) <= sizeof(int32_t), static_assert(sizeof(paramType) <= sizeof(int32_t),
"TextureShareType assumes to be int32_t"); "TextureShareType assumes to be int32_t");
WriteParam(msg, int32_t(param)); WriteParam(msg, int32_t(param));
} }

8
ipc/chromium/src/base/pickle.cc
View File

@ -16,7 +16,7 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
MOZ_STATIC_ASSERT(MOZ_ALIGNOF(Pickle::memberAlignmentType) >= MOZ_ALIGNOF(uint32_t), static_assert(MOZ_ALIGNOF(Pickle::memberAlignmentType) >= MOZ_ALIGNOF(uint32_t),
"Insufficient alignment"); "Insufficient alignment");
// static // static
@ -61,7 +61,7 @@ struct Copier<T, sizeof(uint64_t), false>
#else #else
static const int loIndex = 1, hiIndex = 0; static const int loIndex = 1, hiIndex = 0;
#endif #endif
MOZ_STATIC_ASSERT(MOZ_ALIGNOF(uint32_t*) == MOZ_ALIGNOF(void*), static_assert(MOZ_ALIGNOF(uint32_t*) == MOZ_ALIGNOF(void*),
"Pointers have different alignments"); "Pointers have different alignments");
uint32_t* src = *reinterpret_cast<uint32_t**>(iter); uint32_t* src = *reinterpret_cast<uint32_t**>(iter);
uint32_t* uint32dest = reinterpret_cast<uint32_t*>(dest); uint32_t* uint32dest = reinterpret_cast<uint32_t*>(dest);
@ -81,7 +81,7 @@ struct Copier<T, size, true>
// big as MOZ_ALIGNOF(T). // big as MOZ_ALIGNOF(T).
// Check the first condition, as the second condition is already // Check the first condition, as the second condition is already
// known to be true, or we wouldn't be here. // known to be true, or we wouldn't be here.
MOZ_STATIC_ASSERT(MOZ_ALIGNOF(T*) == MOZ_ALIGNOF(void*), static_assert(MOZ_ALIGNOF(T*) == MOZ_ALIGNOF(void*),
"Pointers have different alignments"); "Pointers have different alignments");
*dest = *(*reinterpret_cast<T**>(iter)); *dest = *(*reinterpret_cast<T**>(iter));
} }
@ -89,7 +89,7 @@ struct Copier<T, size, true>
template<typename T> template<typename T>
void CopyFromIter(T* dest, void** iter) { void CopyFromIter(T* dest, void** iter) {
MOZ_STATIC_ASSERT(mozilla::IsPod<T>::value, "Copied type must be a POD type"); static_assert(mozilla::IsPod<T>::value, "Copied type must be a POD type");
Copier<T, sizeof(T), (MOZ_ALIGNOF(T) <= sizeof(Pickle::memberAlignmentType))>::Copy(dest, iter); Copier<T, sizeof(T), (MOZ_ALIGNOF(T) <= sizeof(Pickle::memberAlignmentType))>::Copy(dest, iter);
} }

2
ipc/chromium/src/base/pickle.h
View File

@ -251,7 +251,7 @@ class Pickle {
// a power of 2. // a power of 2.
template<uint32_t alignment> struct ConstantAligner { template<uint32_t alignment> struct ConstantAligner {
static uint32_t align(int bytes) { static uint32_t align(int bytes) {
MOZ_STATIC_ASSERT((alignment & (alignment - 1)) == 0, static_assert((alignment & (alignment - 1)) == 0,
"alignment must be a power of two"); "alignment must be a power of two");
return (bytes + (alignment - 1)) & ~static_cast<uint32_t>(alignment - 1); return (bytes + (alignment - 1)) & ~static_cast<uint32_t>(alignment - 1);
} }

12
js/public/RootingAPI.h
View File

@ -188,7 +188,7 @@ class Heap : public js::HeapBase<T>
{ {
public: public:
Heap() { Heap() {
MOZ_STATIC_ASSERT(sizeof(T) == sizeof(Heap<T>), static_assert(sizeof(T) == sizeof(Heap<T>),
"Heap<T> must be binary compatible with T."); "Heap<T> must be binary compatible with T.");
init(js::GCMethods<T>::initial()); init(js::GCMethods<T>::initial());
} }
@ -301,7 +301,7 @@ class TenuredHeap : public js::HeapBase<T>
{ {
public: public:
TenuredHeap() : bits(0) { TenuredHeap() : bits(0) {
MOZ_STATIC_ASSERT(sizeof(T) == sizeof(TenuredHeap<T>), static_assert(sizeof(T) == sizeof(TenuredHeap<T>),
"TenuredHeap<T> must be binary compatible with T."); "TenuredHeap<T> must be binary compatible with T.");
} }
explicit TenuredHeap(T p) : bits(0) { setPtr(p); } explicit TenuredHeap(T p) : bits(0) { setPtr(p); }
@ -385,21 +385,21 @@ class MOZ_NONHEAP_CLASS Handle : public js::HandleBase<T>
Handle(Handle<S> handle, Handle(Handle<S> handle,
typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0) typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0)
{ {
MOZ_STATIC_ASSERT(sizeof(Handle<T>) == sizeof(T *), static_assert(sizeof(Handle<T>) == sizeof(T *),
"Handle must be binary compatible with T*."); "Handle must be binary compatible with T*.");
ptr = reinterpret_cast<const T *>(handle.address()); ptr = reinterpret_cast<const T *>(handle.address());
} }
/* Create a handle for a NULL pointer. */ /* Create a handle for a NULL pointer. */
Handle(js::NullPtr) { Handle(js::NullPtr) {
MOZ_STATIC_ASSERT(mozilla::IsPointer<T>::value, static_assert(mozilla::IsPointer<T>::value,
"js::NullPtr overload not valid for non-pointer types"); "js::NullPtr overload not valid for non-pointer types");
ptr = reinterpret_cast<const T *>(&js::NullPtr::constNullValue); ptr = reinterpret_cast<const T *>(&js::NullPtr::constNullValue);
} }
/* Create a handle for a NULL pointer. */ /* Create a handle for a NULL pointer. */
Handle(JS::NullPtr) { Handle(JS::NullPtr) {
MOZ_STATIC_ASSERT(mozilla::IsPointer<T>::value, static_assert(mozilla::IsPointer<T>::value,
"JS::NullPtr overload not valid for non-pointer types"); "JS::NullPtr overload not valid for non-pointer types");
ptr = reinterpret_cast<const T *>(&JS::NullPtr::constNullValue); ptr = reinterpret_cast<const T *>(&JS::NullPtr::constNullValue);
} }
@ -1034,7 +1034,7 @@ template <typename T>
inline inline
MutableHandle<T>::MutableHandle(Rooted<T> *root) MutableHandle<T>::MutableHandle(Rooted<T> *root)
{ {
MOZ_STATIC_ASSERT(sizeof(MutableHandle<T>) == sizeof(T *), static_assert(sizeof(MutableHandle<T>) == sizeof(T *),
"MutableHandle must be binary compatible with T*."); "MutableHandle must be binary compatible with T*.");
ptr = root->address(); ptr = root->address();
} }

2
js/public/Utility.h
View File

@ -62,7 +62,7 @@ namespace js {}
# define JS_DIAGNOSTICS_ASSERT(expr) ((void) 0) # define JS_DIAGNOSTICS_ASSERT(expr) ((void) 0)
#endif #endif
#define JS_STATIC_ASSERT(cond) MOZ_STATIC_ASSERT(cond, "JS_STATIC_ASSERT") #define JS_STATIC_ASSERT(cond) static_assert(cond, "JS_STATIC_ASSERT")
#define JS_STATIC_ASSERT_IF(cond, expr) MOZ_STATIC_ASSERT_IF(cond, expr, "JS_STATIC_ASSERT_IF") #define JS_STATIC_ASSERT_IF(cond, expr) MOZ_STATIC_ASSERT_IF(cond, expr, "JS_STATIC_ASSERT_IF")
extern MOZ_NORETURN JS_PUBLIC_API(void) extern MOZ_NORETURN JS_PUBLIC_API(void)

6
js/public/Value.h
View File

@ -1645,11 +1645,11 @@ inline Anchor<Value>::~Anchor()
namespace detail { namespace detail {
struct ValueAlignmentTester { char c; JS::Value v; }; struct ValueAlignmentTester { char c; JS::Value v; };
MOZ_STATIC_ASSERT(sizeof(ValueAlignmentTester) == 16, static_assert(sizeof(ValueAlignmentTester) == 16,
"JS::Value must be 16-byte-aligned"); "JS::Value must be 16-byte-aligned");
struct LayoutAlignmentTester { char c; jsval_layout l; }; struct LayoutAlignmentTester { char c; jsval_layout l; };
MOZ_STATIC_ASSERT(sizeof(LayoutAlignmentTester) == 16, static_assert(sizeof(LayoutAlignmentTester) == 16,
"jsval_layout must be 16-byte-aligned"); "jsval_layout must be 16-byte-aligned");
} // namespace detail } // namespace detail
@ -1664,7 +1664,7 @@ MOZ_STATIC_ASSERT(sizeof(LayoutAlignmentTester) == 16,
*/ */
typedef JS::Value jsval; typedef JS::Value jsval;
MOZ_STATIC_ASSERT(sizeof(jsval_layout) == sizeof(JS::Value), static_assert(sizeof(jsval_layout) == sizeof(JS::Value),
"jsval_layout and JS::Value must have identical layouts"); "jsval_layout and JS::Value must have identical layouts");
/************************************************************************/ /************************************************************************/

2
js/src/assembler/wtf/Assertions.h
View File

@ -46,6 +46,6 @@
} while (0) } while (0)
#define ASSERT_NOT_REACHED() MOZ_ASSUME_UNREACHABLE() #define ASSERT_NOT_REACHED() MOZ_ASSUME_UNREACHABLE()
#define CRASH() MOZ_CRASH() #define CRASH() MOZ_CRASH()
#define COMPILE_ASSERT(exp, name) MOZ_STATIC_ASSERT(exp, #name) #define COMPILE_ASSERT(exp, name) static_assert(exp, #name)
#endif /* assembler_wtf_Assertions_h */ #endif /* assembler_wtf_Assertions_h */

2
js/src/ds/LifoAlloc.h
View File

@ -32,7 +32,7 @@ JS_ALWAYS_INLINE
char * char *
AlignPtr(void *orig) AlignPtr(void *orig)
{ {
MOZ_STATIC_ASSERT(mozilla::tl::FloorLog2<LIFO_ALLOC_ALIGN>::value == static_assert(mozilla::tl::FloorLog2<LIFO_ALLOC_ALIGN>::value ==
mozilla::tl::CeilingLog2<LIFO_ALLOC_ALIGN>::value, mozilla::tl::CeilingLog2<LIFO_ALLOC_ALIGN>::value,
"LIFO_ALLOC_ALIGN must be a power of two"); "LIFO_ALLOC_ALIGN must be a power of two");

2
js/src/frontend/BytecodeEmitter.cpp
View File

@ -5458,7 +5458,7 @@ EmitObject(ExclusiveContext *cx, BytecodeEmitter *bce, ParseNode *pn)
if (!objbox) if (!objbox)
return false; return false;
unsigned index = bce->objectList.add(objbox); unsigned index = bce->objectList.add(objbox);
MOZ_STATIC_ASSERT(JSOP_NEWINIT_LENGTH == JSOP_NEWOBJECT_LENGTH, static_assert(JSOP_NEWINIT_LENGTH == JSOP_NEWOBJECT_LENGTH,
"newinit and newobject must have equal length to edit in-place"); "newinit and newobject must have equal length to edit in-place");
EMIT_UINT32_IN_PLACE(offset, JSOP_NEWOBJECT, uint32_t(index)); EMIT_UINT32_IN_PLACE(offset, JSOP_NEWOBJECT, uint32_t(index));
} }

2
js/src/jsfun.h
View File

@ -52,7 +52,7 @@ class JSFunction : public JSObject
static void staticAsserts() { static void staticAsserts() {
JS_STATIC_ASSERT(INTERPRETED == JS_FUNCTION_INTERPRETED_BIT); JS_STATIC_ASSERT(INTERPRETED == JS_FUNCTION_INTERPRETED_BIT);
MOZ_STATIC_ASSERT(sizeof(JSFunction) == sizeof(js::shadow::Function), static_assert(sizeof(JSFunction) == sizeof(js::shadow::Function),
"shadow interface must match actual interface"); "shadow interface must match actual interface");
} }

6
js/src/jsobj.h
View File

@ -1018,11 +1018,11 @@ class JSObject : public js::ObjectImpl
private: private:
static void staticAsserts() { static void staticAsserts() {
MOZ_STATIC_ASSERT(sizeof(JSObject) == sizeof(js::shadow::Object), static_assert(sizeof(JSObject) == sizeof(js::shadow::Object),
"shadow interface must match actual interface"); "shadow interface must match actual interface");
MOZ_STATIC_ASSERT(sizeof(JSObject) == sizeof(js::ObjectImpl), static_assert(sizeof(JSObject) == sizeof(js::ObjectImpl),
"JSObject itself must not have any fields"); "JSObject itself must not have any fields");
MOZ_STATIC_ASSERT(sizeof(JSObject) % sizeof(js::Value) == 0, static_assert(sizeof(JSObject) % sizeof(js::Value) == 0,
"fixed slots after an object must be aligned"); "fixed slots after an object must be aligned");
} }

6
js/src/vm/NumericConversions.h
View File

@ -38,7 +38,7 @@ template<typename ResultType>
inline ResultType inline ResultType
ToUintWidth(double d) ToUintWidth(double d)
{ {
MOZ_STATIC_ASSERT(mozilla::IsUnsigned<ResultType>::value, static_assert(mozilla::IsUnsigned<ResultType>::value,
"ResultType must be an unsigned type"); "ResultType must be an unsigned type");
uint64_t bits = mozilla::BitwiseCast<uint64_t>(d); uint64_t bits = mozilla::BitwiseCast<uint64_t>(d);
@ -69,7 +69,7 @@ ToUintWidth(double d)
// The significand contains the bits that will determine the final result. // The significand contains the bits that will determine the final result.
// Shift those bits left or right, according to the exponent, to their // Shift those bits left or right, according to the exponent, to their
// locations in the unsigned binary representation of floor(abs(d)). // locations in the unsigned binary representation of floor(abs(d)).
MOZ_STATIC_ASSERT(sizeof(ResultType) <= sizeof(uint64_t), static_assert(sizeof(ResultType) <= sizeof(uint64_t),
"Left-shifting below would lose upper bits"); "Left-shifting below would lose upper bits");
ResultType result = (exponent > mozilla::DoubleExponentShift) ResultType result = (exponent > mozilla::DoubleExponentShift)
? ResultType(bits << (exponent - mozilla::DoubleExponentShift)) ? ResultType(bits << (exponent - mozilla::DoubleExponentShift))
@ -113,7 +113,7 @@ template<typename ResultType>
inline ResultType inline ResultType
ToIntWidth(double d) ToIntWidth(double d)
{ {
MOZ_STATIC_ASSERT(mozilla::IsSigned<ResultType>::value, static_assert(mozilla::IsSigned<ResultType>::value,
"ResultType must be a signed type"); "ResultType must be a signed type");
const ResultType MaxValue = (1ULL << (CHAR_BIT * sizeof(ResultType) - 1)) - 1; const ResultType MaxValue = (1ULL << (CHAR_BIT * sizeof(ResultType) - 1)) - 1;

20
js/src/vm/ObjectImpl.h
View File

@ -457,7 +457,7 @@ class ElementsHeader
}; };
void staticAsserts() { void staticAsserts() {
MOZ_STATIC_ASSERT(sizeof(ElementsHeader) == ValuesPerHeader * sizeof(Value), static_assert(sizeof(ElementsHeader) == ValuesPerHeader * sizeof(Value),
"Elements size and values-per-Elements mismatch"); "Elements size and values-per-Elements mismatch");
} }
@ -638,7 +638,7 @@ struct uint8_clamped {
} }
void staticAsserts() { void staticAsserts() {
MOZ_STATIC_ASSERT(sizeof(uint8_clamped) == 1, static_assert(sizeof(uint8_clamped) == 1,
"uint8_clamped must be layout-compatible with uint8_t"); "uint8_clamped must be layout-compatible with uint8_t");
} }
}; };
@ -1072,7 +1072,7 @@ class ObjectElements
uint32_t length; uint32_t length;
void staticAsserts() { void staticAsserts() {
MOZ_STATIC_ASSERT(sizeof(ObjectElements) == VALUES_PER_HEADER * sizeof(Value), static_assert(sizeof(ObjectElements) == VALUES_PER_HEADER * sizeof(Value),
"Elements size and values-per-Elements mismatch"); "Elements size and values-per-Elements mismatch");
} }
@ -1211,18 +1211,18 @@ class ObjectImpl : public gc::Cell
private: private:
static void staticAsserts() { static void staticAsserts() {
MOZ_STATIC_ASSERT(sizeof(ObjectImpl) == sizeof(shadow::Object), static_assert(sizeof(ObjectImpl) == sizeof(shadow::Object),
"shadow interface must match actual implementation"); "shadow interface must match actual implementation");
MOZ_STATIC_ASSERT(sizeof(ObjectImpl) % sizeof(Value) == 0, static_assert(sizeof(ObjectImpl) % sizeof(Value) == 0,
"fixed slots after an object must be aligned"); "fixed slots after an object must be aligned");
MOZ_STATIC_ASSERT(offsetof(ObjectImpl, shape_) == offsetof(shadow::Object, shape), static_assert(offsetof(ObjectImpl, shape_) == offsetof(shadow::Object, shape),
"shadow shape must match actual shape"); "shadow shape must match actual shape");
MOZ_STATIC_ASSERT(offsetof(ObjectImpl, type_) == offsetof(shadow::Object, type), static_assert(offsetof(ObjectImpl, type_) == offsetof(shadow::Object, type),
"shadow type must match actual type"); "shadow type must match actual type");
MOZ_STATIC_ASSERT(offsetof(ObjectImpl, slots) == offsetof(shadow::Object, slots), static_assert(offsetof(ObjectImpl, slots) == offsetof(shadow::Object, slots),
"shadow slots must match actual slots"); "shadow slots must match actual slots");
MOZ_STATIC_ASSERT(offsetof(ObjectImpl, elements) == offsetof(shadow::Object, _1), static_assert(offsetof(ObjectImpl, elements) == offsetof(shadow::Object, _1),
"shadow placeholder must match actual elements"); "shadow placeholder must match actual elements");
} }
@ -1623,7 +1623,7 @@ class ObjectImpl : public gc::Cell
} }
inline HeapSlot *fixedElements() const { inline HeapSlot *fixedElements() const {
MOZ_STATIC_ASSERT(2 * sizeof(Value) == sizeof(ObjectElements), static_assert(2 * sizeof(Value) == sizeof(ObjectElements),
"when elements are stored inline, the first two " "when elements are stored inline, the first two "
"slots will hold the ObjectElements header"); "slots will hold the ObjectElements header");
return &fixedSlots()[2]; return &fixedSlots()[2];

2
layout/base/FramePropertyTable.cpp
View File

@ -41,7 +41,7 @@ FramePropertyTable::Set(nsIFrame* aFrame, const FramePropertyDescriptor* aProper
// We need to expand the single current entry to an array // We need to expand the single current entry to an array
PropertyValue current = entry->mProp; PropertyValue current = entry->mProp;
entry->mProp.mProperty = nullptr; entry->mProp.mProperty = nullptr;
MOZ_STATIC_ASSERT(sizeof(nsTArray<PropertyValue>) <= sizeof(void *), static_assert(sizeof(nsTArray<PropertyValue>) <= sizeof(void *),
"Property array must fit entirely within entry->mProp.mValue"); "Property array must fit entirely within entry->mProp.mValue");
new (&entry->mProp.mValue) nsTArray<PropertyValue>(4); new (&entry->mProp.mValue) nsTArray<PropertyValue>(4);
entry->mProp.ToArray()->AppendElement(current); entry->mProp.ToArray()->AppendElement(current);

4
layout/base/RestyleManager.cpp
View File

@ -519,9 +519,9 @@ FrameHasPositionedPlaceholderDescendants(nsIFrame* aFrame, uint32_t aPositionMas
static bool static bool
NeedToReframeForAddingOrRemovingTransform(nsIFrame* aFrame) NeedToReframeForAddingOrRemovingTransform(nsIFrame* aFrame)
{ {
MOZ_STATIC_ASSERT(0 <= NS_STYLE_POSITION_ABSOLUTE && static_assert(0 <= NS_STYLE_POSITION_ABSOLUTE &&
NS_STYLE_POSITION_ABSOLUTE < 32, "Style constant out of range"); NS_STYLE_POSITION_ABSOLUTE < 32, "Style constant out of range");
MOZ_STATIC_ASSERT(0 <= NS_STYLE_POSITION_FIXED && static_assert(0 <= NS_STYLE_POSITION_FIXED &&
NS_STYLE_POSITION_FIXED < 32, "Style constant out of range"); NS_STYLE_POSITION_FIXED < 32, "Style constant out of range");
uint32_t positionMask; uint32_t positionMask;

2
layout/base/nsAutoLayoutPhase.cpp
View File

@ -4,7 +4,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef DEBUG #ifndef DEBUG
MOZ_STATIC_ASSERT(false, "This should not be compiled in !DEBUG"); static_assert(false, "This should not be compiled in !DEBUG");
#endif // DEBUG #endif // DEBUG
#include "nsAutoLayoutPhase.h" #include "nsAutoLayoutPhase.h"

2
layout/base/nsCSSFrameConstructor.cpp
View File

@ -9031,7 +9031,7 @@ nsCSSFrameConstructor::ProcessChildren(nsFrameConstructorState& aState,
"Parent frame in ProcessChildren should be its own " "Parent frame in ProcessChildren should be its own "
"content insertion frame"); "content insertion frame");
const uint32_t kMaxDepth = 2 * MAX_REFLOW_DEPTH; const uint32_t kMaxDepth = 2 * MAX_REFLOW_DEPTH;
MOZ_STATIC_ASSERT(kMaxDepth <= UINT16_MAX, "mCurrentDepth type is too narrow"); static_assert(kMaxDepth <= UINT16_MAX, "mCurrentDepth type is too narrow");
AutoRestore<uint16_t> savedDepth(mCurrentDepth); AutoRestore<uint16_t> savedDepth(mCurrentDepth);
if (mCurrentDepth != UINT16_MAX) { if (mCurrentDepth != UINT16_MAX) {
++mCurrentDepth; ++mCurrentDepth;

2
layout/base/nsPresContext.cpp
View File

@ -538,7 +538,7 @@ nsPresContext::GetFontPrefsForLang(nsIAtom *aLanguage) const
&prefs->mDefaultCursiveFont, &prefs->mDefaultCursiveFont,
&prefs->mDefaultFantasyFont &prefs->mDefaultFantasyFont
}; };
MOZ_STATIC_ASSERT(NS_ARRAY_LENGTH(fontTypes) == eDefaultFont_COUNT, static_assert(NS_ARRAY_LENGTH(fontTypes) == eDefaultFont_COUNT,
"FontTypes array count is not correct"); "FontTypes array count is not correct");
// Get attributes specific to each generic font. We do not get the user's // Get attributes specific to each generic font. We do not get the user's

2
layout/build/nsLayoutModule.cpp
View File

@ -396,7 +396,7 @@ Initialize()
return NS_ERROR_FAILURE; return NS_ERROR_FAILURE;
} }
MOZ_STATIC_ASSERT(sizeof(uintptr_t) == sizeof(void*), static_assert(sizeof(uintptr_t) == sizeof(void*),
"Eeek! You'll need to adjust the size of uintptr_t to the " "Eeek! You'll need to adjust the size of uintptr_t to the "
"size of a pointer on your platform."); "size of a pointer on your platform.");

2
layout/generic/nsImageFrame.cpp
View File

@ -885,7 +885,7 @@ nsImageFrame::Reflow(nsPresContext* aPresContext,
// We include the altFeedbackSize in our visual overflow, but not in our // We include the altFeedbackSize in our visual overflow, but not in our
// scrollable overflow, since it doesn't really need to be scrolled to // scrollable overflow, since it doesn't really need to be scrolled to
// outside the image. // outside the image.
MOZ_STATIC_ASSERT(eOverflowType_LENGTH == 2, "Unknown overflow types?"); static_assert(eOverflowType_LENGTH == 2, "Unknown overflow types?");
nsRect& visualOverflow = aMetrics.VisualOverflow(); nsRect& visualOverflow = aMetrics.VisualOverflow();
visualOverflow.UnionRect(visualOverflow, altFeedbackSize); visualOverflow.UnionRect(visualOverflow, altFeedbackSize);
} }

2
layout/generic/nsLineBox.cpp
View File

@ -44,7 +44,7 @@ nsLineBox::nsLineBox(nsIFrame* aFrame, int32_t aCount, bool aIsBlock)
} }
#endif #endif
MOZ_STATIC_ASSERT(NS_STYLE_CLEAR_LAST_VALUE <= 15, static_assert(NS_STYLE_CLEAR_LAST_VALUE <= 15,
"FlagBits needs more bits to store the full range of " "FlagBits needs more bits to store the full range of "
"break type ('clear') values"); "break type ('clear') values");
#if NS_STYLE_CLEAR_NONE > 0 #if NS_STYLE_CLEAR_NONE > 0

6
layout/generic/nsQueryFrame.h
View File

@ -24,7 +24,7 @@
#define NS_QUERYFRAME_ENTRY(class) \ #define NS_QUERYFRAME_ENTRY(class) \
case class::kFrameIID: { \ case class::kFrameIID: { \
MOZ_STATIC_ASSERT((mozilla::IsSame<class, class::Has_NS_DECL_QUERYFRAME_TARGET>::value), \ static_assert(mozilla::IsSame<class, class::Has_NS_DECL_QUERYFRAME_TARGET>::value, \
#class " must declare itself as a queryframe target"); \ #class " must declare itself as a queryframe target"); \
return static_cast<class*>(this); \ return static_cast<class*>(this); \
} }
@ -32,7 +32,7 @@
#define NS_QUERYFRAME_ENTRY_CONDITIONAL(class, condition) \ #define NS_QUERYFRAME_ENTRY_CONDITIONAL(class, condition) \
case class::kFrameIID: \ case class::kFrameIID: \
if (condition) { \ if (condition) { \
MOZ_STATIC_ASSERT((mozilla::IsSame<class, class::Has_NS_DECL_QUERYFRAME_TARGET>::value), \ static_assert(mozilla::IsSame<class, class::Has_NS_DECL_QUERYFRAME_TARGET>::value, \
#class " must declare itself as a queryframe target"); \ #class " must declare itself as a queryframe target"); \
return static_cast<class*>(this); \ return static_cast<class*>(this); \
} \ } \
@ -81,7 +81,7 @@ public:
template<class Dest> template<class Dest>
operator Dest*() { operator Dest*() {
MOZ_STATIC_ASSERT((mozilla::IsSame<Dest, typename Dest::Has_NS_DECL_QUERYFRAME_TARGET>::value), static_assert(mozilla::IsSame<Dest, typename Dest::Has_NS_DECL_QUERYFRAME_TARGET>::value,
"Dest must declare itself as a queryframe target"); "Dest must declare itself as a queryframe target");
if (!mRawPtr) if (!mRawPtr)
return nullptr; return nullptr;

2
layout/inspector/src/inDOMUtils.cpp
View File

@ -754,7 +754,7 @@ GetStatesForPseudoClass(const nsAString& aStatePseudo)
nsEventStates(), nsEventStates(),
nsEventStates() nsEventStates()
}; };
MOZ_STATIC_ASSERT(NS_ARRAY_LENGTH(sPseudoClassStates) == static_assert(NS_ARRAY_LENGTH(sPseudoClassStates) ==
nsCSSPseudoClasses::ePseudoClass_NotPseudoClass + 1, nsCSSPseudoClasses::ePseudoClass_NotPseudoClass + 1,
"Length of PseudoClassStates array is incorrect"); "Length of PseudoClassStates array is incorrect");

4
layout/style/Declaration.cpp
View File

@ -20,7 +20,7 @@ namespace css {
// check that we can fit all the CSS properties into a uint16_t // check that we can fit all the CSS properties into a uint16_t
// for the mOrder array // for the mOrder array
MOZ_STATIC_ASSERT(eCSSProperty_COUNT_no_shorthands - 1 <= UINT16_MAX, static_assert(eCSSProperty_COUNT_no_shorthands - 1 <= UINT16_MAX,
"CSS longhand property numbers no longer fit in a uint16_t"); "CSS longhand property numbers no longer fit in a uint16_t");
Declaration::Declaration() Declaration::Declaration()
@ -481,7 +481,7 @@ Declaration::GetValue(nsCSSProperty aProperty, nsAString& aValue) const
MOZ_ASSERT(nsCSSProps::kKeywordTableTable[ MOZ_ASSERT(nsCSSProps::kKeywordTableTable[
eCSSProperty_background_clip] == eCSSProperty_background_clip] ==
nsCSSProps::kBackgroundOriginKTable); nsCSSProps::kBackgroundOriginKTable);
MOZ_STATIC_ASSERT(NS_STYLE_BG_CLIP_BORDER == static_assert(NS_STYLE_BG_CLIP_BORDER ==
NS_STYLE_BG_ORIGIN_BORDER && NS_STYLE_BG_ORIGIN_BORDER &&
NS_STYLE_BG_CLIP_PADDING == NS_STYLE_BG_CLIP_PADDING ==
NS_STYLE_BG_ORIGIN_PADDING && NS_STYLE_BG_ORIGIN_PADDING &&

2
layout/style/StyleRule.cpp
View File

@ -302,7 +302,7 @@ nsCSSSelector::nsCSSSelector(void)
mPseudoType(nsCSSPseudoElements::ePseudo_NotPseudoElement) mPseudoType(nsCSSPseudoElements::ePseudo_NotPseudoElement)
{ {
MOZ_COUNT_CTOR(nsCSSSelector); MOZ_COUNT_CTOR(nsCSSSelector);
MOZ_STATIC_ASSERT(nsCSSPseudoElements::ePseudo_MAX < INT16_MAX, static_assert(nsCSSPseudoElements::ePseudo_MAX < INT16_MAX,
"nsCSSPseudoElements::Type values overflow mPseudoType"); "nsCSSPseudoElements::Type values overflow mPseudoType");
} }

4
layout/style/nsAnimationManager.cpp
View File

@ -667,9 +667,9 @@ public:
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; } static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey) { static PLDHashNumber HashKey(KeyTypePointer aKey) {
MOZ_STATIC_ASSERT(sizeof(PLDHashNumber) == sizeof(uint32_t), static_assert(sizeof(PLDHashNumber) == sizeof(uint32_t),
"this hash function assumes PLDHashNumber is uint32_t"); "this hash function assumes PLDHashNumber is uint32_t");
MOZ_STATIC_ASSERT(PLDHashNumber(-1) > PLDHashNumber(0), static_assert(PLDHashNumber(-1) > PLDHashNumber(0),
"this hash function assumes PLDHashNumber is uint32_t"); "this hash function assumes PLDHashNumber is uint32_t");
float key = *aKey; float key = *aKey;
NS_ABORT_IF_FALSE(0.0f <= key && key <= 1.0f, "out of range"); NS_ABORT_IF_FALSE(0.0f <= key && key <= 1.0f, "out of range");

8
layout/style/nsCSSDataBlock.h
View File

@ -160,15 +160,15 @@ private:
// Make sure the values and properties are aligned appropriately. (These // Make sure the values and properties are aligned appropriately. (These
// assertions are stronger than necessary to keep them simple.) // assertions are stronger than necessary to keep them simple.)
MOZ_STATIC_ASSERT(sizeof(nsCSSCompressedDataBlock) == 8, static_assert(sizeof(nsCSSCompressedDataBlock) == 8,
"nsCSSCompressedDataBlock's size has changed"); "nsCSSCompressedDataBlock's size has changed");
MOZ_STATIC_ASSERT(NS_ALIGNMENT_OF(nsCSSValue) == 4 || NS_ALIGNMENT_OF(nsCSSValue) == 8, static_assert(NS_ALIGNMENT_OF(nsCSSValue) == 4 || NS_ALIGNMENT_OF(nsCSSValue) == 8,
"nsCSSValue doesn't align with nsCSSCompressedDataBlock"); "nsCSSValue doesn't align with nsCSSCompressedDataBlock");
MOZ_STATIC_ASSERT(NS_ALIGNMENT_OF(nsCSSCompressedDataBlock::CompressedCSSProperty) == 2, static_assert(NS_ALIGNMENT_OF(nsCSSCompressedDataBlock::CompressedCSSProperty) == 2,
"CompressedCSSProperty doesn't align with nsCSSValue"); "CompressedCSSProperty doesn't align with nsCSSValue");
// Make sure that sizeof(CompressedCSSProperty) is big enough. // Make sure that sizeof(CompressedCSSProperty) is big enough.
MOZ_STATIC_ASSERT(eCSSProperty_COUNT_no_shorthands <= static_assert(eCSSProperty_COUNT_no_shorthands <=
nsCSSCompressedDataBlock::MaxCompressedCSSProperty, nsCSSCompressedDataBlock::MaxCompressedCSSProperty,
"nsCSSProperty doesn't fit in StoredSizeOfCSSProperty"); "nsCSSProperty doesn't fit in StoredSizeOfCSSProperty");

12
layout/style/nsCSSParser.cpp
View File

@ -6957,7 +6957,7 @@ CSSParserImpl::ParseBackgroundItem(CSSParserImpl::BackgroundParseState& aState)
MOZ_ASSERT(nsCSSProps::kKeywordTableTable[ MOZ_ASSERT(nsCSSProps::kKeywordTableTable[
eCSSProperty_background_clip] == eCSSProperty_background_clip] ==
nsCSSProps::kBackgroundOriginKTable); nsCSSProps::kBackgroundOriginKTable);
MOZ_STATIC_ASSERT(NS_STYLE_BG_CLIP_BORDER == static_assert(NS_STYLE_BG_CLIP_BORDER ==
NS_STYLE_BG_ORIGIN_BORDER && NS_STYLE_BG_ORIGIN_BORDER &&
NS_STYLE_BG_CLIP_PADDING == NS_STYLE_BG_CLIP_PADDING ==
NS_STYLE_BG_ORIGIN_PADDING && NS_STYLE_BG_ORIGIN_PADDING &&
@ -9531,7 +9531,7 @@ CSSParserImpl::ParseTextDecoration()
eDecorationBlink = NS_STYLE_TEXT_DECORATION_LINE_BLINK, eDecorationBlink = NS_STYLE_TEXT_DECORATION_LINE_BLINK,
eDecorationPrefAnchors = NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS eDecorationPrefAnchors = NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS
}; };
MOZ_STATIC_ASSERT((eDecorationNone ^ eDecorationUnderline ^ static_assert((eDecorationNone ^ eDecorationUnderline ^
eDecorationOverline ^ eDecorationLineThrough ^ eDecorationOverline ^ eDecorationLineThrough ^
eDecorationBlink ^ eDecorationPrefAnchors) == eDecorationBlink ^ eDecorationPrefAnchors) ==
(eDecorationNone | eDecorationUnderline | (eDecorationNone | eDecorationUnderline |
@ -10774,7 +10774,7 @@ CSSParserImpl::ParseMarker()
bool bool
CSSParserImpl::ParsePaintOrder() CSSParserImpl::ParsePaintOrder()
{ {
MOZ_STATIC_ASSERT static_assert
((1 << NS_STYLE_PAINT_ORDER_BITWIDTH) > NS_STYLE_PAINT_ORDER_LAST_VALUE, ((1 << NS_STYLE_PAINT_ORDER_BITWIDTH) > NS_STYLE_PAINT_ORDER_LAST_VALUE,
"bitfield width insufficient for paint-order constants"); "bitfield width insufficient for paint-order constants");
@ -10786,7 +10786,7 @@ CSSParserImpl::ParsePaintOrder()
eCSSKeyword_UNKNOWN,-1 eCSSKeyword_UNKNOWN,-1
}; };
MOZ_STATIC_ASSERT(NS_ARRAY_LENGTH(kPaintOrderKTable) == static_assert(NS_ARRAY_LENGTH(kPaintOrderKTable) ==
2 * (NS_STYLE_PAINT_ORDER_LAST_VALUE + 2), 2 * (NS_STYLE_PAINT_ORDER_LAST_VALUE + 2),
"missing paint-order values in kPaintOrderKTable"); "missing paint-order values in kPaintOrderKTable");
@ -10801,7 +10801,7 @@ CSSParserImpl::ParsePaintOrder()
// Ensure that even cast to a signed int32_t when stored in CSSValue, // Ensure that even cast to a signed int32_t when stored in CSSValue,
// we have enough space for the entire paint-order value. // we have enough space for the entire paint-order value.
MOZ_STATIC_ASSERT static_assert
(NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE < 32, (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE < 32,
"seen and order not big enough"); "seen and order not big enough");
@ -10845,7 +10845,7 @@ CSSParserImpl::ParsePaintOrder()
} }
} }
MOZ_STATIC_ASSERT(NS_STYLE_PAINT_ORDER_NORMAL == 0, static_assert(NS_STYLE_PAINT_ORDER_NORMAL == 0,
"unexpected value for NS_STYLE_PAINT_ORDER_NORMAL"); "unexpected value for NS_STYLE_PAINT_ORDER_NORMAL");
value.SetIntValue(static_cast<int32_t>(order), eCSSUnit_Enumerated); value.SetIntValue(static_cast<int32_t>(order), eCSSUnit_Enumerated);
} }

8
layout/style/nsCSSProps.cpp
View File

@ -356,7 +356,7 @@ nsCSSProps::LookupProperty(const nsACString& aProperty,
// Check eCSSAliasCount against 0 to make it easy for the // Check eCSSAliasCount against 0 to make it easy for the
// compiler to optimize away the 0-aliases case. // compiler to optimize away the 0-aliases case.
if (eCSSAliasCount != 0 && res >= eCSSProperty_COUNT) { if (eCSSAliasCount != 0 && res >= eCSSProperty_COUNT) {
MOZ_STATIC_ASSERT(eCSSProperty_UNKNOWN < eCSSProperty_COUNT, static_assert(eCSSProperty_UNKNOWN < eCSSProperty_COUNT,
"assuming eCSSProperty_UNKNOWN doesn't hit this code"); "assuming eCSSProperty_UNKNOWN doesn't hit this code");
if (IsEnabled(res) || aEnabled == eAny) { if (IsEnabled(res) || aEnabled == eAny) {
res = gAliases[res - eCSSProperty_COUNT]; res = gAliases[res - eCSSProperty_COUNT];
@ -383,7 +383,7 @@ nsCSSProps::LookupProperty(const nsAString& aProperty, EnabledState aEnabled)
// Check eCSSAliasCount against 0 to make it easy for the // Check eCSSAliasCount against 0 to make it easy for the
// compiler to optimize away the 0-aliases case. // compiler to optimize away the 0-aliases case.
if (eCSSAliasCount != 0 && res >= eCSSProperty_COUNT) { if (eCSSAliasCount != 0 && res >= eCSSProperty_COUNT) {
MOZ_STATIC_ASSERT(eCSSProperty_UNKNOWN < eCSSProperty_COUNT, static_assert(eCSSProperty_UNKNOWN < eCSSProperty_COUNT,
"assuming eCSSProperty_UNKNOWN doesn't hit this code"); "assuming eCSSProperty_UNKNOWN doesn't hit this code");
if (IsEnabled(res) || aEnabled == eAny) { if (IsEnabled(res) || aEnabled == eAny) {
res = gAliases[res - eCSSProperty_COUNT]; res = gAliases[res - eCSSProperty_COUNT];
@ -647,7 +647,7 @@ const int32_t nsCSSProps::kBackgroundInlinePolicyKTable[] = {
eCSSKeyword_UNKNOWN,-1 eCSSKeyword_UNKNOWN,-1
}; };
MOZ_STATIC_ASSERT(NS_STYLE_BG_CLIP_BORDER == NS_STYLE_BG_ORIGIN_BORDER && static_assert(NS_STYLE_BG_CLIP_BORDER == NS_STYLE_BG_ORIGIN_BORDER &&
NS_STYLE_BG_CLIP_PADDING == NS_STYLE_BG_ORIGIN_PADDING && NS_STYLE_BG_CLIP_PADDING == NS_STYLE_BG_ORIGIN_PADDING &&
NS_STYLE_BG_CLIP_CONTENT == NS_STYLE_BG_ORIGIN_CONTENT, NS_STYLE_BG_CLIP_CONTENT == NS_STYLE_BG_ORIGIN_CONTENT,
"bg-clip and bg-origin style constants must agree"); "bg-clip and bg-origin style constants must agree");
@ -1954,7 +1954,7 @@ static const nsCSSProperty gBorderBottomSubpropTable[] = {
eCSSProperty_UNKNOWN eCSSProperty_UNKNOWN
}; };
MOZ_STATIC_ASSERT(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 && static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3, NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
"box side constants not top/right/bottom/left == 0/1/2/3"); "box side constants not top/right/bottom/left == 0/1/2/3");
static const nsCSSProperty gBorderColorSubpropTable[] = { static const nsCSSProperty gBorderColorSubpropTable[] = {

2
layout/style/nsCSSProps.h
View File

@ -159,7 +159,7 @@
// See CSSParserImpl::ParseSingleValueProperty and comment above // See CSSParserImpl::ParseSingleValueProperty and comment above
// CSS_PROPERTY_PARSE_FUNCTION (which is different). // CSS_PROPERTY_PARSE_FUNCTION (which is different).
#define CSS_PROPERTY_VALUE_PARSER_FUNCTION (1<<12) #define CSS_PROPERTY_VALUE_PARSER_FUNCTION (1<<12)
MOZ_STATIC_ASSERT((CSS_PROPERTY_PARSE_PROPERTY_MASK & static_assert((CSS_PROPERTY_PARSE_PROPERTY_MASK &
CSS_PROPERTY_VALUE_PARSER_FUNCTION) == 0, CSS_PROPERTY_VALUE_PARSER_FUNCTION) == 0,
"didn't leave enough room for the parse property constants"); "didn't leave enough room for the parse property constants");

2
layout/style/nsCSSRuleProcessor.cpp
View File

@ -1619,7 +1619,7 @@ static const nsEventStates sPseudoClassStates[] = {
nsEventStates(), nsEventStates(),
nsEventStates() nsEventStates()
}; };
MOZ_STATIC_ASSERT(NS_ARRAY_LENGTH(sPseudoClassStates) == static_assert(NS_ARRAY_LENGTH(sPseudoClassStates) ==
nsCSSPseudoClasses::ePseudoClass_NotPseudoClass + 1, nsCSSPseudoClasses::ePseudoClass_NotPseudoClass + 1,
"ePseudoClass_NotPseudoClass is no longer at the end of" "ePseudoClass_NotPseudoClass is no longer at the end of"
"sPseudoClassStates"); "sPseudoClassStates");

2
layout/style/nsCSSScanner.cpp
View File

@ -76,7 +76,7 @@ static const uint8_t gLexTable[] = {
SUIJ, SUIJ, SUIJ, SU, SU, SU, SU, S, SUIJ, SUIJ, SUIJ, SU, SU, SU, SU, S,
}; };
MOZ_STATIC_ASSERT(MOZ_ARRAY_LENGTH(gLexTable) == 128, static_assert(MOZ_ARRAY_LENGTH(gLexTable) == 128,
"gLexTable expected to cover all 128 ASCII characters"); "gLexTable expected to cover all 128 ASCII characters");
#undef I #undef I

6
layout/style/nsCSSValue.cpp
View File

@ -863,7 +863,7 @@ nsCSSValue::AppendToString(nsCSSProperty aProperty, nsAString& aResult) const
break; break;
case eCSSProperty_paint_order: case eCSSProperty_paint_order:
MOZ_STATIC_ASSERT static_assert
(NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8, (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8,
"SVGStyleStruct::mPaintOrder and the following cast not big enough"); "SVGStyleStruct::mPaintOrder and the following cast not big enough");
nsStyleUtil::AppendPaintOrderValue(static_cast<uint8_t>(GetIntValue()), nsStyleUtil::AppendPaintOrderValue(static_cast<uint8_t>(GetIntValue()),
@ -1533,7 +1533,7 @@ nsCSSRect_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
return n; return n;
} }
MOZ_STATIC_ASSERT(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 && static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3, NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
"box side constants not top/right/bottom/left == 0/1/2/3"); "box side constants not top/right/bottom/left == 0/1/2/3");
@ -1933,7 +1933,7 @@ nsCSSCornerSizes::Reset()
} }
} }
MOZ_STATIC_ASSERT(NS_CORNER_TOP_LEFT == 0 && NS_CORNER_TOP_RIGHT == 1 && static_assert(NS_CORNER_TOP_LEFT == 0 && NS_CORNER_TOP_RIGHT == 1 &&
NS_CORNER_BOTTOM_RIGHT == 2 && NS_CORNER_BOTTOM_LEFT == 3, NS_CORNER_BOTTOM_RIGHT == 2 && NS_CORNER_BOTTOM_LEFT == 3,
"box corner constants not tl/tr/br/bl == 0/1/2/3"); "box corner constants not tl/tr/br/bl == 0/1/2/3");

4
layout/style/nsComputedDOMStyle.cpp
View File

@ -2958,7 +2958,7 @@ nsComputedDOMStyle::DoGetDirection()
return val; return val;
} }
MOZ_STATIC_ASSERT(NS_STYLE_UNICODE_BIDI_NORMAL == 0, static_assert(NS_STYLE_UNICODE_BIDI_NORMAL == 0,
"unicode-bidi style constants not as expected"); "unicode-bidi style constants not as expected");
CSSValue* CSSValue*
@ -3734,7 +3734,7 @@ nsComputedDOMStyle::GetAbsoluteOffset(mozilla::css::Side aSide)
return val; return val;
} }
MOZ_STATIC_ASSERT(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 && static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3, NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
"box side constants not as expected for NS_OPPOSITE_SIDE"); "box side constants not as expected for NS_OPPOSITE_SIDE");
#define NS_OPPOSITE_SIDE(s_) mozilla::css::Side(((s_) + 2) & 3) #define NS_OPPOSITE_SIDE(s_) mozilla::css::Side(((s_) + 2) & 3)

6
layout/style/nsRuleData.cpp
View File

@ -14,11 +14,11 @@ nsRuleData::GetPoisonOffset()
// Fill in mValueOffsets such that mValueStorage + mValueOffsets[i] // Fill in mValueOffsets such that mValueStorage + mValueOffsets[i]
// will yield the frame poison value for all uninitialized value // will yield the frame poison value for all uninitialized value
// offsets. // offsets.
MOZ_STATIC_ASSERT(sizeof(uintptr_t) == sizeof(size_t), static_assert(sizeof(uintptr_t) == sizeof(size_t),
"expect uintptr_t and size_t to be the same size"); "expect uintptr_t and size_t to be the same size");
MOZ_STATIC_ASSERT(uintptr_t(-1) > uintptr_t(0), static_assert(uintptr_t(-1) > uintptr_t(0),
"expect uintptr_t to be unsigned"); "expect uintptr_t to be unsigned");
MOZ_STATIC_ASSERT(size_t(-1) > size_t(0), static_assert(size_t(-1) > size_t(0),
"expect size_t to be unsigned"); "expect size_t to be unsigned");
uintptr_t framePoisonValue = mozPoisonValue(); uintptr_t framePoisonValue = mozPoisonValue();
return size_t(framePoisonValue - uintptr_t(mValueStorage)) / return size_t(framePoisonValue - uintptr_t(mValueStorage)) /

6
layout/style/nsRuleNode.cpp
View File

@ -3082,7 +3082,7 @@ nsRuleNode::SetFont(nsPresContext* aPresContext, nsStyleContext* aContext,
aFont->mLanguage); aFont->mLanguage);
// -moz-system-font: enum (never inherit!) // -moz-system-font: enum (never inherit!)
MOZ_STATIC_ASSERT( static_assert(
NS_STYLE_FONT_CAPTION == LookAndFeel::eFont_Caption && NS_STYLE_FONT_CAPTION == LookAndFeel::eFont_Caption &&
NS_STYLE_FONT_ICON == LookAndFeel::eFont_Icon && NS_STYLE_FONT_ICON == LookAndFeel::eFont_Icon &&
NS_STYLE_FONT_MENU == LookAndFeel::eFont_Menu && NS_STYLE_FONT_MENU == LookAndFeel::eFont_Menu &&
@ -5549,7 +5549,7 @@ struct BackgroundItemComputer<nsCSSValuePairList, nsStyleBackground::Size>
size.*(axis->type) = nsStyleBackground::Size::eAuto; size.*(axis->type) = nsStyleBackground::Size::eAuto;
} }
else if (eCSSUnit_Enumerated == specified.GetUnit()) { else if (eCSSUnit_Enumerated == specified.GetUnit()) {
MOZ_STATIC_ASSERT(nsStyleBackground::Size::eContain == static_assert(nsStyleBackground::Size::eContain ==
NS_STYLE_BG_SIZE_CONTAIN && NS_STYLE_BG_SIZE_CONTAIN &&
nsStyleBackground::Size::eCover == nsStyleBackground::Size::eCover ==
NS_STYLE_BG_SIZE_COVER, NS_STYLE_BG_SIZE_COVER,
@ -7535,7 +7535,7 @@ nsRuleNode::ComputeSVGData(void* aStartStruct,
break; break;
case eCSSUnit_Enumerated: case eCSSUnit_Enumerated:
MOZ_STATIC_ASSERT static_assert
(NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8, (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8,
"SVGStyleStruct::mPaintOrder not big enough"); "SVGStyleStruct::mPaintOrder not big enough");
svg->mPaintOrder = static_cast<uint8_t>(paintOrderValue->GetIntValue()); svg->mPaintOrder = static_cast<uint8_t>(paintOrderValue->GetIntValue());

6
layout/style/nsStyleAnimation.cpp
View File

@ -2824,7 +2824,7 @@ nsStyleAnimation::ExtractComputedValue(nsCSSProperty aProperty,
case eCSSProperty_font_stretch: { case eCSSProperty_font_stretch: {
int16_t stretch = int16_t stretch =
static_cast<const nsStyleFont*>(styleStruct)->mFont.stretch; static_cast<const nsStyleFont*>(styleStruct)->mFont.stretch;
MOZ_STATIC_ASSERT(NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED == -4 && static_assert(NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED == -4 &&
NS_STYLE_FONT_STRETCH_ULTRA_EXPANDED == 4, NS_STYLE_FONT_STRETCH_ULTRA_EXPANDED == 4,
"font stretch constants not as expected"); "font stretch constants not as expected");
if (stretch < NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED || if (stretch < NS_STYLE_FONT_STRETCH_ULTRA_CONDENSED ||
@ -3049,7 +3049,7 @@ nsStyleAnimation::ExtractComputedValue(nsCSSProperty aProperty,
case eStyleAnimType_Sides_Right: case eStyleAnimType_Sides_Right:
case eStyleAnimType_Sides_Bottom: case eStyleAnimType_Sides_Bottom:
case eStyleAnimType_Sides_Left: { case eStyleAnimType_Sides_Left: {
MOZ_STATIC_ASSERT( static_assert(
NS_SIDE_TOP == eStyleAnimType_Sides_Top -eStyleAnimType_Sides_Top && NS_SIDE_TOP == eStyleAnimType_Sides_Top -eStyleAnimType_Sides_Top &&
NS_SIDE_RIGHT == eStyleAnimType_Sides_Right -eStyleAnimType_Sides_Top && NS_SIDE_RIGHT == eStyleAnimType_Sides_Right -eStyleAnimType_Sides_Top &&
NS_SIDE_BOTTOM == eStyleAnimType_Sides_Bottom-eStyleAnimType_Sides_Top && NS_SIDE_BOTTOM == eStyleAnimType_Sides_Bottom-eStyleAnimType_Sides_Top &&
@ -3065,7 +3065,7 @@ nsStyleAnimation::ExtractComputedValue(nsCSSProperty aProperty,
case eStyleAnimType_Corner_TopRight: case eStyleAnimType_Corner_TopRight:
case eStyleAnimType_Corner_BottomRight: case eStyleAnimType_Corner_BottomRight:
case eStyleAnimType_Corner_BottomLeft: { case eStyleAnimType_Corner_BottomLeft: {
MOZ_STATIC_ASSERT( static_assert(
NS_CORNER_TOP_LEFT == eStyleAnimType_Corner_TopLeft - NS_CORNER_TOP_LEFT == eStyleAnimType_Corner_TopLeft -
eStyleAnimType_Corner_TopLeft && eStyleAnimType_Corner_TopLeft &&
NS_CORNER_TOP_RIGHT == eStyleAnimType_Corner_TopRight - NS_CORNER_TOP_RIGHT == eStyleAnimType_Corner_TopRight -

2
layout/style/nsStyleContext.cpp
View File

@ -48,7 +48,7 @@ nsStyleContext::nsStyleContext(nsStyleContext* aParent,
{ {
// This check has to be done "backward", because if it were written the // This check has to be done "backward", because if it were written the
// more natural way it wouldn't fail even when it needed to. // more natural way it wouldn't fail even when it needed to.
MOZ_STATIC_ASSERT((UINT32_MAX >> NS_STYLE_CONTEXT_TYPE_SHIFT) >= static_assert((UINT32_MAX >> NS_STYLE_CONTEXT_TYPE_SHIFT) >=
nsCSSPseudoElements::ePseudo_MAX, nsCSSPseudoElements::ePseudo_MAX,
"pseudo element bits no longer fit in a uint32_t"); "pseudo element bits no longer fit in a uint32_t");
MOZ_ASSERT(aRuleNode); MOZ_ASSERT(aRuleNode);

12
layout/style/nsStyleCoord.cpp
View File

@ -248,7 +248,7 @@ void nsStyleCorners::Reset()
// Validation of NS_SIDE_IS_VERTICAL and NS_HALF_CORNER_IS_X. // Validation of NS_SIDE_IS_VERTICAL and NS_HALF_CORNER_IS_X.
#define CASE(side, result) \ #define CASE(side, result) \
MOZ_STATIC_ASSERT(NS_SIDE_IS_VERTICAL(side) == result, \ static_assert(NS_SIDE_IS_VERTICAL(side) == result, \
"NS_SIDE_IS_VERTICAL is wrong") "NS_SIDE_IS_VERTICAL is wrong")
CASE(NS_SIDE_TOP, false); CASE(NS_SIDE_TOP, false);
CASE(NS_SIDE_RIGHT, true); CASE(NS_SIDE_RIGHT, true);
@ -257,7 +257,7 @@ CASE(NS_SIDE_LEFT, true);
#undef CASE #undef CASE
#define CASE(corner, result) \ #define CASE(corner, result) \
MOZ_STATIC_ASSERT(NS_HALF_CORNER_IS_X(corner) == result, \ static_assert(NS_HALF_CORNER_IS_X(corner) == result, \
"NS_HALF_CORNER_IS_X is wrong") "NS_HALF_CORNER_IS_X is wrong")
CASE(NS_CORNER_TOP_LEFT_X, true); CASE(NS_CORNER_TOP_LEFT_X, true);
CASE(NS_CORNER_TOP_LEFT_Y, false); CASE(NS_CORNER_TOP_LEFT_Y, false);
@ -271,7 +271,7 @@ CASE(NS_CORNER_BOTTOM_LEFT_Y, false);
// Validation of NS_HALF_TO_FULL_CORNER. // Validation of NS_HALF_TO_FULL_CORNER.
#define CASE(corner, result) \ #define CASE(corner, result) \
MOZ_STATIC_ASSERT(NS_HALF_TO_FULL_CORNER(corner) == result, \ static_assert(NS_HALF_TO_FULL_CORNER(corner) == result, \
"NS_HALF_TO_FULL_CORNER is wrong") "NS_HALF_TO_FULL_CORNER is wrong")
CASE(NS_CORNER_TOP_LEFT_X, NS_CORNER_TOP_LEFT); CASE(NS_CORNER_TOP_LEFT_X, NS_CORNER_TOP_LEFT);
CASE(NS_CORNER_TOP_LEFT_Y, NS_CORNER_TOP_LEFT); CASE(NS_CORNER_TOP_LEFT_Y, NS_CORNER_TOP_LEFT);
@ -285,7 +285,7 @@ CASE(NS_CORNER_BOTTOM_LEFT_Y, NS_CORNER_BOTTOM_LEFT);
// Validation of NS_FULL_TO_HALF_CORNER. // Validation of NS_FULL_TO_HALF_CORNER.
#define CASE(corner, vert, result) \ #define CASE(corner, vert, result) \
MOZ_STATIC_ASSERT(NS_FULL_TO_HALF_CORNER(corner, vert) == result, \ static_assert(NS_FULL_TO_HALF_CORNER(corner, vert) == result, \
"NS_FULL_TO_HALF_CORNER is wrong") "NS_FULL_TO_HALF_CORNER is wrong")
CASE(NS_CORNER_TOP_LEFT, false, NS_CORNER_TOP_LEFT_X); CASE(NS_CORNER_TOP_LEFT, false, NS_CORNER_TOP_LEFT_X);
CASE(NS_CORNER_TOP_LEFT, true, NS_CORNER_TOP_LEFT_Y); CASE(NS_CORNER_TOP_LEFT, true, NS_CORNER_TOP_LEFT_Y);
@ -299,7 +299,7 @@ CASE(NS_CORNER_BOTTOM_LEFT, true, NS_CORNER_BOTTOM_LEFT_Y);
// Validation of NS_SIDE_TO_{FULL,HALF}_CORNER. // Validation of NS_SIDE_TO_{FULL,HALF}_CORNER.
#define CASE(side, second, result) \ #define CASE(side, second, result) \
MOZ_STATIC_ASSERT(NS_SIDE_TO_FULL_CORNER(side, second) == result, \ static_assert(NS_SIDE_TO_FULL_CORNER(side, second) == result, \
"NS_SIDE_TO_FULL_CORNER is wrong") "NS_SIDE_TO_FULL_CORNER is wrong")
CASE(NS_SIDE_TOP, false, NS_CORNER_TOP_LEFT); CASE(NS_SIDE_TOP, false, NS_CORNER_TOP_LEFT);
CASE(NS_SIDE_TOP, true, NS_CORNER_TOP_RIGHT); CASE(NS_SIDE_TOP, true, NS_CORNER_TOP_RIGHT);
@ -315,7 +315,7 @@ CASE(NS_SIDE_LEFT, true, NS_CORNER_TOP_LEFT);
#undef CASE #undef CASE
#define CASE(side, second, parallel, result) \ #define CASE(side, second, parallel, result) \
MOZ_STATIC_ASSERT(NS_SIDE_TO_HALF_CORNER(side, second, parallel) == result, \ static_assert(NS_SIDE_TO_HALF_CORNER(side, second, parallel) == result, \
"NS_SIDE_TO_HALF_CORNER is wrong") "NS_SIDE_TO_HALF_CORNER is wrong")
CASE(NS_SIDE_TOP, false, true, NS_CORNER_TOP_LEFT_X); CASE(NS_SIDE_TOP, false, true, NS_CORNER_TOP_LEFT_X);
CASE(NS_SIDE_TOP, false, false, NS_CORNER_TOP_LEFT_Y); CASE(NS_SIDE_TOP, false, false, NS_CORNER_TOP_LEFT_Y);

4
layout/style/nsStyleStruct.cpp
View File

@ -29,7 +29,7 @@
#include "mozilla/Likely.h" #include "mozilla/Likely.h"
#include <algorithm> #include <algorithm>
MOZ_STATIC_ASSERT((((1 << nsStyleStructID_Length) - 1) & static_assert((((1 << nsStyleStructID_Length) - 1) &
~(NS_STYLE_INHERIT_MASK)) == 0, ~(NS_STYLE_INHERIT_MASK)) == 0,
"Not enough bits in NS_STYLE_INHERIT_MASK"); "Not enough bits in NS_STYLE_INHERIT_MASK");
@ -2101,7 +2101,7 @@ void nsTimingFunction::AssignFromKeyword(int32_t aTimingFunctionType)
break; break;
} }
MOZ_STATIC_ASSERT(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE == 0 && static_assert(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE == 0 &&
NS_STYLE_TRANSITION_TIMING_FUNCTION_LINEAR == 1 && NS_STYLE_TRANSITION_TIMING_FUNCTION_LINEAR == 1 &&
NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN == 2 && NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_IN == 2 &&
NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_OUT == 3 && NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE_OUT == 3 &&

4
layout/style/nsStyleUtil.cpp
View File

@ -160,7 +160,7 @@ nsStyleUtil::AppendBitmaskCSSValue(nsCSSProperty aProperty,
nsStyleUtil::AppendPaintOrderValue(uint8_t aValue, nsStyleUtil::AppendPaintOrderValue(uint8_t aValue,
nsAString& aResult) nsAString& aResult)
{ {
MOZ_STATIC_ASSERT static_assert
(NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8, (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8,
"SVGStyleStruct::mPaintOrder and local variables not big enough"); "SVGStyleStruct::mPaintOrder and local variables not big enough");
@ -170,7 +170,7 @@ nsStyleUtil::AppendPaintOrderValue(uint8_t aValue,
} }
// Append the minimal value necessary for the given paint order. // Append the minimal value necessary for the given paint order.
MOZ_STATIC_ASSERT(NS_STYLE_PAINT_ORDER_LAST_VALUE == 3, static_assert(NS_STYLE_PAINT_ORDER_LAST_VALUE == 3,
"paint-order values added; check serialization"); "paint-order values added; check serialization");
// The following relies on the default order being the order of the // The following relies on the default order being the order of the

2
layout/tables/nsCellMap.cpp
View File

@ -37,7 +37,7 @@ static nsCellMap::CellDataArray * sEmptyRow;
CellData::CellData(nsTableCellFrame* aOrigCell) CellData::CellData(nsTableCellFrame* aOrigCell)
{ {
MOZ_COUNT_CTOR(CellData); MOZ_COUNT_CTOR(CellData);
MOZ_STATIC_ASSERT(sizeof(mOrigCell) == sizeof(mBits), static_assert(sizeof(mOrigCell) == sizeof(mBits),
"mOrigCell and mBits must be the same size"); "mOrigCell and mBits must be the same size");
mOrigCell = aOrigCell; mOrigCell = aOrigCell;
} }

2
memory/mozalloc/mozalloc_oom.cpp
View File

@ -37,7 +37,7 @@ mozalloc_handle_oom(size_t size)
if (gAbortHandler) if (gAbortHandler)
gAbortHandler(size); gAbortHandler(size);
MOZ_STATIC_ASSERT(OOM_MSG_FIRST_DIGIT_OFFSET > 0, static_assert(OOM_MSG_FIRST_DIGIT_OFFSET > 0,
"Loop below will never terminate (i can't go below 0)"); "Loop below will never terminate (i can't go below 0)");
// Insert size into the diagnostic message using only primitive operations // Insert size into the diagnostic message using only primitive operations

6
mfbt/Atomics.h
View File

@ -706,7 +706,7 @@ struct IntrinsicBase
typedef T ValueType; typedef T ValueType;
typedef PrimitiveIntrinsics<sizeof(T)> Primitives; typedef PrimitiveIntrinsics<sizeof(T)> Primitives;
typedef typename Primitives::Type PrimType; typedef typename Primitives::Type PrimType;
MOZ_STATIC_ASSERT(sizeof(PrimType) == sizeof(T), static_assert(sizeof(PrimType) == sizeof(T),
"Selection of PrimitiveIntrinsics was wrong"); "Selection of PrimitiveIntrinsics was wrong");
typedef CastHelper<PrimType, T> Cast; typedef CastHelper<PrimType, T> Cast;
}; };
@ -898,10 +898,10 @@ class Atomic : public detail::AtomicBase<T, Order>
{ {
// We only support 32-bit types on 32-bit Windows, which constrains our // We only support 32-bit types on 32-bit Windows, which constrains our
// implementation elsewhere. But we support pointer-sized types everywhere. // implementation elsewhere. But we support pointer-sized types everywhere.
MOZ_STATIC_ASSERT(sizeof(T) == 4 || (sizeof(uintptr_t) == 8 && sizeof(T) == 8), static_assert(sizeof(T) == 4 || (sizeof(uintptr_t) == 8 && sizeof(T) == 8),
"mozilla/Atomics.h only supports 32-bit and pointer-sized types"); "mozilla/Atomics.h only supports 32-bit and pointer-sized types");
// Regardless of the OS, we only support integral types here. // Regardless of the OS, we only support integral types here.
MOZ_STATIC_ASSERT(IsIntegral<T>::value, "can only have integral atomic variables"); static_assert(IsIntegral<T>::value, "can only have integral atomic variables");
typedef typename detail::AtomicBase<T, Order> Base; typedef typename detail::AtomicBase<T, Order> Base;

2
mfbt/BloomFilter.h
View File

@ -106,7 +106,7 @@ class BloomFilter
*/ */
public: public:
BloomFilter() { BloomFilter() {
MOZ_STATIC_ASSERT(KeySize <= keyShift, "KeySize too big"); static_assert(KeySize <= keyShift, "KeySize too big");
// Should we have a custom operator new using calloc instead and // Should we have a custom operator new using calloc instead and
// require that we're allocated via the operator? // require that we're allocated via the operator?

2
mfbt/Casting.h
View File

@ -27,7 +27,7 @@ template<typename To, typename From>
inline To inline To
BitwiseCast(const From from) BitwiseCast(const From from)
{ {
MOZ_STATIC_ASSERT(sizeof(From) == sizeof(To), static_assert(sizeof(From) == sizeof(To),
"To and From must have the same size"); "To and From must have the same size");
union { union {
From from; From from;

6
mfbt/Char16.h
View File

@ -50,8 +50,8 @@
*/ */
#define MOZ_UTF16(s) MOZ_UTF16_HELPER(s) #define MOZ_UTF16(s) MOZ_UTF16_HELPER(s)
MOZ_STATIC_ASSERT(sizeof(char16_t) == 2, "Is char16_t type 16 bits?"); static_assert(sizeof(char16_t) == 2, "Is char16_t type 16 bits?");
MOZ_STATIC_ASSERT(sizeof(MOZ_UTF16('A')) == 2, "Is char literal 16 bits?"); static_assert(sizeof(MOZ_UTF16('A')) == 2, "Is char literal 16 bits?");
MOZ_STATIC_ASSERT(sizeof(MOZ_UTF16("")[0]) == 2, "Is string char 16 bits?"); static_assert(sizeof(MOZ_UTF16("")[0]) == 2, "Is string char 16 bits?");
#endif /* mozilla_Char16_h */ #endif /* mozilla_Char16_h */

9
mfbt/CheckedInt.h
View File

@ -18,7 +18,6 @@
# include "mozilla/Assertions.h" # include "mozilla/Assertions.h"
#else #else
# include <cassert> # include <cassert>
# define MOZ_STATIC_ASSERT(cond, reason) assert((cond) && reason)
# define MOZ_ASSERT(cond, reason) assert((cond) && reason) # define MOZ_ASSERT(cond, reason) assert((cond) && reason)
# define MOZ_DELETE # define MOZ_DELETE
#endif #endif
@ -600,7 +599,7 @@ class CheckedInt
template<typename U> template<typename U>
CheckedInt(U value, bool isValid) : mValue(value), mIsValid(isValid) CheckedInt(U value, bool isValid) : mValue(value), mIsValid(isValid)
{ {
MOZ_STATIC_ASSERT(detail::IsSupported<T>::value && static_assert(detail::IsSupported<T>::value &&
detail::IsSupported<U>::value, detail::IsSupported<U>::value,
"This type is not supported by CheckedInt"); "This type is not supported by CheckedInt");
} }
@ -624,7 +623,7 @@ class CheckedInt
: mValue(T(value)), : mValue(T(value)),
mIsValid(detail::IsInRange<T>(value)) mIsValid(detail::IsInRange<T>(value))
{ {
MOZ_STATIC_ASSERT(detail::IsSupported<T>::value && static_assert(detail::IsSupported<T>::value &&
detail::IsSupported<U>::value, detail::IsSupported<U>::value,
"This type is not supported by CheckedInt"); "This type is not supported by CheckedInt");
} }
@ -643,7 +642,7 @@ class CheckedInt
/** Constructs a valid checked integer with initial value 0 */ /** Constructs a valid checked integer with initial value 0 */
CheckedInt() : mValue(0), mIsValid(true) CheckedInt() : mValue(0), mIsValid(true)
{ {
MOZ_STATIC_ASSERT(detail::IsSupported<T>::value, static_assert(detail::IsSupported<T>::value,
"This type is not supported by CheckedInt"); "This type is not supported by CheckedInt");
} }
@ -817,7 +816,7 @@ template<typename T, typename U>
inline typename detail::CastToCheckedIntImpl<T, U>::ReturnType inline typename detail::CastToCheckedIntImpl<T, U>::ReturnType
castToCheckedInt(U u) castToCheckedInt(U u)
{ {
MOZ_STATIC_ASSERT(detail::IsSupported<T>::value && static_assert(detail::IsSupported<T>::value &&
detail::IsSupported<U>::value, detail::IsSupported<U>::value,
"This type is not supported by CheckedInt"); "This type is not supported by CheckedInt");
return detail::CastToCheckedIntImpl<T, U>::run(u); return detail::CastToCheckedIntImpl<T, U>::run(u);

10
mfbt/FloatingPoint.h
View File

@ -38,7 +38,7 @@ namespace mozilla {
* the case. But we required this in implementations of these algorithms that * the case. But we required this in implementations of these algorithms that
* preceded this header, so we shouldn't break anything if we continue doing so. * preceded this header, so we shouldn't break anything if we continue doing so.
*/ */
MOZ_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t), "double must be 64 bits"); static_assert(sizeof(double) == sizeof(uint64_t), "double must be 64 bits");
const unsigned DoubleExponentBias = 1023; const unsigned DoubleExponentBias = 1023;
const unsigned DoubleExponentShift = 52; const unsigned DoubleExponentShift = 52;
@ -47,14 +47,14 @@ const uint64_t DoubleSignBit = 0x8000000000000000ULL;
const uint64_t DoubleExponentBits = 0x7ff0000000000000ULL; const uint64_t DoubleExponentBits = 0x7ff0000000000000ULL;
const uint64_t DoubleSignificandBits = 0x000fffffffffffffULL; const uint64_t DoubleSignificandBits = 0x000fffffffffffffULL;
MOZ_STATIC_ASSERT((DoubleSignBit & DoubleExponentBits) == 0, static_assert((DoubleSignBit & DoubleExponentBits) == 0,
"sign bit doesn't overlap exponent bits"); "sign bit doesn't overlap exponent bits");
MOZ_STATIC_ASSERT((DoubleSignBit & DoubleSignificandBits) == 0, static_assert((DoubleSignBit & DoubleSignificandBits) == 0,
"sign bit doesn't overlap significand bits"); "sign bit doesn't overlap significand bits");
MOZ_STATIC_ASSERT((DoubleExponentBits & DoubleSignificandBits) == 0, static_assert((DoubleExponentBits & DoubleSignificandBits) == 0,
"exponent bits don't overlap significand bits"); "exponent bits don't overlap significand bits");
MOZ_STATIC_ASSERT((DoubleSignBit | DoubleExponentBits | DoubleSignificandBits) == static_assert((DoubleSignBit | DoubleExponentBits | DoubleSignificandBits) ==
~uint64_t(0), ~uint64_t(0),
"all bits accounted for"); "all bits accounted for");

2
mfbt/HashFunctions.h
View File

@ -175,7 +175,7 @@ AddToHash(uint32_t hash, A* a)
* catch data pointers and couldn't handle function pointers. * catch data pointers and couldn't handle function pointers.
*/ */
MOZ_STATIC_ASSERT(sizeof(a) == sizeof(uintptr_t), static_assert(sizeof(a) == sizeof(uintptr_t),
"Strange pointer!"); "Strange pointer!");
return detail::AddUintptrToHash<sizeof(uintptr_t)>(hash, uintptr_t(a)); return detail::AddUintptrToHash<sizeof(uintptr_t)>(hash, uintptr_t(a));

4
mfbt/Poison.cpp
View File

@ -142,8 +142,8 @@ GetDesiredRegionSize()
#endif // system dependencies #endif // system dependencies
MOZ_STATIC_ASSERT(sizeof(uintptr_t) == 4 || sizeof(uintptr_t) == 8, ""); static_assert(sizeof(uintptr_t) == 4 || sizeof(uintptr_t) == 8, "");
MOZ_STATIC_ASSERT(sizeof(uintptr_t) == sizeof(void *), ""); static_assert(sizeof(uintptr_t) == sizeof(void *), "");
static uintptr_t static uintptr_t
ReservePoisonArea(uintptr_t rgnsize) ReservePoisonArea(uintptr_t rgnsize)

4
mfbt/RefPtr.h
View File

@ -103,7 +103,7 @@ class RefCounted : public detail::RefCounted<T, detail::NonAtomicRefCount>
{ {
public: public:
~RefCounted() { ~RefCounted() {
MOZ_STATIC_ASSERT((IsBaseOf<RefCounted, T>::value), static_assert(IsBaseOf<RefCounted, T>::value,
"T must derive from RefCounted<T>"); "T must derive from RefCounted<T>");
} }
}; };
@ -117,7 +117,7 @@ class AtomicRefCounted : public detail::RefCounted<T, detail::AtomicRefCount>
{ {
public: public:
~AtomicRefCounted() { ~AtomicRefCounted() {
MOZ_STATIC_ASSERT((IsBaseOf<AtomicRefCounted, T>::value), static_assert(IsBaseOf<AtomicRefCounted, T>::value,
"T must derive from AtomicRefCounted<T>"); "T must derive from AtomicRefCounted<T>");
} }
}; };

2
mfbt/ThreadLocal.h
View File

@ -100,7 +100,7 @@ template<typename T>
inline bool inline bool
ThreadLocal<T>::init() ThreadLocal<T>::init()
{ {
MOZ_STATIC_ASSERT(sizeof(T) <= sizeof(void*), static_assert(sizeof(T) <= sizeof(void*),
"mozilla::ThreadLocal can't be used for types larger than " "mozilla::ThreadLocal can't be used for types larger than "
"a pointer"); "a pointer");
MOZ_ASSERT(!initialized()); MOZ_ASSERT(!initialized());

2
mfbt/Util.h
View File

@ -324,7 +324,7 @@ ArrayEnd(T (&arr)[N])
/* /*
* MOZ_ARRAY_LENGTH() is an alternative to mozilla::ArrayLength() for C files * MOZ_ARRAY_LENGTH() is an alternative to mozilla::ArrayLength() for C files
* that can't use C++ template functions and for MOZ_STATIC_ASSERT() calls that * that can't use C++ template functions and for static_assert() calls that
* can't call ArrayLength() when it is not a C++11 constexpr function. * can't call ArrayLength() when it is not a C++11 constexpr function.
*/ */
#ifdef MOZ_HAVE_CXX11_CONSTEXPR #ifdef MOZ_HAVE_CXX11_CONSTEXPR

2
mfbt/Vector.h
View File

@ -1121,7 +1121,7 @@ template<typename T, size_t N, class AP, class TV>
inline void inline void
VectorBase<T, N, AP, TV>::swap(TV& other) VectorBase<T, N, AP, TV>::swap(TV& other)
{ {
MOZ_STATIC_ASSERT(N == 0, static_assert(N == 0,
"still need to implement this for N != 0"); "still need to implement this for N != 0");
// This only works when inline storage is always empty. // This only works when inline storage is always empty.

2
mfbt/WeakPtr.h
View File

@ -108,7 +108,7 @@ class SupportsWeakPtrBase
protected: protected:
~SupportsWeakPtrBase() { ~SupportsWeakPtrBase() {
MOZ_STATIC_ASSERT((IsBaseOf<SupportsWeakPtrBase<T, WeakReference>, T>::value), static_assert(IsBaseOf<SupportsWeakPtrBase<T, WeakReference>, T>::value,
"T must derive from SupportsWeakPtrBase<T, WeakReference>"); "T must derive from SupportsWeakPtrBase<T, WeakReference>");
if (weakRef) if (weakRef)
weakRef->detach(); weakRef->detach();

2
mfbt/tests/TestSHA1.cpp
View File

@ -193,7 +193,7 @@ main()
{ 0xc8, 0xf2, 0x09, 0x59, 0x4e, 0x64, 0x40, 0xaa, 0x7b, 0xf7, 0xb8, 0xe0, { 0xc8, 0xf2, 0x09, 0x59, 0x4e, 0x64, 0x40, 0xaa, 0x7b, 0xf7, 0xb8, 0xe0,
0xfa, 0x44, 0xb2, 0x31, 0x95, 0xad, 0x94, 0x81 }; 0xfa, 0x44, 0xb2, 0x31, 0x95, 0xad, 0x94, 0x81 };
MOZ_STATIC_ASSERT(sizeof(expected) == sizeof(SHA1Sum::Hash), static_assert(sizeof(expected) == sizeof(SHA1Sum::Hash),
"expected-data size should be the same as the actual hash " "expected-data size should be the same as the actual hash "
"size"); "size");

112
mfbt/tests/TestTypeTraits.cpp
View File

@ -14,53 +14,53 @@ using mozilla::IsUnsigned;
using mozilla::MakeSigned; using mozilla::MakeSigned;
using mozilla::MakeUnsigned; using mozilla::MakeUnsigned;
MOZ_STATIC_ASSERT(!IsSigned<bool>::value, "bool shouldn't be signed"); static_assert(!IsSigned<bool>::value, "bool shouldn't be signed");
MOZ_STATIC_ASSERT(IsUnsigned<bool>::value, "bool should be unsigned"); static_assert(IsUnsigned<bool>::value, "bool should be unsigned");
MOZ_STATIC_ASSERT(!IsSigned<const bool>::value, "const bool shouldn't be signed"); static_assert(!IsSigned<const bool>::value, "const bool shouldn't be signed");
MOZ_STATIC_ASSERT(IsUnsigned<const bool>::value, "const bool should be unsigned"); static_assert(IsUnsigned<const bool>::value, "const bool should be unsigned");
MOZ_STATIC_ASSERT(!IsSigned<volatile bool>::value, "volatile bool shouldn't be signed"); static_assert(!IsSigned<volatile bool>::value, "volatile bool shouldn't be signed");
MOZ_STATIC_ASSERT(IsUnsigned<volatile bool>::value, "volatile bool should be unsigned"); static_assert(IsUnsigned<volatile bool>::value, "volatile bool should be unsigned");
MOZ_STATIC_ASSERT(!IsSigned<unsigned char>::value, "unsigned char shouldn't be signed"); static_assert(!IsSigned<unsigned char>::value, "unsigned char shouldn't be signed");
MOZ_STATIC_ASSERT(IsUnsigned<unsigned char>::value, "unsigned char should be unsigned"); static_assert(IsUnsigned<unsigned char>::value, "unsigned char should be unsigned");
MOZ_STATIC_ASSERT(IsSigned<signed char>::value, "signed char should be signed"); static_assert(IsSigned<signed char>::value, "signed char should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<signed char>::value, "signed char shouldn't be unsigned"); static_assert(!IsUnsigned<signed char>::value, "signed char shouldn't be unsigned");
MOZ_STATIC_ASSERT(!IsSigned<unsigned short>::value, "unsigned short shouldn't be signed"); static_assert(!IsSigned<unsigned short>::value, "unsigned short shouldn't be signed");
MOZ_STATIC_ASSERT(IsUnsigned<unsigned short>::value, "unsigned short should be unsigned"); static_assert(IsUnsigned<unsigned short>::value, "unsigned short should be unsigned");
MOZ_STATIC_ASSERT(IsSigned<short>::value, "short should be signed"); static_assert(IsSigned<short>::value, "short should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<short>::value, "short shouldn't be unsigned"); static_assert(!IsUnsigned<short>::value, "short shouldn't be unsigned");
MOZ_STATIC_ASSERT(!IsSigned<unsigned int>::value, "unsigned int shouldn't be signed"); static_assert(!IsSigned<unsigned int>::value, "unsigned int shouldn't be signed");
MOZ_STATIC_ASSERT(IsUnsigned<unsigned int>::value, "unsigned int should be unsigned"); static_assert(IsUnsigned<unsigned int>::value, "unsigned int should be unsigned");
MOZ_STATIC_ASSERT(IsSigned<int>::value, "int should be signed"); static_assert(IsSigned<int>::value, "int should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<int>::value, "int shouldn't be unsigned"); static_assert(!IsUnsigned<int>::value, "int shouldn't be unsigned");
MOZ_STATIC_ASSERT(!IsSigned<unsigned long>::value, "unsigned long shouldn't be signed"); static_assert(!IsSigned<unsigned long>::value, "unsigned long shouldn't be signed");
MOZ_STATIC_ASSERT(IsUnsigned<unsigned long>::value, "unsigned long should be unsigned"); static_assert(IsUnsigned<unsigned long>::value, "unsigned long should be unsigned");
MOZ_STATIC_ASSERT(IsSigned<long>::value, "long should be signed"); static_assert(IsSigned<long>::value, "long should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<long>::value, "long shouldn't be unsigned"); static_assert(!IsUnsigned<long>::value, "long shouldn't be unsigned");
MOZ_STATIC_ASSERT(IsSigned<float>::value, "float should be signed"); static_assert(IsSigned<float>::value, "float should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<float>::value, "float shouldn't be unsigned"); static_assert(!IsUnsigned<float>::value, "float shouldn't be unsigned");
MOZ_STATIC_ASSERT(IsSigned<const float>::value, "const float should be signed"); static_assert(IsSigned<const float>::value, "const float should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<const float>::value, "const float shouldn't be unsigned"); static_assert(!IsUnsigned<const float>::value, "const float shouldn't be unsigned");
MOZ_STATIC_ASSERT(IsSigned<double>::value, "double should be signed"); static_assert(IsSigned<double>::value, "double should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<double>::value, "double shouldn't be unsigned"); static_assert(!IsUnsigned<double>::value, "double shouldn't be unsigned");
MOZ_STATIC_ASSERT(IsSigned<volatile double>::value, "volatile double should be signed"); static_assert(IsSigned<volatile double>::value, "volatile double should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<volatile double>::value, "volatile double shouldn't be unsigned"); static_assert(!IsUnsigned<volatile double>::value, "volatile double shouldn't be unsigned");
MOZ_STATIC_ASSERT(IsSigned<long double>::value, "long double should be signed"); static_assert(IsSigned<long double>::value, "long double should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<long double>::value, "long double shouldn't be unsigned"); static_assert(!IsUnsigned<long double>::value, "long double shouldn't be unsigned");
MOZ_STATIC_ASSERT(IsSigned<const volatile long double>::value, static_assert(IsSigned<const volatile long double>::value,
"const volatile long double should be signed"); "const volatile long double should be signed");
MOZ_STATIC_ASSERT(!IsUnsigned<const volatile long double>::value, static_assert(!IsUnsigned<const volatile long double>::value,
"const volatile long double shouldn't be unsigned"); "const volatile long double shouldn't be unsigned");
namespace CPlusPlus11IsBaseOf { namespace CPlusPlus11IsBaseOf {
@ -153,55 +153,55 @@ TestIsConvertible()
// "C doesn't convert to A (private inheritance)"); // "C doesn't convert to A (private inheritance)");
} }
MOZ_STATIC_ASSERT((IsSame<MakeSigned<const unsigned char>::Type, const signed char>::value), static_assert(IsSame<MakeSigned<const unsigned char>::Type, const signed char>::value,
"const unsigned char won't signify correctly"); "const unsigned char won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<volatile unsigned short>::Type, volatile signed short>::value), static_assert(IsSame<MakeSigned<volatile unsigned short>::Type, volatile signed short>::value,
"volatile unsigned short won't signify correctly"); "volatile unsigned short won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<const volatile unsigned int>::Type, const volatile signed int>::value), static_assert(IsSame<MakeSigned<const volatile unsigned int>::Type, const volatile signed int>::value,
"const volatile unsigned int won't signify correctly"); "const volatile unsigned int won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<unsigned long>::Type, signed long>::value), static_assert(IsSame<MakeSigned<unsigned long>::Type, signed long>::value,
"unsigned long won't signify correctly"); "unsigned long won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<const signed char>::Type, const signed char>::value), static_assert(IsSame<MakeSigned<const signed char>::Type, const signed char>::value,
"const signed char won't signify correctly"); "const signed char won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<volatile signed short>::Type, volatile signed short>::value), static_assert(IsSame<MakeSigned<volatile signed short>::Type, volatile signed short>::value,
"volatile signed short won't signify correctly"); "volatile signed short won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<const volatile signed int>::Type, const volatile signed int>::value), static_assert(IsSame<MakeSigned<const volatile signed int>::Type, const volatile signed int>::value,
"const volatile signed int won't signify correctly"); "const volatile signed int won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<signed long>::Type, signed long>::value), static_assert(IsSame<MakeSigned<signed long>::Type, signed long>::value,
"signed long won't signify correctly"); "signed long won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<char>::Type, signed char>::value), static_assert(IsSame<MakeSigned<char>::Type, signed char>::value,
"char won't signify correctly"); "char won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<volatile char>::Type, volatile signed char>::value), static_assert(IsSame<MakeSigned<volatile char>::Type, volatile signed char>::value,
"volatile char won't signify correctly"); "volatile char won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeSigned<const char>::Type, const signed char>::value), static_assert(IsSame<MakeSigned<const char>::Type, const signed char>::value,
"const char won't signify correctly"); "const char won't signify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<const signed char>::Type, const unsigned char>::value), static_assert(IsSame<MakeUnsigned<const signed char>::Type, const unsigned char>::value,
"const signed char won't unsignify correctly"); "const signed char won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<volatile signed short>::Type, volatile unsigned short>::value), static_assert(IsSame<MakeUnsigned<volatile signed short>::Type, volatile unsigned short>::value,
"volatile signed short won't unsignify correctly"); "volatile signed short won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<const volatile signed int>::Type, const volatile unsigned int>::value), static_assert(IsSame<MakeUnsigned<const volatile signed int>::Type, const volatile unsigned int>::value,
"const volatile signed int won't unsignify correctly"); "const volatile signed int won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<signed long>::Type, unsigned long>::value), static_assert(IsSame<MakeUnsigned<signed long>::Type, unsigned long>::value,
"signed long won't unsignify correctly"); "signed long won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<const unsigned char>::Type, const unsigned char>::value), static_assert(IsSame<MakeUnsigned<const unsigned char>::Type, const unsigned char>::value,
"const unsigned char won't unsignify correctly"); "const unsigned char won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<volatile unsigned short>::Type, volatile unsigned short>::value), static_assert(IsSame<MakeUnsigned<volatile unsigned short>::Type, volatile unsigned short>::value,
"volatile unsigned short won't unsignify correctly"); "volatile unsigned short won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<const volatile unsigned int>::Type, const volatile unsigned int>::value), static_assert(IsSame<MakeUnsigned<const volatile unsigned int>::Type, const volatile unsigned int>::value,
"const volatile unsigned int won't unsignify correctly"); "const volatile unsigned int won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<unsigned long>::Type, unsigned long>::value), static_assert(IsSame<MakeUnsigned<unsigned long>::Type, unsigned long>::value,
"signed long won't unsignify correctly"); "signed long won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<char>::Type, unsigned char>::value), static_assert(IsSame<MakeUnsigned<char>::Type, unsigned char>::value,
"char won't unsignify correctly"); "char won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<volatile char>::Type, volatile unsigned char>::value), static_assert(IsSame<MakeUnsigned<volatile char>::Type, volatile unsigned char>::value,
"volatile char won't unsignify correctly"); "volatile char won't unsignify correctly");
MOZ_STATIC_ASSERT((IsSame<MakeUnsigned<const char>::Type, const unsigned char>::value), static_assert(IsSame<MakeUnsigned<const char>::Type, const unsigned char>::value,
"const char won't unsignify correctly"); "const char won't unsignify correctly");
int int

2
mozglue/linker/SeekableZStream.h
View File

@ -52,7 +52,7 @@ struct SeekableZStreamHeader: public Zip::SignedEntity<SeekableZStreamHeader>
}; };
#pragma pack() #pragma pack()
MOZ_STATIC_ASSERT(sizeof(SeekableZStreamHeader) == 5 * 4, static_assert(sizeof(SeekableZStreamHeader) == 5 * 4,
"SeekableZStreamHeader should be 5 32-bits words"); "SeekableZStreamHeader should be 5 32-bits words");
/** /**

2
netwerk/dns/nsEffectiveTLDService.cpp
View File

@ -46,7 +46,7 @@ void
nsDomainEntry::FuncForStaticAsserts(void) nsDomainEntry::FuncForStaticAsserts(void)
{ {
#define ETLD_ENTRY(name, ex, wild) \ #define ETLD_ENTRY(name, ex, wild) \
MOZ_STATIC_ASSERT(ETLD_ENTRY_OFFSET(name) < (1 << ETLD_ENTRY_N_INDEX_BITS), \ static_assert(ETLD_ENTRY_OFFSET(name) < (1 << ETLD_ENTRY_N_INDEX_BITS), \
"invalid strtab index"); "invalid strtab index");
#include "etld_data.inc" #include "etld_data.inc"
#undef ETLD_ENTRY #undef ETLD_ENTRY

2
netwerk/protocol/http/SpdySession3.cpp
View File

@ -558,7 +558,7 @@ SpdySession3::EnsureBuffer(nsAutoArrayPtr<T> &buf,
objSize = (newSize + 2048 + 4095) & ~4095; objSize = (newSize + 2048 + 4095) & ~4095;
MOZ_STATIC_ASSERT(sizeof(T) == 1, "sizeof(T) must be 1"); static_assert(sizeof(T) == 1, "sizeof(T) must be 1");
nsAutoArrayPtr<T> tmp(new T[objSize]); nsAutoArrayPtr<T> tmp(new T[objSize]);
memcpy(tmp, buf, preserve); memcpy(tmp, buf, preserve);
buf = tmp; buf = tmp;

2
security/manager/ssl/src/CryptoTask.h
View File

@ -37,7 +37,7 @@ public:
template <size_t LEN> template <size_t LEN>
nsresult Dispatch(const char (&taskThreadName)[LEN]) nsresult Dispatch(const char (&taskThreadName)[LEN])
{ {
MOZ_STATIC_ASSERT(LEN <= 15, static_assert(LEN <= 15,
"Thread name must be no more than 15 characters"); "Thread name must be no more than 15 characters");
return Dispatch(nsDependentCString(taskThreadName)); return Dispatch(nsDependentCString(taskThreadName));
} }

2
security/manager/ssl/src/JARSignatureVerification.cpp
View File

@ -92,7 +92,7 @@ FindAndLoadOneEntry(nsIZipReader * zip,
// Also, keep in mind bug 164695 and that we must leave room for // Also, keep in mind bug 164695 and that we must leave room for
// null-terminating the buffer. // null-terminating the buffer.
static const uint32_t MAX_LENGTH = 1024 * 1024; static const uint32_t MAX_LENGTH = 1024 * 1024;
MOZ_STATIC_ASSERT(MAX_LENGTH < UINT32_MAX, "MAX_LENGTH < UINT32_MAX"); static_assert(MAX_LENGTH < UINT32_MAX, "MAX_LENGTH < UINT32_MAX");
NS_ENSURE_TRUE(len64 < MAX_LENGTH, NS_ERROR_FILE_CORRUPTED); NS_ENSURE_TRUE(len64 < MAX_LENGTH, NS_ERROR_FILE_CORRUPTED);
NS_ENSURE_TRUE(len64 < UINT32_MAX, NS_ERROR_FILE_CORRUPTED); // bug 164695 NS_ENSURE_TRUE(len64 < UINT32_MAX, NS_ERROR_FILE_CORRUPTED); // bug 164695
SECITEM_AllocItem(buf, static_cast<uint32_t>(len64 + 1)); SECITEM_AllocItem(buf, static_cast<uint32_t>(len64 + 1));

2
security/manager/ssl/src/nsNSSComponent.cpp
View File

@ -1058,7 +1058,7 @@ nsNSSComponent::InitializeNSS(bool showWarningBox)
PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsNSSComponent::InitializeNSS\n")); PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsNSSComponent::InitializeNSS\n"));
MOZ_STATIC_ASSERT(nsINSSErrorsService::NSS_SEC_ERROR_BASE == SEC_ERROR_BASE && static_assert(nsINSSErrorsService::NSS_SEC_ERROR_BASE == SEC_ERROR_BASE &&
nsINSSErrorsService::NSS_SEC_ERROR_LIMIT == SEC_ERROR_LIMIT && nsINSSErrorsService::NSS_SEC_ERROR_LIMIT == SEC_ERROR_LIMIT &&
nsINSSErrorsService::NSS_SSL_ERROR_BASE == SSL_ERROR_BASE && nsINSSErrorsService::NSS_SSL_ERROR_BASE == SSL_ERROR_BASE &&
nsINSSErrorsService::NSS_SSL_ERROR_LIMIT == SSL_ERROR_LIMIT, nsINSSErrorsService::NSS_SSL_ERROR_LIMIT == SSL_ERROR_LIMIT,

6
toolkit/identity/IdentityCryptoService.cpp
View File

@ -455,9 +455,9 @@ GenerateDSAKeyPair(PK11SlotInfo * slot,
0x72,0xDF,0xFA,0x89,0x62,0x33,0x39,0x7A 0x72,0xDF,0xFA,0x89,0x62,0x33,0x39,0x7A
}; };
MOZ_STATIC_ASSERT(MOZ_ARRAY_LENGTH(P) == 1024 / CHAR_BIT, "bad DSA P"); static_assert(MOZ_ARRAY_LENGTH(P) == 1024 / CHAR_BIT, "bad DSA P");
MOZ_STATIC_ASSERT(MOZ_ARRAY_LENGTH(Q) == 160 / CHAR_BIT, "bad DSA Q"); static_assert(MOZ_ARRAY_LENGTH(Q) == 160 / CHAR_BIT, "bad DSA Q");
MOZ_STATIC_ASSERT(MOZ_ARRAY_LENGTH(G) == 1024 / CHAR_BIT, "bad DSA G"); static_assert(MOZ_ARRAY_LENGTH(G) == 1024 / CHAR_BIT, "bad DSA G");
PQGParams pqgParams = { PQGParams pqgParams = {
NULL /*arena*/, NULL /*arena*/,

4
toolkit/xre/nsAppRunner.cpp
View File

@ -757,7 +757,7 @@ nsXULAppInfo::GetWidgetToolkit(nsACString& aResult)
// is synchronized with the const unsigned longs defined in // is synchronized with the const unsigned longs defined in
// xpcom/system/nsIXULRuntime.idl. // xpcom/system/nsIXULRuntime.idl.
#define SYNC_ENUMS(a,b) \ #define SYNC_ENUMS(a,b) \
MOZ_STATIC_ASSERT(nsIXULRuntime::PROCESS_TYPE_ ## a == \ static_assert(nsIXULRuntime::PROCESS_TYPE_ ## a == \
static_cast<int>(GeckoProcessType_ ## b), \ static_cast<int>(GeckoProcessType_ ## b), \
"GeckoProcessType in nsXULAppAPI.h not synchronized with nsIXULRuntime.idl"); "GeckoProcessType in nsXULAppAPI.h not synchronized with nsIXULRuntime.idl");
@ -767,7 +767,7 @@ SYNC_ENUMS(CONTENT, Content)
SYNC_ENUMS(IPDLUNITTEST, IPDLUnitTest) SYNC_ENUMS(IPDLUNITTEST, IPDLUnitTest)
// .. and ensure that that is all of them: // .. and ensure that that is all of them:
MOZ_STATIC_ASSERT(GeckoProcessType_IPDLUnitTest + 1 == GeckoProcessType_End, static_assert(GeckoProcessType_IPDLUnitTest + 1 == GeckoProcessType_End,
"Did not find the final GeckoProcessType"); "Did not find the final GeckoProcessType");
NS_IMETHODIMP NS_IMETHODIMP

6
tools/profiler/UnwinderThread2.cpp
View File

@ -217,9 +217,9 @@ utb__addEntry(/*MODIFIED*/UnwinderThreadBuffer* utb, ProfileEntry ent)
////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////
//// BEGIN type UnwindThreadBuffer //// BEGIN type UnwindThreadBuffer
MOZ_STATIC_ASSERT(sizeof(uint32_t) == 4, "uint32_t size incorrect"); static_assert(sizeof(uint32_t) == 4, "uint32_t size incorrect");
MOZ_STATIC_ASSERT(sizeof(uint64_t) == 8, "uint64_t size incorrect"); static_assert(sizeof(uint64_t) == 8, "uint64_t size incorrect");
MOZ_STATIC_ASSERT(sizeof(uintptr_t) == sizeof(void*), static_assert(sizeof(uintptr_t) == sizeof(void*),
"uintptr_t size incorrect"); "uintptr_t size incorrect");
typedef typedef

8
widget/gonk/nsAppShell.cpp
View File

@ -401,16 +401,16 @@ private:
void void
GeckoInputReaderPolicy::setDisplayInfo() GeckoInputReaderPolicy::setDisplayInfo()
{ {
MOZ_STATIC_ASSERT(nsIScreen::ROTATION_0_DEG == static_assert(nsIScreen::ROTATION_0_DEG ==
DISPLAY_ORIENTATION_0, DISPLAY_ORIENTATION_0,
"Orientation enums not matched!"); "Orientation enums not matched!");
MOZ_STATIC_ASSERT(nsIScreen::ROTATION_90_DEG == static_assert(nsIScreen::ROTATION_90_DEG ==
DISPLAY_ORIENTATION_90, DISPLAY_ORIENTATION_90,
"Orientation enums not matched!"); "Orientation enums not matched!");
MOZ_STATIC_ASSERT(nsIScreen::ROTATION_180_DEG == static_assert(nsIScreen::ROTATION_180_DEG ==
DISPLAY_ORIENTATION_180, DISPLAY_ORIENTATION_180,
"Orientation enums not matched!"); "Orientation enums not matched!");
MOZ_STATIC_ASSERT(nsIScreen::ROTATION_270_DEG == static_assert(nsIScreen::ROTATION_270_DEG ==
DISPLAY_ORIENTATION_270, DISPLAY_ORIENTATION_270,
"Orientation enums not matched!"); "Orientation enums not matched!");

2
widget/nsGUIEvent.h
View File

@ -594,7 +594,7 @@ private:
inline void SetRawFlags(RawFlags aRawFlags) inline void SetRawFlags(RawFlags aRawFlags)
{ {
MOZ_STATIC_ASSERT(sizeof(BaseEventFlags) <= sizeof(RawFlags), static_assert(sizeof(BaseEventFlags) <= sizeof(RawFlags),
"mozilla::widget::EventFlags must not be bigger than the RawFlags"); "mozilla::widget::EventFlags must not be bigger than the RawFlags");
memcpy(this, &aRawFlags, sizeof(BaseEventFlags)); memcpy(this, &aRawFlags, sizeof(BaseEventFlags));
} }

6
xpcom/base/MapsMemoryReporter.cpp
View File

@ -264,9 +264,9 @@ MapsReporter::ParseMapping(
{ {
// We need to use native types in order to get good warnings from fscanf, so // We need to use native types in order to get good warnings from fscanf, so
// let's make sure that the native types have the sizes we expect. // let's make sure that the native types have the sizes we expect.
MOZ_STATIC_ASSERT(sizeof(long long) == sizeof(int64_t), static_assert(sizeof(long long) == sizeof(int64_t),
"size of (long long) is expected to match (int64_t)"); "size of (long long) is expected to match (int64_t)");
MOZ_STATIC_ASSERT(sizeof(int) == sizeof(int32_t), static_assert(sizeof(int) == sizeof(int32_t),
"size of (int) is expected to match (int32_t)"); "size of (int) is expected to match (int32_t)");
// Don't bail if FindLibxul fails. We can still gather meaningful stats // Don't bail if FindLibxul fails. We can still gather meaningful stats
@ -465,7 +465,7 @@ MapsReporter::ParseMapBody(
nsISupports *aClosure, nsISupports *aClosure,
CategoriesSeen *aCategoriesSeen) CategoriesSeen *aCategoriesSeen)
{ {
MOZ_STATIC_ASSERT(sizeof(long long) == sizeof(int64_t), static_assert(sizeof(long long) == sizeof(int64_t),
"size of (long long) is expected to match (int64_t)"); "size of (long long) is expected to match (int64_t)");
const int argCount = 2; const int argCount = 2;

2
xpcom/base/nsCycleCollector.cpp
View File

@ -674,7 +674,7 @@ private:
Block() : mNext(nullptr) { Block() : mNext(nullptr) {
// Ensure Block is the right size (see above). // Ensure Block is the right size (see above).
MOZ_STATIC_ASSERT( static_assert(
sizeof(Block) == 16384 || // 32-bit sizeof(Block) == 16384 || // 32-bit
sizeof(Block) == 32768, // 64-bit sizeof(Block) == 32768, // 64-bit
"ill-sized nsPurpleBuffer::Block" "ill-sized nsPurpleBuffer::Block"

4
xpcom/base/nsErrorAsserts.cpp
View File

@ -4,7 +4,7 @@
// No reason to pull in Assertions.h for every single file that includes // No reason to pull in Assertions.h for every single file that includes
// nsError.h, so let's put this in its own .cpp file instead of in the .h. // nsError.h, so let's put this in its own .cpp file instead of in the .h.
MOZ_STATIC_ASSERT(((nsresult)0) < ((nsresult)-1), static_assert(((nsresult)0) < ((nsresult)-1),
"nsresult must be an unsigned type"); "nsresult must be an unsigned type");
MOZ_STATIC_ASSERT(sizeof(nsresult) == sizeof(uint32_t), static_assert(sizeof(nsresult) == sizeof(uint32_t),
"nsresult must be 32 bits"); "nsresult must be 32 bits");

Some files were not shown because too many files have changed in this diff Show More