From 2b8235269221cacbcf9beb793d969c451b1927a3 Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Sat, 8 Jul 2017 20:27:28 -0300
Subject: [PATCH] Disallow non-pure constant state variables in 0.5.0

---
 Changelog.md                                  |  1 +
 libsolidity/analysis/TypeChecker.cpp          | 19 +++++++++---
 .../SolidityNameAndTypeResolution.cpp         | 31 ++++++++++++++++---
 3 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index 81f0b3a6f..8ebc30d05 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -3,6 +3,7 @@
 Features:
  * Parser: Better error message for unexpected trailing comma in parameter lists.
  * Syntax Checker: Unary ``+`` is now a syntax error as experimental 0.5.0 feature.
+ * Type Checker: Disallow non-pure constant state variables as experimental 0.5.0 feature.
 
 Bugfixes:
  * Parser: Fix source location of VariableDeclarationStatement.
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index d45e9e899..b2a880595 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -645,14 +645,23 @@ bool TypeChecker::visit(VariableDeclaration const& _variable)
 			if (!allowed)
 				m_errorReporter.typeError(_variable.location(), "Constants of non-value type not yet implemented.");
 		}
+
 		if (!_variable.value())
 			m_errorReporter.typeError(_variable.location(), "Uninitialized \"constant\" variable.");
 		else if (!_variable.value()->annotation().isPure)
-			m_errorReporter.warning(
-				_variable.value()->location(),
-				"Initial value for constant variable has to be compile-time constant. "
-				"This will fail to compile with the next breaking version change."
-			);
+		{
+			if (_variable.sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::V050))
+				m_errorReporter.typeError(
+					_variable.value()->location(),
+					"Initial value for constant variable has to be compile-time constant."
+				);
+			else
+				m_errorReporter.warning(
+					_variable.value()->location(),
+					"Initial value for constant variable has to be compile-time constant. "
+					"This will fail to compile with the next breaking version change."
+				);
+		}
 	}
 	if (!_variable.isStateVariable())
 	{
diff --git a/test/libsolidity/SolidityNameAndTypeResolution.cpp b/test/libsolidity/SolidityNameAndTypeResolution.cpp
index 8b1122579..c60ccaf89 100644
--- a/test/libsolidity/SolidityNameAndTypeResolution.cpp
+++ b/test/libsolidity/SolidityNameAndTypeResolution.cpp
@@ -2361,17 +2361,28 @@ BOOST_AUTO_TEST_CASE(assigning_value_to_const_variable)
 	CHECK_ERROR(text, TypeError, "Cannot assign to a constant variable.");
 }
 
-BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable)
+BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable_0_4_x)
 {
 	char const* text = R"(
 		contract C {
 			address constant x = msg.sender;
 		}
 	)";
-	// Change to TypeError for 0.5.0.
 	CHECK_WARNING(text, "Initial value for constant variable has to be compile-time constant.");
 }
 
+BOOST_AUTO_TEST_CASE(assigning_state_to_const_variable)
+{
+	char const* text = R"(
+		pragma experimental "v0.5.0";
+
+		contract C {
+			address constant x = msg.sender;
+		}
+	)";
+	CHECK_ERROR(text, TypeError, "Initial value for constant variable has to be compile-time constant.");
+}
+
 BOOST_AUTO_TEST_CASE(constant_string_literal_disallows_assignment)
 {
 	char const* text = R"(
@@ -2388,7 +2399,7 @@ BOOST_AUTO_TEST_CASE(constant_string_literal_disallows_assignment)
 	CHECK_ERROR(text, TypeError, "Index access for string is not possible.");
 }
 
-BOOST_AUTO_TEST_CASE(assign_constant_function_value_to_constant)
+BOOST_AUTO_TEST_CASE(assign_constant_function_value_to_constant_0_4_x)
 {
 	char const* text = R"(
 		contract C {
@@ -2396,10 +2407,22 @@ BOOST_AUTO_TEST_CASE(assign_constant_function_value_to_constant)
 			uint constant y = x();
 		}
 	)";
-	// Change to TypeError for 0.5.0.
 	CHECK_WARNING(text, "Initial value for constant variable has to be compile-time constant.");
 }
 
+BOOST_AUTO_TEST_CASE(assign_constant_function_value_to_constant)
+{
+	char const* text = R"(
+		pragma experimental "v0.5.0";
+
+		contract C {
+			function () constant returns (uint) x;
+			uint constant y = x();
+		}
+	)";
+	CHECK_ERROR(text, TypeError, "Initial value for constant variable has to be compile-time constant.");
+}
+
 BOOST_AUTO_TEST_CASE(assignment_to_const_var_involving_conversion)
 {
 	char const* text = R"(