Merge remote-tracking branch 'origin/1.3.x' into 1.4.x

extension.neon

@@ -398,3 +398,8 @@ services:
  class: PHPStan\PhpDoc\Doctrine\QueryTypeNodeResolverExtension
  tags:
  - phpstan.phpDoc.typeNodeResolverExtension
+
+ -
+ class: PHPStan\Type\Doctrine\EntityManagerInterfaceThrowTypeExtension
+ tags:
+ - phpstan.dynamicMethodThrowTypeExtension

phpstan-baseline.neon

@@ -40,6 +40,11 @@ parameters:
  count: 1
  path: tests/Rules/Exceptions/CatchWithUnthrownExceptionRuleTest.php
 
+ -
+ message: "#^Accessing PHPStan\\\\Rules\\\\Exceptions\\\\TooWideMethodThrowTypeRule\\:\\:class is not covered by backward compatibility promise\\. The class might change in a minor PHPStan version\\.$#"
+ count: 1
+ path: tests/Rules/Exceptions/TooWideMethodThrowTypeRuleTest.php
+
  -
  message: "#^Accessing PHPStan\\\\Rules\\\\DeadCode\\\\UnusedPrivatePropertyRule\\:\\:class is not covered by backward compatibility promise\\. The class might change in a minor PHPStan version\\.$#"
  count: 1
@@ -59,4 +64,3 @@ parameters:
  message: "#^Accessing PHPStan\\\\Rules\\\\Properties\\\\MissingReadOnlyPropertyAssignRule\\:\\:class is not covered by backward compatibility promise\\. The class might change in a minor PHPStan version\\.$#"
  count: 1
  path: tests/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php
-

rules.neon

@@ -35,6 +35,7 @@ services:
  class: PHPStan\Rules\Doctrine\ORM\QueryBuilderDqlRule
  arguments:
  reportDynamicQueryBuilders: %doctrine.reportDynamicQueryBuilders%
+ searchOtherMethodsForQueryBuilderBeginning: %doctrine.searchOtherMethodsForQueryBuilderBeginning%
  tags:
  - phpstan.rules.rule
  -

src/Rules/Doctrine/ORM/QueryBuilderDqlRule.php

@@ -12,6 +12,7 @@
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Doctrine\DoctrineTypeUtils;
 use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+use PHPStan\Type\Doctrine\QueryBuilder\OtherMethodQueryBuilderParser;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\TypeUtils;
 use Throwable;
@@ -31,13 +32,23 @@ class QueryBuilderDqlRule implements Rule
  /** @var bool */
  private $reportDynamicQueryBuilders;
 
+ /** @var OtherMethodQueryBuilderParser */
+ private $otherMethodQueryBuilderParser;
+
+ /** @var bool */
+ private $searchOtherMethodsForQueryBuilderBeginning;
+
  public function __construct(
  ObjectMetadataResolver $objectMetadataResolver,
- bool $reportDynamicQueryBuilders
+ OtherMethodQueryBuilderParser $otherMethodQueryBuilderParser,
+ bool $reportDynamicQueryBuilders,
+ bool $searchOtherMethodsForQueryBuilderBeginning
  )
  {
  $this->objectMetadataResolver = $objectMetadataResolver;
+ $this->otherMethodQueryBuilderParser = $otherMethodQueryBuilderParser;
  $this->reportDynamicQueryBuilders = $reportDynamicQueryBuilders;
+ $this->searchOtherMethodsForQueryBuilderBeginning = $searchOtherMethodsForQueryBuilderBeginning;
  }
 
  public function getNodeType(): string
