Fix boost::rational comparison bug with gcc < 14 and C++20

Use explicit .operator==() calls to avoid infinite recursion in rational-to-integer comparisons caused by symmetric operator overload resolution bug

Author: clonker

.circleci/config.yml

@@ -1901,10 +1901,10 @@ workflows:
       # build-only
       - b_docs: *requires_nothing
       - b_ubu_ossfuzz: *requires_nothing
-      - b_ubu_2204: *requires_nothing
       - b_ubu_2204_clang: *requires_nothing
 
-      # Ubuntu 22.04 boost::rational bug repro test
+      # build and test on ubuntu 22.04
+      - b_ubu_2204: *requires_nothing
       - t_ubu_2204_soltest:
           <<: *on_all_tags_and_branches
           requires:

Changelog.md

@@ -7,6 +7,7 @@ Compiler Features:
 
 Bugfixes:
 * Assembler: Fix not using a fixed-width type for IDs being assigned to subassemblies nested more than one level away, resulting in inconsistent `--asm-json` output between target architectures.
+* General: Fix boost::rational comparison bug with gcc < 14 and C++20 that leads to infinite recursion.
 * Yul Optimizer: Fix edge case in which invalid Yul code is produced by ExpressionSimplifier due to expressions being substituted that contain out-of-scope variables.
 
 ### 0.8.30 (2025-05-07)

libsolidity/analysis/ConstantEvaluator.cpp

@@ -92,12 +92,12 @@ std::optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operato
 	case Token::Sub: return _left - _right;
 	case Token::Mul: return _left * _right;
 	case Token::Div:
-		if (_right == rational(0))
+		if (_right.operator==(rational(0)))
 			return std::nullopt;
 		else
 			return _left / _right;
 	case Token::Mod:
-		if (_right == rational(0))
+		if (_right.operator==(rational(0)))
 			return std::nullopt;
 		else if (fractional)
 		{
@@ -117,9 +117,9 @@ std::optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operato
 		// for 0, 1 and -1 the size of the exponent doesn't have to be restricted
 		if (exp == 0)
 			return 1;
-		else if (_left == 0 || _left == 1)
+		else if (_left.operator==(0) || _left.operator==(1))
 			return _left;
-		else if (_left == -1)
+		else if (_left.operator==(-1))
 		{
 			bigint isOdd = abs(exp) & bigint(1);
 			return 1 - 2 * isOdd.convert_to<int>();

libsolidity/analysis/DeclarationTypeChecker.cpp

@@ -347,7 +347,7 @@ void DeclarationTypeChecker::endVisit(ArrayTypeName const& _typeName)
 				length->location(),
 				"Invalid array length, expected integer literal or constant expression."
 			);
-		else if (*lengthValue == 0)
+		else if (lengthValue->operator==(0))
 			m_errorReporter.typeError(1406_error, length->location(), "Array with zero length specified.");
 		else if (lengthValue->denominator() != 1)
 			m_errorReporter.typeError(3208_error, length->location(), "Array with fractional length specified.");

libsolidity/analysis/StaticAnalyzer.cpp

@@ -317,7 +317,7 @@ bool StaticAnalyzer::visit(BinaryOperation const& _operation)
 		ConstantEvaluator::evaluate(m_errorReporter, _operation.leftExpression())
 	)
 		if (auto rhs = ConstantEvaluator::evaluate(m_errorReporter, _operation.rightExpression()))
-			if (rhs->value == 0)
+			if (rhs->value.operator==(0))
 				m_errorReporter.typeError(
 					1211_error,
 					_operation.location(),
@@ -338,7 +338,7 @@ bool StaticAnalyzer::visit(FunctionCall const& _functionCall)
 			solAssert(_functionCall.arguments().size() == 3, "");
 			if (*_functionCall.arguments()[2]->annotation().isPure)
 				if (auto lastArg = ConstantEvaluator::evaluate(m_errorReporter, *(_functionCall.arguments())[2]))
-					if (lastArg->value == 0)
+					if (lastArg->value.operator==(0))
 						m_errorReporter.typeError(
 							4195_error,
 							_functionCall.location(),

libsolidity/ast/Types.cpp

@@ -932,7 +932,7 @@ std::tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _li
 			value = std::get<1>(mantissa);
 
 			// 0E... is always zero.
-			if (value == 0)
+			if (value.operator==(0))
 				return std::make_tuple(true, rational(0));
 
 			bigint exp = bigint(std::string(expPoint + 1, valueString.end()));
@@ -1033,7 +1033,7 @@ BoolResult RationalNumberType::isImplicitlyConvertibleTo(Type const& _convertTo)
 		return fitsIntoBits(value.numerator(), targetType.numBits(), targetType.isSigned());
 	}
 	case Category::FixedBytes:
-		return (m_value == rational(0)) || (m_compatibleBytesType && *m_compatibleBytesType == _convertTo);
+		return (m_value.operator==(rational(0))) || (m_compatibleBytesType && *m_compatibleBytesType == _convertTo);
 	default:
 		return false;
 	}
@@ -1048,7 +1048,7 @@ BoolResult RationalNumberType::isExplicitlyConvertibleTo(Type const& _convertTo)
 	if (category == Category::FixedBytes)
 		return false;
 	else if (auto addressType = dynamic_cast<AddressType const*>(&_convertTo))
-		return (m_value == 0) ||
+		return (m_value.operator==(0)) ||
 			((addressType->stateMutability() != StateMutability::Payable) &&
 			!isNegative() &&
 			!isFractional() &&

libsolidity/ast/Types.h

@@ -627,7 +627,7 @@ class RationalNumberType: public Type
 	bool isNegative() const { return m_value < 0; }
 
 	/// @returns true if the value is zero.
-	bool isZero() const { return m_value == 0; }
+	bool isZero() const { return m_value.operator==(0); }
 
 	/// @returns true if the literal is a valid integer.
 	static std::tuple<bool, rational> isValidLiteral(Literal const& _literal);

libsolidity/experimental/analysis/TypeInference.cpp

@@ -980,7 +980,7 @@ std::optional<rational> rationalValue(Literal const& _literal)
 			value = *mantissa;
 
 			// 0E... is always zero.
-			if (value == 0)
+			if (value.operator==(0))
 				return std::nullopt;
 
 			bigint exp = bigint(std::string(expPoint + 1, valueString.end()));