Fixes #8112

vimeo · Nov 30, 2022 · 0d9d0ed · 0d9d0ed
1 parent 870f581
commit 0d9d0ed
Show file tree

Hide file tree

Showing 2 changed files with 135 additions and 0 deletions.
diff --git a/src/Psalm/Internal/Type/Comparator/ObjectComparator.php b/src/Psalm/Internal/Type/Comparator/ObjectComparator.php
@@ -6,6 +6,7 @@
 use Psalm\Internal\Analyzer\Statements\ExpressionAnalyzer;
 use Psalm\Type\Atomic;
 use Psalm\Type\Atomic\TIterable;
+use Psalm\Type\Atomic\TMixed;
 use Psalm\Type\Atomic\TNamedObject;
 use Psalm\Type\Atomic\TObjectWithProperties;
 use Psalm\Type\Atomic\TTemplateParam;
@@ -32,6 +33,17 @@ public static function isShallowlyContainedBy(
         bool $allow_interface_equality,
         ?TypeComparisonResult $atomic_comparison_result
     ): bool {
+        if ($container_type_part instanceof TTemplateParam && $input_type_part instanceof TTemplateParam
+            && 1 == count($container_type_part->as->getAtomicTypes()) && 1 == count($input_type_part->as->getAtomicTypes())) {
+            $containerAs = current($container_type_part->as->getAtomicTypes());
+            $inputAs = current($input_type_part->as->getAtomicTypes());
+            if ($containerAs instanceof TNamedObject && $inputAs instanceof TNamedObject) {
+                return self::isShallowlyContainedBy($codebase, current($input_type_part->as->getAtomicTypes()), current($container_type_part->as->getAtomicTypes()), $allow_interface_equality, $atomic_comparison_result);
+            } else if ($containerAs instanceof TMixed && $inputAs instanceof TMixed) {
+                return true;
+            }
+        }
+
         $intersection_input_types = self::getIntersectionTypes($input_type_part);
         $intersection_container_types = self::getIntersectionTypes($container_type_part);
 

diff --git a/tests/Template/NestedTemplateTest.php b/tests/Template/NestedTemplateTest.php
@@ -124,6 +124,129 @@ function toList(array $arr): array {
                         return reset($arr);
                     }'
             ],
+            '3levelNestedTemplatesOfMixed' => [
+                'code' => '<?php
+                    /** @template T */
+                    interface A {}
+
+                    /**
+                     * @template T
+                     * @template U of A<T>
+                     */
+                    interface B {}
+
+                    /** @template T */
+                    interface J {}
+
+                    /**
+                     * @template T
+                     * @template U of A<T>
+                     * @implements J<U>
+                     */
+                    class K2 implements J {}
+
+                    /**
+                     * @template T
+                     * @template U of A<T>
+                     * @template V of B<T, U>
+                     * @extends J<V>
+                     */
+                    interface K3 extends J {}
+
+                    /**
+                     * @template T
+                     * @template U of A<T>
+                     * @template V of B<T, U>
+                     * @implements J<V>
+                     */
+                    class K1 implements J {}'
+            ],
+            '4levelNestedTemplatesOfObjects' => [
+                'code' => '<?php
+                    /**
+                     * Interface for all DB entities that map to some data-model object.
+                     *
+                     * @template T
+                     */
+                    interface DbEntity
+                    {
+                        /**
+                         * Maps this entity to a data-model entity
+                         *
+                         * @return T Data-model entity to which this DB entity maps.
+                         */
+                        public function toCore();
+                    }
+
+                    /**
+                     * @template T of object
+                     */
+                    abstract class EntityRepository {}
+
+                    /**
+                     * Base entity repository with common tooling.
+                     *
+                     * @template T of object
+                     * @extends EntityRepository<T>
+                     */
+                    abstract class DbEntityRepository
+                    extends EntityRepository {}
+
+                    interface ObjectId {}
+
+                    /**
+                     * @template I of ObjectId
+                     */
+                    interface AnObject {}
+
+                    /**
+                     * Base entity repository with common tooling.
+                     *
+                     * @template I of ObjectId
+                     * @template O of AnObject<I>
+                     * @template E of DbEntity<O>
+                     * @extends DbEntityRepository<E>
+                     */
+                    abstract class AnObjectEntityRepository
+                    extends DbEntityRepository
+                    {}
+
+                    /**
+                     * Base repository implementation backed by a Db repository.
+                     *
+                     * @template T
+                     * @template E of DbEntity<T>
+                     * @template R of DbEntityRepository<E>
+                     */
+                    abstract class DbRepositoryWrapper
+                    {
+                        /** @var R $repo Db repository */
+                        private DbEntityRepository $repo;
+
+                        /**
+                         * Getter for the Db repository.
+                         *
+                         * @return DbEntityRepository The Db repository.
+                         * @psalm-return R
+                         */
+                        protected function getDbRepo(): DbEntityRepository
+                        {
+                            return $this->repo;
+                        }
+                    }
+
+                    /**
+                     * Base implementation for all custom repositories that map to Core objects.
+                     *
+                     * @template I of ObjectId
+                     * @template O of AnObject<I>
+                     * @template E of DbEntity<O>
+                     * @template R of AnObjectEntityRepository<I, O, E>
+                     * @extends DbRepositoryWrapper<O, E, R>
+                     */
+                    abstract class AnObjectDbRepositoryWrapper
+                    extends DbRepositoryWrapper {}'
+            ]
         ];
     }