Skip to content

Commit 1362403

Browse files
nikola-maticnikola-matic
committed
Require with custom error for legacy pipeline
1 parent d0190e1 commit 1362403

17 files changed

+132
-27
lines changed

‎Changelog.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
### 0.8.27 (unreleased)
22

33
Language Features:
4+
* Make ``require(bool, Error)`` available when using the legacy pipeline.
45

56

67
Compiler Features:

‎libsolidity/codegen/ExpressionCompiler.cpp‎

Lines changed: 42 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -990,6 +990,8 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
990990
}
991991
case FunctionType::Kind::Error:
992992
{
993+
// This case is part of the ``revert Error()`` path of the codegen.
994+
// For ``require(bool, Error())`` refer to the ``Kind::Require`` case.
993995
_functionCall.expression().accept(*this);
994996
std::vector<Type const*> argumentTypes;
995997
for (ASTPointer<Expression const> const& arg: _functionCall.sortedArguments())
@@ -1249,21 +1251,56 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
12491251
case FunctionType::Kind::Require:
12501252
{
12511253
acceptAndConvert(*arguments.front(), *function.parameterTypes().front(), false);
1252-
1254+
// stack: <condition>
12531255
bool haveReasonString = arguments.size() > 1 && m_context.revertStrings() != RevertStrings::Strip;
1254-
12551256
if (arguments.size() > 1)
12561257
{
12571258
// Users probably expect the second argument to be evaluated
12581259
// even if the condition is false, as would be the case for an actual
12591260
// function call.
12601261
solAssert(arguments.size() == 2, "");
12611262
solAssert(function.kind() == FunctionType::Kind::Require, "");
1262-
// Check if the function call matches ``require(bool, error)``, and throw an unimplemented error,
1263-
// as require with custom errors is not supported in legacy codegen.
12641263
auto const* magicType = dynamic_cast<MagicType const*>(arguments[1]->annotation().type);
12651264
if (magicType && magicType->kind() == MagicType::Kind::Error)
1266-
solUnimplemented("Require with a custom error is only available using the via-ir pipeline.");
1265+
{
1266+
// Make sure that error constructor arguments are evaluated regardless of the require condition
1267+
auto const& errorConstructorCall = dynamic_cast<FunctionCall const&>(*arguments[1]);
1268+
errorConstructorCall.expression().accept(*this);
1269+
std::vector<Type const*> errorConstructorArgumentTypes{};
1270+
for (ASTPointer<Expression const> const& errorConstructorArgument: errorConstructorCall.sortedArguments())
1271+
{
1272+
errorConstructorArgument->accept(*this);
1273+
errorConstructorArgumentTypes.push_back(errorConstructorArgument->annotation().type);
1274+
}
1275+
unsigned const sizeOfConditionArgument = arguments.at(0)->annotation().type->sizeOnStack();
1276+
unsigned const sizeOfErrorArguments = CompilerUtils::sizeOnStack(errorConstructorArgumentTypes);
1277+
if (sizeOfErrorArguments + sizeOfConditionArgument > 16)
1278+
BOOST_THROW_EXCEPTION(
1279+
StackTooDeepError() <<
1280+
errinfo_sourceLocation(errorConstructorCall.location()) <<
1281+
util::errinfo_comment(util::stackTooDeepString)
1282+
);
1283+
// stack: <condition> <arg0> <arg1> ... <argN>
1284+
// Move condition to the top of the stack
1285+
utils().moveToStackTop(sizeOfErrorArguments, sizeOfConditionArgument);
1286+
// stack: <arg0> <arg1> ... <argN> <condition>
1287+
m_context << Instruction::ISZERO << Instruction::ISZERO;
1288+
AssemblyItem successBranchTag = m_context.appendConditionalJump();
1289+
1290+
auto const* errorDefinition = dynamic_cast<ErrorDefinition const*>(ASTNode::referencedDeclaration(errorConstructorCall.expression()));
1291+
solAssert(errorDefinition && errorDefinition->functionType(true));
1292+
utils().revertWithError(
1293+
errorDefinition->functionType(true)->externalSignature(),
1294+
errorDefinition->functionType(true)->parameterTypes(),
1295+
errorConstructorArgumentTypes
1296+
);
1297+
// Here, the argument is consumed, but in the other branch, it is still there.
1298+
m_context.adjustStackOffset(static_cast<int>(sizeOfErrorArguments));
1299+
m_context << successBranchTag;
1300+
// In case of the success branch i.e. require(true, ...), pop error constructor arguments
1301+
utils().popStackSlots(sizeOfErrorArguments);
1302+
break;
1303+
}
12671304

12681305
if (m_context.revertStrings() == RevertStrings::Strip)
12691306
{

‎test/libsolidity/semanticTests/errors/require_different_errors_same_parameters.sol‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,8 +14,6 @@ contract C
1414
}
1515
}
1616

17-
// ====
18-
// compileViaYul: true
1917
// ----
2018
// f() -> FAILURE, hex"f55fefe3", hex"0000000000000000000000000000000000000000000000000000000000000001", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"0000000000000000000000000000000000000000000000000000000000000003", hex"0000000000000000000000000000000000000000000000000000000000000003", hex"74776f0000000000000000000000000000000000000000000000000000000000"
2119
// g() -> FAILURE, hex"44a06798", hex"0000000000000000000000000000000000000000000000000000000000000004", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"0000000000000000000000000000000000000000000000000000000000000006", hex"0000000000000000000000000000000000000000000000000000000000000004", hex"6669766500000000000000000000000000000000000000000000000000000000"

‎test/libsolidity/semanticTests/errors/require_error_condition_evaluated_only_once.sol‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
contract C {
2+
uint256 counter = 0;
3+
4+
error CustomError(uint256);
5+
6+
function getCounter() public view returns (uint256) {
7+
return counter;
8+
}
9+
10+
function g(bool condition) internal returns (bool) {
11+
counter++;
12+
return condition;
13+
}
14+
15+
function f(bool condition) external {
16+
require(g(condition), CustomError(counter));
17+
}
18+
}
19+
20+
// ----
21+
// f(bool): false -> FAILURE, hex"110b3655", 1
22+
// getCounter() -> 0
23+
// f(bool): true ->
24+
// getCounter() -> 1

‎test/libsolidity/semanticTests/errors/require_evaluation_order.sol‎ renamed to ‎test/libsolidity/semanticTests/errors/require_error_evaluation_order_1.sol‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,8 +21,6 @@ contract C
2121
}
2222
}
2323

