Skip to content

Commit 6f4709d

Browse files
MarenzMarenz
committed
Remove empty assert messages
1 parent a550048 commit 6f4709d

File tree

3 files changed

+165
-167
lines changed

3 files changed

+165
-167
lines changed

‎libsolidity/codegen/CompilerUtils.cpp

Lines changed: 47 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,7 @@ static_assert(CompilerUtils::generalPurposeMemoryStart >= CompilerUtils::zeroPoi
5454
void CompilerUtils::initialiseFreeMemoryPointer()
5555
{
5656
size_t reservedMemory = m_context.reservedMemory();
57-
solAssert(bigint(generalPurposeMemoryStart) + bigint(reservedMemory) < bigint(1) << 63, "");
57+
solAssert(bigint(generalPurposeMemoryStart) + bigint(reservedMemory) < bigint(1) << 63);
5858
m_context << (u256(generalPurposeMemoryStart) + reservedMemory);
5959
storeFreeMemoryPointer();
6060
}
@@ -92,7 +92,7 @@ void CompilerUtils::toSizeAfterFreeMemoryPointer()
9292

9393
void CompilerUtils::revertWithStringData(Type const& _argumentType)
9494
{
95-
solAssert(_argumentType.isImplicitlyConvertibleTo(*TypeProvider::fromElementaryTypeName("string memory")), "");
95+
solAssert(_argumentType.isImplicitlyConvertibleTo(*TypeProvider::fromElementaryTypeName("string memory")));
9696
fetchFreeMemoryPointer();
9797
m_context << util::selectorFromSignature("Error(string)");
9898
m_context << Instruction::DUP2 << Instruction::MSTORE;
@@ -173,9 +173,9 @@ void CompilerUtils::loadFromMemoryDynamic(
173173

174174
if (auto arrayType = dynamic_cast<ArrayType const*>(&_type))
175175
{
176-
solAssert(!arrayType->isDynamicallySized(), "");
177-
solAssert(!_fromCalldata, "");
178-
solAssert(_padToWordBoundaries, "");
176+
solAssert(!arrayType->isDynamicallySized());
177+
solAssert(!_fromCalldata);
178+
solAssert(_padToWordBoundaries);
179179
if (_keepUpdatedMemoryOffset)
180180
m_context << arrayType->memoryDataSize() << Instruction::ADD;
181181
}
@@ -251,7 +251,7 @@ void CompilerUtils::abiDecode(TypePointers const& _typeParameters, bool _fromMem
251251
// Use the new Yul-based decoding function
252252
auto stackHeightBefore = m_context.stackHeight();
253253
abiDecodeV2(_typeParameters, _fromMemory);
254-
solAssert(m_context.stackHeight() - stackHeightBefore == sizeOnStack(_typeParameters) - 2, "");
254+
solAssert(m_context.stackHeight() - stackHeightBefore == sizeOnStack(_typeParameters) - 2);
255255
return;
256256
}
257257

@@ -290,7 +290,7 @@ void CompilerUtils::abiDecode(TypePointers const& _typeParameters, bool _fromMem
290290
);
291291
// @todo If base type is an array or struct, it is still calldata-style encoded, so
292292
// we would have to convert it like below.
293-
solAssert(arrayType.location() == DataLocation::Memory, "");
293+
solAssert(arrayType.location() == DataLocation::Memory);
294294
if (arrayType.isDynamicallySized())
295295
{
296296
// compute data pointer
@@ -430,7 +430,7 @@ void CompilerUtils::encodeToMemory(
430430
// stack: <v1> <v2> ... <vn> <mem>
431431
bool const encoderV2 = m_context.useABICoderV2();
432432
TypePointers targetTypes = _targetTypes.empty() ? _givenTypes : _targetTypes;
433-
solAssert(targetTypes.size() == _givenTypes.size(), "");
433+
solAssert(targetTypes.size() == _givenTypes.size());
434434
for (Type const*& t: targetTypes)
435435
{
436436
Type const* tEncoding = t->fullEncodingType(_encodeAsLibraryTypes, encoderV2, !_padToWordBoundaries);
@@ -449,7 +449,7 @@ void CompilerUtils::encodeToMemory(
449449
);
450450
auto stackHeightBefore = m_context.stackHeight();
451451
abiEncodeV2(_givenTypes, targetTypes, _encodeAsLibraryTypes, _padToWordBoundaries);
452-
solAssert(stackHeightBefore - m_context.stackHeight() == sizeOnStack(_givenTypes), "");
452+
solAssert(stackHeightBefore - m_context.stackHeight() == sizeOnStack(_givenTypes));
453453
return;
454454
}
455455

@@ -489,8 +489,8 @@ void CompilerUtils::encodeToMemory(
489489
{
490490
// special case: convert storage reference type to value type - this is only
491491
// possible for library calls where we just forward the storage reference
492-
solAssert(_encodeAsLibraryTypes, "");
493-
solAssert(_givenTypes[i]->sizeOnStack() == 1, "");
492+
solAssert(_encodeAsLibraryTypes);
493+
solAssert(_givenTypes[i]->sizeOnStack() == 1);
494494
}
495495
else if (
496496
_givenTypes[i]->dataStoredIn(DataLocation::Storage) ||
@@ -638,7 +638,7 @@ void CompilerUtils::zeroInitialiseMemoryArray(ArrayType const& _type)
638638
{
639639
if (_type.baseType()->hasSimpleZeroValueInMemory())
640640
{
641-
solAssert(_type.baseType()->isValueType(), "");
641+
solAssert(_type.baseType()->isValueType());
642642
Whiskers templ(R"({
643643
let size := mul(length, <element_size>)
644644
// cheap way of zero-initializing a memory range
@@ -774,9 +774,9 @@ void CompilerUtils::convertType(
774774

775775
if (stackTypeCategory == Type::Category::UserDefinedValueType)
776776
{
777-
solAssert(_cleanupNeeded, "");
777+
solAssert(_cleanupNeeded);
778778
auto& userDefined = dynamic_cast<UserDefinedValueType const&>(_typeOnStack);
779-
solAssert(_typeOnStack == _targetType || _targetType == userDefined.underlyingType(), "");
779+
solAssert(_typeOnStack == _targetType || _targetType == userDefined.underlyingType());
780780
return convertType(
781781
userDefined.underlyingType(),
782782
_targetType,
@@ -787,9 +787,9 @@ void CompilerUtils::convertType(
787787
}
788788
if (targetTypeCategory == Type::Category::UserDefinedValueType)
789789
{
790-
solAssert(_cleanupNeeded, "");
790+
solAssert(_cleanupNeeded);
791791
auto& userDefined = dynamic_cast<UserDefinedValueType const&>(_targetType);
792-
solAssert(_typeOnStack.isImplicitlyConvertibleTo(userDefined.underlyingType()), "");
792+
solAssert(_typeOnStack.isImplicitlyConvertibleTo(userDefined.underlyingType()));
793793
return convertType(
794794
_typeOnStack,
795795
userDefined.underlyingType(),
@@ -829,7 +829,7 @@ void CompilerUtils::convertType(
829829
}
830830
else if (targetTypeCategory == Type::Category::Address)
831831
{
832-
solAssert(typeOnStack.numBytes() * 8 == 160, "");
832+
solAssert(typeOnStack.numBytes() * 8 == 160);
833833
rightShiftNumberOnStack(256 - 160);
834834
}
835835
else
@@ -849,7 +849,7 @@ void CompilerUtils::convertType(
849849
break;
850850
}
851851
case Type::Category::Enum:
852-
solAssert(_targetType == _typeOnStack || targetTypeCategory == Type::Category::Integer, "");
852+
solAssert(_targetType == _typeOnStack || targetTypeCategory == Type::Category::Integer);
853853
if (enumOverflowCheckPending)
854854
{
855855
EnumType const& enumType = dynamic_cast<decltype(enumType)>(_typeOnStack);
@@ -885,13 +885,13 @@ void CompilerUtils::convertType(
885885
cleanHigherOrderBits(*typeOnStack);
886886
}
887887
else if (stackTypeCategory == Type::Category::Address)
888-
solAssert(targetBytesType.numBytes() * 8 == 160, "");
888+
solAssert(targetBytesType.numBytes() * 8 == 160);
889889
leftShiftNumberOnStack(256 - targetBytesType.numBytes() * 8);
890890
}
891891
else if (targetTypeCategory == Type::Category::Enum)
892892
{
893893
solAssert(stackTypeCategory != Type::Category::Address, "Invalid conversion to EnumType requested.");
894-
solAssert(_typeOnStack.mobileType(), "");
894+
solAssert(_typeOnStack.mobileType());
895895
// just clean
896896
convertType(_typeOnStack, *_typeOnStack.mobileType(), true);
897897
EnumType const& enumType = dynamic_cast<decltype(enumType)>(_targetType);
@@ -964,13 +964,13 @@ void CompilerUtils::convertType(
964964
if (targetTypeCategory == Type::Category::FixedBytes)
965965
{
966966
unsigned const numBytes = dynamic_cast<FixedBytesType const&>(_targetType).numBytes();
967-
solAssert(data.size() <= 32, "");
967+
solAssert(data.size() <= 32);
968968
m_context << (u256(h256(data, h256::AlignLeft)) & (~(u256(-1) >> (8 * numBytes))));
969969
}
970970
else if (targetTypeCategory == Type::Category::Array)
971971
{
972972
auto const& arrayType = dynamic_cast<ArrayType const&>(_targetType);
973-
solAssert(arrayType.isByteArray(), "");
973+
solAssert(arrayType.isByteArray());
974974
size_t storageSize = 32 + ((data.size() + 31) / 32) * 32;
975975
allocateMemory(storageSize);
976976
// stack: mempos
@@ -995,10 +995,10 @@ void CompilerUtils::convertType(
995995
typeOnStack.isByteArray() && !typeOnStack.isString(),
996996
"Array types other than bytes not convertible to bytesNN."
997997
);
998-
solAssert(typeOnStack.isDynamicallySized(), "");
998+
solAssert(typeOnStack.isDynamicallySized());
999999

10001000
bool fromCalldata = typeOnStack.dataStoredIn(DataLocation::CallData);
1001-
solAssert(typeOnStack.sizeOnStack() == (fromCalldata ? 2 : 1), "");
1001+
solAssert(typeOnStack.sizeOnStack() == (fromCalldata ? 2 : 1));
10021002
if (fromCalldata)
10031003
m_context << Instruction::SWAP1;
10041004

@@ -1012,7 +1012,7 @@ void CompilerUtils::convertType(
10121012
);
10131013
break;
10141014
}
1015-
solAssert(targetTypeCategory == stackTypeCategory, "");
1015+
solAssert(targetTypeCategory == stackTypeCategory);
10161016
auto const& targetType = dynamic_cast<ArrayType const&>(_targetType);
10171017
switch (targetType.location())
10181018
{
@@ -1034,9 +1034,9 @@ void CompilerUtils::convertType(
10341034
typeOnStack.baseType()->isDynamicallyEncoded()
10351035
)
10361036
{
1037-
solAssert(m_context.useABICoderV2(), "");
1037+
solAssert(m_context.useABICoderV2());
10381038
// stack: offset length(optional in case of dynamically sized array)
1039-
solAssert(typeOnStack.sizeOnStack() == (typeOnStack.isDynamicallySized() ? 2 : 1), "");
1039+
solAssert(typeOnStack.sizeOnStack() == (typeOnStack.isDynamicallySized() ? 2 : 1));
10401040
if (typeOnStack.isDynamicallySized())
10411041
m_context << Instruction::SWAP1;
10421042

@@ -1122,9 +1122,9 @@ void CompilerUtils::convertType(
11221122
typeOnStack.arrayType().isByteArray() && !typeOnStack.arrayType().isString(),
11231123
"Array types other than bytes not convertible to bytesNN."
11241124
);
1125-
solAssert(typeOnStack.isDynamicallySized(), "");
1126-
solAssert(typeOnStack.dataStoredIn(DataLocation::CallData), "");
1127-
solAssert(typeOnStack.sizeOnStack() == 2, "");
1125+
solAssert(typeOnStack.isDynamicallySized());
1126+
solAssert(typeOnStack.dataStoredIn(DataLocation::CallData));
1127+
solAssert(typeOnStack.sizeOnStack() == 2);
11281128

11291129
m_context << Instruction::SWAP1;
11301130
m_context.callYulFunction(
@@ -1138,7 +1138,7 @@ void CompilerUtils::convertType(
11381138
break;
11391139
}
11401140

1141-
solAssert(_targetType.category() == Type::Category::Array, "");
1141+
solAssert(_targetType.category() == Type::Category::Array);
11421142
auto const& targetArrayType = dynamic_cast<ArrayType const&>(_targetType);
11431143
solAssert(
11441144
typeOnStack.arrayType().isImplicitlyConvertibleTo(targetArrayType) ||
@@ -1147,16 +1147,15 @@ void CompilerUtils::convertType(
11471147
solAssert(
11481148
typeOnStack.arrayType().dataStoredIn(DataLocation::CallData) &&
11491149
typeOnStack.arrayType().isDynamicallySized() &&
1150-
!typeOnStack.arrayType().baseType()->isDynamicallyEncoded(),
1151-
""
1150+
!typeOnStack.arrayType().baseType()->isDynamicallyEncoded()
11521151
);
11531152
if (!_targetType.dataStoredIn(DataLocation::CallData))
11541153
return convertType(typeOnStack.arrayType(), _targetType);
11551154
break;
11561155
}
11571156
case Type::Category::Struct:
11581157
{
1159-
solAssert(targetTypeCategory == stackTypeCategory, "");
1158+
solAssert(targetTypeCategory == stackTypeCategory);
11601159
auto& targetType = dynamic_cast<StructType const&>(_targetType);
11611160
auto& typeOnStack = dynamic_cast<StructType const&>(_typeOnStack);
11621161
switch (targetType.location())
@@ -1185,7 +1184,7 @@ void CompilerUtils::convertType(
11851184
// stack: <memory ptr> <source ref> <memory ptr>
11861185
for (auto const& member: typeOnStack->members(nullptr))
11871186
{
1188-
solAssert(!member.type->containsNestedMapping(), "");
1187+
solAssert(!member.type->containsNestedMapping());
11891188
pair<u256, unsigned> const& offsets = typeOnStack->storageOffsetsOfMember(member.name);
11901189
_context << offsets.first << Instruction::DUP3 << Instruction::ADD;
11911190
_context << u256(offsets.second);
@@ -1212,7 +1211,7 @@ void CompilerUtils::convertType(
12121211
{
12131212
if (typeOnStack.isDynamicallyEncoded())
12141213
{
1215-
solAssert(m_context.useABICoderV2(), "");
1214+
solAssert(m_context.useABICoderV2());
12161215
m_context.callYulFunction(
12171216
m_context.utilFunctions().conversionFunction(typeOnStack, targetType),
12181217
1,
@@ -1234,7 +1233,7 @@ void CompilerUtils::convertType(
12341233
}
12351234
break;
12361235
case DataLocation::CallData:
1237-
solAssert(_typeOnStack == _targetType, "");
1236+
solAssert(_typeOnStack == _targetType);
12381237
// nothing to do
12391238
break;
12401239
}
@@ -1244,15 +1243,15 @@ void CompilerUtils::convertType(
12441243
{
12451244
TupleType const& sourceTuple = dynamic_cast<TupleType const&>(_typeOnStack);
12461245
TupleType const& targetTuple = dynamic_cast<TupleType const&>(_targetType);
1247-
solAssert(targetTuple.components().size() == sourceTuple.components().size(), "");
1246+
solAssert(targetTuple.components().size() == sourceTuple.components().size());
12481247
unsigned depth = sourceTuple.sizeOnStack();
12491248
for (size_t i = 0; i < sourceTuple.components().size(); ++i)
12501249
{
12511250
Type const* sourceType = sourceTuple.components()[i];
12521251
Type const* targetType = targetTuple.components()[i];
12531252
if (!sourceType)
12541253
{
1255-
solAssert(!targetType, "");
1254+
solAssert(!targetType);
12561255
continue;
12571256
}
12581257
unsigned sourceSize = sourceType->sizeOnStack();
@@ -1294,7 +1293,7 @@ void CompilerUtils::convertType(
12941293
break;
12951294
default:
12961295
// we used to allow conversions from function to address
1297-
solAssert(!(stackTypeCategory == Type::Category::Function && targetTypeCategory == Type::Category::Address), "");
1296+
solAssert(!(stackTypeCategory == Type::Category::Function && targetTypeCategory == Type::Category::Address));
12981297
if (stackTypeCategory == Type::Category::Function && targetTypeCategory == Type::Category::Function)
12991298
{
13001299
FunctionType const& typeOnStack = dynamic_cast<FunctionType const&>(_typeOnStack);
@@ -1351,14 +1350,14 @@ void CompilerUtils::pushZeroValue(Type const& _type)
13511350
}
13521351
if (referenceType->location() == DataLocation::CallData)
13531352
{
1354-
solAssert(referenceType->sizeOnStack() == 1 || referenceType->sizeOnStack() == 2, "");
1353+
solAssert(referenceType->sizeOnStack() == 1 || referenceType->sizeOnStack() == 2);
13551354
m_context << Instruction::CALLDATASIZE;
13561355
if (referenceType->sizeOnStack() == 2)
13571356
m_context << 0;
13581357
return;
13591358
}
13601359

1361-
solAssert(referenceType->location() == DataLocation::Memory, "");
1360+
solAssert(referenceType->location() == DataLocation::Memory);
13621361
if (auto arrayType = dynamic_cast<ArrayType const*>(&_type))
13631362
if (arrayType->isDynamicallySized())
13641363
{
@@ -1386,7 +1385,7 @@ void CompilerUtils::pushZeroValue(Type const& _type)
13861385
}
13871386
else if (auto arrayType = dynamic_cast<ArrayType const*>(type))
13881387
{
1389-
solAssert(!arrayType->isDynamicallySized(), "");
1388+
solAssert(!arrayType->isDynamicallySized());
13901389
if (arrayType->length() > 0)
13911390
{
13921391
_context << arrayType->length() << Instruction::SWAP1;
@@ -1486,7 +1485,7 @@ void CompilerUtils::popStackSlots(size_t _amount)
14861485

14871486
void CompilerUtils::popAndJump(unsigned _toHeight, evmasm::AssemblyItem const& _jumpTo)
14881487
{
1489-
solAssert(m_context.stackHeight() >= _toHeight, "");
1488+
solAssert(m_context.stackHeight() >= _toHeight);
14901489
unsigned amount = m_context.stackHeight() - _toHeight;
14911490
popStackSlots(amount);
14921491
m_context.appendJumpTo(_jumpTo);
@@ -1554,7 +1553,7 @@ void CompilerUtils::storeStringData(bytesConstRef _data)
15541553

15551554
unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCalldata, bool _padToWords)
15561555
{
1557-
solAssert(_type.isValueType(), "");
1556+
solAssert(_type.isValueType());
15581557
Type const* type = &_type;
15591558
if (auto const* userDefined = dynamic_cast<UserDefinedValueType const*>(type))
15601559
type = &userDefined->underlyingType();
@@ -1606,7 +1605,7 @@ void CompilerUtils::cleanHigherOrderBits(IntegerType const& _typeOnStack)
16061605

16071606
void CompilerUtils::leftShiftNumberOnStack(unsigned _bits)
16081607
{
1609-
solAssert(_bits < 256, "");
1608+
solAssert(_bits < 256);
16101609
if (m_context.evmVersion().hasBitwiseShifting())
16111610
m_context << _bits << Instruction::SHL;
16121611
else
@@ -1615,7 +1614,7 @@ void CompilerUtils::leftShiftNumberOnStack(unsigned _bits)
16151614

16161615
void CompilerUtils::rightShiftNumberOnStack(unsigned _bits)
16171616
{
1618-
solAssert(_bits < 256, "");
1617+
solAssert(_bits < 256);
16191618
// NOTE: If we add signed right shift, SAR rounds differently than SDIV
16201619
if (m_context.evmVersion().hasBitwiseShifting())
16211620
m_context << _bits << Instruction::SHR;
@@ -1630,7 +1629,7 @@ unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWords,
16301629
"Memory store of types with stack size != 1 not allowed (Type: " + _type.toString(true) + ")."
16311630
);
16321631

1633-
solAssert(!_type.isDynamicallyEncoded(), "");
1632+
solAssert(!_type.isDynamicallyEncoded());
16341633

16351634
unsigned numBytes = _type.calldataEncodedSize(_padToWords);
16361635

‎libsolidity/codegen/YulUtilFunctions.cpp

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3219,7 +3219,7 @@ string YulUtilFunctions::conversionFunction(Type const& _from, Type const& _to)
32193219
solAssert(fromType.arrayType().isByteArray(), "Array types other than bytes not convertible to bytesNN.");
32203220
return bytesToFixedBytesConversionFunction(fromType.arrayType(), dynamic_cast<FixedBytesType const &>(_to));
32213221
}
3222-
solAssert(_to.category() == Type::Category::Array, "");
3222+
solAssert(_to.category() == Type::Category::Array);
32233223
auto const& targetType = dynamic_cast<ArrayType const&>(_to);
32243224

32253225
solAssert(
@@ -3229,8 +3229,7 @@ string YulUtilFunctions::conversionFunction(Type const& _from, Type const& _to)
32293229
solAssert(
32303230
fromType.arrayType().dataStoredIn(DataLocation::CallData) &&
32313231
fromType.arrayType().isDynamicallySized() &&
3232-
!fromType.arrayType().baseType()->isDynamicallyEncoded(),
3233-
""
3232+
!fromType.arrayType().baseType()->isDynamicallyEncoded()
32343233
);
32353234

32363235
if (!targetType.dataStoredIn(DataLocation::CallData))

0 commit comments

Comments
 (0)