Support exhaustiveness checks for sealed interfaces implemented by an enum

[stof]

#[Sealed(permits: [ColorFormatEnum::class, SpanColorFormat::class])]
interface ColorFormat
{
}


enum ColorFormatEnum implements ColorFormat
{
    /**
     * A color defined using the `rgb()` or `rgba()` functions.
     */
    case rgbFunction;
    /**
     * A color defined using the `hsl()` or `hsla()` functions.
     */
    case hslFunction;
}

final class SpanColorFormat implements ColorFormat
{
    private readonly string $original;

    public function __construct(string $original)
    {
        $this->original = $original;
    }

    public function getOriginal(): string
    {
        return $this->original;
    }
}

interface SassColor {
    public function getFormat(): ColorFormat;
}

function writeColorWithMatch(SassColor $value): void
{
        $format = $value->getFormat();
            match ($format) {
                ColorFormatEnum::rgbFunction => writeRgb($value),
                ColorFormatEnum::hslFunction => writeHsl($value),
                default => write($format->getOriginal()),
            };
}

function writeColorWithIf(SassColor $value): void
{
        $format = $value->getFormat();

            if ($format === ColorFormatEnum::rgbFunction) {
                writeRgb($value);
            } elseif ($format === ColorFormatEnum::hslFunction) {
                writeHsl($value);
            } else {
                write($format->getOriginal());
            }
}

function writeRgb(SassColor $color): void {
// Omitted
}
function writeHsl(SassColor $color): void {
// Omitted
}

function write(string $text): void {
// Omitted
}

In the code snippet above, as ColorFormat allows only ColorFormatEnum and SpanColorFormat and I'm checking explicitly all cases of the enum, I would expect the default branch of writeColorWithMatch and the else branch of writeColorWithIf to know that $format must be a SpanColorFormat there (and so calling getOriginal is OK.

[jiripudil]

Hi, at first glance, this might be a limitation on the side of PHPStan's type subtraction logic. I'll try and look into it, see if that's the case and if I can find a way around it

[stof]

Or maybe this is something that should be fixed in the phpstan side indeed. I haven't debugged this.

[stof]

@jiripudil did you manage to look at this ?

[stof]

for reference, replacing the sealed interface with a union SpanColorFormat|ColorFormatEnum in the SassColor::getFormat return type removes the error reported by phpstan. So it looks like phpstan already supports the exhaustiveness check when eliminating enum cases one by one in case an actual union is used.

[stof]

I opened a phpstan issue about that: phpstan/phpstan#10148