diff --git a/Changelog.md b/Changelog.md index 3d79926ad..333be4108 100644 --- a/Changelog.md +++ b/Changelog.md @@ -27,10 +27,15 @@ AST Changes: ### 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: + * 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/docs/contracts/functions.rst b/docs/contracts/functions.rst index 73ba7d2c1..279fec1f3 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. diff --git a/docs/grammar/Solidity.g4 b/docs/grammar/Solidity.g4 index 6e243612e..3d66df9b6 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;} diff --git a/docs/installing-solidity.rst b/docs/installing-solidity.rst index 9a787b30b..e7e2d73e7 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,12 +189,109 @@ 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: +Static Binaries +=============== -.. code-block:: bash +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. - emerge dev-lang/solidity +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: @@ -271,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 @@ -338,10 +445,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 @@ -381,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``. @@ -409,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: @@ -428,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 diff --git a/libsolidity/analysis/OverrideChecker.cpp b/libsolidity/analysis/OverrideChecker.cpp index 939c01e9e..0b87f9502 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/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp index 2397dafcc..f0db8f323 100644 --- a/libsolidity/analysis/TypeChecker.cpp +++ b/libsolidity/analysis/TypeChecker.cpp @@ -1846,15 +1846,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/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/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp index 6fbf921f7..bab2e588b 100644 --- a/libsolidity/codegen/ContractCompiler.cpp +++ b/libsolidity/codegen/ContractCompiler.cpp @@ -478,10 +478,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"); @@ -490,6 +501,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()); @@ -599,7 +611,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()) @@ -609,7 +623,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( @@ -639,7 +653,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)); @@ -650,7 +665,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; @@ -1226,7 +1241,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()) @@ -1391,11 +1406,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/libsolidity/codegen/YulUtilFunctions.cpp b/libsolidity/codegen/YulUtilFunctions.cpp index 3b079bd61..5ce5d27a5 100644 --- a/libsolidity/codegen/YulUtilFunctions.cpp +++ b/libsolidity/codegen/YulUtilFunctions.cpp @@ -3090,14 +3090,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/libsolidity/codegen/ir/IRGenerator.cpp b/libsolidity/codegen/ir/IRGenerator.cpp index 73bc6b1bb..c518c7763 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/libsolidity/formal/SMTEncoder.cpp b/libsolidity/formal/SMTEncoder.cpp index 2296631aa..bffe372fe 100644 --- a/libsolidity/formal/SMTEncoder.cpp +++ b/libsolidity/formal/SMTEncoder.cpp @@ -1119,7 +1119,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(), diff --git a/scripts/bytecodecompare/storebytecode.sh b/scripts/bytecodecompare/storebytecode.sh index 9bfce7c29..d9b04ae54 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/ @@ -108,10 +104,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." diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp index 64ef533a5..b74cc224f 100644 --- a/solc/CommandLineInterface.cpp +++ b/solc/CommandLineInterface.cpp @@ -55,6 +55,7 @@ #include #include +#include #include #include @@ -1780,20 +1781,26 @@ 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; + serr() << '"' << string(it, it + min(placeholderSize, static_cast(end - it))) << "\" is not a valid link reference." << endl; 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. 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 072762931..2af98f0d8 100644 --- a/test/cmdlineTests/standard_generatedSources/output.json +++ b/test/cmdlineTests/standard_generatedSources/output.json @@ -84,5 +84,9 @@ } } +<<<<<<< HEAD ","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:283::-;;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:18;;:::i;:::-;2042:2;2150:10;2146:2;2139:22;1924:243;;;;:::o;2173:311::-;;2340:18;2332:6;2329:30;2326:2;;;2362:18;;:::i;:::-;2326:2;2412:4;2404:6;2400:17;2392:25;;2472:4;2466;2462:15;2454:23;;2255:229;;;:::o;2490:77::-;;2556:5;2545:16;;2535:32;;;:::o;2573:180::-;2621:77;2618:1;2611:88;2718:4;2715:1;2708:15;2742:4;2739:1;2732:15;2759:122;2832:24;2850:5;2832:24;:::i;:::-;2825:5;2822:35;2812:2;;2871:1;2868;2861:12;2812:2;2802: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! +>>>>>>> origin/develop ","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 b26c6f8a9..51a35afb5 100644 --- a/test/cmdlineTests/standard_optimizer_generatedSources/output.json +++ b/test/cmdlineTests/standard_optimizer_generatedSources/output.json @@ -35,6 +35,7 @@ tail := add(headStart, 32) mstore(headStart, value0) } +<<<<<<< HEAD function panic_error_0x41() { mstore(0, shl(224, 0x4e487b71)) @@ -42,4 +43,7 @@ revert(0, 0x24) } }","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:1158: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:18;;:::i;:::-;560:2;556;552:11;592:2;586:9;643:2;638;630:6;626:15;622:24;696:6;684:10;681:22;676:2;664:10;661:18;658:46;655:2;;;707:18;;:::i;:::-;743:2;736:22;793:18;;;827:15;;;;-1:-1:-1;862:11:1;;;892;;;888:20;;885:33;-1:-1:-1;882:2:1;;;936:6;928;921:22;882:2;963:6;954:15;;978:163;992:2;989:1;986:9;978:163;;;1049:17;;1037:30;;1010:1;1003:9;;;;;1087:12;;;;1119;;978:163;;;-1:-1:-1;1160:6:1;109:1063;-1:-1:-1;;;;;;;;109:1063:1:o;1177:177::-;1323:25;;;1311:2;1296:18;;1278:76::o;1359:127::-;1420:10;1415:3;1411:20;1408:1;1401:31;1451:4;1448:1;1441:15;1475:4;1472:1;1465:15"}}}}},"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! +>>>>>>> origin/develop ","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 253862f68..cd7dc1710 100644 --- a/test/libsolidity/SolidityEndToEndTest.cpp +++ b/test/libsolidity/SolidityEndToEndTest.cpp @@ -1890,7 +1890,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); @@ -1912,7 +1912,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); @@ -1960,7 +1960,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 { @@ -1985,7 +1985,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 { @@ -2043,7 +2043,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; @@ -2074,7 +2074,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; @@ -2239,7 +2239,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; @@ -2567,7 +2567,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; } } @@ -2710,7 +2710,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; @@ -3097,7 +3097,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) { @@ -3120,7 +3120,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) { @@ -3169,7 +3169,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; @@ -3768,7 +3768,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))); @@ -5040,7 +5040,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")); @@ -5114,7 +5115,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); @@ -5184,7 +5186,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); @@ -5227,7 +5230,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")); @@ -5239,7 +5243,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; @@ -5281,7 +5285,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; @@ -5310,7 +5314,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); @@ -5344,7 +5348,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; @@ -5401,7 +5405,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); @@ -5491,7 +5495,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 e2d1cee72..387278e8f 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 f24d12e9e..0eacba1b4 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 2539a2fd4..4d2e79634 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 b1cfaed8a..d2c02378d 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 d4a343564..95e257bee 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 e5093803c..23c251307 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 fc0204516..df15ad38b 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/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_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/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/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/memoryManagement/assembly_access.sol b/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol new file mode 100644 index 000000000..15e171dfc --- /dev/null +++ b/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol @@ -0,0 +1,16 @@ +contract C { + function f() public pure { + uint[] memory x; + uint y; + 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); + } +} +// ==== +// 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/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 de252d89c..206e59d9d 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_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.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_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.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_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_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_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 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 9ce8b142a..f8ad6b9ec 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 8624ccc96..14c9ef209 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 d8657ef7e..337325967 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 3622bab38..6bd1acbbf 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/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/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 {} +} +// ---- 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. 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/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/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)". 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/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. 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; }