This bug has been fixed in SVN.

Snapshots of the sources are packaged every three hours; this change
will be in the next snapshot. You can grab the snapshot at
http://snaps.php.net/.
 
Thank you for the report, and for helping us make PHP better.

Will you backport this bugfix to PHP 5.3.2 branch?
Otherwise the behavior will be really odd due to presence of this bug.

Can you explain me, please, why this is not fixed in 5.3.2 stable?

"Thank you for the report, and for helping us make PHP better."
You are intentionally making PHP worse!

Hello!
This isn't my decision, but the release manager.

Thanks.

Hello, I've reverted the wrong changes introduced by trying to fix the issue reported, but actually there is no bug at all. self::bar(), static::bar() and foo::bar() are being called in an object context, hence the __call() is called.

I.e.
$foo->start(); // invoke the __call method
foo::start(); // invoke the __callStatic method

Thanks.

You cannot call foo::start(), because the method is non-static and therefore it does not make sense.

Also, self, static and class name are used to call methods statically, not in a object context.
For calling method bar in object context, I think '$this->' should be used instead.

Obviously parent should not behave this way and respect context, but I think it should be the only exception (as shown in #52713).

Sorry by realive this topic, but I really think that it is a bug.

If I want call "bar" with context, the correct mean is $this->bar(). Else, the 
"static" sounds for me like "call without context". I'm wrong?

Please, read this topic to understand what I'm saying: 
http://stackoverflow.com/questions/6181603/php-is-handling-incorrectly-my-static-
call

This is ridiculous- this bug is not bogus, it's completely legitimate, unexpected 
behavior, and totally non documented. As a reasonable programmer, one expects a 
static call to behave the same inside of a class as well as outside of a class.

How can we bring the "desired" behavior up for vote? I think that it's insane to 
not fix it.

For me, the real issue is to understand the :: operator, if you do, this is absolutely 
no bug, but consistent and wanted behaviour.

To sum it all up, the :: operator tries to call the method in the current context 
(static vs. non-static) whenever possible and assumes that the current context was 
meant for non-existing methods.

----------

In details, the :: operator, does the following:

In a non-static context:

(1) Operand 1 is the context's class (via name, static or self)
	(a) if the method is (defined) non-static, it is called non-static in the 
current context
	(b) if the method is (defined) static, it is called static
	(c) if the method is not defined and __call is defined in the context’s class, 
__call is called (in the context’s class)

(2) Operand 1 is a parent class of the context's class (via name or parent)
	(a) if the method is (defined) non-static, it is called non-static in the 
current context
	(b) if the method is (defined) static, it is called static
	(c) if the method is not defined and __call is defined in the context’s class, 
a fatal error is issued
	(d) if the method is not defined and __call is defined in the parent’s class, 
__call is called (in the parent’s class)
	(e) if the method is not defined and __call is defined in the context’s class 
and in the parent’s class, __call is called in the context’s class

(3) Operand 1 is a class not related to the context
	(a) if the method is (defined) non-static, it is called non-static in the 
current context (additionally a strict standards warning is issued)
	(b) if the method is (defined) static, it is called static
	(c) if the method is not defined and __callStatic is defined in the not related 
class, __callStatic is called (in the not related class)

Observations:

(I) 2c and 2e are inconsistent. In 2c PHP wants to handle the issue in the parent 
class, whereas in 2e suddenly the issue is handled in the context’s class. I fail to 
see consistent arguments here explaining both situations.

In a static context:

(1) Operand 1 is the context’s class (via name, static or self)
	(a) if the method is (defined) static, it is called static
	(b) if the method is (defined) non-static, it is called static (additionally a 
strict standards warning is issued)
	(c) if the method is not defined and __callStatic is defined in the context’s 
class, __callStatic is called (in the context’s class)

(2) Operand 1 is a parent class of the context’s class (via name or parent)
	(a) if the method is (defined) static, it is called static
	(b) if the method is (defined) non-static, it is called static (additionally a 
strict standards warning is issued)
	(c) if the method is not defined and __callStatic is defined in the context’s 
class, a fatal error is issued
	(d) if the method is not defined and __callStatic is defined in the parent’s 
class, __callStatic is called (in the parent’s class)
	(e) if the method is not defined and __callStatic is defined in the context’s 
and in the parent’s class, __call is called in the parent’s class

(3) Operand 1 is a class not related to the context
	(a) if the method is (defined) static, it is called static
	(b) if the method is (defined) non-static, it is called static (additionally a 
strict standards warning is issued)
	(c) if the method is not defined and __callStatic is defined in the not related 
class, __callStatic is called (in the not related class)

Observations:

(I) As compared to the non-static context, 2c and 2e are consistent.

This is a real badass bug. Please explain why is this behaviour considered expected?

Perhaps this behavior seems logical, although I don't understand why the :: operator in a non-static context should refer to non-static methods. But then answer the question: how do I call __callStatic in this context? After all, no one has provided such an opportunity