solidity/test/libsolidity/SolidityParser.cpp

696 lines
16 KiB
C++
Raw Normal View History

/*
This file is part of solidity.
solidity is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @author Christian <c@ethdev.com>
* @date 2014
* Unit tests for the solidity parser.
*/
#include <string>
2014-12-03 06:46:55 +00:00
#include <memory>
#include <liblangutil/Scanner.h>
2015-10-20 22:21:52 +00:00
#include <libsolidity/parsing/Parser.h>
#include <liblangutil/ErrorReporter.h>
#include <test/Common.h>
#include <test/libsolidity/ErrorCheck.h>
#include <libsolidity/ast/ASTVisitor.h>
#include <boost/test/unit_test.hpp>
2014-12-03 06:46:55 +00:00
using namespace std;
using namespace solidity::langutil;
2014-12-03 06:46:55 +00:00
namespace solidity::frontend::test
2014-10-16 12:08:54 +00:00
{
2014-10-16 12:08:54 +00:00
namespace
{
ASTPointer<ContractDefinition> parseText(std::string const& _source, ErrorList& _errors, bool errorRecovery = false)
2014-10-16 12:08:54 +00:00
{
ErrorReporter errorReporter(_errors);
ASTPointer<SourceUnit> sourceUnit = Parser(
errorReporter,
solidity::test::CommonOptions::get().evmVersion(),
errorRecovery
).parse(std::make_shared<Scanner>(CharStream(_source, "")));
2015-10-15 14:27:26 +00:00
if (!sourceUnit)
return ASTPointer<ContractDefinition>();
2015-08-31 16:44:29 +00:00
for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
2014-12-03 06:46:55 +00:00
if (ASTPointer<ContractDefinition> contract = dynamic_pointer_cast<ContractDefinition>(node))
return contract;
BOOST_FAIL("No contract found in source.");
return ASTPointer<ContractDefinition>();
2014-10-16 12:08:54 +00:00
}
bool successParse(std::string const& _source)
{
ErrorList errors;
try
{
auto sourceUnit = parseText(_source, errors);
2015-10-15 14:27:26 +00:00
if (!sourceUnit)
return false;
}
2016-03-18 08:22:15 +00:00
catch (FatalError const& /*_exception*/)
{
if (Error::containsErrorOfType(errors, Error::Type::ParserError))
return false;
}
if (Error::containsErrorOfType(errors, Error::Type::ParserError))
return false;
2015-10-15 14:27:26 +00:00
BOOST_CHECK(Error::containsOnlyWarnings(errors));
return true;
}
Error getError(std::string const& _source, bool errorRecovery = false)
{
ErrorList errors;
try
{
parseText(_source, errors, errorRecovery);
}
catch (FatalError const& /*_exception*/)
{
// no-op
}
Error const* error = Error::containsErrorOfType(errors, Error::Type::ParserError);
BOOST_REQUIRE(error);
return *error;
}
void checkFunctionNatspec(
FunctionDefinition const* _function,
std::string const& _expectedDoc
)
{
auto doc = _function->documentation()->text();
BOOST_CHECK_MESSAGE(doc != nullptr, "Function does not have Natspec Doc as expected");
BOOST_CHECK_EQUAL(*doc, _expectedDoc);
}
}
#define CHECK_PARSE_ERROR(source, substring) \
do \
{\
Error err = getError((source)); \
BOOST_CHECK(searchErrorMessage(err, (substring))); \
}\
while(0)
BOOST_AUTO_TEST_SUITE(SolidityParser)
2019-10-30 13:34:37 +00:00
BOOST_AUTO_TEST_CASE(reserved_keywords)
{
BOOST_CHECK(!TokenTraits::isReservedKeyword(Token::Identifier));
BOOST_CHECK(TokenTraits::isReservedKeyword(Token::After));
2019-10-30 13:34:37 +00:00
BOOST_CHECK(TokenTraits::isReservedKeyword(Token::Unchecked));
BOOST_CHECK(!TokenTraits::isReservedKeyword(Token::Illegal));
}
BOOST_AUTO_TEST_CASE(unsatisfied_version)
{
char const* text = R"(
pragma solidity ^99.99.0;
)";
CHECK_PARSE_ERROR(text, "Source file requires different compiler version");
}
2018-12-12 15:45:17 +00:00
BOOST_AUTO_TEST_CASE(unsatisfied_version_followed_by_invalid_syntax)
{
char const* text = R"(
pragma solidity ^99.99.0;
this is surely invalid
)";
CHECK_PARSE_ERROR(text, "Source file requires different compiler version");
}
BOOST_AUTO_TEST_CASE(unsatisfied_version_with_recovery)
{
char const* text = R"(
pragma solidity ^99.99.0;
contract test {
uint ;
}
)";
Error err = getError(text, true);
BOOST_CHECK(searchErrorMessage(err, "Expected identifier but got ';'"));
}
BOOST_AUTO_TEST_CASE(function_natspec_documentation)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
uint256 stateVar;
/// This is a test function
function functionName(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
}
)";
BOOST_CHECK(successParse(text));
ErrorList errors;
ASTPointer<ContractDefinition> contract = parseText(text, errors);
FunctionDefinition const* function = nullptr;
auto functions = contract->definedFunctions();
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
checkFunctionNatspec(function, "This is a test function");
}
BOOST_AUTO_TEST_CASE(function_normal_comments)
{
FunctionDefinition const* function = nullptr;
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
uint256 stateVar;
// We won't see this comment
function functionName(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
}
)";
BOOST_CHECK(successParse(text));
ErrorList errors;
ASTPointer<ContractDefinition> contract = parseText(text, errors);
auto functions = contract->definedFunctions();
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
2015-08-31 16:44:29 +00:00
BOOST_CHECK_MESSAGE(function->documentation() == nullptr,
"Should not have gotten a Natspecc comment for this function");
}
BOOST_AUTO_TEST_CASE(multiple_functions_natspec_documentation)
{
FunctionDefinition const* function = nullptr;
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
uint256 stateVar;
/// This is test function 1
function functionName1(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
/// This is test function 2
function functionName2(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
// nothing to see here
function functionName3(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
/// This is test function 4
function functionName4(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
}
)";
BOOST_CHECK(successParse(text));
ErrorList errors;
ASTPointer<ContractDefinition> contract = parseText(text, errors);
auto functions = contract->definedFunctions();
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
checkFunctionNatspec(function, "This is test function 1");
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(1), "Failed to retrieve function");
checkFunctionNatspec(function, "This is test function 2");
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(2), "Failed to retrieve function");
2015-08-31 16:44:29 +00:00
BOOST_CHECK_MESSAGE(function->documentation() == nullptr,
"Should not have gotten natspec comment for functionName3()");
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(3), "Failed to retrieve function");
checkFunctionNatspec(function, "This is test function 4");
}
BOOST_AUTO_TEST_CASE(multiline_function_documentation)
{
FunctionDefinition const* function = nullptr;
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
uint256 stateVar;
/// This is a test function
/// and it has 2 lines
function functionName1(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
}
)";
BOOST_CHECK(successParse(text));
ErrorList errors;
ASTPointer<ContractDefinition> contract = parseText(text, errors);
auto functions = contract->definedFunctions();
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
checkFunctionNatspec(function, "This is a test function\n"
" and it has 2 lines");
}
BOOST_AUTO_TEST_CASE(natspec_comment_in_function_body)
{
FunctionDefinition const* function = nullptr;
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
/// fun1 description
function fun1(uint256 a) {
var b;
/// I should not interfere with actual natspec comments
uint256 c;
mapping(address=>bytes32) d;
bytes7 name = "Solidity";
}
/// This is a test function
/// and it has 2 lines
function fun(bytes32 input) public returns (bytes32 out) {}
2016-12-01 03:39:30 +00:00
}
)";
BOOST_CHECK(successParse(text));
ErrorList errors;
ASTPointer<ContractDefinition> contract = parseText(text, errors);
auto functions = contract->definedFunctions();
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
checkFunctionNatspec(function, "fun1 description");
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(1), "Failed to retrieve function");
checkFunctionNatspec(function, "This is a test function\n"
" and it has 2 lines");
}
BOOST_AUTO_TEST_CASE(natspec_docstring_between_keyword_and_signature)
{
FunctionDefinition const* function = nullptr;
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
uint256 stateVar;
function ///I am in the wrong place
fun1(uint256 a) {
var b;
/// I should not interfere with actual natspec comments
uint256 c;
mapping(address=>bytes32) d;
bytes7 name = "Solidity";
}
}
)";
BOOST_CHECK(successParse(text));
ErrorList errors;
ASTPointer<ContractDefinition> contract = parseText(text, errors);
auto functions = contract->definedFunctions();
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
2015-08-31 16:44:29 +00:00
BOOST_CHECK_MESSAGE(!function->documentation(),
"Shouldn't get natspec docstring for this function");
}
BOOST_AUTO_TEST_CASE(natspec_docstring_after_signature)
{
FunctionDefinition const* function = nullptr;
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
uint256 stateVar;
function fun1(uint256 a) {
/// I should have been above the function signature
var b;
/// I should not interfere with actual natspec comments
uint256 c;
mapping(address=>bytes32) d;
bytes7 name = "Solidity";
}
}
)";
BOOST_CHECK(successParse(text));
ErrorList errors;
ASTPointer<ContractDefinition> contract = parseText(text, errors);
auto functions = contract->definedFunctions();
2017-09-20 09:52:41 +00:00
BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
2015-08-31 16:44:29 +00:00
BOOST_CHECK_MESSAGE(!function->documentation(),
"Shouldn't get natspec docstring for this function");
}
BOOST_AUTO_TEST_CASE(variable_definition)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
function fun(uint256 a) {
var b;
uint256 c;
mapping(address=>bytes32) d;
customtype varname;
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(variable_definition_with_initialization)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
function fun(uint256 a) {
var b = 2;
uint256 c = 0x87;
mapping(address=>bytes32) d;
bytes7 name = "Solidity";
customtype varname;
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(operator_expression)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
function fun(uint256 a) {
uint256 x = (1 + 4) || false && (1 - 12) + -9;
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(complex_expression)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
function fun(uint256 a) {
uint256 x = (1 + 4).member(++67)[a/=9] || true;
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(statement_starting_with_type_conversion)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
function fun() {
uint64(2);
uint64[7](3);
uint64[](3);
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(type_conversion_to_dynamic_array)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
function fun() {
var x = uint64[](3);
}
}
)";
BOOST_CHECK(successParse(text));
}
2014-12-03 06:46:55 +00:00
BOOST_AUTO_TEST_CASE(import_directive)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
import "abc";
contract test {
function fun() {
uint64(2);
}
}
)";
BOOST_CHECK(successParse(text));
2014-12-03 06:46:55 +00:00
}
BOOST_AUTO_TEST_CASE(multiple_contracts)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract test {
function fun() {
uint64(2);
}
}
contract test2 {
function fun() {
uint64(2);
}
}
)";
BOOST_CHECK(successParse(text));
2014-12-03 06:46:55 +00:00
}
BOOST_AUTO_TEST_CASE(multiple_contracts_and_imports)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
import "abc";
contract test {
function fun() {
uint64(2);
}
}
import "def";
contract test2 {
function fun() {
uint64(2);
}
}
import "ghi";
)";
BOOST_CHECK(successParse(text));
2014-12-03 06:46:55 +00:00
}
2015-01-15 15:15:01 +00:00
BOOST_AUTO_TEST_CASE(contract_inheritance)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract base {
function fun() {
uint64(2);
}
}
contract derived is base {
function fun() {
uint64(2);
}
}
)";
BOOST_CHECK(successParse(text));
2015-01-15 15:15:01 +00:00
}
BOOST_AUTO_TEST_CASE(contract_multiple_inheritance)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract base {
function fun() {
uint64(2);
}
}
contract derived is base, nonExisting {
function fun() {
uint64(2);
}
}
)";
BOOST_CHECK(successParse(text));
2015-01-15 15:15:01 +00:00
}
BOOST_AUTO_TEST_CASE(contract_multiple_inheritance_with_arguments)
{
2016-12-01 03:39:30 +00:00
char const* text = R"(
contract base {
function fun() {
uint64(2);
}
}
contract derived is base(2), nonExisting("abc", "def", base.fun()) {
function fun() {
uint64(2);
}
}
)";
BOOST_CHECK(successParse(text));
}
2015-02-02 16:24:09 +00:00
BOOST_AUTO_TEST_CASE(multiple_visibility_specifiers)
{
char const* text = R"(
contract c {
2015-02-22 18:37:54 +00:00
uint private internal a;
}
)";
CHECK_PARSE_ERROR(text, "Visibility already specified as \"private\".");
text = R"(
contract c {
function f() private external {}
}
)";
CHECK_PARSE_ERROR(text, "Visibility already specified as \"private\".");
2015-02-02 16:24:09 +00:00
}
BOOST_AUTO_TEST_CASE(keyword_is_reserved)
{
auto keywords = {
"after",
2018-03-01 11:18:44 +00:00
"alias",
"apply",
"auto",
"case",
"catch",
2018-03-01 11:18:44 +00:00
"copyof",
"default",
2018-03-01 11:18:44 +00:00
"define",
"final",
2018-03-01 11:18:44 +00:00
"immutable",
"implements",
"in",
"inline",
"let",
2018-03-01 11:18:44 +00:00
"macro",
"match",
2018-03-01 11:18:44 +00:00
"mutable",
"null",
"of",
2018-03-01 11:18:44 +00:00
"partial",
"promise",
"reference",
"relocatable",
2018-03-01 11:18:44 +00:00
"sealed",
"sizeof",
"static",
2018-03-01 11:18:44 +00:00
"supports",
"switch",
"try",
2018-03-01 11:18:44 +00:00
"typedef",
"typeof",
"unchecked"
};
BOOST_CHECK_EQUAL(std::size(keywords), static_cast<int>(Token::Unchecked) - static_cast<int>(Token::After) + 1);
2019-02-13 15:22:42 +00:00
for (auto const& keyword: keywords)
{
auto text = std::string("contract ") + keyword + " {}";
2018-03-01 11:18:44 +00:00
CHECK_PARSE_ERROR(text.c_str(), string("Expected identifier but got reserved keyword '") + keyword + "'");
}
}
BOOST_AUTO_TEST_CASE(member_access_parser_ambiguity)
{
char const* text = R"(
contract C {
struct S { uint a; uint b; uint[][][] c; }
function f() {
C.S x;
C.S memory y;
C.S[10] memory z;
C.S[10](x);
x.a = 2;
x.c[1][2][3] = 9;
}
}
)";
BOOST_CHECK(successParse(text));
}
2015-11-22 19:39:10 +00:00
BOOST_AUTO_TEST_CASE(using_for)
{
char const* text = R"(
contract C {
struct s { uint a; }
using LibraryName for uint;
using Library2 for *;
using Lib for s;
function f() {
}
}
)";
BOOST_CHECK(successParse(text));
}
2015-12-14 17:01:40 +00:00
BOOST_AUTO_TEST_CASE(complex_import)
{
char const* text = R"(
import "abc" as x;
import * as x from "abc";
import {a as b, c as d, f} from "def";
contract x {}
)";
BOOST_CHECK(successParse(text));
}
2017-08-14 16:58:56 +00:00
BOOST_AUTO_TEST_CASE(recursion_depth1)
{
string text("contract C { bytes");
for (size_t i = 0; i < 30000; i++)
text += "[";
CHECK_PARSE_ERROR(text.c_str(), "Maximum recursion depth reached during parsing");
}
BOOST_AUTO_TEST_CASE(recursion_depth2)
{
string text("contract C { function f() {");
for (size_t i = 0; i < 30000; i++)
text += "{";
CHECK_PARSE_ERROR(text, "Maximum recursion depth reached during parsing");
}
BOOST_AUTO_TEST_CASE(recursion_depth3)
{
string text("contract C { function f() { uint x = f(");
for (size_t i = 0; i < 30000; i++)
text += "(";
CHECK_PARSE_ERROR(text, "Maximum recursion depth reached during parsing");
}
2017-08-14 16:59:17 +00:00
BOOST_AUTO_TEST_CASE(recursion_depth4)
{
string text("contract C { function f() { uint a;");
for (size_t i = 0; i < 30000; i++)
text += "(";
text += "a";
for (size_t i = 0; i < 30000; i++)
text += "++)";
text += "}}";
CHECK_PARSE_ERROR(text, "Maximum recursion depth reached during parsing");
}
BOOST_AUTO_TEST_CASE(inline_asm_end_location)
{
auto sourceCode = std::string(R"(
contract C {
function f() public pure returns (uint y) {
uint a;
assembly { a := 0x12345678 }
uint z = a;
y = z;
}
}
)");
ErrorList errors;
auto contract = parseText(sourceCode, errors);
class CheckInlineAsmLocation: public ASTConstVisitor
{
public:
bool visited = false;
virtual bool visit(InlineAssembly const& _inlineAsm)
{
auto loc = _inlineAsm.location();
auto asmStr = loc.source->source().substr(loc.start, loc.end - loc.start);
BOOST_CHECK_EQUAL(asmStr, "assembly { a := 0x12345678 }");
visited = true;
return false;
}
};
CheckInlineAsmLocation visitor;
contract->accept(visitor);
BOOST_CHECK_MESSAGE(visitor.visited, "No inline asm block found?!");
}
BOOST_AUTO_TEST_SUITE_END()
2014-10-16 12:08:54 +00:00
} // end namespaces