It is actually callable. But calling it statically breaks the strict standards, but the strict standards will break BC in many situations.

I would suggest to make this change in trunk only.

@pajoye: Yes, this particular example was callable. However, if the method is 
actually an instance method, and has references to $this, is_callable() still 
returns true -- making it an invalid test to use to determine whether or not it's 
safe to then call call_user_func(). Instead, to really determine if the callback 
is valid, you have to start doing a bunch of reflection -- checking to see if the 
method is defined and static, or if there is a __callStatic defined that would 
intercept the call.

That's the more serious implication of the behavior, and why it needs to be 
fixed.

The method can always be called statically. The access to $this might be forbidden but the method itself can be called. is_callable() doesn't mean it will execute properly. (the $this error is basically the same as a call to an undefined funciton in there or such)

To change this the only way would be to forbid calling non-static methods statically. Maybe this can be done nowadays (we needed the behavior for PHP 4 compatibility) but that's no bug but requires a RFC and discussion on internals as this might break quite a few applications (many PEAR-based things, many legacy applications not fully "converted" to PHP 5 ....)

@johannes Perhaps an optional "strict" flag to is_callable() would address this? 
That would keep BC, while allowing for better checking for >= PHP-5 apps. Usage 
would be:

$callback = array('Foo', 'bar');

if (is_callable($callback, true)) {
    // Passed strict check
} else {
    // failed strict check
}

Thoughts?

I don't like the optional flag idea. You can disable strictness using error_reporting already.

However I would like to see this change in trunk, can you come up with a RFC pls?

Another variation that actually (unexpectedly) works:
Calling is_callable and call_user_func from inside an instance (non-static) method using any of: 'self::otherInstanceMethod', array('self','otherInstanceMethod'), array(self,'otherInstanceMethod') succeed.  It appears that (the context for) '$this' is carried over from the original method, even though the calls are being done statically.

Calling self::otherInstanceMethod() directly also succeeds.  It appears that methods called from an instance method 'inherit' the context for $this.  A bit unexpected, but *reasonable*.
Win XP SP3
PHP 5.3.1 (xampp)

philduby at phriendly dot net : what you mention seems to be  another 
bug/misfeature.

<?php

/**
 * @author zhouw
 * @copyright 2010
 */

class Foo
{
    public function bar()
    {
        return 'foo bar';
    }
}

$callback = array('Foo', 'bar');
if (is_callable($callback)) {
    echo call_user_func($callback);
}

?>

我测试可以用的。

Let's first make important note that it is not a bug - it is an intended 
functionality, is_callable is supposed to return true on this data and as far as 
I can see, has always done so at least since 5.2 (maybe earlier, just don't have 
binary to check). 

Secondly, Foo::Bar is not always a static call. Consider this code:

 class Foo
    {
        private $number = 42;
        public function bar()
        {
           var_dump($this->number);
           return __METHOD__;
        }
    }

class Bar extends Foo {
        public function callme($callback) {
                echo call_user_func($callback);
        }
}

$callback = array('Foo', 'Bar');
var_dump(is_callable($callback));
$bar = new Bar();
$bar->callme($callback);

This is a bit convoluted, but everything works just fine. Changing is_callable 
and the engine to prohibit this case would cause massive code breakage, and as a 
lot of code uses this pattern to call parent ctors, it's probably not feasible. 
There's a difference between "true static call" and "parent method call that 
looks like static call" and unfortunately, this difference exists only in 
runtime when the actual call is made, is_callable would not be able to predict 
it.

Assigning to myself. I have an RFC relevant to this: https://wiki.php.net/rfc/consistent_callables

In PHP 8.0 calling non-static methods statically is (finally) prohibited. This has also fixed the is_callable() issue as a side effect.