[Sol->Yul] Implementing push for nested storage arrays and storage arrays of structs.

libsolidity/codegen/YulUtilFunctions.cpp

@@ -1047,8 +1047,6 @@ string YulUtilFunctions::storageArrayPushZeroFunction(ArrayType const& _type)
 	solUnimplementedAssert(!_type.isByteArray(), "Byte Arrays not yet implemented!");
 	solUnimplementedAssert(_type.baseType()->storageBytes() <= 32, "Base type is not yet implemented.");
 
-	solAssert(_type.baseType()->isValueType(), "");
-
 	string functionName = "array_push_zero_" + _type.identifier();
 	return m_functionCollector.createFunction(functionName, [&]() {
 		return Whiskers(R"(
@@ -1057,15 +1055,12 @@ string YulUtilFunctions::storageArrayPushZeroFunction(ArrayType const& _type)
 				if iszero(lt(oldLen, <maxArrayLength>)) { <panic>() }
 				sstore(array, add(oldLen, 1))
 				slot, offset := <indexAccess>(array, oldLen)
-				<storeValue>(slot, offset, <zeroValueFunction>())
 			})")
 			("functionName", functionName)
 			("panic", panicFunction())
 			("fetchLength", arrayLengthFunction(_type))
 			("indexAccess", storageArrayIndexAccessFunction(_type))
-			("storeValue", updateStorageValueFunction(*_type.baseType(), *_type.baseType()))
 			("maxArrayLength", (u256(1) << 64).str())
-			("zeroValueFunction", zeroValueFunction(*_type.baseType()))
 			.render();
 	});
 }

test/libsolidity/semanticTests/array/array_push_nested.sol

@@ -0,0 +1,17 @@
+contract C {
+    uint8 b = 23;
+    uint120[][] s;
+    uint8 a = 17;
+    function f() public {
+        s.push();
+        assert(s.length == 1);
+        assert(s[0].length == 0);
+        s[0].push();
+        assert(s[0].length == 1);
+        assert(s[0][0] == 0);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f() ->

test/libsolidity/semanticTests/array/dynamic_arrays_in_storage.sol

@@ -39,6 +39,8 @@ contract c {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // getLengths() -> 0, 0
 // setLengths(uint256,uint256): 48, 49 ->

test/libsolidity/semanticTests/array/push_no_args_2d.sol

@@ -24,6 +24,8 @@ contract C {
 		array2d.push().push() = value;
 	}
 }
+// ====
+// compileViaYul: also
 // ----
 // l() -> 0
 // f(uint256,uint256): 42, 64 ->

test/libsolidity/semanticTests/getters/array_mapping_struct.sol

@@ -18,6 +18,8 @@ contract C {
         n[1][1].b = 10;
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // m(uint256,uint256): 0, 0 -> 0x00, 0x00
 // m(uint256,uint256): 1, 0 -> 1, 2

test/libsolidity/semanticTests/getters/mapping_array_struct.sol

@@ -16,6 +16,8 @@ contract C {
         n[1][1].b = 10;
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // m(uint256,uint256): 0, 0 -> FAILURE
 // m(uint256,uint256): 1, 0 -> 1, 2

test/libsolidity/semanticTests/structs/struct_storage_push_zero_value.sol

@@ -0,0 +1,28 @@
+contract C {
+    struct S {
+        uint256 x;
+        uint128 y;
+        uint32 z;
+        uint128[3] a1;
+        uint128[] a2;
+    }
+    uint8 b = 23;
+    S[] s;
+    uint8 a = 17;
+    function f() public {
+        s.push();
+        assert(s[0].x == 0);
+        assert(s[0].y == 0);
+        assert(s[0].z == 0);
+        assert(s[0].a1[0] == 0);
+        assert(s[0].a1[1] == 0);
+        assert(s[0].a1[2] == 0);
+        assert(s[0].a2.length == 0);
+        assert(b == 23);
+        assert(a == 17);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f() ->