rector/vendor/rector/rector-doctrine/docs/rector_rules_overview.md

19 Rules Overview

ChangeCompositeExpressionAddMultipleWithWithRector

Change CompositeExpression ->addMultiple($parts) to ->with(...$parts)

• class: Rector\Doctrine\Dbal40\Rector\MethodCall\ChangeCompositeExpressionAddMultipleWithWithRector

 use Doctrine\ORM\EntityRepository;
 use Doctrine\DBAL\Query\Expression\CompositeExpression;

 class SomeRepository extends EntityRepository
 {
     public function getSomething($parts)
     {
         $compositeExpression = CompositeExpression::and('', ...$parts);
-        $compositeExpression->addMultiple($parts);
+        $compositeExpression->with(...$parts);
     }
 }

CorrectDefaultTypesOnEntityPropertyRector

Change default value types to match Doctrine annotation type

• class: Rector\Doctrine\CodeQuality\Rector\Property\CorrectDefaultTypesOnEntityPropertyRector

 use Doctrine\ORM\Mapping as ORM;

 /**
  * @ORM\Entity()
  */
 class User
 {
     /**
      * @ORM\Column(name="is_old", type="boolean")
      */
-    private $isOld = '0';
+    private $isOld = false;
 }

EventSubscriberInterfaceToAttributeRector

Replace EventSubscriberInterface with AsDoctrineListener attribute(s)

• class: Rector\Doctrine\Bundle210\Rector\Class_\EventSubscriberInterfaceToAttributeRector

+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
 use Doctrine\ORM\Event\PrePersistEventArgs;
 use Doctrine\ORM\Event\PostUpdateEventArgs;
-use Doctrine\Common\EventSubscriber;
 use Doctrine\ORM\Events;

-class MyEventSubscriber implements EventSubscriber
+#[AsDoctrineListener(event: Events::postUpdate)]
+#[AsDoctrineListener(event: Events::prePersist)]
+class MyEventSubscriber
 {
-    public function getSubscribedEvents()
-    {
-        return array(
-            Events::postUpdate,
-            Events::prePersist,
-        );
-    }
-
     public function postUpdate(PostUpdateEventArgs $args)
     {
         // ...
     }

     public function prePersist(PrePersistEventArgs $args)
     {
         // ...
     }
 }

ExplicitRelationCollectionRector

Use explicit collection in one-to-many relations of Doctrine entity

• class: Rector\Doctrine\CodeQuality\Rector\Class_\ExplicitRelationCollectionRector

+use Doctrine\ORM\Mapping\Entity;
 use Doctrine\ORM\Mapping\OneToMany;
-use Doctrine\ORM\Mapping\Entity;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;

 #[Entity]
 class SomeClass
 {
     #[OneToMany(targetEntity: 'SomeClass')]
-    private $items = [];
+    private Collection $items;
+
+    public function __construct()
+    {
+        $this->items = new ArrayCollection();
+    }
 }

ExtractArrayArgOnQueryBuilderSelectRector

Extract array arg on QueryBuilder select, addSelect, groupBy, addGroupBy

• class: Rector\Doctrine\Dbal211\Rector\MethodCall\ExtractArrayArgOnQueryBuilderSelectRector

 function query(\Doctrine\DBAL\Query\QueryBuilder $queryBuilder)
 {
-    $query = $queryBuilder->select(['u.id', 'p.id']);
+    $query = $queryBuilder->select('u.id', 'p.id');
 }

ImproveDoctrineCollectionDocTypeInEntityRector

Improve @var, @param and @return types for Doctrine collections to make them useful both for PHPStan and PHPStorm

• class: Rector\Doctrine\CodeQuality\Rector\Property\ImproveDoctrineCollectionDocTypeInEntityRector

 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;

 /**
  * @ORM\Entity
  */
 class SomeClass
 {
     /**
      * @ORM\OneToMany(targetEntity=Trainer::class, mappedBy="trainer")
-     * @var Collection|Trainer[]
+     * @var Collection<int, Trainer>
      */
     private $trainings = [];
 }

InitializeDefaultEntityCollectionRector

Initialize collection property in Entity constructor

• class: Rector\Doctrine\CodeQuality\Rector\Class_\InitializeDefaultEntityCollectionRector

 use Doctrine\ORM\Mapping as ORM;

 /**
  * @ORM\Entity
  */
 class SomeClass
 {
     /**
      * @ORM\OneToMany(targetEntity="MarketingEvent")
      */
     private $marketingEvents = [];
+
+    public function __construct()
+    {
+        $this->marketingEvents = new ArrayCollection();
+    }
 }

IterateToToIterableRector

Change iterate() => toIterable()

• class: Rector\Doctrine\Orm28\Rector\MethodCall\IterateToToIterableRector

 use Doctrine\ORM\EntityRepository;
 use Doctrine\ORM\Internal\Hydration\IterableResult;

 class SomeRepository extends EntityRepository
 {
-    public function run(): IterateResult
+    public function run(): iterable
     {
         /** @var \Doctrine\ORM\AbstractQuery $query */
         $query = $this->getEntityManager()->select('e')->from('entity')->getQuery();

-        return $query->iterate();
+        return $query->toIterable();
     }
 }

MakeEntityDateTimePropertyDateTimeInterfaceRector

Make maker bundle generate DateTime property accept DateTimeInterface too

• class: Rector\Doctrine\CodeQuality\Rector\Property\MakeEntityDateTimePropertyDateTimeInterfaceRector

 use Doctrine\ORM\Mapping as ORM;

 /**
  * @ORM\Entity()
  */
 class User
 {
     /**
-     * @var DateTime|null
+     * @var DateTimeInterface|null
      */
     private $bornAt;

     public function setBornAt(DateTimeInterface $bornAt)
     {
         $this->bornAt = $bornAt;
     }
 }

