[WIP] Validate entity field types against column types

extension.neon

@@ -25,6 +25,12 @@ conditionalTags:
 		phpstan.broker.methodsClassReflectionExtension: %doctrine.allCollectionsSelectable%
 
 services:
+	-
+		class: PHPStan\Type\Doctrine\DescriptorRegistryFactory
+	-
+		class: PHPStan\Type\Doctrine\DescriptorRegistry
+		factory: @PHPStan\Type\Doctrine\DescriptorRegistryFactory::createRegistry
+
 	-
 		class: PHPStan\Reflection\Doctrine\DoctrineSelectableClassReflectionExtension
 	-
@@ -177,3 +183,77 @@ services:
 		arguments:
 			class: Doctrine\ORM\Query\Expr
 			argumentsProcessor: @doctrineQueryBuilderArgumentsProcessor
+
+	# Type descriptors
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\ArrayType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\BigIntType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\BinaryType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\BlobType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateIntervalType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeTzImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeTzType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DecimalType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\FloatType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\GuidType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\IntegerType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\JsonArrayType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\JsonType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\ObjectType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\SimpleArrayType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\SmallIntType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\StringType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\TextType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\TimeImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\TimeType
+		tags: [phpstan.doctrine.typeDescriptor]

rules.neon

@@ -17,6 +17,7 @@ rules:
 	- PHPStan\Rules\Doctrine\ORM\DqlRule
 	- PHPStan\Rules\Doctrine\ORM\MagicRepositoryMethodCallRule
 	- PHPStan\Rules\Doctrine\ORM\RepositoryMethodCallRule
+	- PHPStan\Rules\Doctrine\ORM\EntityColumnRule
 
 services:
 	-

src/Rules/Doctrine/ORM/EntityColumnRule.php

@@ -0,0 +1,100 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MissingPropertyFromReflectionException;
+use PHPStan\Rules\Rule;
+use PHPStan\Type\Doctrine\DescriptorNotRegisteredException;
+use PHPStan\Type\Doctrine\DescriptorRegistry;
+use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\VerbosityLevel;
+use function sprintf;
+
+class EntityColumnRule implements Rule
+{
+
+	/** @var \PHPStan\Type\Doctrine\ObjectMetadataResolver */
+	private $objectMetadataResolver;
+
+	/** @var \PHPStan\Type\Doctrine\DescriptorRegistry */
+	private $descriptorRegistry;
+
+	public function __construct(ObjectMetadataResolver $objectMetadataResolver, DescriptorRegistry $descriptorRegistry)
+	{
+		$this->objectMetadataResolver = $objectMetadataResolver;
+		$this->descriptorRegistry = $descriptorRegistry;
+	}
+
+	public function getNodeType(): string
+	{
+		return Node\Stmt\PropertyProperty::class;
+	}
+
+	/**
+	 * @param \PhpParser\Node\Stmt\PropertyProperty $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return string[]
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$class = $scope->getClassReflection();
+		if ($class === null) {
+			return [];
+		}
+
+		$objectManager = $this->objectMetadataResolver->getObjectManager();
+		if ($objectManager === null) {
+			return [];
+		}
+
+		$className = $class->getName();
+		if ($objectManager->getMetadataFactory()->isTransient($className)) {
+			return [];
+		}
+
+		/** @var \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata */
+		$metadata = $objectManager->getClassMetadata($className);
+		$classMetadataInfo = 'Doctrine\ORM\Mapping\ClassMetadataInfo';
+		if (!$metadata instanceof $classMetadataInfo) {
+			return [];
+		}
+
+		$propertyName = (string) $node->name;
+		try {
+			$property = $class->getNativeProperty($propertyName);
+		} catch (MissingPropertyFromReflectionException $e) {
+			return [];
+		}
+
+		if (!isset($metadata->fieldMappings[$propertyName])) {
+			return [];
+		}
+		$fieldMapping = $metadata->fieldMappings[$propertyName];
+
+		$errors = [];
+		try {
+			$descriptor = $this->descriptorRegistry->get($fieldMapping['type']);
+		} catch (DescriptorNotRegisteredException $e) {
+			return [];
+		}
+
+		$writableToPropertyType = $descriptor->getWritableToPropertyType();
+		$writableToDatabaseType = $descriptor->getWritableToDatabaseType();
+		if ($fieldMapping['nullable'] === true) {
+			$writableToPropertyType = TypeCombinator::addNull($writableToPropertyType);
+			$writableToDatabaseType = TypeCombinator::addNull($writableToDatabaseType);
+		}
+
+		if (!$property->getWritableType()->isSuperTypeOf($writableToPropertyType)->yes()) {
+			$errors[] = sprintf('Database can contain %s but property expects %s.', $writableToPropertyType->describe(VerbosityLevel::typeOnly()), $property->getWritableType()->describe(VerbosityLevel::typeOnly()));
+		}
+		if (!$writableToDatabaseType->isSuperTypeOf($property->getReadableType())->yes()) {
+			$errors[] = sprintf('Property can contain %s but database expects %s.', $property->getReadableType()->describe(VerbosityLevel::typeOnly()), $writableToDatabaseType->describe(VerbosityLevel::typeOnly()));
+		}
+		return $errors;
+	}
+
+}

