Add TangerineWhistle.

libsolidity/interface/EVMVersion.h

@@ -23,6 +23,7 @@
 #include <string>
 
 #include <boost/optional.hpp>
+#include <boost/operators.hpp>
 
 namespace dev
 {
@@ -33,42 +34,50 @@ namespace solidity
  * A version specifier of the EVM we want to compile to.
  * Defaults to the latest version.
  */
-class EVMVersion
+class EVMVersion:
+	boost::less_than_comparable<EVMVersion>,
+	boost::equality_comparable<EVMVersion>
 {
 public:
 	EVMVersion() {}
 
 	static EVMVersion homestead() { return {Version::Homestead}; }
+	static EVMVersion tangerineWhistle() { return {Version::TangerineWhistle}; }
+	static EVMVersion spuriousDragon() { return {Version::SpuriousDragon}; }
 	static EVMVersion byzantium() { return {Version::Byzantium}; }
 
 	static boost::optional<EVMVersion> fromString(std::string const& _version)
 	{
-		if (_version == "homestead")
-			return homestead();
-		else if (_version == "byzantium")
-			return byzantium();
-		else
-			return {};
+		for (auto const& v: {homestead(), tangerineWhistle(), spuriousDragon(), byzantium()})
+			if (_version == v.name())
+				return v;
+		return {};
 	}
 
 	bool operator==(EVMVersion const& _other) const { return m_version == _other.m_version; }
-	bool operator!=(EVMVersion const& _other) const { return !this->operator==(_other); }
+	bool operator<(EVMVersion const& _other) const { return m_version < _other.m_version; }
 
-	std::string name() const { return m_version == Version::Byzantium ? "byzantium" : "homestead"; }
+	std::string name() const
+	{
+		switch (m_version)
+		{
+		case Version::Byzantium: return "byzantium";
+		case Version::TangerineWhistle: return "tangerineWhistle";
+		case Version::SpuriousDragon: return "spuriousDragon";
+		case Version::Homestead: return "homestead";
+		}
+		return "INVALID";
+	}
 
-	bool hasReturndatacopy() const { return m_version == Version::Byzantium; }
-	bool hasStaticCall() const { return m_version == Version::Byzantium; }
+	bool hasReturndatacopy() const { return *this >= byzantium(); }
+	bool hasStaticCall() const { return *this >= byzantium(); }
 
 	/// Whether we have to retain the costs for the call opcode itself (false),
 	/// or whether we can just forward easily all remaining gas (true).
-	bool canOverchargeGasForCall() const
-	{
-		// @TODO when exactly was this introduced? Was together with the call stack fix.
-		return m_version == Version::Byzantium;
-	}
+	bool canOverchargeGasForCall() const { return *this >= tangerineWhistle(); }
 
 private:
-	enum class Version { Homestead, Byzantium };
+	enum class Version { Homestead, TangerineWhistle, SpuriousDragon, Byzantium };
 
 	EVMVersion(Version _version): m_version(_version) {}
 

solc/CommandLineInterface.cpp

@@ -539,7 +539,7 @@ Allowed options)",
 		(
 			g_strEVMVersion.c_str(),
 			po::value<string>()->value_name("version"),
-			"Select desired EVM version. Either homestead or byzantium (default)."
+			"Select desired EVM version. Either homestead, tangerineWhistle, spuriousDragon or byzantium (default)."
 		)
 		(g_argOptimize.c_str(), "Enable bytecode optimizer.")
 		(

test/RPCSession.cpp

@@ -219,9 +219,13 @@ string RPCSession::personal_newAccount(string const& _password)
 
 void RPCSession::test_setChainParams(vector<string> const& _accounts)
 {
-	string enableByzantium;
-	if (test::Options::get().evmVersion() == solidity::EVMVersion::byzantium())
-		 enableByzantium = "\"byzantiumForkBlock\": \"0x00\",";
+	string forks;
+	if (test::Options::get().evmVersion() >= solidity::EVMVersion::tangerineWhistle())
+		forks += "\"EIP150ForkBlock\": \"0x00\",\n";
+	if (test::Options::get().evmVersion() >= solidity::EVMVersion::spuriousDragon())
+		forks += "\"EIP158ForkBlock\": \"0x00\",\n";
+	if (test::Options::get().evmVersion() >= solidity::EVMVersion::byzantium())
+		forks += "\"byzantiumForkBlock\": \"0x00\",\n";
 	static string const c_configString = R"(
 	{
 		"sealEngine": "NoProof",
@@ -230,10 +234,8 @@ void RPCSession::test_setChainParams(vector<string> const& _accounts)
 			"maximumExtraDataSize": "0x1000000",
 			"blockReward": "0x",
 			"allowFutureBlocks": true,
-			"homesteadForkBlock": "0x00",
-			)" + enableByzantium + R"(
-			"EIP150ForkBlock": "0x00",
-			"EIP158ForkBlock": "0x00"
+			)" + forks + R"(
+			"homesteadForkBlock": "0x00"
 		},
 		"genesis": {
 			"author": "0000000000000010000000000000000000000000",

test/libsolidity/SolidityNameAndTypeResolution.cpp

@@ -6845,7 +6845,7 @@ BOOST_AUTO_TEST_CASE(returndatacopy_as_variable)
 		{Error::Type::Warning, "Variable is shadowed in inline assembly by an instruction of the same name"},
 		{Error::Type::DeclarationError, "Unbalanced stack"}
 	});
-	if (dev::test::Options::get().evmVersion() == EVMVersion::homestead())
+	if (!dev::test::Options::get().evmVersion().hasReturndatacopy())
 		expectations.emplace_back(make_pair(Error::Type::Warning, std::string("\"returndatasize\" instruction is only available for Byzantium-compatible")));
 	CHECK_ALLOW_MULTI(text, expectations);
 }

test/libsolidity/StandardCompiler.cpp

@@ -593,6 +593,10 @@ BOOST_AUTO_TEST_CASE(evm_version)
 	Json::Value result;
 	result = compile(inputForVersion("\"evmVersion\": \"homestead\","));
 	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"homestead\"") != string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"tangerineWhistle\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"tangerineWhistle\"") != string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"spuriousDragon\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"spuriousDragon\"") != string::npos);
 	result = compile(inputForVersion("\"evmVersion\": \"byzantium\","));
 	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"byzantium\"") != string::npos);
 	// test default

test/libsolidity/ViewPureChecker.cpp

@@ -425,7 +425,7 @@ BOOST_AUTO_TEST_CASE(assembly_staticcall)
 			}
 		}
 	)";
-	if (dev::test::Options::get().evmVersion() == EVMVersion::homestead())
+	if (!dev::test::Options::get().evmVersion().hasStaticCall())
 		CHECK_WARNING(text, "\"staticcall\" instruction is only available for Byzantium-compatible");
 	else
 		CHECK_SUCCESS_NO_WARNINGS(text);