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