Changing a Readonly Property

So, you know how readonly properties are, well… read-only? Turns out they’re not!

I stumbled upon this mechanism just as PHP started deprecating it — but hey, if you ignore the deprecation warnings, you can still use it up until PHP 9!

A bit of theory first: readonly properties can only be assigned inside a class constructor. After that, they’re supposed to be immutable.
final readonly class ReadonlyClass
{
public string $someProp;

public function __construct()
{
$this->someProp = 'unchangeable!';
}
}

The only official way to set such a property outside the constructor is via reflection — but even then, only if the property hasn’t been initialized yet:
final readonly class ReadonlyClass
{
public string $someProp;
}
$test = new ReadonlyClass();
$reflection = new ReflectionClass(ReadonlyClass::class)->getProperty('someProp');
$reflection->setValue($test, 'changed once!');
var_dump($test->someProp);
$reflection->setValue($test, 'changed twice?');
This produces the predictable result:
string(13) "changed once!"

Fatal error: Uncaught Error: Cannot modify readonly property ReadonlyClass::$someProp

Changing It Multiple Times

Enough stalling — let’s dive in! The magical object that can modify a readonly property (and much more) is ArrayObject.

Normally, you’d use ArrayObject to wrap an array. But it also accepts any object as the backing value — and that’s where the fun begins. Once you know how PHP stores properties internally (which is actually pretty simple), chaos follows.

Let’s start with this class:
final readonly class ReadonlyClass
{
public string $someProp;
private string $somePrivateProp;
protected string $someProtectedProp;

public function __construct()
{
$this->someProp = 'unchangeable?';
$this->somePrivateProp = 'unchangeable?';
$this->someProtectedProp = 'unchangeable?';
}

public function getSomePrivateProp(): string
{
return $this->somePrivateProp;
}

public function getSomeProtectedProp(): string
{
return $this->someProtectedProp;
}
}
Now we create an instance and wrap it in an ArrayObject:
$instance = new ReadonlyClass();
$arrayObj = new ArrayObject($instance);

And now comes the fun part:
// simply use the property name for public properties
$arrayObj['someProp'] = 'changeable public!';
// use "\0[FQN]\0[Property name]" for private properties
$arrayObj["\0ReadonlyClass\0somePrivateProp"] = 'changeable private!';
// use "\0*\0[Property name]" for protected properties
$arrayObj["\0*\0someProtectedProp"] = 'changeable protected!';

var_dump($instance->someProp, $instance->getSomePrivateProp(), $instance->getSomeProtectedProp());
This prints:
string(18) "changeable public!"
string(19) "changeable private!"
string(21) "changeable protected!"
And just like that, you’ve changed an unchangeable property. You can modify it as many times as you want. So… what other arcane tricks are possible?

Changing an Enum Value

Enums are basically fancy objects that represent a specific named instance — optionally with a value. The key difference from old userland implementations is that PHP guarantees every enum case is a unique instance that’s always equal to itself, no matter where it’s referenced from.

In other words, an enum is really just an object, and ->value or ->name are plain properties.
enum MyEnum: string {
case A = 'a';
case B = 'b';
}

$arrayObj = new ArrayObject(MyEnum::A);
$arrayObj['value'] = 'b';
$arrayObj['name'] = 'C';

var_dump(MyEnum::A->value);
var_dump(MyEnum::A->name);
This prints exactly what you’d expect after reading the previous example:
string(1) "b"
string(1) "C"
Even more amusing: Running var_dump(MyEnum::A); now prints enum(MyEnum::C).

It won’t actually make it equal to another enum case, but if you use the value somewhere and reconstruct it using MyEnum::from(), you’ll get back MyEnum::B.

If you try to serialize and deserialize it, you’ll get an error — because MyEnum::C doesn’t exist:
var_dump(MyEnum::from(MyEnum::A->value));
var_dump(unserialize(serialize(MyEnum::A)));
The first prints enum(MyEnum::B), while the second throws a warning: Undefined constant MyEnum::C.

Breaking Types