MoveCurrentDateTimeDefaultInEntityToConstructorRector

Move default value for entity property to constructor, the safest place

• class: Rector\Doctrine\CodeQuality\Rector\Class_\MoveCurrentDateTimeDefaultInEntityToConstructorRector

 use Doctrine\ORM\Mapping as ORM;

 /**
  * @ORM\Entity()
  */
 class User
 {
     /**
      * @var DateTimeInterface
      *
-     * @ORM\Column(type="datetime", nullable=false, options={"default"="now()"})
+     * @ORM\Column(type="datetime", nullable=false)
      */
-    private $when = 'now()';
+    private $when;
+
+    public function __construct()
+    {
+        $this->when = new \DateTime();
+    }
 }

OrderByKeyToClassConstRector

Replace OrderBy Attribute ASC/DESC with class constant from Criteria

• class: Rector\Doctrine\CodeQuality\Rector\Property\OrderByKeyToClassConstRector

 use Doctrine\ORM\Mapping as ORM;

 class ReplaceOrderByAscWithClassConstant
 {
-    #[ORM\OrderBy(['createdAt' => 'ASC'])]
+    #[ORM\OrderBy(['createdAt' => \Doctrine\Common\Collections\Criteria::ASC])]
     protected \DateTimeInterface $messages;
 }
 ?>

RemoveEmptyTableAttributeRector

Remove empty Table attribute on entities because it's useless

• class: Rector\Doctrine\CodeQuality\Rector\Class_\RemoveEmptyTableAttributeRector

 <?php

 use Doctrine\ORM\Mapping as ORM;

-#[ORM\Table]
 #[ORM\Entity]
 class Product
 {
 }

ReplaceFetchAllMethodCallRector

Change Doctrine\DBAL\Connection and Doctrine\DBAL\Driver\ResultStatement ->fetchAll() to ->fetchAllAssociative() and other replacements

• class: Rector\Doctrine\Dbal211\Rector\MethodCall\ReplaceFetchAllMethodCallRector

 use Doctrine\DBAL\Connection;

 class SomeClass
 {
     public function run(Connection $connection)
     {
-        return $connection->fetchAll();
+        return $connection->fetchAllAssociative();
     }
 }

ReplaceLifecycleEventArgsByDedicatedEventArgsRector

Replace Doctrine\ORM\Event\LifecycleEventArgs with specific event classes based on the function call

• class: Rector\Doctrine\Orm214\Rector\Param\ReplaceLifecycleEventArgsByDedicatedEventArgsRector

-use Doctrine\ORM\Event\LifecycleEventArgs;
+use Doctrine\ORM\Event\PrePersistEventArgs;

 class PrePersistExample
 {
-    public function prePersist(LifecycleEventArgs $args)
+    public function prePersist(PrePersistEventArgs $args)
     {
         // ...
     }
 }

TypedPropertyFromColumnTypeRector

Complete @var annotations or types based on @ORM\Column

• class: Rector\Doctrine\CodeQuality\Rector\Property\TypedPropertyFromColumnTypeRector

 use Doctrine\ORM\Mapping as ORM;

 class SimpleColumn
 {
     /**
      * @ORM\Column(type="string")
      */
-    private $name;
+    private string|null $name = null;
 }

TypedPropertyFromDoctrineCollectionRector

Add typed property based on Doctrine collection

• class: Rector\Doctrine\CodeQuality\Rector\Property\TypedPropertyFromDoctrineCollectionRector

 use Doctrine\ORM\Mapping as ORM;
 use App\Entity\TrainingTerm;

 /**
  * @ORM\Entity
  */
 class DoctrineCollection
 {
     /**
      * @ORM\OneToMany(targetEntity="App\Entity\TrainingTerm", mappedBy="training")
      * @var TrainingTerm[]|Collection
      */
-    private $trainingTerms;
+    private \Doctrine\Common\Collections\Collection $trainingTerms;
 }

TypedPropertyFromToManyRelationTypeRector

Complete @var annotations or types based on @ORM*toMany annotations or attributes

• class: Rector\Doctrine\CodeQuality\Rector\Property\TypedPropertyFromToManyRelationTypeRector

 use Doctrine\ORM\Mapping as ORM;

 class SimpleColumn
 {
     /**
      * @ORM\OneToMany(targetEntity="App\Product")
+     * @var \Doctrine\Common\Collections\Collection<int, \App\Product>
      */
-    private $products;
+    private \Doctrine\Common\Collections\Collection $products;
 }

TypedPropertyFromToOneRelationTypeRector

Complete @var annotations or types based on @ORM*toOne annotations or attributes

• class: Rector\Doctrine\CodeQuality\Rector\Property\TypedPropertyFromToOneRelationTypeRector

 use Doctrine\ORM\Mapping as ORM;

 class SimpleColumn
 {
     /**
      * @ORM\OneToOne(targetEntity="App\Company\Entity\Company")
      */
-    private $company;
+    private ?\App\Company\Entity\Company $company = null;
 }

YamlToAttributeDoctrineMappingRector

Converts YAML Doctrine Entity mapping to particular annotation mapping

🔧 configure it!

• class: Rector\Doctrine\CodeQuality\Rector\Class_\YamlToAttributeDoctrineMappingRector

+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
 class SomeEntity
 {
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: 'integer')]
     private $id;

+    #[ORM\Column(type: 'string')]
     private $name;
 }