Merge pull request #11628 from ethereum/noOverrideForInterface

Add override exception for interface functions.

Author: chriseth

Changelog.md

@@ -1,6 +1,7 @@
 ### 0.8.8 (unreleased)
 
 Language Features:
+ * Inheritance: A function that overrides only a single interface function does not require the ``override`` specifier.
 
 
 Compiler Features:

docs/contracts/inheritance.rst

@@ -303,6 +303,13 @@ contracts can no longer change the behaviour of that function.
   outside of interfaces. In interfaces, all functions are
   automatically considered ``virtual``.
 
+.. note::
+
+  Starting from Solidity 0.8.8, the ``override`` keyword is not
+  required when overriding an interface function, except for the
+  case where the function is defined in multiple bases.
+
+
 Public state variables can override external functions if the
 parameter and return types of the function matches the getter function
 of the variable:

docs/contracts/interfaces.rst

@@ -33,10 +33,10 @@ Interfaces are denoted by their own keyword:
 
 Contracts can inherit interfaces as they would inherit other contracts.
 
-All functions declared in interfaces are implicitly ``virtual``, which means that
-they can be overridden. This does not automatically mean that an overriding function
-can be overridden again - this is only possible if the overriding
-function is marked ``virtual``.
+All functions declared in interfaces are implicitly ``virtual`` and any
+functions that override them do not need the ``override`` keyword.
+This does not automatically mean that an overriding function can be overridden again -
+this is only possible if the overriding function is marked ``virtual``.
 
 Interfaces can inherit from other interfaces. This has the same rules as normal
 inheritance.

libsolidity/analysis/OverrideChecker.cpp

@@ -86,7 +86,8 @@ struct OverrideGraph
 		int currentNode = static_cast<int>(numNodes++);
 		nodes[_function] = currentNode;
 		nodeInv[currentNode] = _function;
-		if (_function.overrides())
+
+		if (!_function.baseFunctions().empty())
 			for (auto const& baseFunction: _function.baseFunctions())
 				addEdge(currentNode, visit(baseFunction));
 		else
@@ -518,7 +519,7 @@ void OverrideChecker::checkOverride(OverrideProxy const& _overriding, OverridePr
 			"Override changes modifier signature."
 		);
 
-	if (!_overriding.overrides())
+	if (!_overriding.overrides() && !(_super.isFunction() && _super.contract().isInterface()))
 		overrideError(
 			_overriding,
 			_super,

test/libsolidity/syntaxTests/inheritance/interface/overrides_multiple.sol

@@ -23,8 +23,6 @@ interface Sub is SuperA, SuperB {
 }
 
 // ----
-// TypeError 9456: (572-616): Overriding function is missing "override" specifier.
-// TypeError 9456: (572-616): Overriding function is missing "override" specifier.
 // TypeError 4327: (572-616): Function needs to specify overridden contracts "SuperA" and "SuperB".
 // TypeError 4327: (647-655): Function needs to specify overridden contracts "SuperA" and "SuperB".
 // TypeError 4327: (705-721): Function needs to specify overridden contract "SuperB".

test/libsolidity/syntaxTests/inheritance/interface/overrides_single.sol

@@ -11,4 +11,3 @@ interface Sub is Super {
 }
 
 // ----
-// TypeError 9456: (197-241): Overriding function is missing "override" specifier.

test/libsolidity/syntaxTests/inheritance/override/calldata_memory_interface.sol

@@ -6,9 +6,9 @@ interface I {
 }
 contract C is I {
     uint dummy;
-    function f(uint[] memory) public override pure {}
-    function g(uint[] memory) public override view { dummy; }
-    function h(uint[] memory) public override { dummy = 42; }
-    function i(uint[] memory) public override payable {}
+    function f(uint[] memory) public pure {}
+    function g(uint[] memory) public view { dummy; }
+    function h(uint[] memory) public { dummy = 42; }
+    function i(uint[] memory) public payable {}
 }
 // ----

test/libsolidity/syntaxTests/inheritance/override/calldata_memory_interface_instantiate.sol

@@ -2,7 +2,7 @@ interface I {
     function f(uint[] calldata) external pure;
 }
 contract A is I {
-    function f(uint[] memory) public override pure {}
+    function f(uint[] memory) public pure {}
 }
 contract C {
     function f() public {

test/libsolidity/syntaxTests/inheritance/override/calldata_memory_interface_struct.sol

@@ -9,8 +9,8 @@ interface I {
 contract C is I {
     uint dummy;
     function f(S memory) public override pure {}
-    function g(S memory) public override view { dummy; }
+    function g(S memory) public view { dummy; }
     function h(S memory) public override { dummy = 42; }
-    function i(S memory) public override payable {}
+    function i(S memory) public payable {}
 }
 // ----

test/libsolidity/syntaxTests/inheritance/override/change_return_types_in_interface.sol

@@ -7,5 +7,4 @@ contract B is I {
   function f() public pure returns (uint, uint) {}
 }
 // ----
-// TypeError 9456: (182-230): Overriding function is missing "override" specifier.
 // TypeError 4822: (182-230): Overriding function return types differ.