Simplify ConstantEvaluator.

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;
+	auto sub = type(_operation.subExpression());
-	if (!dynamic_cast<RationalNumberType const*>(subType.get()))
+	if (sub)
-		return;
+		setType(_operation, sub->unaryOperatorResult(_operation.getOperator()));
-	TypePointer t = subType->unaryOperatorResult(_operation.getOperator());
-	_operation.annotation().type = t;
 }
 
-/// FIXME: this is pretty much a copy of TypeChecker::endVisit(BinaryOperation)
 void ConstantEvaluator::endVisit(BinaryOperation const& _operation)
 {
-	TypePointer const& leftType = _operation.leftExpression().annotation().type;
+	auto left = type(_operation.leftExpression());
-	TypePointer const& rightType = _operation.rightExpression().annotation().type;
+	auto right = type(_operation.rightExpression());
-	if (!dynamic_cast<RationalNumberType const*>(leftType.get()))
+	if (left && right)
-		return;
-	if (!dynamic_cast<RationalNumberType const*>(rightType.get()))
-		return;
-	TypePointer commonType = leftType->binaryOperatorResult(_operation.getOperator(), rightType);
-	if (!commonType)
 	{
-		m_errorReporter.typeError(
+		auto commonType = left->binaryOperatorResult(_operation.getOperator(), right);
+		if (!commonType)
+			m_errorReporter.fatalTypeError(
 				_operation.location(),
 				"Operator " +
 				string(Token::toString(_operation.getOperator())) +
 				" not compatible with types " +
-			leftType->toString() +
+				left->toString() +
 				" and " +
-			rightType->toString()
+				right->toString()
 			);
-		commonType = leftType;
+		setType(
-	}
+			_operation,
-	_operation.annotation().commonType = commonType;
-	_operation.annotation().type =
 			Token::isCompareOp(_operation.getOperator()) ?
 			make_shared<BoolType>() :
-		commonType;
+			left->binaryOperatorResult(_operation.getOperator(), right)
+		);
+	}
 }
 
 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;
-
+	else if (!m_types->count(value.get()))
-	if (!value->annotation().type)
 	{
 		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);
 }

libsolidity/analysis/ConstantEvaluator.h

@@ -38,22 +38,32 @@ class TypeChecker;
 class ConstantEvaluator: private ASTConstVisitor
 {
 public:
-	ConstantEvaluator(Expression const& _expr, ErrorReporter& _errorReporter, size_t _newDepth = 0):
+	ConstantEvaluator(
+		ErrorReporter& _errorReporter,
+		size_t _newDepth = 0,
+		std::shared_ptr<std::map<ASTNode const*, TypePointer>> _types = std::make_shared<std::map<ASTNode const*, TypePointer>>()
+	):
 		m_errorReporter(_errorReporter),
-		m_depth(_newDepth)
+		m_depth(_newDepth),
+		m_types(_types)
 	{
-		_expr.accept(*this);
 	}
 
+	TypePointer evaluate(Expression const& _expr);
+
 private:
 	virtual void endVisit(BinaryOperation const& _operation);
 	virtual void endVisit(UnaryOperation const& _operation);
 	virtual void endVisit(Literal const& _literal);
 	virtual void endVisit(Identifier const& _identifier);
 
+	void setType(ASTNode const& _node, TypePointer const& _type);
+	TypePointer type(ASTNode const& _node);
+
 	ErrorReporter& m_errorReporter;
 	/// Current recursion depth.
-	size_t m_depth;
+	size_t m_depth = 0;
+	std::shared_ptr<std::map<ASTNode const*, TypePointer>> m_types;
 };
 
 }

libsolidity/analysis/ReferencesResolver.cpp

@@ -146,9 +146,10 @@ void ReferencesResolver::endVisit(ArrayTypeName const& _typeName)
 		fatalTypeError(_typeName.baseType().location(), "Illegal base type of storage size zero for array.");
 	if (Expression const* length = _typeName.length())
 	{
-		if (!length->annotation().type)
+		TypePointer lengthTypeGeneric = length->annotation().type;
-			ConstantEvaluator e(*length, m_errorReporter);
+		if (!lengthTypeGeneric)
-		auto const* lengthType = dynamic_cast<RationalNumberType const*>(length->annotation().type.get());
+			lengthTypeGeneric = ConstantEvaluator(m_errorReporter).evaluate(*length);
+		RationalNumberType const* lengthType = dynamic_cast<RationalNumberType const*>(lengthTypeGeneric.get());
 		if (!lengthType || !lengthType->mobileType())
 			fatalTypeError(length->location(), "Invalid array length, expected integer literal or constant expression.");
 		else if (lengthType->isFractional())

test/libsolidity/SolidityNameAndTypeResolution.cpp

@@ -7370,7 +7370,7 @@ BOOST_AUTO_TEST_CASE(array_length_cannot_be_constant_function_parameter)
 			}
 		}
 	)";
-	CHECK_ERROR(text, TypeError, "Constant identifier declaration must have a constant value.");
+	CHECK_ERROR(text, TypeError, "Invalid array length, expected integer literal or constant expression.");
 }
 
 BOOST_AUTO_TEST_CASE(array_length_with_cyclic_constant)