Merge pull request #5416 from ethereum/develop

Merge develop into release for 0.5.0

1 files changed, 52 insertions, 51 deletions

diff --git a/test/libsolidity/SolidityOptimizer.cpp b/test/libsolidity/SolidityOptimizer.cpp
index 5326feaf..f925d36e 100644
--- a/test/libsolidity/SolidityOptimizer.cpp
+++ b/test/libsolidity/SolidityOptimizer.cpp
@@ -25,7 +25,6 @@
 #include <libevmasm/Instruction.h>
 
 #include <boost/test/unit_test.hpp>
-#include <boost/lexical_cast.hpp>
 
 #include <chrono>
 #include <string>
@@ -74,16 +73,16 @@ public:
 		unsigned const _optimizeRuns = 200
 	)
 	{
-		m_nonOptimizedBytecode = compileAndRunWithOptimizer(_sourceCode, _value, _contractName, false, _optimizeRuns);
+		m_nonOptimizedBytecode = compileAndRunWithOptimizer("pragma solidity >=0.0;\n" + _sourceCode, _value, _contractName, false, _optimizeRuns);
 		m_nonOptimizedContract = m_contractAddress;
-		m_optimizedBytecode = compileAndRunWithOptimizer(_sourceCode, _value, _contractName, true, _optimizeRuns);
+		m_optimizedBytecode = compileAndRunWithOptimizer("pragma solidity >=0.0;\n" + _sourceCode, _value, _contractName, true, _optimizeRuns);
 		size_t nonOptimizedSize = numInstructions(m_nonOptimizedBytecode);
 		size_t optimizedSize = numInstructions(m_optimizedBytecode);
 		BOOST_CHECK_MESSAGE(
 			_optimizeRuns < 50 || optimizedSize < nonOptimizedSize,
 			string("Optimizer did not reduce bytecode size. Non-optimized size: ") +
-			std::to_string(nonOptimizedSize) + " - optimized size: " +
-			std::to_string(optimizedSize)
+			to_string(nonOptimizedSize) + " - optimized size: " +
+			to_string(optimizedSize)
 		);
 		m_optimizedContract = m_contractAddress;
 	}
@@ -104,7 +103,7 @@ public:
 							"\nOptimized:     " + toHex(optimizedOutput));
 	}
 
-	/// @returns the number of intructions in the given bytecode, not taking the metadata hash
+	/// @returns the number of instructions in the given bytecode, not taking the metadata hash
 	/// into account.
 	size_t numInstructions(bytes const& _bytecode, boost::optional<Instruction> _which = boost::optional<Instruction>{})
 	{
@@ -136,10 +135,11 @@ BOOST_AUTO_TEST_CASE(smoke_test)
 {
 	char const* sourceCode = R"(
 		contract test {
-			function f(uint a) returns (uint b) {
+			function f(uint a) public returns (uint b) {
 				return a;
 			}
-		})";
+		}
+	)";
 	compileBothVersions(sourceCode);
 	compareVersions("f(uint256)", u256(7));
 }
@@ -148,10 +148,11 @@ BOOST_AUTO_TEST_CASE(identities)
 {
 	char const* sourceCode = R"(
 		contract test {
-			function f(int a) returns (int b) {
+			function f(int a) public returns (int b) {
 				return int(0) | (int(1) * (int(0) ^ (0 + a)));
 			}
-		})";
+		}
+	)";
 	compileBothVersions(sourceCode);
 	compareVersions("f(int256)", u256(0x12334664));
 }
@@ -161,11 +162,12 @@ BOOST_AUTO_TEST_CASE(unused_expressions)
 	char const* sourceCode = R"(
 		contract test {
 			uint data;
-			function f() returns (uint a, uint b) {
+			function f() public returns (uint a, uint b) {
 				10 + 20;
 				data;
 			}
-		})";
+		}
+	)";
 	compileBothVersions(sourceCode);
 	compareVersions("f()");
 }
@@ -177,10 +179,11 @@ BOOST_AUTO_TEST_CASE(constant_folding_both_sides)
 	// literals as late as possible
 	char const* sourceCode = R"(
 		contract test {
-			function f(uint x) returns (uint y) {
+			function f(uint x) public returns (uint y) {
 				return 98 ^ (7 * ((1 | (x | 1000)) * 40) ^ 102);
 			}
-		})";
+		}
+	)";
 	compileBothVersions(sourceCode);
 	compareVersions("f(uint256)", 7);
 }
