Introduce default hydration mode

src/Type/Doctrine/CreateQueryDynamicReturnTypeExtension.php

@@ -16,6 +16,7 @@
 use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\ConstantTypeHelper;
 use PHPStan\Type\Doctrine\Query\QueryResultTypeBuilder;
 use PHPStan\Type\Doctrine\Query\QueryResultTypeWalker;
 use PHPStan\Type\Doctrine\Query\QueryType;
@@ -76,7 +77,7 @@
 		if (!isset($args[$queryStringArgIndex])) {
 			return new GenericObjectType(
 				Query::class,
-				[new MixedType(), new MixedType()],
+				[new MixedType(), new MixedType(), new MixedType()],
 			);
 		}
 
@@ -95,21 +96,28 @@
 				}
 
 				$typeBuilder = new QueryResultTypeBuilder();
+				$query = $em->createQuery($queryString);
+				$hydrationMode = ConstantTypeHelper::getTypeFromValue($query->getHydrationMode());
 
 				try {
-					$query = $em->createQuery($queryString);
 					QueryResultTypeWalker::walk($query, $typeBuilder, $this->descriptorRegistry, $this->phpVersion, $this->driverDetector);
 				} catch (ORMException | DBALException | NewDBALException | CommonException | MappingException | \Doctrine\ORM\Exception\ORMException $e) {
-					return new QueryType($queryString, null, null);
+					return new QueryType($queryString, null, null, null, $hydrationMode);
 				} catch (AssertionError $e) {
-					return new QueryType($queryString, null, null);
+					return new QueryType($queryString, null, null, null, $hydrationMode);
 				}
 
-				return new QueryType($queryString, $typeBuilder->getIndexType(), $typeBuilder->getResultType());
+				return new QueryType(
+					$queryString,
+					$typeBuilder->getIndexType(),
+					$typeBuilder->getResultType(),
+					null,
+					$hydrationMode,
+				);
 			}
 			return new GenericObjectType(
 				Query::class,
-				[new MixedType(), new MixedType()],
+				[new MixedType(), new MixedType(), new MixedType()],
 			);
 		});
 	}

src/Type/Doctrine/HydrationModeReturnTypeResolver.php

@@ -3,7 +3,6 @@
 namespace PHPStan\Type\Doctrine;
 
 use Doctrine\ORM\AbstractQuery;
-use Doctrine\Persistence\ObjectManager;
 use PHPStan\Type\Accessory\AccessoryArrayListType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BenevolentUnionType;
@@ -25,7 +24,7 @@ public function getMethodReturnTypeForHydrationMode(
 		Type $hydrationMode,
 		Type $queryKeyType,
 		Type $queryResultType,
-		?ObjectManager $objectManager
+		?Type $defaultHydrationModeType = null
 	): ?Type
 	{
 		$isVoidType = (new VoidType())->isSuperTypeOf($queryResultType);
@@ -42,6 +41,10 @@ public function getMethodReturnTypeForHydrationMode(
 			return null;
 		}
 
+		if ($defaultHydrationModeType !== null && $hydrationMode->isNull()->yes()) {
+			$hydrationMode = $defaultHydrationModeType;
+		}
+
 		if (!$hydrationMode instanceof ConstantIntegerType) {
 			return null;
 		}

src/Type/Doctrine/Query/QueryResultDynamicReturnTypeExtension.php

@@ -9,7 +9,6 @@
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\Doctrine\HydrationModeReturnTypeResolver;
-use PHPStan\Type\Doctrine\ObjectMetadataResolver;
 use PHPStan\Type\DynamicMethodReturnTypeExtension;
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
@@ -27,16 +26,12 @@ final class QueryResultDynamicReturnTypeExtension implements DynamicMethodReturn
 		'getSingleResult' => 0,
 	];
 
-	private ObjectMetadataResolver $objectMetadataResolver;
-
 	private HydrationModeReturnTypeResolver $hydrationModeReturnTypeResolver;
 
 	public function __construct(
-		ObjectMetadataResolver $objectMetadataResolver,
 		HydrationModeReturnTypeResolver $hydrationModeReturnTypeResolver
 	)
 	{
-		$this->objectMetadataResolver = $objectMetadataResolver;
 		$this->hydrationModeReturnTypeResolver = $hydrationModeReturnTypeResolver;
 	}
 
