This is somewhat expected, a call to foo::bar() from a non-static context will be a non-static call, unless the function is explicitly defined as static. 

However, some of this(especially the part about calling a "static method" from/to an invalid context) is scheduled for cleanup.

Actually, in this particular case, it's completely expected.

Class A {
  public function foo() {

  }
}

class B extends A {
  public function bar() {
    parent::foo(); // normal call
    static::foo(); // normal call as well
    A::foo(); // same here...
  }
}

$b = new B; $b->bar();

Now, for BC purposes, it would probably break things if those call suddenly stop calling __call in case A::foo() wasn't defined, which how it currently works in PHP 5.

I see your problem that "it would probably break things". But when i'm calling a static method with static::coolMethod() i would expect that this is __always__ a static call, why using the object context when it can't be used in the static methods either?

In your example i would expect an Error that the foo() method of class A can't be called statically.

You're misunderstanding the meaning of static::foo();

it doesn't mean "call foo statically" but rather "use runtime information to get the class currently called", and do a static(or not) call to the method of that class.

It's similar to
$name = get_called_class(); $name::foo();

For more information:
php.net/language.oop5.late-static-bindings

ok, i see... what about the following fallback alternative for a call like A::foo()

1. if method foo() in class A exists, call it, if not -> 2
2. if method __callstatic() implemented, call it, if not -> 3
3. if method __call implemented, call it, if not -> 4
4. fatal error

and there you have compatibility for php < 5.3.

For me A::foo() looks like a static call. Or do you really think it always must follow the context? In my opinion, when calling a method in the same style from different contexts, it isn't __always__ good that they aren't treated the same...