src/Type/Doctrine/DescriptorNotRegisteredException.php

@@ -0,0 +1,8 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine;
+
+class DescriptorNotRegisteredException extends \RuntimeException
+{
+
+}

src/Type/Doctrine/DescriptorRegistry.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine;
+
+use PHPStan\Type\Doctrine\Descriptors\DoctrineTypeDescriptor;
+
+class DescriptorRegistry
+{
+
+	/** @var array<string, \PHPStan\Type\Doctrine\Descriptors\DoctrineTypeDescriptor> */
+	private $descriptors = [];
+
+	/**
+	 * @param \PHPStan\Type\Doctrine\Descriptors\DoctrineTypeDescriptor[] $descriptors
+	 */
+	public function __construct(array $descriptors)
+	{
+		foreach ($descriptors as $descriptor) {
+			$this->descriptors[$descriptor->getType()] = $descriptor;
+		}
+	}
+
+	public function get(string $type): DoctrineTypeDescriptor
+	{
+		if (!isset($this->descriptors[$type])) {
+			throw new \PHPStan\Type\Doctrine\DescriptorNotRegisteredException();
+		}
+		return $this->descriptors[$type];
+	}
+
+}

src/Type/Doctrine/DescriptorRegistryFactory.php

@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine;
+
+use PHPStan\DependencyInjection\Container;
+
+class DescriptorRegistryFactory
+{
+
+	public const TYPE_DESCRIPTOR_TAG = 'phpstan.doctrine.typeDescriptor';
+
+	/** @var \PHPStan\DependencyInjection\Container */
+	private $container;
+
+	public function __construct(Container $container)
+	{
+		$this->container = $container;
+	}
+
+	public function createRegistry(): DescriptorRegistry
+	{
+		return new DescriptorRegistry($this->container->getServicesByTag(self::TYPE_DESCRIPTOR_TAG));
+	}
+
+}

src/Type/Doctrine/Descriptors/ArrayType.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+
+class ArrayType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'array';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+}

src/Type/Doctrine/Descriptors/BigIntType.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+
+class BigIntType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'bigint';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\StringType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return TypeCombinator::union(new \PHPStan\Type\StringType(), new \PHPStan\Type\IntegerType());
+	}
+
+}

src/Type/Doctrine/Descriptors/BinaryType.php

@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ResourceType;
+use PHPStan\Type\Type;
+
+class BinaryType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'binary';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ResourceType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new MixedType();
+	}
+
+}

src/Type/Doctrine/Descriptors/BlobType.php

@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ResourceType;
+use PHPStan\Type\Type;
+
+class BlobType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'blob';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ResourceType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new MixedType();
+	}
+
+}