@@ -84,7 +79,7 @@ public function getTypeFromMethodCall(
 			$hydrationMode,
 			$queryType->getTemplateType(AbstractQuery::class, 'TKey'),
 			$queryType->getTemplateType(AbstractQuery::class, 'TResult'),
-			$this->objectMetadataResolver->getObjectManager(),
+			$queryType->getTemplateType(AbstractQuery::class, 'THydrationMode'),
 		);
 	}
 

src/Type/Doctrine/Query/QueryType.php

@@ -15,16 +15,26 @@ class QueryType extends GenericObjectType
 
 	private Type $resultType;
 
+	private Type $defaultHydrationModeType;
+
 	private string $dql;
 
-	public function __construct(string $dql, ?Type $indexType = null, ?Type $resultType = null, ?Type $subtractedType = null)
+	public function __construct(
+		string $dql,
+		?Type $indexType = null,
+		?Type $resultType = null,
+		?Type $subtractedType = null,
+		?Type $defaultHydrationModeType = null
+	)
 	{
 		$this->indexType = $indexType ?? new MixedType();
 		$this->resultType = $resultType ?? new MixedType();
+		$this->defaultHydrationModeType = $defaultHydrationModeType ?? new MixedType();
 
 		parent::__construct('Doctrine\ORM\Query', [
 			$this->indexType,
 			$this->resultType,
+			$this->defaultHydrationModeType,
 		], $subtractedType);
 
 		$this->dql = $dql;
@@ -41,7 +51,7 @@ public function equals(Type $type): bool
 
 	public function changeSubtractedType(?Type $subtractedType): Type
 	{
-		return new self('Doctrine\ORM\Query', $this->indexType, $this->resultType, $subtractedType);
+		return new self('Doctrine\ORM\Query', $this->indexType, $this->resultType, $subtractedType, $this->defaultHydrationModeType);
 	}
 
 	public function isSuperTypeOf(Type $type): IsSuperTypeOfResult

src/Type/Doctrine/QueryBuilder/QueryBuilderGetQueryDynamicReturnTypeExtension.php

@@ -7,6 +7,7 @@
 use Doctrine\DBAL\DBALException;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\ORMException;
+use Doctrine\ORM\QueryBuilder;
 use Doctrine\Persistence\Mapping\MappingException;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Identifier;
@@ -15,6 +16,7 @@
 use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Rules\Doctrine\ORM\DynamicQueryBuilderArgumentException;
+use PHPStan\Type\ConstantTypeHelper;
 use PHPStan\Type\Doctrine\ArgumentsProcessor;
 use PHPStan\Type\Doctrine\DescriptorRegistry;
 use PHPStan\Type\Doctrine\DoctrineTypeUtils;
@@ -183,31 +185,41 @@
 				}
 			}
 
-			$resultTypes[] = $this->getQueryType($queryBuilder->getDQL());
+			$resultTypes[] = $this->getQueryType($queryBuilder);
 		}
 
 		return TypeCombinator::union(...$resultTypes);
 	}
 
-	private function getQueryType(string $dql): Type
+	private function getQueryType(QueryBuilder $queryBuilder): Type
 	{
+		$dql = $queryBuilder->getDQL();
+
 		$em = $this->objectMetadataResolver->getObjectManager();
 		if (!$em instanceof EntityManagerInterface) {
 			return new QueryType($dql, null);
 		}
 
+		$hydrationMode = ConstantTypeHelper::getTypeFromValue($queryBuilder->getQuery()->getHydrationMode());
+
 		$typeBuilder = new QueryResultTypeBuilder();
+		$query = $em->createQuery($dql);
 
 		try {
-			$query = $em->createQuery($dql);
 			QueryResultTypeWalker::walk($query, $typeBuilder, $this->descriptorRegistry, $this->phpVersion, $this->driverDetector);
 		} catch (ORMException | DBALException | CommonException | MappingException | \Doctrine\ORM\Exception\ORMException $e) {
-			return new QueryType($dql, null);
+			return new QueryType($dql, null, null, null, $hydrationMode);
 		} catch (AssertionError $e) {
-			return new QueryType($dql, null);
+			return new QueryType($dql, null, null, null, $hydrationMode);
 		}
 
-		return new QueryType($dql, $typeBuilder->getIndexType(), $typeBuilder->getResultType());
+		return new QueryType(
+			$dql,
+			$typeBuilder->getIndexType(),
+			$typeBuilder->getResultType(),
+			null,
+			$hydrationMode,
+		);
 	}
 
 }

