Why Does Wrapping a Function Call in Parentheses Avoid a Reference Error in PHP?

Ambiguous Function Call Behavior in PHP: Unveiling the Hidden Nuance

In PHP, a peculiar behavior arises when invoking a function and encapsulating its result within parentheses. This seemingly innocuous action can alter the interpretation of the result, potentially leading to unexpected behavior.

Consider the following code snippet:

error_reporting(E_ALL | E_STRICT);

function get_array() {
   return array();
}

function foo() {
   return reset(get_array()); // Error: "Only variables should be passed by reference"

   return reset((get_array())); // Success
}

foo();

In the first variant, attempting to assign the result of get_array() to the reset() function triggers an error, as it should be a variable passed by reference. However, when we wrap the function call in parentheses, the script runs successfully.

While one might speculate about the underlying mechanics, a thorough examination of the documentation fails to provide an explicit explanation for this phenomenon.

Delving deeper into the intricacies of the PHP grammar and using tools like phc to visualize the code's AST revealed that both snippets result in identical parse trees. This eliminates the possibility of syntactic alterations influencing the behavior.

However, a closer inspection of the PHP opcode structure reveals a hidden caveat within the ZEND_SEND_VAR_NO_REF opcode. This opcode dictates that a reference error should not be thrown when the argument is not a function call and has a reference count of 1.

In the second variant of foo(), the function call is no longer recognized due to the added parentheses. As a result, the system classifies the argument as an expr_without_variable and initiates the SEND_VAR_NO_REF opcode. Since the returned array has a reference count of 1, it is deemed suitable as a variable, thus avoiding the reference error.

It is important to note that this behavior should be regarded as a bug and not an intended feature. Relying on such inconsistencies can lead to unpredictable and unreliable code.

The above is the detailed content of Why Does Wrapping a Function Call in Parentheses Avoid a Reference Error in PHP?. For more information, please follow other related articles on the PHP Chinese website!