chore: pass PHPStan at level 9

Author: martingold

composer.json

@@ -37,6 +37,7 @@
     "require-dev": {
         "doctrine/common": "^2.0|^3.1",
         "doctrine/doctrine-bundle": "^2.0",
+        "phpstan/phpstan": "^1.12",
         "phpunit/phpunit": "^9.6.18",
         "symfony/error-handler": "^6.4|^7.0",
         "symfony/framework-bundle": "^5.4|^6.4|^7.0",

phpstan.neon.dist

@@ -0,0 +1,4 @@
+parameters:
+	level: 9
+	paths:
+		- src

src/DependencyInjection/RegisterDoctrineTypePass.php

@@ -15,6 +15,7 @@ public function process(ContainerBuilder $container): void
             throw new RuntimeException('This bundle expects DoctrineBundle to be registered, it should provide the doctrine.dbal.connection_factory.types container parameter');
         }
 
+        /** @var array<string, mixed> $types */
         $types = $container->getParameter('doctrine.dbal.connection_factory.types');
         $types[TranslatableStringType::NAME] = ['class' => TranslatableStringType::class];
 

src/DependencyInjection/WebfactoryPolyglotExtension.php

@@ -16,6 +16,9 @@
 
 final class WebfactoryPolyglotExtension extends Extension
 {
+    /**
+     * @param list<array{defaultLocale: string}> $configs
+     */
     public function load(array $configs, ContainerBuilder $container): void
     {
         $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));

src/Doctrine/PersistentTranslatable.php

@@ -9,6 +9,7 @@
 
 namespace Webfactory\Bundle\PolyglotBundle\Doctrine;
 
+use Doctrine\Common\Collections\Collection;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\Common\Collections\Selectable;
 use Doctrine\ORM\UnitOfWork;
