PHP struggles with attributes syntax

PHP 8.0 is on the horizon, and the project has imposed a feature freeze for the release. There's one exception to the feature freeze, though: the new attributes syntax. An attribute is syntactical metadata for PHP code, identical to what is called an "annotation" in other languages. Even though attributes have been voted on multiple times by the community, major contributor and creator of XDebug Derick Rethans threw a wrench into the works days before the feature freeze by challenging the current syntax. The ensuing discussion lead to the fourth attributes proposal for the year, with a special feature freeze exception being made by release manager Sara Golemon. This exception gives Rethans one more opportunity to convince the community to change how attributes work up to the Beta 3 release, scheduled for September 3.

What are PHP attributes?

As said, attributes are metadata for code, and provide a way to attach metadata to classes, functions, object properties, and so on to add information that isn't necessarily relevant to the execution of that code (such as the name of the author responsible for writing a particular method). While they can be used strictly for informational purposes, attributes can also play an important role in the code itself — such as telling the PHP engine if a particular method should be compiled by the just-in-time compiler also coming in PHP 8.0. Currently, the idea of attributes in PHP takes the form of a pseudo-language implemented as multi-line comments known as DocBlocks. In PHP 8.0, the hope is to replace the need for these DocBlocks with a native attribute syntax that can be parsed by the PHP engine. These attributes would then be available to the PHP engine itself, as well as being made available to developers through PHP's reflection capabilities.

The idea of attributes in PHP is not a new concept; contributor Dmitry Stogov proposed it back in 2016 for PHP 7.1. After extensive discussion, this original proposal was not accepted. The concept of attributes was recently brought back to life for PHP 8.0 by Benjamin Eberlei with a new proposal based on Stogov's work. Eberlei went through considerable effort, according to his post, to update things based on the feedback from Stogov's failed attempt, writing at the time:

Eberlei was successful in getting his proposal accepted by a 51 to 1 vote in favor. Additionally, the PHP internals community voted on the syntax that these new attributes would use. They were asked to select between two choices: << >> and @:. Both choices allow for attributes to have function-like arguments that would also be parsed to be used in a yet-to-be-determined way. Here is an example of how these would look in code, taken from the proposal:

    /* Using the << >> syntax */

    <<WithoutArgument>>
    <<SingleArgument(0)>>
    <<FewArguments('Hello', 'World')>>
    function foo() { /* ... */}

    /* Using the @: syntax */

    @:WithoutArgument
    @:SingleArgument(0)
    @:FewArguments('Hello', 'World')
    function foo() { /* ... */

Ultimately, the community voted to accept the << >> syntax over @: in a 41 to 12 vote, and the matter was believed to be resolved.

The fight over syntax

Not all of the community was satisfied with the decision on syntax, however, and last month Theodore Brown (with Martin Schröder) published another proposal to change the syntax from the previously accepted << >> syntax to @@ or #[] as shown:

    /* Using the @@ syntax */

    @@FewArguments('Hello', 'World')
    function foo() { /* ... */}

    /* Using the #[] syntax */

    #[FewArguments('Hello', 'World')]
    Function foo() { /* ... */ }

In the proposal, Brown itemized several faults he found with the accepted attribute syntax, among them were: its verbosity, its inability to support nested attributes, its dissimilarity with other languages that implement similar constructs, and potential confusion with bit-shifting operations.

The proposal included a vote to first decide if a change should even be considered, followed by a ranked-choice vote on the preference for the new syntax. The options provided by the proposal for the new syntax were: << >> (the original), @@, or #[]. Brown's proposal passed with a 50 to 8 vote in favor of changing the syntax. The top choice for the new syntax was @@, followed by << >>, and finally #[]. Brown's proposal succeeded in changing the syntax to @@, and again the community moved forward, believing the matter to be resolved. As of the first alpha versions of PHP 8.0, the @@ syntax for attributes remained — until Rethans interjected. Rethans decided to throw the aforementioned wrench into the works with an email to internals on July 22 (less than two weeks before the PHP 8.0 feature freeze) entitled "The @@ is terrible, are we sure we're OK with it?":

In the discussion that followed, Brown pushed back against yet another vote on syntax and challenged Rethans's complaints:

As for Rethans's suggestion to use the #[] syntax, Brown further pointed out that the proposal had already been made and rejected:

Ultimately, release manager for PHP 8.0, Sara Golemon, weighed in on the matter and challenged Rethans to back up his claims that the syntax would lead to "further parsing issues". With PHP 8.0 feature freeze scheduled less than two weeks away, Golemon said she needed "something more substantial than 'it maybe breaks something somewhere somehow'" to consider revisiting attribute syntax. Golemon did seem to give Rethans the benefit of the doubt regarding these parser issues, however, saying "I'm not doubting that there is one, you're quite clever, but at the moment you're stating facts not currently in evidence."

After what appears to have been conversations that took place outside of the regular internals mailing list, Golemon followed up on her post to share what she had learned regarding Rethans's supposed parser issues:

In the lengthy conversation that followed, which included Golemon suggesting that attributes be removed from PHP 8.0 and moved to PHP 8.1, she decided to give everyone time to sort out the mess:

Where does that leave attributes?

The PHP 8.0 feature freeze happened as scheduled; in the meantime, Rethans (with the help of contributor Joe Ferguson) submitted yet another proposal for attribute syntax. According to Ferguson:

PHP_CodeSniffer is a static-analysis tool for PHP to detect and correct violations of coding standards within a PHP code base. As might be expected, Brown continued to argue against another change with support from others. In contrast, other longstanding members of the PHP internals community like Paul M. Jones seem to be uninterested with re-voting on the matter. In response to the new proposal, Jones wrote:

Ultimately Eberlei, as the original proposer of the implementation of attributes that the community accepted, managed to find common ground between the parties by offering a rather complicated solution using the single transferable vote (STV) system:

Both Rethans and Ferguson agreed with Eberlei's suggestion and updated the proposal to reflect the proposed voting matrix. Meanwhile, the community is waiting for the release managers to make a decision on Eberlei's suggestion. With Rethans on board, it is unlikely the release managers will stand in the way. Unfortunately for everyone, however, the conflict over the syntax of attributes has left a significant language feature slated for PHP 8.0 up in the air for the time being. The general consensus is that no one in the community wants the feature to be delayed until PHP 8.1, but preventing that delay will require a meeting of the minds that has been elusive on this issue — only time will tell where things end up.