cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleanup fixed point type changes

Browse Source
This commit is contained in:
chriseth 2017-07-12 15:44:27 +02:00 committed by Alex Beregszaszi
parent 78769f3b39
commit 72917c4f35
4 changed files with 111 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
libsolidity/ast/Types.cpp
View File

@ -353,12 +353,10 @@ bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{ {
FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo); FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo);
if (((u256(1) << m_bits) <= convertTo.numBits() && convertTo.fractionalDigits() == 0) || isAddress()) if (isAddress())
return false; return false;
else if (isSigned())
return convertTo.isSigned();
else else
return !convertTo.isSigned() || convertTo.numBits() > m_bits; return maxValue() <= convertTo.maxIntegerValue() && minValue() >= convertTo.minIntegerValue();
} }
else else
return false; return false;
@ -501,7 +499,7 @@ FixedPointType::FixedPointType(int _totalBits, int _fractionalDigits, FixedPoint
string FixedPointType::identifier() const string FixedPointType::identifier() const
{ {
return "t_" + string(isSigned() ? "" : "u") + "fixed" + std::to_string(numBits()) + "x" + std::to_string(fractionalDigits()); return "t_" + string(isSigned() ? "" : "u") + "fixed" + std::to_string(m_totalBits) + "x" + std::to_string(m_fractionalDigits);
} }
bool FixedPointType::isImplicitlyConvertibleTo(Type const& _convertTo) const bool FixedPointType::isImplicitlyConvertibleTo(Type const& _convertTo) const
@ -512,7 +510,7 @@ bool FixedPointType::isImplicitlyConvertibleTo(Type const& _convertTo) const
if (convertTo.numBits() < m_totalBits || convertTo.fractionalDigits() < m_fractionalDigits) if (convertTo.numBits() < m_totalBits || convertTo.fractionalDigits() < m_fractionalDigits)
return false; return false;
else else
return convertTo.maximumPossibleInteger() >= maximumPossibleInteger(); return convertTo.maxIntegerValue() >= maxIntegerValue() && convertTo.minIntegerValue() <= minIntegerValue();
} }
return false; return false;
} }
@ -524,31 +522,6 @@ bool FixedPointType::isExplicitlyConvertibleTo(Type const& _convertTo) const
_convertTo.category() == Category::FixedBytes; _convertTo.category() == Category::FixedBytes;
} }
/*bool FixedPointType::canHoldInteger(unsigned const _bits, bool const _signed) const
{
// If fixed type has 200 bits and 2 fractional digits, integer has 8 bits, then conversion is possible.
// Write helper function that returns max integer number, not necessarily the bits.
// 2^m_bits <= integer
// REMINDER: The below was a work in progress until better solution thought up, see below:
// add min and max number functions to integer and fixed types, use them when converting types.
if (_signed && isSigned())
{
u256 maxInteger = (u256(1) << _bits) - 1;
u256 maxFixedInteger = u256(((u256(1) << numBits()) - 1) / (pow(bigint(10), decimalDigits())));
}
else if (_signed && !isSigned())
{
}
else
{
u256 maxInteger = (u256(1) << _bits) - 1;
u256 maxFixedInteger = u256(((u256(1) << numBits()) - 1) / (pow(bigint(10), decimalDigits())));
return maxInteger <= maxFixedInteger;
}
}*/
TypePointer FixedPointType::unaryOperatorResult(Token::Value _operator) const TypePointer FixedPointType::unaryOperatorResult(Token::Value _operator) const
{ {
// "delete" is ok for all fixed types // "delete" is ok for all fixed types
@ -580,6 +553,23 @@ string FixedPointType::toString(bool) const
return prefix + dev::toString(m_totalBits) + "x" + dev::toString(m_fractionalDigits); return prefix + dev::toString(m_totalBits) + "x" + dev::toString(m_fractionalDigits);
} }
bigint FixedPointType::maxIntegerValue() const
{
bigint maxValue = (bigint(1) << (m_totalBits - (isSigned() ? 1 : 0))) - 1;
return maxValue / pow(bigint(10), m_fractionalDigits);
}
bigint FixedPointType::minIntegerValue() const
{
if (isSigned())
{
bigint minValue = -(bigint(1) << (m_totalBits - (isSigned() ? 1 : 0)));
return minValue / pow(bigint(10), m_fractionalDigits);
}
else
return bigint(0);
}
TypePointer FixedPointType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const TypePointer FixedPointType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{ {
if ( if (
@ -765,15 +755,8 @@ bool RationalNumberType::isImplicitlyConvertibleTo(Type const& _convertTo) const
else if (_convertTo.category() == Category::FixedPoint) else if (_convertTo.category() == Category::FixedPoint)
{ {
if (auto fixed = fixedPointType()) if (auto fixed = fixedPointType())
{ return fixed->isImplicitlyConvertibleTo(_convertTo);
// We disallow implicit conversion if we would have to truncate (fixedPointType() else
// can return a type that requires truncation).
rational value = m_value * boost::multiprecision::pow(bigint(10), fixed->fractionalDigits());
cout << "value denominator: " << value.denominator() << endl;
cout << "value: " << value << endl;
return value.denominator() == 1 && fixed->isImplicitlyConvertibleTo(_convertTo);
}
cout << "could not convert to fixed type" << endl;
return false; return false;
} }
else if (_convertTo.category() == Category::FixedBytes) else if (_convertTo.category() == Category::FixedBytes)
@ -978,10 +961,9 @@ u256 RationalNumberType::literalValue(Literal const*) const
else else
{ {
auto fixed = fixedPointType(); auto fixed = fixedPointType();
solAssert(!!fixed, ""); solAssert(fixed, "");
// truncate int fractionalDigits = fixed->fractionalDigits();
shiftedValue = m_value.numerator() / m_value.denominator(); shiftedValue = (m_value.numerator() / m_value.denominator()) * pow(bigint(10), fractionalDigits);
cout << "Shifted value: " << shiftedValue << endl;
} }
// we ignore the literal and hope that the type was correctly determined // we ignore the literal and hope that the type was correctly determined
@ -1035,14 +1017,9 @@ shared_ptr<FixedPointType const> RationalNumberType::fixedPointType() const
} }
if (value > maxValue) if (value > maxValue)
{
cout << "value > maxValue" << endl;
return shared_ptr<FixedPointType const>(); return shared_ptr<FixedPointType const>();
} // This means we round towards zero for positive and negative values.
// u256(v) is the actual value that will be put on the stack
// From here on, very similar to integerType()
bigint v = value.numerator() / value.denominator(); bigint v = value.numerator() / value.denominator();
cout << "Big int: " << u256(v) << endl;
if (negative) if (negative)
// modify value to satisfy bit requirements for negative numbers: // modify value to satisfy bit requirements for negative numbers:
// add one bit for sign and decrement because negative numbers can be larger // add one bit for sign and decrement because negative numbers can be larger
@ -1054,7 +1031,6 @@ shared_ptr<FixedPointType const> RationalNumberType::fixedPointType() const
unsigned totalBits = max(bytesRequired(v), 1u) * 8; unsigned totalBits = max(bytesRequired(v), 1u) * 8;
solAssert(totalBits <= 256, ""); solAssert(totalBits <= 256, "");
cout << "rational turned into " << (negative ? "fixed" : "ufixed") << totalBits << "x" << fractionalDigits << endl;
return make_shared<FixedPointType>( return make_shared<FixedPointType>(
totalBits, fractionalDigits, totalBits, fractionalDigits,
negative ? FixedPointType::Modifier::Signed : FixedPointType::Modifier::Unsigned negative ? FixedPointType::Modifier::Signed : FixedPointType::Modifier::Unsigned

16
libsolidity/ast/Types.h
View File

@ -321,10 +321,6 @@ public:
int numBits() const { return m_bits; } int numBits() const { return m_bits; }
bool isAddress() const { return m_modifier == Modifier::Address; } bool isAddress() const { return m_modifier == Modifier::Address; }
bool isSigned() const { return m_modifier == Modifier::Signed; } bool isSigned() const { return m_modifier == Modifier::Signed; }
u256 maximumPossibleInteger() const { return isSigned() ?
u256((u256(1) << m_bits) - 1):
u256((u256(1) << m_bits));
}
bigint minValue() const; bigint minValue() const;
bigint maxValue() const; bigint maxValue() const;
@ -365,13 +361,17 @@ public:
virtual TypePointer encodingType() const override { return shared_from_this(); } virtual TypePointer encodingType() const override { return shared_from_this(); }
virtual TypePointer interfaceType(bool) const override { return shared_from_this(); } virtual TypePointer interfaceType(bool) const override { return shared_from_this(); }
/// Number of bits used for this type in total.
int numBits() const { return m_totalBits; } int numBits() const { return m_totalBits; }
/// Number of decimal digits after the radix point.
int fractionalDigits() const { return m_fractionalDigits; } int fractionalDigits() const { return m_fractionalDigits; }
bool isSigned() const { return m_modifier == Modifier::Signed; } bool isSigned() const { return m_modifier == Modifier::Signed; }
u256 maximumPossibleInteger() const { return isSigned() ? /// @returns the largest integer value this type con hold. Note that this is not the
u256(((u256(1) << m_totalBits) - 1) / (pow(bigint(10), m_fractionalDigits))): /// largest value in general.
u256(((u256(1) << m_totalBits)) / (pow(bigint(10), m_fractionalDigits))); bigint maxIntegerValue() const;
} /// @returns the smallest integer value this type can hold. Note hat this is not the
/// smallest value in general.
bigint minIntegerValue() const;
private: private:
int m_totalBits; int m_totalBits;

2
libsolidity/parsing/Token.cpp
View File

@ -70,7 +70,7 @@ void ElementaryTypeNameToken::assertDetails(Token::Value _baseType, unsigned con
else if (_baseType == Token::UFixedMxN || _baseType == Token::FixedMxN) else if (_baseType == Token::UFixedMxN || _baseType == Token::FixedMxN)
{ {
solAssert( solAssert(
_first <= 256 && _first % 8 == 0 && _second >= 0 && _second <= 80, _first >= 8 && _first <= 256 && _first % 8 == 0 && _second <= 80,
"No elementary type " + string(Token::toString(_baseType)) + to_string(_first) + "x" + to_string(_second) + "." "No elementary type " + string(Token::toString(_baseType)) + to_string(_first) + "x" + to_string(_second) + "."
); );
} }

156
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -2290,6 +2290,9 @@ BOOST_AUTO_TEST_CASE(test_fromElementaryTypeName)
BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::BytesM, 30, 0)) == *make_shared<FixedBytesType>(30)); BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::BytesM, 30, 0)) == *make_shared<FixedBytesType>(30));
BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::BytesM, 31, 0)) == *make_shared<FixedBytesType>(31)); BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::BytesM, 31, 0)) == *make_shared<FixedBytesType>(31));
BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::BytesM, 32, 0)) == *make_shared<FixedBytesType>(32)); BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::BytesM, 32, 0)) == *make_shared<FixedBytesType>(32));
BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::Fixed, 0, 0)) == *make_shared<FixedPointType>(128, 19, FixedPointType::Modifier::Signed));
BOOST_CHECK(*Type::fromElementaryTypeName(ElementaryTypeNameToken(Token::UFixed, 0, 0)) == *make_shared<FixedPointType>(128, 19, FixedPointType::Modifier::Unsigned));
} }
BOOST_AUTO_TEST_CASE(test_byte_is_alias_of_byte1) BOOST_AUTO_TEST_CASE(test_byte_is_alias_of_byte1)
@ -4033,7 +4036,7 @@ BOOST_AUTO_TEST_CASE(invalid_fixed_types_0x7_mxn)
fixed0x7 a = .3; fixed0x7 a = .3;
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, DeclarationError, "Identifier not found");
} }
BOOST_AUTO_TEST_CASE(invalid_fixed_types_long_invalid_identifier) BOOST_AUTO_TEST_CASE(invalid_fixed_types_long_invalid_identifier)
@ -4043,7 +4046,7 @@ BOOST_AUTO_TEST_CASE(invalid_fixed_types_long_invalid_identifier)
fixed99999999999999999999999999999999999999x7 b = 9.5; fixed99999999999999999999999999999999999999x7 b = 9.5;
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, DeclarationError, "Identifier not found");
} }
BOOST_AUTO_TEST_CASE(invalid_fixed_types_7x8_mxn) BOOST_AUTO_TEST_CASE(invalid_fixed_types_7x8_mxn)
@ -4053,7 +4056,7 @@ BOOST_AUTO_TEST_CASE(invalid_fixed_types_7x8_mxn)
fixed7x8 c = 3.12345678; fixed7x8 c = 3.12345678;
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, DeclarationError, "Identifier not found");
} }
BOOST_AUTO_TEST_CASE(library_instances_cannot_be_used) BOOST_AUTO_TEST_CASE(library_instances_cannot_be_used)
@ -4067,7 +4070,7 @@ BOOST_AUTO_TEST_CASE(library_instances_cannot_be_used)
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "Member \"l\" not found or not visible after argument-dependent lookup in library L");
} }
BOOST_AUTO_TEST_CASE(invalid_fixed_type_long) BOOST_AUTO_TEST_CASE(invalid_fixed_type_long)
@ -4079,7 +4082,7 @@ BOOST_AUTO_TEST_CASE(invalid_fixed_type_long)
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, DeclarationError, "Identifier not found");
} }
BOOST_AUTO_TEST_CASE(fixed_type_int_conversion) BOOST_AUTO_TEST_CASE(fixed_type_int_conversion)
@ -4087,8 +4090,8 @@ BOOST_AUTO_TEST_CASE(fixed_type_int_conversion)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
uint128 a = 3; uint64 a = 3;
int128 b = 4; int64 b = 4;
fixed c = b; fixed c = b;
ufixed d = a; ufixed d = a;
c; d; c; d;
@ -4137,7 +4140,7 @@ BOOST_AUTO_TEST_CASE(invalid_int_implicit_conversion_from_fixed)
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "Type fixed128x19 is not implicitly convertible to expected type int256");
} }
BOOST_AUTO_TEST_CASE(rational_unary_operation) BOOST_AUTO_TEST_CASE(rational_unary_operation)
@ -4145,12 +4148,23 @@ BOOST_AUTO_TEST_CASE(rational_unary_operation)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed16x2 a = +3.25; ufixed16x2 a = 3.25;
fixed16x2 b = -3.25; fixed16x2 b = -3.25;
a; b;
} }
} }
)"; )";
CHECK_WARNING(text,"Use of unary + is deprecated"); CHECK_SUCCESS_NO_WARNINGS(text);
text = R"(
contract test {
function f() {
ufixed16x2 a = +3.25;
fixed16x2 b = -3.25;
a; b;
}
}
)";
CHECK_WARNING(text, "Use of unary + is deprecated");
text = R"( text = R"(
contract test { contract test {
function f(uint x) { function f(uint x) {
@ -4167,10 +4181,11 @@ BOOST_AUTO_TEST_CASE(leading_zero_rationals_convert)
char const* text = R"( char const* text = R"(
contract A { contract A {
function f() { function f() {
ufixed16x8 a = 0.5; ufixed16x2 a = 0.5;
ufixed256x56 b = 0.0000000000000006661338147750939242541790008544921875; ufixed256x52 b = 0.0000000000000006661338147750939242541790008544921875;
fixed16x8 c = -0.5; fixed16x2 c = -0.5;
fixed256x56 d = -0.0000000000000006661338147750939242541790008544921875; fixed256x52 d = -0.0000000000000006661338147750939242541790008544921875;
a; b; c; d;
} }
} }
)"; )";
@ -4188,6 +4203,7 @@ BOOST_AUTO_TEST_CASE(size_capabilities_of_fixed_point_types)
fixed256x1 d = -123456781234567979695948382928485849359686494864095409282048094275023098123.5; fixed256x1 d = -123456781234567979695948382928485849359686494864095409282048094275023098123.5;
fixed256x76 e = -0.93322335481643744342575580035176794825198893968114429702091846411734101080123; fixed256x76 e = -0.93322335481643744342575580035176794825198893968114429702091846411734101080123;
fixed256x79 g = -0.0001178860664374434257558003517679482519889396811442970209184641173410108012309; fixed256x79 g = -0.0001178860664374434257558003517679482519889396811442970209184641173410108012309;
a; b; c; d; e; g;
} }
} }
)"; )";
@ -4199,8 +4215,8 @@ BOOST_AUTO_TEST_CASE(zero_handling)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
fixed16x8 a = 0; fixed16x2 a = 0; a;
ufixed8x8 b = 0; ufixed32x1 b = 0; b;
} }
} }
)"; )";
@ -4213,11 +4229,11 @@ BOOST_AUTO_TEST_CASE(fixed_type_invalid_implicit_conversion_size)
contract test { contract test {
function f() { function f() {
ufixed a = 11/4; ufixed a = 11/4;
ufixed248x8 b = a; ufixed248x8 b = a; b;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "Type ufixed128x19 is not implicitly convertible to expected type ufixed248x8");
} }
BOOST_AUTO_TEST_CASE(fixed_type_invalid_implicit_conversion_lost_data) BOOST_AUTO_TEST_CASE(fixed_type_invalid_implicit_conversion_lost_data)
@ -4225,11 +4241,11 @@ BOOST_AUTO_TEST_CASE(fixed_type_invalid_implicit_conversion_lost_data)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed256x1 a = 1/3; ufixed256x1 a = 1/3; a;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "is not implicitly convertible to expected type ufixed256x1");
} }
BOOST_AUTO_TEST_CASE(fixed_type_valid_explicit_conversions) BOOST_AUTO_TEST_CASE(fixed_type_valid_explicit_conversions)
@ -4237,9 +4253,9 @@ BOOST_AUTO_TEST_CASE(fixed_type_valid_explicit_conversions)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed256x80 a = ufixed256x80(1/3); ufixed256x80 a = ufixed256x80(1/3); a;
ufixed248x80 b = ufixed248x80(1/3); ufixed248x80 b = ufixed248x80(1/3); b;
ufixed8x1 c = ufixed8x1(1/3); ufixed8x1 c = ufixed8x1(1/3); c;
} }
} }
)"; )";
@ -4251,11 +4267,11 @@ BOOST_AUTO_TEST_CASE(invalid_array_declaration_with_rational)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
uint[3.5] a; uint[3.5] a; a;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal");
} }
BOOST_AUTO_TEST_CASE(invalid_array_declaration_with_signed_fixed_type) BOOST_AUTO_TEST_CASE(invalid_array_declaration_with_signed_fixed_type)
@ -4263,11 +4279,11 @@ BOOST_AUTO_TEST_CASE(invalid_array_declaration_with_signed_fixed_type)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
uint[fixed(3.5)] a; uint[fixed(3.5)] a; a;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal");
} }
BOOST_AUTO_TEST_CASE(invalid_array_declaration_with_unsigned_fixed_type) BOOST_AUTO_TEST_CASE(invalid_array_declaration_with_unsigned_fixed_type)
@ -4275,11 +4291,11 @@ BOOST_AUTO_TEST_CASE(invalid_array_declaration_with_unsigned_fixed_type)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
uint[ufixed(3.5)] a; uint[ufixed(3.5)] a; a;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal");
} }
BOOST_AUTO_TEST_CASE(rational_to_bytes_implicit_conversion) BOOST_AUTO_TEST_CASE(rational_to_bytes_implicit_conversion)
@ -4287,11 +4303,11 @@ BOOST_AUTO_TEST_CASE(rational_to_bytes_implicit_conversion)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
bytes32 c = 3.2; bytes32 c = 3.2; c;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "is not implicitly convertible to expected type bytes32");
} }
BOOST_AUTO_TEST_CASE(fixed_to_bytes_implicit_conversion) BOOST_AUTO_TEST_CASE(fixed_to_bytes_implicit_conversion)
@ -4300,11 +4316,11 @@ BOOST_AUTO_TEST_CASE(fixed_to_bytes_implicit_conversion)
contract test { contract test {
function f() { function f() {
fixed a = 3.25; fixed a = 3.25;
bytes32 c = a; bytes32 c = a; c;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "fixed128x19 is not implicitly convertible to expected type bytes32");
} }
BOOST_AUTO_TEST_CASE(mapping_with_fixed_literal) BOOST_AUTO_TEST_CASE(mapping_with_fixed_literal)
@ -4351,7 +4367,7 @@ BOOST_AUTO_TEST_CASE(inline_array_rationals)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed16x3[4] memory a = [3.5, 4.125, 2.5, 4.0]; ufixed128x3[4] memory a = [ufixed128x3(3.5), 4.125, 2.5, 4.0];
} }
} }
)"; )";
@ -4368,7 +4384,7 @@ BOOST_AUTO_TEST_CASE(rational_index_access)
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "rational_const 1/2 is not implicitly convertible to expected type uint256");
} }
BOOST_AUTO_TEST_CASE(rational_to_fixed_literal_expression) BOOST_AUTO_TEST_CASE(rational_to_fixed_literal_expression)
@ -4376,9 +4392,9 @@ BOOST_AUTO_TEST_CASE(rational_to_fixed_literal_expression)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed8x8 a = 3.5 * 3; ufixed64x8 a = 3.5 * 3;
ufixed8x8 b = 4 - 2.5; ufixed64x8 b = 4 - 2.5;
ufixed16x8 c = 11 / 4; ufixed64x8 c = 11 / 4;
ufixed240x5 d = 599 + 0.21875; ufixed240x5 d = 599 + 0.21875;
ufixed256x80 e = ufixed256x80(35.245 % 12.9); ufixed256x80 e = ufixed256x80(35.245 % 12.9);
ufixed256x80 f = ufixed256x80(1.2 % 2); ufixed256x80 f = ufixed256x80(1.2 % 2);
@ -4399,7 +4415,7 @@ BOOST_AUTO_TEST_CASE(rational_as_exponent_value_signed)
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
} }
BOOST_AUTO_TEST_CASE(rational_as_exponent_value_unsigned) BOOST_AUTO_TEST_CASE(rational_as_exponent_value_unsigned)
@ -4411,7 +4427,7 @@ BOOST_AUTO_TEST_CASE(rational_as_exponent_value_unsigned)
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
} }
BOOST_AUTO_TEST_CASE(rational_as_exponent_half) BOOST_AUTO_TEST_CASE(rational_as_exponent_half)
@ -4419,11 +4435,11 @@ BOOST_AUTO_TEST_CASE(rational_as_exponent_half)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed24x24 b = 2 ** (1/2); 2 ** (1/2);
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
} }
BOOST_AUTO_TEST_CASE(rational_as_exponent_value_neg_quarter) BOOST_AUTO_TEST_CASE(rational_as_exponent_value_neg_quarter)
@ -4431,11 +4447,11 @@ BOOST_AUTO_TEST_CASE(rational_as_exponent_value_neg_quarter)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
fixed40x40 c = 42 ** (-1/4); 42 ** (-1/4);
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
} }
BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_15) BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_15)
@ -4443,23 +4459,11 @@ BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_15)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed a = 3 ** ufixed(1.5); var a = 3 ** ufixed(1.5);
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
}
BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_half)
{
char const* text = R"(
contract test {
function f() {
ufixed b = 2 ** ufixed(1/2);
}
}
)";
BOOST_CHECK(!success(text));
} }
BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_neg) BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_neg)
@ -4467,23 +4471,11 @@ BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_neg)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
fixed c = 42 ** fixed(-1/4); var c = 42 ** fixed(-1/4);
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
}
BOOST_AUTO_TEST_CASE(fixed_point_casting_exponents_neg_decimal)
{
char const* text = R"(
contract test {
function f() {
fixed d = 16 ** fixed(-0.5);
}
}
)";
BOOST_CHECK(!success(text));
} }
BOOST_AUTO_TEST_CASE(var_capable_of_holding_constant_rationals) BOOST_AUTO_TEST_CASE(var_capable_of_holding_constant_rationals)
@ -4531,11 +4523,11 @@ BOOST_AUTO_TEST_CASE(rational_bitnot_unary_operation)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
fixed a = ~3.5; ~fixed(3.5);
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "cannot be applied");
} }
BOOST_AUTO_TEST_CASE(rational_bitor_binary_operation) BOOST_AUTO_TEST_CASE(rational_bitor_binary_operation)
@ -4543,11 +4535,11 @@ BOOST_AUTO_TEST_CASE(rational_bitor_binary_operation)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
fixed a = 1.5 | 3; fixed(1.5) | 3;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
} }
BOOST_AUTO_TEST_CASE(rational_bitxor_binary_operation) BOOST_AUTO_TEST_CASE(rational_bitxor_binary_operation)
@ -4555,11 +4547,11 @@ BOOST_AUTO_TEST_CASE(rational_bitxor_binary_operation)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
fixed a = 1.75 ^ 3; fixed(1.75) ^ 3;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
} }
BOOST_AUTO_TEST_CASE(rational_bitand_binary_operation) BOOST_AUTO_TEST_CASE(rational_bitand_binary_operation)
@ -4567,11 +4559,11 @@ BOOST_AUTO_TEST_CASE(rational_bitand_binary_operation)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
fixed a = 1.75 & 3; fixed(1.75) & 3;
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "not compatible with types");
} }
BOOST_AUTO_TEST_CASE(missing_bool_conversion) BOOST_AUTO_TEST_CASE(missing_bool_conversion)
@ -4591,7 +4583,7 @@ BOOST_AUTO_TEST_CASE(integer_and_fixed_interaction)
char const* text = R"( char const* text = R"(
contract test { contract test {
function f() { function f() {
ufixed a = uint128(1) + ufixed(2); ufixed a = uint64(1) + ufixed(2);
} }
} }
)"; )";
@ -4621,7 +4613,7 @@ BOOST_AUTO_TEST_CASE(one_divided_by_three_integer_conversion)
} }
} }
)"; )";
BOOST_CHECK(!success(text)); CHECK_ERROR(text, TypeError, "is not implicitly convertible to expected type uint256. Try converting to type ufixed256x77");
} }
BOOST_AUTO_TEST_CASE(unused_return_value) BOOST_AUTO_TEST_CASE(unused_return_value)