Difference between static:: and $this::

I know there is a difference between static:: and self:: like in this example ( from https://stackoverflow.com/a/13613718/2342518 )

<?php
class One
{
    const TEST = "test1";
    function test() { echo static::TEST; }
}
class Two extends One
{
    const TEST = "test2";
}

$c = new Two();
$c->test();

Which returns test2 when static::TEST is used and test1 when self::TEST is used. But it also returns test2 when $this::TEST is used.

static::TEST can be used inside a static method, whereas $this::TEST requires an instance before being used (so non-usable in static methods).

But if one cannot use $this:: in static methods, static:: can be used in non-static methods (like in the example).

So, what is the difference between static:: and $this:: in a non static method?

Optional complete test

<?php
abstract class AOne
{
    const TEST = "test1";
    abstract public function test();
}
class OneStatic extends AOne
{
    public function test()
    {
        return static::TEST;
    }
}
class TwoStatic extends OneStatic
{
    const TEST = "test2";
}
class OneSelf extends AOne
{
    public function test()
    {
        return self::TEST;
    }
}
class TwoSelf extends OneSelf
{
    const TEST = "test2";
}
class OneThis extends AOne
{
    public function test()
    {
        return $this::TEST;
    }
}
class TwoThis extends OneThis
{
    const TEST = "test2";
}

$objects = array(
    'one, static::'     => new OneStatic(),
    'two, static::'     => new TwoStatic(),
    'one,   self::'     => new OneSelf(),
    'two,   self::'     => new TwoSelf(),
    'one,  $this::'     => new OneThis(),
    'two,  $this::'     => new TwoThis(),
);

$results = array();
foreach ($objects as $name=>$object)
    $results[$name] = $object->test();

var_dump($results);
?>

Which yields

'one, static::' => 'test1'
'two, static::' => 'test2'
'one, self::' => 'test1'
'two, self::' => 'test1'
'one, $this::' => 'test1'
'two, $this::' => 'test2'

So self refers to the class where the method is defined, but there's no difference between $this:: and static:: in these non static methods.

Solution

There are three cases when you CAN'T use $this:: over static::

1. In static methods

public static function test() {
    return $this::MY_CONST;
}

Output:

Fatal error: Uncaught Error: Using $this when not in object context

2. In none-static methods which get called from a non-object context

class A {
    const MY_CONST = 33;
    public function test() {
        return $this::MY_CONST;
    }
}

echo A::test(); // test method here is called without instantiating class A

Output:

Fatal error: Uncaught Error: Using $this when not in object context

Updates:

As of PHP 8 calling a non-static method from a non-object context is not allowed and will yield the following error

Fatal error: Uncaught Error: Non-static method A::test() cannot be called statically

3. When using the special ::class keyword

class A {
    public function test() {
        return $this::class;
    }
}

$a = new A;
echo $a->test();

Output:

Fatal error: Dynamic class names are not allowed in compile-time

Note: in all the three cases static:: will work

For the last case PHP Documentation states that:

Note:

The class name resolution using ::class is a compile time transformation. That means at the time the class name string is created no autoloading has happened yet. As a consequence, class names are expanded even if the class does not exist. No error is issued in that case.

So you can't use $this::class because you can't reference to non-existent classes

PHP 8

The behavior in PHP 8 has changed!

For consistency reasons $this::class now provides the same result as get_class($this) and static::class

https://3v4l.org/iB99O