Description:
------------
PHP's namespace fallback policy for functions is a great feature for mocking built-in functions like time() for unit tests. I'm using this in my mocking library php-mock: https://github.com/malkusch/php-mock

I experienced a suprising behaviour when an unqualified call in a class happened before the definition of the namespaced function. E.g. when calling in foo\Foo time() and defining afterwards foo\time(). I would expect that after that definition time() in foo\Foo would resolve to foo\time(). Instead it resolves to whatever was resolvable during the first call.

In the example you see two cases. In the rand() case I call foo\Foo::rand() first after the definition of foo\rand(). Those assertions are fine and rand() resolves to foo\rand().

In the time case() I call foo\Foo::time() first before the definition of foo\time(). The call after defining foo\time() still resolves to \time(). I would expect here a resolution to foo\time(). If this is intentional the documentation might be more clear about this.

Test script:
---------------
<?php

namespace foo;

class Foo
{
    
    public static function time()
    {
        return time();
    }
    
    public static function rand()
    {
        return rand();
    }
}

Foo::time(); // If you remove this line all assertions are true.

// It doesn't matter if you eval the namespaced function or include it.
eval("
    namespace foo {
        function time() {
            return 1234;
        }
        
        function rand() {
            return 5678;
        }
    }
");

assert (5678 == rand());
assert (5678 == Foo::rand());

assert (1234 == time());
assert (1234 == Foo::time());

Expected result:
----------------
All assertions are true and time() resolves in the last call to foo\time().

Actual result:
--------------
The last assertion fails, because time() resolves in foo\Foo to \time() even though foo\time() exists.