@@ -58,6 +69,14 @@ public function processNode(Node $node, Scope $scope): array
  $calledOnType = $scope->getType($node->var);
  $queryBuilderTypes = DoctrineTypeUtils::getQueryBuilderTypes($calledOnType);
  if (count($queryBuilderTypes) === 0) {
+
+ if ($this->searchOtherMethodsForQueryBuilderBeginning) {
+ $queryBuilderTypes = $this->otherMethodQueryBuilderParser->getQueryBuilderTypes($scope, $node);
+ if (count($queryBuilderTypes) !== 0) {
+ return [];
+ }
+ }
+
  if (
  $this->reportDynamicQueryBuilders
  && (new ObjectType('Doctrine\ORM\QueryBuilder'))->isSuperTypeOf($calledOnType)->yes()

src/Type/Doctrine/EntityManagerInterfaceThrowTypeExtension.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine;
+
+use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Exception\ORMException;
+use Doctrine\Persistence\ObjectManager;
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\DynamicMethodThrowTypeExtension;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use function array_map;
+
+class EntityManagerInterfaceThrowTypeExtension implements DynamicMethodThrowTypeExtension
+{
+
+ public const SUPPORTED_METHOD = [
+ 'flush' => [
+ ORMException::class,
+ UniqueConstraintViolationException::class,
+ ],
+ ];
+
+ public function isMethodSupported(MethodReflection $methodReflection): bool
+ {
+ return $methodReflection->getDeclaringClass()->getName() === ObjectManager::class
+ && isset(self::SUPPORTED_METHOD[$methodReflection->getName()]);
+ }
+
+ public function getThrowTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
+ {
+ $type = $scope->getType($methodCall->var);
+
+ if ((new ObjectType(EntityManagerInterface::class))->isSuperTypeOf($type)->yes()) {
+ return TypeCombinator::union(
+ ...array_map(static function ($class): Type {
+ return new ObjectType($class);
+ }, self::SUPPORTED_METHOD[$methodReflection->getName()])
+ );
+ }
+
+ return $methodReflection->getThrowType();
+ }
+
+}

src/Type/Doctrine/QueryBuilder/OtherMethodQueryBuilderParser.php

@@ -19,6 +19,10 @@
 use PHPStan\Parser\Parser;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\Generic\TemplateTypeMap;
+use PHPStan\Type\IntersectionType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeTraverser;
+use PHPStan\Type\UnionType;
 use function count;
 use function is_array;
 
@@ -118,11 +122,18 @@ private function findQueryBuilderTypesInCalledMethod(Scope $scope, MethodCall $m
  }
 
  $exprType = $scope->getType($node->expr);
- if (!$exprType instanceof QueryBuilderType) {
- return;
- }
 
- $queryBuilderTypes[] = $exprType;
+ TypeTraverser::map($exprType, static function (Type $type, callable $traverse) use (&$queryBuilderTypes): Type {
+ if ($type instanceof UnionType || $type instanceof IntersectionType) {
+ return $traverse($type);
+ }
+
+ if ($type instanceof QueryBuilderType) {
+ $queryBuilderTypes[] = $type;
+ }
+
+ return $type;
+ });
  });
 
  return $queryBuilderTypes;

stubs/EntityManagerInterface.stub

@@ -60,11 +60,12 @@ interface EntityManagerInterface extends ObjectManager
  */
  public function copy($entity, $deep = false);
 
- /**
- * @template T of object
- * @phpstan-param class-string<T> $className
- *
- * @phpstan-return ClassMetadata<T>
- */
- public function getClassMetadata($className);
+ /**
+ * @template T of object
+ * @phpstan-param class-string<T> $className
+ *
+ * @phpstan-return ClassMetadata<T>
+ */
+ public function getClassMetadata($className);
+
 }

stubs/bleedingEdge/ORM/QueryBuilder.stub

@@ -58,9 +58,9 @@ class QueryBuilder
  }
 
  /**
- * @param literal-string  $from
- * @param literal-string $alias
- * @param literal-string|null $indexBy
+ * @param literal-string|class-string $from
+ * @param literal-string  $alias
+ * @param literal-string|null  $indexBy
  *
  * @return $this
  */
