Added self and parent types

src/ParentClassStringLiteralType.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Type;
+
+/**
+ * @api
+ * @psalm-immutable
+ * @implements Type<class-string>
+ * Absence of a template declaration for the object type is intentional. Consider a trait: parent::class type declared in
+ * this trait does not represent class of the trait, but an instance of a class that uses this trait.
+ */
+final class ParentClassStringLiteralType implements Type
+{
+    /**
+     * @var class-string
+     */
+    public readonly string $declaredAtClass;
+
+    /**
+     * @internal
+     * @psalm-internal Typhoon\Type
+     * @param class-string $declaredAtClass
+     */
+    public function __construct(
+        string $declaredAtClass,
+    ) {
+        $this->declaredAtClass = $declaredAtClass;
+    }
+
+    public function accept(TypeVisitor $visitor): mixed
+    {
+        return $visitor->visitParentClassStringLiteral($this);
+    }
+}

src/ParentType.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Type;
+
+/**
+ * @api
+ * @psalm-immutable
+ * @implements Type<object>
+ * Absence of a template declaration for the object type is intentional. Consider a trait: parent type declared in
+ * this trait does not represent instance of the trait, but an instance of a class that uses this trait.
+ */
+final class ParentType implements Type
+{
+    /**
+     * @var class-string
+     */
+    public readonly string $declaredAtClass;
+
+    /**
+     * @var list<Type>
+     */
+    public readonly array $templateArguments;
+
+    /**
+     * @internal
+     * @psalm-internal Typhoon\Type
+     * @param class-string $declaredAtClass
+     * @param list<Type> $templateArguments
+     */
+    public function __construct(
+        string $declaredAtClass,
+        array $templateArguments = [],
+    ) {
+        $this->declaredAtClass = $declaredAtClass;
+        $this->templateArguments = $templateArguments;
+    }
+
+    public function accept(TypeVisitor $visitor): mixed
+    {
+        return $visitor->visitParent($this);
+    }
+}

src/SelfClassStringLiteralType.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Type;
+
+/**
+ * @api
+ * @psalm-immutable
+ * @implements Type<class-string>
+ * Absence of a template declaration for the object type is intentional. Consider a trait: self::class type declared in
+ * this trait does not represent class of the trait, but an instance of a class that uses this trait.
+ */
+final class SelfClassStringLiteralType implements Type
+{
+    /**
+     * @var class-string
+     */
+    public readonly string $declaredAtClass;
+
+    /**
+     * @internal
+     * @psalm-internal Typhoon\Type
+     * @param class-string $declaredAtClass
+     */
+    public function __construct(
+        string $declaredAtClass,
+    ) {
+        $this->declaredAtClass = $declaredAtClass;
+    }
+
+    public function accept(TypeVisitor $visitor): mixed
+    {
+        return $visitor->visitSelfClassStringLiteral($this);
+    }
+}

src/SelfType.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Type;
+
+/**
+ * @api
+ * @psalm-immutable
+ * @implements Type<object>
+ * Absence of a template declaration for the object type is intentional. Consider a trait: self type declared in
+ * this trait does not represent instance of the trait, but an instance of a class that uses this trait.
+ */
+final class SelfType implements Type
+{
+    /**
+     * @var class-string
+     */
+    public readonly string $declaredAtClass;
+
+    /**
+     * @var list<Type>
+     */
+    public readonly array $templateArguments;
+
+    /**
+     * @internal
+     * @psalm-internal Typhoon\Type
+     * @param class-string $declaredAtClass
+     * @param list<Type> $templateArguments
+     */
+    public function __construct(
+        string $declaredAtClass,
+        array $templateArguments = [],
+    ) {
+        $this->declaredAtClass = $declaredAtClass;
+        $this->templateArguments = $templateArguments;
+    }
+
+    public function accept(TypeVisitor $visitor): mixed
+    {
+        return $visitor->visitSelf($this);
+    }
+}