@@ -25,6 +26,9 @@
 use Webfactory\Bundle\PolyglotBundle\TranslatableInterface;
 
 /**
+ * @template T
+ * @implements TranslatableInterface<T>
+ *
  * This class implements `TranslatableInterface` for entities that are managed by
  * the entity manager. PolyglotListener will replace `Translatable` instances with
  * instances of this class as soon as a new entity is passed to EntityManager::persist().
@@ -61,17 +65,17 @@ final class PersistentTranslatable implements TranslatableInterface
     private LoggerInterface $logger;
 
     /**
-     * @param UnitOfWork            $unitOfWork            The UoW managing the entity that contains this PersistentTranslatable
-     * @param class-string          $class                 The class of the entity containing this PersistentTranslatable instance
-     * @param object                $entity                The entity containing this PersistentTranslatable instance
-     * @param string                $primaryLocale         The locale for which the translated value will be persisted in the "main" entity
-     * @param DefaultLocaleProvider $defaultLocaleProvider DefaultLocaleProvider that provides the locale to use when no explicit locale is passed to e. g. translate()
-     * @param ReflectionProperty    $translationProperty   ReflectionProperty pointing to the field in the translations class that holds the translated value to use
-     * @param ReflectionProperty    $translationCollection ReflectionProperty pointing to the collection in the main class that holds translation instances
-     * @param ReflectionClass       $translationClass      ReflectionClass for the class holding translated values
-     * @param ReflectionProperty    $localeField           ReflectionProperty pointing to the field in the translations class that holds a translation's locale
-     * @param ReflectionProperty    $translationMapping    ReflectionProperty pointing to the field in the translations class that refers back to the main entity (the owning side of the one-to-many translations collection).
-     * @param ReflectionProperty    $translatedProperty    ReflectionProperty pointing to the field in the main entity where this PersistentTranslatable instance will be used
+     * @param UnitOfWork              $unitOfWork            The UoW managing the entity that contains this PersistentTranslatable
+     * @param class-string            $class                 The class of the entity containing this PersistentTranslatable instance
+     * @param object                  $entity                The entity containing this PersistentTranslatable instance
+     * @param string                  $primaryLocale         The locale for which the translated value will be persisted in the "main" entity
+     * @param DefaultLocaleProvider   $defaultLocaleProvider DefaultLocaleProvider that provides the locale to use when no explicit locale is passed to e. g. translate()
+     * @param ReflectionProperty      $translationProperty   ReflectionProperty pointing to the field in the translations class that holds the translated value to use
+     * @param ReflectionProperty      $translationCollection ReflectionProperty pointing to the collection in the main class that holds translation instances
+     * @param ReflectionClass<object> $translationClass      ReflectionClass for the class holding translated values
+     * @param ReflectionProperty      $localeField           ReflectionProperty pointing to the field in the translations class that holds a translation's locale
+     * @param ReflectionProperty      $translationMapping    ReflectionProperty pointing to the field in the translations class that refers back to the main entity (the owning side of the one-to-many translations collection).
+     * @param ReflectionProperty      $translatedProperty    ReflectionProperty pointing to the field in the main entity where this PersistentTranslatable instance will be used
      */
     public function __construct(
         private readonly UnitOfWork $unitOfWork,
@@ -150,7 +154,10 @@ private function createTranslationEntity(string $locale): object
         $this->localeField->setValue($entity, $locale);
 
         $this->translationMapping->setValue($entity, $this->entity);
-        $this->translationCollection->getValue($this->entity)->add($entity);
+
+        /** @var Collection<array-key, object> $collection */
+        $collection = $this->translationCollection->getValue($this->entity);
+        $collection->add($entity);
 
         self::$_translations[$this->class][$this->oid][$locale] = $entity;
         $this->unitOfWork->persist($entity);
@@ -241,13 +248,17 @@ private function isTranslationCached(string $locale): bool
      */
     private function cacheTranslation(string $locale): void
     {
-        /** @var $translationsInAllLanguages Selectable */
+        /** @var Selectable<array-key, object> $translationsInAllLanguages */
         $translationsInAllLanguages = $this->translationCollection->getValue($this->entity);
         $criteria = $this->createLocaleCriteria($locale);
         $translationsFilteredByLocale = $translationsInAllLanguages->matching($criteria);
 
         $translationInLocale = ($translationsFilteredByLocale->count() > 0) ? $translationsFilteredByLocale->first() : null;
 
+        if (is_bool($translationInLocale)) {
+            return;
+        }
+
         self::$_translations[$this->class][$this->oid][$locale] = $translationInLocale;
     }
 

src/Doctrine/PolyglotListener.php

@@ -10,10 +10,12 @@
 namespace Webfactory\Bundle\PolyglotBundle\Doctrine;
 
 use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Event\PostFlushEventArgs;
 use Doctrine\ORM\Event\PreFlushEventArgs;
 use Doctrine\Persistence\Event\LifecycleEventArgs;
 use Doctrine\Persistence\Mapping\RuntimeReflectionService;
+use Doctrine\Persistence\ObjectManager;
 use Psr\Log\LoggerInterface;
 use Psr\Log\NullLogger;
 use WeakReference;
@@ -39,28 +41,34 @@ final class PolyglotListener
     private array $translatedClasses = [];
 
     /**
-     * @var array<WeakReference>
+     * @var array<WeakReference<object>>
      */
     private array $entitiesWithTranslatables = [];
 
     /**
-     * @var list<PersistentTranslatable>
+     * @var list<PersistentTranslatable<mixed>>
      */
     private array $ejectedTranslatables = [];
 
     public function __construct(
         private readonly DefaultLocaleProvider $defaultLocaleProvider,
-        private readonly LoggerInterface $logger = null ?? new NullLogger(),
+        private readonly LoggerInterface $logger = new NullLogger(),
         private readonly RuntimeReflectionService $reflectionService = new RuntimeReflectionService(),
     ) {
     }
 
+    /**
+     * @param LifecycleEventArgs<EntityManager> $event
+     */
     public function postLoad(LifecycleEventArgs $event): void
     {
         // Called when the entity has been hydrated
         $this->injectPersistentTranslatables($event->getObjectManager(), $event->getObject());
     }
 
+    /**
+     * @param LifecycleEventArgs<EntityManager> $event
+     */
     public function prePersist(LifecycleEventArgs $event): void
     {
         // Called when a new entity is passed to persist() for the first time
@@ -109,7 +117,7 @@ public function postFlush(PostFlushEventArgs $event): void
     /**
      * @return list<TranslatableClassMetadata>
      */
-    private function getTranslationMetadatas(object $entity, EntityManager $em): array
+    private function getTranslationMetadatas(object $entity, EntityManagerInterface $em): array
     {
         $class = $entity::class;
 
@@ -127,7 +135,10 @@ private function getTranslationMetadatas(object $entity, EntityManager $em): arr
         return $this->translatableClassMetadatasByClass[$class];
     }
 
-    private function loadTranslationMetadataForClass($className, EntityManager $em): ?TranslatableClassMetadata
+    /**
+     * @param class-string<object> $className
+     */
+    private function loadTranslationMetadataForClass(string $className, EntityManagerInterface $em): ?TranslatableClassMetadata
     {
         // In memory cache
         if (isset($this->translatedClasses[$className])) {
@@ -140,6 +151,7 @@ private function loadTranslationMetadataForClass($className, EntityManager $em):
 
         if ($cache?->hasItem($cacheKey)) {
             $item = $cache->getItem($cacheKey);
+            /** @var SerializedTranslatableClassMetadata|null $data */
             $data = $item->get();
             if (null === $data) {
                 $this->translatedClasses[$className] = null;

src/Doctrine/SerializedTranslatableClassMetadata.php

@@ -11,33 +11,40 @@
 
 final class SerializedTranslatableClassMetadata
 {
+    /**
+     * @var class-string<object>
+     */
     public string $class;
+
+    /**
+     * @var class-string<object>
+     */
     public string $translationClass;
 
     /**
-     * @var array<string, array{0: string, 1: string}>
+     * @var array<string, array{0: class-string<object>, 1: string}>
      */
-    public array $translationFieldMapping = [];
+    public array $translationFieldMapping;
 
     /**
-     * @var array<string, array{0: string, 1: string}>
+     * @var array<string, array{0: class-string<object>, 1: string}>
      */
-    public array $translatedProperties = [];
+    public array $translatedProperties;
 
     /**
-     * @var array{0: string, 1: string}
+     * @var array{0: class-string<object>, 1: string}
      */
-    public array $translationLocaleProperty = [];
+    public array $translationLocaleProperty;
 
     /**
-     * @var array{0: string, 1: string}
+     * @var array{0: class-string<object>, 1: string}
      */
-    public array $translationsCollectionProperty = [];
+    public array $translationsCollectionProperty;
 
     /**
-     * @var array{0: string, 1: string}
+     * @var array{0: class-string<object>, 1: string}
      */
-    public array $translationMappingProperty = [];
+    public array $translationMappingProperty;
 
     public string $primaryLocale;
 }