cc @muglug @nicolas-grekas I believe you were interested in having this.

Currently it is also exposed via ReflectionType::isBuiltin() as true

returning false would make more sense I agree, same as self and parent.

Because the static type conflicts syntactically with static properties, it is excluded from property types on the grammar level.

if we want to support it, it could be allowed as part of union types: public self|static $foo;.

Thank you for opening this! \o/

However, static is usually considered a class in userland, so it might make sense to hack that to return false?

interface DateTimeInterface {
    public function add(DateTimeInterval $interval) : static;
    public static function createFromFormat(string $format , string $time [, DateTimeZone $timezone ]) : static;
    // etc.
}

i.e. altering DateTimeInterface to include the methods whose only difference between DateTime and DateTimeImmutable is the return type, wouldn't those be ReflectionType::isBuiltIn() === true ?

Because the static type conflicts syntactically with static properties, it is excluded from property types on the grammar level.

I wonder if Hack uses this to avoid the clash (regardless, it doesn’t bother me)

Potentially to be added as invalid scenario: static in combination of a final class:

this looks valid to me, especially considering your next case:

what happens when self is used in a child class that overrides a method that returns static?

looks invalid to me, as it breaks the promise of the base class, stating that the method returns the same type as the object's class

makes sense?

Potentially to be added as invalid scenario: static in combination of a final class:

I agree with Nicolas, it seems ok for me.

what happens when self is used in a child class that overrides a method that returns static?

Maybe I misinterpret LSP, but this example also seems ok for me: returning a child class (self) instead of the parent or any child class (static) is covariant - which is what is expected. Or am I missing something?

Replacing static with self is invalid, as tested in https://github.com/php/php-src/pull/5062/files#diff-1861cb2c956e77e7c533e2e73c1f9549.

A replacement from static to self could only (theoretically speaking) be legal if the new method is final, but I don't think we'd want to special-case that.

@kocsismate

Or am I missing something?

the danger comes here:

class A {
  public static function getInstance() : static {
    return new static();
  }

  public function foo() : void {}

  public static function getInstanceAndCall() : static {
    $i = static::getInstance();
    $i->foo();
    return $i;
  }
}

class B extends A {
  public static function getInstance() : self {
    return new self();
  }
}

class C extends B {}

calling C::getInstanceAndCall() should return an instance of C, but actually returns an instance of B.

@muglug Ok, now I see. Thanks for the explanation. I was only considering the most basic scenario (when there is only one child class)

RFC: https://wiki.php.net/rfc/static_return_type

I'm all for this. I was working with @sgolemon on this as an idea at the end of last year.

https://phpc.social/@pollita/103256122403635150

Basic description: https://gist.github.com/simensen/729c4ac9056b06d60038377f59a92cfe

Sara's implementation: master...sgolemon:static-return

I haven't had time to circle back and try to get an RFC up. Now I guess I don't have to? :) Thanks for the work on this!!! Let me know how I can help champion this.

LGTM, I've wanted this for return types for a while.

Some phpt tests of traits would be useful in validating the implementation, e.g.

1. A class inheriting a trait and/or an interface which declare a method with a return type of static
2. A trait has a method returning static, the class overrides it with a return type of : self
3. A parent class has a method returning static, the class uses a trait with a return type of : self

(I've had a lot of issues with writing code analyzing traits in the past)

Future scope - method cascading:

class Test {
    public function doWhatever(): $this {
        // Do whatever.
        return $this;
    }
}

What do you think about to implement it like the void, but instead of returning nothing return $this.

Syntax sugar in examples:

class Test {
    public function doWhatever(): $this {
        // will return $this even there is no return in the method
    }

    public function doWhatever2(): $this {
        // will return $this even there is no return value specified
        return;
    }

    public function doWhatever3(): $this {
        // error, return value specified, but return value defined in method declaration
        return $this;
    }
}

Reflection should behave exactly the same as if the return type is defined as static.