@@ -70,7 +70,7 @@ class QueryBuilder
  }
 
  /**
- * @param literal-string  $join
+ * @param literal-string|class-string $join
  * @param literal-string $alias
  * @param Expr\Join::ON|Expr\Join::WITH|null $conditionType
  * @param literal-string|Expr\Comparison|Expr\Composite|Expr\Func|null $condition
@@ -84,7 +84,7 @@ class QueryBuilder
  }
 
  /**
- * @param literal-string  $join
+ * @param literal-string|class-string $join
  * @param literal-string $alias
  * @param Expr\Join::ON|Expr\Join::WITH|null $conditionType
  * @param literal-string|Expr\Comparison|Expr\Composite|Expr\Func|null $condition
@@ -98,7 +98,7 @@ class QueryBuilder
  }
 
  /**
- * @param literal-string  $join
+ * @param literal-string|class-string $join
  * @param literal-string $alias
  * @param Expr\Join::ON|Expr\Join::WITH|null $conditionType
  * @param literal-string|Expr\Comparison|Expr\Composite|Expr\Func|null $condition

tests/Rules/Doctrine/ORM/QueryBuilderDqlRuleSlowTest.php

@@ -5,6 +5,7 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+use PHPStan\Type\Doctrine\QueryBuilder\OtherMethodQueryBuilderParser;
 
 /**
  * @extends RuleTestCase<QueryBuilderDqlRule>
@@ -14,7 +15,12 @@ class QueryBuilderDqlRuleSlowTest extends RuleTestCase
 
  protected function getRule(): Rule
  {
- return new QueryBuilderDqlRule(new ObjectMetadataResolver(__DIR__ . '/entity-manager.php'), true);
+ return new QueryBuilderDqlRule(
+ new ObjectMetadataResolver(__DIR__ . '/entity-manager.php'),
+ self::getContainer()->getByType(OtherMethodQueryBuilderParser::class),
+ true,
+ true
+ );
  }
 
  public function testRule(): void
@@ -40,10 +46,6 @@ public function testRule(): void
  'QueryBuilder: [Semantical Error] line 0, col 14 near \'Foo e\': Error: Class \'Foo\' is not defined.',
  71,
  ],
- [
- 'Could not analyse QueryBuilder with unknown beginning.',
- 89,
- ],
  [
  'Could not analyse QueryBuilder with dynamic arguments.',
  99,

tests/Rules/Doctrine/ORM/QueryBuilderDqlRuleTest.php

@@ -5,6 +5,7 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+use PHPStan\Type\Doctrine\QueryBuilder\OtherMethodQueryBuilderParser;
 
 /**
  * @extends RuleTestCase<QueryBuilderDqlRule>
@@ -14,7 +15,12 @@ class QueryBuilderDqlRuleTest extends RuleTestCase
 
  protected function getRule(): Rule
  {
- return new QueryBuilderDqlRule(new ObjectMetadataResolver(__DIR__ . '/entity-manager.php'), true);
+ return new QueryBuilderDqlRule(
+ new ObjectMetadataResolver(__DIR__ . '/entity-manager.php'),
+ self::getContainer()->getByType(OtherMethodQueryBuilderParser::class),
+ true,
+ true
+ );
  }
 
  public function testRule(): void
@@ -40,10 +46,6 @@ public function testRule(): void
  'QueryBuilder: [Semantical Error] line 0, col 14 near \'Foo e\': Error: Class \'Foo\' is not defined.',
  71,
  ],
- [
- 'Could not analyse QueryBuilder with unknown beginning.',
- 89,
- ],
  [
  'Could not analyse QueryBuilder with dynamic arguments.',
  99,

tests/Rules/Exceptions/TooWideMethodThrowTypeRuleTest.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Exceptions;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<TooWideMethodThrowTypeRule>
+ */
+class TooWideMethodThrowTypeRuleTest extends RuleTestCase
+{
+
+ protected function getRule(): Rule
+ {
+ return self::getContainer()->getByType(TooWideMethodThrowTypeRule::class);
+ }
+
+ public function testRule(): void
+ {
+ $this->analyse([__DIR__ . '/data/entity-manager-interface.php'], []);
+ }
+
+ public static function getAdditionalConfigFiles(): array
+ {
+ return [
+ __DIR__ . '/../../../extension.neon',
+ ];
+ }
+
+}

tests/Rules/Exceptions/data/entity-manager-interface.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace EntityManagerInterfaceThrowTypeExtensionTest;
+
+use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Exception\ORMException;
+
+class Example
+{
+
+ /**
+ * @throws ORMException
+ * @throws UniqueConstraintViolationException
+ */
+ public function doFoo(EntityManagerInterface $entityManager): void
+ {
+ $entityManager->flush();
+ }
+
+}

tests/Rules/Exceptions/data/unthrown-exception.php

@@ -8,13 +8,21 @@ class FooFacade
  /** @var \Doctrine\ORM\EntityManager */
  private $entityManager;
 
+ /** @var \Doctrine\ORM\EntityManagerInterface */
+ private $entityManagerInterface;
+
  public function doFoo(): void
  {
  try {
  $this->entityManager->flush();
  } catch (\Doctrine\DBAL\Exception\UniqueConstraintViolationException $e) {
  // pass
  }
+ try {
+ $this->entityManagerInterface->flush();
+ } catch (\Doctrine\DBAL\Exception\UniqueConstraintViolationException $e) {
+ // pass
+ }
  }
 
 }

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

@@ -140,10 +140,11 @@ public function testQueryResultTypeIsVoidWithDeleteOrUpdate(EntityManagerInterfa
 
  public function testQueryTypeIsInferredOnAcrossMethods(EntityManagerInterface $em): void
  {
- $query = $this->getQueryBuilder($em)
-  ->getQuery();
+ $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>', $branchingQuery);
  }
 
  private function getQueryBuilder(EntityManagerInterface $em): QueryBuilder
@@ -152,4 +153,17 @@ private function getQueryBuilder(EntityManagerInterface $em): QueryBuilder
  ->select('m')
  ->from(Many::class, 'm');
  }
+
+ private function getBranchingQueryBuilder(EntityManagerInterface $em): QueryBuilder
+ {
+ $queryBuilder = $em->createQueryBuilder()
+ ->select('m')
+ ->from(Many::class, 'm');
+
+ if (random_int(0, 1) === 1) {
+ $queryBuilder->andWhere('m.intColumn = 1');
+ }
+
+ return $queryBuilder;
+ }
 }