Allow enums in interfaces

Changelog.md

@@ -69,6 +69,7 @@ Language Features:
  * General: Allow appending ``calldata`` keyword to types, to explicitly specify data location for arguments of external functions.
  * General: Support ``pop()`` for storage arrays.
  * General: Scoping rules now follow the C99-style.
+ * General: Allow ``enum``s in interfaces.
 
 Compiler Features:
  * C API (``libsolc``): Export the ``solidity_license``, ``solidity_version`` and ``solidity_compile`` methods.

libsolidity/analysis/TypeChecker.cpp

@@ -751,13 +751,6 @@ bool TypeChecker::visit(VariableDeclaration const& _variable)
 	return false;
 }
 
-bool TypeChecker::visit(EnumDefinition const& _enum)
-{
-	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
-		m_errorReporter.typeError(_enum.location(), "Enumerable cannot be declared in interfaces.");
-	return false;
-}
-
 void TypeChecker::visitManually(
 	ModifierInvocation const& _modifier,
 	vector<ContractDefinition const*> const& _bases

libsolidity/analysis/TypeChecker.h

@@ -96,7 +96,6 @@ class TypeChecker: private ASTConstVisitor
 	virtual bool visit(StructDefinition const& _struct) override;
 	virtual bool visit(FunctionDefinition const& _function) override;
 	virtual bool visit(VariableDeclaration const& _variable) override;
-	virtual bool visit(EnumDefinition const& _enum) override;
 	/// We need to do this manually because we want to pass the bases of the current contract in
 	/// case this is a base constructor call.
 	void visitManually(ModifierInvocation const& _modifier, std::vector<ContractDefinition const*> const& _bases);

test/libsolidity/SolidityEndToEndTest.cpp

@@ -4577,6 +4577,50 @@ BOOST_AUTO_TEST_CASE(constructing_enums_from_ints)
 	ABI_CHECK(callContractFunction("test()"), encodeArgs(1));
 }
 
+BOOST_AUTO_TEST_CASE(enum_referencing)
+{
+	char const* sourceCode = R"(
+		interface I {
+			enum Direction { A, B, Left, Right }
+		}
+		library L {
+			enum Direction { Left, Right }
+			function f() public pure returns (Direction) {
+				return Direction.Right;
+			}
+			function g() public pure returns (I.Direction) {
+				return I.Direction.Right;
+			}
+		}
+		contract C is I {
+			function f() public pure returns (Direction) {
+				return Direction.Right;
+			}
+			function g() public pure returns (I.Direction) {
+				return I.Direction.Right;
+			}
+			function h() public pure returns (L.Direction) {
+				return L.Direction.Right;
+			}
+			function x() public pure returns (L.Direction) {
+				return L.f();
+			}
+			function y() public pure returns (I.Direction) {
+				return L.g();
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "L");
+	ABI_CHECK(callContractFunction("f()"), encodeArgs(1));
+	ABI_CHECK(callContractFunction("g()"), encodeArgs(3));
+	compileAndRun(sourceCode, 0, "C", bytes(), map<string, Address>{{"L", m_contractAddress}});
+	ABI_CHECK(callContractFunction("f()"), encodeArgs(3));
+	ABI_CHECK(callContractFunction("g()"), encodeArgs(3));
+	ABI_CHECK(callContractFunction("h()"), encodeArgs(1));
+	ABI_CHECK(callContractFunction("x()"), encodeArgs(1));
+	ABI_CHECK(callContractFunction("y()"), encodeArgs(3));
+}
+
 BOOST_AUTO_TEST_CASE(inline_member_init)
 {
 	char const* sourceCode = R"(

test/libsolidity/syntaxTests/nameAndTypeResolution/422_interface_enums.sol

@@ -2,4 +2,3 @@ interface I {
     enum A { B, C }
 }
 // ----
-// TypeError: (18-33): Enumerable cannot be declared in interfaces.

test/libsolidity/syntaxTests/parsing/enum_from_interface.sol

@@ -0,0 +1,9 @@
+interface I {
+    enum Direction { Left, Right }
+}
+
+contract D {
+    function f() public pure returns (I.Direction) {
+      return I.Direction.Left;
+    }
+}

test/libsolidity/syntaxTests/parsing/enum_from_interface_in_library.sol

@@ -0,0 +1,12 @@
+interface I {
+    enum Direction { Left, Right }
+}
+
+library L {
+    function f() public pure returns (I.Direction) {
+      return I.Direction.Left;
+    }
+    function g() internal pure returns (I.Direction) {
+      return I.Direction.Left;
+    }
+}

test/libsolidity/syntaxTests/parsing/enum_from_library.sol

@@ -0,0 +1,9 @@
+library L {
+    enum Direction { Left, Right }
+}
+
+contract D {
+    function f() public pure returns (L.Direction) {
+      return L.Direction.Left;
+    }
+}

test/libsolidity/syntaxTests/parsing/enum_inheritance_contract.sol

@@ -0,0 +1,9 @@
+contract C {
+    enum Direction { Left, Right }
+}
+
+contract D is C {
+    function f() public pure returns (Direction) {
+      return Direction.Left;
+    }
+}

test/libsolidity/syntaxTests/parsing/enum_inheritance_interface.sol

@@ -0,0 +1,9 @@
+interface I {
+    enum Direction { Left, Right }
+}
+
+contract D is I {
+    function f() public pure returns (Direction) {
+      return Direction.Left;
+    }
+}