@@ -190,7 +193,7 @@ BOOST_AUTO_TEST_CASE(storage_access)
 	char const* sourceCode = R"(
 		contract test {
 			uint8[40] data;
-			function f(uint x) returns (uint y) {
+			function f(uint x) public returns (uint y) {
 				data[2] = data[7] = uint8(x);
 				data[4] = data[2] * 10 + data[3];
 			}
@@ -206,13 +209,13 @@ BOOST_AUTO_TEST_CASE(array_copy)
 		contract test {
 			bytes2[] data1;
 			bytes5[] data2;
-			function f(uint x) returns (uint l, uint y) {
+			function f(uint x) public returns (uint l, uint y) {
 				data1.length = msg.data.length;
 				for (uint i = 0; i < msg.data.length; ++i)
 					data1[i] = msg.data[i];
 				data2 = data1;
 				l = data2.length;
-				y = uint(data2[x]);
+				y = uint(uint40(data2[x]));
 			}
 		}
 	)";
@@ -226,8 +229,8 @@ BOOST_AUTO_TEST_CASE(function_calls)
 {
 	char const* sourceCode = R"(
 		contract test {
-			function f1(uint x) returns (uint) { return x*x; }
-			function f(uint x) returns (uint) { return f1(7+x) - this.f1(x**9); }
+			function f1(uint x) public returns (uint) { return x*x; }
+			function f(uint x) public returns (uint) { return f1(7+x) - this.f1(x**9); }
 		}
 	)";
 	compileBothVersions(sourceCode);
@@ -241,8 +244,8 @@ BOOST_AUTO_TEST_CASE(storage_write_in_loops)
 	char const* sourceCode = R"(
 		contract test {
 			uint d;
-			function f(uint a) returns (uint r) {
-				var x = d;
+			function f(uint a) public returns (uint r) {
+				uint x = d;
 				for (uint i = 1; i < a * a; i++) {
 					r = d;
 					d = i;
@@ -261,18 +264,18 @@ BOOST_AUTO_TEST_CASE(storage_write_in_loops)
 // Information in joining branches is not retained anymore.
 BOOST_AUTO_TEST_CASE(retain_information_in_branches)
 {
-	// This tests that the optimizer knows that we already have "z == keccak256(y)" inside both branches.
+	// This tests that the optimizer knows that we already have "z == keccak256(abi.encodePacked(y))" inside both branches.
 	char const* sourceCode = R"(
 		contract c {
 			bytes32 d;
 			uint a;
-			function f(uint x, bytes32 y) returns (uint r_a, bytes32 r_d) {
-				bytes32 z = keccak256(y);
+			function f(uint x, bytes32 y) public returns (uint r_a, bytes32 r_d) {
+				bytes32 z = keccak256(abi.encodePacked(y));
 				if (x > 8) {
-					z = keccak256(y);
+					z = keccak256(abi.encodePacked(y));
 					a = x;
 				} else {
-					z = keccak256(y);
+					z = keccak256(abi.encodePacked(y));
 					a = x;
 				}
 				r_a = a;
@@ -309,19 +312,19 @@ BOOST_AUTO_TEST_CASE(store_tags_as_unions)
 		contract test {
 			bytes32 data;
 			function f(uint x, bytes32 y) external returns (uint r_a, bytes32 r_d) {
-				r_d = keccak256(y);
+				r_d = keccak256(abi.encodePacked(y));
 				shared(y);
-				r_d = keccak256(y);
+				r_d = keccak256(abi.encodePacked(y));
 				r_a = 5;
 			}
 			function g(uint x, bytes32 y) external returns (uint r_a, bytes32 r_d) {
-				r_d = keccak256(y);
+				r_d = keccak256(abi.encodePacked(y));
 				shared(y);
-				r_d = bytes32(uint(keccak256(y)) + 2);
+				r_d = bytes32(uint(keccak256(abi.encodePacked(y))) + 2);
 				r_a = 7;
 			}
 			function shared(bytes32 y) internal {
-				data = keccak256(y);
+				data = keccak256(abi.encodePacked(y));
 			}
 		}
 	)";
@@ -347,9 +350,9 @@ BOOST_AUTO_TEST_CASE(incorrect_storage_access_bug)
 		contract C
 		{
 			mapping(uint => uint) data;
-			function f() returns (uint)
+			function f() public returns (uint)
 			{
-				if(data[now] == 0)
+				if (data[now] == 0)
 					data[uint(-7)] = 5;
 				return data[now];
 			}
@@ -366,7 +369,7 @@ BOOST_AUTO_TEST_CASE(sequence_number_for_calls)
 	// to storage), so the sequence number should be incremented.
 	char const* sourceCode = R"(
 		contract test {
-			function f(string a, string b) returns (bool) { return sha256(a) == sha256(b); }
+			function f(string memory a, string memory b) public returns (bool) { return sha256(bytes(a)) == sha256(bytes(b)); }
 		}
 	)";
 	compileBothVersions(sourceCode);
@@ -381,24 +384,24 @@ BOOST_AUTO_TEST_CASE(computing_constants)
 			uint m_b;
 			uint m_c;
 			uint m_d;
-			function C() {
+			constructor() public {
 				set();
 			}
-			function set() returns (uint) {
+			function set() public returns (uint) {
 				m_a = 0x77abc0000000000000000000000000000000000000000000000000000000001;
 				m_b = 0x817416927846239487123469187231298734162934871263941234127518276;
 				g();
 				return 1;
 			}
-			function g() {
+			function g() public {
 				m_b = 0x817416927846239487123469187231298734162934871263941234127518276;
 				m_c = 0x817416927846239487123469187231298734162934871263941234127518276;
 				h();
 			}
-			function h() {
+			function h() public {
 				m_d = 0xff05694900000000000000000000000000000000000000000000000000000000;
 			}
-			function get() returns (uint ra, uint rb, uint rc, uint rd) {
+			function get() public returns (uint ra, uint rb, uint rc, uint rd) {
 				ra = m_a;
 				rb = m_b;
 				rc = m_c;
@@ -437,10 +440,8 @@ BOOST_AUTO_TEST_CASE(constant_optimization_early_exit)
 	// This tests that the constant optimizer does not try to find the best representation
 	// indefinitely but instead stops after some number of iterations.
 	char const* sourceCode = R"(
-	pragma solidity ^0.4.0;
-
 	contract HexEncoding {
-		function hexEncodeTest(address addr) returns (bytes32 ret) {
+		function hexEncodeTest(address addr) public returns (bytes32 ret) {
 			uint x = uint(addr) / 2**32;
 
 			// Nibble interleave
@@ -514,8 +515,8 @@ BOOST_AUTO_TEST_CASE(inconsistency)
 
 			// Called with params: containerIndex=0, valueIndex=0
 			function levelIII(uint containerIndex, uint valueIndex) private {
-				Container container = containers[containerIndex];
-				Value value = container.values[valueIndex];
+				Container storage container = containers[containerIndex];
+				Value storage value = container.values[valueIndex];
 				debug = container.valueIndices[value.number];
 			}
 			function levelII() private {
@@ -526,7 +527,7 @@ BOOST_AUTO_TEST_CASE(inconsistency)
 
 			function trigger() public returns (uint) {
 				containers.length++;
-				Container container = containers[0];
+				Container storage container = containers[0];
 
 				container.values.push(Value({
 					badnum: 9000,
@@ -557,11 +558,11 @@ BOOST_AUTO_TEST_CASE(dead_code_elimination_across_assemblies)
 	char const* sourceCode = R"(
 		contract DCE {
 			function () internal returns (uint) stored;
-			function DCE() {
+			constructor() public {
 				stored = f;
 			}
 			function f() internal returns (uint) { return 7; }
-			function test() returns (uint) { return stored(); }
+			function test() public returns (uint) { return stored(); }
 		}
 	)";
 	compileBothVersions(sourceCode);
@@ -573,12 +574,12 @@ BOOST_AUTO_TEST_CASE(invalid_state_at_control_flow_join)
 	char const* sourceCode = R"(
 		contract Test {
 			uint256 public totalSupply = 100;
-			function f() returns (uint r) {
+			function f() public returns (uint r) {
 				if (false)
 					r = totalSupply;
 				totalSupply -= 10;
 			}
-			function test() returns (uint) {
+			function test() public returns (uint) {
 				f();
 				return this.totalSupply();
 			}
@@ -596,7 +597,7 @@ BOOST_AUTO_TEST_CASE(init_empty_dynamic_arrays)
 	// not use any memory.
 	char const* sourceCode = R"(
 		contract Test {
-			function f() pure returns (uint r) {
+			function f() public pure returns (uint r) {
 				uint[][] memory x = new uint[][](20000);
 				return x.length;
 			}
@@ -615,7 +616,7 @@ BOOST_AUTO_TEST_CASE(optimise_multi_stores)
 			struct S { uint16 a; uint16 b; uint16[3] c; uint[] dyn; }
 			uint padding;
 			S[] s;
-			function f() public returns (uint16, uint16, uint16[3], uint) {
+			function f() public returns (uint16, uint16, uint16[3] memory, uint) {
 				uint16[3] memory c;
 				c[0] = 7;
 				c[1] = 8;