Merge pull request #10211 from ethereum/copyArrayCalldata2MemSol2Yul

[Sol->Yul] Copying arrays from calldata to memory

test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_memory.sol

@@ -0,0 +1,38 @@
+pragma experimental ABIEncoderV2;
+
+contract c {
+    function test1(uint256[][] calldata c) external returns (uint256, uint256) {
+        uint256[][] memory a1 = c;
+        assert(a1[0][0] == c[0][0]);
+        assert(a1[0][1] == c[0][1]);
+        return (a1.length, a1[0][0] + a1[1][1]);
+    }
+
+    function test2(uint256[][2] calldata c) external returns (uint256, uint256) {
+        uint256[][2] memory a2 = c;
+        assert(a2[0][0] == c[0][0]);
+        assert(a2[0][1] == c[0][1]);
+        return (a2[0].length, a2[0][0] + a2[1][1]);
+    }
+
+    function test3(uint256[2][] calldata c) external returns (uint256, uint256) {
+        uint256[2][] memory a3 = c;
+        assert(a3[0][0] == c[0][0]);
+        assert(a3[0][1] == c[0][1]);
+        return (a3.length, a3[0][0] + a3[1][1]);
+    }
+
+    function test4(uint256[2][2] calldata c) external returns (uint256) {
+        uint256[2][2] memory a4 = c;
+        assert(a4[0][0] == c[0][0]);
+        assert(a4[0][1] == c[0][1]);
+        return (a4[0][0] + a4[1][1]);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1(uint256[][]): 0x20, 2, 0x40, 0x40, 2, 23, 42 -> 2, 65
+// test2(uint256[][2]): 0x20, 0x40, 0x40, 2, 23, 42 -> 2, 65
+// test3(uint256[2][]): 0x20, 2, 23, 42, 23, 42 -> 2, 65
+// test4(uint256[2][2]): 23, 42, 23, 42 -> 65

test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol

@@ -10,28 +10,28 @@ contract c {
         a1 = c;
         assert(a1[0][0] == c[0][0]);
         assert(a1[0][1] == c[0][1]);
-        return (a1.length, a1[1][0] + a1[1][1]);
+        return (a1.length, a1[0][0] + a1[1][1]);
     }
 
     function test2(uint256[][2] calldata c) external returns (uint256, uint256) {
         a2 = c;
         assert(a2[0][0] == c[0][0]);
         assert(a2[0][1] == c[0][1]);
-        return (a2[0].length, a2[1][0] + a2[1][1]);
+        return (a2[0].length, a2[0][0] + a2[1][1]);
     }
 
     function test3(uint256[2][] calldata c) external returns (uint256, uint256) {
         a3 = c;
         assert(a3[0][0] == c[0][0]);
         assert(a3[0][1] == c[0][1]);
-        return (a3.length, a3[1][0] + a3[1][1]);
+        return (a3.length, a3[0][0] + a3[1][1]);
     }
 
     function test4(uint256[2][2] calldata c) external returns (uint256) {
         a4 = c;
         assert(a4[0][0] == c[0][0]);
         assert(a4[0][1] == c[0][1]);
-        return (a4[1][0] + a4[1][1]);
+        return (a4[0][0] + a4[1][1]);
     }
 }
 // ====
@@ -39,5 +39,5 @@ contract c {
 // ----
 // test1(uint256[][]): 0x20, 2, 0x40, 0x40, 2, 23, 42 -> 2, 65
 // test2(uint256[][2]): 0x20, 0x40, 0x40, 2, 23, 42 -> 2, 65
-// test3(uint256[2][]): 0x20, 2, 0x40, 0x40, 23, 42 -> 2, 65
+// test3(uint256[2][]): 0x20, 2, 23, 42, 23, 42 -> 2, 65
 // test4(uint256[2][2]): 23, 42, 23, 42 -> 65

test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_memory.sol

@@ -0,0 +1,22 @@
+pragma experimental ABIEncoderV2;
+
+contract C {
+    struct S {
+        uint128 a;
+        uint64 b;
+        uint128 c;
+    }
+    function f(S[3] calldata c) public returns (uint128, uint64, uint128) {
+        S[3] memory m = c;
+        return (m[2].a, m[1].b, m[0].c);
+    }
+    function g(S[] calldata c) public returns (uint128, uint64, uint128) {
+        S[] memory m = c;
+        return (m[2].a, m[1].b, m[0].c);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f((uint128, uint64, uint128)[3]): 0, 0, 12, 0, 11, 0, 10, 0, 0 -> 10, 11, 12
+// g((uint128, uint64, uint128)[]): 0x20, 3, 0, 0, 12, 0, 11, 0, 10, 0, 0 -> 10, 11, 12

test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_memory.sol

@@ -0,0 +1,23 @@
+pragma experimental ABIEncoderV2;
+
+contract C {
+    struct S {
+        uint256[] a;
+    }
+
+    function f(S[] calldata c) external returns (uint256, uint256) {
+        S[] memory s = c;
+        assert(s.length == c.length);
+        for (uint i = 0; i < s.length; i++) {
+            assert(s[i].a.length == c[i].a.length);
+            for (uint j = 0; j < s[i].a.length; j++) {
+                assert(s[i].a[j] == c[i].a[j]);
+            }
+        }
+        return (s[1].a.length, s[1].a[0]);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f((uint256[])[]): 0x20, 3, 0x60, 0x60, 0x60, 0x20, 3, 1, 2, 3 -> 3, 1

test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol

@@ -9,6 +9,13 @@ contract C {
 
     function f(S[] calldata c) external returns (uint256, uint256) {
         s = c;
+        assert(s.length == c.length);
+        for (uint i = 0; i < s.length; i++) {
+            assert(s[i].a.length == c[i].a.length);
+            for (uint j = 0; j < s[i].a.length; j++) {
+                assert(s[i].a[j] == c[i].a[j]);
+            }
+        }
         return (s[1].a.length, s[1].a[0]);
     }
 }

test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol

@@ -21,5 +21,7 @@ contract C {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // f((uint256,uint256)[]): 0x20, 0x2, 0x1, 0x2, 0x3, 0x4 -> 2, 1, 2, 3, 4

test/libsolidity/semanticTests/array/copying/calldata_array_static_to_memory.sol

@@ -0,0 +1,10 @@
+contract C {
+    function f(uint256[2] calldata c) public returns (uint256, uint256) {
+        uint256[2] memory m1 = c;
+        return (m1[0], m1[1]);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f(uint256[2]): 43, 57 -> 43, 57

test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol

@@ -11,5 +11,7 @@ contract C {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // f(uint256[][]): 0x20, 0x1, 0x20, 0x2, 0x17, 0x2a -> 0x1, 0x40, 0x2, 0x17, 0x2a