= new without $value creates it twice. Hooked object.

[ACEx86]

Description

The following code:

<?php
$B = new B;
$B->A = new A;
Class B
{
    Final Object $A{
        get => $this->A;
        set(Object $value) => new A;
    }
}

Class A
{
    public function __construct()
    {
        echo 'A'.PHP_EOL;
    }
}

Resulted in this output:

A
A

But I expected this output instead:

A

In the hooked variable set with = to new A instead of value will call it twice.
If object is not equal to calling value don't do actions.

PHP Version

PHP 8.5.1 (cli) (built: Dec 16 2025 18:26:57) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.5.1, Copyright (c) Zend Technologies
    with Zend OPcache v8.5.1, Copyright (c), by Zend Technologies

Operating System

No response

[iluuu1994]

I don't understand your description, but consider the example with a conventional getter/setter. https://3v4l.org/N6Lqq#veol Maybe that will help you understand what is happening. Anyway, the example doesn't look like a bug, A\nA is what I'd expect.

[ACEx86]

You try to set the object A to be the classes A object.
The $value of the hooked object is the call for the new A so no setting the object that you try to set with the $value so the call for new A shouldn't call new A.
Ignoring the $value from the setter function is not using it, so not doing the equal signs so not calling the new A.
I did = to something not executed it and this is also visible if i do $this->A = $value; that won't do the call twice.

[ACEx86]

@derickr xdebug/xdebug#1024

[ACEx86]

In this case doing new A is like executing code directly or executing code from inside the variable statement.
The = whatever if not applied should be ignored or if it is the same things optimised out.

[iluuu1994]

That's not how the feature is specified. set(Object $value) => new A; will always ignore the RHS of the assignment, and set the value to new A. That's almost certainly not what you want.

[ACEx86]

I don't get what you mean by That's almost certainly not what you want.
What i don't want, is before the variable is set $this->A=$value the class to be assigned to something, in that case seems like it is the value of the objects setter. But that was ignored from a set statement =.
= haven't apllied and the $value was ignored so why execing the constructor when we don't try to set the object variable that set the value but the object it self.
Also the variable that we try to set is not the $value object of the Variable Object but the variable object itself.

[ACEx86]

We set this->blah to something not the hooked parameters variables. This isn't a function call.
Yes this is passed if in the setter, the assigned value is equal to caller ( = new Blah ) but when we do $a = new Blah we try to set $a to new blah no the setters caller variable to new Blah (so not the set Object $value { }).
So if from setter we ignore the action that we try to do ( = new Blah ) and do something else then because we called it with = new Blah it shouldn't just execute.

[ACEx86]

It can be optimised if trying to set the same thing or have some shadow properties to not execute anything before assignment completed for being able to do things like $value instanceof.

[MorganLOCode]

I still don't see what the bug is supposed to be. Two distinct A objects are being created.

The first in the assignment statement. This has to be created because it's the value of the assignment expression itself and happens before there is any attempt to set $B's property. (in $q = $B->A = new A, what should the value of $q be?). It has to be created first so that there is something to assign.

Then in $B's setter, that first instance of A is ignored (whoever wrote the setter chose to ignore it by not using $value for some inadequately-explained reason) and instead a second instance of A is created and assigned to the property.

I don't see any justification for simply ignoring what was actually written (Ignore the code in the assignment because the value it creates gets thrown away later? Ignore the code in the setter because it doesn't use the passed-in value?).

[Answer to the question: it contains the first-created instance of A]

$q = $B->A = new A;

echo $q === $B->A ? 'same object' : 'different objects';

[ACEx86]

The completion of set of the variable is happening inside the setter and for this the example is this->whatever = $value; that came from $this->whatever = new A;

If the setting is no completed so the call to set object to class object why executing the __constructor?
What we try to do is set the object to a value when we set this $this->whatever = new A; not the objects setter to a value. and this isn't just a function call. is an object setting operation by equals sign.
(Ignore the code in the assignment because the value it creates gets thrown away later?) no ignore the $value of assignment because we don't try to set it but another value to an assignment. Ignore the code in the setter because it doesn't use the passed-in value?). ofc because we don't try to set each reference value to something but it to something and this is visible also by the code calling it. $this->whatever = new A;

Doing $q = $this->whatever = new A; is a different scope. You try to set $q to the value not just $B->A to the value.
The difference is that we haven't written $q = = we wrote only 1 statement.
That the value should be this. If it failed what would have happened?

[ACEx86]

Because php created a fake reference to pass the execution of the original statement.
I don't think that it should call an execution of the __constructor only from the reference if it was not complete (it failed we never did succeded on doing $a = $b).
Because we try to do equals to something and that is not true at all as you see so why executing the constructor.
The logic is that we need this action $this->b = new A; to be executed, if it is not complete why executing A constructor since also on failure you won't do it.
You have the set hook, this action would have been completed if php did set $this-b to new A. no the reference to do it, to do so, so the setters object value.
$this->A without setter ok. $this->A with setter because it has object value it doesn't mean that the action we try to perform is complete that is setting this->A to something. so why setting the value of it so the reference and executing before the action that we try to do is complete.
We don't try to set the reference value so the call to do the action so that ( $value ) but the action we perform.
Yes this is the reference so the way to get all of this but the action we try to perform is not setting it, but setting the original variable to something.
So $a = new and $b = $a = new is different.
At one of this i clearly only try to do one thing only.

[MorganLOCode]

The first construction has to happen before the assignment is attempted so that the assignment operation has a value to assign.

If, inside the setter, you choose to ignore that value and perform a second construction instead then that's your decision.

You have the set hook, this action would have been completed if php did set $this-b to new A.

And it did. Right there in that line set(Object $value) => new A;. The setter did exactly what you asked of it. How is that a failure?

If you want the setter to use the same object that you construct in the assignment then your setter should be

set(Object $value) => $value;

i.e., actually use the value that you passed in to it rather than ignore it.

Here's your code again, with bits added to report each object's internal ID number, and a check to see that $B->A was successfully set to an instance of A. Whether it's the instance you wanted it to be set to or not isn't clear from your explanations.

<?php
Class B
{
    Final Object $A{
        get => $this->A;
        set(Object $value) => new A;
    }
}

Class A
{
    public function __construct()
    {
        echo 'A:'.spl_object_id($this).PHP_EOL;
    }
}

$B = new B;
echo 'B:'.spl_object_id($B).PHP_EOL;
$B->A = new A;

echo get_class($B->A);

Again: you call new A twice (once in the assignment operation, and once in the setter), and so two instances of A get constructed. You throw the first one away almost immediately but, again, that's your choice.

If you want PHP to do an analysis of all your setters to confirm that $value actually gets used at some point and report some sort of error if it isn't, then that is a lot of work for very little payoff and in the general case isn't even computable. If you want PHP to ignore code that you have written, why bother to write it in the first place?

As it stands, PHP is handling the given code as intended and documented and this behaviour does not represent a bug in PHP.