Proposal: abstract constants

[Lenald]

Description

User Story

As a PHP developer, I want to be able to declare abstract constants inside a class so that I can enforce their implementation in subclasses, either by their own implementation or through interface implementation. This will allow me to safely and more obvious use late static binding to reference these constants within the class and ensure their proper implementation in subclasses.

Behavior

If an abstract constant is not implemented in a subclass, either on its own or through interface implementation, then the subclass should be declared as abstract. Otherwise, a fatal error should be thrown during class loading or instance creation, with a message such as “Fatal error: Class [ClassName] contains N abstract constant(s) and must therefore be declared abstract or implement the remaining constants ([AbstractConstantName]) in [ClassFilePath] on line [LineNumberOfError]”. Direct reads of abstract constants should also trigger a fatal error with a message such as “Fatal error: Direct read of abstract constant [ClassName]::[AbstractConstantName] in [ClassFilePath] on line [LineNumberOfError]”. When an abstract constant is declared, its value should not be set, similar to how abstract methods are declared.

Purposes

This feature would be useful to enforce the implementation of a constant in subclasses, without the need for workarounds such as declaring this constant in the parent class with a default value and checking for overrides in the subclass.

Example Code

<?php

abstract class Parent
{
    abstract public const SOMETHING;

    public function foo(): string
    {
        echo static::SOMETHING . PHP_EOL;
    }
}

class ChildImplementsOnTheirOwn extends Parent
{
    public const SOMETHING = 'Implemented by Child class';
}

interface SomethingInterface
{
    public const SOMETHING = 'Implemented by Interface';
}

class ChildImplementsByInterface extends Parent implements SomethingInterface
{
}

class NotImplemented
{
}

Parent::SOMETHING; //Fatal: Direct read of abstract

ChildImplementsOnTheirOwn::SOMETHING; //'Implemented by Child class'
(new ChildImplementsOnTheirOwn())->foo(); //'Implemented by Child class'

SomethingInterface::SOMETHING; //'Implemented by Interface'
ChildImplementsByInterface::SOMETHING; //'Implemented by Interface'
(new ChildImplementsByInterface())->foo(); //'Implemented by Interface'

NotImplemented::SOMETHING; //Fatal: Must implement or be declared as abstract
$notImplemented = new NotImplemented(); //Fatal: Must implement or be declared as abstract
(new NotImplemented())->foo(); //Fatal: Must implement or be declared as abstract (must be thrown already from __construct())

[iluuu1994]

Hi! I personally don't see a particular need for this. IMO class constants have already been "OOP'd" too much (in that they can change in sub-classes). The same can be achieved with abstract methods. But my opinion aside, as this is a language change it would require an RFC. https://wiki.php.net/rfc/howto Is that something you're interested in? The first step would be writing an e-mail to the mailing list to see if this is something people are interested in.

[Girgias]

You can already kinda force child classes to implement a class by using a self referenced constant: https://3v4l.org/KujvH

class P {
    public const NEED_IMPLEMENTATION = self::NEED_IMPLEMENTATION;
}

class C extends P {
    
}

$o = new C;

However, this will only cause an Error during instantiation.

[github-actions]

There has not been any recent activity in this feature request. It will automatically be closed in 14 days if no further action is taken. Please see https://github.com/probot/stale#is-closing-stale-issues-really-a-good-idea to understand why we auto-close stale feature requests.

[Arkemlar]

How many times I had to declare abstract getClassName() functions or something similar. This would be a nice replacement, static declaration and kind of neat.