A better workaround is, of course, to just define the 
member with "var" in the class header.

But it's still a bug IMHO.

Thank you for taking the time to write to us, but this is not
a bug. Please double-check the documentation available at
http://www.php.net/manual/ and the instructions on how to report
a bug at http://bugs.php.net/how-to-report.php

Sorry, it's not in the manual..

http://de.php.net/manual/en/language.oop5.overloading.php

Please re-classify as "documentation issue" at least, if you're sure that it really is not a bug..

It's not in the manual, because it's obvious - your __get() method does nothing, so you get nothing as the result.

Ok. But haven't you seen the comment in __get()?

Here's another testcase, just returning an array now 
always and with further output, when __get() gets called:


Description:
------------
When using "array creating syntax" (like $a[] or $a[1]), 
__get() does not seem to work correctly, IF the var has 
not been defined using the "var" key for the class.

Reproduce code:
---------------
<?php

class A
{
        function __get($v)
        {
                // note: even returning array() here won't 
fix it  
        }
}


$A = new A();

$A->foo[1] = 1;
var_dump( $A->foo );

$A->foo[] = 2;
var_dump( $A->foo );

$A->foo['a'] = 3;
var_dump( $A->foo );

$A->foo = array();
var_dump( $A->foo );

$A->foo = 1;
var_dump( $A->foo );

?>

Expected result:
----------------
__get: foo
array(1) {
  1 => 1
}
array(2) {
  1 => 1,
  2 => 2
}
array(0) {
  1 => 1,
  2 => 2,
  'a' => 3
}
array(0) {
}
int(1)


Actual result:
--------------
__get: foo
__get: foo
array(0) {
}
__get: foo
__get: foo
array(0) {
}
__get: foo
__get: foo
array(0) {
}
array(0) {
}
int(1)

Yes, I did see the comment. 
The point is that with $A->foo[] = 1; you call __get() first, which returns NULL and you modify this temporary variable. That happens because we need to get the array itself to be able to add an element, but to create a variable directly (like $A->foo = 1) this is not needed.

Sorry, to reopen it again.

The "Reproduce code" in the comment above was wrong.

I've let it return "array()" always and this changes the 
output, so that it is "array()" instead of "NULL".

But still: the array does not get changed!

I've written a comment for Bug 39426, which seems to 
suffer from something related, but cannot post it, because 
it's bogus.. :/

I've already explained everything, just read my previous comment carefully.

Ok. I've even slept over it.

Why should this not work?

---------------------------------
<?php
class A
{
        function __get($v)
        {
                if( isset($this->var) )
                        return $this->var;
                return array();
        }
}


$A = new A();

$A->foo[] = 1;
var_dump( $A->foo );
?>
---------------------------------

It prints:
array(0) {
}

Your comment, which I've reread carefully, does not 
explain it. The temp var from __get() is first array and 
later the $var itself.

Adding a __set() method to the class shows that this does 
not get called at all.

Re: I've also said it before.. it works, if the var is set 
in the constructor. To see the diff:

------------------------------------
<?php
class A
{
        private $vars;
        function __get($v)
        {
                if( isset($this->vars[$v]) )
                        return $this->vars[$v];
                return array();
        }

        function __set($v, $vv)
        {
                echo "__set: '$v'\n";
                var_dump($vv);
                $this->vars[$v] = $vv;
        }
}

class B extends A
{
        var $foo;
}


$A = new A();
$B = new B();

echo "A: ----------------\n";
$A->foo[] = 1;
var_dump( $A->foo );

echo "B: ----------------\n";
$B->foo[] = 1;
var_dump( $B->foo );
?>
-----------------------------------

Result:
-------
A: ----------------
array(0) {
}
B: ----------------
array(1) {
  [0]=>
  int(1)
}

Thank you for taking the time to write to us, but this is not
a bug. Please double-check the documentation available at
http://www.php.net/manual/ and the instructions on how to report
a bug at http://bugs.php.net/how-to-report.php

Notice: Indirect modification of overloaded property A::$foo 
has no effect.

This is why the assignment has no effect.

iliaa, thanks for taking the time to look at this.

Unfortunately I don't understand your note. A::$foo is 
overloaded in class B and there it shows the IMHO correct 
behaviour (because in class B there's "var $foo").

The expected result in the last code example would have 
been:
A: ----------------
array(1) {
  [0]=>
  int(1)
}
B: ----------------
array(1) {
  [0]=>
  int(1)
}

instead of:

A: ----------------
array(0) {
}
B: ----------------
array(1) {
  [0]=>
  int(1)
}

foo property is not actually created, hence the warning.

ilia, which warning are you talking about? There's no 
(PHP) warning?!

All I want to say is: overloading of arrays by 
e.g. "$Foo->bar[] = 1" does not work, if $bar is not 
defined as a member in the class definition (without a 
value, of course).

Ilia is talking about this warning:
Notice: Indirect modification of overloaded property A::$foo has no effect

I cannot believe that I've not seen the Notice before, but 
now I do. Sorry.