stubs/ORM/AbstractQuery.stub

@@ -9,6 +9,7 @@ use Doctrine\ORM\NoResultException;
 /**
  * @template-covariant TKey The type of column used in indexBy
  * @template-covariant TResult The type of results returned by this query in HYDRATE_OBJECT mode
+ * @template-covariant THydrationMode of string|AbstractQuery::HYDRATE_* = string|AbstractQuery::HYDRATE_* The default hydration mode when none is provided
  */
 abstract class AbstractQuery
 {
@@ -84,4 +85,14 @@ abstract class AbstractQuery
     {
     }
 
+    /**
+     * @template TNewHydrationMode of string|AbstractQuery::HYDRATE_*
+     * @param TNewHydrationMode $hydrationMode
+     * @phpstan-self-out static<TKey, TResult, TNewHydrationMode>
+     * @return static<TKey, TResult, TNewHydrationMode>
+     */
+    public function setHydrationMode($hydrationMode): static
+    {
+    }
+
 }

stubs/ORM/Query.stub

@@ -5,9 +5,21 @@ namespace Doctrine\ORM;
 /**
  * @template-covariant TKey The type of column used in indexBy
  * @template-covariant TResult The type of results returned by this query in HYDRATE_OBJECT mode
+ * @template-covariant THydrationMode of string|AbstractQuery::HYDRATE_* = string|AbstractQuery::HYDRATE_* The default hydration mode when none is provided
  *
- * @extends AbstractQuery<TKey, TResult>
+ * @extends AbstractQuery<TKey, TResult, THydrationMode>
  */
 final class Query extends AbstractQuery
 {
+
+    /**
+     * @template TNewHydrationMode of string|AbstractQuery::HYDRATE_*
+     * @param TNewHydrationMode $hydrationMode
+     * @phpstan-self-out static<TKey, TResult, TNewHydrationMode>
+     * @return static<TKey, TResult, TNewHydrationMode>
+     */
+    public function setHydrationMode($hydrationMode): static
+    {
+    }
+
 }

stubs/ORM/QueryBuilder.stub

@@ -2,6 +2,7 @@
 
 namespace Doctrine\ORM;
 
+use Doctrine\ORM\AbstractQuery;
 use Doctrine\ORM\Query\Expr;
 
 class QueryBuilder
@@ -17,7 +18,7 @@ class QueryBuilder
 	}
 
 	/**
-	 * @return Query<mixed>
+	 * @return Query<null, mixed, AbstractQuery::HYDRATE_OBJECT>
 	 */
 	public function getQuery()
 	{

tests/DoctrineIntegration/ORM/data/queryBuilder.php

@@ -67,7 +67,7 @@ public function usingMethodThatReturnStatic(): ?MyEntity
 			]);
 
 		$result = $queryBuilder->getQuery()->getOneOrNullResult();
-		assertType('mixed', $result);
+		assertType('PHPStan\DoctrineIntegration\ORM\CustomRepositoryUsage\MyEntity|null', $result);
 
 		return $result;
 	}

tests/Type/Doctrine/Query/QueryResultTypeWalkerHydrationModeTest.php

