Adding new tests and activating old tests.

test/cmdlineTests/name_simplifier/output

@@ -19,52 +19,49 @@ object "C_56" {
     object "C_56_deployed" {
         code {
             {
-                mstore(64, 128)
+                let _1 := 64
+                mstore(_1, 128)
                 if iszero(lt(calldatasize(), 4))
                 {
-                    let _1 := 0
+                    let _2 := 0
-                    if eq(0xf8eddcc6, shr(224, calldataload(_1)))
+                    if eq(0xf8eddcc6, shr(224, calldataload(_2)))
                     {
-                        if callvalue() { revert(_1, _1) }
+                        if callvalue() { revert(_2, _2) }
-                        let _2 := 32
+                        let _3 := 32
-                        if slt(add(calldatasize(), not(3)), _2) { revert(_1, _1) }
+                        if slt(add(calldatasize(), not(3)), _3) { revert(_2, _2) }
                         let offset := calldataload(4)
-                        let _3 := 0xffffffffffffffff
+                        let _4 := 0xffffffffffffffff
-                        if gt(offset, _3) { revert(_1, _1) }
+                        if gt(offset, _4) { revert(_2, _2) }
-                        if iszero(slt(add(offset, 35), calldatasize())) { revert(_1, _1) }
+                        if iszero(slt(add(offset, 35), calldatasize())) { revert(_2, _2) }
-                        let length := calldataload(add(4, offset))
+                        let _5 := calldataload(add(4, offset))
-                        if gt(length, _3) { invalid() }
+                        if gt(_5, _4) { invalid() }
-                        let _4 := mul(length, _2)
+                        let _6 := mul(_5, _3)
-                        let dst := allocateMemory(add(_4, _2))
+                        let dst := allocateMemory(add(_6, _3))
                         let dst_1 := dst
-                        mstore(dst, length)
+                        mstore(dst, _5)
-                        dst := add(dst, _2)
+                        dst := add(dst, _3)
                         let src := add(offset, 36)
-                        if gt(add(add(offset, _4), 36), calldatasize()) { revert(_1, _1) }
+                        if gt(add(add(offset, _6), 36), calldatasize()) { revert(_2, _2) }
-                        let i := _1
+                        let i := _2
-                        for { } lt(i, length) { i := add(i, 1) }
+                        for { } lt(i, _5) { i := add(i, 1) }
                         {
-                            mstore(dst, abi_decode_t_struct$_S(src, calldatasize()))
+                            if slt(sub(calldatasize(), src), _3) { revert(_2, _2) }
-                            dst := add(dst, _2)
+                            let memPtr := mload(_1)
-                            src := add(src, _2)
+                            let newFreePtr := add(memPtr, _3)
+                            if or(gt(newFreePtr, _4), lt(newFreePtr, memPtr)) { invalid() }
+                            mstore(_1, newFreePtr)
+                            mstore(memPtr, calldataload(src))
+                            mstore(dst, memPtr)
+                            dst := add(dst, _3)
+                            src := add(src, _3)
                         }
                         let ret, ret_1 := fun_sumArray_55(dst_1)
-                        let memPos := allocateMemory(_1)
+                        let memPos := allocateMemory(_2)
                         return(memPos, sub(abi_encode_uint256_t_string(memPos, ret, ret_1), memPos))
                     }
                 }
                 revert(0, 0)
             }
-            function abi_decode_t_struct$_S(headStart, end) -> value
-            {
-                if slt(sub(end, headStart), 0x20) { revert(value, value) }
-                let memPtr := mload(64)
-                let newFreePtr := add(memPtr, 0x20)
-                if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { invalid() }
-                mstore(64, newFreePtr)
-                value := memPtr
-                mstore(memPtr, calldataload(headStart))
-            }
             function abi_encode_uint256_t_string(headStart, value0, value1) -> tail
             {
                 mstore(headStart, value0)

test/libsolidity/gasTests/abiv2.sol

@@ -14,9 +14,9 @@ contract C {
 }
 // ----
 // creation:
-//   codeDepositCost: 1107400
+//   codeDepositCost: 1164600
-//   executionCost: 1154
+//   executionCost: 1207
-//   totalCost: 1108554
+//   totalCost: 1165807
 // external:
 //   a(): 1130
 //   b(uint256): infinite

test/libsolidity/gasTests/abiv2_optimised.sol

@@ -17,9 +17,9 @@ contract C {
 // optimize-yul: true
 // ----
 // creation:
-//   codeDepositCost: 605000
+//   codeDepositCost: 578200
-//   executionCost: 638
+//   executionCost: 613
-//   totalCost: 605638
+//   totalCost: 578813
 // external:
 //   a(): 1029
 //   b(uint256): 2084

test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol

@@ -15,6 +15,7 @@ contract C {
     }
 }
 // ====
+// compileViaYul: also
 // EVMVersion: >homestead
 // ----
 // f(uint256[][1]): 32, 32, 0 -> true

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_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/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

test/libsolidity/semanticTests/inlineAssembly/calldata_array_assign.sol

@@ -4,5 +4,7 @@ contract C {
         r = x;
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // f(uint256[2][]): 0x0, 1, 8, 7, 6, 5 -> 0x20, 2, 8, 7, 6, 5

test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_array_to_memory.sol

@@ -0,0 +1,23 @@
+pragma experimental ABIEncoderV2;
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256[2] b;
+        uint256 c;
+    }
+
+    function f(S calldata c)
+        external
+        pure
+        returns (uint256, uint256, uint256, uint256)
+    {
+        S memory m = c;
+        return (m.a, m.b[0], m.b[1], m.c);
+    }
+}
+
+// ====
+// compileViaYul: also
+// ----
+// f((uint256,uint256[2],uint256)): 42, 1, 2, 23 -> 42, 1, 2, 23