Implement prototype

src/Psalm/Internal/Type/Comparator/AtomicTypeComparator.php

@@ -31,10 +31,12 @@
 use Psalm\Type\Atomic\TNull;
 use Psalm\Type\Atomic\TObject;
 use Psalm\Type\Atomic\TObjectWithProperties;
+use Psalm\Type\Atomic\TSatisfiedBy;
 use Psalm\Type\Atomic\TScalar;
 use Psalm\Type\Atomic\TString;
 use Psalm\Type\Atomic\TTemplateKeyOf;
 use Psalm\Type\Atomic\TTemplateParam;
+use Psalm\Type\Atomic\TTemplateSatisfiedBy;
 use Psalm\Type\Atomic\TTemplateValueOf;
 use Psalm\Type\Atomic\TValueOf;
 use Psalm\Type\Union;
@@ -105,6 +107,32 @@ public static function isContainedBy(
             }
         }
 
+        if ($input_type_part instanceof TSatisfiedBy) {
+            if ($container_type_part instanceof TSatisfiedBy) {
+                return UnionTypeComparator::isContainedBy(
+                    $codebase,
+                    $input_type_part->type->as_type,
+                    $container_type_part->type->as_type,
+                    false,
+                    false,
+                    null,
+                    false,
+                    false,
+                );
+            } else {
+                return UnionTypeComparator::isContainedBy(
+                    $codebase,
+                    $input_type_part->type->as_type,
+                    new Union([$container_type_part]),
+                    false,
+                    false,
+                    null,
+                    false,
+                    false,
+                );
+            }
+        }
+
         if ($container_type_part instanceof TMixed
             || ($container_type_part instanceof TTemplateParam
                 && $container_type_part->as->isMixed()
@@ -432,6 +460,18 @@ public static function isContainedBy(
             );
         }
 
+        if ($container_type_part instanceof TTemplateSatisfiedBy) {
+            if (!$input_type_part instanceof TTemplateSatisfiedBy) {
+                return false;
+            }
+
+            return UnionTypeComparator::isContainedBy(
+                $codebase,
+                $input_type_part->as,
+                $container_type_part->as,
+            );
+        }
+
         if ($input_type_part instanceof TTemplateValueOf) {
             $array_value_type = TValueOf::getValueType($input_type_part->as, $codebase);
             if ($array_value_type === null) {
@@ -454,6 +494,28 @@ public static function isContainedBy(
             return true;
         }
 
+        if ($input_type_part instanceof TTemplateSatisfiedBy) {
+            $array_value_type = $input_type_part->as->as_type;
+            if ($array_value_type === null) {
+                return false;
+            }
+
+            foreach ($array_value_type->getAtomicTypes() as $array_value_atomic) {
+                if (!self::isContainedBy(
+                    $codebase,
+                    $array_value_atomic,
+                    $container_type_part,
+                    $allow_interface_equality,
+                    $allow_float_int_equality,
+                    $atomic_comparison_result,
+                )) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         if ($container_type_part instanceof TTemplateParam && $input_type_part instanceof TTemplateParam) {
             return UnionTypeComparator::isContainedBy(
                 $codebase,

src/Psalm/Internal/Type/ParseTree/TypeIsTree.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Psalm\Internal\Type\ParseTree;
+
+use Psalm\Internal\Type\ParseTree;
+
+/**
+ * @internal
+ */
+final class TypeIsTree extends ParseTree
+{
+}

src/Psalm/Internal/Type/ParseTreeCreator.php

@@ -562,11 +562,11 @@ private function handleColon(): void
             return;
         }
 
-        if (!$this->current_leaf instanceof Value) {
-            throw new TypeParseTreeException('Unexpected LHS of property');
-        }
-
         if ($current_parent instanceof KeyedArrayTree) {
+            if (!$this->current_leaf instanceof Value) {
+                throw new TypeParseTreeException('Unexpected LHS of property');
+            }
+
             $prev_token = $this->t > 0 ? $this->type_tokens[$this->t - 1] : null;
 
             $new_parent_leaf = new KeyedArrayPropertyTree($this->current_leaf->value, $current_parent);

src/Psalm/Internal/Type/SimpleAssertionReconciler.php

@@ -68,6 +68,7 @@
 use Psalm\Type\Atomic\TObject;
 use Psalm\Type\Atomic\TObjectWithProperties;
 use Psalm\Type\Atomic\TResource;
+use Psalm\Type\Atomic\TSatisfiedBy;
 use Psalm\Type\Atomic\TScalar;
 use Psalm\Type\Atomic\TString;
 use Psalm\Type\Atomic\TTemplateParam;
@@ -291,6 +292,10 @@ public static function reconcile(
 
         $assertion_type = $assertion->getAtomicType();
 
+        while ($assertion_type instanceof TSatisfiedBy) {
+            $assertion_type = $assertion_type->type->as_type;
+        }
+
         if ($assertion_type instanceof TObject) {
             return self::reconcileObject(
                 $codebase,

src/Psalm/Internal/Type/TemplateInferredTypeReplacer.php

@@ -22,11 +22,13 @@
 use Psalm\Type\Atomic\TObject;
 use Psalm\Type\Atomic\TObjectWithProperties;
 use Psalm\Type\Atomic\TPropertiesOf;
+use Psalm\Type\Atomic\TSatisfiedBy;
 use Psalm\Type\Atomic\TTemplateIndexedAccess;
 use Psalm\Type\Atomic\TTemplateKeyOf;
 use Psalm\Type\Atomic\TTemplateParam;
 use Psalm\Type\Atomic\TTemplateParamClass;
 use Psalm\Type\Atomic\TTemplatePropertiesOf;
+use Psalm\Type\Atomic\TTemplateSatisfiedBy;
 use Psalm\Type\Atomic\TTemplateValueOf;
 use Psalm\Type\Atomic\TValueOf;
 use Psalm\Type\Union;
@@ -173,6 +175,7 @@ public static function replace(
                 }
             } elseif ($atomic_type instanceof TTemplateKeyOf
                 || $atomic_type instanceof TTemplateValueOf
+                || $atomic_type instanceof TTemplateSatisfiedBy
             ) {
                 $new_type = self::replaceTemplateKeyOfValueOf(
                     $codebase,
@@ -234,12 +237,22 @@ public static function replace(
             throw new UnexpectedValueException('This array should be full');
         }
 
-        return $union->getBuilder()->setTypes(
+        $builder = $union->getBuilder()->setTypes(
             TypeCombiner::combine(
                 $atomic_types,
                 $codebase,
             )->getAtomicTypes(),
-        )->freeze();
+        );
+
+        if ($union->as_type !== null) {
+            $builder->as_type = self::replace(
+                $union->as_type,
+                $template_result,
+                $codebase
+            );
+        }
+
+        return $builder->freeze();
     }
 
     /**
@@ -333,7 +346,7 @@ private static function replaceTemplateParam(
     }
 
     /**
-     * @param TTemplateKeyOf|TTemplateValueOf $atomic_type
+     * @param TTemplateKeyOf|TTemplateValueOf|TTemplateSatisfiedBy $atomic_type
      * @param array<string, array<string, non-empty-list<TemplateBound>>> $inferred_lower_bounds
      */
     private static function replaceTemplateKeyOfValueOf(
@@ -362,6 +375,12 @@ private static function replaceTemplateKeyOfValueOf(
             return new TValueOf($template_type);
         }
 
+        if ($atomic_type instanceof TTemplateSatisfiedBy
+            && $template_type->as_type !== null
+        ) {
+            return new TSatisfiedBy($template_type);
+        }
+
         return null;
     }
 

src/Psalm/Internal/Type/TemplateStandinTypeReplacer.php

@@ -33,6 +33,7 @@
 use Psalm\Type\Atomic\TTemplateParam;
 use Psalm\Type\Atomic\TTemplateParamClass;
 use Psalm\Type\Atomic\TTemplatePropertiesOf;
+use Psalm\Type\Atomic\TTemplateSatisfiedBy;
 use Psalm\Type\Atomic\TTemplateValueOf;
 use Psalm\Type\Union;
 
@@ -324,7 +325,8 @@ private static function handleAtomicStandin(
         }
 
         if ($atomic_type instanceof TTemplateKeyOf
-            || $atomic_type instanceof TTemplateValueOf) {
+            || $atomic_type instanceof TTemplateValueOf
+            || $atomic_type instanceof TTemplateSatisfiedBy) {
             if (!$replace) {
                 return [$atomic_type];
             }
@@ -344,6 +346,12 @@ private static function handleAtomicStandin(
             }
 
             if ($template_type) {
+                if ($atomic_type instanceof TTemplateSatisfiedBy) {
+                    if ($template_type->as_type === null) {
+                        return [$atomic_type];
+                    }
+                    return $template_type->as_type->getAtomicTypes();
+                }
                 foreach ($template_type->getAtomicTypes() as $template_atomic) {
                     if (!$template_atomic instanceof TKeyedArray
                         && !$template_atomic instanceof TArray

src/Psalm/Internal/Type/TypeExpander.php

@@ -32,6 +32,7 @@
 use Psalm\Type\Atomic\TNull;
 use Psalm\Type\Atomic\TObjectWithProperties;
 use Psalm\Type\Atomic\TPropertiesOf;
+use Psalm\Type\Atomic\TSatisfiedBy;
 use Psalm\Type\Atomic\TTemplateParam;
 use Psalm\Type\Atomic\TTypeAlias;
 use Psalm\Type\Atomic\TValueOf;
@@ -355,6 +356,22 @@ public static function expandAtomic(
             );
         }
 
+        if ($return_type instanceof TSatisfiedBy) {
+            return self::expandTSatisfiedBy(
+                $codebase,
+                $return_type,
+                $self_class,
+                $static_class_type,
+                $parent_class,
+                $evaluate_class_constants,
+                $evaluate_conditional_types,
+                $final,
+                $expand_generic,
+                $expand_templates,
+                $throw_on_unresolvable_constant,
+            );
+        }
+
         if ($return_type instanceof TIntMask) {
             if (!$evaluate_class_constants) {
                 return [new TInt()];
@@ -1096,4 +1113,43 @@ private static function expandKeyOfValueOf(
 
         return array_values($new_return_types->getAtomicTypes());
     }
+
+
+    /**
+     * @return non-empty-list<Atomic>
+     */
+    private static function expandTSatisfiedBy(
+        Codebase $codebase,
+        TSatisfiedBy &$return_type,
+        ?string $self_class,
+        string|TNamedObject|TTemplateParam|null $static_class_type,
+        ?string $parent_class,
+        bool $evaluate_class_constants = true,
+        bool $evaluate_conditional_types = false,
+        bool $final = false,
+        bool $expand_generic = false,
+        bool $expand_templates = false,
+        bool $throw_on_unresolvable_constant = false,
+    ): array {
+        // Expand class constants to their atomics
+        $type_atomics = [];
+        foreach ($return_type->type->as_type->getAtomicTypes() as $type_param) {
+            $type_param_expanded = self::expandAtomic(
+                $codebase,
+                $type_param,
+                $self_class,
+                $static_class_type,
+                $parent_class,
+                $evaluate_class_constants,
+                $evaluate_conditional_types,
+                $final,
+                $expand_generic,
+                $expand_templates,
+                $throw_on_unresolvable_constant,
+            );
+            $type_atomics = [...$type_atomics, ...$type_param_expanded];
+        }
+
+        return $type_atomics;
+    }
 }

src/Psalm/Internal/Type/TypeParser.php

@@ -60,12 +60,14 @@
 use Psalm\Type\Atomic\TObject;
 use Psalm\Type\Atomic\TObjectWithProperties;
 use Psalm\Type\Atomic\TPropertiesOf;
+use Psalm\Type\Atomic\TSatisfiedBy;
 use Psalm\Type\Atomic\TString;
 use Psalm\Type\Atomic\TTemplateIndexedAccess;
 use Psalm\Type\Atomic\TTemplateKeyOf;
 use Psalm\Type\Atomic\TTemplateParam;
 use Psalm\Type\Atomic\TTemplateParamClass;
 use Psalm\Type\Atomic\TTemplatePropertiesOf;
+use Psalm\Type\Atomic\TTemplateSatisfiedBy;
 use Psalm\Type\Atomic\TTemplateValueOf;
 use Psalm\Type\Atomic\TTypeAlias;
 use Psalm\Type\Atomic\TUnknownClassString;
@@ -726,8 +728,10 @@ private static function getTypeFromGenericTree(
                     || $atomic_type instanceof TTemplateValueOf
                     || $atomic_type instanceof TTemplateKeyOf
                     || $atomic_type instanceof TTemplateParamClass
+                    || $atomic_type instanceof TTemplateSatisfiedBy
                     || $atomic_type instanceof TTypeAlias
                     || $atomic_type instanceof TValueOf
+                    || $atomic_type instanceof TSatisfiedBy
                     || $atomic_type instanceof TConditional
                     || $atomic_type instanceof TKeyOf
                     || !$from_docblock
@@ -965,6 +969,34 @@ private static function getTypeFromGenericTree(
             return new TValueOf($generic_params[0]);
         }
 
+        if ($generic_type_value === 'satisfied-by') {
+            $param_name = $generic_params[0]->getId(false);
+
+            if (isset($template_type_map[$param_name])
+                && ($defining_class = array_key_first($template_type_map[$param_name])) !== null
+            ) {
+                return new TTemplateSatisfiedBy(
+                    $param_name,
+                    $defining_class,
+                    $generic_params[0],
+                    $from_docblock,
+                );
+            }
+
+            if (!$generic_params[0]->as_type
+                && !$generic_params[0] instanceof TTypeAlias
+                && !$generic_params[0] instanceof TValueOf
+                && !$generic_params[0] instanceof TKeyOf
+                && !$generic_params[0] instanceof TPropertiesOf
+            ) {
+                throw new TypeParseTreeException(
+                    'Untemplated satisfied-by param ' . $param_name . ' should have an upper bound!',
+                );
+            }
+
+            return new TSatisfiedBy($generic_params[0]);
+        }
+
         if ($generic_type_value === 'int-mask') {
             $atomic_types = [];
 

src/Psalm/Internal/Type/TypeTokenizer.php

@@ -90,6 +90,7 @@ final class TypeTokenizer
         'public-properties-of' => true,
         'protected-properties-of' => true,
         'private-properties-of' => true,
+        'satisfied-by' => true,
         'non-empty-countable' => true,
         'list' => true,
         'non-empty-list' => true,