Add support for more types

Author: vudaltsov

src/Internal/ContextualTypeParser.php

@@ -20,8 +20,8 @@
 use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
 use Typhoon\PHPStanTypeParser\CustomTypeParser;
 use Typhoon\PHPStanTypeParser\TypeContext;
+use Typhoon\Type\ArrayDefaultT;
 use Typhoon\Type\ArrayT;
-use Typhoon\Type\ObjectT;
 use Typhoon\Type\Type;
 use function Typhoon\Type\andT;
 use function Typhoon\Type\floatRangeT;
@@ -37,6 +37,7 @@
 use const Typhoon\Type\falseT;
 use const Typhoon\Type\floatT;
 use const Typhoon\Type\intT;
+use const Typhoon\Type\literalStringT;
 use const Typhoon\Type\lowercaseStringT;
 use const Typhoon\Type\mixedT;
 use const Typhoon\Type\negativeIntT;
@@ -48,11 +49,13 @@
 use const Typhoon\Type\nullT;
 use const Typhoon\Type\numericStringT;
 use const Typhoon\Type\numericT;
+use const Typhoon\Type\objectT;
 use const Typhoon\Type\positiveIntT;
 use const Typhoon\Type\resourceT;
 use const Typhoon\Type\scalarT;
 use const Typhoon\Type\stringT;
 use const Typhoon\Type\trueT;
+use const Typhoon\Type\truthyStringT;
 use const Typhoon\Type\voidT;
 
 /**
@@ -119,12 +122,14 @@ private function parseIdentifier(string $name, array $genericNodes = []): Type
             'non-empty-string' => nonEmptyStringT,
             'lowercase-string' => lowercaseStringT,
             'numeric-string' => numericStringT,
+            'literal-string' => literalStringT,
             'string' => stringT,
+            'truthy-string', 'non-falsy-string' => truthyStringT,
             'resource' => resourceT,
             'array-key' => arrayKeyT,
             'numeric' => numericT,
             'scalar' => scalarT,
-            'object' => new ObjectT([]),
+            'object' => objectT,
             'mixed' => mixedT,
             default => null,
         };
@@ -147,22 +152,8 @@ private function parseIdentifier(string $name, array $genericNodes = []): Type
 
         $templateArguments = array_map($this->parseTypeNode(...), $genericNodes);
 
-        if ($name === 'array') {
-            return match ($number = \count($templateArguments)) {
-                0 => arrayT,
-                1 => new ArrayT(valueType: $templateArguments[0]),
-                2 => new ArrayT($templateArguments[0], $templateArguments[1]),
-                default => throw new \LogicException(\sprintf('array type should have at most 2 type arguments, got %d', $number)),
-            };
-        }
-
-        if ($name === 'non-empty-array') {
-            return match ($number = \count($templateArguments)) {
-                0 => new ArrayT(isNonEmpty: true),
-                1 => new ArrayT(valueType: $templateArguments[0], isNonEmpty: true),
-                2 => new ArrayT($templateArguments[0], $templateArguments[1], isNonEmpty: true),
-                default => throw new \LogicException(\sprintf('non-empty-array type should have at most 2 type arguments, got %d', $number)),
-            };
+        if ($name === 'array' || $name === 'non-empty-array') {
+            return $this->parseArray($templateArguments, isNonEmpty: $name === 'non-empty-array');
         }
 
         return $this->customTypeParser->parseCustomType($name, $templateArguments, $this->context)
@@ -187,24 +178,6 @@ private function parseInt(array $genericNodes): Type
         };
     }
 
-    /**
-     * @param list<TypeNode> $genericNodes
-     */
-    private function parseFloat(array $genericNodes): Type
-    {
-        return match (\count($genericNodes)) {
-            0 => floatT,
-            2 => floatRangeT(
-                min: self::parseFloatRangeLimit($genericNodes[0], 'min'),
-                max: self::parseFloatRangeLimit($genericNodes[1], 'max'),
-            ),
-            default => throw new \LogicException(\sprintf(
-                'Float range type should have 2 type arguments, got %d',
-                \count($genericNodes),
-            ))
-        };
-    }
-
     /**
      * @param 'min'|'max' $name
      */