src/StaticClassStringLiteralType.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Type;
+
+/**
+ * @api
+ * @psalm-immutable
+ * @implements Type<class-string>
+ * Absence of a template declaration for the object type is intentional. Consider a trait: static::class type declared in
+ * this trait does not represent class of the trait, but an instance of a class that uses this trait.
+ */
+final class StaticClassStringLiteralType implements Type
+{
+    /**
+     * @var class-string
+     */
+    public readonly string $declaredAtClass;
+
+    /**
+     * @internal
+     * @psalm-internal Typhoon\Type
+     * @param class-string $declaredAtClass
+     */
+    public function __construct(
+        string $declaredAtClass,
+    ) {
+        $this->declaredAtClass = $declaredAtClass;
+    }
+
+    public function accept(TypeVisitor $visitor): mixed
+    {
+        return $visitor->visitStaticClassStringLiteral($this);
+    }
+}

src/StaticType.php

@@ -7,13 +7,14 @@
 /**
  * @api
  * @psalm-immutable
- * @template-covariant TObject of object
- * @implements Type<TObject>
+ * @implements Type<object>
+ * Absence of a template declaration for the object type is intentional. Consider a trait: self type declared in
+ * this trait does not represent instance of the trait, but an instance of a class that uses this trait.
  */
 final class StaticType implements Type
 {
     /**
-     * @var class-string<TObject>
+     * @var class-string
      */
     public readonly string $declaredAtClass;
 
@@ -25,7 +26,7 @@ final class StaticType implements Type
     /**
      * @internal
      * @psalm-internal Typhoon\Type
-     * @param class-string<TObject> $declaredAtClass
+     * @param class-string $declaredAtClass
      * @param list<Type> $templateArguments
      */
     public function __construct(

src/TypeVisitor.php

@@ -65,6 +65,15 @@ public function visitNumericString(NumericStringType $type): mixed;
     /** @return TReturn */
     public function visitClassStringLiteral(ClassStringLiteralType $type): mixed;
 
+    /** @return TReturn */
+    public function visitSelfClassStringLiteral(SelfClassStringLiteralType $type): mixed;
+
+    /** @return TReturn */
+    public function visitParentClassStringLiteral(ParentClassStringLiteralType $type): mixed;
+
+    /** @return TReturn */
+    public function visitStaticClassStringLiteral(StaticClassStringLiteralType $type): mixed;
+
     /** @return TReturn */
     public function visitNamedClassString(NamedClassStringType $type): mixed;
 
@@ -125,6 +134,12 @@ public function visitIterable(IterableType $type): mixed;
     /** @return TReturn */
     public function visitNamedObject(NamedObjectType $type): mixed;
 
+    /** @return TReturn */
+    public function visitSelf(SelfType $type): mixed;
+
+    /** @return TReturn */
+    public function visitParent(ParentType $type): mixed;
+
     /** @return TReturn */
     public function visitStatic(StaticType $type): mixed;
 

src/types.php

@@ -131,6 +131,33 @@ public static function classString(string|Type $classOrType): ClassStringLiteral
         return new NamedClassStringType($classOrType);
     }
 
+    /**
+     * @psalm-pure
+     * @param class-string $declaredAtClass
+     */
+    public static function selfClassString(string $declaredAtClass): SelfClassStringLiteralType
+    {
+        return new SelfClassStringLiteralType($declaredAtClass);
+    }
+
+    /**
+     * @psalm-pure
+     * @param class-string $declaredAtClass
+     */
+    public static function parentClassString(string $declaredAtClass): ParentClassStringLiteralType
+    {
+        return new ParentClassStringLiteralType($declaredAtClass);
+    }
+
+    /**
+     * @psalm-pure
+     * @param class-string $declaredAtClass
+     */
+    public static function staticClassString(string $declaredAtClass): StaticClassStringLiteralType
+    {
+        return new StaticClassStringLiteralType($declaredAtClass);
+    }
+
     /**
      * @psalm-pure
      * @template TValue
@@ -265,9 +292,27 @@ public static function object(string $class, Type ...$templateArguments): NamedO
     /**
      * @psalm-pure
      * @no-named-arguments
-     * @template TObject of object
-     * @param class-string<TObject> $declaredAtClass
-     * @return StaticType<TObject>
+     * @param class-string $declaredAtClass
+     */
+    public static function self(string $declaredAtClass, Type ...$templateArguments): SelfType
+    {
+        return new SelfType($declaredAtClass, $templateArguments);
+    }
+
+    /**
+     * @psalm-pure
+     * @no-named-arguments
+     * @param class-string $declaredAtClass
+     */
+    public static function parent(string $declaredAtClass, Type ...$templateArguments): ParentType
+    {
+        return new ParentType($declaredAtClass, $templateArguments);
+    }
+
+    /**
+     * @psalm-pure
+     * @no-named-arguments
+     * @param class-string $declaredAtClass
      */
     public static function static(string $declaredAtClass, Type ...$templateArguments): StaticType
     {

tests/PsalmTest.php

@@ -66,8 +66,13 @@ public static function extractType(Type $_type): mixed
     #[TestWith([__DIR__ . '/psalm/NumericType.phpt'])]
     #[TestWith([__DIR__ . '/psalm/ObjectShapeType.phpt'])]
     #[TestWith([__DIR__ . '/psalm/ObjectType.phpt'])]
+    #[TestWith([__DIR__ . '/psalm/ParentClassStringLiteralType.phpt'])]
+    #[TestWith([__DIR__ . '/psalm/ParentType.phpt'])]
     #[TestWith([__DIR__ . '/psalm/ResourceType.phpt'])]
     #[TestWith([__DIR__ . '/psalm/ScalarType.phpt'])]
+    #[TestWith([__DIR__ . '/psalm/SelfClassStringLiteralType.phpt'])]
+    #[TestWith([__DIR__ . '/psalm/SelfType.phpt'])]
+    #[TestWith([__DIR__ . '/psalm/StaticClassStringLiteralType.phpt'])]
     #[TestWith([__DIR__ . '/psalm/StaticType.phpt'])]
     #[TestWith([__DIR__ . '/psalm/StringLiteralType.phpt'])]
     #[TestWith([__DIR__ . '/psalm/StringType.phpt'])]

tests/psalm/ParentClassStringLiteralType.phpt

@@ -0,0 +1,9 @@
+--FILE--
+<?php
+
+namespace Typhoon\Type;
+
+$_type = PsalmTest::extractType(new ParentClassStringLiteralType(\stdClass::class));
+/** @psalm-check-type-exact $_type = \class-string */
+
+--EXPECT--

tests/psalm/ParentType.phpt

@@ -0,0 +1,9 @@
+--FILE--
+<?php
+
+namespace Typhoon\Type;
+
+$_type = PsalmTest::extractType(new ParentType(\stdClass::class));
+/** @psalm-check-type-exact $_type = \object */
+
+--EXPECT--

tests/psalm/SelfClassStringLiteralType.phpt

@@ -0,0 +1,9 @@
+--FILE--
+<?php
+
+namespace Typhoon\Type;
+
+$_type = PsalmTest::extractType(new SelfClassStringLiteralType(\stdClass::class));
+/** @psalm-check-type-exact $_type = \class-string */
+
+--EXPECT--

tests/psalm/SelfType.phpt

@@ -0,0 +1,9 @@
+--FILE--
+<?php
+
+namespace Typhoon\Type;
+
+$_type = PsalmTest::extractType(new SelfType(\stdClass::class));
+/** @psalm-check-type-exact $_type = \object */
+
+--EXPECT--

tests/psalm/StaticClassStringLiteralType.phpt

@@ -0,0 +1,9 @@
+--FILE--
+<?php
+
+namespace Typhoon\Type;
+
+$_type = PsalmTest::extractType(new StaticClassStringLiteralType(\stdClass::class));
+/** @psalm-check-type-exact $_type = \class-string */
+
+--EXPECT--

tests/psalm/StaticType.phpt

@@ -4,6 +4,6 @@
 namespace Typhoon\Type;
 
 $_type = PsalmTest::extractType(new StaticType(\stdClass::class));
-/** @psalm-check-type-exact $_type = \stdClass */
+/** @psalm-check-type-exact $_type = \object */
 
 --EXPECT--