Reflection-based TypeResolver

docs/reflection/types.md

@@ -29,7 +29,7 @@ final class A
 
 $reflector = TyphoonReflector::build();
 
-$class = $reflector->reflectClass(A::class);
+$class = $reflector->reflectClass(ChildOfArrayObject::class);
 
 $constant = $class->constants()['CONSTANT'];
 

src/Reflection/Visitor/ClassIdResolver.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection\Visitor;
+
+use Typhoon\DeclarationId\AnonymousClassId;
+use Typhoon\DeclarationId\NamedClassId;
+use Typhoon\Type\Type;
+use Typhoon\Type\Visitor\DefaultTypeVisitor;
+use function Typhoon\Type\stringify;
+
+/**
+ * @internal
+ * @psalm-internal Typhoon\Reflection\Visitor
+ * @extends DefaultTypeVisitor<NamedClassId|AnonymousClassId>
+ */
+final class ClassIdResolver extends DefaultTypeVisitor
+{
+ public function namedObject(Type $type, NamedClassId|AnonymousClassId $classId, array $typeArguments): mixed
+ {
+ return $classId;
+ }
+
+ public function self(Type $type, array $typeArguments, null|NamedClassId|AnonymousClassId $resolvedClassId): mixed
+ {
+ if ($resolvedClassId === null) {
+ return $this->default($type);
+ }
+
+ return $resolvedClassId;
+ }
+
+ public function parent(Type $type, array $typeArguments, ?NamedClassId $resolvedClassId): mixed
+ {
+ if ($resolvedClassId === null) {
+ return $this->default($type);
+ }
+
+ return $resolvedClassId;
+ }
+
+ public function static(Type $type, array $typeArguments, null|NamedClassId|AnonymousClassId $resolvedClassId): mixed
+ {
+ if ($resolvedClassId === null) {
+ return $this->default($type);
+ }
+
+ return $resolvedClassId;
+ }
+
+ protected function default(Type $type): mixed
+ {
+ throw new \LogicException(\sprintf('Cannot resolve %s type as class', stringify($type)));
+ }
+}

src/Reflection/Visitor/ExternalTypeResolver.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection\Visitor;
+
+use Typhoon\DeclarationId\AliasId;
+use Typhoon\Reflection\ClassConstantReflection;
+use Typhoon\Reflection\TyphoonReflector;
+use Typhoon\Type\Type;
+use Typhoon\Type\types;
+use Typhoon\Type\Visitor\RecursiveTypeReplacer;
+
+/**
+ * @api
+ */
+final class ExternalTypeResolver extends RecursiveTypeReplacer
+{
+ public function __construct(
+ private readonly TyphoonReflector $reflector,
+ ) {}
+
+ public function alias(Type $type, AliasId $aliasId, array $typeArguments): mixed
+ {
+ // todo apply $typeArguments https://github.com/typhoon-php/typhoon/issues/65
+ return $this->reflector->reflect($aliasId)->type()->accept($this);
+ }
+
+ public function classConstant(Type $type, Type $classType, string $name): mixed
+ {
+ $classId = $classType->accept($this)->accept(new ClassIdResolver());
+
+ return $this->reflector->reflect($classId)->constants()[$name]->type()->accept($this);
+ }
+
+ public function classConstantMask(Type $type, Type $classType, string $namePrefix): mixed
+ {
+ $classId = $classType->accept($this)->accept(new ClassIdResolver());
+
+ $types = $this->reflector
+ ->reflect($classId)
+ ->constants()
+ ->filter(static fn(ClassConstantReflection $_constant, string $name): bool => str_starts_with($name, $namePrefix))
+ ->map(static fn(ClassConstantReflection $constant): Type => $constant->type())
+ ->toList();
+
+ return types::union(...$types);
+ }
+}