@@ -77,7 +77,7 @@
 		$typeBuilder = new QueryResultTypeBuilder();
 
 		QueryResultTypeWalker::walk(
 			$query,
 			$typeBuilder,
 			self::getContainer()->getByType(DescriptorRegistry::class),
 			self::getContainer()->getByType(PhpVersion::class),
@@ -91,7 +91,6 @@
 			new ConstantIntegerType($this->getRealHydrationMode($methodName, $hydrationMode)),
 			$typeBuilder->getIndexType(),
 			$typeBuilder->getResultType(),
-			$entityManager,
 		) ?? new MixedType();
 
 		self::assertSame(

tests/Type/Doctrine/data/QueryResult/createQuery.php

@@ -15,42 +15,42 @@ public function testQueryTypeParametersAreInfered(EntityManagerInterface $em): v
 			FROM		QueryResult\Entities\Many m
 		');
 
-		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many>', $query);
+		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many, 1>', $query);
 
 		$query = $em->createQuery('
 			SELECT		m.intColumn, m.stringNullColumn
 			FROM		QueryResult\Entities\Many m
 		');
 
-		assertType('Doctrine\ORM\Query<null, array{intColumn: int, stringNullColumn: string|null}>', $query);
+		assertType('Doctrine\ORM\Query<null, array{intColumn: int, stringNullColumn: string|null}, 1>', $query);
 	}
 
 	public function testQueryTypeSimpleArray(EntityManagerInterface $em): void
 	{
 		$query = $em->createQuery('SELECT m.simpleArrayColumn FROM QueryResult\Entities\Many m');
 
-		assertType('Doctrine\ORM\Query<null, array{simpleArrayColumn: list<string>}>', $query);
+		assertType('Doctrine\ORM\Query<null, array{simpleArrayColumn: list<string>}, 1>', $query);
 	}
 
 	public function testMappingError(EntityManagerInterface $em): void
 	{
 		$query = $em->createQuery('SELECT u.foo FROM ' . CreateQuery::class . ' u');
 
-		assertType('Doctrine\ORM\Query<mixed, mixed>', $query);
+		assertType('Doctrine\ORM\Query<mixed, mixed, 1>', $query);
 	}
 
 	public function testQueryResultTypeIsMixedWhenDQLIsNotKnown(EntityManagerInterface $em, string $dql): void
 	{
 		$query = $em->createQuery($dql);
 
-		assertType('Doctrine\ORM\Query<mixed, mixed>', $query);
+		assertType('Doctrine\ORM\Query<mixed, mixed, mixed>', $query);
 	}
 
 	public function testQueryResultTypeIsMixedWhenDQLIsInvalid(EntityManagerInterface $em, string $dql): void
 	{
 		$query = $em->createQuery('invalid');
 
-		assertType('Doctrine\ORM\Query<mixed, mixed>', $query);
+		assertType('Doctrine\ORM\Query<mixed, mixed, 1>', $query);
 	}
 
 }

tests/Type/Doctrine/data/QueryResult/queryBuilderExpressionTypeResolver.php

@@ -25,15 +25,15 @@ public function testQueryTypeIsInferredOnAcrossMethods(EntityManagerInterface $e
 		$query = $this->getQueryBuilder($em)->getQuery();
 		$branchingQuery = $this->getBranchingQueryBuilder($em)->getQuery();
 
-		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many>', $query);
-		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many>#1|Doctrine\ORM\Query<null, QueryResult\Entities\Many>#2', $branchingQuery);
+		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many, 1>', $query);
+		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many, 1>#1|Doctrine\ORM\Query<null, QueryResult\Entities\Many, 1>#2', $branchingQuery);
 	}
 
 	public function testQueryTypeIsInferredOnAcrossMethodsEvenWhenVariableAssignmentIsUsed(EntityManagerInterface $em): void
 	{
 		$queryBuilder = $this->getQueryBuilder($em);
 
-		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many>', $queryBuilder->getQuery());
+		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many, 1>', $queryBuilder->getQuery());
 	}
 
 	public function testQueryBuilderPassedElsewhereNotTracked(EntityManagerInterface $em): void
@@ -43,22 +43,22 @@ public function testQueryBuilderPassedElsewhereNotTracked(EntityManagerInterface
 
 		$this->adjustQueryBuilderToIndexByInt($queryBuilder);
 
-		assertType('Doctrine\ORM\Query<string, QueryResult\Entities\Many>', $queryBuilder->getQuery());
+		assertType('Doctrine\ORM\Query<string, QueryResult\Entities\Many, 1>', $queryBuilder->getQuery());
 	}
 
 	public function testDiveIntoCustomEntityRepository(EntityManagerInterface $em): void
 	{
 		$queryBuilder = $this->myRepository->getCustomQueryBuilder($em);
 
-		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many>', $queryBuilder->getQuery());
+		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many, 1>', $queryBuilder->getQuery());
 	}
 
 
 	public function testStaticCallWorksToo(EntityManagerInterface $em): void
 	{
 		$queryBuilder = self::getStaticQueryBuilder($em);
 
-		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many>', $queryBuilder->getQuery());
+		assertType('Doctrine\ORM\Query<null, QueryResult\Entities\Many, 1>', $queryBuilder->getQuery());
 	}
 
 	public function testFirstClassCallableDoesNotFail(EntityManagerInterface $em): void