Remove inappropriate inheritance signature checks on private methods View as Markdown

Introduction

Currently, a method with the same name as a parent's method, is still checked for some inheritance rules regardless of the parent's method visibility.

This leads to inheritance checks being executed even if the parent's method is private. Since private methods are not callable outside of the scope they are defined in, these rules should not be applied.

Some rules are already skipped like the number of arguments or their type, but other rules are still enforced. Namely:

• When a method has the same name as a parent's final private method
• When a method has the same name as a parent's static private method and the child's method is non-static, or vice-versa
• When a method has the same name as a parent's concrete private method and the child's method is abstract

The documentation explicitly states that only public and protected methods are inherited:

For example, when you extend a class, the subclass inherits all of the public and protected methods from the parent class. Unless a class overrides those methods, they will retain their original functionality.

Proposal

This RFC proposes removing these inappropriate inheritance checks that are still enforced in the case of the parent method being private.

In the current state:

<?php
 
class A 
{ 
    final private function finalPrivate() { 
        echo __METHOD__ . PHP_EOL; 
    } 
} 
 
class B extends A 
{ 
    private function finalPrivate() { 
        echo __METHOD__ . PHP_EOL; 
    } 
}

Produces:

Fatal error: Cannot override final method A::finalPrivate()

Besides the error occurring, the message mentions overriding which isn't applicable for private methods.

With the implementation of this RFC, the previous and the following code would compile correctly:

<?php
 
class A 
{ 
    function callYourPrivate() { 
        $this->myPrivate(); 
    }
 
    function notOverriden_callYourPrivate() {
        $this->myPrivate(); 
    } 
    final private function myPrivate() { 
        echo __METHOD__ . PHP_EOL;
    } 
}
 
class B extends A 
{ 
    function callYourPrivate() {
        $this->myPrivate(); 
    } 
    private function myPrivate() { 
        echo __METHOD__ . PHP_EOL; 
    } 
}
 
$a = new A(); 
$a->callYourPrivate(); 
$a->notOverriden_callYourPrivate();
 
$b = new B(); 
$b->callYourPrivate(); 
$b->notOverriden_callYourPrivate();  

And would produce:

Warning: Private methods cannot be final as they are never overridden by other classes in ...
A::myPrivate
A::myPrivate
B::myPrivate
A::myPrivate

The final keyword when applied to a private method should have no significance. In most cases, a correct approach is to use final protected modifiers in a function where overriding is not desired.

NOTE: Due to how common the usage of final private function __construct is and given that the same results cannot be achieved with a protected visibility, an exception to this rule is made for constructors. With this exception, they are the only case where a child class can't override a final private method.

Backward Incompatible Changes

The new compiler warning:

Warning: Private methods cannot be final as they are never overridden by other classes in ...

Will start appearing in some code bases where both modifiers final and private are used. However, given that an exception is made for the most common case final private function __construct, I believe the warning is useful to let users know about this change.

Proposed PHP Version(s)

PHP 8.0

Unaffected PHP Functionality

The inheritance rules for visible methods remains unaffected, including when these are static or declared on a trait.

Vote

Voting started 2020-06-15 and ends 2020-06-29.

Vote: Remove inappropriate inheritance signature checks on private methods — Yes: 24 · No: 11 (closed)

Patches and Tests

Implementation: https://github.com/php/php-src/pull/5401