ArrayObject is so powerful that even the type system trembles before it. Types? Mere suggestions!
final class TestTypedClass
{
public string $str = 'test';
public bool $bool = true;
public int $int = 42;
}

$instance = new TestTypedClass();
$arrayObj = new ArrayObject($instance);

$arrayObj['str'] = 5;
$arrayObj['bool'] = 'hello';
$arrayObj['int'] = new stdClass();

var_dump($instance->str, $instance->bool, $instance->int);
Output:
int(5)
string(5) "hello"
object(stdClass)#3 (0) {
}
So if you ever thought “Hmm, this boolean could really use more than two possible values” — now you know how!

Dynamic Properties Everywhere

Some internal classes like Closure, Generator, and DateTime disallow dynamic properties. Nevermore!
$closure = fn () => true;
$arrayObject = new ArrayObject($closure);
$arrayObject['test'] = 'hello';

var_dump($closure->test);
// prints string(5) "hello"

Crashing PHP

And finally — my favourite one! Ever wanted to cause a segmentation fault? Try this:
$exception = new Exception("Hello there!");
$arrayObject = new ArrayObject($exception);
$arrayObject["\0Exception\0trace"] = -1;

var_dump($exception->getTraceAsString());
That gave me one beautiful Segmentation fault (core dumped)!

So, how did you like these all-powerful ArrayObject shenanigans?

Xdebug Update: October 2025
Original Post

In this update I explain what happened with Xdebug development in the last two months.

GitHub and Pro/Business supporters will get it earlier, around the first of each month.

In the last months, I spend around 35 hours on Xdebug, with 44 hours funded.

Xdebug 3.4

In the last installment I wrote about a problem with Lazy Objects. Since then, a user managed to provide a short reproducible case which illustrates the problem. With that, I managed to fix this specific bug and a related one.

These bug fixes also made it into a new release, Xdebug 3.4.7.

After this was released, a user reported two more bugs (#2376, #2377) with regards to Lazy Objects, so I will have to do more work here for a next bug fix release.

PHP 8.5

Most of the time this month I spent on making Xdebug PHP 8.5 ready, and finalising Native Path Mapping.

I have added PHP 8.5 to the Windows CI test runners, but I am still running into some issue where some tests don't seem to work. I haven't quite figured out why these suddenly fail with PHP 8.5, but not with 8.4.

I did fix a bug with regards to changes in PHP 8.5's glob feature. With PHP 8.5 being released soon, I hope to have this sorted before that release happens.

Native Path Mapping

The Xdebug 3.5.0alpha2 release, that came out at the beginning of October, has the first preview for PHP 8.5, with Native Path Mapping support. Documentation is still missing, as well as a minor issue with mapping on Windows, due to its different path separator (/ vs \\).

Beyond that issue, the native path mapping's basic functionality seems to work.

There are a few minor things to do when looking at the project plan, but these might have to wait for Xdebug 3.5.1 (or later).

Xdebug Videos

I have created no new videos in the last months.

All Xdebug videos can be watched on my channel.

If you have any suggestions, feel free to reach out to me on Mastodon or via email.

Business Supporter Scheme and Funding

On GitHub sponsors, I am currently 41% towards my $2,500 per month goal, which is set to allow continued of Xdebug.

If you are leading a team or company, then it is also possible to support Xdebug through a subscription.

In the last month, no new business supporters signed up.

Besides business support, I also maintain a Patreon page, a profile on GitHub sponsors, as well as an OpenCollective organisation.

If you want to contribute to specific projects, you can find those on the Projects page.

Xdebug Cloud

Xdebug Cloud is the Proxy As A Service platform to allow for debugging in more scenarios, where it is hard, or impossible, to have Xdebug make a connection to the IDE. It is continuing to operate as Beta release.

Packages start at £49/month, and I have recently introduced a package for larger companies. This has a larger initial set of tokens, and discounted extra tokens.

If you want to be kept up to date with Xdebug Cloud, please sign up to the mailing list, which I will use to send out an update not more than once a month.