Basic DQL rule

Author: ondrejmirtes

README.md

@@ -11,6 +11,7 @@ This extension provides following features:
 
 * Provides correct return type for `Doctrine\ORM\EntityManager::find`, `getReference` and `getPartialReference` when `Foo::class` entity class name is provided as the first argument
 * Adds missing `matching` method on `Doctrine\Common\Collections\Collection`. This can be turned off by setting `parameters.doctrine.allCollectionsSelectable` to `false`.
+* Basic DQL validation for parse errors, unknown entity classes and unknown persistent fields.
 
 ## Usage
 
@@ -20,13 +21,20 @@ To use this extension, require it in [Composer](https://getcomposer.org/):
 composer require --dev phpstan/phpstan-doctrine
 ```
 
-And include extension.neon in your project's PHPStan config:
+Include extension.neon in your project's PHPStan config:
 
 ```
 includes:
 	- vendor/phpstan/phpstan-doctrine/extension.neon
 ```
 
+If you're interested in DQL validation, include also `rules.neon` (you will also need to provide the `objectManagerLoader`, see below):
+
+```
+includes:
+	- vendor/phpstan/phpstan-doctrine/rules.neon
+```
+
 ## Configuration
 
 If your repositories have a common base class, you can configure it in your `phpstan.neon` and PHPStan will see additional methods you define in it:

phpstan.neon

@@ -7,3 +7,6 @@ includes:
 parameters:
 	excludes_analyse:
 		- */tests/*/data/*
+
+	ignoreErrors:
+		- '~^Parameter \#1 \$node \(.*\) of method .*Rule::processNode\(\) should be contravariant with parameter \$node \(PhpParser\\Node\) of method PHPStan\\Rules\\Rule::processNode\(\)$~'

rules.neon

@@ -0,0 +1,84 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\EntityManagerInterface;
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+use PHPStan\Type\ObjectType;
+
+class DqlRule implements Rule
+{
+
+	/** @var ObjectMetadataResolver */
+	private $objectMetadataResolver;
+
+	public function __construct(ObjectMetadataResolver $objectMetadataResolver)
+	{
+		$this->objectMetadataResolver = $objectMetadataResolver;
+	}
+
+	public function getNodeType(): string
+	{
+		return Node\Expr\MethodCall::class;
+	}
+
+	/**
+	 * @param \PhpParser\Node\Expr\MethodCall $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return string[]
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (!$node->name instanceof Node\Identifier) {
+			return [];
+		}
+
+		if (count($node->args) === 0) {
+			return [];
+		}
+
+		$dqlType = $scope->getType($node->args[0]->value);
+		if (!$dqlType instanceof ConstantStringType) {
+			return [];
+		}
+
+		$methodName = $node->name->toLowerString();
+		if ($methodName !== 'createquery') {
+			return [];
+		}
+
+		$calledOnType = $scope->getType($node->var);
+		$entityManagerInterface = 'Doctrine\ORM\EntityManagerInterface';
+		if (!(new ObjectType($entityManagerInterface))->isSuperTypeOf($calledOnType)->yes()) {
+			return [];
+		}
+
+		$objectManager = $this->objectMetadataResolver->getObjectManager();
+		if ($objectManager === null) {
+			throw new ShouldNotHappenException('Please provide the "objectManagerLoader" setting for the DQL validation.');
+		}
+		if (!$objectManager instanceof $entityManagerInterface) {
+			return [];
+		}
+
+		/** @var EntityManagerInterface $objectManager */
+		$objectManager = $objectManager;
+
+		$dql = $dqlType->getValue();
+		$query = $objectManager->createQuery($dql);
+
+		try {
+			$query->getSQL();
+		} catch (\Doctrine\ORM\Query\QueryException $e) {
+			return [sprintf('DQL: %s', $e->getMessage())];
+		}
+
+		return [];
+	}
+
+}

src/Rules/Doctrine/ORM/DqlRule.php

@@ -18,7 +18,7 @@ final class ObjectMetadataResolver
 	public function __construct(?string $objectManagerLoader, ?string $repositoryClass)
 	{
 		if ($objectManagerLoader !== null) {
-			$this->objectManager = $this->getObjectManager($objectManagerLoader);
+			$this->objectManager = $this->loadObjectManager($objectManagerLoader);
 		}
 		if ($repositoryClass !== null) {
 			$this->repositoryClass = $repositoryClass;
@@ -29,14 +29,12 @@ public function __construct(?string $objectManagerLoader, ?string $repositoryCla
 		}
 	}
 
-	/**
-	 * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingReturnTypeHint
-	 * @param string $objectManagerLoader
-	 * @return ObjectManager
-	 */
-	private function getObjectManager(string $objectManagerLoader)
+	private function loadObjectManager(string $objectManagerLoader): ?ObjectManager
 	{
-		if (! file_exists($objectManagerLoader) && ! is_readable($objectManagerLoader)) {
+		if (
+			!file_exists($objectManagerLoader)
+			|| !is_readable($objectManagerLoader)
+		) {
 			throw new \PHPStan\ShouldNotHappenException('Object manager could not be loaded');
 		}
 
@@ -68,4 +66,9 @@ public function getRepositoryClass(string $className): string
 		return $this->repositoryClass;
 	}
 
+	public function getObjectManager(): ?ObjectManager
+	{
+		return $this->objectManager;
+	}
+
 }

src/Type/Doctrine/ObjectMetadataResolver.php

@@ -0,0 +1,35 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+
+class DqlRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new DqlRule(new ObjectMetadataResolver(__DIR__ . '/entity-manager.php', null));
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/dql.php'], [
+			[
+				'DQL: [Syntax Error] line 0, col -1: Error: Expected Doctrine\ORM\Query\Lexer::T_IDENTIFIER, got end of string.',
+				30,
+			],
+			[
+				'DQL: [Semantical Error] line 0, col 60 near \'transient = \': Error: Class PHPStan\Rules\Doctrine\ORM\MyEntity has no field or association named transient',
+				37,
+			],
+			[
+				'DQL: [Semantical Error] line 0, col 14 near \'Foo e\': Error: Class \'Foo\' is not defined.',
+				44,
+			],
+		]);
+	}
+
+}

tests/Rules/Doctrine/ORM/DqlRuleTest.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity()
+ */
+class MyEntity
+{
+	/**
+	 * @ORM\Id()
+	 * @ORM\GeneratedValue()
+	 * @ORM\Column(type="integer")
+	 *
+	 * @var int
+	 */
+	private $id;
+
+	/**
+	 * @var string
+	 * @ORM\Column(type="string")
+	 */
+	private $title;
+
+	/**
+	 * @var string
+	 */
+	private $transient;
+
+}

tests/Rules/Doctrine/ORM/data/MyEntity.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\EntityManager;
+
+class TestRepository
+{
+
+	/** @var EntityManager */
+	private $entityManager;
+
+	public function __construct(EntityManager $entityManager)
+	{
+		$this->entityManager = $entityManager;
+	}
+
+	/**
+	 * @return MyEntity[]
+	 */
+	public function getEntities(): array
+	{
+		return $this->entityManager->createQuery(
+			'SELECT e FROM ' . MyEntity::class . ' e'
+		)->getResult();
+	}
+
+	public function parseError(): void
+	{
+		$this->entityManager->createQuery(
+			'SELECT e FROM ' . MyEntity::class
+		)->getResult();
+	}
+
+	public function unknownField(): void
+	{
+		$this->entityManager->createQuery(
+			'SELECT e FROM ' . MyEntity::class . ' e WHERE e.transient = :test'
+		)->getResult();
+	}
+
+	public function unknownEntity(): void
+	{
+		$this->entityManager->createQuery(
+			'SELECT e FROM Foo e'
+		)->getResult();
+	}
+
+}

tests/Rules/Doctrine/ORM/data/dql.php

@@ -0,0 +1,30 @@
+<?php declare(strict_types = 1);
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\AnnotationRegistry;
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\ORM\Configuration;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
+
+AnnotationRegistry::registerUniqueLoader('class_exists');
+
+$config = new Configuration();
+$config->setProxyDir(__DIR__);
+$config->setProxyNamespace('PHPstan\Doctrine\OrmProxies');
+$config->setMetadataCacheImpl(new ArrayCache());
+
+$config->setMetadataDriverImpl(
+	new AnnotationDriver(
+		new AnnotationReader(),
+		[__DIR__ . '/data']
+	)
+);
+
+return EntityManager::create(
+	[
+		'driver' => 'pdo_sqlite',
+		'memory' => true,
+	],
+	$config
+);