Add push() for dynamic storage arrays

test/libsolidity/SolidityEndToEndTest.cpp

@@ -4759,7 +4759,8 @@ BOOST_AUTO_TEST_CASE(array_push)
 				x = data[0];
 				data.push(4);
 				y = data[1];
-				l = data.push(3);
+				data.push(3);
+				l = data.length;
 				z = data[2];
 			}
 		}
@@ -4816,11 +4817,13 @@ BOOST_AUTO_TEST_CASE(byte_array_push)
 		contract c {
 			bytes data;
 			function test() public returns (bool x) {
-				if (data.push(0x05) != 1)  return true;
+				data.push(0x05);
+				if (data.length != 1)  return true;
 				if (data[0] != 0x05) return true;
 				data.push(0x04);
 				if (data[1] != 0x04) return true;
-				uint l = data.push(0x03);
+				data.push(0x03);
+				uint l = data.length;
 				if (data[2] != 0x03) return true;
 				if (l != 0x03) return true;
 			}
@@ -4860,7 +4863,8 @@ BOOST_AUTO_TEST_CASE(array_pop)
 			uint[] data;
 			function test() public returns (uint x, uint l) {
 				data.push(7);
-				x = data.push(3);
+				data.push(3);
+				x = data.length;
 				data.pop();
 				x = data.length;
 				data.pop();
@@ -4996,10 +5000,12 @@ BOOST_AUTO_TEST_CASE(byte_array_pop)
 			bytes data;
 			function test() public returns (uint x, uint y, uint l) {
 				data.push(0x07);
-				x = data.push(0x03);
+				data.push(0x03);
+				x = data.length;
 				data.pop();
 				data.pop();
-				y = data.push(0x02);
+				data.push(0x02);
+				y = data.length;
 				l = data.length;
 			}
 		}

test/libsolidity/semanticTests/array/push_no_args_1d.sol

@@ -0,0 +1,32 @@
+contract C {
+	uint[] array;
+
+	function f() public returns (uint) {
+		uint y = array.push();
+		return y;
+	}
+
+	function lv(uint value) public {
+		array.push() = value;
+	}
+
+	function a(uint index) public view returns (uint) {
+		return array[index];
+	}
+
+	function l() public view returns (uint) {
+		return array.length;
+	}
+
+}
+// ----
+// l() -> 0
+// lv(uint256): 42 ->
+// l() -> 1
+// a(uint256): 0 -> 42
+// f() -> 0
+// l() -> 2
+// a(uint256): 1 -> 0
+// lv(uint256): 111 ->
+// l() -> 3
+// a(uint256): 2 -> 111

test/libsolidity/semanticTests/array/push_no_args_2d.sol

@@ -0,0 +1,39 @@
+contract C {
+	uint[][] array2d;
+
+	function l() public returns (uint) {
+		return array2d.length;
+	}
+
+	function ll(uint index) public returns (uint) {
+		return array2d[index].length;
+	}
+
+	function a(uint i, uint j) public returns (uint) {
+		return array2d[i][j];
+	}
+
+	function f(uint index, uint value) public {
+		uint[] storage pointer = array2d.push();
+		for (uint i = 0; i <= index; ++i)
+			pointer.push();
+		pointer[index] = value;
+	}
+
+	function lv(uint value) public {
+		array2d.push().push() = value;
+	}
+}
+// ----
+// l() -> 0
+// f(uint256,uint256): 42, 64 ->
+// l() -> 1
+// ll(uint256): 0 -> 43
+// a(uint256,uint256): 0, 42 -> 64
+// f(uint256,uint256): 84, 128 ->
+// l() -> 2
+// ll(uint256): 1 -> 85
+// a(uint256,uint256): 0, 42 -> 64
+// a(uint256,uint256): 1, 84 -> 128
+// lv(uint256): 512 ->
+// a(uint256,uint256): 2, 0 -> 512

test/libsolidity/semanticTests/array/push_no_args_bytes.sol

@@ -0,0 +1,28 @@
+contract C {
+	bytes array;
+
+	function f() public {
+		array.push();
+	}
+
+	function g(uint x) public {
+		for (uint i = 0; i < x; ++i)
+			array.push() = bytes1(uint8(i));
+	}
+
+	function l() public returns (uint) {
+		return array.length;
+	}
+
+	function a(uint index) public view returns (bytes1) {
+		return array[index];
+	}
+}
+// ----
+// l() -> 0
+// g(uint256): 70 ->
+// l() -> 70
+// a(uint256): 69 -> left(69)
+// f() ->
+// l() -> 71
+// a(uint256): 70 -> 0

test/libsolidity/semanticTests/array/push_no_args_struct.sol

@@ -0,0 +1,44 @@
+contract C {
+	struct S {
+		uint x;
+	}
+
+	S[] array;
+
+	function f(uint y) public {
+		S storage s = array.push();
+		g(s, y);
+	}
+
+	function g(S storage s, uint y) internal {
+		s.x = y;
+	}
+
+	function h(uint y) public {
+		g(array.push(), y);
+	}
+
+	function lv(uint y) public {
+		array.push().x = y;
+	}
+
+	function a(uint i) public returns (uint) {
+		return array[i].x;
+	}
+
+	function l() public returns (uint) {
+		return array.length;
+	}
+
+}
+// ----
+// l() -> 0
+// f(uint256): 42 ->
+// l() -> 1
+// a(uint256): 0 -> 42
+// h(uint256): 84 ->
+// l() -> 2
+// a(uint256): 1 -> 84
+// lv(uint256): 4096 ->
+// l() -> 3
+// a(uint256): 2 -> 4096