Difference between static:: and $this::

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

There really isn't one. The :: functionality has been expanded over time, so that the left hand side doesn't need to be a class literal but may also be an object instance or string variable with a class name. Sometime around the same time late static binding was introduced with the static keyword. As you said, $this can't be used in static methods, so static is the obvious and only choice here for late static binding.

In an object instance however you could use static:: to refer to the late-static bound class, which will be the class of the current object instance. Or you could use $this:: as a side effect of being able to use an object instance as shorthand for <class of this object $var>::. The end result is the same, it's simply functionality which happens to overlap in this particular point. The internal workings are somewhat different, but I can't think of a case where there would ever be any difference.

Just to complete the Venn diagram:

Only static can do this:

public static function foo() {
    static::FOO;
}

Only $var:: can do this:

$obj = new Foo;
$obj::FOO;

Both can do this:

public function foo() {
    static::FOO;
    $this::FOO;
}