24-
// ====
25-
// compileViaYul: true
2624
// ----
2725
// f() -> 7
2826
// g() -> 7

‎test/libsolidity/semanticTests/errors/require_error_evaluation_order_2.sol‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
contract C {
2+
uint y;
3+
function g(bool x) internal returns (bool) {
4+
y = 42;
5+
return x;
6+
}
7+
error E(uint256);
8+
function h() internal returns (uint256) { return y; }
9+
function f(bool c) public {
10+
require(g(c), E(h()));
11+
}
12+
}
13+
14+
// ----
15+
// f(bool): false -> FAILURE, hex"002ff067", 42
16+
// f(bool): true ->

‎test/libsolidity/semanticTests/errors/require_error_evaluation_order_3.sol‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
contract C {
2+
string failureMessage = "Failure Message";
3+
function g(bool x) internal returns (bool) {
4+
failureMessage = "Intercepted failure message";
5+
return x;
6+
}
7+
function h() internal returns (string memory) { return failureMessage; }
8+
function f(bool c) public {
9+
require(g(c), h());
10+
}
11+
}
12+
13+
// ----
14+
// f(bool): false -> FAILURE, hex"08c379a0", 0x20, 0x1b, "Intercepted failure message"
15+
// f(bool): true ->

‎test/libsolidity/semanticTests/errors/require_error_function_join_control_flow.sol‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
contract C {
2+
uint x = 0;
3+
uint y = 42;
4+
error E(uint);
5+
function f(bool c) public returns (uint256, uint256, uint256) {
6+
uint z = x;
7+
if (y == 42) {
8+
x = 21;
9+
} else {
10+
require(c, E(y));
11+
}
12+
y /= 2;
13+
return (x,y,z);
14+
}
15+
}
16+
// ----
17+
// f(bool): true -> 0x15, 0x15, 0
18+
// f(bool): false -> FAILURE, hex"002ff067", 21

‎test/libsolidity/semanticTests/errors/require_error_function_pointer_parameter.sol‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,5 @@ contract C
1414
}
1515
}
1616

17-
// ====
18-
// compileViaYul: true
1917
// ----
2018
// f() -> FAILURE, hex"271b1dfa", hex"c06afe3a8444fc0004668591e8306bfb9968e79ef37cdc8e0000000000000000"

‎test/libsolidity/semanticTests/errors/require_error_multiple_arguments.sol‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,8 +13,6 @@ contract C
1313
}
1414
}
1515

16-
// ====
17-
// compileViaYul: true
1816
// ----
1917
// f() -> FAILURE, hex"11a1077e", hex"0000000000000000000000000000000000000000000000000000000000000001", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"0000000000000000000000000000000000000000000000000000000000000003", hex"0000000000000000000000000000000000000000000000000000000000000003", hex"74776f0000000000000000000000000000000000000000000000000000000000"
2018
// g() -> FAILURE, hex"11a1077e", hex"0000000000000000000000000000000000000000000000000000000000000004", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"0000000000000000000000000000000000000000000000000000000000000006", hex"0000000000000000000000000000000000000000000000000000000000000004", hex"6669766500000000000000000000000000000000000000000000000000000000"

0 commit comments

Comments
 (0)