Simplify ConstantEvaluator.

1 files changed, 43 insertions, 34 deletions

diff --git a/libsolidity/analysis/ConstantEvaluator.cpp b/libsolidity/analysis/ConstantEvaluator.cpp
index 7f5ffb51..14171b01 100644
--- a/libsolidity/analysis/ConstantEvaluator.cpp
+++ b/libsolidity/analysis/ConstantEvaluator.cpp
@@ -28,49 +28,42 @@ using namespace std;
 using namespace dev;
 using namespace dev::solidity;
 
-/// FIXME: this is pretty much a copy of TypeChecker::endVisit(BinaryOperation)
 void ConstantEvaluator::endVisit(UnaryOperation const& _operation)
 {
-	TypePointer const& subType = _operation.subExpression().annotation().type;
-	if (!dynamic_cast<RationalNumberType const*>(subType.get()))
-		return;
-	TypePointer t = subType->unaryOperatorResult(_operation.getOperator());
-	_operation.annotation().type = t;
+	auto sub = type(_operation.subExpression());
+	if (sub)
+		setType(_operation, sub->unaryOperatorResult(_operation.getOperator()));
 }
 
-/// FIXME: this is pretty much a copy of TypeChecker::endVisit(BinaryOperation)
 void ConstantEvaluator::endVisit(BinaryOperation const& _operation)
 {
-	TypePointer const& leftType = _operation.leftExpression().annotation().type;
-	TypePointer const& rightType = _operation.rightExpression().annotation().type;
-	if (!dynamic_cast<RationalNumberType const*>(leftType.get()))
-		return;
-	if (!dynamic_cast<RationalNumberType const*>(rightType.get()))
-		return;
-	TypePointer commonType = leftType->binaryOperatorResult(_operation.getOperator(), rightType);
-	if (!commonType)
+	auto left = type(_operation.leftExpression());
+	auto right = type(_operation.rightExpression());
+	if (left && right)
 	{
-		m_errorReporter.typeError(
-			_operation.location(),
-			"Operator " +
-			string(Token::toString(_operation.getOperator())) +
-			" not compatible with types " +
-			leftType->toString() +
-			" and " +
-			rightType->toString()
+		auto commonType = left->binaryOperatorResult(_operation.getOperator(), right);
+		if (!commonType)
+			m_errorReporter.fatalTypeError(
+				_operation.location(),
+				"Operator " +
+				string(Token::toString(_operation.getOperator())) +
+				" not compatible with types " +
+				left->toString() +
+				" and " +
+				right->toString()
+			);
+		setType(
+			_operation,
+			Token::isCompareOp(_operation.getOperator()) ?
+			make_shared<BoolType>() :
+			left->binaryOperatorResult(_operation.getOperator(), right)
 		);
-		commonType = leftType;
 	}
-	_operation.annotation().commonType = commonType;
-	_operation.annotation().type =
-		Token::isCompareOp(_operation.getOperator()) ?
-		make_shared<BoolType>() :
-		commonType;
 }
 
 void ConstantEvaluator::endVisit(Literal const& _literal)
 {
-	_literal.annotation().type = Type::forLiteral(_literal);
+	setType(_literal, Type::forLiteral(_literal));
 }
 
 void ConstantEvaluator::endVisit(Identifier const& _identifier)
@@ -84,13 +77,29 @@ void ConstantEvaluator::endVisit(Identifier const& _identifier)
 	ASTPointer<Expression> const& value = variableDeclaration->value();
 	if (!value)
 		return;
-
-	if (!value->annotation().type)
+	else if (!m_types->count(value.get()))
 	{
 		if (m_depth > 32)
 			m_errorReporter.fatalTypeError(_identifier.location(), "Cyclic constant definition (or maximum recursion depth exhausted).");
-		ConstantEvaluator e(*value, m_errorReporter, m_depth + 1);
+		ConstantEvaluator(m_errorReporter, m_depth + 1, m_types).evaluate(*value);
 	}
 
-	_identifier.annotation().type = value->annotation().type;
+	setType(_identifier, type(*value));
+}
+
+void ConstantEvaluator::setType(ASTNode const& _node, TypePointer const& _type)
+{
+	if (_type && _type->category() == Type::Category::RationalNumber)
+		(*m_types)[&_node] = _type;
+}
+
+TypePointer ConstantEvaluator::type(ASTNode const& _node)
+{
+	return (*m_types)[&_node];
+}
+
+TypePointer ConstantEvaluator::evaluate(Expression const& _expr)
+{
+	_expr.accept(*this);
+	return type(_expr);
 }