- added conversion for string/hash of equal sizes

- added tests

libsolidity/ExpressionCompiler.cpp

@@ -628,7 +628,33 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
 		return;
 	Type::Category stackTypeCategory = _typeOnStack.getCategory();
 	Type::Category targetTypeCategory = _targetType.getCategory();
-	if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT ||
+
+	if (stackTypeCategory == Type::Category::STRING && targetTypeCategory == Type::Category::INTEGER)
+	{
+		// conversion from string to hash. no need to clean the high bit
+		// only to shift right because of opposite alignment
+		IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType);
+		StaticStringType const& sourceStringType = dynamic_cast<StaticStringType const&>(_typeOnStack);
+		if (targetIntegerType.isHash())
+		{
+			solAssert(targetIntegerType.getNumBits() == sourceStringType.getNumBytes() * 8, "The size should be the same.");
+			m_context << u256(std::pow(2, 256 - sourceStringType.getNumBytes() * 8)) <<
+					eth::Instruction::SWAP1 << eth::Instruction::DIV;
+		}
+	}
+	else if (targetTypeCategory == Type::Category::STRING && stackTypeCategory == Type::Category::INTEGER)
+	{
+		// conversion from hash to string. no need to clean the high bit
+		// only to shift left because of opposite alignment
+		StaticStringType const& targetStringType = dynamic_cast<StaticStringType const&>(_targetType);
+		IntegerType const& sourceIntegerType = dynamic_cast<IntegerType const&>(_typeOnStack);
+		if (sourceIntegerType.isHash())
+		{
+			solAssert(sourceIntegerType.getNumBits() == targetStringType.getNumBytes() * 8, "The size should be the same.");
+			m_context << u256(std::pow(2, 256 - sourceIntegerType.getNumBits())) << eth::Instruction::MUL;
+		}
+	}
+	else if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT ||
 			 stackTypeCategory == Type::Category::INTEGER_CONSTANT)
 	{
 		solAssert(targetTypeCategory == Type::Category::INTEGER || targetTypeCategory == Type::Category::CONTRACT, "");
@@ -657,7 +683,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
 	}
 	else if (stackTypeCategory == Type::Category::STRING)
 	{
-		solAssert(targetTypeCategory == Type::Category::STRING, "");
+		solAssert(targetTypeCategory == Type::Category::STRING || targetTypeCategory == Type::Category::INTEGER, "Invalid type conversion requested.");
 		// nothing to do, strings are high-order-bit-aligned
 		//@todo clear lower-order bytes if we allow explicit conversion to shorter strings
 	}

libsolidity/Types.cpp

@@ -140,6 +140,11 @@ bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
 
 bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 {
+	if (_convertTo.getCategory() == Category::STRING)
+	{
+		StaticStringType const& convertTo = dynamic_cast<StaticStringType const&>(_convertTo);
+		return isHash() && (m_bits == convertTo.getNumBytes() * 8);
+	}
 	return _convertTo.getCategory() == getCategory() || _convertTo.getCategory() == Category::CONTRACT;
 }
 
@@ -367,6 +372,17 @@ bool StaticStringType::isImplicitlyConvertibleTo(Type const& _convertTo) const
 	return convertTo.m_bytes >= m_bytes;
 }
 
+bool StaticStringType::isExplicitlyConvertibleTo(Type const& _convertTo) const
+{
+	if (_convertTo.getCategory() == Category::INTEGER)
+	{
+		IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
+		if (convertTo.isHash() && (m_bytes * 8 == convertTo.getNumBits()))
+			return true;
+	}
+	return isImplicitlyConvertibleTo(_convertTo);
+}
+
 bool StaticStringType::operator==(Type const& _other) const
 {
 	if (_other.getCategory() != getCategory())

libsolidity/Types.h

@@ -233,9 +233,10 @@ public:
 	/// if no type fits.
 	static std::shared_ptr<StaticStringType> smallestTypeForLiteral(std::string const& _literal);
 
-	StaticStringType(int _bytes);
+	explicit StaticStringType(int _bytes);
 
 	virtual bool isImplicitlyConvertibleTo(Type const& _convertTo) const override;
+	virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override;
 	virtual bool operator==(Type const& _other) const override;
 
 	virtual unsigned getCalldataEncodedSize() const override { return m_bytes; }

test/SolidityEndToEndTest.cpp

@@ -940,6 +940,72 @@ BOOST_AUTO_TEST_CASE(type_conversions_cleanup)
 														   0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0x11, 0x22}));
 }
 
+BOOST_AUTO_TEST_CASE(convert_string_to_string)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			function pipeTrough(string3 input) returns (string3 ret) {
+				return string3(input);
+			}
+		})";
+	compileAndRun(sourceCode);
+	string s = "abc";
+	auto res = callContractFunction("pipeTrough(string3)", "abc");
+	auto goldenRes = encodeArgs(s);
+	BOOST_CHECK(callContractFunction("pipeTrough(string3)", "abc") == encodeArgs("abc"));
+}
+
+BOOST_AUTO_TEST_CASE(convert_hash_to_string_same_size)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			function hashToString(hash h) returns (string32 s) {
+				return string32(h);
+			}
+		})";
+	compileAndRun(sourceCode);
+	u256 a("0x6162630000000000000000000000000000000000000000000000000000000000");
+	BOOST_CHECK(callContractFunction("hashToString(hash256)", a) == encodeArgs(a));
+}
+
+BOOST_AUTO_TEST_CASE(convert_hash_to_string_different_size)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			function hashToString(hash160 h) returns (string20 s) {
+				return string20(h);
+			}
+		})";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("hashToString(hash160)", u160("0x00000000000000616263")) ==
+						encodeArgs(u256("0x0000000000000000000000000000000000616263000000000000000000000000")));
+}
+
+BOOST_AUTO_TEST_CASE(convert_string_to_hash_same_size)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			function stringToHash(string32 s) returns (hash h) {
+				return hash(s);
+			}
+		})";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("stringToHash(string32)", string("abc2")) ==
+					encodeArgs(u256("0x6162633200000000000000000000000000000000000000000000000000000000")));
+}
+
+BOOST_AUTO_TEST_CASE(convert_string_to_hash_different_size)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			function stringToHash(string20 s) returns (hash160 h) {
+				return hash160(s);
+			}
+		})";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("stringToHash(string20)", u256("0x0000000000000000000000000000000000616263000000000000000000000000")) ==
+					encodeArgs(u160("0x00000000000000616263")));
+}
 
 BOOST_AUTO_TEST_CASE(send_ether)
 {