From 31a0a31c26b12ae4a9de9f5313dcd362afa10a1b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Fri, 20 Nov 2020 14:56:12 +0100 Subject: [PATCH 01/18] storebytecode.sh: Allow BUILD_DIR outside of REPO_ROOT --- scripts/bytecodecompare/storebytecode.sh | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/scripts/bytecodecompare/storebytecode.sh b/scripts/bytecodecompare/storebytecode.sh index 13e320960..c8668147c 100755 --- a/scripts/bytecodecompare/storebytecode.sh +++ b/scripts/bytecodecompare/storebytecode.sh @@ -28,18 +28,14 @@ set -e REPO_ROOT="$(dirname "$0")"/../.. +cd "$REPO_ROOT" +REPO_ROOT=$(pwd) # make it absolute -if test -z "$1"; then - BUILD_DIR="build" -else - BUILD_DIR="$1" -fi +BUILD_DIR="${1:-${REPO_ROOT}/build}" echo "Compiling all test contracts into bytecode..." TMPDIR=$(mktemp -d) ( - cd "$REPO_ROOT" - REPO_ROOT=$(pwd) # make it absolute cd "$TMPDIR" "$REPO_ROOT"/scripts/isolate_tests.py "$REPO_ROOT"/test/ @@ -110,10 +106,10 @@ EOF ./solc *.sol > report.txt echo "Finished running the compiler." else - $REPO_ROOT/scripts/bytecodecompare/prepare_report.py $REPO_ROOT/$BUILD_DIR/solc/solc + "$REPO_ROOT/scripts/bytecodecompare/prepare_report.py" "$BUILD_DIR/solc/solc" fi - cp report.txt $REPO_ROOT + cp report.txt "$REPO_ROOT" ) rm -rf "$TMPDIR" echo "Storebytecode finished." From fda352094f0e9f586004dda48daef9788068f523 Mon Sep 17 00:00:00 2001 From: chriseth Date: Thu, 5 Nov 2020 18:03:32 +0100 Subject: [PATCH 02/18] Allow fallback function to return data. --- libsolidity/analysis/TypeChecker.cpp | 20 +++++++++----- libsolidity/codegen/ContractCompiler.cpp | 27 ++++++++++++++----- libsolidity/codegen/ir/IRGenerator.cpp | 12 +++++++-- .../semanticTests/fallback/falback_return.sol | 18 +++++++++++++ .../fallback/fallback_argument.sol | 17 ++++++++++++ .../fallback/fallback_argument_to_storage.sol | 16 +++++++++++ .../fallback/fallback_return_data.sol | 14 ++++++++++ .../syntaxTests/fallback/arguments.sol | 2 +- .../fallback/no_input_no_output.sol | 9 +++++++ .../fallback/return_value_number.sol | 2 +- .../fallback/return_value_type.sol | 2 +- .../fallback/return_value_unsupported.sol | 2 +- .../syntaxTests/fallback/returns.sol | 4 +++ .../075_fallback_function_with_arguments.sol | 2 +- ...llback_function_with_return_parameters.sol | 2 +- 15 files changed, 128 insertions(+), 21 deletions(-) create mode 100644 test/libsolidity/semanticTests/fallback/falback_return.sol create mode 100644 test/libsolidity/semanticTests/fallback/fallback_argument.sol create mode 100644 test/libsolidity/semanticTests/fallback/fallback_argument_to_storage.sol create mode 100644 test/libsolidity/semanticTests/fallback/fallback_return_data.sol create mode 100644 test/libsolidity/syntaxTests/fallback/no_input_no_output.sol create mode 100644 test/libsolidity/syntaxTests/fallback/returns.sol diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp index 0ddd69229..7bc4677e2 100644 --- a/libsolidity/analysis/TypeChecker.cpp +++ b/libsolidity/analysis/TypeChecker.cpp @@ -1831,15 +1831,21 @@ void TypeChecker::typeCheckFallbackFunction(FunctionDefinition const& _function) ); if (_function.visibility() != Visibility::External) m_errorReporter.typeError(1159_error, _function.location(), "Fallback function must be defined as \"external\"."); - if (!_function.returnParameters().empty()) + + if (!_function.returnParameters().empty() || !_function.parameters().empty()) { - if (_function.returnParameters().size() > 1 || *type(*_function.returnParameters().front()) != *TypeProvider::bytesMemory()) - m_errorReporter.typeError(5570_error, _function.returnParameterList()->location(), "Fallback function can only have a single \"bytes memory\" return value."); - else - m_errorReporter.typeError(6151_error, _function.returnParameterList()->location(), "Return values for fallback functions are not yet implemented."); + if ( + _function.returnParameters().size() != 1 || + *type(*_function.returnParameters().front()) != *TypeProvider::bytesMemory() || + _function.parameters().size() != 1 || + *type(*_function.parameters().front()) != *TypeProvider::bytesCalldata() + ) + m_errorReporter.typeError( + 5570_error, + _function.returnParameterList()->location(), + "Fallback function either has to have the signature \"fallback()\" or \"fallback(bytes calldata) returns (bytes memory)\"." + ); } - if (!_function.parameters().empty()) - m_errorReporter.typeError(3978_error, _function.parameterList().location(), "Fallback function cannot take parameters."); } void TypeChecker::typeCheckReceiveFunction(FunctionDefinition const& _function) diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp index d339e50b9..66c67f59a 100644 --- a/libsolidity/codegen/ContractCompiler.cpp +++ b/libsolidity/codegen/ContractCompiler.cpp @@ -467,10 +467,21 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac appendCallValueCheck(); solAssert(fallback->isFallback(), ""); - solAssert(FunctionType(*fallback).parameterTypes().empty(), ""); - solAssert(FunctionType(*fallback).returnParameterTypes().empty(), ""); + m_context.setStackOffset(0); + + if (!FunctionType(*fallback).parameterTypes().empty()) + m_context << u256(0) << Instruction::CALLDATASIZE; + fallback->accept(*this); - m_context << Instruction::STOP; + + if (FunctionType(*fallback).returnParameterTypes().empty()) + m_context << Instruction::STOP; + else + { + m_context << Instruction::DUP1 << Instruction::MLOAD << Instruction::SWAP1; + m_context << u256(0x20) << Instruction::ADD; + m_context << Instruction::RETURN; + } } else m_context.appendRevert("Unknown signature and no fallback defined"); @@ -479,6 +490,7 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac for (auto const& it: interfaceFunctions) { + m_context.setStackOffset(1); FunctionTypePointer const& functionType = it.second; solAssert(functionType->hasDeclaration(), ""); CompilerContext::LocationSetter locationSetter(m_context, functionType->declaration()); @@ -588,7 +600,9 @@ bool ContractCompiler::visit(FunctionDefinition const& _function) // reserve additional slots: [retarg0] ... [retargm] unsigned parametersSize = CompilerUtils::sizeOnStack(_function.parameters()); - if (!_function.isConstructor()) + if (_function.isFallback()) + m_context.adjustStackOffset(static_cast(parametersSize)); + else if (!_function.isConstructor()) // adding 1 for return address. m_context.adjustStackOffset(static_cast(parametersSize) + 1); for (ASTPointer const& variable: _function.parameters()) @@ -628,7 +642,8 @@ bool ContractCompiler::visit(FunctionDefinition const& _function) unsigned const c_returnValuesSize = CompilerUtils::sizeOnStack(_function.returnParameters()); vector stackLayout; - stackLayout.push_back(static_cast(c_returnValuesSize)); // target of return address + if (!_function.isConstructor() && !_function.isFallback()) + stackLayout.push_back(static_cast(c_returnValuesSize)); // target of return address stackLayout += vector(c_argumentsSize, -1); // discard all arguments for (size_t i = 0; i < c_returnValuesSize; ++i) stackLayout.push_back(static_cast(i)); @@ -639,7 +654,7 @@ bool ContractCompiler::visit(FunctionDefinition const& _function) errinfo_sourceLocation(_function.location()) << errinfo_comment("Stack too deep, try removing local variables.") ); - while (stackLayout.back() != static_cast(stackLayout.size() - 1)) + while (!stackLayout.empty() && stackLayout.back() != static_cast(stackLayout.size() - 1)) if (stackLayout.back() < 0) { m_context << Instruction::POP; diff --git a/libsolidity/codegen/ir/IRGenerator.cpp b/libsolidity/codegen/ir/IRGenerator.cpp index 46ae3381c..4a8804182 100644 --- a/libsolidity/codegen/ir/IRGenerator.cpp +++ b/libsolidity/codegen/ir/IRGenerator.cpp @@ -652,8 +652,16 @@ string IRGenerator::dispatchRoutine(ContractDefinition const& _contract) { string fallbackCode; if (!fallback->isPayable()) - fallbackCode += callValueCheck(); - fallbackCode += m_context.enqueueFunctionForCodeGeneration(*fallback) + "() stop()"; + fallbackCode += callValueCheck() + "\n"; + if (fallback->parameters().empty()) + fallbackCode += m_context.enqueueFunctionForCodeGeneration(*fallback) + "() stop()"; + else + { + solAssert(fallback->parameters().size() == 1 && fallback->returnParameters().size() == 1, ""); + fallbackCode += "let retval := " + m_context.enqueueFunctionForCodeGeneration(*fallback) + "(0, calldatasize())\n"; + fallbackCode += "return(add(retval, 0x20), mload(retval))\n"; + + } t("fallback", fallbackCode); } diff --git a/test/libsolidity/semanticTests/fallback/falback_return.sol b/test/libsolidity/semanticTests/fallback/falback_return.sol new file mode 100644 index 000000000..2868d85d0 --- /dev/null +++ b/test/libsolidity/semanticTests/fallback/falback_return.sol @@ -0,0 +1,18 @@ +contract A { + uint public x; + fallback () external { + if (x == 2) return; + x++; + } +} +// ==== +// compileViaYul: also +// ---- +// () +// x() -> 1 +// () +// x() -> 2 +// () +// x() -> 2 +// () +// x() -> 2 diff --git a/test/libsolidity/semanticTests/fallback/fallback_argument.sol b/test/libsolidity/semanticTests/fallback/fallback_argument.sol new file mode 100644 index 000000000..1e3433d93 --- /dev/null +++ b/test/libsolidity/semanticTests/fallback/fallback_argument.sol @@ -0,0 +1,17 @@ +contract A { + uint public x; + fallback (bytes calldata _input) external returns (bytes memory) { + x = _input.length; + return ""; + } + function f() public returns (bool, bytes memory) { + (bool success, bytes memory retval) = address(this).call("abc"); + return (success, retval); + } +} +// ==== +// compileViaYul: also +// EVMVersion: >=byzantium +// ---- +// f() -> 0x01, 0x40, 0x00 +// x() -> 3 diff --git a/test/libsolidity/semanticTests/fallback/fallback_argument_to_storage.sol b/test/libsolidity/semanticTests/fallback/fallback_argument_to_storage.sol new file mode 100644 index 000000000..1a995a8cd --- /dev/null +++ b/test/libsolidity/semanticTests/fallback/fallback_argument_to_storage.sol @@ -0,0 +1,16 @@ +contract A { + bytes public x; + fallback (bytes calldata _input) external returns (bytes memory) { + x = _input; + return ""; + } + function f() public returns (bool, bytes memory) { + (bool success, bytes memory retval) = address(this).call("abc"); + return (success, retval); + } +} +// ==== +// EVMVersion: >=byzantium +// ---- +// f() -> 0x01, 0x40, 0x00 +// x() -> 0x20, 3, "abc" diff --git a/test/libsolidity/semanticTests/fallback/fallback_return_data.sol b/test/libsolidity/semanticTests/fallback/fallback_return_data.sol new file mode 100644 index 000000000..130212613 --- /dev/null +++ b/test/libsolidity/semanticTests/fallback/fallback_return_data.sol @@ -0,0 +1,14 @@ +contract A { + fallback (bytes calldata _input) external returns (bytes memory) { + return _input; + } + function f() public returns (bool, bytes memory) { + (bool success, bytes memory retval) = address(this).call("abc"); + return (success, retval); + } +} +// ==== +// compileViaYul: also +// EVMVersion: >=byzantium +// ---- +// f() -> 0x01, 0x40, 0x03, 0x6162630000000000000000000000000000000000000000000000000000000000 diff --git a/test/libsolidity/syntaxTests/fallback/arguments.sol b/test/libsolidity/syntaxTests/fallback/arguments.sol index 806874feb..c796161d2 100644 --- a/test/libsolidity/syntaxTests/fallback/arguments.sol +++ b/test/libsolidity/syntaxTests/fallback/arguments.sol @@ -2,4 +2,4 @@ contract C { fallback(uint256) external {} } // ---- -// TypeError 3978: (25-34): Fallback function cannot take parameters. +// TypeError 5570: (44-44): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". diff --git a/test/libsolidity/syntaxTests/fallback/no_input_no_output.sol b/test/libsolidity/syntaxTests/fallback/no_input_no_output.sol new file mode 100644 index 000000000..868671d2a --- /dev/null +++ b/test/libsolidity/syntaxTests/fallback/no_input_no_output.sol @@ -0,0 +1,9 @@ +contract C { + fallback() external returns (bytes memory _output) {} +} +contract D { + fallback(bytes calldata _input) external {} +} +// ---- +// TypeError 5570: (45-67): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". +// TypeError 5570: (131-131): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". diff --git a/test/libsolidity/syntaxTests/fallback/return_value_number.sol b/test/libsolidity/syntaxTests/fallback/return_value_number.sol index c41b837a8..e5d358c73 100644 --- a/test/libsolidity/syntaxTests/fallback/return_value_number.sol +++ b/test/libsolidity/syntaxTests/fallback/return_value_number.sol @@ -2,4 +2,4 @@ contract C { fallback() external returns (bytes memory, bytes memory) {} } // ---- -// TypeError 5570: (45-73): Fallback function can only have a single "bytes memory" return value. +// TypeError 5570: (45-73): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". diff --git a/test/libsolidity/syntaxTests/fallback/return_value_type.sol b/test/libsolidity/syntaxTests/fallback/return_value_type.sol index a6557139d..01363ebe4 100644 --- a/test/libsolidity/syntaxTests/fallback/return_value_type.sol +++ b/test/libsolidity/syntaxTests/fallback/return_value_type.sol @@ -2,4 +2,4 @@ contract C { fallback() external returns (uint256) {} } // ---- -// TypeError 5570: (45-54): Fallback function can only have a single "bytes memory" return value. +// TypeError 5570: (45-54): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". diff --git a/test/libsolidity/syntaxTests/fallback/return_value_unsupported.sol b/test/libsolidity/syntaxTests/fallback/return_value_unsupported.sol index 3b90b5ad2..88f181f3f 100644 --- a/test/libsolidity/syntaxTests/fallback/return_value_unsupported.sol +++ b/test/libsolidity/syntaxTests/fallback/return_value_unsupported.sol @@ -2,4 +2,4 @@ contract C { fallback() external returns (bytes memory) {} } // ---- -// TypeError 6151: (45-59): Return values for fallback functions are not yet implemented. +// TypeError 5570: (45-59): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". diff --git a/test/libsolidity/syntaxTests/fallback/returns.sol b/test/libsolidity/syntaxTests/fallback/returns.sol new file mode 100644 index 000000000..a4d45c522 --- /dev/null +++ b/test/libsolidity/syntaxTests/fallback/returns.sol @@ -0,0 +1,4 @@ +contract C { + fallback(bytes calldata _input) external returns (bytes memory _output) {} +} +// ---- diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/075_fallback_function_with_arguments.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/075_fallback_function_with_arguments.sol index 8beac9f1a..6ed769c88 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/075_fallback_function_with_arguments.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/075_fallback_function_with_arguments.sol @@ -3,4 +3,4 @@ contract C { fallback(uint a) external { x = 2; } } // ---- -// TypeError 3978: (37-45): Fallback function cannot take parameters. +// TypeError 5570: (55-55): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/077_fallback_function_with_return_parameters.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/077_fallback_function_with_return_parameters.sol index 3ec82b390..268a7e69b 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/077_fallback_function_with_return_parameters.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/077_fallback_function_with_return_parameters.sol @@ -2,4 +2,4 @@ contract C { fallback() external returns (uint) { } } // ---- -// TypeError 5570: (45-51): Fallback function can only have a single "bytes memory" return value. +// TypeError 5570: (45-51): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". From bb9688e0fe88ce2b8f4f9be8fdcc15b9e22d8490 Mon Sep 17 00:00:00 2001 From: chriseth Date: Tue, 10 Nov 2020 15:37:20 +0100 Subject: [PATCH 03/18] Grammar for fallback returning. --- docs/grammar/Solidity.g4 | 36 ++++++++++++++++++++++++++++++------ 1 file changed, 30 insertions(+), 6 deletions(-) diff --git a/docs/grammar/Solidity.g4 b/docs/grammar/Solidity.g4 index 8246ba073..9a99aa475 100644 --- a/docs/grammar/Solidity.g4 +++ b/docs/grammar/Solidity.g4 @@ -84,7 +84,8 @@ contractBodyElement: constructorDefinition | functionDefinition | modifierDefinition - | fallbackReceiveFunctionDefinition + | fallbackFunctionDefinition + | receiveFunctionDefinition | structDefinition | enumDefinition | stateVariableDeclaration @@ -189,9 +190,32 @@ locals[ (Semicolon | body=block); /** - * Definitions of the special fallback and receive functions. + * Definition of the special fallback function. */ -fallbackReceiveFunctionDefinition +fallbackFunctionDefinition +locals[ + boolean visibilitySet = false, + boolean mutabilitySet = false, + boolean virtualSet = false, + boolean overrideSpecifierSet = false, + boolean hasParameters = false +] +: + kind=Fallback LParen (parameterList { $hasParameters = true; } )? RParen + ( + {!$visibilitySet}? External {$visibilitySet = true;} + | {!$mutabilitySet}? stateMutability {$mutabilitySet = true;} + | modifierInvocation + | {!$virtualSet}? Virtual {$virtualSet = true;} + | {!$overrideSpecifierSet}? overrideSpecifier {$overrideSpecifierSet = true;} + )* + ( {$hasParameters}? Returns LParen returnParameters=parameterList RParen | {!$hasParameters}? ) + (Semicolon | body=block); + +/** + * Definition of the special receive function. + */ +receiveFunctionDefinition locals[ boolean visibilitySet = false, boolean mutabilitySet = false, @@ -199,10 +223,10 @@ locals[ boolean overrideSpecifierSet = false ] : - kind=(Fallback | Receive) LParen RParen + kind=Receive LParen RParen ( - {!$visibilitySet}? visibility {$visibilitySet = true;} - | {!$mutabilitySet}? stateMutability {$mutabilitySet = true;} + {!$visibilitySet}? External {$visibilitySet = true;} + | {!$mutabilitySet}? Payable {$mutabilitySet = true;} | modifierInvocation | {!$virtualSet}? Virtual {$virtualSet = true;} | {!$overrideSpecifierSet}? overrideSpecifier {$overrideSpecifierSet = true;} From 67ec5f6b17bd0fb5369350a270d4b9433eafaf4c Mon Sep 17 00:00:00 2001 From: chriseth Date: Wed, 11 Nov 2020 15:24:11 +0100 Subject: [PATCH 04/18] Override semantics for fallback function. --- libsolidity/analysis/OverrideChecker.cpp | 25 ++++++++++++------- .../fallback/fallback_duplicate_returns.sol | 6 +++++ ...fallback_duplicate_returns_inheritance.sol | 9 +++++++ .../fallback_duplicate_returns_override.sol | 7 ++++++ 4 files changed, 38 insertions(+), 9 deletions(-) create mode 100644 test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns.sol create mode 100644 test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_inheritance.sol create mode 100644 test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_override.sol diff --git a/libsolidity/analysis/OverrideChecker.cpp b/libsolidity/analysis/OverrideChecker.cpp index 0bfb032b1..c0cae71e4 100644 --- a/libsolidity/analysis/OverrideChecker.cpp +++ b/libsolidity/analysis/OverrideChecker.cpp @@ -394,6 +394,10 @@ bool OverrideProxy::OverrideComparator::operator<(OverrideComparator const& _oth if (functionKind != _other.functionKind) return *functionKind < *_other.functionKind; + // Parameters do not matter for non-regular functions. + if (functionKind != Token::Function) + return false; + if (!parameterTypes || !_other.parameterTypes) return false; @@ -574,16 +578,19 @@ void OverrideChecker::checkOverride(OverrideProxy const& _overriding, OverridePr FunctionType const* functionType = _overriding.functionType(); FunctionType const* superType = _super.functionType(); - solAssert(functionType->hasEqualParameterTypes(*superType), "Override doesn't have equal parameters!"); + if (_overriding.functionKind() != Token::Fallback) + { + solAssert(functionType->hasEqualParameterTypes(*superType), "Override doesn't have equal parameters!"); - if (!functionType->hasEqualReturnTypes(*superType)) - overrideError( - _overriding, - _super, - 4822_error, - "Overriding " + _overriding.astNodeName() + " return types differ.", - "Overridden " + _overriding.astNodeName() + " is here:" - ); + if (!functionType->hasEqualReturnTypes(*superType)) + overrideError( + _overriding, + _super, + 4822_error, + "Overriding " + _overriding.astNodeName() + " return types differ.", + "Overridden " + _overriding.astNodeName() + " is here:" + ); + } // Stricter mutability is always okay except when super is Payable if ( diff --git a/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns.sol b/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns.sol new file mode 100644 index 000000000..625c17f98 --- /dev/null +++ b/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns.sol @@ -0,0 +1,6 @@ +contract C { + fallback(bytes calldata _input) external returns (bytes memory _output) {} + fallback() external {} +} +// ---- +// DeclarationError 7301: (96-118): Only one fallback function is allowed. diff --git a/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_inheritance.sol b/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_inheritance.sol new file mode 100644 index 000000000..818006a11 --- /dev/null +++ b/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_inheritance.sol @@ -0,0 +1,9 @@ +contract C { + fallback(bytes calldata _input) external returns (bytes memory _output) {} +} +contract D is C { + fallback() external {} +} +// ---- +// TypeError 9456: (116-138): Overriding function is missing "override" specifier. +// TypeError 4334: (17-91): Trying to override non-virtual function. Did you forget to add "virtual"? diff --git a/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_override.sol b/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_override.sol new file mode 100644 index 000000000..32638c082 --- /dev/null +++ b/test/libsolidity/syntaxTests/fallback/fallback_duplicate_returns_override.sol @@ -0,0 +1,7 @@ +contract C { + fallback(bytes calldata _input) external virtual returns (bytes memory _output) {} +} +contract D is C { + fallback() external override {} +} +// ---- From 0326367b228803cb3147527b631e403df09df122 Mon Sep 17 00:00:00 2001 From: chriseth Date: Wed, 11 Nov 2020 15:29:46 +0100 Subject: [PATCH 05/18] Documentation. --- Changelog.md | 3 +++ docs/contracts/functions.rst | 27 ++++++++++++++++++--------- 2 files changed, 21 insertions(+), 9 deletions(-) diff --git a/Changelog.md b/Changelog.md index 85c71df8e..57ea23eea 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,5 +1,8 @@ ### 0.7.6 (unreleased) +Language Features: + * The fallback function can now also have a single ``calldata`` argument (equaling ``msg.data``) and return ``bytes memory`` (which will not be ABI-encoded but returned as-is). + Compiler Features: * SMTChecker: Support named arguments in function calls. diff --git a/docs/contracts/functions.rst b/docs/contracts/functions.rst index aa9263ff8..8ddb15a44 100644 --- a/docs/contracts/functions.rst +++ b/docs/contracts/functions.rst @@ -275,7 +275,10 @@ A contract can have at most one ``receive`` function, declared using ``receive() external payable { ... }`` (without the ``function`` keyword). This function cannot have arguments, cannot return anything and must have -``external`` visibility and ``payable`` state mutability. It is executed on a +``external`` visibility and ``payable`` state mutability. +It can be virtual, can override and can have modifiers. + +The receive function is executed on a call to the contract with empty calldata. This is the function that is executed on plain Ether transfers (e.g. via ``.send()`` or ``.transfer()``). If no such function exists, but a payable :ref:`fallback function ` @@ -339,15 +342,22 @@ Below you can see an example of a Sink contract that uses function ``receive``. Fallback Function ================= -A contract can have at most one ``fallback`` function, declared using ``fallback () external [payable]`` -(without the ``function`` keyword). -This function cannot have arguments, cannot return anything and must have ``external`` visibility. -It is executed on a call to the contract if none of the other +A contract can have at most one ``fallback`` function, declared using either ``fallback () external [payable]`` +or ``fallback (bytes calldata _input) external [payable] returns (bytes memory _output)`` +(both without the ``function`` keyword). +This function must have ``external`` visibility. A fallback function can be virtual, can override +and can have modifiers. + +The fallback function is executed on a call to the contract if none of the other functions match the given function signature, or if no data was supplied at all and there is no :ref:`receive Ether function `. The fallback function always receives data, but in order to also receive Ether it must be marked ``payable``. +If the version with parameters is used, ``_input`` will contain the full data sent to the contract +(equal to ``msg.data``) and can return data in ``_output``. The returned data will not be +ABI-encoded. Instead it will be returned without modifications (not even padding). + In the worst case, if a payable fallback function is also used in place of a receive function, it can only rely on 2300 gas being available (see :ref:`receive Ether function ` @@ -364,12 +374,11 @@ operations as long as there is enough gas passed on to it. to distinguish Ether transfers from interface confusions. .. note:: - Even though the fallback function cannot have arguments, one can still use ``msg.data`` to retrieve - any payload supplied with the call. - After having checked the first four bytes of ``msg.data``, + If you want to decode the input data, you can check the first four bytes + for the function selector and then you can use ``abi.decode`` together with the array slice syntax to decode ABI-encoded data: - ``(c, d) = abi.decode(msg.data[4:], (uint256, uint256));`` + ``(c, d) = abi.decode(_input[4:], (uint256, uint256));`` Note that this should only be used as a last resort and proper functions should be used instead. From 19e9e8b550ecbfb019204dde50a061412fa18184 Mon Sep 17 00:00:00 2001 From: chriseth Date: Wed, 18 Nov 2020 20:09:39 +0100 Subject: [PATCH 06/18] Some more tests. --- .../fallback/fallback_override.sol | 19 ++++++++++++++++ .../fallback/fallback_override2.sol | 18 +++++++++++++++ .../fallback/fallback_override_multi.sol | 22 +++++++++++++++++++ .../fallback/fallback_wrong_data_location.sol | 13 +++++++++++ .../fallback/inheritance_multi_base.sol | 20 +++++++++++++++++ 5 files changed, 92 insertions(+) create mode 100644 test/libsolidity/semanticTests/fallback/fallback_override.sol create mode 100644 test/libsolidity/semanticTests/fallback/fallback_override2.sol create mode 100644 test/libsolidity/semanticTests/fallback/fallback_override_multi.sol create mode 100644 test/libsolidity/syntaxTests/fallback/fallback_wrong_data_location.sol create mode 100644 test/libsolidity/syntaxTests/fallback/inheritance_multi_base.sol diff --git a/test/libsolidity/semanticTests/fallback/fallback_override.sol b/test/libsolidity/semanticTests/fallback/fallback_override.sol new file mode 100644 index 000000000..c1099e151 --- /dev/null +++ b/test/libsolidity/semanticTests/fallback/fallback_override.sol @@ -0,0 +1,19 @@ +contract A { + fallback (bytes calldata _input) virtual external returns (bytes memory) { + return _input; + } +} +contract B is A { + fallback (bytes calldata _input) override external returns (bytes memory) { + return "xyz"; + } + function f() public returns (bool, bytes memory) { + (bool success, bytes memory retval) = address(this).call("abc"); + return (success, retval); + } +} +// ==== +// EVMVersion: >=byzantium +// compileViaYul: also +// ---- +// f() -> 0x01, 0x40, 0x03, 0x78797a0000000000000000000000000000000000000000000000000000000000 diff --git a/test/libsolidity/semanticTests/fallback/fallback_override2.sol b/test/libsolidity/semanticTests/fallback/fallback_override2.sol new file mode 100644 index 000000000..e92163476 --- /dev/null +++ b/test/libsolidity/semanticTests/fallback/fallback_override2.sol @@ -0,0 +1,18 @@ +contract A { + fallback (bytes calldata _input) virtual external returns (bytes memory) { + return _input; + } +} +contract B is A { + fallback () override external { + } + function f() public returns (bool, bytes memory) { + (bool success, bytes memory retval) = address(this).call("abc"); + return (success, retval); + } +} +// ==== +// EVMVersion: >=byzantium +// compileViaYul: also +// ---- +// f() -> 1, 0x40, 0x00 diff --git a/test/libsolidity/semanticTests/fallback/fallback_override_multi.sol b/test/libsolidity/semanticTests/fallback/fallback_override_multi.sol new file mode 100644 index 000000000..1e2b3a630 --- /dev/null +++ b/test/libsolidity/semanticTests/fallback/fallback_override_multi.sol @@ -0,0 +1,22 @@ +contract A { + fallback (bytes calldata _input) virtual external returns (bytes memory) { + return _input; + } +} +contract B { + fallback (bytes calldata _input) virtual external returns (bytes memory) { + return "xyz"; + } +} +contract C is B, A { + fallback () external override (B, A) {} + function f() public returns (bool, bytes memory) { + (bool success, bytes memory retval) = address(this).call("abc"); + return (success, retval); + } +} +// ==== +// EVMVersion: >=byzantium +// compileViaYul: also +// ---- +// f() -> 0x01, 0x40, 0x00 diff --git a/test/libsolidity/syntaxTests/fallback/fallback_wrong_data_location.sol b/test/libsolidity/syntaxTests/fallback/fallback_wrong_data_location.sol new file mode 100644 index 000000000..5ddefdf3d --- /dev/null +++ b/test/libsolidity/syntaxTests/fallback/fallback_wrong_data_location.sol @@ -0,0 +1,13 @@ +contract D { + fallback(bytes memory) external returns (bytes memory) {} +} +contract E { + fallback(bytes memory) external returns (bytes calldata) {} +} +contract F { + fallback(bytes calldata) external returns (bytes calldata) {} +} +// ---- +// TypeError 5570: (57-71): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". +// TypeError 5570: (134-150): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". +// TypeError 5570: (215-231): Fallback function either has to have the signature "fallback()" or "fallback(bytes calldata) returns (bytes memory)". diff --git a/test/libsolidity/syntaxTests/fallback/inheritance_multi_base.sol b/test/libsolidity/syntaxTests/fallback/inheritance_multi_base.sol new file mode 100644 index 000000000..330ff156c --- /dev/null +++ b/test/libsolidity/syntaxTests/fallback/inheritance_multi_base.sol @@ -0,0 +1,20 @@ +contract A { + fallback (bytes calldata _input) external returns (bytes memory) { + return _input; + } +} +contract B { + fallback (bytes calldata _input) external returns (bytes memory) { + return "xyz"; + } +} +contract C is B, A { + function f() public returns (bool, bytes memory) { + (bool success, bytes memory retval) = address(this).call("abc"); + return (success, retval); + } +} +// ==== +// EVMVersion: >=byzantium +// ---- +// TypeError 6480: (229-420): Derived contract must override function "". Two or more base classes define function with same name and parameter types. From 68cfa0a9018fcac8b909e47985ef03263bc8ff36 Mon Sep 17 00:00:00 2001 From: Leonardo Alt Date: Mon, 23 Nov 2020 19:40:29 +0100 Subject: [PATCH 07/18] Fix spelling in SMTChecker comment --- libsolidity/formal/SMTEncoder.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libsolidity/formal/SMTEncoder.cpp b/libsolidity/formal/SMTEncoder.cpp index bbbe1b00d..be7112ad1 100644 --- a/libsolidity/formal/SMTEncoder.cpp +++ b/libsolidity/formal/SMTEncoder.cpp @@ -1124,7 +1124,7 @@ bool SMTEncoder::visit(MemberAccess const& _memberAccess) } else // NOTE: supporting name, creationCode, runtimeCode would be easy enough, but the bytes/string they return are not - // at all useable in the SMT checker currently + // at all usable in the SMT checker currently m_errorReporter.warning( 7507_error, _memberAccess.location(), From 5f0372c5b85fa2ec944fcb9af8e8df5f6d4cca10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Tue, 3 Nov 2020 16:02:32 +0100 Subject: [PATCH 08/18] installing-solidity.rst: Put information about macOS packages in a separate section --- docs/installing-solidity.rst | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/docs/installing-solidity.rst b/docs/installing-solidity.rst index 9a787b30b..1fcf97132 100644 --- a/docs/installing-solidity.rst +++ b/docs/installing-solidity.rst @@ -92,8 +92,8 @@ When using this interface it is not necessary to mount any directories. docker run ethereum/solc:stable --standard-json < input.json > output.json -Binary Packages -=============== +Linux packages +============== Binary packages of Solidity are available at `solidity/releases `_. @@ -143,6 +143,16 @@ Arch Linux also has packages, albeit limited to the latest development version: pacman -S solidity +Gentoo Linux has an `Ethereum overlay `_ that contains a solidity package. +After the overlay is setup, ``solc`` can be installed in x86_64 architectures by: + +.. code-block:: bash + + emerge dev-lang/solidity + +macOS packages +============== + We distribute the Solidity compiler through Homebrew as a build-from-source version. Pre-built bottles are currently not supported. @@ -179,13 +189,6 @@ Install it using ``brew``: # eg. Install 0.4.8 brew install solidity.rb -Gentoo Linux has an `Ethereum overlay `_ that contains a solidity package. -After the overlay is setup, ``solc`` can be installed in x86_64 architectures by: - -.. code-block:: bash - - emerge dev-lang/solidity - .. _building-from-source: Building from Source From be5143bbecfa5ceaeafc53f8dad0cc270e70f871 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Thu, 19 Nov 2020 18:21:34 +0100 Subject: [PATCH 09/18] installing-solidity.rst: Add a link to ccache --- docs/installing-solidity.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/installing-solidity.rst b/docs/installing-solidity.rst index 1fcf97132..094d8773a 100644 --- a/docs/installing-solidity.rst +++ b/docs/installing-solidity.rst @@ -341,10 +341,12 @@ Command-Line Build **Be sure to install External Dependencies (see above) before build.** Solidity project uses CMake to configure the build. -You might want to install ccache to speed up repeated builds. +You might want to install `ccache`_ to speed up repeated builds. CMake will pick it up automatically. Building Solidity is quite similar on Linux, macOS and other Unices: +.. _ccache: https://ccache.dev/ + .. code-block:: bash mkdir build From c58341022f9d6875d1ceef998f43bbc253827a2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Thu, 19 Nov 2020 18:22:00 +0100 Subject: [PATCH 10/18] installing-solidity.rst: Add a section about Static binaries and solc-bin --- docs/installing-solidity.rst | 104 +++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/docs/installing-solidity.rst b/docs/installing-solidity.rst index 094d8773a..880fa0be5 100644 --- a/docs/installing-solidity.rst +++ b/docs/installing-solidity.rst @@ -189,6 +189,110 @@ Install it using ``brew``: # eg. Install 0.4.8 brew install solidity.rb +Static Binaries +=============== + +We maintain a repository containing static builds of past and current compiler versions for all +supported platforms at `solc-bin`_. This is also the location where you can find the nightly builds. + +The repository is not only a quick and easy way for end users to get binaries ready to be used +out-of-the-box but it is also meant to be friendly to third-party tools: + +- The content is mirrored to https://binaries.soliditylang.org where it can be easily downloaded over + HTTPS without any authentication, rate limiting or the need to use git. +- Content is served with correct `Content-Type` headers and lenient CORS configuration so that it + can be directly loaded by tools running in the browser. +- Binaries do not require installation or unpacking (with the exception of older Windows builds + bundled with necessary DLLs). +- We strive for a high level of backwards-compatibility. Files, once added, are not removed or moved + without providing a symlink/redirect at the old location. They are also never modified + in place and should always match the original checksum. The only exception would be broken or + unusable files with a potential to cause more harm than good if left as is. +- Files are served over both HTTP and HTTPS. As long as you obtain the file list in a secure way + (via git, HTTPS, IPFS or just have it cached locally) and verify hashes of the binaries + after downloading them, you do not have to use HTTPS for the binaries themselves. + +The same binaries are in most cases available on the `Solidity release page on Github`_. The +difference is that we do not generally update old releases on the Github release page. This means +that we do not rename them if the naming convention changes and we do not add builds for platforms +that were not supported at the time of release. This only happens in ``solc-bin``. + +The ``solc-bin`` repository contains several top-level directories, each representing a single platform. +Each one contains a ``list.json`` file listing the available binaries. For example in +``emscripten-wasm32/list.json`` you will find the following information about version 0.7.4: + +.. code-block:: json + + { + "path": "solc-emscripten-wasm32-v0.7.4+commit.3f05b770.js", + "version": "0.7.4", + "build": "commit.3f05b770", + "longVersion": "0.7.4+commit.3f05b770", + "keccak256": "0x300330ecd127756b824aa13e843cb1f43c473cb22eaf3750d5fb9c99279af8c3", + "urls": [ + "bzzr://16c5f09109c793db99fe35f037c6092b061bd39260ee7a677c8a97f18c955ab1", + "dweb:/ipfs/QmTLs5MuLEWXQkths41HiACoXDiH8zxyqBHGFDRSzVE5CS" + ] + } + +This means that: + +- You can find the binary in the same directory under the name + `solc-emscripten-wasm32-v0.7.4+commit.3f05b770.js `_. + Note that the file might be a symlink, and you will need to resolve it yourself if you are not using + git to download it or your file system does not support symlinks. +- The binary is also mirrored at https://binaries.soliditylang.org/emscripten-wasm32/solc-emscripten-wasm32-v0.7.4+commit.3f05b770.js. + In this case git is not necessary and symlinks are resolved transparently, either by serving a copy + of the file or returning a HTTP redirect. +- The file is also available on IPFS at `QmTLs5MuLEWXQkths41HiACoXDiH8zxyqBHGFDRSzVE5CS`_. +- The file might in future be available on Swarm at `16c5f09109c793db99fe35f037c6092b061bd39260ee7a677c8a97f18c955ab1`_. +- You can verify the integrity of the binary by comparing its keccak256 hash to + ``0x300330ecd127756b824aa13e843cb1f43c473cb22eaf3750d5fb9c99279af8c3``. The hash can be computed + on the command line using ``keccak256sum`` utility provided by `sha3sum`_ or `keccak256() function + from ethereumjs-util`_ in JavaScript. + +.. warning:: + + Due to the strong backwards compatibility requirement the repository contains some legacy elements + but you should avoid using them when writing new tools: + + - Use ``emscripten-wasm32/`` (with a fallback to ``emscripten-asmjs/``) instead of ``bin/`` if + you want the best performance. Until version 0.6.1 we only provided asm.js binaries. + Starting with 0.6.2 we switched to `WebAssembly builds`_ with much better performance. We have + rebuilt the older versions for wasm but the original asm.js files remain in ``bin/``. + The new ones had to be placed in a separate directory to avoid name clashes. + - Use ``emscripten-asmjs/`` and ``emscripten-wasm32/`` instead of ``bin/`` and ``wasm/`` directories + if you want to be sure whether you are downloading a wasm or an asm.js binary. + - Use ``list.json`` instead of ``list.js`` and ``list.txt``. The JSON list format contains all + the information from the old ones and more. + - Use https://binaries.soliditylang.org instead of https://solc-bin.ethereum.org. To keep things + simple we moved almost everything related to the compiler under the new ``soliditylang.org`` + domain and this applies to ``solc-bin`` too. While the new domain is recommended, the old one + is still fully supported and guaranteed to point at the same location. + +.. warning:: + + The binaries are also available at https://ethereum.github.io/solc-bin/ but this page + stopped being updated just after the release of version 0.7.2, will not receive any new releases + or nightly builds for any platform and does not serve the new directory structure, including + non-emscripten builds. + + If you are using it, please switch to https://binaries.soliditylang.org, which is a drop-in + replacement. This allows us to make changes to the underlying hosting in a transparent way and + minimize disruption. Unlike the ``ethereum.github.io`` domain, which we do not have any control + over, ``binaries.soliditylang.org`` is guaranteed to work and maintain the same URL structure + in the long-term. + +.. _IPFS: https://ipfs.io +.. _Swarm: https://swarm-gateways.net/bzz:/swarm.eth +.. _solc-bin: https://github.com/ethereum/solc-bin/ +.. _Solidity release page on github: https://github.com/ethereum/solidity/releases +.. _sha3sum: https://github.com/maandree/sha3sum +.. _keccak256() function from ethereumjs-util: https://github.com/ethereumjs/ethereumjs-util/blob/master/docs/modules/_hash_.md#const-keccak256 +.. _WebAssembly builds: https://emscripten.org/docs/compiling/WebAssembly.html +.. _QmTLs5MuLEWXQkths41HiACoXDiH8zxyqBHGFDRSzVE5CS: https://gateway.ipfs.io/ipfs/QmTLs5MuLEWXQkths41HiACoXDiH8zxyqBHGFDRSzVE5CS +.. _16c5f09109c793db99fe35f037c6092b061bd39260ee7a677c8a97f18c955ab1: https://swarm-gateways.net/bzz:/16c5f09109c793db99fe35f037c6092b061bd39260ee7a677c8a97f18c955ab1/ + .. _building-from-source: Building from Source From 8044ea602ca4f809047c3f3e6d1fe09b13c0e174 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Thu, 19 Nov 2020 18:36:20 +0100 Subject: [PATCH 11/18] installing-solidity.rst: Capitalize headers and the project name --- docs/installing-solidity.rst | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/installing-solidity.rst b/docs/installing-solidity.rst index 880fa0be5..e7e2d73e7 100644 --- a/docs/installing-solidity.rst +++ b/docs/installing-solidity.rst @@ -92,7 +92,7 @@ When using this interface it is not necessary to mount any directories. docker run ethereum/solc:stable --standard-json < input.json > output.json -Linux packages +Linux Packages ============== Binary packages of Solidity are available at @@ -143,14 +143,14 @@ Arch Linux also has packages, albeit limited to the latest development version: pacman -S solidity -Gentoo Linux has an `Ethereum overlay `_ that contains a solidity package. +Gentoo Linux has an `Ethereum overlay `_ that contains a Solidity package. After the overlay is setup, ``solc`` can be installed in x86_64 architectures by: .. code-block:: bash emerge dev-lang/solidity -macOS packages +macOS Packages ============== We distribute the Solidity compiler through Homebrew @@ -378,7 +378,7 @@ If you already have one IDE and only need the compiler and libraries, you could install Visual Studio 2019 Build Tools. Visual Studio 2019 provides both IDE and necessary compiler and libraries. -So if you have not got an IDE and prefer to develop solidity, Visual Studio 2019 +So if you have not got an IDE and prefer to develop Solidity, Visual Studio 2019 may be a choice for you to get everything setup easily. Here is the list of components that should be installed @@ -490,7 +490,7 @@ Alternatively, you can build for Windows on the command-line, like so: cmake --build . --config Release -CMake options +CMake Options ============= If you are interested what CMake options are available run ``cmake .. -LH``. @@ -518,7 +518,7 @@ Inside the build folder you can disable them, since they are enabled by default: # disables both Z3 and CVC4 cmake .. -DUSE_CVC4=OFF -DUSE_Z3=OFF -The version string in detail +The Version String in Detail ============================ The Solidity version string contains four parts: @@ -537,7 +537,7 @@ A release example: ``0.4.8+commit.60cc1668.Emscripten.clang``. A pre-release example: ``0.4.9-nightly.2017.1.17+commit.6ecb4aa3.Emscripten.clang`` -Important information about versioning +Important Information About Versioning ====================================== After a release is made, the patch version level is bumped, because we assume that only From bd1989bd0bba90f8e14648e06c1c0e66b176b9b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Sat, 14 Nov 2020 00:20:52 +0100 Subject: [PATCH 12/18] CommandLineInterface::link(): Rename confusingly named "name" to "foundPlaceholder" --- solc/CommandLineInterface.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp index 64ef533a5..47af37d46 100644 --- a/solc/CommandLineInterface.cpp +++ b/solc/CommandLineInterface.cpp @@ -1786,14 +1786,14 @@ bool CommandLineInterface::link() return false; } - string name(it, it + placeholderSize); - if (librariesReplacements.count(name)) + string foundPlaceholder(it, it + placeholderSize); + if (librariesReplacements.count(foundPlaceholder)) { - string hexStr(toHex(librariesReplacements.at(name).asBytes())); + string hexStr(toHex(librariesReplacements.at(foundPlaceholder).asBytes())); copy(hexStr.begin(), hexStr.end(), it); } else - serr() << "Reference \"" << name << "\" in file \"" << src.first << "\" still unresolved." << endl; + serr() << "Reference \"" << foundPlaceholder << "\" in file \"" << src.first << "\" still unresolved." << endl; it += placeholderSize; } // Remove hints for resolved libraries. From f099d48b341e4e3be91aa40a2cc5db1ca9d9e858 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Sat, 14 Nov 2020 00:24:08 +0100 Subject: [PATCH 13/18] CommandLineInterface::link(): Report an error if a placeholder does not have exactly four underscores --- solc/CommandLineInterface.cpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp index 47af37d46..7d3f7d763 100644 --- a/solc/CommandLineInterface.cpp +++ b/solc/CommandLineInterface.cpp @@ -1780,9 +1780,14 @@ bool CommandLineInterface::link() { while (it != end && *it != '_') ++it; if (it == end) break; - if (end - it < placeholderSize) + if ( + end - it < placeholderSize || + *(it + 1) != '_' || + *(it + placeholderSize - 2) != '_' || + *(it + placeholderSize - 1) != '_' + ) { - serr() << "Error in binary object file " << src.first << " at position " << (end - src.second.begin()) << endl; + serr() << "Error in binary object file " << src.first << " at position " << (it - src.second.begin()) << endl; return false; } From 2a8cff626b9be044a165475b70eef379f5bc7535 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Thu, 19 Nov 2020 19:57:35 +0100 Subject: [PATCH 14/18] CommandLineInterface::link(): Print invalid link references to stderr --- solc/CommandLineInterface.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp index 7d3f7d763..b74cc224f 100644 --- a/solc/CommandLineInterface.cpp +++ b/solc/CommandLineInterface.cpp @@ -55,6 +55,7 @@ #include #include +#include #include #include @@ -1788,6 +1789,7 @@ bool CommandLineInterface::link() ) { serr() << "Error in binary object file " << src.first << " at position " << (it - src.second.begin()) << endl; + serr() << '"' << string(it, it + min(placeholderSize, static_cast(end - it))) << "\" is not a valid link reference." << endl; return false; } From eea6513b5dd05dc1b7c3d83d42ba347c859ec456 Mon Sep 17 00:00:00 2001 From: Djordje Mijovic Date: Mon, 23 Nov 2020 15:17:11 +0100 Subject: [PATCH 15/18] [Sol->Yul] Implementing copying dynamically encoded structs from calldata to memory Co-authored-by: Leonardo --- libsolidity/codegen/ABIFunctions.h | 7 ++- libsolidity/codegen/YulUtilFunctions.cpp | 14 +++--- .../calldata/calldata_nested_structs.sol | 49 +++++++++++++++++++ ...ata_struct_as_argument_of_lib_function.sol | 29 +++++++++++ .../calldata_struct_as_memory_argument.sol | 23 +++++++++ ...data_struct_to_memory_tuple_assignment.sol | 22 +++++++++ ...ata_struct_with_nested_array_to_memory.sol | 23 +++++++++ 7 files changed, 159 insertions(+), 8 deletions(-) create mode 100644 test/libsolidity/semanticTests/structs/calldata/calldata_nested_structs.sol create mode 100644 test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_argument_of_lib_function.sol create mode 100644 test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_memory_argument.sol create mode 100644 test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory_tuple_assignment.sol create mode 100644 test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_memory.sol diff --git a/libsolidity/codegen/ABIFunctions.h b/libsolidity/codegen/ABIFunctions.h index 2b5bffd46..b90494168 100644 --- a/libsolidity/codegen/ABIFunctions.h +++ b/libsolidity/codegen/ABIFunctions.h @@ -170,6 +170,11 @@ public: /// signature: (dataOffset, length, dataEnd) -> decodedArray std::string abiDecodingFunctionArrayAvailableLength(ArrayType const& _type, bool _fromMemory); + /// Internal decoding function that is also used by some copying routines. + /// @returns the name of a function that decodes structs. + /// signature: (dataStart, dataEnd) -> decodedStruct + std::string abiDecodingFunctionStruct(StructType const& _type, bool _fromMemory); + private: /// Part of @a abiEncodingFunction for array target type and given calldata array. /// Uses calldatacopy and does not perform cleanup or validation and can therefore only @@ -245,8 +250,6 @@ private: std::string abiDecodingFunctionCalldataStruct(StructType const& _type); /// Part of @a abiDecodingFunction for array types. std::string abiDecodingFunctionFunctionType(FunctionType const& _type, bool _fromMemory, bool _forUseOnStack); - /// Part of @a abiDecodingFunction for struct types. - std::string abiDecodingFunctionStruct(StructType const& _type, bool _fromMemory); /// @returns the name of a function that retrieves an element from calldata. std::string calldataAccessFunction(Type const& _type); diff --git a/libsolidity/codegen/YulUtilFunctions.cpp b/libsolidity/codegen/YulUtilFunctions.cpp index 202f95499..791e8b5b9 100644 --- a/libsolidity/codegen/YulUtilFunctions.cpp +++ b/libsolidity/codegen/YulUtilFunctions.cpp @@ -2992,14 +2992,16 @@ string YulUtilFunctions::conversionFunction(Type const& _from, Type const& _to) solUnimplementedAssert(fromStructType.location() != DataLocation::Memory, ""); if (fromStructType.location() == DataLocation::CallData) - { - solUnimplementedAssert(!fromStructType.isDynamicallyEncoded(), ""); body = Whiskers(R"( converted := (value, calldatasize()) - )")("abiDecode", ABIFunctions(m_evmVersion, m_revertStrings, m_functionCollector).tupleDecoder( - {&toStructType} - )).render(); - } + )") + ( + "abiDecode", + ABIFunctions(m_evmVersion, m_revertStrings, m_functionCollector).abiDecodingFunctionStruct( + toStructType, + false + ) + ).render(); else { solAssert(fromStructType.location() == DataLocation::Storage, ""); diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_nested_structs.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_nested_structs.sol new file mode 100644 index 000000000..ee9527236 --- /dev/null +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_nested_structs.sol @@ -0,0 +1,49 @@ +pragma experimental ABIEncoderV2; + +contract C { + struct S { + uint128 p1; + uint256[][2] a; + uint32 p2; + } + + struct S1 { + uint128 u; + S s; + } + + struct S2 { + S[2] array; + } + + function f1(S1 calldata c) internal returns(S1 calldata) { + return c; + } + + function f(S1 calldata c, uint32 p) external returns(uint32, uint128, uint256, uint256, uint32) { + S1 memory m = f1(c); + assert(m.s.a[0][0] == c.s.a[0][0]); + assert(m.s.a[1][1] == c.s.a[1][1]); + return (p, m.s.p1, m.s.a[0][0], m.s.a[1][1], m.s.p2); + } + + function g(S2 calldata c) external returns(uint128, uint256, uint256, uint32) { + S2 memory m = c; + assert(m.array[0].a[0][0] == c.array[0].a[0][0]); + assert(m.array[0].a[1][1] == c.array[0].a[1][1]); + return (m.array[1].p1, m.array[1].a[0][0], m.array[1].a[1][1], m.array[1].p2); + } + + function h(S1 calldata c, uint32 p) external returns(uint32, uint128, uint256, uint256, uint32) { + S memory m = c.s; + assert(m.a[0][0] == c.s.a[0][0]); + assert(m.a[1][1] == c.s.a[1][1]); + return (p, m.p1, m.a[0][0], m.a[1][1], m.p2); + } +} +// ==== +// compileViaYul: true +// ---- +// f((uint128, (uint128, uint256[][2], uint32)), uint32): 0x40, 44, 11, 0x40, 22, 0x60, 33, 0x40, 0x40, 2, 1, 2 -> 44, 22, 1, 2, 33 +// g(((uint128, uint256[][2], uint32)[2])): 0x20, 0x20, 0x40, 0x40, 22, 0x60, 33, 0x40, 0x40, 2, 1, 2 -> 22, 1, 2, 33 +// h((uint128, (uint128, uint256[][2], uint32)), uint32): 0x40, 44, 11, 0x40, 22, 0x60, 33, 0x40, 0x40, 2, 1, 2 -> 44, 22, 1, 2, 33 diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_argument_of_lib_function.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_argument_of_lib_function.sol new file mode 100644 index 000000000..c44c5cd2a --- /dev/null +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_argument_of_lib_function.sol @@ -0,0 +1,29 @@ +pragma experimental ABIEncoderV2; + +struct S { + uint128 p1; + uint256[][2] a; + uint32 p2; +} +struct S1 { + uint128 u; + S s; +} + +library L { + function f(S1 memory m, uint32 p) external returns(uint32, uint128, uint256, uint256, uint32) { + return (p, m.s.p1, m.s.a[0][0], m.s.a[1][1], m.s.p2); + } +} + +contract C { + + function f(S1 calldata c, uint32 p) external returns(uint32, uint128, uint256, uint256, uint32) { + return L.f(c, p); + } +} +// ==== +// compileViaYul: true +// ---- +// library: L +// f((uint128, (uint128, uint256[][2], uint32)), uint32): 0x40, 44, 11, 0x40, 22, 0x60, 33, 0x40, 0x40, 2, 1, 2 -> 44, 22, 1, 2, 33 diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_memory_argument.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_memory_argument.sol new file mode 100644 index 000000000..71b55abf4 --- /dev/null +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_as_memory_argument.sol @@ -0,0 +1,23 @@ +pragma experimental ABIEncoderV2; + +contract C { + struct S { + uint128 p1; + uint256[][2] a; + uint32 p2; + } + + function g(uint32 p1, S memory s) internal returns(uint32, uint128, uint256, uint256, uint32) { + s.p1++; + s.a[0][1]++; + return (p1, s.p1, s.a[0][0], s.a[1][1], s.p2); + } + + function f(uint32 p1, S calldata c) external returns(uint32, uint128, uint256, uint256, uint32) { + return g(p1, c); + } +} +// ==== +// compileViaYul: true +// ---- +// f(uint32, (uint128, uint256[][2], uint32)): 55, 0x40, 77, 0x60, 88, 0x40, 0x40, 2, 1, 2 -> 55, 78, 1, 2, 88 diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory_tuple_assignment.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory_tuple_assignment.sol new file mode 100644 index 000000000..9bf1d1f48 --- /dev/null +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory_tuple_assignment.sol @@ -0,0 +1,22 @@ +pragma experimental ABIEncoderV2; + +contract C { + struct S { + uint128 p1; + uint256[][2] a; + uint32 p2; + } + + function f(uint32 p1, S calldata c) external returns(uint32, uint128, uint256, uint256, uint32) { + S memory m; + uint32 p2; + (p2, m) = (p1, c); + m.p1++; + m.a[0][1]++; + return (p2, m.p1, m.a[0][0], m.a[1][1], m.p2); + } +} +// ==== +// compileViaYul: true +// ---- +// f(uint32, (uint128, uint256[][2], uint32)): 55, 0x40, 77, 0x60, 88, 0x40, 0x40, 2, 1, 2 -> 55, 78, 1, 2, 88 diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_memory.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_memory.sol new file mode 100644 index 000000000..9ad5bed9c --- /dev/null +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_memory.sol @@ -0,0 +1,23 @@ +pragma experimental ABIEncoderV2; + +contract C { + struct S { + uint128 p1; + uint256[][2] a; + uint32 p2; + } + function f(uint32 p1, S calldata c) external returns(uint32, uint128, uint256, uint256, uint32) { + S memory s = c; + assert(s.a[0][0] == c.a[0][0]); + assert(s.a[1][1] == c.a[1][1]); + s.p1++; + assert(s.p1 != c.p1); + s.a[0][1]++; + assert(s.a[0][1] != c.a[0][1]); + return (p1, s.p1, s.a[0][0], s.a[1][1], s.p2); + } +} +// ==== +// compileViaYul: true +// ---- +// f(uint32, (uint128, uint256[][2], uint32)): 55, 0x40, 77, 0x60, 88, 0x40, 0x40, 2, 1, 2 -> 55, 78, 1, 2, 88 From 409e92580f76971b0663cb0ba5d9f428a411efee Mon Sep 17 00:00:00 2001 From: chriseth Date: Thu, 19 Nov 2020 11:00:18 +0100 Subject: [PATCH 16/18] Do not allocate memory objects if they will be assigned directly. --- Changelog.md | 2 ++ libsolidity/codegen/ContractCompiler.cpp | 17 ++++++++--- libsolidity/codegen/ContractCompiler.h | 5 +++- .../memoryManagement/assembly_access.sol | 14 +++++++++ .../memoryManagement/return_variable.sol | 30 +++++++++++++++++++ .../static_memory_array_allocation.sol | 24 +++++++++++++++ .../memoryManagement/struct_allocation.sol | 24 +++++++++++++++ .../access_in_assignment_dynamic_array.sol | 7 +++++ .../scoping/access_in_assignment_struct.sol | 8 +++++ 9 files changed, 126 insertions(+), 5 deletions(-) create mode 100644 test/libsolidity/semanticTests/memoryManagement/assembly_access.sol create mode 100644 test/libsolidity/semanticTests/memoryManagement/return_variable.sol create mode 100644 test/libsolidity/semanticTests/memoryManagement/static_memory_array_allocation.sol create mode 100644 test/libsolidity/semanticTests/memoryManagement/struct_allocation.sol create mode 100644 test/libsolidity/syntaxTests/scoping/access_in_assignment_dynamic_array.sol create mode 100644 test/libsolidity/syntaxTests/scoping/access_in_assignment_struct.sol diff --git a/Changelog.md b/Changelog.md index e113a9997..c51fc2a54 100644 --- a/Changelog.md +++ b/Changelog.md @@ -4,9 +4,11 @@ Language Features: * The fallback function can now also have a single ``calldata`` argument (equaling ``msg.data``) and return ``bytes memory`` (which will not be ABI-encoded but returned as-is). Compiler Features: + * Code Generator: Avoid memory allocation for default value if it is not used. * SMTChecker: Support named arguments in function calls. * SMTChecker: Support struct constructor. + ### 0.7.5 (2020-11-18) Language Features: diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp index 66c67f59a..a73166507 100644 --- a/libsolidity/codegen/ContractCompiler.cpp +++ b/libsolidity/codegen/ContractCompiler.cpp @@ -612,7 +612,7 @@ bool ContractCompiler::visit(FunctionDefinition const& _function) } for (ASTPointer const& variable: _function.returnParameters()) - appendStackVariableInitialisation(*variable); + appendStackVariableInitialisation(*variable, /* _provideDefaultValue = */ true); if (_function.isConstructor()) if (auto c = dynamic_cast(*_function.scope()).nextConstructor( @@ -1230,7 +1230,7 @@ bool ContractCompiler::visit(VariableDeclarationStatement const& _variableDeclar // and freed in the end of their scope. for (auto decl: _variableDeclarationStatement.declarations()) if (decl) - appendStackVariableInitialisation(*decl); + appendStackVariableInitialisation(*decl, !_variableDeclarationStatement.initialValue()); StackHeightChecker checker(m_context); if (Expression const* expression = _variableDeclarationStatement.initialValue()) @@ -1376,11 +1376,20 @@ void ContractCompiler::appendModifierOrFunctionCode() m_context.setModifierDepth(m_modifierDepth); } -void ContractCompiler::appendStackVariableInitialisation(VariableDeclaration const& _variable) +void ContractCompiler::appendStackVariableInitialisation( + VariableDeclaration const& _variable, + bool _provideDefaultValue +) { CompilerContext::LocationSetter location(m_context, _variable); m_context.addVariable(_variable); - CompilerUtils(m_context).pushZeroValue(*_variable.annotation().type); + if (!_provideDefaultValue && _variable.type()->dataStoredIn(DataLocation::Memory)) + { + solAssert(_variable.type()->sizeOnStack() == 1, ""); + m_context << u256(0); + } + else + CompilerUtils(m_context).pushZeroValue(*_variable.annotation().type); } void ContractCompiler::compileExpression(Expression const& _expression, TypePointer const& _targetType) diff --git a/libsolidity/codegen/ContractCompiler.h b/libsolidity/codegen/ContractCompiler.h index 64c86fc2d..d3290a4c7 100644 --- a/libsolidity/codegen/ContractCompiler.h +++ b/libsolidity/codegen/ContractCompiler.h @@ -130,7 +130,10 @@ private: /// body itself if the last modifier was reached. void appendModifierOrFunctionCode(); - void appendStackVariableInitialisation(VariableDeclaration const& _variable); + /// Creates a stack slot for the given variable and assigns a default value. + /// If the default value is complex (needs memory allocation) and @a _provideDefaultValue + /// is false, this might be skipped. + void appendStackVariableInitialisation(VariableDeclaration const& _variable, bool _provideDefaultValue); void compileExpression(Expression const& _expression, TypePointer const& _targetType = TypePointer()); /// Frees the variables of a certain scope (to be used when leaving). diff --git a/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol b/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol new file mode 100644 index 000000000..449edc304 --- /dev/null +++ b/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol @@ -0,0 +1,14 @@ +contract C { + function f() public pure { + uint[] memory x; + uint y; + assembly { + y := x + } + assert(y != 0); + } +} +// ==== +// compileViaYul: also +// ---- +// f() -> diff --git a/test/libsolidity/semanticTests/memoryManagement/return_variable.sol b/test/libsolidity/semanticTests/memoryManagement/return_variable.sol new file mode 100644 index 000000000..501fea0f1 --- /dev/null +++ b/test/libsolidity/semanticTests/memoryManagement/return_variable.sol @@ -0,0 +1,30 @@ +contract C { + function memorySize() internal pure returns (uint s) { + assembly { s := mload(0x40) } + } + function f() public returns (uint, uint, uint) { + uint a = memorySize(); + g(); + uint b = memorySize(); + h(); + uint c = memorySize(); + i(); + uint d = memorySize(); + return (b - a, c - b, d - c); + } + // In these functions, we do allocate memory in both cases. + // In `i()`, this could be avoided but we would have to check + // that all code paths return explicitly and provide a value. + function g() internal returns (uint[40] memory) { + } + function h() internal returns (uint[40] memory t) { + } + function i() internal returns (uint[40] memory) { + uint[40] memory x; + return x; + } +} +// ==== +// compileViaYul: also +// ---- +// f() -> 0x0500, 0x0500, 0x0a00 diff --git a/test/libsolidity/semanticTests/memoryManagement/static_memory_array_allocation.sol b/test/libsolidity/semanticTests/memoryManagement/static_memory_array_allocation.sol new file mode 100644 index 000000000..868d532b8 --- /dev/null +++ b/test/libsolidity/semanticTests/memoryManagement/static_memory_array_allocation.sol @@ -0,0 +1,24 @@ +contract C { + function memorySize() internal pure returns (uint s) { + assembly { s := mload(0x40) } + } + function withValue() public pure returns (uint) { + uint[20] memory x; + uint memorySizeBefore = memorySize(); + uint[20] memory t = x; + uint memorySizeAfter = memorySize(); + return memorySizeAfter - memorySizeBefore; + } + function withoutValue() public pure returns (uint) { + uint[20] memory x; + uint memorySizeBefore = memorySize(); + uint[20] memory t; + uint memorySizeAfter = memorySize(); + return memorySizeAfter - memorySizeBefore; + } +} +// ==== +// compileViaYul: also +// ---- +// withValue() -> 0x00 +// withoutValue() -> 0x0280 diff --git a/test/libsolidity/semanticTests/memoryManagement/struct_allocation.sol b/test/libsolidity/semanticTests/memoryManagement/struct_allocation.sol new file mode 100644 index 000000000..68a52182b --- /dev/null +++ b/test/libsolidity/semanticTests/memoryManagement/struct_allocation.sol @@ -0,0 +1,24 @@ +contract C { + struct S { uint x; uint y; uint z; } + function memorySize() internal pure returns (uint s) { + assembly { s := mload(0x40) } + } + function withValue() public pure returns (uint) { + S memory x = S(1, 2, 3); + uint memorySizeBefore = memorySize(); + S memory t = x; + uint memorySizeAfter = memorySize(); + return memorySizeAfter - memorySizeBefore; + } + function withoutValue() public pure returns (uint) { + uint memorySizeBefore = memorySize(); + S memory t; + uint memorySizeAfter = memorySize(); + return memorySizeAfter - memorySizeBefore; + } +} +// ==== +// compileViaYul: also +// ---- +// withValue() -> 0x00 +// withoutValue() -> 0x60 diff --git a/test/libsolidity/syntaxTests/scoping/access_in_assignment_dynamic_array.sol b/test/libsolidity/syntaxTests/scoping/access_in_assignment_dynamic_array.sol new file mode 100644 index 000000000..12454b740 --- /dev/null +++ b/test/libsolidity/syntaxTests/scoping/access_in_assignment_dynamic_array.sol @@ -0,0 +1,7 @@ +contract C { + function f() public pure { + uint[] memory x = x[0]; + } +} +// ---- +// DeclarationError 7576: (70-71): Undeclared identifier. "x" is not (or not yet) visible at this point. diff --git a/test/libsolidity/syntaxTests/scoping/access_in_assignment_struct.sol b/test/libsolidity/syntaxTests/scoping/access_in_assignment_struct.sol new file mode 100644 index 000000000..152ee038e --- /dev/null +++ b/test/libsolidity/syntaxTests/scoping/access_in_assignment_struct.sol @@ -0,0 +1,8 @@ +contract C { + struct S { uint y; } + function f() public pure { + S memory x = x.y; + } +} +// ---- +// DeclarationError 7576: (90-91): Undeclared identifier. "x" is not (or not yet) visible at this point. From dbb24484e90484f2f183023a52da5f0d7d0912f4 Mon Sep 17 00:00:00 2001 From: chriseth Date: Tue, 24 Nov 2020 14:39:37 +0100 Subject: [PATCH 17/18] Update test/libsolidity/semanticTests/memoryManagement/assembly_access.sol MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Kamil Śliwak --- .../semanticTests/memoryManagement/assembly_access.sol | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol b/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol index 449edc304..15e171dfc 100644 --- a/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol +++ b/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol @@ -5,6 +5,8 @@ contract C { assembly { y := x } + // The value of an uninitialized dynamic array is not zero but rather + // an address of a location in memory that has the value of zero. assert(y != 0); } } From 79669ecd48f65298f981ce82829f225dac16b6bc Mon Sep 17 00:00:00 2001 From: chriseth Date: Mon, 23 Nov 2020 19:06:44 +0100 Subject: [PATCH 18/18] Use new abicoder pragma. --- .../abiencoderv2_no_warning/input.sol | 2 +- .../combined_json_generated_sources/input.sol | 4 +- test/cmdlineTests/name_simplifier/input.sol | 2 +- .../standard_generatedSources/input.json | 2 +- .../standard_generatedSources/output.json | 2 +- .../input.json | 2 +- .../output.json | 2 +- test/externalTests/common.sh | 10 ++-- test/libsolidity/ABIJson/event_structs.sol | 2 +- test/libsolidity/ABIJson/global_struct.sol | 2 +- test/libsolidity/ABIJson/return_structs.sol | 2 +- .../ABIJson/return_structs_with_contracts.sol | 2 +- .../ABIJson/structs_in_libraries.sol | 2 +- test/libsolidity/SolidityEndToEndTest.cpp | 50 ++++++++++--------- .../SolidityExecutionFramework.cpp | 7 +-- .../SolidityNameAndTypeResolution.cpp | 4 +- test/libsolidity/gasTests/abiv2.sol | 2 +- test/libsolidity/gasTests/abiv2_optimised.sol | 2 +- test/libsolidity/gasTests/exp.sol | 2 +- test/libsolidity/gasTests/exp_optimized.sol | 2 +- .../abi_decode_static_array_v2.sol | 2 +- .../abiEncoderV1/abi_decode_v2.sol | 2 +- .../abiEncoderV1/abi_decode_v2_calldata.sol | 2 +- .../abiEncoderV1/abi_decode_v2_storage.sol | 2 +- .../abi_encode_calldata_slice.sol | 2 +- .../abi_encode_empty_string_v2.sol | 2 +- .../abiEncoderV2/abi_encode_rational_v2.sol | 2 +- .../abiEncoderV2/abi_encode_v2.sol | 2 +- ...2_in_function_inherited_in_v1_contract.sol | 2 +- ...ode_v2_in_modifier_used_in_v1_contract.sol | 2 +- .../abiEncoderV2/bool_out_of_bounds.sol | 2 +- .../abiEncoderV2/byte_arrays.sol | 2 +- .../abiEncoderV2/calldata_array.sol | 2 +- .../abiEncoderV2/calldata_array_dynamic.sol | 2 +- .../calldata_array_dynamic_index_access.sol | 2 +- .../calldata_array_dynamic_static_dynamic.sol | 2 +- ...data_array_dynamic_static_short_decode.sol | 2 +- ...ta_array_dynamic_static_short_reencode.sol | 2 +- .../calldata_array_function_types.sol | 2 +- .../calldata_array_multi_dynamic.sol | 2 +- .../abiEncoderV2/calldata_array_static.sol | 2 +- .../calldata_array_static_dynamic_static.sol | 2 +- .../calldata_array_static_index_access.sol | 2 +- .../calldata_array_struct_dynamic.sol | 2 +- .../calldata_array_two_dynamic.sol | 2 +- .../calldata_array_two_static.sol | 2 +- .../abiEncoderV2/calldata_struct_dynamic.sol | 2 +- .../calldata_struct_member_offset.sol | 2 +- .../abiEncoderV2/calldata_struct_simple.sol | 2 +- .../abiEncoderV2/cleanup/address.sol | 2 +- .../abiEncoderV2/cleanup/bool.sol | 2 +- .../abiEncoderV2/cleanup/bytesx.sol | 2 +- .../abiEncoderV2/cleanup/cleanup.sol | 2 +- .../abiEncoderV2/cleanup/dynamic_array.sol | 2 +- .../abiEncoderV2/cleanup/function.sol | 2 +- .../abiEncoderV2/cleanup/intx.sol | 2 +- .../abiEncoderV2/cleanup/simple_struct.sol | 2 +- .../abiEncoderV2/cleanup/static_array.sol | 2 +- .../abiEncoderV2/cleanup/uintx.sol | 2 +- .../abiEncoderV2/dynamic_arrays.sol | 2 +- .../abiEncoderV2/dynamic_nested_arrays.sol | 2 +- .../semanticTests/abiEncoderV2/enums.sol | 2 +- .../memory_params_in_external_function.sol | 2 +- .../abiEncoderV2/storage_array_encoding.sol | 2 +- .../abiEncoderV2/struct/mediocre2_struct.sol | 2 +- .../abiEncoderV2/struct/mediocre_struct.sol | 2 +- .../abiEncoderV2/struct/struct_function.sol | 2 +- .../abiEncoderV2/struct/struct_short.sol | 2 +- .../abiEncoderV2/struct/struct_simple.sol | 2 +- .../abiEncoderV2/struct/struct_validation.sol | 2 +- ...validation_function_type_inside_struct.sol | 2 +- .../abiencodedecode/contract_array_v2.sol | 2 +- .../semanticTests/array/calldata_array.sol | 2 +- .../array/calldata_array_dynamic_invalid.sol | 2 +- ...ta_array_dynamic_invalid_static_middle.sol | 2 +- .../array/calldata_array_of_struct.sol | 2 +- .../array/calldata_array_two_dimensional.sol | 2 +- .../calldata_array_two_dimensional_1.sol | 2 +- .../array/calldata_bytes_array_bounds.sol | 2 +- .../array_nested_calldata_to_storage.sol | 2 +- .../array_of_struct_calldata_to_storage.sol | 2 +- ..._containing_arrays_calldata_to_storage.sol | 2 +- ...ts_containing_arrays_memory_to_storage.sol | 2 +- .../calldata_array_dynamic_to_storage.sol | 2 +- .../calldata_array_of_struct_to_memory.sol | 2 +- .../calldata_bytes_array_to_memory.sol | 2 +- .../calldata_dynamic_array_to_memory.sol | 2 +- .../copy_byte_array_in_struct_to_storage.sol | 2 +- .../copying/storage_memory_nested_bytes.sol | 2 +- .../calldata/calldata_array_dynamic_bytes.sol | 2 +- .../calldata_internal_multi_array.sol | 2 +- .../calldata/calldata_string_array.sol | 2 +- .../calldata/calldata_struct_cleaning.sol | 2 +- .../calldata/calldata_struct_internal.sol | 2 +- .../cleanup/bool_conversion_v2.sol | 2 +- .../cleanup/cleanup_address_types_v2.sol | 2 +- .../cleanup/cleanup_bytes_types_v2.sol | 2 +- .../ecrecover/ecrecover_abiV2.sol | 2 +- .../library_function_selectors_struct.sol | 2 +- .../library_return_struct_with_mapping.sol | 2 +- .../semanticTests/literals/escape.sol | 2 +- .../shifts/shift_right_garbled_signed_v2.sol | 2 +- .../shifts/shift_right_garbled_v2.sol | 2 +- ...ht_negative_lvalue_signextend_int16_v2.sol | 2 +- ...ht_negative_lvalue_signextend_int32_v2.sol | 2 +- ...ght_negative_lvalue_signextend_int8_v2.sol | 2 +- .../calldata_array_dynamic_invalid.sol | 2 +- ...data_array_dynamic_static_short_decode.sol | 2 +- ...ta_array_dynamic_static_short_reencode.sol | 2 +- .../calldata_array_invalid_length.sol | 2 +- .../calldata_arrays_too_large.sol | 2 +- .../revertStrings/calldata_tail_short.sol | 2 +- .../semanticTests/revertStrings/empty_v2.sol | 2 +- .../revertStrings/short_input_array.sol | 2 +- .../revertStrings/short_input_bytes.sol | 2 +- .../semanticTests/smoke/arrays.sol | 2 +- .../libsolidity/semanticTests/smoke/basic.sol | 2 +- .../semanticTests/smoke/structs.sol | 2 +- .../structs/calldata/calldata_struct.sol | 2 +- .../calldata/calldata_struct_and_ints.sol | 2 +- .../calldata/calldata_struct_array_member.sol | 2 +- .../calldata/calldata_struct_to_memory.sol | 2 +- .../calldata/calldata_struct_to_storage.sol | 2 +- ...ta_struct_with_nested_array_to_storage.sol | 2 +- .../structs/calldata/calldata_structs.sol | 2 +- .../structs/calldata/dynamic_nested.sol | 2 +- .../structs/calldata/dynamically_encoded.sol | 2 +- .../semanticTests/structs/global.sol | 2 +- .../memory_struct_named_constructor.sol | 2 +- .../struct_delete_storage_with_array.sol | 2 +- .../structs/struct_memory_to_storage.sol | 2 +- .../struct_memory_to_storage_function_ptr.sol | 2 +- .../structs/struct_storage_to_memory.sol | 2 +- .../struct_storage_to_memory_function_ptr.sol | 2 +- .../types/mapping_enum_key_getter_v2.sol | 2 +- ...ublic_state_overridding_dynamic_struct.sol | 2 +- ..._overridding_mapping_to_dynamic_struct.sol | 2 +- .../various/nested_calldata_struct.sol | 2 +- .../nested_calldata_struct_to_memory.sol | 2 +- ...or_static_arrays_with_dynamic_elements.sol | 2 +- .../viaYul/calldata_array_access.sol | 2 +- .../calldata_array_index_range_access.sol | 2 +- .../viaYul/calldata_array_length.sol | 2 +- .../calldata_array_three_dimensional.sol | 2 +- .../viaYul/calldata_bytes_array_bounds.sol | 2 +- .../viaYul/dirty_calldata_struct.sol | 2 +- .../viaYul/mapping_enum_key_getter.sol | 2 +- .../viaYul/struct_member_access.sol | 2 +- ...ngth_1d_assignment_2d_memory_to_memory.sol | 2 +- ...th_1d_assignment_2d_storage_to_storage.sol | 2 +- .../length_1d_copy_2d_memory_to_storage.sol | 2 +- .../length_1d_copy_2d_storage_to_memory.sol | 2 +- .../length_assignment_2d_memory_to_memory.sol | 2 +- .../functions/abi_encode_functions.sol | 2 +- .../types/array_aliasing_memory_1.sol | 2 +- .../types/array_aliasing_memory_2.sol | 2 +- .../types/array_aliasing_memory_3.sol | 2 +- .../smtCheckerTests/types/enum_in_struct.sol | 2 +- .../array_struct_array_struct_memory_safe.sol | 2 +- ...rray_struct_array_struct_memory_unsafe.sol | 2 +- ...array_struct_array_struct_storage_safe.sol | 2 +- .../types/struct/struct_aliasing_memory.sol | 2 +- .../struct_array_struct_array_memory_safe.sol | 2 +- ...uct_array_struct_array_memory_unsafe_1.sol | 2 +- ...uct_array_struct_array_memory_unsafe_2.sol | 2 +- .../types/struct/struct_delete_memory.sol | 2 +- .../types/struct/struct_delete_storage.sol | 2 +- .../types/struct/struct_unary_add.sol | 2 +- .../types/struct/struct_unary_sub.sol | 2 +- .../abiEncoder/conflicting_settings.sol | 2 +- ...rary_function_accepting_storage_struct.sol | 2 +- ...all_to_v2_constructor_accepting_struct.sol | 2 +- ...on_accepting_struct_via_named_argument.sol | 2 +- ...ract_function_pointer_accepting_struct.sol | 2 +- ...unction_returning_dynamic_string_array.sol | 2 +- ..._v2_contract_function_returning_struct.sol | 2 +- ...on_returning_struct_with_dynamic_array.sol | 2 +- .../v1_call_to_v2_event_accepting_struct.sol | 2 +- ...ibrary_bound_function_returning_struct.sol | 2 +- ...rary_function_accepting_storage_struct.sol | 2 +- ...o_v2_library_function_returning_struct.sol | 2 +- .../abiEncoder/v1_call_to_v2_modifier.sol | 2 +- .../v1_constructor_with_v2_modifier.sol | 2 +- ...ance_from_contract_calling_v2_function.sol | 2 +- ...itance_from_contract_defining_v2_event.sol | 2 +- ..._defining_v2_function_accepting_struct.sol | 2 +- ..._defining_v2_function_returning_struct.sol | 2 +- ...itance_from_contract_emitting_v2_event.sol | 2 +- .../v1_modifier_overriding_v2_modifier.sol | 2 +- .../abiEncoder/v1_v2_v1_modifier_mix.sol | 4 +- ..._dynamic_array_with_returndata_support.sol | 2 +- ...namic_array_without_returndata_support.sol | 2 +- ...all_to_v2_constructor_accepting_struct.sol | 4 +- ...ract_function_pointer_accepting_struct.sol | 4 +- ...unction_returning_dynamic_string_array.sol | 4 +- ..._v2_contract_function_returning_struct.sol | 4 +- ...on_returning_struct_with_dynamic_array.sol | 4 +- .../v2_call_to_v2_event_accepting_struct.sol | 4 +- ...rary_function_pointer_accepting_struct.sol | 4 +- ...o_v2_library_function_returning_struct.sol | 4 +- .../abiEncoder/v2_v1_v1_modifier_sandwich.sol | 2 +- .../abiEncoder/v2_v1_v2_modifier_sandwich.sol | 4 +- .../syntaxTests/array/calldata.sol | 2 +- .../syntaxTests/array/calldata_assign.sol | 2 +- .../syntaxTests/array/calldata_dynamic.sol | 2 +- .../syntaxTests/array/calldata_multi.sol | 2 +- .../array/calldata_multi_dynamic.sol | 2 +- .../syntaxTests/array/function_mapping.sol | 2 +- .../array/function_mapping_library.sol | 2 +- .../parameter_too_large_multidim_ABIv2.sol | 2 +- .../array/nested_calldata_memory.sol | 2 +- .../array/nested_calldata_memory2.sol | 2 +- .../array/nested_calldata_memory3.sol | 2 +- .../array/nested_calldata_storage.sol | 2 +- .../array/nested_calldata_storage2.sol | 2 +- ..._of_string_literals_to_calldata_string.sol | 2 +- .../events/event_array_indexed_v2.sol | 2 +- .../syntaxTests/events/event_array_v2.sol | 2 +- .../events/event_nested_array_indexed_v2.sol | 2 +- .../events/event_nested_array_v2.sol | 2 +- .../events/event_struct_indexed_v2.sol | 2 +- .../syntaxTests/events/event_struct_v2.sol | 2 +- .../iceRegressionTests/large_struct_array.sol | 2 +- .../imports/inheritance_abi_encoder_match.sol | 6 +-- .../inheritance_abi_encoder_mismatch_1.sol | 4 +- .../inheritance_abi_encoder_mismatch_2.sol | 2 +- .../syntaxTests/imports/transitive.sol | 2 +- .../calldata_memory_interface_struct.sol | 2 +- .../override/calldata_memory_struct.sol | 2 +- ...var_override_mapping_to_dynamic_struct.sol | 2 +- ...ar_override_struct_with_memory_element.sol | 2 +- .../lvalues/calldata_member_access.sol | 2 +- .../missing_functions_duplicate_bug.sol | 2 +- ...ns_with_identical_structs_in_interface.sol | 2 +- ...ns_with_different_structs_in_interface.sol | 2 +- ...cts_of_non_external_types_in_interface.sol | 2 +- ...s_of_non_external_types_in_interface_2.sol | 2 +- ...s_of_non_external_types_in_interface_2.sol | 2 +- ...non_external_types_in_interface_nested.sol | 2 +- ...non_external_types_in_interface_nested.sol | 2 +- ...rning_multi_dimensional_arrays_new_abi.sol | 2 +- ...47_returning_arrays_in_structs_new_abi.sol | 2 +- .../260_library_memory_struct.sol | 2 +- .../403_return_structs.sol | 2 +- .../404_read_returned_struct.sol | 2 +- .../parsing/array_range_nested.sol | 2 +- .../parsing/array_range_nested_invalid.sol | 2 +- ...i_encodePacked_nested_dynamic_array_v2.sol | 2 +- .../abi_encodePacked_structs_v2.sol | 2 +- .../abi_encode_nested_dynamic_array_v2.sol | 2 +- .../abi_encode_structs_abiv2.sol | 2 +- .../abi_decode_nested_dynamic_array_v2.sol | 2 +- .../abidecode/abi_decode_struct_v2.sol | 2 +- .../encode_array_of_struct.sol | 2 +- .../syntaxTests/structs/array_calldata.sol | 2 +- .../syntaxTests/structs/calldata.sol | 2 +- .../structs/calldata_array_assign.sol | 2 +- .../syntaxTests/structs/calldata_assign.sol | 2 +- .../syntaxTests/structs/calldata_dynamic.sol | 2 +- .../structs/calldata_struct_function_type.sol | 2 +- .../calldata_struct_mapping_function.sol | 2 +- .../structs/memory_to_calldata.sol | 2 +- .../recursion/multi_struct_composition.sol | 2 +- .../structs/recursion/parallel_structs.sol | 2 +- ..._struct_as_contract_function_parameter.sol | 2 +- ...t_as_memory_library_function_parameter.sol | 2 +- .../recursive_struct_forward_reference.sol | 2 +- .../recursive_struct_function_pointer.sol | 2 +- .../recursion/return_recursive_structs.sol | 2 +- .../recursion/return_recursive_structs2.sol | 2 +- .../recursion/return_recursive_structs3.sol | 2 +- .../encoding_fractional_abiencoderv2.sol | 2 +- ...ncoding_packed_fractional_abiencoderv2.sol | 2 +- .../types/mapping/library_nested_mapping.sol | 2 +- .../mapping/mapping_function_calldata.sol | 2 +- .../mapping_struct_data_location_memory.sol | 2 +- ..._struct_recusrive_data_location_memory.sol | 2 +- 277 files changed, 325 insertions(+), 320 deletions(-) diff --git a/test/cmdlineTests/abiencoderv2_no_warning/input.sol b/test/cmdlineTests/abiencoderv2_no_warning/input.sol index c2eb120f8..5a1dc985b 100644 --- a/test/cmdlineTests/abiencoderv2_no_warning/input.sol +++ b/test/cmdlineTests/abiencoderv2_no_warning/input.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.0; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint x; } diff --git a/test/cmdlineTests/combined_json_generated_sources/input.sol b/test/cmdlineTests/combined_json_generated_sources/input.sol index 7fce7aa65..b08878fb1 100644 --- a/test/cmdlineTests/combined_json_generated_sources/input.sol +++ b/test/cmdlineTests/combined_json_generated_sources/input.sol @@ -1,5 +1,5 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint[] calldata) pure external {} -} \ No newline at end of file +} diff --git a/test/cmdlineTests/name_simplifier/input.sol b/test/cmdlineTests/name_simplifier/input.sol index b1ca2565a..39034e275 100644 --- a/test/cmdlineTests/name_simplifier/input.sol +++ b/test/cmdlineTests/name_simplifier/input.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.0; -pragma experimental ABIEncoderV2; +pragma abicoder v2; // The point of this test is to check that the // AST IDs are removed from the optimized IR diff --git a/test/cmdlineTests/standard_generatedSources/input.json b/test/cmdlineTests/standard_generatedSources/input.json index 75537c4fb..a179db435 100644 --- a/test/cmdlineTests/standard_generatedSources/input.json +++ b/test/cmdlineTests/standard_generatedSources/input.json @@ -2,7 +2,7 @@ "language": "Solidity", "sources": { "a.sol": { - "content": "// SPDX-License-Identifier: GPL-3.0\npragma experimental ABIEncoderV2; contract A { function f(uint[] memory) public view returns (uint256) { } }" + "content": "// SPDX-License-Identifier: GPL-3.0\npragma abicoder v2; contract A { function f(uint[] memory) public view returns (uint256) { } }" } }, "settings": { diff --git a/test/cmdlineTests/standard_generatedSources/output.json b/test/cmdlineTests/standard_generatedSources/output.json index ee8f8df93..68ce41c71 100644 --- a/test/cmdlineTests/standard_generatedSources/output.json +++ b/test/cmdlineTests/standard_generatedSources/output.json @@ -82,5 +82,5 @@ } } -","id":1,"language":"Yul","name":"#utility.yul"}],"immutableReferences":{},"linkReferences":{},"object":"","opcodes":"","sourceMap":"70:74:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83:59;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;130:7;83:59;;;:::o;24:622:1:-;;145:80;160:64;217:6;160:64;:::i;:::-;145:80;:::i;:::-;136:89;;245:5;273:6;266:5;259:21;299:4;292:5;288:16;281:23;;324:6;374:3;366:4;358:6;354:17;349:3;345:27;342:36;339:2;;;391:1;388;381:12;339:2;419:1;404:236;429:6;426:1;423:13;404:236;;;496:3;524:37;557:3;545:10;524:37;:::i;:::-;519:3;512:50;591:4;586:3;582:14;575:21;;625:4;620:3;616:14;609:21;;464:176;451:1;448;444:9;439:14;;404:236;;;408:14;126:520;;;;;;;:::o;669:303::-;;789:3;782:4;774:6;770:17;766:27;756:2;;807:1;804;797:12;756:2;847:6;834:20;872:94;962:3;954:6;947:4;939:6;935:17;872:94;:::i;:::-;863:103;;746:226;;;;;:::o;978:139::-;;1062:6;1049:20;1040:29;;1078:33;1105:5;1078:33;:::i;:::-;1030:87;;;;:::o;1123:403::-;;1256:2;1244:9;1235:7;1231:23;1227:32;1224:2;;;1272:1;1269;1262:12;1224:2;1342:1;1331:9;1327:17;1314:31;1372:18;1364:6;1361:30;1358:2;;;1404:1;1401;1394:12;1358:2;1431:78;1501:7;1492:6;1481:9;1477:22;1431:78;:::i;:::-;1421:88;;1286:233;1214:312;;;;:::o;1532:118::-;1619:24;1637:5;1619:24;:::i;:::-;1614:3;1607:37;1597:53;;:::o;1656:222::-;;1787:2;1776:9;1772:18;1764:26;;1800:71;1868:1;1857:9;1853:17;1844:6;1800:71;:::i;:::-;1754:124;;;;:::o;1884:278::-;;1950:2;1944:9;1934:19;;1992:4;1984:6;1980:17;2099:6;2087:10;2084:22;2063:18;2051:10;2048:34;2045:62;2042:2;;;2110:13;;:::i;:::-;2042:2;2145:10;2141:2;2134:22;1924:238;;;;:::o;2168:306::-;;2335:18;2327:6;2324:30;2321:2;;;2357:13;;:::i;:::-;2321:2;2402:4;2394:6;2390:17;2382:25;;2462:4;2456;2452:15;2444:23;;2250:224;;;:::o;2480:77::-;;2546:5;2535:16;;2525:32;;;:::o;2563:48::-;2596:9;2617:122;2690:24;2708:5;2690:24;:::i;:::-;2683:5;2680:35;2670:2;;2729:1;2726;2719:12;2670:2;2660:79;:::o"}}}}},"errors":[{"component":"general","errorCode":"3420","formattedMessage":"a.sol: Warning: Source file does not specify required compiler version! +","id":1,"language":"Yul","name":"#utility.yul"}],"immutableReferences":{},"linkReferences":{},"object":"","opcodes":"","sourceMap":"56:74:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69:59;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;116:7;69:59;;;:::o;24:622:1:-;;145:80;160:64;217:6;160:64;:::i;:::-;145:80;:::i;:::-;136:89;;245:5;273:6;266:5;259:21;299:4;292:5;288:16;281:23;;324:6;374:3;366:4;358:6;354:17;349:3;345:27;342:36;339:2;;;391:1;388;381:12;339:2;419:1;404:236;429:6;426:1;423:13;404:236;;;496:3;524:37;557:3;545:10;524:37;:::i;:::-;519:3;512:50;591:4;586:3;582:14;575:21;;625:4;620:3;616:14;609:21;;464:176;451:1;448;444:9;439:14;;404:236;;;408:14;126:520;;;;;;;:::o;669:303::-;;789:3;782:4;774:6;770:17;766:27;756:2;;807:1;804;797:12;756:2;847:6;834:20;872:94;962:3;954:6;947:4;939:6;935:17;872:94;:::i;:::-;863:103;;746:226;;;;;:::o;978:139::-;;1062:6;1049:20;1040:29;;1078:33;1105:5;1078:33;:::i;:::-;1030:87;;;;:::o;1123:403::-;;1256:2;1244:9;1235:7;1231:23;1227:32;1224:2;;;1272:1;1269;1262:12;1224:2;1342:1;1331:9;1327:17;1314:31;1372:18;1364:6;1361:30;1358:2;;;1404:1;1401;1394:12;1358:2;1431:78;1501:7;1492:6;1481:9;1477:22;1431:78;:::i;:::-;1421:88;;1286:233;1214:312;;;;:::o;1532:118::-;1619:24;1637:5;1619:24;:::i;:::-;1614:3;1607:37;1597:53;;:::o;1656:222::-;;1787:2;1776:9;1772:18;1764:26;;1800:71;1868:1;1857:9;1853:17;1844:6;1800:71;:::i;:::-;1754:124;;;;:::o;1884:278::-;;1950:2;1944:9;1934:19;;1992:4;1984:6;1980:17;2099:6;2087:10;2084:22;2063:18;2051:10;2048:34;2045:62;2042:2;;;2110:13;;:::i;:::-;2042:2;2145:10;2141:2;2134:22;1924:238;;;;:::o;2168:306::-;;2335:18;2327:6;2324:30;2321:2;;;2357:13;;:::i;:::-;2321:2;2402:4;2394:6;2390:17;2382:25;;2462:4;2456;2452:15;2444:23;;2250:224;;;:::o;2480:77::-;;2546:5;2535:16;;2525:32;;;:::o;2563:48::-;2596:9;2617:122;2690:24;2708:5;2690:24;:::i;:::-;2683:5;2680:35;2670:2;;2729:1;2726;2719:12;2670:2;2660:79;:::o"}}}}},"errors":[{"component":"general","errorCode":"3420","formattedMessage":"a.sol: Warning: Source file does not specify required compiler version! ","message":"Source file does not specify required compiler version!","severity":"warning","sourceLocation":{"end":-1,"file":"a.sol","start":-1},"type":"Warning"}],"sources":{"a.sol":{"id":0}}} diff --git a/test/cmdlineTests/standard_optimizer_generatedSources/input.json b/test/cmdlineTests/standard_optimizer_generatedSources/input.json index f3682dd28..6b21efd6a 100644 --- a/test/cmdlineTests/standard_optimizer_generatedSources/input.json +++ b/test/cmdlineTests/standard_optimizer_generatedSources/input.json @@ -2,7 +2,7 @@ "language": "Solidity", "sources": { "a.sol": { - "content": "// SPDX-License-Identifier: GPL-3.0\npragma experimental ABIEncoderV2; contract A { function f(uint[] memory) public view returns (uint256) { } }" + "content": "// SPDX-License-Identifier: GPL-3.0\npragma abicoder v2; contract A { function f(uint[] memory) public view returns (uint256) { } }" } }, "settings": { diff --git a/test/cmdlineTests/standard_optimizer_generatedSources/output.json b/test/cmdlineTests/standard_optimizer_generatedSources/output.json index 9f4936877..a3521f53f 100644 --- a/test/cmdlineTests/standard_optimizer_generatedSources/output.json +++ b/test/cmdlineTests/standard_optimizer_generatedSources/output.json @@ -35,5 +35,5 @@ tail := add(headStart, 32) mstore(headStart, value0) } -}","id":1,"language":"Yul","name":"#utility.yul"}],"immutableReferences":{},"linkReferences":{},"object":"","opcodes":"","sourceMap":"70:74:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83:59;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;130:7:0;;83:59::o;14:1140:1:-;;129:2;172;160:9;151:7;147:23;143:32;140:2;;;193:6;185;178:22;140:2;238:9;225:23;267:18;308:2;300:6;297:14;294:2;;;329:6;321;314:22;294:2;372:6;361:9;357:22;347:32;;417:7;410:4;406:2;402:13;398:27;388:2;;444:6;436;429:22;388:2;485;472:16;507:2;503;500:10;497:2;;;513:9;497:2;551;547;543:11;583:2;577:9;634:2;629;621:6;617:15;613:24;687:6;675:10;672:22;667:2;655:10;652:18;649:46;646:2;;;698:9;646:2;725;718:22;775:18;;;809:15;;;;-1:-1:-1;844:11:1;;;874;;;870:20;;867:33;-1:-1:-1;864:2:1;;;918:6;910;903:22;864:2;945:6;936:15;;960:163;974:2;971:1;968:9;960:163;;;1031:17;;1019:30;;992:1;985:9;;;;;1069:12;;;;1101;;960:163;;;-1:-1:-1;1142:6:1;109:1045;-1:-1:-1;;;;;;;;109:1045:1:o;1159:177::-;1305:25;;;1293:2;1278:18;;1260:76::o"}}}}},"errors":[{"component":"general","errorCode":"3420","formattedMessage":"a.sol: Warning: Source file does not specify required compiler version! +}","id":1,"language":"Yul","name":"#utility.yul"}],"immutableReferences":{},"linkReferences":{},"object":"","opcodes":"","sourceMap":"56:74:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69:59;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;116:7:0;;69:59::o;14:1140:1:-;;129:2;172;160:9;151:7;147:23;143:32;140:2;;;193:6;185;178:22;140:2;238:9;225:23;267:18;308:2;300:6;297:14;294:2;;;329:6;321;314:22;294:2;372:6;361:9;357:22;347:32;;417:7;410:4;406:2;402:13;398:27;388:2;;444:6;436;429:22;388:2;485;472:16;507:2;503;500:10;497:2;;;513:9;497:2;551;547;543:11;583:2;577:9;634:2;629;621:6;617:15;613:24;687:6;675:10;672:22;667:2;655:10;652:18;649:46;646:2;;;698:9;646:2;725;718:22;775:18;;;809:15;;;;-1:-1:-1;844:11:1;;;874;;;870:20;;867:33;-1:-1:-1;864:2:1;;;918:6;910;903:22;864:2;945:6;936:15;;960:163;974:2;971:1;968:9;960:163;;;1031:17;;1019:30;;992:1;985:9;;;;;1069:12;;;;1101;;960:163;;;-1:-1:-1;1142:6:1;109:1045;-1:-1:-1;;;;;;;;109:1045:1:o;1159:177::-;1305:25;;;1293:2;1278:18;;1260:76::o"}}}}},"errors":[{"component":"general","errorCode":"3420","formattedMessage":"a.sol: Warning: Source file does not specify required compiler version! ","message":"Source file does not specify required compiler version!","severity":"warning","sourceLocation":{"end":-1,"file":"a.sol","start":-1},"type":"Warning"}],"sources":{"a.sol":{"id":0}}} diff --git a/test/externalTests/common.sh b/test/externalTests/common.sh index fe2527443..ebc57b97d 100644 --- a/test/externalTests/common.sh +++ b/test/externalTests/common.sh @@ -180,14 +180,14 @@ function force_solc_settings function force_abi_v2 { - # Add "pragma experimental ABIEncoderV2" to all files. - printLog "Forcibly enabling ABIEncoderV2..." + # Add "pragma abi coder v2" to all files. + printLog "Forcibly enabling abi coder v2..." find contracts test -name '*.sol' -type f -print0 | \ while IFS= read -r -d '' file do # Only add the pragma if it is not already there. - if grep -q -v 'pragma experimental ABIEncoderV2' "$file"; then - sed -i -e '1 i pragma experimental ABIEncoderV2;' "$file" + if grep -q -v 'pragma abicoder v2' "$file"; then + sed -i -e '1 i pragma abicoder v2;' "$file" fi done } @@ -257,7 +257,7 @@ function truffle_run_test do clean force_solc_settings "$CONFIG" "$optimize" "istanbul" - # Force ABIEncoderV2 in the last step. Has to be the last because code is modified. + # Force abi coder v2 in the last step. Has to be the last because code is modified. if [ "$FORCE_ABIv2" = true ]; then [[ "$optimize" =~ yul ]] && force_abi_v2 fi diff --git a/test/libsolidity/ABIJson/event_structs.sol b/test/libsolidity/ABIJson/event_structs.sol index af4d3b0bd..83431907a 100644 --- a/test/libsolidity/ABIJson/event_structs.sol +++ b/test/libsolidity/ABIJson/event_structs.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; T[] sub; bytes b; } struct T { uint[2] x; } diff --git a/test/libsolidity/ABIJson/global_struct.sol b/test/libsolidity/ABIJson/global_struct.sol index baffe7cc4..11ce8246f 100644 --- a/test/libsolidity/ABIJson/global_struct.sol +++ b/test/libsolidity/ABIJson/global_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct S { uint a; } contract C { function f(S calldata s) external view {} diff --git a/test/libsolidity/ABIJson/return_structs.sol b/test/libsolidity/ABIJson/return_structs.sol index 818eb2bbb..9a1e493d5 100644 --- a/test/libsolidity/ABIJson/return_structs.sol +++ b/test/libsolidity/ABIJson/return_structs.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; T[] sub; } struct T { uint[2] x; } diff --git a/test/libsolidity/ABIJson/return_structs_with_contracts.sol b/test/libsolidity/ABIJson/return_structs_with_contracts.sol index 12887d5e2..135c3295f 100644 --- a/test/libsolidity/ABIJson/return_structs_with_contracts.sol +++ b/test/libsolidity/ABIJson/return_structs_with_contracts.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { C[] x; C y; } function f() public returns (S memory s, C c) { diff --git a/test/libsolidity/ABIJson/structs_in_libraries.sol b/test/libsolidity/ABIJson/structs_in_libraries.sol index cb63d4a8b..3f278337f 100644 --- a/test/libsolidity/ABIJson/structs_in_libraries.sol +++ b/test/libsolidity/ABIJson/structs_in_libraries.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct S { uint a; T[] sub; bytes b; } struct T { uint[2] x; } diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp index b650db5b5..5f4eba110 100644 --- a/test/libsolidity/SolidityEndToEndTest.cpp +++ b/test/libsolidity/SolidityEndToEndTest.cpp @@ -1983,7 +1983,7 @@ BOOST_AUTO_TEST_CASE(event_really_really_lots_of_data_from_storage) BOOST_AUTO_TEST_CASE(event_struct_memory_v2) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { struct S { uint a; } event E(S); @@ -2005,7 +2005,7 @@ BOOST_AUTO_TEST_CASE(event_struct_memory_v2) BOOST_AUTO_TEST_CASE(event_struct_storage_v2) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { struct S { uint a; } event E(S); @@ -2053,7 +2053,7 @@ BOOST_AUTO_TEST_CASE(event_dynamic_array_memory) BOOST_AUTO_TEST_CASE(event_dynamic_array_memory_v2) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { event E(uint[]); function createEvent(uint x) public { @@ -2078,7 +2078,7 @@ BOOST_AUTO_TEST_CASE(event_dynamic_array_memory_v2) BOOST_AUTO_TEST_CASE(event_dynamic_nested_array_memory_v2) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { event E(uint[][]); function createEvent(uint x) public { @@ -2136,7 +2136,7 @@ BOOST_AUTO_TEST_CASE(event_dynamic_array_storage) BOOST_AUTO_TEST_CASE(event_dynamic_array_storage_v2) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { event E(uint[]); uint[] arr; @@ -2167,7 +2167,7 @@ BOOST_AUTO_TEST_CASE(event_dynamic_array_storage_v2) BOOST_AUTO_TEST_CASE(event_dynamic_nested_array_storage_v2) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { event E(uint[][]); uint[][] arr; @@ -2332,7 +2332,7 @@ BOOST_AUTO_TEST_CASE(generic_delegatecall) for (auto v2: {false, true}) { - string source = (v2 ? "pragma experimental ABIEncoderV2;\n" : "") + string(sourceCode); + string source = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n" + string(sourceCode); compileAndRun(source, 0, "Receiver"); u160 const c_receiverAddress = m_contractAddress; @@ -2660,7 +2660,7 @@ BOOST_AUTO_TEST_CASE(storing_invalid_boolean) BOOST_AUTO_TEST_CASE(struct_referencing) { static char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; interface I { struct S { uint a; } } @@ -2803,7 +2803,7 @@ BOOST_AUTO_TEST_CASE(array_copy_storage_abi) // NOTE: This does not really test copying from storage to ABI directly, // because it will always copy to memory first. char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract c { uint8[] x; uint16[] y; @@ -3191,7 +3191,7 @@ BOOST_AUTO_TEST_CASE(memory_types_initialisation) BOOST_AUTO_TEST_CASE(calldata_struct_short) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { struct S { uint256 a; uint256 b; } function f(S calldata) external pure returns (uint256) { @@ -3214,7 +3214,7 @@ BOOST_AUTO_TEST_CASE(calldata_struct_short) BOOST_AUTO_TEST_CASE(calldata_struct_function_type) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { struct S { function (uint) external returns (uint) fn; } function f(S calldata s) external returns (uint256) { @@ -3263,7 +3263,7 @@ BOOST_AUTO_TEST_CASE(calldata_array_dynamic_three_dimensional) arrayType += outerDynamicallySized ? "[]" : "[2]"; string sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { function test()" + arrayType + R"( calldata a) external returns (uint256) { return a.length; @@ -3865,7 +3865,7 @@ BOOST_AUTO_TEST_CASE(using_library_mappings_external) )"; for (auto v2: {false, true}) { - string prefix = v2 ? "pragma experimental ABIEncoderV2;\n" : ""; + string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n"; compileAndRun(prefix + libSourceCode, 0, "Lib"); compileAndRun(prefix + sourceCode, 0, "Test", bytes(), map{{"Lib", m_contractAddress}}); ABI_CHECK(callContractFunction("f()"), encodeArgs(u256(2), u256(0), u256(84), u256(46), u256(0), u256(198))); @@ -5137,7 +5137,8 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked) )"; for (auto v2: {false, true}) { - compileAndRun(string(v2 ? "pragma experimental ABIEncoderV2;\n" : "") + sourceCode, 0, "C"); + string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n"; + compileAndRun(prefix + sourceCode, 0, "C"); ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 0)); ABI_CHECK(callContractFunction("f1()"), encodeArgs(0x20, 2, "\x01\x02")); ABI_CHECK(callContractFunction("f2()"), encodeArgs(0x20, 5, "\x01" "abc" "\x02")); @@ -5211,7 +5212,8 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked_from_storage) )"; for (auto v2: {false, true}) { - compileAndRun(string(v2 ? "pragma experimental ABIEncoderV2;\n" : "") + sourceCode, 0, "C"); + string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n"; + compileAndRun(prefix + sourceCode, 0, "C"); bytes payload = encodeArgs(0xfffff1, 0, 0xfffff2, 0, 0, 0xfffff3, 0, 0, 0xfffff4); bytes encoded = encodeArgs(0x20, 0x122, "\x01" + asString(payload) + "\x02"); ABI_CHECK(callContractFunction("sf()"), encoded); @@ -5281,7 +5283,8 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked_from_memory) )"; for (auto v2: {false, true}) { - compileAndRun(string(v2 ? "pragma experimental ABIEncoderV2;\n" : "") + sourceCode, 0, "C"); + string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n"; + compileAndRun(prefix + sourceCode, 0, "C"); bytes payload = encodeArgs(0xfffff1, 0, 0xfffff2, 0, 0, 0xfffff3, 0, 0, 0xfffff4); bytes encoded = encodeArgs(0x20, 0x122, "\x01" + asString(payload) + "\x02"); ABI_CHECK(callContractFunction("sf()"), encoded); @@ -5324,7 +5327,8 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked_functionPtr) )"; for (auto v2: {false, true}) { - compileAndRun(string(v2 ? "pragma experimental ABIEncoderV2;\n" : "") + sourceCode, 0, "C"); + string prefix = "pragma abicoder " + string(v2 ? "v2" : "v1") + ";\n"; + compileAndRun(prefix + sourceCode, 0, "C"); string directEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "02")); ABI_CHECK(callContractFunction("testDirect()"), encodeArgs(0x20, directEncoding.size(), directEncoding)); string arrayEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "0000000000000000" "02")); @@ -5336,7 +5340,7 @@ BOOST_AUTO_TEST_CASE(abi_encodePacked_functionPtr) BOOST_AUTO_TEST_CASE(abi_encodePackedV2_structs) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { struct S { uint8 a; @@ -5378,7 +5382,7 @@ BOOST_AUTO_TEST_CASE(abi_encodePackedV2_structs) BOOST_AUTO_TEST_CASE(abi_encodePackedV2_nestedArray) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { struct S { uint8 a; @@ -5407,7 +5411,7 @@ BOOST_AUTO_TEST_CASE(abi_encodePackedV2_nestedArray) BOOST_AUTO_TEST_CASE(abi_encodePackedV2_arrayOfStrings) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { string[] x; event E(string[] indexed); @@ -5441,7 +5445,7 @@ BOOST_AUTO_TEST_CASE(event_signature_in_library) // This tests a bug that was present where the "internal signature" // for structs was also used for events. char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; library L { struct S { uint8 a; @@ -5498,7 +5502,7 @@ BOOST_AUTO_TEST_CASE(abi_encode_with_selector) BOOST_AUTO_TEST_CASE(abi_encode_with_selectorv2) { char const* sourceCode = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { function f0() public pure returns (bytes memory) { return abi.encodeWithSelector(0x12345678); @@ -5588,7 +5592,7 @@ BOOST_AUTO_TEST_CASE(abi_encode_with_signature) BOOST_AUTO_TEST_CASE(abi_encode_with_signaturev2) { char const* sourceCode = R"T( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract C { function f0() public pure returns (bytes memory) { return abi.encodeWithSignature("f(uint256)"); diff --git a/test/libsolidity/SolidityExecutionFramework.cpp b/test/libsolidity/SolidityExecutionFramework.cpp index e61f1469e..d46ce0dfd 100644 --- a/test/libsolidity/SolidityExecutionFramework.cpp +++ b/test/libsolidity/SolidityExecutionFramework.cpp @@ -132,11 +132,12 @@ bytes SolidityExecutionFramework::compileContract( string SolidityExecutionFramework::addPreamble(string const& _sourceCode) { // Silence compiler version warning - string preamble = "pragma solidity >=0.0;\n"; + string preamble = "pragma solidity >=0.0;\n// SPDX-License-Identifier: unlicensed\n"; if ( solidity::test::CommonOptions::get().useABIEncoderV2 && - _sourceCode.find("pragma experimental ABIEncoderV2;") == string::npos + _sourceCode.find("pragma experimental ABIEncoderV2;") == string::npos && + _sourceCode.find("pragma abicoder") == string::npos ) - preamble += "pragma experimental ABIEncoderV2;\n"; + preamble += "pragma abicoder v2;\n"; return preamble + _sourceCode; } diff --git a/test/libsolidity/SolidityNameAndTypeResolution.cpp b/test/libsolidity/SolidityNameAndTypeResolution.cpp index 1ecd0e9f9..fb520227f 100644 --- a/test/libsolidity/SolidityNameAndTypeResolution.cpp +++ b/test/libsolidity/SolidityNameAndTypeResolution.cpp @@ -197,7 +197,7 @@ BOOST_AUTO_TEST_CASE(enum_external_type) BOOST_AUTO_TEST_CASE(external_struct_signatures) { char const* text = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; contract Test { enum ActionChoices { GoLeft, GoRight, GoStraight, Sit } struct Simple { uint i; } @@ -228,7 +228,7 @@ BOOST_AUTO_TEST_CASE(external_struct_signatures) BOOST_AUTO_TEST_CASE(external_struct_signatures_in_libraries) { char const* text = R"( - pragma experimental ABIEncoderV2; + pragma abicoder v2; library Test { enum ActionChoices { GoLeft, GoRight, GoStraight, Sit } struct Simple { uint i; } diff --git a/test/libsolidity/gasTests/abiv2.sol b/test/libsolidity/gasTests/abiv2.sol index 8995be072..ee13f3b55 100644 --- a/test/libsolidity/gasTests/abiv2.sol +++ b/test/libsolidity/gasTests/abiv2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint public a; diff --git a/test/libsolidity/gasTests/abiv2_optimised.sol b/test/libsolidity/gasTests/abiv2_optimised.sol index e7b8ba94f..bb41f63f1 100644 --- a/test/libsolidity/gasTests/abiv2_optimised.sol +++ b/test/libsolidity/gasTests/abiv2_optimised.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint public a; diff --git a/test/libsolidity/gasTests/exp.sol b/test/libsolidity/gasTests/exp.sol index 238af8990..ef9d94890 100644 --- a/test/libsolidity/gasTests/exp.sol +++ b/test/libsolidity/gasTests/exp.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function exp_neg_one(uint exponent) public returns(int) { diff --git a/test/libsolidity/gasTests/exp_optimized.sol b/test/libsolidity/gasTests/exp_optimized.sol index 499a3b5a5..51e034dcd 100644 --- a/test/libsolidity/gasTests/exp_optimized.sol +++ b/test/libsolidity/gasTests/exp_optimized.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function exp_neg_one(uint exponent) public returns(int) { diff --git a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array_v2.sol b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array_v2.sol index 27c022cfd..08467feb8 100644 --- a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array_v2.sol +++ b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2.sol b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2.sol index 6d7b27f58..6f1c652a0 100644 --- a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2.sol +++ b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_calldata.sol b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_calldata.sol index 9ed9ada78..bcb14d684 100644 --- a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_calldata.sol +++ b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_calldata.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_storage.sol b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_storage.sol index 79c450556..cdedf048e 100644 --- a/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_storage.sol +++ b/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol index 6253039f1..9e5985cbc 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function enc_packed_bytes(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) { return abi.encodePacked(data[start:end]); diff --git a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_empty_string_v2.sol b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_empty_string_v2.sol index f5c26f402..c3f472ba2 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_empty_string_v2.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_empty_string_v2.sol @@ -1,6 +1,6 @@ // Tests that this will not end up using a "bytes0" type // (which would assert) -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_rational_v2.sol b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_rational_v2.sol index e84f0d5f9..f2013f6c8 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_rational_v2.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_rational_v2.sol @@ -1,5 +1,5 @@ // Tests that rational numbers (even negative ones) are encoded properly. -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2.sol b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2.sol index bfa750712..8fb565d3f 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_function_inherited_in_v1_contract.sol b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_function_inherited_in_v1_contract.sol index 5c074032b..8c3341189 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_function_inherited_in_v1_contract.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_function_inherited_in_v1_contract.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { uint a; diff --git a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_modifier_used_in_v1_contract.sol b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_modifier_used_in_v1_contract.sol index a6ac945a7..81095f83c 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_modifier_used_in_v1_contract.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_modifier_used_in_v1_contract.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { uint value; diff --git a/test/libsolidity/semanticTests/abiEncoderV2/bool_out_of_bounds.sol b/test/libsolidity/semanticTests/abiEncoderV2/bool_out_of_bounds.sol index 9e0dc5e74..773795336 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/bool_out_of_bounds.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/bool_out_of_bounds.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(bool b) public pure returns (bool) { return b; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/byte_arrays.sol b/test/libsolidity/semanticTests/abiEncoderV2/byte_arrays.sol index 4492c6f9d..2b9b5c5d3 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/byte_arrays.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/byte_arrays.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint a, bytes memory b, uint c) diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol index e950959a9..d8bcd4601 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function g(uint256[] calldata) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic.sol index c47af87f4..ef48518ba 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_index_access.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_index_access.sol index 92067f8db..8b7ecb49a 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_index_access.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_index_access.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_dynamic.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_dynamic.sol index 46d1122a9..ffaedd40a 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_dynamic.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint8[][1][] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_decode.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_decode.sol index 006ad455f..42e669567 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_decode.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_decode.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][2][] calldata x) external returns (uint256) { x[0]; // trigger bounds checks diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_reencode.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_reencode.sol index c777b12fd..2cf09b19b 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_reencode.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_reencode.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][2][] calldata x) external returns (uint256) { return 42; diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_function_types.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_function_types.sol index 26045f60d..f5380901f 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_function_types.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_function_types.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(function() external returns (uint)[] calldata s) external returns (uint, uint, uint) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_multi_dynamic.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_multi_dynamic.sol index f50f59d1f..e01655fce 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_multi_dynamic.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_multi_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static.sol index 3a6fd9151..fbab06363 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[3] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_dynamic_static.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_dynamic_static.sol index 2688f899d..4cbdc9da7 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_dynamic_static.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_dynamic_static.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint8[1][][1] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_index_access.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_index_access.sol index d23dfecfb..ea4565e1e 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_index_access.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_static_index_access.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[3] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_struct_dynamic.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_struct_dynamic.sol index ce2f7a390..a1735c138 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_struct_dynamic.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_struct_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint256[] a; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_dynamic.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_dynamic.sol index 51674081e..b077b66e4 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_dynamic.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[] calldata s1, uint256[] calldata s2, bool which) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_static.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_static.sol index 45a89c483..58ad531ef 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_static.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_two_static.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[3] calldata s1, uint256[2] calldata s2, bool which) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_dynamic.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_dynamic.sol index 0ae57dbed..ad0f00dd6 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_dynamic.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint256[] a; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_member_offset.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_member_offset.sol index 196967a44..7744fbf62 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_member_offset.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_member_offset.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct A { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_simple.sol b/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_simple.sol index 6d747fdf0..413ea3070 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_simple.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_simple.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint256 a; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/address.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/address.sol index efb5045fc..3ac82eee5 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/address.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/address.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function g(address x) external pure returns (uint256 r) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bool.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bool.sol index eb9ce5962..79cf68795 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bool.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bool.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function gggg(bool x) external pure returns (bool) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bytesx.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bytesx.sol index 294a666e9..26ff5fb69 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bytesx.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/bytesx.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function gg1(bytes1 x) external pure returns (bytes32) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/cleanup.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/cleanup.sol index 4c4e119e7..cb04163b9 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/cleanup.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/cleanup.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint16 a, int16 b, address c, bytes3 d, bool e) diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/dynamic_array.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/dynamic_array.sol index e56ff257b..fc62f13d0 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/dynamic_array.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/dynamic_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function ggg(uint8[] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/function.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/function.sol index b872b2fb1..7a4ec0ce5 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/function.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/function.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { function() external f; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/intx.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/intx.sol index 15cd07d49..db636986e 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/intx.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/intx.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function ggg8(int8 x) external pure returns (int256) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/simple_struct.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/simple_struct.sol index 2a2327c08..b809feb59 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/simple_struct.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/simple_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint8 a; bytes1 b; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/static_array.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/static_array.sol index d353fda95..9806dc019 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/static_array.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/static_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function gggggggg(uint8[2] calldata s) external pure returns (bytes memory) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/uintx.sol b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/uintx.sol index 9788431e1..cf17ef623 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/cleanup/uintx.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/cleanup/uintx.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function ggg8(uint8 x) external pure returns (uint256) { diff --git a/test/libsolidity/semanticTests/abiEncoderV2/dynamic_arrays.sol b/test/libsolidity/semanticTests/abiEncoderV2/dynamic_arrays.sol index 9dfa00175..0993ab594 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/dynamic_arrays.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/dynamic_arrays.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint a, uint16[] memory b, uint c) diff --git a/test/libsolidity/semanticTests/abiEncoderV2/dynamic_nested_arrays.sol b/test/libsolidity/semanticTests/abiEncoderV2/dynamic_nested_arrays.sol index 21672f080..23faf0d89 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/dynamic_nested_arrays.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/dynamic_nested_arrays.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint a, uint16[][] memory b, uint[2][][3] memory c, uint d) diff --git a/test/libsolidity/semanticTests/abiEncoderV2/enums.sol b/test/libsolidity/semanticTests/abiEncoderV2/enums.sol index c61e4e12b..5538c5506 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/enums.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/enums.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { enum E { A, B } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/memory_params_in_external_function.sol b/test/libsolidity/semanticTests/abiEncoderV2/memory_params_in_external_function.sol index 6c4845403..66a64e1f9 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/memory_params_in_external_function.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/memory_params_in_external_function.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(bytes memory a, bytes calldata b, uint[] memory c) diff --git a/test/libsolidity/semanticTests/abiEncoderV2/storage_array_encoding.sol b/test/libsolidity/semanticTests/abiEncoderV2/storage_array_encoding.sol index d09460fa0..1a233681f 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/storage_array_encoding.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/storage_array_encoding.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; // tests encoding from storage arrays diff --git a/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre2_struct.sol b/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre2_struct.sol index e4ffcb422..afa16826d 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre2_struct.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre2_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { C c; uint[] x; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre_struct.sol b/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre_struct.sol index 4f05afe9b..7775423d4 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre_struct.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/struct/mediocre_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { C c; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_function.sol b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_function.sol index 4dcf6c010..7e3031ba5 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_function.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_function.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { function () external returns (uint) f; uint b; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_short.sol b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_short.sol index 10b4cebb4..9eceff81e 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_short.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_short.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { int a; uint b; bytes16 c; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_simple.sol b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_simple.sol index 1f47aa66d..d8d8c0438 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_simple.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_simple.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; uint8 b; uint8 c; bytes2 d; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_validation.sol b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_validation.sol index f8c77be64..68fb477a9 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_validation.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_validation.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { int16 a; uint8 b; bytes2 c; } diff --git a/test/libsolidity/semanticTests/abiEncoderV2/struct/validation_function_type_inside_struct.sol b/test/libsolidity/semanticTests/abiEncoderV2/struct/validation_function_type_inside_struct.sol index 7944262a3..8c5350828 100644 --- a/test/libsolidity/semanticTests/abiEncoderV2/struct/validation_function_type_inside_struct.sol +++ b/test/libsolidity/semanticTests/abiEncoderV2/struct/validation_function_type_inside_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { function () external x; } diff --git a/test/libsolidity/semanticTests/abiencodedecode/contract_array_v2.sol b/test/libsolidity/semanticTests/abiencodedecode/contract_array_v2.sol index 1d2625be0..69360fe04 100644 --- a/test/libsolidity/semanticTests/abiencodedecode/contract_array_v2.sol +++ b/test/libsolidity/semanticTests/abiencodedecode/contract_array_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(bytes calldata x) public returns (C[] memory) { return abi.decode(x, (C[])); diff --git a/test/libsolidity/semanticTests/array/calldata_array.sol b/test/libsolidity/semanticTests/array/calldata_array.sol index aa8a49987..7897a8eb6 100644 --- a/test/libsolidity/semanticTests/array/calldata_array.sol +++ b/test/libsolidity/semanticTests/array/calldata_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid.sol b/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid.sol index 0ce1e3e4f..5aacf790f 100644 --- a/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid.sol +++ b/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid_static_middle.sol b/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid_static_middle.sol index d4c02df5e..d63b14302 100644 --- a/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid_static_middle.sol +++ b/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid_static_middle.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/array/calldata_array_of_struct.sol b/test/libsolidity/semanticTests/array/calldata_array_of_struct.sol index 781c61189..c5aa08ddb 100644 --- a/test/libsolidity/semanticTests/array/calldata_array_of_struct.sol +++ b/test/libsolidity/semanticTests/array/calldata_array_of_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/array/calldata_array_two_dimensional.sol b/test/libsolidity/semanticTests/array/calldata_array_two_dimensional.sol index 4c20627e7..cc95ece28 100644 --- a/test/libsolidity/semanticTests/array/calldata_array_two_dimensional.sol +++ b/test/libsolidity/semanticTests/array/calldata_array_two_dimensional.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function test(uint256[][2] calldata a) external returns (uint256) { return a.length; diff --git a/test/libsolidity/semanticTests/array/calldata_array_two_dimensional_1.sol b/test/libsolidity/semanticTests/array/calldata_array_two_dimensional_1.sol index 9d40a356d..ff454603c 100644 --- a/test/libsolidity/semanticTests/array/calldata_array_two_dimensional_1.sol +++ b/test/libsolidity/semanticTests/array/calldata_array_two_dimensional_1.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function test(uint256[][] calldata a) external returns (uint256) { return a.length; diff --git a/test/libsolidity/semanticTests/array/calldata_bytes_array_bounds.sol b/test/libsolidity/semanticTests/array/calldata_bytes_array_bounds.sol index ed120d501..5e0fd0bc9 100644 --- a/test/libsolidity/semanticTests/array/calldata_bytes_array_bounds.sol +++ b/test/libsolidity/semanticTests/array/calldata_bytes_array_bounds.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(bytes[] calldata a, uint256 i) external returns (uint) { return uint8(a[0][i]); diff --git a/test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol index aaeba2ad6..efd90f88f 100644 --- a/test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract c { uint256[][] a1; diff --git a/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol index 3329391f3..f8350c67e 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol index 4aeed91f6..e930a8ea6 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol index d24cd563d..5d332e6e8 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol b/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol index c45c2c52f..9c1022298 100644 --- a/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint256[] s; diff --git a/test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol b/test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol index 21feb2790..eba9105e5 100644 --- a/test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol +++ b/test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/array/copying/calldata_bytes_array_to_memory.sol b/test/libsolidity/semanticTests/array/copying/calldata_bytes_array_to_memory.sol index d67a24741..7a966f91f 100644 --- a/test/libsolidity/semanticTests/array/copying/calldata_bytes_array_to_memory.sol +++ b/test/libsolidity/semanticTests/array/copying/calldata_bytes_array_to_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol b/test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol index 81ae5e2d9..a1cd58194 100644 --- a/test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol +++ b/test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol b/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol index 2f983e022..f318ee099 100644 --- a/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct S { uint16 x; bytes a; diff --git a/test/libsolidity/semanticTests/array/copying/storage_memory_nested_bytes.sol b/test/libsolidity/semanticTests/array/copying/storage_memory_nested_bytes.sol index e71a68c76..c0dd812ad 100644 --- a/test/libsolidity/semanticTests/array/copying/storage_memory_nested_bytes.sol +++ b/test/libsolidity/semanticTests/array/copying/storage_memory_nested_bytes.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { bytes[] a; diff --git a/test/libsolidity/semanticTests/calldata/calldata_array_dynamic_bytes.sol b/test/libsolidity/semanticTests/calldata/calldata_array_dynamic_bytes.sol index b59885de8..ad1c80936 100644 --- a/test/libsolidity/semanticTests/calldata/calldata_array_dynamic_bytes.sol +++ b/test/libsolidity/semanticTests/calldata/calldata_array_dynamic_bytes.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/calldata/calldata_internal_multi_array.sol b/test/libsolidity/semanticTests/calldata/calldata_internal_multi_array.sol index 6dea02b29..33f27a084 100644 --- a/test/libsolidity/semanticTests/calldata/calldata_internal_multi_array.sol +++ b/test/libsolidity/semanticTests/calldata/calldata_internal_multi_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function g(uint[][2] calldata s) internal pure returns (uint, uint[] calldata) { diff --git a/test/libsolidity/semanticTests/calldata/calldata_string_array.sol b/test/libsolidity/semanticTests/calldata/calldata_string_array.sol index 62459505b..1ab1b25a8 100644 --- a/test/libsolidity/semanticTests/calldata/calldata_string_array.sol +++ b/test/libsolidity/semanticTests/calldata/calldata_string_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/calldata/calldata_struct_cleaning.sol b/test/libsolidity/semanticTests/calldata/calldata_struct_cleaning.sol index f7828aacf..dad6864d1 100644 --- a/test/libsolidity/semanticTests/calldata/calldata_struct_cleaning.sol +++ b/test/libsolidity/semanticTests/calldata/calldata_struct_cleaning.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/calldata/calldata_struct_internal.sol b/test/libsolidity/semanticTests/calldata/calldata_struct_internal.sol index 810900dd6..50351087e 100644 --- a/test/libsolidity/semanticTests/calldata/calldata_struct_internal.sol +++ b/test/libsolidity/semanticTests/calldata/calldata_struct_internal.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct S { uint x; diff --git a/test/libsolidity/semanticTests/cleanup/bool_conversion_v2.sol b/test/libsolidity/semanticTests/cleanup/bool_conversion_v2.sol index 0b2608c4e..0844f42de 100644 --- a/test/libsolidity/semanticTests/cleanup/bool_conversion_v2.sol +++ b/test/libsolidity/semanticTests/cleanup/bool_conversion_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/cleanup/cleanup_address_types_v2.sol b/test/libsolidity/semanticTests/cleanup/cleanup_address_types_v2.sol index 902908894..ebff7898c 100644 --- a/test/libsolidity/semanticTests/cleanup/cleanup_address_types_v2.sol +++ b/test/libsolidity/semanticTests/cleanup/cleanup_address_types_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; // Checks that address types are properly cleaned before they are compared. diff --git a/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_v2.sol b/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_v2.sol index f2ba19fd1..d6036ba8a 100644 --- a/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_v2.sol +++ b/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; // Checks that bytesXX types are properly cleaned before they are compared. diff --git a/test/libsolidity/semanticTests/ecrecover/ecrecover_abiV2.sol b/test/libsolidity/semanticTests/ecrecover/ecrecover_abiV2.sol index 158a85a5e..265e58bda 100644 --- a/test/libsolidity/semanticTests/ecrecover/ecrecover_abiV2.sol +++ b/test/libsolidity/semanticTests/ecrecover/ecrecover_abiV2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract test { function a(bytes32 h, uint8 v, bytes32 r, bytes32 s) public returns (address addr) { return ecrecover(h, v, r, s); diff --git a/test/libsolidity/semanticTests/libraries/library_function_selectors_struct.sol b/test/libsolidity/semanticTests/libraries/library_function_selectors_struct.sol index 8081b0e24..186fad7db 100644 --- a/test/libsolidity/semanticTests/libraries/library_function_selectors_struct.sol +++ b/test/libsolidity/semanticTests/libraries/library_function_selectors_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct S { uint256 a; } function f(S storage s) external returns (uint) { return s.a; } diff --git a/test/libsolidity/semanticTests/libraries/library_return_struct_with_mapping.sol b/test/libsolidity/semanticTests/libraries/library_return_struct_with_mapping.sol index 251c9842b..00001a2f8 100644 --- a/test/libsolidity/semanticTests/libraries/library_return_struct_with_mapping.sol +++ b/test/libsolidity/semanticTests/libraries/library_return_struct_with_mapping.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; library Lib { struct Items { diff --git a/test/libsolidity/semanticTests/literals/escape.sol b/test/libsolidity/semanticTests/literals/escape.sol index 11bd5bab6..1b9fdb4e1 100644 --- a/test/libsolidity/semanticTests/literals/escape.sol +++ b/test/libsolidity/semanticTests/literals/escape.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_signed_v2.sol b/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_signed_v2.sol index 965daa3f7..8843a00b5 100644 --- a/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_signed_v2.sol +++ b/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_signed_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_v2.sol b/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_v2.sol index dbcd25763..6397c7aa0 100644 --- a/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_v2.sol +++ b/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int16_v2.sol b/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int16_v2.sol index 8153f9ff9..cfc73bf49 100644 --- a/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int16_v2.sol +++ b/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int16_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int32_v2.sol b/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int32_v2.sol index bc30aa0ca..ea0347812 100644 --- a/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int32_v2.sol +++ b/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int32_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int8_v2.sol b/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int8_v2.sol index 9a4b5ec4c..3fb9e714c 100644 --- a/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int8_v2.sol +++ b/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int8_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_invalid.sol b/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_invalid.sol index e91f08a03..37f9da6c2 100644 --- a/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_invalid.sol +++ b/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_invalid.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][] calldata a) external returns (uint) { return 42; diff --git a/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_decode.sol b/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_decode.sol index d39b3f4fb..4e857cea9 100644 --- a/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_decode.sol +++ b/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_decode.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][2][] calldata x) external returns (uint256) { x[0]; diff --git a/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_reencode.sol b/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_reencode.sol index 0e2ba94b1..48e97fa9c 100644 --- a/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_reencode.sol +++ b/test/libsolidity/semanticTests/revertStrings/calldata_array_dynamic_static_short_reencode.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][2][] calldata x) external returns (uint256) { return 42; diff --git a/test/libsolidity/semanticTests/revertStrings/calldata_array_invalid_length.sol b/test/libsolidity/semanticTests/revertStrings/calldata_array_invalid_length.sol index f54a47d73..55beec091 100644 --- a/test/libsolidity/semanticTests/revertStrings/calldata_array_invalid_length.sol +++ b/test/libsolidity/semanticTests/revertStrings/calldata_array_invalid_length.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][] calldata x) external returns (uint256) { return x[0].length; diff --git a/test/libsolidity/semanticTests/revertStrings/calldata_arrays_too_large.sol b/test/libsolidity/semanticTests/revertStrings/calldata_arrays_too_large.sol index c19538d0a..ca953af4e 100644 --- a/test/libsolidity/semanticTests/revertStrings/calldata_arrays_too_large.sol +++ b/test/libsolidity/semanticTests/revertStrings/calldata_arrays_too_large.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint a, uint[] calldata b, uint c) external pure returns (uint) { return 7; diff --git a/test/libsolidity/semanticTests/revertStrings/calldata_tail_short.sol b/test/libsolidity/semanticTests/revertStrings/calldata_tail_short.sol index c3fcece1b..545f30474 100644 --- a/test/libsolidity/semanticTests/revertStrings/calldata_tail_short.sol +++ b/test/libsolidity/semanticTests/revertStrings/calldata_tail_short.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][] calldata x) external { x[0]; } } diff --git a/test/libsolidity/semanticTests/revertStrings/empty_v2.sol b/test/libsolidity/semanticTests/revertStrings/empty_v2.sol index eafb05268..ea81afbe8 100644 --- a/test/libsolidity/semanticTests/revertStrings/empty_v2.sol +++ b/test/libsolidity/semanticTests/revertStrings/empty_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() public { revert(""); diff --git a/test/libsolidity/semanticTests/revertStrings/short_input_array.sol b/test/libsolidity/semanticTests/revertStrings/short_input_array.sol index 4c83b79ff..77e5ef5ac 100644 --- a/test/libsolidity/semanticTests/revertStrings/short_input_array.sol +++ b/test/libsolidity/semanticTests/revertStrings/short_input_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint[] memory a) public pure returns (uint) { return 7; } } diff --git a/test/libsolidity/semanticTests/revertStrings/short_input_bytes.sol b/test/libsolidity/semanticTests/revertStrings/short_input_bytes.sol index b8bb0493a..de6876ac7 100644 --- a/test/libsolidity/semanticTests/revertStrings/short_input_bytes.sol +++ b/test/libsolidity/semanticTests/revertStrings/short_input_bytes.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function e(bytes memory a) public pure returns (uint) { return 7; } } diff --git a/test/libsolidity/semanticTests/smoke/arrays.sol b/test/libsolidity/semanticTests/smoke/arrays.sol index 67706929e..85d721d14 100644 --- a/test/libsolidity/semanticTests/smoke/arrays.sol +++ b/test/libsolidity/semanticTests/smoke/arrays.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { diff --git a/test/libsolidity/semanticTests/smoke/basic.sol b/test/libsolidity/semanticTests/smoke/basic.sol index 892ee8702..affdc29da 100644 --- a/test/libsolidity/semanticTests/smoke/basic.sol +++ b/test/libsolidity/semanticTests/smoke/basic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function d() public { diff --git a/test/libsolidity/semanticTests/smoke/structs.sol b/test/libsolidity/semanticTests/smoke/structs.sol index 178786977..a6d9fbfc6 100644 --- a/test/libsolidity/semanticTests/smoke/structs.sol +++ b/test/libsolidity/semanticTests/smoke/structs.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct.sol index 68d1fc1e2..37a4baab4 100644 --- a/test/libsolidity/semanticTests/structs/calldata/calldata_struct.sol +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_and_ints.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_and_ints.sol index 21fada9c2..7d4d124bb 100644 --- a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_and_ints.sol +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_and_ints.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_array_member.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_array_member.sol index 3e8613fad..c15aaaf50 100644 --- a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_array_member.sol +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_array_member.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory.sol index ba985e3cd..9362d17be 100644 --- a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory.sol +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_storage.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_storage.sol index 185ffbe9a..1113c494d 100644 --- a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_storage.sol +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_storage.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_storage.sol index 8defbb9c9..efcb2a639 100644 --- a/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_storage.sol +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/calldata/calldata_structs.sol b/test/libsolidity/semanticTests/structs/calldata/calldata_structs.sol index 025e38829..cfcb43458 100644 --- a/test/libsolidity/semanticTests/structs/calldata/calldata_structs.sol +++ b/test/libsolidity/semanticTests/structs/calldata/calldata_structs.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/structs/calldata/dynamic_nested.sol b/test/libsolidity/semanticTests/structs/calldata/dynamic_nested.sol index f457af2eb..a22a11bf5 100644 --- a/test/libsolidity/semanticTests/structs/calldata/dynamic_nested.sol +++ b/test/libsolidity/semanticTests/structs/calldata/dynamic_nested.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S2 { uint256 b; } diff --git a/test/libsolidity/semanticTests/structs/calldata/dynamically_encoded.sol b/test/libsolidity/semanticTests/structs/calldata/dynamically_encoded.sol index 37396e9f0..b31fe3554 100644 --- a/test/libsolidity/semanticTests/structs/calldata/dynamically_encoded.sol +++ b/test/libsolidity/semanticTests/structs/calldata/dynamically_encoded.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint256[] a; } diff --git a/test/libsolidity/semanticTests/structs/global.sol b/test/libsolidity/semanticTests/structs/global.sol index ecbb39a24..6f943dbf7 100644 --- a/test/libsolidity/semanticTests/structs/global.sol +++ b/test/libsolidity/semanticTests/structs/global.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct S { uint256 a; uint256 b; } contract C { diff --git a/test/libsolidity/semanticTests/structs/memory_struct_named_constructor.sol b/test/libsolidity/semanticTests/structs/memory_struct_named_constructor.sol index af0060d51..32c36acaf 100644 --- a/test/libsolidity/semanticTests/structs/memory_struct_named_constructor.sol +++ b/test/libsolidity/semanticTests/structs/memory_struct_named_constructor.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol b/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol index b2ccfe2da..4194ff15b 100644 --- a/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol +++ b/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/struct_memory_to_storage.sol b/test/libsolidity/semanticTests/structs/struct_memory_to_storage.sol index d426105fc..71acc1ab9 100644 --- a/test/libsolidity/semanticTests/structs/struct_memory_to_storage.sol +++ b/test/libsolidity/semanticTests/structs/struct_memory_to_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol b/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol index 2a8b36f36..bdabb001a 100644 --- a/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol +++ b/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/struct_storage_to_memory.sol b/test/libsolidity/semanticTests/structs/struct_storage_to_memory.sol index 0a453f938..51db51b93 100644 --- a/test/libsolidity/semanticTests/structs/struct_storage_to_memory.sol +++ b/test/libsolidity/semanticTests/structs/struct_storage_to_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/structs/struct_storage_to_memory_function_ptr.sol b/test/libsolidity/semanticTests/structs/struct_storage_to_memory_function_ptr.sol index 12ba289ea..74a32a76e 100644 --- a/test/libsolidity/semanticTests/structs/struct_storage_to_memory_function_ptr.sol +++ b/test/libsolidity/semanticTests/structs/struct_storage_to_memory_function_ptr.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/types/mapping_enum_key_getter_v2.sol b/test/libsolidity/semanticTests/types/mapping_enum_key_getter_v2.sol index f822a9395..834e866a3 100644 --- a/test/libsolidity/semanticTests/types/mapping_enum_key_getter_v2.sol +++ b/test/libsolidity/semanticTests/types/mapping_enum_key_getter_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract test { enum E { A, B, C } mapping(E => uint8) public table; diff --git a/test/libsolidity/semanticTests/variables/public_state_overridding_dynamic_struct.sol b/test/libsolidity/semanticTests/variables/public_state_overridding_dynamic_struct.sol index f6fa4d45e..366b5fb09 100644 --- a/test/libsolidity/semanticTests/variables/public_state_overridding_dynamic_struct.sol +++ b/test/libsolidity/semanticTests/variables/public_state_overridding_dynamic_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct S { uint256 v; string s; } diff --git a/test/libsolidity/semanticTests/variables/public_state_overridding_mapping_to_dynamic_struct.sol b/test/libsolidity/semanticTests/variables/public_state_overridding_mapping_to_dynamic_struct.sol index 404013ee6..5a3df6d21 100644 --- a/test/libsolidity/semanticTests/variables/public_state_overridding_mapping_to_dynamic_struct.sol +++ b/test/libsolidity/semanticTests/variables/public_state_overridding_mapping_to_dynamic_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct S { uint256 v; string s; } diff --git a/test/libsolidity/semanticTests/various/nested_calldata_struct.sol b/test/libsolidity/semanticTests/various/nested_calldata_struct.sol index f02fda353..dde91c719 100644 --- a/test/libsolidity/semanticTests/various/nested_calldata_struct.sol +++ b/test/libsolidity/semanticTests/various/nested_calldata_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/various/nested_calldata_struct_to_memory.sol b/test/libsolidity/semanticTests/various/nested_calldata_struct_to_memory.sol index 19b2f64a7..3e96f2a6f 100644 --- a/test/libsolidity/semanticTests/various/nested_calldata_struct_to_memory.sol +++ b/test/libsolidity/semanticTests/various/nested_calldata_struct_to_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/semanticTests/various/skip_dynamic_types_for_static_arrays_with_dynamic_elements.sol b/test/libsolidity/semanticTests/various/skip_dynamic_types_for_static_arrays_with_dynamic_elements.sol index b320c2bce..65e0b4769 100644 --- a/test/libsolidity/semanticTests/various/skip_dynamic_types_for_static_arrays_with_dynamic_elements.sol +++ b/test/libsolidity/semanticTests/various/skip_dynamic_types_for_static_arrays_with_dynamic_elements.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/semanticTests/viaYul/calldata_array_access.sol b/test/libsolidity/semanticTests/viaYul/calldata_array_access.sol index 115015f03..6af0a830f 100644 --- a/test/libsolidity/semanticTests/viaYul/calldata_array_access.sol +++ b/test/libsolidity/semanticTests/viaYul/calldata_array_access.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[] calldata x, uint256 i) external returns (uint256) { return x[i]; diff --git a/test/libsolidity/semanticTests/viaYul/calldata_array_index_range_access.sol b/test/libsolidity/semanticTests/viaYul/calldata_array_index_range_access.sol index 6e0b45781..8d7ad3429 100644 --- a/test/libsolidity/semanticTests/viaYul/calldata_array_index_range_access.sol +++ b/test/libsolidity/semanticTests/viaYul/calldata_array_index_range_access.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[] calldata x, uint256 s, uint256 e) external returns (uint256) { return uint256[](x[s:e]).length; diff --git a/test/libsolidity/semanticTests/viaYul/calldata_array_length.sol b/test/libsolidity/semanticTests/viaYul/calldata_array_length.sol index 507380667..c7c38925e 100644 --- a/test/libsolidity/semanticTests/viaYul/calldata_array_length.sol +++ b/test/libsolidity/semanticTests/viaYul/calldata_array_length.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[] calldata x) external returns (uint256) { return x.length; diff --git a/test/libsolidity/semanticTests/viaYul/calldata_array_three_dimensional.sol b/test/libsolidity/semanticTests/viaYul/calldata_array_three_dimensional.sol index effa3b2b2..43158b14a 100644 --- a/test/libsolidity/semanticTests/viaYul/calldata_array_three_dimensional.sol +++ b/test/libsolidity/semanticTests/viaYul/calldata_array_three_dimensional.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][2][] calldata x, uint256 i, uint256 j, uint256 k) external returns (uint256 a, uint256 b, uint256 c, uint256 d) { diff --git a/test/libsolidity/semanticTests/viaYul/calldata_bytes_array_bounds.sol b/test/libsolidity/semanticTests/viaYul/calldata_bytes_array_bounds.sol index f9eebf14e..80b7dbcdc 100644 --- a/test/libsolidity/semanticTests/viaYul/calldata_bytes_array_bounds.sol +++ b/test/libsolidity/semanticTests/viaYul/calldata_bytes_array_bounds.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(bytes[] calldata a, uint256 i) external returns (uint) { return uint8(a[0][i]); diff --git a/test/libsolidity/semanticTests/viaYul/dirty_calldata_struct.sol b/test/libsolidity/semanticTests/viaYul/dirty_calldata_struct.sol index 633fc45c6..a9a5183be 100644 --- a/test/libsolidity/semanticTests/viaYul/dirty_calldata_struct.sol +++ b/test/libsolidity/semanticTests/viaYul/dirty_calldata_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint16[] m; diff --git a/test/libsolidity/semanticTests/viaYul/mapping_enum_key_getter.sol b/test/libsolidity/semanticTests/viaYul/mapping_enum_key_getter.sol index 78d9a39b9..c7790aa0c 100644 --- a/test/libsolidity/semanticTests/viaYul/mapping_enum_key_getter.sol +++ b/test/libsolidity/semanticTests/viaYul/mapping_enum_key_getter.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract test { enum E { A, B, C } mapping(E => uint8) public table; diff --git a/test/libsolidity/semanticTests/viaYul/struct_member_access.sol b/test/libsolidity/semanticTests/viaYul/struct_member_access.sol index 957226195..4dc22ef40 100644 --- a/test/libsolidity/semanticTests/viaYul/struct_member_access.sol +++ b/test/libsolidity/semanticTests/viaYul/struct_member_access.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_memory_to_memory.sol b/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_memory_to_memory.sol index 2e3ef86fd..bc1f7021b 100644 --- a/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_memory_to_memory.sol +++ b/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_memory_to_memory.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint[][] memory arr) public pure { diff --git a/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_storage_to_storage.sol b/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_storage_to_storage.sol index acf6a1e1d..6c4516ec7 100644 --- a/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_storage_to_storage.sol +++ b/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_storage_to_storage.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint[][] arr; diff --git a/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_memory_to_storage.sol b/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_memory_to_storage.sol index ce0d9ef5d..90c873d10 100644 --- a/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_memory_to_storage.sol +++ b/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_memory_to_storage.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint[][] arr; diff --git a/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_storage_to_memory.sol b/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_storage_to_memory.sol index 4aa03c222..355a9187e 100644 --- a/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_storage_to_memory.sol +++ b/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_storage_to_memory.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint[][] arr; diff --git a/test/libsolidity/smtCheckerTests/array_members/length_assignment_2d_memory_to_memory.sol b/test/libsolidity/smtCheckerTests/array_members/length_assignment_2d_memory_to_memory.sol index d85f01104..cfac3d721 100644 --- a/test/libsolidity/smtCheckerTests/array_members/length_assignment_2d_memory_to_memory.sol +++ b/test/libsolidity/smtCheckerTests/array_members/length_assignment_2d_memory_to_memory.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint[][] memory arr) public pure { diff --git a/test/libsolidity/smtCheckerTests/functions/abi_encode_functions.sol b/test/libsolidity/smtCheckerTests/functions/abi_encode_functions.sol index fb72bd18e..3c7fc141e 100644 --- a/test/libsolidity/smtCheckerTests/functions/abi_encode_functions.sol +++ b/test/libsolidity/smtCheckerTests/functions/abi_encode_functions.sol @@ -1,4 +1,4 @@ -pragma experimental SMTChecker;pragma experimental ABIEncoderV2; +pragma experimental SMTChecker;pragma abicoder v2; contract C { function f() public pure returns (bytes memory, bytes memory) { return (abi.encode(""), abi.encodePacked( "7?8r")); diff --git a/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_1.sol b/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_1.sol index 78d13ed14..bf02fcec3 100644 --- a/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_1.sol +++ b/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_1.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_2.sol b/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_2.sol index 3778ffe62..fd3c6759b 100644 --- a/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_2.sol +++ b/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_2.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_3.sol b/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_3.sol index 6304e39cd..94116f30a 100644 --- a/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_3.sol +++ b/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_3.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/smtCheckerTests/types/enum_in_struct.sol b/test/libsolidity/smtCheckerTests/types/enum_in_struct.sol index ffe5dfd95..179b624fd 100644 --- a/test/libsolidity/smtCheckerTests/types/enum_in_struct.sol +++ b/test/libsolidity/smtCheckerTests/types/enum_in_struct.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { diff --git a/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_safe.sol b/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_safe.sol index c7524fb64..a52c66f06 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_safe.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_safe.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { diff --git a/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_unsafe.sol b/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_unsafe.sol index f89b41288..7cdacc86b 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_unsafe.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_unsafe.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { diff --git a/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_storage_safe.sol b/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_storage_safe.sol index bfa45c90f..941710403 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_storage_safe.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_storage_safe.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_memory.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_memory.sol index a6be72cc4..b6da89f50 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_memory.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_memory.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_safe.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_safe.sol index ed8d97905..bb48fe150 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_safe.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_safe.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_1.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_1.sol index dcdad4da7..c000fa5b7 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_1.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_1.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_2.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_2.sol index 30271985b..59fb6c067 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_2.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_2.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_delete_memory.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_delete_memory.sol index 94c919f8b..553d2b859 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_delete_memory.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_delete_memory.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_delete_storage.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_delete_storage.sol index 47f46767c..92b2c598e 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_delete_storage.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_delete_storage.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_unary_add.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_unary_add.sol index 93e6195f2..68d1bac5b 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_unary_add.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_unary_add.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/smtCheckerTests/types/struct/struct_unary_sub.sol b/test/libsolidity/smtCheckerTests/types/struct/struct_unary_sub.sol index 47713019e..a7dc5d4dc 100644 --- a/test/libsolidity/smtCheckerTests/types/struct/struct_unary_sub.sol +++ b/test/libsolidity/smtCheckerTests/types/struct/struct_unary_sub.sol @@ -1,5 +1,5 @@ pragma experimental SMTChecker; -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { diff --git a/test/libsolidity/syntaxTests/abiEncoder/conflicting_settings.sol b/test/libsolidity/syntaxTests/abiEncoder/conflicting_settings.sol index 29488de12..da81a3bc6 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/conflicting_settings.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/conflicting_settings.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; pragma abicoder v1; // ---- // SyntaxError 3845: (34-53): ABI coder has already been selected for this source unit. diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol index 63f7af68a..231ab66e0 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_constructor_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_constructor_accepting_struct.sol index c7ecbfff7..0005e3bbb 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_constructor_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_constructor_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_accepting_struct_via_named_argument.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_accepting_struct_via_named_argument.sol index 220fc1b29..0110a734a 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_accepting_struct_via_named_argument.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_accepting_struct_via_named_argument.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_pointer_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_pointer_accepting_struct.sol index be9517f40..8fb8b9ed8 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_pointer_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_pointer_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_dynamic_string_array.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_dynamic_string_array.sol index 24254e5f4..6f96508f9 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_dynamic_string_array.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_dynamic_string_array.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() external view returns (string[] memory) {} diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct.sol index d62452ab8..8b80f80c4 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol index 881ebd954..88d13a41e 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_event_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_event_accepting_struct.sol index 87498d206..4ba439035 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_event_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_event_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_bound_function_returning_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_bound_function_returning_struct.sol index 7804240ad..901a02328 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_bound_function_returning_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_bound_function_returning_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol index 46b350118..238905863 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_returning_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_returning_struct.sol index 86be448f7..71f64d84f 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_returning_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_returning_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol index 2096c4174..8322f650d 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { bool flag; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol index 7c3b3b98f..eb68a03bf 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { bool flag; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol index ddf8650f1..ce72e3825 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { bool flag; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol index a1241fcee..fa0ab0a3d 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Item { uint x; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_accepting_struct.sol index 3665e22f6..4657a431f 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_returning_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_returning_struct.sol index febb3d3d7..9b687a030 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_returning_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_function_returning_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol index 42a13138f..2dc8e4b58 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Item { uint x; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol index 9d9bfccfb..c43b49154 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { bool flag; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol index a0aa13f5d..983579657 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol @@ -30,7 +30,7 @@ contract V1B { } } ==== Source: V2A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "X"; contract V2A { @@ -40,7 +40,7 @@ contract V2A { } } ==== Source: X ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { bool flag; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_with_returndata_support.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_with_returndata_support.sol index bc3b4ce36..bafff148d 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_with_returndata_support.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_with_returndata_support.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function get() public view returns (uint[][] memory) {} diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_without_returndata_support.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_without_returndata_support.sol index eb1b9bb9d..7e97b98da 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_without_returndata_support.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_accessing_returned_dynamic_array_without_returndata_support.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function get() public view returns (uint[][] memory) {} diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_constructor_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_constructor_accepting_struct.sol index c5f54a95f..bf3720c6c 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_constructor_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_constructor_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { @@ -9,7 +9,7 @@ contract C { constructor(Item memory _item) {} } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_pointer_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_pointer_accepting_struct.sol index a47f0d6d3..f55e778fe 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_pointer_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_pointer_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { @@ -9,7 +9,7 @@ contract C { function get(Item memory _item) external {} } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_dynamic_string_array.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_dynamic_string_array.sol index 6b5d8dfb8..032e2a8f3 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_dynamic_string_array.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_dynamic_string_array.sol @@ -1,11 +1,11 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() external view returns (string[] memory) {} } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct.sol index 4d2d7f9e5..48ee2f5cb 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { @@ -9,7 +9,7 @@ contract C { function get() external view returns(Item memory) {} } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol index fd5f9da7e..502f06da8 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_contract_function_returning_struct_with_dynamic_array.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct Item { @@ -9,7 +9,7 @@ contract C { function get() external view returns(Item memory) {} } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_event_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_event_accepting_struct.sol index 434a7e4b9..b18b1c650 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_event_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_event_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { @@ -8,7 +8,7 @@ library L { event E(Item _value); } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_pointer_accepting_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_pointer_accepting_struct.sol index 5b3829526..0a7919261 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_pointer_accepting_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_pointer_accepting_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { @@ -9,7 +9,7 @@ library L { function get(Item memory _item) external {} } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_returning_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_returning_struct.sol index 333c36101..1f1222a5a 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_returning_struct.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_returning_struct.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct Item { @@ -9,7 +9,7 @@ library L { function get() external view returns(Item memory) {} } ==== Source: B ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "A"; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v1_modifier_sandwich.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v1_modifier_sandwich.sol index ea64c5c6f..337da4846 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v1_modifier_sandwich.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v1_modifier_sandwich.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { bool flag; diff --git a/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v2_modifier_sandwich.sol b/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v2_modifier_sandwich.sol index df1c4ed3c..57d1ba770 100644 --- a/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v2_modifier_sandwich.sol +++ b/test/libsolidity/syntaxTests/abiEncoder/v2_v1_v2_modifier_sandwich.sol @@ -1,5 +1,5 @@ ==== Source: A ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct Data { bool flag; @@ -18,7 +18,7 @@ contract B { } } ==== Source: C ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "B"; diff --git a/test/libsolidity/syntaxTests/array/calldata.sol b/test/libsolidity/syntaxTests/array/calldata.sol index f405adb5e..77af5400d 100644 --- a/test/libsolidity/syntaxTests/array/calldata.sol +++ b/test/libsolidity/syntaxTests/array/calldata.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { function f(uint[3] calldata) external { } } diff --git a/test/libsolidity/syntaxTests/array/calldata_assign.sol b/test/libsolidity/syntaxTests/array/calldata_assign.sol index 694c9e580..05a8f682d 100644 --- a/test/libsolidity/syntaxTests/array/calldata_assign.sol +++ b/test/libsolidity/syntaxTests/array/calldata_assign.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { function f(uint256[] calldata s) external { s[0] = 4; } } diff --git a/test/libsolidity/syntaxTests/array/calldata_dynamic.sol b/test/libsolidity/syntaxTests/array/calldata_dynamic.sol index 1a480111c..0b8d3fda5 100644 --- a/test/libsolidity/syntaxTests/array/calldata_dynamic.sol +++ b/test/libsolidity/syntaxTests/array/calldata_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { function f(uint[] calldata) external { } } diff --git a/test/libsolidity/syntaxTests/array/calldata_multi.sol b/test/libsolidity/syntaxTests/array/calldata_multi.sol index 6489f4aa5..9fa2b60ad 100644 --- a/test/libsolidity/syntaxTests/array/calldata_multi.sol +++ b/test/libsolidity/syntaxTests/array/calldata_multi.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { function f(uint[3][4] calldata) external { } } diff --git a/test/libsolidity/syntaxTests/array/calldata_multi_dynamic.sol b/test/libsolidity/syntaxTests/array/calldata_multi_dynamic.sol index fd860b2f4..8112fd4cd 100644 --- a/test/libsolidity/syntaxTests/array/calldata_multi_dynamic.sol +++ b/test/libsolidity/syntaxTests/array/calldata_multi_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { function f(uint[][] calldata) external { } } diff --git a/test/libsolidity/syntaxTests/array/function_mapping.sol b/test/libsolidity/syntaxTests/array/function_mapping.sol index 934c7ebd8..531ef6c7b 100644 --- a/test/libsolidity/syntaxTests/array/function_mapping.sol +++ b/test/libsolidity/syntaxTests/array/function_mapping.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { function f(mapping(uint => uint)[] memory x) public pure {} diff --git a/test/libsolidity/syntaxTests/array/function_mapping_library.sol b/test/libsolidity/syntaxTests/array/function_mapping_library.sol index fb709292a..f495362c9 100644 --- a/test/libsolidity/syntaxTests/array/function_mapping_library.sol +++ b/test/libsolidity/syntaxTests/array/function_mapping_library.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { function f(mapping(uint => uint)[2] memory a) external pure returns (mapping(uint => uint)[2] memory) {} } diff --git a/test/libsolidity/syntaxTests/array/length/parameter_too_large_multidim_ABIv2.sol b/test/libsolidity/syntaxTests/array/length/parameter_too_large_multidim_ABIv2.sol index a837d1b5f..7fd7b531b 100644 --- a/test/libsolidity/syntaxTests/array/length/parameter_too_large_multidim_ABIv2.sol +++ b/test/libsolidity/syntaxTests/array/length/parameter_too_large_multidim_ABIv2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(bytes32[1263941234127518272][500] memory) public pure {} diff --git a/test/libsolidity/syntaxTests/array/nested_calldata_memory.sol b/test/libsolidity/syntaxTests/array/nested_calldata_memory.sol index b8361e115..25be459a9 100644 --- a/test/libsolidity/syntaxTests/array/nested_calldata_memory.sol +++ b/test/libsolidity/syntaxTests/array/nested_calldata_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct shouldBug { diff --git a/test/libsolidity/syntaxTests/array/nested_calldata_memory2.sol b/test/libsolidity/syntaxTests/array/nested_calldata_memory2.sol index c886c8eee..2aed58103 100644 --- a/test/libsolidity/syntaxTests/array/nested_calldata_memory2.sol +++ b/test/libsolidity/syntaxTests/array/nested_calldata_memory2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct shouldBug { diff --git a/test/libsolidity/syntaxTests/array/nested_calldata_memory3.sol b/test/libsolidity/syntaxTests/array/nested_calldata_memory3.sol index d8716d18e..94008ae59 100644 --- a/test/libsolidity/syntaxTests/array/nested_calldata_memory3.sol +++ b/test/libsolidity/syntaxTests/array/nested_calldata_memory3.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct shouldBug { diff --git a/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol b/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol index bae103321..e9878fc22 100644 --- a/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol +++ b/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint[][2] tmp_i; diff --git a/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol b/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol index d922d717f..2d1c1f586 100644 --- a/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol +++ b/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { uint[][] tmp_i; diff --git a/test/libsolidity/syntaxTests/conversion/implicit_conversion_from_array_of_string_literals_to_calldata_string.sol b/test/libsolidity/syntaxTests/conversion/implicit_conversion_from_array_of_string_literals_to_calldata_string.sol index 328a86f79..b9f95df66 100644 --- a/test/libsolidity/syntaxTests/conversion/implicit_conversion_from_array_of_string_literals_to_calldata_string.sol +++ b/test/libsolidity/syntaxTests/conversion/implicit_conversion_from_array_of_string_literals_to_calldata_string.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() public pure returns(string[5] calldata) { diff --git a/test/libsolidity/syntaxTests/events/event_array_indexed_v2.sol b/test/libsolidity/syntaxTests/events/event_array_indexed_v2.sol index 6c208be87..558e2f433 100644 --- a/test/libsolidity/syntaxTests/events/event_array_indexed_v2.sol +++ b/test/libsolidity/syntaxTests/events/event_array_indexed_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract c { event E(uint[] indexed); } diff --git a/test/libsolidity/syntaxTests/events/event_array_v2.sol b/test/libsolidity/syntaxTests/events/event_array_v2.sol index 9a3cc3966..6f0a1936d 100644 --- a/test/libsolidity/syntaxTests/events/event_array_v2.sol +++ b/test/libsolidity/syntaxTests/events/event_array_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract c { event E(uint[]); } diff --git a/test/libsolidity/syntaxTests/events/event_nested_array_indexed_v2.sol b/test/libsolidity/syntaxTests/events/event_nested_array_indexed_v2.sol index 3f8a7c626..0643fdec2 100644 --- a/test/libsolidity/syntaxTests/events/event_nested_array_indexed_v2.sol +++ b/test/libsolidity/syntaxTests/events/event_nested_array_indexed_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract c { event E(uint[][] indexed); } diff --git a/test/libsolidity/syntaxTests/events/event_nested_array_v2.sol b/test/libsolidity/syntaxTests/events/event_nested_array_v2.sol index 1ec22f9e8..a314a164f 100644 --- a/test/libsolidity/syntaxTests/events/event_nested_array_v2.sol +++ b/test/libsolidity/syntaxTests/events/event_nested_array_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract c { event E(uint[][]); } diff --git a/test/libsolidity/syntaxTests/events/event_struct_indexed_v2.sol b/test/libsolidity/syntaxTests/events/event_struct_indexed_v2.sol index 2a8748313..b67b37b85 100644 --- a/test/libsolidity/syntaxTests/events/event_struct_indexed_v2.sol +++ b/test/libsolidity/syntaxTests/events/event_struct_indexed_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract c { struct S { uint a ; } event E(S indexed); diff --git a/test/libsolidity/syntaxTests/events/event_struct_v2.sol b/test/libsolidity/syntaxTests/events/event_struct_v2.sol index 4f4839acc..53e538d1a 100644 --- a/test/libsolidity/syntaxTests/events/event_struct_v2.sol +++ b/test/libsolidity/syntaxTests/events/event_struct_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract c { struct S { uint a ; } event E(S); diff --git a/test/libsolidity/syntaxTests/iceRegressionTests/large_struct_array.sol b/test/libsolidity/syntaxTests/iceRegressionTests/large_struct_array.sol index 0f6f49f63..411518710 100644 --- a/test/libsolidity/syntaxTests/iceRegressionTests/large_struct_array.sol +++ b/test/libsolidity/syntaxTests/iceRegressionTests/large_struct_array.sol @@ -1,5 +1,5 @@ // Used to cause ICE because of a too strict assert -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; T[222222222222222222222222222] sub; } struct T { uint[] x; } diff --git a/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_match.sol b/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_match.sol index 01ac5fdc3..c4eca74fb 100644 --- a/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_match.sol +++ b/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_match.sol @@ -1,5 +1,5 @@ ==== Source: A.sol ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract A { @@ -8,12 +8,12 @@ contract A function f(S memory _s) public returns (S memory,S memory) { } } ==== Source: B.sol ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "./A.sol"; contract B is A { } ==== Source: C.sol ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "./B.sol"; contract C is B { } diff --git a/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_1.sol b/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_1.sol index 6e90f7d49..9e1761284 100644 --- a/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_1.sol +++ b/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_1.sol @@ -1,5 +1,5 @@ ==== Source: A.sol ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract A { @@ -8,7 +8,7 @@ contract A function f(S memory _s) public returns (S memory,S memory) { } } ==== Source: B.sol ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "./A.sol"; contract B is A { } diff --git a/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_2.sol b/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_2.sol index 7e5cfc7fd..b4cd6c6c4 100644 --- a/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_2.sol +++ b/test/libsolidity/syntaxTests/imports/inheritance_abi_encoder_mismatch_2.sol @@ -1,5 +1,5 @@ ==== Source: A.sol ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract A { diff --git a/test/libsolidity/syntaxTests/imports/transitive.sol b/test/libsolidity/syntaxTests/imports/transitive.sol index e6a5771e9..eab02b6f6 100644 --- a/test/libsolidity/syntaxTests/imports/transitive.sol +++ b/test/libsolidity/syntaxTests/imports/transitive.sol @@ -4,7 +4,7 @@ struct S { uint[2] mS; } import "a" as A; struct T { A.S[2] mT; } ==== Source: c ==== -pragma experimental ABIEncoderV2; +pragma abicoder v2; import "b" as B; contract C { function f(B.T memory y, B.A.S memory z) public pure returns (uint, uint) { diff --git a/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_interface_struct.sol b/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_interface_struct.sol index e422ac280..e77836724 100644 --- a/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_interface_struct.sol +++ b/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_interface_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; interface I { struct S { int a; } function f(S calldata) external pure; diff --git a/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_struct.sol b/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_struct.sol index 4ae4403bb..65afb8cc6 100644 --- a/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_struct.sol +++ b/test/libsolidity/syntaxTests/inheritance/override/calldata_memory_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract A { uint dummy; struct S { int a; } diff --git a/test/libsolidity/syntaxTests/inheritance/override/public_var_override_mapping_to_dynamic_struct.sol b/test/libsolidity/syntaxTests/inheritance/override/public_var_override_mapping_to_dynamic_struct.sol index d02284aef..f3e886552 100644 --- a/test/libsolidity/syntaxTests/inheritance/override/public_var_override_mapping_to_dynamic_struct.sol +++ b/test/libsolidity/syntaxTests/inheritance/override/public_var_override_mapping_to_dynamic_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; abstract contract C { struct S { diff --git a/test/libsolidity/syntaxTests/inheritance/override/public_var_override_struct_with_memory_element.sol b/test/libsolidity/syntaxTests/inheritance/override/public_var_override_struct_with_memory_element.sol index 4e6e02598..3a0fce375 100644 --- a/test/libsolidity/syntaxTests/inheritance/override/public_var_override_struct_with_memory_element.sol +++ b/test/libsolidity/syntaxTests/inheritance/override/public_var_override_struct_with_memory_element.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; abstract contract C { struct S { diff --git a/test/libsolidity/syntaxTests/lvalues/calldata_member_access.sol b/test/libsolidity/syntaxTests/lvalues/calldata_member_access.sol index 42c3a3f97..dc6e9290a 100644 --- a/test/libsolidity/syntaxTests/lvalues/calldata_member_access.sol +++ b/test/libsolidity/syntaxTests/lvalues/calldata_member_access.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint256 x; } function f(S calldata s) external pure { diff --git a/test/libsolidity/syntaxTests/missing_functions_duplicate_bug.sol b/test/libsolidity/syntaxTests/missing_functions_duplicate_bug.sol index 0ba307b8f..32ae4045b 100644 --- a/test/libsolidity/syntaxTests/missing_functions_duplicate_bug.sol +++ b/test/libsolidity/syntaxTests/missing_functions_duplicate_bug.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Ownable { address private _owner; diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/039_functions_with_identical_structs_in_interface.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/039_functions_with_identical_structs_in_interface.sol index 38fe146e8..f750fae39 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/039_functions_with_identical_structs_in_interface.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/039_functions_with_identical_structs_in_interface.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S1 { int i; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/040_functions_with_different_structs_in_interface.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/040_functions_with_different_structs_in_interface.sol index 291dd0800..9bc0471bc 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/040_functions_with_different_structs_in_interface.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/040_functions_with_different_structs_in_interface.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S1 { function() external a; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/041_functions_with_structs_of_non_external_types_in_interface.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/041_functions_with_structs_of_non_external_types_in_interface.sol index 77f8dd247..6dff9d8b2 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/041_functions_with_structs_of_non_external_types_in_interface.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/041_functions_with_structs_of_non_external_types_in_interface.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { function() internal a; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_structs_of_non_external_types_in_interface_2.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_structs_of_non_external_types_in_interface_2.sol index 541dd0a04..297f809fd 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_structs_of_non_external_types_in_interface_2.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_structs_of_non_external_types_in_interface_2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { mapping(uint => uint) a; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_stucts_of_non_external_types_in_interface_2.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_stucts_of_non_external_types_in_interface_2.sol index 541dd0a04..297f809fd 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_stucts_of_non_external_types_in_interface_2.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/042_functions_with_stucts_of_non_external_types_in_interface_2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { mapping(uint => uint) a; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_structs_of_non_external_types_in_interface_nested.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_structs_of_non_external_types_in_interface_nested.sol index d2c96d4bc..78660bdae 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_structs_of_non_external_types_in_interface_nested.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_structs_of_non_external_types_in_interface_nested.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { mapping(uint => uint) a; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_stucts_of_non_external_types_in_interface_nested.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_stucts_of_non_external_types_in_interface_nested.sol index d2c96d4bc..78660bdae 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_stucts_of_non_external_types_in_interface_nested.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/043_functions_with_stucts_of_non_external_types_in_interface_nested.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { mapping(uint => uint) a; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/044_returning_multi_dimensional_arrays_new_abi.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/044_returning_multi_dimensional_arrays_new_abi.sol index aa41880b1..c266406d2 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/044_returning_multi_dimensional_arrays_new_abi.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/044_returning_multi_dimensional_arrays_new_abi.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() public pure returns (string[][] memory) {} diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/047_returning_arrays_in_structs_new_abi.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/047_returning_arrays_in_structs_new_abi.sol index c130d62d9..5b761aad2 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/047_returning_arrays_in_structs_new_abi.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/047_returning_arrays_in_structs_new_abi.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { string[] s; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/260_library_memory_struct.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/260_library_memory_struct.sol index 1b9825623..cfd3fcda6 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/260_library_memory_struct.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/260_library_memory_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; library c { struct S { uint x; } function f() public returns (S memory) {} diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/403_return_structs.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/403_return_structs.sol index 063244eed..d025dfb8b 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/403_return_structs.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/403_return_structs.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; T[] sub; } struct T { uint[] x; } diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/404_read_returned_struct.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/404_read_returned_struct.sol index b074cb488..39958b66c 100644 --- a/test/libsolidity/syntaxTests/nameAndTypeResolution/404_read_returned_struct.sol +++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/404_read_returned_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract A { struct T { int x; diff --git a/test/libsolidity/syntaxTests/parsing/array_range_nested.sol b/test/libsolidity/syntaxTests/parsing/array_range_nested.sol index 16fde7999..5f027cc8c 100644 --- a/test/libsolidity/syntaxTests/parsing/array_range_nested.sol +++ b/test/libsolidity/syntaxTests/parsing/array_range_nested.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][] calldata x) external pure { x[0][1:2]; diff --git a/test/libsolidity/syntaxTests/parsing/array_range_nested_invalid.sol b/test/libsolidity/syntaxTests/parsing/array_range_nested_invalid.sol index c224818b4..700f3e1ff 100644 --- a/test/libsolidity/syntaxTests/parsing/array_range_nested_invalid.sol +++ b/test/libsolidity/syntaxTests/parsing/array_range_nested_invalid.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(uint256[][] calldata x) external pure { x[1:2]; diff --git a/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_nested_dynamic_array_v2.sol b/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_nested_dynamic_array_v2.sol index 54a81e839..150ac68e3 100644 --- a/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_nested_dynamic_array_v2.sol +++ b/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_nested_dynamic_array_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() public pure { diff --git a/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_structs_v2.sol b/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_structs_v2.sol index 044ce6031..f03c27a1b 100644 --- a/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_structs_v2.sol +++ b/test/libsolidity/syntaxTests/specialFunctions/abi_encodePacked_structs_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint x; } diff --git a/test/libsolidity/syntaxTests/specialFunctions/abi_encode_nested_dynamic_array_v2.sol b/test/libsolidity/syntaxTests/specialFunctions/abi_encode_nested_dynamic_array_v2.sol index 911c7b6fd..e12c37e7b 100644 --- a/test/libsolidity/syntaxTests/specialFunctions/abi_encode_nested_dynamic_array_v2.sol +++ b/test/libsolidity/syntaxTests/specialFunctions/abi_encode_nested_dynamic_array_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() public pure { diff --git a/test/libsolidity/syntaxTests/specialFunctions/abi_encode_structs_abiv2.sol b/test/libsolidity/syntaxTests/specialFunctions/abi_encode_structs_abiv2.sol index 7f1bc6180..e7117f2b1 100644 --- a/test/libsolidity/syntaxTests/specialFunctions/abi_encode_structs_abiv2.sol +++ b/test/libsolidity/syntaxTests/specialFunctions/abi_encode_structs_abiv2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint x; } diff --git a/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_nested_dynamic_array_v2.sol b/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_nested_dynamic_array_v2.sol index 55f3b169b..54f1d5a6e 100644 --- a/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_nested_dynamic_array_v2.sol +++ b/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_nested_dynamic_array_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f() public pure { diff --git a/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_struct_v2.sol b/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_struct_v2.sol index 80c9c527a..824f723ed 100644 --- a/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_struct_v2.sol +++ b/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_struct_v2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; struct S { uint x; diff --git a/test/libsolidity/syntaxTests/specialFunctions/encode_array_of_struct.sol b/test/libsolidity/syntaxTests/specialFunctions/encode_array_of_struct.sol index 8918decb7..0e7b99a54 100644 --- a/test/libsolidity/syntaxTests/specialFunctions/encode_array_of_struct.sol +++ b/test/libsolidity/syntaxTests/specialFunctions/encode_array_of_struct.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint x; } function f() public pure { diff --git a/test/libsolidity/syntaxTests/structs/array_calldata.sol b/test/libsolidity/syntaxTests/structs/array_calldata.sol index e0a750c10..30ca2ebed 100644 --- a/test/libsolidity/syntaxTests/structs/array_calldata.sol +++ b/test/libsolidity/syntaxTests/structs/array_calldata.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct S { int a; } function f(S[] calldata) external { } diff --git a/test/libsolidity/syntaxTests/structs/calldata.sol b/test/libsolidity/syntaxTests/structs/calldata.sol index 16a66aaba..420cc6b7f 100644 --- a/test/libsolidity/syntaxTests/structs/calldata.sol +++ b/test/libsolidity/syntaxTests/structs/calldata.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct S { int a; } function f(S calldata) external { } diff --git a/test/libsolidity/syntaxTests/structs/calldata_array_assign.sol b/test/libsolidity/syntaxTests/structs/calldata_array_assign.sol index adfa389ae..33b10f5f5 100644 --- a/test/libsolidity/syntaxTests/structs/calldata_array_assign.sol +++ b/test/libsolidity/syntaxTests/structs/calldata_array_assign.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct S { int[3] a; } function f(S calldata s, int[3] calldata a) external { diff --git a/test/libsolidity/syntaxTests/structs/calldata_assign.sol b/test/libsolidity/syntaxTests/structs/calldata_assign.sol index d8d921008..798e6dd60 100644 --- a/test/libsolidity/syntaxTests/structs/calldata_assign.sol +++ b/test/libsolidity/syntaxTests/structs/calldata_assign.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct S { int a; } function f(S calldata s) external { s.a = 4; } diff --git a/test/libsolidity/syntaxTests/structs/calldata_dynamic.sol b/test/libsolidity/syntaxTests/structs/calldata_dynamic.sol index 72e126f1d..8e3f1954d 100644 --- a/test/libsolidity/syntaxTests/structs/calldata_dynamic.sol +++ b/test/libsolidity/syntaxTests/structs/calldata_dynamic.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct S { int[] a; } function f(S calldata) external { } diff --git a/test/libsolidity/syntaxTests/structs/calldata_struct_function_type.sol b/test/libsolidity/syntaxTests/structs/calldata_struct_function_type.sol index 420ee6cd6..b2e5f6e2c 100644 --- a/test/libsolidity/syntaxTests/structs/calldata_struct_function_type.sol +++ b/test/libsolidity/syntaxTests/structs/calldata_struct_function_type.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { function (uint) external returns (uint) fn; } function f(S calldata s) external returns (uint256 a) { diff --git a/test/libsolidity/syntaxTests/structs/calldata_struct_mapping_function.sol b/test/libsolidity/syntaxTests/structs/calldata_struct_mapping_function.sol index 398c52701..dcdbad68b 100644 --- a/test/libsolidity/syntaxTests/structs/calldata_struct_mapping_function.sol +++ b/test/libsolidity/syntaxTests/structs/calldata_struct_mapping_function.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract test { struct S { diff --git a/test/libsolidity/syntaxTests/structs/memory_to_calldata.sol b/test/libsolidity/syntaxTests/structs/memory_to_calldata.sol index 19747e9a5..56d26a27a 100644 --- a/test/libsolidity/syntaxTests/structs/memory_to_calldata.sol +++ b/test/libsolidity/syntaxTests/structs/memory_to_calldata.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct S { int a; } function f(S calldata s) external { s = S(2); } diff --git a/test/libsolidity/syntaxTests/structs/recursion/multi_struct_composition.sol b/test/libsolidity/syntaxTests/structs/recursion/multi_struct_composition.sol index aab55d643..40f1eca8d 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/multi_struct_composition.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/multi_struct_composition.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct T { U u; V v; } diff --git a/test/libsolidity/syntaxTests/structs/recursion/parallel_structs.sol b/test/libsolidity/syntaxTests/structs/recursion/parallel_structs.sol index 34da3e033..3bd34360a 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/parallel_structs.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/parallel_structs.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract TestContract { diff --git a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_contract_function_parameter.sol b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_contract_function_parameter.sol index f0a3de401..2f29d3d44 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_contract_function_parameter.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_contract_function_parameter.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract Test { struct MyStructName { diff --git a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_memory_library_function_parameter.sol b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_memory_library_function_parameter.sol index e32cceef3..6739a8985 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_memory_library_function_parameter.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_as_memory_library_function_parameter.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; library Test { struct MyStructName { diff --git a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_forward_reference.sol b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_forward_reference.sol index e799573c9..3e429d5b3 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_forward_reference.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_forward_reference.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f(Data.S memory a) public {} diff --git a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_function_pointer.sol b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_function_pointer.sol index dc40ae3b2..5856e9efa 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_function_pointer.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/recursive_struct_function_pointer.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; diff --git a/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs.sol b/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs.sol index 15fca7d71..043dcd658 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; S[] sub; } diff --git a/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs2.sol b/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs2.sol index a5b1507d3..05a53a71b 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs2.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; S[2][] sub; } diff --git a/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs3.sol b/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs3.sol index fa9eebb9b..118dc1973 100644 --- a/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs3.sol +++ b/test/libsolidity/syntaxTests/structs/recursion/return_recursive_structs3.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { uint a; S[][][] sub; } diff --git a/test/libsolidity/syntaxTests/types/encoding_fractional_abiencoderv2.sol b/test/libsolidity/syntaxTests/types/encoding_fractional_abiencoderv2.sol index 406a56bef..6c818fa76 100644 --- a/test/libsolidity/syntaxTests/types/encoding_fractional_abiencoderv2.sol +++ b/test/libsolidity/syntaxTests/types/encoding_fractional_abiencoderv2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f1() public pure returns (bytes memory) { return abi.encode(0.1, 1); diff --git a/test/libsolidity/syntaxTests/types/encoding_packed_fractional_abiencoderv2.sol b/test/libsolidity/syntaxTests/types/encoding_packed_fractional_abiencoderv2.sol index 0448121e8..c227caa40 100644 --- a/test/libsolidity/syntaxTests/types/encoding_packed_fractional_abiencoderv2.sol +++ b/test/libsolidity/syntaxTests/types/encoding_packed_fractional_abiencoderv2.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { function f1() public pure returns (bytes memory) { return abi.encodePacked(0.1, 1); diff --git a/test/libsolidity/syntaxTests/types/mapping/library_nested_mapping.sol b/test/libsolidity/syntaxTests/types/mapping/library_nested_mapping.sol index 31bf3cb1f..5eb22d833 100644 --- a/test/libsolidity/syntaxTests/types/mapping/library_nested_mapping.sol +++ b/test/libsolidity/syntaxTests/types/mapping/library_nested_mapping.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; library L { struct S { mapping(uint => uint) m; } function f(S memory a) external pure returns (S memory) {} diff --git a/test/libsolidity/syntaxTests/types/mapping/mapping_function_calldata.sol b/test/libsolidity/syntaxTests/types/mapping/mapping_function_calldata.sol index f2360b2d1..1301a03c3 100644 --- a/test/libsolidity/syntaxTests/types/mapping/mapping_function_calldata.sol +++ b/test/libsolidity/syntaxTests/types/mapping/mapping_function_calldata.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract test { struct S { diff --git a/test/libsolidity/syntaxTests/types/mapping/mapping_struct_data_location_memory.sol b/test/libsolidity/syntaxTests/types/mapping/mapping_struct_data_location_memory.sol index 648e2f74e..8208c2e2e 100644 --- a/test/libsolidity/syntaxTests/types/mapping/mapping_struct_data_location_memory.sol +++ b/test/libsolidity/syntaxTests/types/mapping/mapping_struct_data_location_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { mapping(uint => uint) a; } function f(S memory) public {} diff --git a/test/libsolidity/syntaxTests/types/mapping/mapping_struct_recusrive_data_location_memory.sol b/test/libsolidity/syntaxTests/types/mapping/mapping_struct_recusrive_data_location_memory.sol index 350129dff..fa09bdeae 100644 --- a/test/libsolidity/syntaxTests/types/mapping/mapping_struct_recusrive_data_location_memory.sol +++ b/test/libsolidity/syntaxTests/types/mapping/mapping_struct_recusrive_data_location_memory.sol @@ -1,4 +1,4 @@ -pragma experimental ABIEncoderV2; +pragma abicoder v2; contract C { struct S { mapping(uint => uint) a; } struct T { S s; }