Additional test coverage for named parameters

Author: nikola-matic

test/libsolidity/semanticTests/events/event_emit_with_named_parameters.sol

@@ -0,0 +1,18 @@
+contract C {
+    event E(uint256 a, uint256 b, string c);
+
+    function trigger() public {
+        emit E(2, 7, "event");
+        emit E({b: 7, a: 2, c: "event"});
+        emit E({a: 2, c: "event", b: 7});
+        emit E({c: "event", a: 2, b: 7});
+        emit E({a: 2, b: 7, c: "event"});
+    }
+}
+// ----
+// trigger() ->
+// ~ emit E(uint256,uint256,string): 0x02, 0x07, 0x60, 0x05, "event"
+// ~ emit E(uint256,uint256,string): 0x02, 0x07, 0x60, 0x05, "event"
+// ~ emit E(uint256,uint256,string): 0x02, 0x07, 0x60, 0x05, "event"
+// ~ emit E(uint256,uint256,string): 0x02, 0x07, 0x60, 0x05, "event"
+// ~ emit E(uint256,uint256,string): 0x02, 0x07, 0x60, 0x05, "event"

test/libsolidity/semanticTests/functionCall/named_args.sol

@@ -1,8 +1,19 @@
-contract test {
-    function a(uint a, uint b, uint c) public returns (uint r) { r = a * 100 + b * 10 + c * 1; }
-    function b() public returns (uint r) { r = a({a: 1, b: 2, c: 3}); }
-    function c() public returns (uint r) { r = a({b: 2, c: 3, a: 1}); }
+contract C {
+    function internalFunction(uint a, uint b, uint c) internal returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+    function publicFunction(uint a, uint b, uint c) public returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+    function externalFunction(uint a, uint b, uint c) public returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+
+    function internalOrdered() public returns (uint r) { r = internalFunction({a: 1, b: 2, c: 3}); }
+    function internalUnordered() public returns (uint r) { r = internalFunction({b: 2, c: 3, a: 1}); }
+    function publicOrdered() public returns (uint r) { r = publicFunction({a: 1, b: 2, c: 3}); }
+    function publicUnordered() public returns (uint r) { r = publicFunction({b: 2, c: 3, a: 1}); }
+    function externalOrdered() public returns (uint r) { r = externalFunction({a: 1, b: 2, c: 3}); }
+    function externalUnordered() public returns (uint r) { r = publicFunction({b: 2, c: 3, a: 1}); }
 }
 // ----
-// b() -> 123
-// c() -> 123
+// internalOrdered() -> 123
+// internalUnordered() -> 123
+// publicOrdered() -> 123
+// publicUnordered() -> 123
+// externalOrdered() -> 123
+// externalUnordered() -> 123

test/libsolidity/semanticTests/inheritance/inherited_function_named_parameters.sol

@@ -0,0 +1,20 @@
+contract A {
+    function f(uint256 a, uint256 b, uint256 c) internal virtual returns (uint256) {
+        return 1 * a + 2 * b + 3 * c;
+    }
+}
+
+contract B is A {
+    function f(uint256 b, uint256 a, uint256 c) internal override returns (uint256) {
+        return 0;
+    }
+    function baseOrdered() public returns (uint256) {
+        return A.f({a: 1, b: 2, c: 3});
+    }
+    function baseUnordered() public returns (uint256) {
+        return A.f({c: 3, a: 1, b: 2});
+    }
+}
+// ----
+// baseOrdered() -> 14
+// baseUnordered() -> 14

test/libsolidity/semanticTests/libraries/library_function_named_parameters.sol

@@ -0,0 +1,29 @@
+library L {
+    function fi(uint256 a, uint256 b, uint256 c) internal returns (uint256) {
+        return 1 * a + 2 * b + 3 * c;
+    }
+    function fe(uint256 a, uint256 b, uint256 c) external returns (uint256) {
+        return 1 * a + 2 * b + 3 * c;
+    }
+}
+
+contract C {
+    function internalOrdered() public returns (uint256) {
+        return L.fi({a: 1, b: 2, c:3});
+    }
+    function internalUnordered() public returns (uint256) {
+        return L.fi({c: 3, a: 1, b: 2});
+    }
+    function externalOrdered() external returns (uint256) {
+        return L.fe({a: 1, b: 2, c:3});
+    }
+    function externalUnordered() public returns (uint256) {
+        return L.fe({c: 3, a: 1, b: 2});
+    }
+}
+// ----
+// library: L
+// internalOrdered() -> 14
+// internalUnordered() -> 14
+// externalOrdered() -> 14
+// externalUnordered() -> 14

test/libsolidity/semanticTests/libraries/using_for_named_parameters.sol

@@ -0,0 +1,21 @@
+library L {
+    function multiply(uint256 self, uint256 x, uint256 y) internal pure returns (uint256, uint256) {
+        return (self * x, self * y);
+    }
+}
+
+contract C {
+    using L for uint256;
+
+    function ordered() external pure returns (uint256, uint256) {
+        uint256 value = 1;
+        return value.multiply({x: 2, y: 7});
+    }
+    function unordered() external pure returns (uint256, uint256) {
+        uint256 value = 1;
+        return value.multiply({y: 7, x: 2});
+    }
+}
+// ----
+// ordered() -> 2, 7
+// unordered() -> 2, 7

test/libsolidity/syntaxTests/abiEncoder/abi_encode_named_parameters.sol

@@ -0,0 +1,8 @@
+contract C {
+    function f() public pure returns (bytes memory) {
+        return abi.encode({x: uint256(1), y: address(0)});
+    }
+}
+
+// ----
+// TypeError 2627: (82-124): Named arguments cannot be used for functions that take arbitrary parameters.

test/libsolidity/syntaxTests/array/array_getter_named_parameter.sol

@@ -0,0 +1,9 @@
+contract C {
+    uint[] public myArray;
+
+    function get(uint256 _index) public view returns (uint256) {
+        return this.myArray({index: _index});
+    }
+}
+// ----
+// TypeError 4974: (121-150): Named argument "index" does not match function declaration.

test/libsolidity/syntaxTests/constructor/inherited_constructor_named_parameters.sol

@@ -0,0 +1,12 @@
+contract B {
+    uint256 public x;
+    uint256 public y;
+    constructor(uint _x, uint _y) { x = _x; y = _y; }
+}
+
+contract C is B {
+    constructor() B({y: 2, x: 1}) {}
+}
+
+// ----
+// ParserError 6933: (152-153): Expected primary expression.

test/libsolidity/syntaxTests/functionCalls/bare_call_named_parameters.sol

@@ -0,0 +1,9 @@
+contract C {
+    function f(address target) public returns (bool success, bytes memory data) {
+        (success, data) = target.call({data: ""});
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// TypeError 4974: (121-144): Named argument "data" does not match function declaration.

test/libsolidity/syntaxTests/functionCalls/named_arguments_function_pointer_call.sol

@@ -0,0 +1,12 @@
+contract C {
+    function add(uint x, uint y) public pure returns (uint) { return x + y; }
+
+    function callViaFunctionPointer() public pure returns (uint) {
+        function(uint, uint) pure returns (uint) fp = add;
+        return fp({y: 2, x: 1});
+    }
+}
+
+// ----
+// TypeError 4974: (233-249): Named argument "y" does not match function declaration.
+// TypeError 4974: (233-249): Named argument "x" does not match function declaration.