Adds support for tuples in test file parser.

Author: erak

test/libsolidity/util/TestFileParser.cpp

@@ -140,20 +140,33 @@ string TestFileParser::parseFunctionSignature()
 	signature += formatToken(SoltToken::LParen);
 	expect(SoltToken::LParen);
 
-	while (!accept(SoltToken::RParen))
+	string parameters = parseIdentifierOrTuple();
+
+	while (accept(SoltToken::Comma))
 	{
-		signature += m_scanner.currentLiteral();
-		expect(SoltToken::Identifier);
-		while (accept(SoltToken::Comma))
-		{
-			signature += m_scanner.currentLiteral();
-			expect(SoltToken::Comma);
-			signature += m_scanner.currentLiteral();
-			expect(SoltToken::Identifier);
-		}
+		parameters += formatToken(SoltToken::Comma);
+		expect(SoltToken::Comma);
+		if (accept(SoltToken::RParen, true))
+			throw Error(Error::Type::ParserError, "Invalid signature detected: " + signature);
+		parameters += parseIdentifierOrTuple();
+	}
+	if (accept(SoltToken::Arrow, true))
+		throw Error(Error::Type::ParserError, "Invalid signature detected: " + signature);
+
+	signature += parameters;
+	/// The last `)` could have been consumed already by
+	/// `parseIdentifierOrTuple` and the occurrence of another `)`
+	/// needs to be handled specifically.
+	if (accept(SoltToken::RParen, true))
+	{
+		/// In case the function signature does not declare any parameters,
+		/// its string representation still contains a sinlge `)`, because
+		/// that's the end of recursion in `parseIdentifierOrTuple`.
+		/// If already appended to the parameters, do not append again.
+		const bool isListEmpty = parameters == formatToken(SoltToken::RParen);
+		if (!isListEmpty)
+			signature += formatToken(SoltToken::RParen);
 	}
-	signature += formatToken(SoltToken::RParen);
-	expect(SoltToken::RParen);
 	return signature;
 }
 
@@ -245,6 +258,45 @@ pair<bytes, ABIType> TestFileParser::parseABITypeLiteral()
 	}
 }
 
+string TestFileParser::parseIdentifierOrTuple()
+{
+	string identOrTuple;
+	if (accept(SoltToken::Identifier))
+	{
+		identOrTuple = m_scanner.currentLiteral();
+		expect(SoltToken::Identifier);
+		return identOrTuple;
+	}
+	/// This is the end of recursion.
+	if (accept(SoltToken::RParen, false))
+		return formatToken(SoltToken::RParen);
+
+	bool isTuple = false;
+	if (accept(SoltToken::LParen, true))
+	{
+		identOrTuple += formatToken(SoltToken::LParen);
+		isTuple = true;
+	}
+
+	identOrTuple += parseIdentifierOrTuple();
+	if (identOrTuple == "()")
+		throw Error(Error::Type::ParserError, "Empty tuples are not supported.");
+
+	while (accept(SoltToken::Comma))
+	{
+		identOrTuple += formatToken(SoltToken::Comma);
+		expect(SoltToken::Comma);
+		identOrTuple += parseIdentifierOrTuple();
+	}
+
+	if (isTuple)
+	{
+		identOrTuple += formatToken(SoltToken::RParen);
+		expect(SoltToken::RParen);
+	}
+	return identOrTuple;
+}
+
 string TestFileParser::parseComment()
 {
 	string comment = m_scanner.currentLiteral();

test/libsolidity/util/TestFileParser.h

@@ -133,7 +133,7 @@ using ParameterList = std::vector<Parameter>;
  */
 struct FunctionCallExpectations
 {
-	/// Representation of the comma-separated (or empty) list of expectated result values
+	/// Representation of the comma-separated (or empty) list of expected result values
 	/// attached to the function call object. It is checked against the actual result of
 	/// a function call when used in test framework.
 	ParameterList result;
@@ -319,7 +319,12 @@ class TestFileParser
 	/// if data type is not supported.
 	std::pair<bytes, ABIType> parseABITypeLiteral();
 
-	/// Parses a comment
+	/// Recursively parses an identifier or a tuple definition that contains identifiers
+	/// and / or parentheses like `((uint, uint), (uint, (uint, uint)), uint)`.
+	std::string parseIdentifierOrTuple();
+
+	/// Parses a comment that is defined like this:
+	/// # A nice comment. #
 	std::string parseComment();
 
 	/// Parses the current number literal.

test/libsolidity/util/TestFileParserTests.cpp

@@ -265,6 +265,61 @@ BOOST_AUTO_TEST_CASE(call_arguments)
 	);
 }
 
+BOOST_AUTO_TEST_CASE(call_arguments_tuple)
+{
+	char const* source = R"(
+		// f((uint256, bytes32), uint256) ->
+		// f((uint8), uint8) ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f((uint256,bytes32),uint256)", false);
+	testFunctionCall(calls.at(1), Mode::SingleLine, "f((uint8),uint8)", false);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_of_tuples)
+{
+	char const* source = R"(
+		// f(((uint256, bytes32), bytes32), uint256)
+		// # f(S memory s, uint256 b) #
+		// ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"f(((uint256,bytes32),bytes32),uint256)",
+		false,
+		fmt::encodeArgs(),
+		fmt::encodeArgs(),
+		0,
+		" f(S memory s, uint256 b) "
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_recursive_tuples)
+{
+	char const* source = R"(
+		// f(((((bytes, bytes, bytes), bytes), bytes), bytes), bytes) ->
+		// f(((((bytes, bytes, (bytes)), bytes), bytes), (bytes, bytes)), (bytes, bytes)) ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(((((bytes,bytes,bytes),bytes),bytes),bytes),bytes)",
+		false
+	);
+	testFunctionCall(
+		calls.at(1),
+		Mode::SingleLine,
+		"f(((((bytes,bytes,(bytes)),bytes),bytes),(bytes,bytes)),(bytes,bytes))",
+		false
+	);
+}
+
 BOOST_AUTO_TEST_CASE(call_arguments_mismatch)
 {
 	char const* source = R"(
@@ -333,7 +388,7 @@ BOOST_AUTO_TEST_CASE(call_signature)
 	char const* source = R"(
 		// f(uint256, uint8, string) -> FAILURE
 		// f(invalid, xyz, foo) -> FAILURE
-		)";
+	)";
 	auto const calls = parse(source);
 	BOOST_REQUIRE_EQUAL(calls.size(), 2);
 	testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256,uint8,string)", true);
@@ -344,7 +399,31 @@ BOOST_AUTO_TEST_CASE(call_signature_invalid)
 {
 	char const* source = R"(
 		// f(uint8,) -> FAILURE
-		)";
+	)";
+	BOOST_REQUIRE_THROW(parse(source), langutil::Error);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_invalid)
+{
+	char const* source = R"(
+		// f((uint8,) -> FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), langutil::Error);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_invalid_empty)
+{
+	char const* source = R"(
+		// f(uint8, ()) -> FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), langutil::Error);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_invalid_parantheses)
+{
+	char const* source = R"(
+		// f((uint8,() -> FAILURE
+	)";
 	BOOST_REQUIRE_THROW(parse(source), langutil::Error);
 }