Merge remote-tracking branch 'origin/develop' into develop_060

test/libsolidity/ABIJson/library_function.sol

@@ -1,9 +1,14 @@
+contract X {}
 library test {
     struct StructType { uint a; }
-    function f(StructType storage b, uint[] storage c, test d) public returns (uint[] memory e, StructType storage f) { f = f; }
-    function f1(uint[] memory c, test d) public pure returns (uint[] memory e) {  }
+    function f(StructType storage b, uint[] storage c, X d) public returns (uint[] memory e, StructType storage f) { f = f; }
+    function f1(uint[] memory c, X d) public pure returns (uint[] memory e) {  }
 }
 // ----
+//     :X
+// []
+//
+//
 //     :test
 // [
 //   {
@@ -15,9 +20,9 @@ library test {
 //         "type": "uint256[]"
 //       },
 //       {
-//         "internalType": "library test",
+//         "internalType": "contract X",
 //         "name": "d",
-//         "type": "test"
+//         "type": "X"
 //       }
 //     ],
 //     "name": "f1",

test/libsolidity/Assembly.cpp

@@ -64,7 +64,7 @@ eth::AssemblyItems compileContract(std::shared_ptr<CharStream> _sourceCode)
 
 	map<ASTNode const*, shared_ptr<DeclarationContainer>> scopes;
 	GlobalContext globalContext;
-	NameAndTypeResolver resolver(globalContext, scopes, errorReporter);
+	NameAndTypeResolver resolver(globalContext, dev::test::Options::get().evmVersion(), scopes, errorReporter);
 	solAssert(Error::containsOnlyWarnings(errorReporter.errors()), "");
 	resolver.registerDeclarations(*sourceUnit);
 	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())

test/libsolidity/SemanticTest.cpp

@@ -78,15 +78,34 @@ TestCase::TestResult SemanticTest::run(ostream& _stream, string const& _linePref
 		for (auto& test: m_tests)
 			test.reset();
 
+		map<string, dev::test::Address> libraries;
+
+		bool constructed = false;
+
 		for (auto& test: m_tests)
 		{
-			if (&test == &m_tests.front())
-				if (test.call().isConstructor)
-					deploy("", test.call().value, test.call().arguments.rawBytes());
-				else
-					soltestAssert(deploy("", 0, bytes()), "Failed to deploy contract.");
+			if (constructed)
+			{
+				soltestAssert(!test.call().isLibrary, "Libraries have to be deployed before any other call.");
+				soltestAssert(!test.call().isConstructor, "Constructor has to be the first function call expect for library deployments.");
+			}
+			else if (test.call().isLibrary)
+			{
+				soltestAssert(
+					deploy(test.call().signature, 0, {}, libraries) && m_transactionSuccessful,
+					"Failed to deploy library " + test.call().signature
+				);
+				libraries[test.call().signature] = m_contractAddress;
+				continue;
+			}
 			else
-				soltestAssert(!test.call().isConstructor, "Constructor has to be the first function call.");
+			{
+				if (test.call().isConstructor)
+					deploy("", test.call().value, test.call().arguments.rawBytes(), libraries);
+				else
+					soltestAssert(deploy("", 0, bytes(), libraries), "Failed to deploy contract.");
+				constructed = true;
+			}
 
 			if (test.call().isConstructor)
 			{
@@ -171,8 +190,8 @@ void SemanticTest::parseExpectations(istream& _stream)
 	std::move(functionCalls.begin(), functionCalls.end(), back_inserter(m_tests));
 }
 
-bool SemanticTest::deploy(string const& _contractName, u256 const& _value, bytes const& _arguments)
+bool SemanticTest::deploy(string const& _contractName, u256 const& _value, bytes const& _arguments, map<string, dev::test::Address> const& _libraries)
 {
-	auto output = compileAndRunWithoutCheck(m_source, _value, _contractName, _arguments);
+	auto output = compileAndRunWithoutCheck(m_source, _value, _contractName, _arguments, _libraries);
 	return !output.empty() && m_transactionSuccessful;
 }

test/libsolidity/SemanticTest.h

@@ -60,7 +60,7 @@ public:
 
 	/// Compiles and deploys currently held source.
 	/// Returns true if deployment was successful, false otherwise.
-	bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments);
+	bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments, std::map<std::string, dev::test::Address> const& _libraries = {});
 
 private:
 	std::string m_source;

