Calling `static::method` from a non-static method results in a non-static call

[someonewithpc]

Description

The following code:

<?php

class A
{
    public static function __callStatic(string $method, array $args): void
    {
        echo "Called static '{$method}'\n";
    }

    public function __call(string $method, array $args): void
    {
        echo "Called non static '{$method}'\n";
    }

    public static function static_method(): void
    {
        static::method();
    }

    public function non_static_method(): void
    {
        static::method();
    }
}

A::static_method();           // Output: Called static 'method'
(new A)::static_method();     // Output: Called static 'method'
(new A)->static_method();     // Output: Called static 'method'
(new A)->non_static_method(); // Output: Called non static 'method'

Resulted in this output:

Called static 'method'
Called static 'method'
Called static 'method'
Called non static 'method'

But I expected this output instead:

Called static 'method'
Called static 'method'
Called static 'method'
Called static 'method'

The __call and __callStatic documentation mentions

__call() is triggered when invoking inaccessible methods in an object context.

Which may mean this is intended behaviour, but it is rather confusing.

Essentially, I'd expect the type of method called to be determined by the operator used: :: or ->

PHP Version

8.1.3, 8.1.1

Operating System

Arch Linux and Alpine (docker)

[damianwadley]

Essentially, I'd expect the type of method called to be determined by the operator used: :: or ->

That is not how it works. :: is called the "scope resolution operator" because it deals with scope - not decide between instanced or static access. Whether a method call is instanced or static depends on (a) how the method is defined and (b) the scope it's being called from.

Here, that first part doesn't apply because there is no "method" method (therefore PHP will do a dynamic call instead), however the second still does. Since the call is happening on an instance, the method call is instanced and thus goes to __call.

[damianwadley]

Actually, let's do this instead:

[someonewithpc]

That is not how it works. :: is called the "scope resolution operator" because it deals with scope - not decide between instanced or static access. Whether a method call is instanced or static depends on (a) how the method is defined and (b) the scope it's being called from

Yeah, that's what I figured from that doc link I sent, it's just unintuitive, I'd say.

For reference for anyone in the future, a workaround is:

(static fn() => static::method())()

from an instance context, to force a static call.