src/Reflection/Visitor/FloatLimitResolver.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection\Visitor;
+
+use Typhoon\Type\Type;
+use Typhoon\Type\Visitor\DefaultTypeVisitor;
+use function Typhoon\Type\stringify;
+
+/**
+ * @internal
+ * @psalm-internal Typhoon\Reflection\Visitor
+ * @extends DefaultTypeVisitor<int|float>
+ */
+final class FloatLimitResolver extends DefaultTypeVisitor
+{
+ public function intValue(Type $type, int $value): mixed
+ {
+ return $value;
+ }
+
+ public function floatValue(Type $type, float $value): mixed
+ {
+ return $value;
+ }
+
+ protected function default(Type $type): mixed
+ {
+ throw new \LogicException(\sprintf('Cannot resolve %s type as int range limit', stringify($type)));
+ }
+}

src/Reflection/Visitor/IntLimitResolver.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection\Visitor;
+
+use Typhoon\Type\Type;
+use Typhoon\Type\Visitor\DefaultTypeVisitor;
+use function Typhoon\Type\stringify;
+
+/**
+ * @internal
+ * @psalm-internal Typhoon\Reflection\Visitor
+ * @extends DefaultTypeVisitor<int>
+ */
+final class IntLimitResolver extends DefaultTypeVisitor
+{
+ public function intValue(Type $type, int $value): mixed
+ {
+ return $value;
+ }
+
+ protected function default(Type $type): mixed
+ {
+ throw new \LogicException(\sprintf('Cannot resolve %s type as int range limit', stringify($type)));
+ }
+}

src/Reflection/Visitor/IntMaskResolver.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection\Visitor;
+
+use Typhoon\Type\Type;
+use Typhoon\Type\Visitor\DefaultTypeVisitor;
+use function Typhoon\Type\stringify;
+
+/**
+ * @internal
+ * @psalm-internal Typhoon\Reflection\Visitor
+ * @extends DefaultTypeVisitor<positive-int>
+ */
+final class IntMaskResolver extends DefaultTypeVisitor
+{
+ public function intValue(Type $type, int $value): mixed
+ {
+ if ($value <= 0) {
+ return $this->default($type);
+ }
+
+ return $value;
+ }
+
+ public function union(Type $type, array $ofTypes): mixed
+ {
+ $mask = 0;
+
+ foreach ($ofTypes as $ofType) {
+ $mask |= $ofType->accept($this);
+ }
+
+ if ($mask <= 0) {
+ return $this->default($type);
+ }
+
+ return $mask;
+ }
+
+ protected function default(Type $type): mixed
+ {
+ throw new \LogicException(\sprintf('Cannot resolve %s type as int-mask type argument', stringify($type)));
+ }
+}

src/Reflection/Visitor/IsNever.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection\Visitor;
+
+use Typhoon\Type\Type;
+use Typhoon\Type\Visitor\DefaultTypeVisitor;
+
+/**
+ * @internal
+ * @psalm-internal Typhoon\Reflection\Visitor
+ * @extends DefaultTypeVisitor<bool>
+ */
+final class IsNever extends DefaultTypeVisitor
+{
+ public function never(Type $type): mixed
+ {
+ return true;
+ }
+
+ protected function default(Type $type): mixed
+ {
+ return false;
+ }
+}

src/Reflection/Visitor/KeyOfResolver.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection\Visitor;
+
+use Typhoon\Type\Type;
+use Typhoon\Type\types;
+use Typhoon\Type\Visitor\DefaultTypeVisitor;
+use function Typhoon\Type\stringify;
+
+/**
+ * @internal
+ * @psalm-internal Typhoon\Reflection\Visitor
+ * @extends DefaultTypeVisitor<Type>
+ */
+final class KeyOfResolver extends DefaultTypeVisitor
+{
+ public function list(Type $type, Type $valueType, array $elements): mixed
+ {
+ if ($valueType->accept(new IsNever())) {
+ return types::listShape(array_map(types::int(...), array_keys($elements)));
+ }
+
+ return types::nonNegativeInt;
+ }
+
+ public function array(Type $type, Type $keyType, Type $valueType, array $elements): mixed
+ {
+ if ($valueType->accept(new IsNever())) {
+ return types::listShape(array_map(types::int(...), array_keys($elements)));
+ }
+
+ return types::nonNegativeInt;
+ }
+
+ protected function default(Type $type): mixed
+ {
+ throw new \LogicException(\sprintf('Cannot resolve %s type as int range limit', stringify($type)));
+ }
+}