/**
 * @template T
 * @param T $bar
 */
function foo(mixed $bar): void
{
    if (is_string($bar)) {
        // тут у $bar тип T & string

        return;
    }

    // а тут у $bar тип T & !string

    trim($bar); // ошибка: ожидается string
}

/**
 * @psalm-assert !null $value
 * @phpstan-assert !null $value
 */
function assertNotNull($value): void
{
    if ($value === null) {
        throw new InvalidArgumentException();
    }
}

non-empty-string = string & !''
non-falsy-string = truthy-string = non-empty-string & !'0'
non-empty-list<TValue> = list<TValue> & !array{}
non-empty-array<TKey, TValue> = array<TKey, TValue> & !array{}

Здесь array{} — это запечатанный array-shape без элементов, то есть []. Его ещё часто пишут как array<never, never>.

enum types implements Type
{
    // ...
    case nonEmptyString;

    public function accept(TypeVisitor $visitor): mixed
    {
        return match ($this) {
            // ...
            self::nonEmptyString => $visitor->intersection($this, [
                self::string,
                self::not(self::string('')),
            ]),
        }
    }
}

class A extends stdClass
{
    public function self(): self { return $this; }
    public function parent(): parent { return $this; }
    public function static(): static { return $this; }
}

final class B extends A {}

A,B::self() возвращают types::object(A::class)
A,B::parent() возвращают types::object(stdClass::class)
A::static() возвращает types::static(A::class)
B::static() возвращает types::static(B::class)

trait T
{
    public function self(): self { return $this; }
    public function parent(): parent { return $this; }
    public function static(): static { return $this; }
}

/**
 * @psalm-require-extends stdClass
 * @phpstan-require-extends stdClass
 */
trait T
{
    public function self(): self { return $this; }
    public function parent(): parent { return $this; }
    public function static(): static { return $this; }
}

final class A extends stdClass
{
    use T;
}

/**
 * @template self of object
 * @template parent of stdClass
 * @template static of self
 */
trait T
{
    public function self(): self { return $this; }
    public function parent(): parent { return $this; }
    public function static(): static { return $this; }
}

final class A extends stdClass
{
    /**
     * @use T<self, parent, self>
     */
    use T;
}

types::template('self', types::atClass(T::class))
types::template('parent', types::atClass(T::class))
types::template('static', types::atClass(T::class))

final class A extends ArrayObject
{
    public function self() { return fn (): self => new self(); }
    public function parent() { return fn (): parent => new parent(); }
    public function static() { return fn (): static => new static(); }
}

final class B extends stdClass {}

$self = (new A())->self();
echo $self()::class; // A
echo $self->call(new B)::class; // B

$parent = (new A())->parent();
echo $parent()::class; // ArrayObject
echo $parent->call(new B)::class; // stdClass

$static = (new A())->static();
echo $static()::class; // A
echo $static->call(new B)::class; // B

trait T
{
    /**
     * @return array{self, parent, static}
     */
    public function types(): array
    {
        return [$this, $this, $this];
    }
}

abstract class A extends stdClass
{
    use T;
}

final class B extends A {}

$type = TyphoonReflector::build()
    ->reflectClass(B::class)
    ->methods()['types']
    ->returnType();

echo stringify($type);

// array{self@A, parent@stdClass, static@B}