@@ -231,6 +204,24 @@ private function parseIntRangeLimit(TypeNode $type, string $name): ?int
         throw new \LogicException();
     }
 
+    /**
+     * @param list<TypeNode> $genericNodes
+     */
+    private function parseFloat(array $genericNodes): Type
+    {
+        return match (\count($genericNodes)) {
+            0 => floatT,
+            2 => floatRangeT(
+                min: self::parseFloatRangeLimit($genericNodes[0], 'min'),
+                max: self::parseFloatRangeLimit($genericNodes[1], 'max'),
+            ),
+            default => throw new \LogicException(\sprintf(
+                'Float range type should have 2 type arguments, got %d',
+                \count($genericNodes),
+            ))
+        };
+    }
+
     /**
      * @param 'min'|'max' $name
      * @return ?numeric-string
@@ -257,4 +248,17 @@ private function parseFloatRangeLimit(TypeNode $type, string $name): ?string
 
         throw new \LogicException();
     }
+
+    /**
+     * @param list<Type> $templateArguments
+     */
+    private function parseArray(array $templateArguments, bool $isNonEmpty = false): ArrayDefaultT|ArrayT
+    {
+        return match ($number = \count($templateArguments)) {
+            0 => $isNonEmpty ? new ArrayT(isNonEmpty: true) : arrayT,
+            1 => new ArrayT(valueType: $templateArguments[0], isNonEmpty: $isNonEmpty),
+            2 => new ArrayT(keyType: $templateArguments[0], valueType: $templateArguments[1], isNonEmpty: $isNonEmpty),
+            default => throw new \LogicException(\sprintf('array type should have at most 2 type arguments, got %d', $number)),
+        };
+    }
 }

tests/PHPStanTypeParserTest.php

@@ -26,22 +26,26 @@
 use const Typhoon\Type\falseT;
 use const Typhoon\Type\floatT;
 use const Typhoon\Type\intT;
+use const Typhoon\Type\literalStringT;
 use const Typhoon\Type\lowercaseStringT;
 use const Typhoon\Type\mixedT;
 use const Typhoon\Type\negativeIntT;
 use const Typhoon\Type\neverT;
 use const Typhoon\Type\nonEmptyStringT;
+use const Typhoon\Type\nonFalsyStringT;
 use const Typhoon\Type\nonNegativeIntT;
 use const Typhoon\Type\nonPositiveIntT;
 use const Typhoon\Type\nonZeroIntT;
 use const Typhoon\Type\nullT;
 use const Typhoon\Type\numericStringT;
 use const Typhoon\Type\numericT;
+use const Typhoon\Type\objectT;
 use const Typhoon\Type\positiveIntT;
 use const Typhoon\Type\resourceT;
 use const Typhoon\Type\scalarT;
 use const Typhoon\Type\stringT;
 use const Typhoon\Type\trueT;
+use const Typhoon\Type\truthyStringT;
 use const Typhoon\Type\voidT;
 
 #[CoversClass(PHPStanTypeParser::class)]
@@ -90,6 +94,9 @@ private static function cases(): \Generator
         yield 'non-empty-string' => nonEmptyStringT;
         yield 'numeric-string' => numericStringT;
         yield 'lowercase-string' => lowercaseStringT;
+        yield 'literal-string' => literalStringT;
+        yield 'truthy-string' => truthyStringT;
+        yield 'non-falsy-string' => nonFalsyStringT;
         yield 'string' => stringT;
         yield 'resource' => resourceT;
         yield 'array-key' => arrayKeyT;
@@ -105,6 +112,7 @@ private static function cases(): \Generator
         yield 'non-empty-array' => nonEmptyArrayT();
         yield 'non-empty-array<string>' => nonEmptyArrayT(value: stringT);
         yield 'non-empty-array<int, string>' => nonEmptyArrayT(intT, stringT);
+        yield 'object' => objectT;
         yield 'mixed' => mixedT;
         yield \stdClass::class => namedObjectT(\stdClass::class);
         yield \Stringable::class => namedObjectT(\Stringable::class);