test/libsolidity/SolidityExpressionCompiler.cpp

@@ -118,7 +118,7 @@ bytes compileFirstExpression(
 	ErrorReporter errorReporter(errors);
 	GlobalContext globalContext;
 	map<ASTNode const*, shared_ptr<DeclarationContainer>> scopes;
-	NameAndTypeResolver resolver(globalContext, scopes, errorReporter);
+	NameAndTypeResolver resolver(globalContext, dev::test::Options::get().evmVersion(), scopes, errorReporter);
 	resolver.registerDeclarations(*sourceUnit);
 
 	vector<ContractDefinition const*> inheritanceHierarchy;

test/libsolidity/semanticTests/libraries/library_address.sol

@@ -0,0 +1,56 @@
+library L {
+    function f(uint256 v) external pure returns (uint) {
+        return v * v;
+    }
+    function g(uint256 v) external returns (uint) {
+        return v * v;
+    }
+}
+contract C {
+    function addr() public view returns (bool) {
+        return address(L) == address(0);
+    }
+    function g(uint256 v) public view returns (uint256) {
+        return L.f(v);
+    }
+    function h(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(L).delegatecall(abi.encodeWithSignature("f(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+    function i(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(L).call(abi.encodeWithSignature("f(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+    function j(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(L).delegatecall(abi.encodeWithSignature("g(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+    function k(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(L).call(abi.encodeWithSignature("g(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// library: L
+// addr() -> false
+// g(uint256): 1 -> 1
+// g(uint256): 2 -> 4
+// g(uint256): 4 -> 16
+// h(uint256): 1 -> 1
+// h(uint256): 2 -> 4
+// h(uint256): 4 -> 16
+// i(uint256): 1 -> 1
+// i(uint256): 2 -> 4
+// i(uint256): 4 -> 16
+// j(uint256): 1 -> 1
+// j(uint256): 2 -> 4
+// j(uint256): 4 -> 16
+// k(uint256): 1 -> FAILURE
+// k(uint256): 2 -> FAILURE
+// k(uint256): 4 -> FAILURE

test/libsolidity/semanticTests/libraries/library_address_homestead.sol

@@ -0,0 +1,24 @@
+library L {
+    function f(uint256 a, uint256 b) external {
+        assert(a * a == b);
+    }
+}
+contract C {
+    function addr() public view returns (bool) {
+        return address(L) == address(0);
+    }
+    function g(uint256 a, uint256 b) public returns (bool) {
+        (bool success,) = address(L).delegatecall(abi.encodeWithSignature("f(uint256,uint256)", a, b));
+        return success;
+    }
+}
+// ----
+// library: L
+// g(uint256,uint256): 1, 1 -> true
+// g(uint256,uint256): 1, 2 -> false
+// g(uint256,uint256): 2, 3 -> false
+// g(uint256,uint256): 2, 4 -> true
+// g(uint256,uint256): 2, 5 -> false
+// g(uint256,uint256): 4, 15 -> false
+// g(uint256,uint256): 4, 16 -> true
+// g(uint256,uint256): 4, 17 -> false

test/libsolidity/semanticTests/libraries/stub.sol

@@ -0,0 +1,13 @@
+library L {
+    function f(uint256 v) external returns (uint256) { return v*v; }
+}
+contract C {
+    function g(uint256 v) external returns (uint256) {
+        return L.f(v);
+    }
+}
+// ----
+// library: L
+// g(uint256): 1 -> 1
+// g(uint256): 2 -> 4
+// g(uint256): 4 -> 16

test/libsolidity/semanticTests/libraries/stub_internal.sol

@@ -0,0 +1,12 @@
+library L {
+    function f(uint256 v) internal returns (uint256) { return v*v; }
+}
+contract C {
+    function g(uint256 v) external returns (uint256) {
+        return L.f(v);
+    }
+}
+// ----
+// g(uint256): 1 -> 1
+// g(uint256): 2 -> 4
+// g(uint256): 4 -> 16

test/libsolidity/semanticTests/viaYul/require.sol

@@ -12,17 +12,33 @@ contract C {
 		x = true;
 		require(true);
 	}
-	/* Not properly supported by test system yet
 	function f2(bool a) public pure returns (bool x) {
 		x = a;
 		string memory message;
+		message = "fancy message!";
 		require(a, message);
-	}*/
+	}
+	function f3(bool a) public pure returns (bool x) {
+		x = a;
+		require(a, "msg");
+	}
+	function f4(bool a) public pure returns (bool x) {
+		x = a;
+		string memory message;
+		require(a, message);
+	}
 }
 // ====
-// compileViaYul: true
+// compileViaYul: also
+// EVMVersion: >=byzantium
 // ----
 // f(bool): true -> true
 // f(bool): false -> FAILURE
 // fail() -> FAILURE
 // succeed() -> true
+// f2(bool): true -> true
+// f2(bool): false -> FAILURE, hex"08c379a0", 0x20, 14, "fancy message!"
+// f3(bool): true -> true
+// f3(bool): false -> FAILURE, hex"08c379a0", 0x20, 3, "msg"
+// f4(bool): true -> true
+// f4(bool): false -> FAILURE, hex"08c379a0", 0x20, 0

test/libsolidity/smtCheckerTests/typecast/function_type_to_address.sol

@@ -0,0 +1,10 @@
+pragma experimental SMTChecker;
+contract C {
+    function f(address a, function(uint) external g) internal pure {
+		address b = address(g);
+		assert(a == b);
+    }
+}
+// ----
+// Warning: (128-138): Type conversion is not yet fully supported and might yield false positives.
+// Warning: (142-156): Assertion violation happens here

test/libsolidity/smtCheckerTests/typecast/function_type_to_function_type_external.sol

@@ -0,0 +1,8 @@
+pragma experimental SMTChecker;
+contract C {
+    function f(function(uint) external returns (uint) g, function(uint) external returns (uint) h) public {
+		assert(g(2) == h(2));
+    }
+}
+// ----
+// Warning: (155-175): Assertion violation happens here

test/libsolidity/smtCheckerTests/typecast/function_type_to_function_type_internal.sol

@@ -0,0 +1,13 @@
+pragma experimental SMTChecker;
+contract C {
+    function f(function(uint) returns (uint) g, function(uint) returns (uint) h) internal {
+		assert(g(2) == h(2));
+		assert(g == h);
+    }
+}
+// ----
+// Warning: (146-150): Assertion checker does not yet implement this type of function call.
+// Warning: (154-158): Assertion checker does not yet implement this type of function call.
+// Warning: (170-176): Assertion checker does not yet implement the type function (uint256) returns (uint256) for comparisons
+// Warning: (139-159): Assertion violation happens here
+// Warning: (163-177): Assertion violation happens here

test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_function_call.sol

@@ -0,0 +1,14 @@
+pragma experimental SMTChecker;
+contract B {
+    function f() pure public {
+		g("0123456");
+	}
+    function g(bytes7 a) pure public {
+		assert(a == "0123456");
+		assert(a == "1234567");
+	}
+}
+// ----
+// Warning: (162-184): Assertion violation happens here
+// Warning: (136-158): Assertion violation happens here
+// Warning: (162-184): Assertion violation happens here

test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_modifier.sol

@@ -0,0 +1,11 @@
+pragma experimental SMTChecker;
+contract B {
+    function f() mod2("0123456") pure public { }
+    modifier mod2(bytes7 a) {
+		assert(a == "0123456");
+		assert(a == "1234567");
+		_;
+	}
+}
+// ----
+// Warning: (152-174): Assertion violation happens here

test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return.sol

@@ -0,0 +1,12 @@
+pragma experimental SMTChecker;
+contract C {
+    function g() public pure returns (bytes32 val) { return "abc"; }
+    function f1() public pure returns (bytes32 val) { return g(); }
+
+	function a() public pure {
+		assert(f1() == "abc");
+		assert(f1() == "cde");
+	}
+}
+// ----
+// Warning: (238-259): Assertion violation happens here

test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return_multi.sol

@@ -0,0 +1,15 @@
+pragma experimental SMTChecker;
+contract C {
+    function h() public pure returns (bytes32 val, bytes3 val2) { return ("abc", "def"); }
+    function g() public pure returns (bytes32 val) { return "abc"; }
+    function f1() public pure returns (bytes32 val) { return g(); }
+    function f2() public pure returns (bytes32 val, bytes3 val2) { return h(); }
+
+	function a() public pure {
+		(bytes32 v1, bytes3 v2) = f2();
+		assert(v1 == "abc");
+		assert(v2 == "cde");
+	}
+}
+// ----
+// Warning: (442-461): Assertion violation happens here

test/libsolidity/smtCheckerTests/types/function_type_as_argument.sol

@@ -0,0 +1,5 @@
+pragma experimental SMTChecker;
+contract C {
+    function f(function(uint) external g) public {
+    }
+}

test/libsolidity/smtCheckerTests/types/function_type_call.sol

@@ -0,0 +1,13 @@
+pragma experimental SMTChecker;
+contract C {
+	function(uint) m_g;
+    function f(function(uint) internal g) internal {
+		g(2);
+    }
+	function h() public {
+		f(m_g);
+	}
+}
+// ----
+// Warning: (121-125): Assertion checker does not yet implement this type of function call.
+// Warning: (121-125): Assertion checker does not yet implement this type of function call.

test/libsolidity/smtCheckerTests/types/function_type_members.sol

@@ -0,0 +1,11 @@
+pragma experimental SMTChecker;
+contract C {
+    function f(function(uint) external payable g) internal {
+		g.selector;
+		g.gas(2).value(3)(4);
+    }
+}
+// ----
+// Warning: (108-118): Assertion checker does not yet support this expression.
+// Warning: (122-130): Assertion checker does not yet implement this type of function call.
+// Warning: (122-139): Assertion checker does not yet implement this type of function call.

test/libsolidity/smtCheckerTests/types/function_type_nested.sol

@@ -0,0 +1,22 @@
+pragma experimental SMTChecker;
+contract C {
+	function(uint) m_g;
+    function f1(function(uint) internal g1) internal {
+		g1(2);
+    }
+    function f2(function(function(uint) internal) internal g2) internal {
+		g2(m_g);
+    }
+	function h() public {
+		f2(f1);
+	}
+}
+// ----
+// Warning: (123-128): Assertion checker does not yet implement this type of function call.
+// Warning: (152-197): Assertion checker does not yet support the type of this variable.
+// Warning: (212-214): Assertion checker does not yet implement type function (function (uint256))
+// Warning: (212-219): Assertion checker does not yet implement this type of function call.
+// Warning: (255-257): Internal error: Expression undefined for SMT solver.
+// Warning: (255-257): Assertion checker does not yet implement type function (function (uint256))
+// Warning: (212-214): Assertion checker does not yet implement type function (function (uint256))
+// Warning: (212-219): Assertion checker does not yet implement this type of function call.

test/libsolidity/smtCheckerTests/types/function_type_nested_return.sol

@@ -0,0 +1,27 @@
+pragma experimental SMTChecker;
+contract C {
+	function(uint) m_g;
+	function r() internal view returns (function(uint)) {
+		return m_g;
+	}
+    function f1(function(uint) internal g1) internal {
+		g1(2);
+    }
+    function f2(function(function(uint) internal) internal g2) internal {
+		g2(r());
+    }
+	function h() public {
+		f2(f1);
+	}
+}
+// ----
+// Warning: (195-200): Assertion checker does not yet implement this type of function call.
+// Warning: (224-269): Assertion checker does not yet support the type of this variable.
+// Warning: (284-286): Assertion checker does not yet implement type function (function (uint256))
+// Warning: (287-288): Assertion checker does not yet support this global variable.
+// Warning: (284-291): Assertion checker does not yet implement this type of function call.
+// Warning: (327-329): Internal error: Expression undefined for SMT solver.
+// Warning: (327-329): Assertion checker does not yet implement type function (function (uint256))
+// Warning: (284-286): Assertion checker does not yet implement type function (function (uint256))
+// Warning: (287-288): Assertion checker does not yet support this global variable.
+// Warning: (284-291): Assertion checker does not yet implement this type of function call.

test/libsolidity/syntaxTests/inlineAssembly/istanbul.sol

@@ -1,12 +1,12 @@
 contract C {
-    function f() pure external {
+    function f() pure external returns (uint id) {
         assembly {
-            pop(chainid())
+            id := chainid()
         }
     }
-    function g() view external {
+    function g() view external returns (uint sb) {
         assembly {
-            pop(selfbalance())
+            sb := selfbalance()
         }
     }
 }

test/libsolidity/syntaxTests/inlineAssembly/istanbul_on_petersburg.sol

@@ -0,0 +1,17 @@
+contract C {
+    function f() pure external returns (uint id) {
+        assembly {
+            id := chainid()
+        }
+    }
+    function g() view external returns (uint sb) {
+        assembly {
+            sb := selfbalance()
+        }
+    }
+}
+// ====
+// EVMVersion: =petersburg
+// ----
+// TypeError: (101-110): The "chainid" instruction is only available for Istanbul-compatible VMs  (you are currently compiling for "petersburg").
+// TypeError: (215-228): The "selfbalance" instruction is only available for Istanbul-compatible VMs  (you are currently compiling for "petersburg").

test/libsolidity/syntaxTests/nameAndTypeResolution/301_library_instances_cannot_be_used.sol

@@ -6,4 +6,5 @@ contract test {
     }
 }
 // ----
+// TypeError: (87-90): The type of a variable cannot be a library.
 // TypeError: (100-103): Member "l" not found or not visible after argument-dependent lookup in library L.

test/libsolidity/syntaxTests/nameAndTypeResolution/typeChecking/library_instances.sol

@@ -0,0 +1,14 @@
+library X { }
+
+contract Y {
+	X abc;
+	function foo(X param) private view
+	{
+		X ofg;
+		ofg = abc;
+	}
+}
+// ----
+// TypeError: (29-34): The type of a variable cannot be a library.
+// TypeError: (50-57): The type of a variable cannot be a library.
+// TypeError: (77-82): The type of a variable cannot be a library.

test/libsolidity/syntaxTests/types/library_to_address.sol

@@ -0,0 +1,8 @@
+library L {
+}
+contract C {
+    function f() public pure returns (address) {
+        return address(L);
+    }
+}
+// ----

test/libsolidity/syntaxTests/types/library_to_address_payable.sol

@@ -0,0 +1,9 @@
+library L {
+}
+contract C {
+    function f() public pure returns (address payable) {
+        return address(L);
+    }
+}
+// ----
+// TypeError: (99-109): Return argument type address is not implicitly convertible to expected type (type of first return variable) address payable.

test/libsolidity/util/SoltestTypes.h

@@ -58,6 +58,7 @@ namespace test
 	K(Boolean, "boolean", 0)       \
 	/* special keywords */         \
 	K(Left, "left", 0)             \
+	K(Library, "library", 0)       \
 	K(Right, "right", 0)           \
 	K(Failure, "FAILURE", 0)       \
 
@@ -268,6 +269,8 @@ struct FunctionCall
 	/// Marks this function call as "short-handed", meaning
 	/// no `->` declared.
 	bool omitsArrow = true;
+	/// Marks a library deployment call.
+	bool isLibrary = false;
 };
 
 }

test/libsolidity/util/TestFileParser.cpp

@@ -75,44 +75,56 @@ vector<dev::solidity::test::FunctionCall> TestFileParser::parseFunctionCalls(siz
 
 				try
 				{
-					tie(call.signature, call.useCallWithoutSignature) = parseFunctionSignature();
-					if (accept(Token::Comma, true))
-						call.value = parseFunctionCallValue();
-					if (accept(Token::Colon, true))
-						call.arguments = parseFunctionCallArguments();
-
-					if (accept(Token::Newline, true))
+					if (accept(Token::Library, true))
 					{
-						call.displayMode = FunctionCall::DisplayMode::MultiLine;
-						m_lineNumber++;
-					}
-
-					call.arguments.comment = parseComment();
-
-					if (accept(Token::Newline, true))
-					{
-						call.displayMode = FunctionCall::DisplayMode::MultiLine;
-						m_lineNumber++;
-					}
-
-					if (accept(Token::Arrow, true))
-					{
-						call.omitsArrow = false;
-						call.expectations = parseFunctionCallExpectations();
-						if (accept(Token::Newline, true))
-							m_lineNumber++;
+						expect(Token::Colon);
+						call.signature = m_scanner.currentLiteral();
+						expect(Token::Identifier);
+						call.isLibrary = true;
+						call.expectations.failure = false;
 					}
 					else
 					{
-						call.expectations.failure = false;
-						call.displayMode = FunctionCall::DisplayMode::SingleLine;
+						tie(call.signature, call.useCallWithoutSignature) = parseFunctionSignature();
+						if (accept(Token::Comma, true))
+							call.value = parseFunctionCallValue();
+						if (accept(Token::Colon, true))
+							call.arguments = parseFunctionCallArguments();
+
+						if (accept(Token::Newline, true))
+						{
+							call.displayMode = FunctionCall::DisplayMode::MultiLine;
+							m_lineNumber++;
+						}
+
+						call.arguments.comment = parseComment();
+
+						if (accept(Token::Newline, true))
+						{
+							call.displayMode = FunctionCall::DisplayMode::MultiLine;
+							m_lineNumber++;
+						}
+
+						if (accept(Token::Arrow, true))
+						{
+							call.omitsArrow = false;
+							call.expectations = parseFunctionCallExpectations();
+							if (accept(Token::Newline, true))
+								m_lineNumber++;
+						}
+						else
+						{
+							call.expectations.failure = false;
+							call.displayMode = FunctionCall::DisplayMode::SingleLine;
+						}
+
+						call.expectations.comment = parseComment();
+
+						if (call.signature == "constructor()")
+							call.isConstructor = true;
+
 					}
 
-					call.expectations.comment = parseComment();
-
-					if (call.signature == "constructor()")
-						call.isConstructor = true;
-
 					calls.emplace_back(std::move(call));
 				}
 				catch (Error const& _e)
@@ -456,6 +468,7 @@ void TestFileParser::Scanner::scanNextToken()
 		if (_literal == "false") return TokenDesc{Token::Boolean, _literal};
 		if (_literal == "ether") return TokenDesc{Token::Ether, _literal};
 		if (_literal == "left") return TokenDesc{Token::Left, _literal};
+		if (_literal == "library") return TokenDesc{Token::Library, _literal};
 		if (_literal == "right") return TokenDesc{Token::Right, _literal};
 		if (_literal == "hex") return TokenDesc{Token::Hex, _literal};
 		if (_literal == "FAILURE") return TokenDesc{Token::Failure, _literal};

test/libsolidity/util/TestFileParserTests.cpp

@@ -57,7 +57,9 @@ void testFunctionCall(
 		u256 _value = 0,
 		string _argumentComment = "",
 		string _expectationComment = "",
-		vector<string> _rawArguments = vector<string>{}
+		vector<string> _rawArguments = vector<string>{},
+		bool _isConstructor = false,
+		bool _isLibrary = false
 )
 {
 	BOOST_REQUIRE_EQUAL(_call.expectations.failure, _failure);
@@ -79,6 +81,9 @@ void testFunctionCall(
 			++index;
 		}
 	}
+
+	BOOST_REQUIRE_EQUAL(_call.isConstructor, _isConstructor);
+	BOOST_REQUIRE_EQUAL(_call.isLibrary, _isLibrary);
 }
 
 BOOST_AUTO_TEST_SUITE(TestFileParserTest)
@@ -883,6 +888,51 @@ BOOST_AUTO_TEST_CASE(call_unexpected_character)
 	BOOST_REQUIRE_THROW(parse(source), langutil::Error);
 }
 
+BOOST_AUTO_TEST_CASE(constructor)
+{
+	char const* source = R"(
+		// constructor()
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"constructor()",
+		false,
+		{},
+		{},
+		0,
+		"",
+		"",
+		{},
+		true
+	);
+}
+
+BOOST_AUTO_TEST_CASE(library)
+{
+	char const* source = R"(
+		// library: L
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"L",
+		false,
+		{},
+		{},
+		0,
+		"",
+		"",
+		{},
+		false,
+		true
+	);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/libsolidity/util/TestFunctionCall.cpp

@@ -55,6 +55,12 @@ string TestFunctionCall::format(
 		string newline = formatToken(Token::Newline);
 		string failure = formatToken(Token::Failure);
 
+		if (m_call.isLibrary)
+		{
+			stream << _linePrefix << newline << ws << "library:" << ws << m_call.signature;
+			return;
+		}
+
 		/// Formats the function signature. This is the same independent from the display-mode.
 		stream << _linePrefix << newline << ws << m_call.signature;
 		if (m_call.value > u256(0))