Allow to skip property type validation (#11130)

Fix enum mapping validation

.doctrine-project.json

@@ -11,21 +11,29 @@
             "slug": "latest",
             "upcoming": true
         },
+        {
+            "name": "2.18",
+            "branchName": "2.18.x",
+            "slug": "2.18",
+            "upcoming": true
+        },
+        {
+            "name": "2.17",
+            "branchName": "2.17.x",
+            "slug": "2.17",
+            "current": true
+        },
         {
             "name": "2.16",
             "branchName": "2.16.x",
             "slug": "2.16",
-            "upcoming": true
+            "maintained": false
         },
         {
             "name": "2.15",
             "branchName": "2.15.x",
             "slug": "2.15",
-            "current": true,
-            "aliases": [
-                "current",
-                "stable"
-            ]
+            "maintained": false
         },
         {
             "name": "2.14",

.github/workflows/continuous-integration.yml

@@ -39,6 +39,7 @@ jobs:
           - "8.0"
           - "8.1"
           - "8.2"
+          - "8.3"
         dbal-version:
           - "default"
         extension:
@@ -62,7 +63,7 @@ jobs:
 
     steps:
       - name: "Checkout"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
         with:
           fetch-depth: 2
 
@@ -111,6 +112,7 @@ jobs:
       matrix:
         php-version:
           - "8.2"
+          - "8.3"
         dbal-version:
           - "default"
           - "3@dev"
@@ -143,7 +145,7 @@ jobs:
 
     steps:
       - name: "Checkout"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
         with:
           fetch-depth: 2
 
@@ -183,6 +185,7 @@ jobs:
       matrix:
         php-version:
           - "8.2"
+          - "8.3"
         dbal-version:
           - "default"
           - "3@dev"
@@ -212,7 +215,7 @@ jobs:
 
     steps:
       - name: "Checkout"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
         with:
           fetch-depth: 2
 
@@ -252,6 +255,7 @@ jobs:
       matrix:
         php-version:
           - "8.2"
+          - "8.3"
         dbal-version:
           - "default"
           - "3@dev"
@@ -281,7 +285,7 @@ jobs:
 
     steps:
       - name: "Checkout"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
         with:
           fetch-depth: 2
 
@@ -333,7 +337,7 @@ jobs:
 
     steps:
       - name: "Checkout"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
         with:
           fetch-depth: 2
 
@@ -363,7 +367,7 @@ jobs:
 
     steps:
       - name: "Checkout"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
         with:
           fetch-depth: 2
 

.github/workflows/documentation.yml

@@ -21,7 +21,7 @@ jobs:
 
     steps:
       - name: "Checkout code"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
 
       - name: "Install PHP"
         uses: "shivammathur/setup-php@v2"
@@ -33,10 +33,7 @@ jobs:
         run: "rm composer.json"
 
       - name: "Require phpdocumentor/guides-cli"
-        run: "composer require --dev phpdocumentor/guides-cli dev-main@dev --no-update"
-
-      - name: "Configure minimum stability"
-        run: "composer config minimum-stability dev"
+        run: "composer require --dev phpdocumentor/guides-cli --no-update"
 
       - name: "Install dependencies with Composer"
         uses: "ramsey/composer-install@v2"
@@ -48,4 +45,4 @@ jobs:
           printf '%s\n%s\n\n%s\n' "Dummy title" "===========" "$(cat docs/en/sidebar.rst)" > docs/en/sidebar.rst
 
       - name: "Run guides-cli"
-        run: "vendor/bin/guides -vvv --no-progress docs/en /tmp/test 2>&1 | ( ! grep WARNING )"
+        run: "vendor/bin/guides -vvv --no-progress docs/en 2>&1 | grep -v 'Unknown directive' | ( ! grep WARNING )"

.github/workflows/phpbench.yml

@@ -36,7 +36,7 @@ jobs:
 
     steps:
       - name: "Checkout"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
         with:
           fetch-depth: 2
 

.github/workflows/static-analysis.yml

@@ -42,7 +42,7 @@ jobs:
 
     steps:
       - name: "Checkout code"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
 
       - name: "Install PHP"
         uses: "shivammathur/setup-php@v2"
@@ -83,7 +83,7 @@ jobs:
 
     steps:
       - name: "Checkout code"
-        uses: "actions/checkout@v3"
+        uses: "actions/checkout@v4"
 
       - name: "Install PHP"
         uses: "shivammathur/setup-php@v2"

UPGRADE.md

@@ -1,11 +1,88 @@
+# Upgrade to 2.17
+
+## Deprecate annotations classes for named queries
+
+The following classes have been deprecated:
+
+* `Doctrine\ORM\Mapping\NamedNativeQueries`
+* `Doctrine\ORM\Mapping\NamedNativeQuery`
+* `Doctrine\ORM\Mapping\NamedQueries`
+* `Doctrine\ORM\Mapping\NamedQuery`
+
+## Deprecate `Doctrine\ORM\Query\Exec\AbstractSqlExecutor::_sqlStatements`
+
+Use `Doctrine\ORM\Query\Exec\AbstractSqlExecutor::sqlStatements` instead.
+
+## Undeprecate `Doctrine\ORM\Proxy\Autoloader`
+
+It will be a full-fledged class, no longer extending
+`Doctrine\Common\Proxy\Autoloader` in 3.0.x.
+
+## Deprecated: reliance on the non-optimal defaults that come with the `AUTO` identifier generation strategy
+
+When the `AUTO` identifier generation strategy was introduced, the best
+strategy at the time was selected for each database platform.
+A lot of time has passed since then, and with ORM 3.0.0 and DBAL 4.0.0, support
+for better strategies will be added.
+
+Because of that, it is now deprecated to rely on the historical defaults when
+they differ from what we will be recommended in the future.
+
+Instead, you should pick a strategy for each database platform you use, and it
+will be used when using `AUTO`. As of now, only PostgreSQL is affected by this.
+
+It is recommended that PostgreSQL users configure their existing and new
+applications to use `SEQUENCE` until `doctrine/dbal` 4.0.0 is released:
+
+```php
+use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
+use Doctrine\ORM\Configuration;
+
+assert($configuration instanceof Configuration);
+$configuration->setIdentityGenerationPreferences([
+    PostgreSQLPlatform::CLASS => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
+]);
+```
+
+When DBAL 4 is released, `AUTO` will result in `IDENTITY`, and the above
+configuration should be removed to migrate to it.
+
+## Deprecate `EntityManagerInterface::getPartialReference()`
+
+This method does not have a replacement and will be removed in 3.0.
+
+## Deprecate not-enabling lazy-ghosts
+
+Not enabling lazy ghost objects is deprecated. In ORM 3.0, they will be always enabled.
+Ensure `Doctrine\ORM\Configuration::setLazyGhostObjectEnabled(true)` is called to enable them.
+
 # Upgrade to 2.16
 
-## Deprecated `\Doctrine\ORM\Internal\CommitOrderCalculator` and related classes
+## Deprecated accepting duplicate IDs in the identity map
 
-With changes made to the commit order computation, the internal classes
-`\Doctrine\ORM\Internal\CommitOrderCalculator`, `\Doctrine\ORM\Internal\CommitOrder\Edge`,
-`\Doctrine\ORM\Internal\CommitOrder\Vertex` and `\Doctrine\ORM\Internal\CommitOrder\VertexState`
-have been deprecated and will be removed in ORM 3.0.
+For any given entity class and ID value, there should be only one object instance
+representing the entity.
+
+In https://github.com/doctrine/orm/pull/10785, a check was added that will guard this
+in the identity map. The most probable cause for violations of this rule are collisions
+of application-provided IDs.
+
+In ORM 2.16.0, the check was added by throwing an exception. In ORM 2.16.1, this will be
+changed to a deprecation notice. ORM 3.0 will make it an exception again. Use
+`\Doctrine\ORM\Configuration::setRejectIdCollisionInIdentityMap()` if you want to opt-in
+to the new mode.
+
+## Potential changes to the order in which `INSERT`s are executed
+
+In https://github.com/doctrine/orm/pull/10547, the commit order computation was improved
+to fix a series of bugs where a correct (working) commit order was previously not found.
+Also, the new computation may get away with fewer queries being executed: By inserting
+referred-to entities first and using their ID values for foreign key fields in subsequent
+`INSERT` statements, additional `UPDATE` statements that were previously necessary can be
+avoided.
+
+When using database-provided, auto-incrementing IDs, this may lead to IDs being assigned
+to entities in a different order than it was previously the case.
 
 ## Deprecated returning post insert IDs from `EntityPersister::executeInserts()`
 
@@ -18,12 +95,12 @@ persister call `Doctrine\ORM\UnitOfWork::assignPostInsertId()` instead.
 In ORM 3.0, a change will be made regarding how the `AttributeDriver` reports field mappings.
 This change is necessary to be able to detect (and reject) some invalid mapping configurations.
 
-To avoid surprises during 2.x upgrades, the new mode is opt-in. It can be activated on the 
+To avoid surprises during 2.x upgrades, the new mode is opt-in. It can be activated on the
 `AttributeDriver` and `AnnotationDriver` by setting the `$reportFieldsWhereDeclared`
 constructor parameter to `true`. It will cause `MappingException`s to be thrown when invalid
 configurations are detected.
 
-Not enabling the new mode will cause a deprecation notice to be raised. In ORM 3.0, 
+Not enabling the new mode will cause a deprecation notice to be raised. In ORM 3.0,
 only the new mode will be available.
 
 # Upgrade to 2.15
@@ -43,7 +120,7 @@ and will be an error in 3.0.
 
 ## Deprecated undeclared entity inheritance
 
-As soon as an entity class inherits from another entity class, inheritance has to 
+As soon as an entity class inherits from another entity class, inheritance has to
 be declared by adding the appropriate configuration for the root entity.
 
 ## Deprecated stubs for "concrete table inheritance"

composer.json

@@ -34,7 +34,7 @@
         "doctrine/lexer": "^2",
         "doctrine/persistence": "^2.4 || ^3",
         "psr/cache": "^1 || ^2 || ^3",
-        "symfony/console": "^4.2 || ^5.0 || ^6.0",
+        "symfony/console": "^4.2 || ^5.0 || ^6.0 || ^7.0",
         "symfony/polyfill-php72": "^1.23",
         "symfony/polyfill-php80": "^1.16"
     },
@@ -42,14 +42,14 @@
         "doctrine/annotations": "^1.13 || ^2",
         "doctrine/coding-standard": "^9.0.2 || ^12.0",
         "phpbench/phpbench": "^0.16.10 || ^1.0",
-        "phpstan/phpstan": "~1.4.10 || 1.10.25",
+        "phpstan/phpstan": "~1.4.10 || 1.10.35",
         "phpunit/phpunit": "^7.5 || ^8.5 || ^9.6",
         "psr/log": "^1 || ^2 || ^3",
         "squizlabs/php_codesniffer": "3.7.2",
-        "symfony/cache": "^4.4 || ^5.4 || ^6.0",
-        "symfony/var-exporter": "^4.4 || ^5.4 || ^6.2",
-        "symfony/yaml": "^3.4 || ^4.0 || ^5.0 || ^6.0",
-        "vimeo/psalm": "4.30.0 || 5.13.1"
+        "symfony/cache": "^4.4 || ^5.4 || ^6.4 || ^7.0",
+        "symfony/var-exporter": "^4.4 || ^5.4 || ^6.2 || ^7.0",
+        "symfony/yaml": "^3.4 || ^4.0 || ^5.0 || ^6.0 || ^7.0",
+        "vimeo/psalm": "4.30.0 || 5.16.0"
     },
     "conflict": {
         "doctrine/annotations": "<1.13 || >= 3.0"

docs/en/cookbook/aggregate-fields.rst

@@ -211,7 +211,7 @@ Now look at the following test-code for our entities:
     {
         public function testAddEntry()
         {
-            $account = new Account("123456", $maxCredit = 200);
+            $account = new Account("123456", maxCredit: 200);
             $this->assertEquals(0, $account->getBalance());
     
             $account->addEntry(500);
@@ -223,7 +223,7 @@ Now look at the following test-code for our entities:
     
         public function testExceedMaxLimit()
         {
-            $account = new Account("123456", $maxCredit = 200);
+            $account = new Account("123456", maxCredit: 200);
     
             $this->expectException(Exception::class);
             $account->addEntry(-1000);

docs/en/cookbook/implementing-the-notify-changetracking-policy.rst

@@ -13,7 +13,7 @@ for all our domain objects.
 .. note::
 
     The notify change tracking policy is deprecated and will be removed in ORM 3.0.
-    (`Details <https://github.com/doctrine/orm/issues/8383>`_)
+    (\ `Details <https://github.com/doctrine/orm/issues/8383>`_)
 
 Implementing NotifyPropertyChanged
 ----------------------------------

docs/en/cookbook/resolve-target-entity-listener.rst

@@ -127,7 +127,7 @@ the targetEntity resolution will occur reliably:
     // Add the ResolveTargetEntityListener
     $evm->addEventListener(Doctrine\ORM\Events::loadClassMetadata, $rtel);
 
-    $connection = \Doctrine\DBAL\DriverManager::createConnection($connectionOptions, $config, $evm);
+    $connection = \Doctrine\DBAL\DriverManager::getConnection($connectionOptions, $config, $evm);
     $em = new \Doctrine\ORM\EntityManager($connection, $config, $evm);
 
 Final Thoughts

docs/en/cookbook/validation-of-entities.rst

@@ -58,6 +58,10 @@ First Attributes:
 .. code-block:: php
 
     <?php
+    use Doctrine\ORM\Mapping\Entity;
+    use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
+    use Doctrine\ORM\Mapping\PrePersist;
+    use Doctrine\ORM\Mapping\PreUpdate;
 
     #[Entity]
     #[HasLifecycleCallbacks]

docs/en/reference/advanced-configuration.rst

@@ -29,7 +29,7 @@ steps of configuration.
 
     $config = new Configuration;
     $config->setMetadataCache($metadataCache);
-    $driverImpl = new AttributeDriver(['/path/to/lib/MyProject/Entities']);
+    $driverImpl = new AttributeDriver(['/path/to/lib/MyProject/Entities'], true);
     $config->setMetadataDriverImpl($driverImpl);
     $config->setQueryCache($queryCache);
     $config->setProxyDir('/path/to/myproject/lib/MyProject/Proxies');
@@ -134,7 +134,7 @@ The attribute driver can be injected in the ``Doctrine\ORM\Configuration``:
     <?php
     use Doctrine\ORM\Mapping\Driver\AttributeDriver;
 
-    $driverImpl = new AttributeDriver(['/path/to/lib/MyProject/Entities']);
+    $driverImpl = new AttributeDriver(['/path/to/lib/MyProject/Entities'], true);
     $config->setMetadataDriverImpl($driverImpl);
 
 The path information to the entities is required for the attribute
@@ -408,7 +408,7 @@ means that you have to register a special autoloader for these classes:
 .. code-block:: php
 
     <?php
-    use Doctrine\Common\Proxy\Autoloader;
+    use Doctrine\ORM\Proxy\Autoloader;
 
     $proxyDir = "/path/to/proxies";
     $proxyNamespace = "MyProxies";

docs/en/reference/architecture.rst

@@ -24,28 +24,34 @@ performance it is also recommended that you use APC with PHP.
 Doctrine ORM Packages
 -------------------
 
-Doctrine ORM is divided into three main packages.
+Doctrine ORM is divided into four main packages.
 
--  Common
--  DBAL (includes Common)
--  ORM (includes DBAL+Common)
+-  `Collections <https://www.doctrine-project.org/projects/doctrine-collections/en/stable/index.html>`_
+-  `Event Manager <https://www.doctrine-project.org/projects/doctrine-event-manager/en/stable/index.html>`_
+-  `Persistence <https://www.doctrine-project.org/projects/doctrine-persistence/en/stable/index.html>`_
+-  `DBAL <https://www.doctrine-project.org/projects/doctrine-dbal/en/stable/index.html>`_
+-  ORM (depends on DBAL+Persistence+Collections)
 
 This manual mainly covers the ORM package, sometimes touching parts
-of the underlying DBAL and Common packages. The Doctrine code base
+of the underlying DBAL and Persistence packages. The Doctrine code base
 is split in to these packages for a few reasons and they are to...
 
 
 -  ...make things more maintainable and decoupled
--  ...allow you to use the code in Doctrine Common without the ORM
-   or DBAL
+-  ...allow you to use the code in Doctrine Persistence and Collections
+  without the ORM or DBAL
 -  ...allow you to use the DBAL without the ORM
 
-The Common Package
-~~~~~~~~~~~~~~~~~~
+Collection, Event Manager and Persistence
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The Common package contains highly reusable components that have no
-dependencies beyond the package itself (and PHP, of course). The
-root namespace of the Common package is ``Doctrine\Common``.
+The Collection, Event Manager and Persistence packages contain highly
+reusable components that have no dependencies beyond the packages
+themselves (and PHP, of course). The root namespace of the Persistence
+package is ``Doctrine\Persistence``. The root namespace of the
+Collection package is ``Doctrine\Common\Collections``, for historical
+reasons. The root namespace of the Event Manager package is just
+``Doctrine\Common``, also for historical reasons.
 
 The DBAL Package
 ~~~~~~~~~~~~~~~~
@@ -199,5 +205,3 @@ typical implementation of the
 to keep track of all the things that need to be done the next time
 ``flush`` is invoked. You usually do not directly interact with a
 ``UnitOfWork`` but with the ``EntityManager`` instead.
-
-

docs/en/reference/basic-mapping.rst

@@ -47,8 +47,7 @@ mapping metadata:
 -  :doc:`Attributes <attributes-reference>`
 -  :doc:`XML <xml-mapping>`
 -  :doc:`PHP code <php-mapping>`
--  :doc:`Docblock Annotations <annotations-reference>` (deprecated and
-  will be removed in ``doctrine/orm`` 3.0)
+-  :doc:`Docblock Annotations <annotations-reference>` (deprecated and will be removed in ``doctrine/orm`` 3.0)
 -  :doc:`YAML <yaml-mapping>` (deprecated and will be removed in ``doctrine/orm`` 3.0.)
 
 This manual will usually show mapping metadata via attributes, though
@@ -423,9 +422,11 @@ the field that serves as the identifier with the ``#[Id]`` attribute.
             # fields here
 
 In most cases using the automatic generator strategy (``#[GeneratedValue]``) is
-what you want. It defaults to the identifier generation mechanism your current
-database vendor prefers: AUTO_INCREMENT with MySQL, sequences with PostgreSQL
-and Oracle and so on.
+what you want, but for backwards-compatibility reasons it might not. It
+defaults to the identifier generation mechanism your current database
+vendor preferred at the time that strategy was introduced:
+``AUTO_INCREMENT`` with MySQL, sequences with PostgreSQL and Oracle and
+so on.
 
 .. _identifier-generation-strategies:
 
@@ -442,17 +443,18 @@ Here is the list of possible generation strategies:
 
 -  ``AUTO`` (default): Tells Doctrine to pick the strategy that is
    preferred by the used database platform. The preferred strategies
-   are IDENTITY for MySQL, SQLite, MsSQL and SQL Anywhere and SEQUENCE
-   for Oracle and PostgreSQL. This strategy provides full portability.
--  ``SEQUENCE``: Tells Doctrine to use a database sequence for ID
-   generation. This strategy does currently not provide full
-   portability. Sequences are supported by Oracle, PostgreSql and
-   SQL Anywhere.
+   are ``IDENTITY`` for MySQL, SQLite, MsSQL and SQL Anywhere and, for
+   historical reasons, ``SEQUENCE`` for Oracle and PostgreSQL. This
+   strategy provides full portability.
 -  ``IDENTITY``: Tells Doctrine to use special identity columns in
    the database that generate a value on insertion of a row. This
    strategy does currently not provide full portability and is
    supported by the following platforms: MySQL/SQLite/SQL Anywhere
-   (AUTO\_INCREMENT), MSSQL (IDENTITY) and PostgreSQL (SERIAL).
+   (``AUTO_INCREMENT``), MSSQL (``IDENTITY``) and PostgreSQL (``SERIAL``).
+-  ``SEQUENCE``: Tells Doctrine to use a database sequence for ID
+   generation. This strategy does currently not provide full
+   portability. Sequences are supported by Oracle, PostgreSql and
+   SQL Anywhere.
 -  ``UUID`` (deprecated): Tells Doctrine to use the built-in Universally
    Unique Identifier generator. This strategy provides full portability.
 -  ``NONE``: Tells Doctrine that the identifiers are assigned (and

docs/en/reference/change-tracking-policies.rst

@@ -63,7 +63,7 @@ Notify
 .. note::
 
     The notify change tracking policy is deprecated and will be removed in ORM 3.0.
-    (`Details <https://github.com/doctrine/orm/issues/8383>`_)
+    (\ `Details <https://github.com/doctrine/orm/issues/8383>`_)
 
 This policy is based on the assumption that the entities notify
 interested listeners of changes to their properties. For that

docs/en/reference/dql-doctrine-query-language.rst

@@ -464,6 +464,11 @@ hierarchies:
     $query = $em->createQuery('SELECT u FROM Doctrine\Tests\Models\Company\CompanyPerson u WHERE u INSTANCE OF Doctrine\Tests\Models\Company\CompanyEmployee');
     $query = $em->createQuery('SELECT u FROM Doctrine\Tests\Models\Company\CompanyPerson u WHERE u INSTANCE OF ?1');
     $query = $em->createQuery('SELECT u FROM Doctrine\Tests\Models\Company\CompanyPerson u WHERE u NOT INSTANCE OF ?1');
+    $query->setParameter(0, $em->getClassMetadata(CompanyEmployee::class));
+
+.. note::
+    To use a class as parameter, you have to bind its class metadata:
+    ``$query->setParameter(0, $em->getClassMetadata(CompanyEmployee::class);``.
 
 Get all users visible on a given website that have chosen certain gender:
 
@@ -1381,7 +1386,7 @@ Result Cache API:
     $query->setResultCacheDriver(new ApcCache());
 
     $query->useResultCache(true)
-          ->setResultCacheLifeTime($seconds = 3600);
+          ->setResultCacheLifeTime(3600);
 
     $result = $query->getResult(); // cache miss
 
@@ -1392,7 +1397,7 @@ Result Cache API:
     $result = $query->getResult(); // saved in given result cache id.
 
     // or call useResultCache() with all parameters:
-    $query->useResultCache(true, $seconds = 3600, 'my_query_result');
+    $query->useResultCache(true, 3600, 'my_query_result');
     $result = $query->getResult(); // cache hit!
 
     // Introspection
@@ -1425,7 +1430,7 @@ userland:
    reloading this data. Partially loaded objects have to be passed to
    ``EntityManager::refresh()`` if they are to be reloaded fully from
    the database. This query hint is deprecated and will be removed
-   in the future (`Details <https://github.com/doctrine/orm/issues/8471>`_)
+   in the future (\ `Details <https://github.com/doctrine/orm/issues/8471>`_)
 -  ``Query::HINT_REFRESH`` - This query is used internally by
    ``EntityManager::refresh()`` and can be used in userland as well.
    If you specify this hint and a query returns the data for an entity
@@ -1457,7 +1462,7 @@ several methods to interact with it:
 
 -  ``Query::setQueryCacheDriver($driver)`` - Allows to set a Cache
    instance
--  ``Query::setQueryCacheLifeTime($seconds = 3600)`` - Set lifetime
+-  ``Query::setQueryCacheLifeTime($seconds)`` - Set lifetime
    of the query caching.
 -  ``Query::expireQueryCache($bool)`` - Enforce the expiring of the
    query cache if set to true.

docs/en/reference/events.rst

@@ -215,6 +215,10 @@ specific to a particular entity class's lifecycle.
         <?php
         use Doctrine\DBAL\Types\Types;
         use Doctrine\ORM\Event\PrePersistEventArgs;
+        use Doctrine\ORM\Mapping\Entity;
+        use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
+        use Doctrine\ORM\Mapping\PrePersist;
+        use Doctrine\ORM\Mapping\PreUpdate;
 
         #[Entity]
         #[HasLifecycleCallbacks]
@@ -453,13 +457,12 @@ prePersist
 
 There are two ways for the ``prePersist`` event to be triggered:
 
-- One is obviously when you call ``EntityManager::persist()``. The
-event is also called for all :ref:`cascaded associations<transitive-persistence>`.
-- The other is inside the
-``flush()`` method when changes to associations are computed and
-this association is marked as :ref:`cascade: persist<transitive-persistence>`. Any new entity found
-during this operation is also persisted and ``prePersist`` called
-on it. This is called :ref:`persistence by reachability<persistence-by-reachability>`.
+- One is when you call ``EntityManager::persist()``. The
+  event is also called for all :ref:`cascaded associations<transitive-persistence>`.
+- The other is inside the ``flush()`` method when changes to associations are computed and
+  this association is marked as :ref:`cascade: persist<transitive-persistence>`. Any new entity found
+  during this operation is also persisted and ``prePersist`` called
+  on it. This is called :ref:`persistence by reachability<persistence-by-reachability>`.
 
 In both cases you get passed a ``PrePersistEventArgs`` instance
 which has access to the entity and the entity manager.
@@ -705,13 +708,21 @@ not directly mapped by Doctrine.
 -  The ``postUpdate`` event occurs after the database
    update operations to entity data. It is not called for a DQL
    ``UPDATE`` statement.
--  The ``postPersist`` event occurs for an entity after
-   the entity has been made persistent. It will be invoked after the
-   database insert operation for that entity. A generated primary key value for
-   the entity will be available in the postPersist event.
+-  The ``postPersist`` event occurs for an entity after the entity has
+   been made persistent. It will be invoked after all database insert
+   operations for new entities have been performed. Generated primary
+   key values will be available for all entities at the time this
+   event is triggered.
 -  The ``postRemove`` event occurs for an entity after the
-   entity has been deleted. It will be invoked after the database
-   delete operations. It is not called for a DQL ``DELETE`` statement.
+   entity has been deleted. It will be invoked after all database
+   delete operations for entity rows have been executed. This event is
+   not called for a DQL ``DELETE`` statement.
+
+.. note::
+
+    At the time ``postPersist`` is called, there may still be collection and/or
+    "extra" updates pending. The database may not yet be completely in
+    sync with the entity states in memory, not even for the new entities.
 
 .. warning::
 
@@ -720,6 +731,19 @@ not directly mapped by Doctrine.
     cascade remove relations. In this case, you should load yourself the proxy in
     the associated ``pre*`` event.
 
+.. warning::
+
+    Making changes to entities and calling ``EntityManager::flush()`` from within
+    ``post*`` event handlers is strongly discouraged, and might be deprecated and
+    eventually prevented in the future.
+
+    The reason is that it causes re-entrance into ``UnitOfWork::commit()`` while a commit
+    is currently being processed. The ``UnitOfWork`` was never designed to support this,
+    and its behavior in this situation is not covered by any tests.
+
+    This may lead to entity or collection updates being missed, applied only in parts and
+    changes being lost at the end of the commit phase.
+
 .. _reference-events-post-load:
 
 postLoad

docs/en/reference/limitations-and-known-issues.rst

@@ -167,7 +167,7 @@ have produced, this is probably fine.
 
 However, to mention known limitations, it is currently not possible to use "class"
 level `annotations <https://github.com/doctrine/orm/pull/1517>`_ or
-`attributes <https://github.com/doctrine/orm/issues/8868>` on traits, and attempts to
+`attributes <https://github.com/doctrine/orm/issues/8868>`_ on traits, and attempts to
 improve parser support for traits as `here <https://github.com/doctrine/annotations/pull/102>`_
 or `there <https://github.com/doctrine/annotations/pull/63>`_ have been abandoned
 due to complexity.

docs/en/reference/partial-objects.rst

@@ -6,7 +6,7 @@ Partial Objects
 
     Creating Partial Objects through DQL is deprecated and
     will be removed in the future, use data transfer object
-    support in DQL instead. (`Details
+    support in DQL instead. (\ `Details
     <https://github.com/doctrine/orm/issues/8471>`_)
 
 A partial object is an object whose state is not fully initialized

docs/en/reference/query-builder.rst

@@ -253,7 +253,7 @@ Calling ``setParameter()`` automatically infers which type you are setting as
 value. This works for integers, arrays of strings/integers, DateTime instances
 and for managed entities. If you want to set a type explicitly you can call
 the third argument to ``setParameter()`` explicitly. It accepts either a DBAL
-Doctrine\DBAL\ParameterType::* or a DBAL Type name for conversion.
+``Doctrine\DBAL\ParameterType::*`` or a DBAL Type name for conversion.
 
 .. note::
 

docs/en/reference/unitofwork.rst

@@ -137,7 +137,7 @@ optimize the performance of the Flush Operation:
 .. note::
 
     Flush only a single entity with ``$entityManager->flush($entity)`` is deprecated and will be removed in ORM 3.0.
-    (`Details <https://github.com/doctrine/orm/issues/8459>`_)
+    (\ `Details <https://github.com/doctrine/orm/issues/8459>`_)
 
 Query Internals
 ---------------

docs/en/reference/working-with-objects.rst

@@ -192,6 +192,11 @@ be properly synchronized with the database when
     database in the most efficient way and a single, short transaction,
     taking care of maintaining referential integrity.
 
+.. note::
+
+    Do not make any assumptions in your code about the number of queries
+    it takes to flush changes, about the ordering of ``INSERT``, ``UPDATE``
+    and ``DELETE`` queries or the order in which entities will be processed.
 
 Example:
 
@@ -777,6 +782,23 @@ and these associations are mapped as EAGER, they will automatically
 be loaded together with the entity being queried and is thus
 immediately available to your application.
 
+Eager Loading can also be configured at runtime through
+``AbstractQuery::setFetchMode`` in DQL or Native Queries.
+
+Eager loading for many-to-one and one-to-one associations is using either a
+LEFT JOIN or a second query for fetching the related entity eagerly.
+
+Eager loading for many-to-one associations uses a second query to load
+the collections for several entities at the same time.
+
+When many-to-many, one-to-one or one-to-many associations are eagerly loaded,
+then the global batch size configuration is used to avoid IN(?) queries with
+too many arguments. The default batch size is 100 and can be changed with
+``Configuration::setEagerFetchBatchSize()``.
+
+For eagerly loaded Many-To-Many associations one query has to be made for each
+collection.
+
 By Lazy Loading
 ~~~~~~~~~~~~~~~
 

docs/en/tutorials/getting-started.rst

@@ -18,7 +18,7 @@ before. There are some prerequisites for the tutorial that have to be
 installed:
 
 - PHP (latest stable version)
-- Composer Package Manager (`Install Composer
+- Composer Package Manager (\ `Install Composer
   <https://getcomposer.org/doc/00-intro.md>`_)
 
 The code of this tutorial is `available on Github <https://github.com/doctrine/doctrine2-orm-tutorial>`_.
@@ -321,7 +321,7 @@ data in your storage, and later in your application when the data is loaded agai
 .. note::
 
     This method, although very common, is inappropriate for Domain Driven
-    Design (`DDD <https://en.wikipedia.org/wiki/Domain-driven_design>`_)
+    Design (\ `DDD <https://en.wikipedia.org/wiki/Domain-driven_design>`_)
     where methods should represent real business operations and not simple
     property change, And business invariants should be maintained both in the
     application state (entities in this case) and in the database, with no
@@ -735,7 +735,7 @@ classes. We'll store them in ``src/Bug.php`` and ``src/User.php``, respectively.
         #[ORM\Id]
         #[ORM\Column(type: 'integer')]
         #[ORM\GeneratedValue]
-        private int $id;
+        private int|null $id;
 
         #[ORM\Column(type: 'string')]
         private string $description;
@@ -1199,21 +1199,21 @@ which translates the YYYY-mm-dd HH:mm:ss database format
 into a PHP DateTime instance and back.
 
 After the field definitions, the two qualified references to the
-user entity are defined. They are created by the ``many-to-one``
-tag. The class name of the related entity has to be specified with
-the ``target-entity`` attribute, which is enough information for
-the database mapper to access the foreign-table. Since
+user entity are defined. They are created by the ``ManyToOne``
+attribute. The class name of the related entity has to be specified with
+the ``targetEntity`` parameter, which is enough information for
+the database mapper to access the foreign table. Since
 ``reporter`` and ``engineer`` are on the owning side of a
-bi-directional relation, we also have to specify the ``inversed-by``
-attribute. They have to point to the field names on the inverse
-side of the relationship. We will see in the next example that the ``inversed-by``
-attribute has a counterpart ``mapped-by`` which makes that
+bi-directional relation, we also have to specify the ``inversedBy``
+parameter. They have to point to the field names on the inverse
+side of the relationship. We will see in the next example that the ``inversedBy``
+parameter has a counterpart ``mappedBy`` which makes that
 the inverse side.
 
 The last definition is for the ``Bug#products`` collection. It
 holds all products where the specific bug occurs. Again
-you have to define the ``target-entity`` and ``field`` attributes
-on the ``many-to-many`` tag.
+you have to define the ``targetEntity`` and ``field`` parameters
+on the ``ManyToMany`` attribute.
 
 Finally, we'll add metadata mappings for the ``User`` entity.
 
@@ -1336,7 +1336,7 @@ Finally, we'll add metadata mappings for the ``User`` entity.
               targetEntity: Bug
               mappedBy: engineer
 
-Here are some new things to mention about the ``one-to-many`` tags.
+Here are some new things to mention about the ``OneToMany`` attribute.
 Remember that we discussed about the inverse and owning side. Now
 both reportedBugs and assignedBugs are inverse relations, which
 means the join details have already been defined on the owning

docs/en/tutorials/pagination.rst

@@ -15,7 +15,7 @@ has a very simple API and implements the SPL interfaces ``Countable`` and
                            ->setFirstResult(0)
                            ->setMaxResults(100);
 
-    $paginator = new Paginator($query, $fetchJoinCollection = true);
+    $paginator = new Paginator($query, fetchJoinCollection: true);
 
     $c = count($paginator);
     foreach ($paginator as $post) {
@@ -36,10 +36,25 @@ correct result:
 
 This behavior is only necessary if you actually fetch join a to-many
 collection. You can disable this behavior by setting the
-``$fetchJoinCollection`` flag to ``false``; in that case only 2 instead of the 3 queries
+``fetchJoinCollection`` argument to ``false``; in that case only 2 instead of the 3 queries
 described are executed. We hope to automate the detection for this in
 the future.
 
 .. note::
 
-    ``$fetchJoinCollection`` flag set to ``true`` might affect results if you use aggregations in your query.
+    ``fetchJoinCollection`` argument set to ``true`` might affect results if you use aggregations in your query.
+
+By using the ``Paginator::HINT_ENABLE_DISTINCT`` you can instruct doctrine that the query to be executed
+will not produce "duplicate" rows (only to-one relations are joined), thus the SQL limit will work as expected.
+In this way the `DISTINCT` keyword will be omitted and can bring important performance improvements.
+
+.. code-block:: php
+
+    <?php
+    use Doctrine\ORM\Tools\Pagination\Paginator;
+
+    $dql = "SELECT u, p FROM User u JOIN u.mainPicture p";
+    $query = $entityManager->createQuery($dql)
+                           ->setHint(Paginator::HINT_ENABLE_DISTINCT, false)
+                           ->setFirstResult(0)
+                           ->setMaxResults(100);

lib/Doctrine/ORM/AbstractQuery.php

@@ -10,7 +10,6 @@ use Doctrine\Common\Cache\Psr6\CacheAdapter;
 use Doctrine\Common\Cache\Psr6\DoctrineProvider;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\DBAL\Cache\QueryCacheProfile;
 use Doctrine\DBAL\Result;
 use Doctrine\Deprecations\Deprecation;
@@ -20,6 +19,7 @@ use Doctrine\ORM\Cache\QueryCacheKey;
 use Doctrine\ORM\Cache\TimestampCacheKey;
 use Doctrine\ORM\Internal\Hydration\IterableResult;
 use Doctrine\ORM\Mapping\MappingException as ORMMappingException;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\Query\Parameter;
 use Doctrine\ORM\Query\QueryException;
 use Doctrine\ORM\Query\ResultSetMapping;
@@ -430,7 +430,7 @@ abstract class AbstractQuery
         }
 
         try {
-            $class = ClassUtils::getClass($value);
+            $class = DefaultProxyClassNameResolver::getClass($value);
             $value = $this->_em->getUnitOfWork()->getSingleIdentifierValue($value);
 
             if ($value === null) {
@@ -1010,7 +1010,7 @@ abstract class AbstractQuery
      *
      * Alias for getSingleResult(HYDRATE_SINGLE_SCALAR).
      *
-     * @return bool|float|int|string The scalar result.
+     * @return bool|float|int|string|null The scalar result.
      *
      * @throws NoResultException        If the query returned no result.
      * @throws NonUniqueResultException If the query result is not unique.

lib/Doctrine/ORM/Cache/DefaultCache.php

@@ -4,12 +4,12 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Cache;
 
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\ORM\Cache;
 use Doctrine\ORM\Cache\Persister\CachedPersister;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\ORMInvalidArgumentException;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\UnitOfWork;
 
 use function is_array;
@@ -293,7 +293,7 @@ class DefaultCache implements Cache
     private function toIdentifierArray(ClassMetadata $metadata, $identifier): array
     {
         if (is_object($identifier)) {
-            $class = ClassUtils::getClass($identifier);
+            $class = DefaultProxyClassNameResolver::getClass($identifier);
             if ($this->em->getMetadataFactory()->hasMetadataFor($class)) {
                 $identifier = $this->uow->getSingleIdentifierValue($identifier);
 

lib/Doctrine/ORM/Cache/DefaultEntityHydrator.php

@@ -4,9 +4,9 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Cache;
 
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\Query;
 use Doctrine\ORM\UnitOfWork;
 use Doctrine\ORM\Utility\IdentifierFlattener;
@@ -112,7 +112,7 @@ class DefaultEntityHydrator implements EntityHydrator
             }
 
             if (! isset($assoc['id'])) {
-                $targetClass = ClassUtils::getClass($data[$name]);
+                $targetClass = DefaultProxyClassNameResolver::getClass($data[$name]);
                 $targetId    = $this->uow->getEntityIdentifier($data[$name]);
                 $data[$name] = new AssociationCacheEntry($targetClass, $targetId);
 

lib/Doctrine/ORM/Cache/Persister/Collection/AbstractCollectionPersister.php

@@ -6,7 +6,6 @@ namespace Doctrine\ORM\Cache\Persister\Collection;
 
 use Doctrine\Common\Collections\Collection;
 use Doctrine\Common\Collections\Criteria;
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Cache\CollectionCacheKey;
 use Doctrine\ORM\Cache\CollectionHydrator;
@@ -19,6 +18,7 @@ use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
 use Doctrine\ORM\PersistentCollection;
 use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\UnitOfWork;
 
 use function array_values;
@@ -148,7 +148,7 @@ abstract class AbstractCollectionPersister implements CachedCollectionPersister
             }
 
             $class     = $this->targetEntity;
-            $className = ClassUtils::getClass($elements[$index]);
+            $className = DefaultProxyClassNameResolver::getClass($elements[$index]);
 
             if ($className !== $this->targetEntity->name) {
                 $class = $this->metadataFactory->getMetadataFor($className);

lib/Doctrine/ORM/Cache/Persister/Collection/ReadOnlyCachedCollectionPersister.php

@@ -4,9 +4,9 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Cache\Persister\Collection;
 
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\ORM\Cache\Exception\CannotUpdateReadOnlyCollection;
 use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 
 class ReadOnlyCachedCollectionPersister extends NonStrictReadWriteCachedCollectionPersister
 {
@@ -17,7 +17,7 @@ class ReadOnlyCachedCollectionPersister extends NonStrictReadWriteCachedCollecti
     {
         if ($collection->isDirty() && $collection->getSnapshot()) {
             throw CannotUpdateReadOnlyCollection::fromEntityAndField(
-                ClassUtils::getClass($collection->getOwner()),
+                DefaultProxyClassNameResolver::getClass($collection->getOwner()),
                 $this->association['fieldName']
             );
         }

lib/Doctrine/ORM/Cache/Persister/Entity/AbstractEntityPersister.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Cache\Persister\Entity;
 
 use Doctrine\Common\Collections\Criteria;
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\ORM\Cache;
 use Doctrine\ORM\Cache\CollectionCacheKey;
 use Doctrine\ORM\Cache\EntityCacheKey;
@@ -21,6 +20,7 @@ use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
 use Doctrine\ORM\PersistentCollection;
 use Doctrine\ORM\Persisters\Entity\EntityPersister;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\UnitOfWork;
 
 use function array_merge;
@@ -190,7 +190,7 @@ abstract class AbstractEntityPersister implements CachedEntityPersister
     public function storeEntityCache($entity, EntityCacheKey $key)
     {
         $class     = $this->class;
-        $className = ClassUtils::getClass($entity);
+        $className = DefaultProxyClassNameResolver::getClass($entity);
 
         if ($className !== $this->class->name) {
             $class = $this->metadataFactory->getMetadataFor($className);
@@ -438,7 +438,7 @@ abstract class AbstractEntityPersister implements CachedEntityPersister
         }
 
         $class     = $this->class;
-        $className = ClassUtils::getClass($entity);
+        $className = DefaultProxyClassNameResolver::getClass($entity);
 
         if ($className !== $this->class->name) {
             $class = $this->metadataFactory->getMetadataFor($className);

lib/Doctrine/ORM/Cache/Persister/Entity/ReadOnlyCachedEntityPersister.php

@@ -4,8 +4,8 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Cache\Persister\Entity;
 
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\ORM\Cache\Exception\CannotUpdateReadOnlyEntity;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 
 /**
  * Specific read-only region entity persister
@@ -17,6 +17,6 @@ class ReadOnlyCachedEntityPersister extends NonStrictReadWriteCachedEntityPersis
      */
     public function update($entity)
     {
-        throw CannotUpdateReadOnlyEntity::fromEntity(ClassUtils::getClass($entity));
+        throw CannotUpdateReadOnlyEntity::fromEntity(DefaultProxyClassNameResolver::getClass($entity));
     }
 }

lib/Doctrine/ORM/Configuration.php

@@ -13,6 +13,7 @@ use Doctrine\Common\Cache\Cache as CacheDriver;
 use Doctrine\Common\Cache\Psr6\CacheAdapter;
 use Doctrine\Common\Cache\Psr6\DoctrineProvider;
 use Doctrine\Common\Persistence\PersistentObject;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Cache\CacheConfiguration;
 use Doctrine\ORM\Cache\Exception\CacheException;
@@ -27,6 +28,7 @@ use Doctrine\ORM\Exception\NotSupported;
 use Doctrine\ORM\Exception\ProxyClassesAlwaysRegenerating;
 use Doctrine\ORM\Exception\UnknownEntityNamespace;
 use Doctrine\ORM\Internal\Hydration\AbstractHydrator;
+use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
 use Doctrine\ORM\Mapping\DefaultEntityListenerResolver;
 use Doctrine\ORM\Mapping\DefaultNamingStrategy;
@@ -68,6 +70,21 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /** @var mixed[] */
     protected $_attributes = [];
 
+    /** @psalm-var array<class-string<AbstractPlatform>, ClassMetadata::GENERATOR_TYPE_*> */
+    private $identityGenerationPreferences = [];
+
+    /** @psalm-param array<class-string<AbstractPlatform>, ClassMetadata::GENERATOR_TYPE_*> $value */
+    public function setIdentityGenerationPreferences(array $value): void
+    {
+        $this->identityGenerationPreferences = $value;
+    }
+
+    /** @psalm-return array<class-string<AbstractPlatform>, ClassMetadata::GENERATOR_TYPE_*> $value */
+    public function getIdentityGenerationPreferences(): array
+    {
+        return $this->identityGenerationPreferences;
+    }
+
     /**
      * Sets the directory where Doctrine generates any necessary proxy class files.
      *
@@ -1117,4 +1134,24 @@ class Configuration extends \Doctrine\DBAL\Configuration
 
         $this->_attributes['isLazyGhostObjectEnabled'] = $flag;
     }
+
+    public function setRejectIdCollisionInIdentityMap(bool $flag): void
+    {
+        $this->_attributes['rejectIdCollisionInIdentityMap'] = $flag;
+    }
+
+    public function isRejectIdCollisionInIdentityMapEnabled(): bool
+    {
+        return $this->_attributes['rejectIdCollisionInIdentityMap'] ?? false;
+    }
+
+    public function setEagerFetchBatchSize(int $batchSize = 100): void
+    {
+        $this->_attributes['fetchModeSubselectBatchSize'] = $batchSize;
+    }
+
+    public function getEagerFetchBatchSize(): int
+    {
+        return $this->_attributes['fetchModeSubselectBatchSize'] ?? 100;
+    }
 }

lib/Doctrine/ORM/Decorator/EntityManagerDecorator.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Decorator;
 
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\EntityRepository;
 use Doctrine\ORM\Query\ResultSetMapping;
@@ -170,6 +171,13 @@ abstract class EntityManagerDecorator extends ObjectManagerDecorator implements
      */
     public function getPartialReference($entityName, $identifier)
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/10987',
+            'Method %s is deprecated and will be removed in 3.0.',
+            __METHOD__
+        );
+
         return $this->wrapped->getPartialReference($entityName, $identifier);
     }
 

lib/Doctrine/ORM/EntityManager.php

@@ -9,7 +9,6 @@ use BadMethodCallException;
 use Doctrine\Common\Cache\Psr6\CacheAdapter;
 use Doctrine\Common\EventManager;
 use Doctrine\Common\Persistence\PersistentObject;
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\DriverManager;
 use Doctrine\DBAL\LockMode;
@@ -24,6 +23,7 @@ use Doctrine\ORM\Exception\ORMException;
 use Doctrine\ORM\Exception\UnrecognizedIdentifierFields;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\Proxy\ProxyFactory;
 use Doctrine\ORM\Query\Expr;
 use Doctrine\ORM\Query\FilterCollection;
@@ -444,7 +444,7 @@ class EntityManager implements EntityManagerInterface
 
         foreach ($id as $i => $value) {
             if (is_object($value)) {
-                $className = ClassUtils::getClass($value);
+                $className = DefaultProxyClassNameResolver::getClass($value);
                 if ($this->metadataFactory->hasMetadataFor($className)) {
                     $id[$i] = $this->unitOfWork->getSingleIdentifierValue($value);
 
@@ -571,6 +571,12 @@ class EntityManager implements EntityManagerInterface
      */
     public function getPartialReference($entityName, $identifier)
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/10987',
+            'Method %s is deprecated and will be removed in 3.0.',
+            __METHOD__
+        );
         $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
 
         $entity = $this->unitOfWork->tryGetById($identifier, $class->rootEntityName);
@@ -981,7 +987,7 @@ class EntityManager implements EntityManagerInterface
         Deprecation::trigger(
             'doctrine/orm',
             'https://github.com/doctrine/orm/pull/9961',
-            '%s() is deprecated. To boostrap a DBAL connection, call %s::getConnection() instead. Use the constructor to create an instance of %s.',
+            '%s() is deprecated. To bootstrap a DBAL connection, call %s::getConnection() instead. Use the constructor to create an instance of %s.',
             __METHOD__,
             DriverManager::class,
             self::class

lib/Doctrine/ORM/EntityManagerInterface.php

@@ -200,6 +200,8 @@ interface EntityManagerInterface extends ObjectManager
      * never be visible to the application (especially not event listeners) as it will
      * never be loaded in the first place.
      *
+     * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
+     *
      * @param string $entityName The name of the entity type.
      * @param mixed  $identifier The entity identifier.
      * @psalm-param class-string<T> $entityName

lib/Doctrine/ORM/Exception/EntityIdentityCollisionException.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Exception;
+
+use function get_class;
+use function sprintf;
+
+final class EntityIdentityCollisionException extends ORMException
+{
+    /**
+     * @param object $existingEntity
+     * @param object $newEntity
+     */
+    public static function create($existingEntity, $newEntity, string $idHash): self
+    {
+        return new self(
+            sprintf(
+                <<<'EXCEPTION'
+While adding an entity of class %s with an ID hash of "%s" to the identity map,
+another object of class %s was already present for the same ID. This exception
+is a safeguard against an internal inconsistency - IDs should uniquely map to
+entity object instances. This problem may occur if:
+
+- you use application-provided IDs and reuse ID values;
+- database-provided IDs are reassigned after truncating the database without
+clearing the EntityManager;
+- you might have been using EntityManager#getReference() to create a reference
+for a nonexistent ID that was subsequently (by the RDBMS) assigned to another
+entity.
+
+Otherwise, it might be an ORM-internal inconsistency, please report it.
+EXCEPTION
+                ,
+                get_class($newEntity),
+                $idHash,
+                get_class($existingEntity)
+            )
+        );
+    }
+}

lib/Doctrine/ORM/Internal/CommitOrder/Edge.php

@@ -1,46 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Internal\CommitOrder;
-
-use Doctrine\Deprecations\Deprecation;
-
-/**
- * @internal
- * @deprecated
- */
-final class Edge
-{
-    /**
-     * @var string
-     * @readonly
-     */
-    public $from;
-
-    /**
-     * @var string
-     * @readonly
-     */
-    public $to;
-
-    /**
-     * @var int
-     * @readonly
-     */
-    public $weight;
-
-    public function __construct(string $from, string $to, int $weight)
-    {
-        Deprecation::triggerIfCalledFromOutside(
-            'doctrine/orm',
-            'https://github.com/doctrine/orm/pull/10547',
-            'The %s class is deprecated and will be removed in ORM 3.0',
-            self::class
-        );
-
-        $this->from   = $from;
-        $this->to     = $to;
-        $this->weight = $weight;
-    }
-}

lib/Doctrine/ORM/Internal/CommitOrder/Vertex.php

@@ -1,49 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Internal\CommitOrder;
-
-use Doctrine\Deprecations\Deprecation;
-use Doctrine\ORM\Mapping\ClassMetadata;
-
-/**
- * @internal
- * @deprecated
- */
-final class Vertex
-{
-    /**
-     * @var string
-     * @readonly
-     */
-    public $hash;
-
-    /**
-     * @var int
-     * @psalm-var VertexState::*
-     */
-    public $state = VertexState::NOT_VISITED;
-
-    /**
-     * @var ClassMetadata
-     * @readonly
-     */
-    public $value;
-
-    /** @var array<string, Edge> */
-    public $dependencyList = [];
-
-    public function __construct(string $hash, ClassMetadata $value)
-    {
-        Deprecation::triggerIfCalledFromOutside(
-            'doctrine/orm',
-            'https://github.com/doctrine/orm/pull/10547',
-            'The %s class is deprecated and will be removed in ORM 3.0',
-            self::class
-        );
-
-        $this->hash  = $hash;
-        $this->value = $value;
-    }
-}

lib/Doctrine/ORM/Internal/CommitOrder/VertexState.php

@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Internal\CommitOrder;
-
-use Doctrine\Deprecations\Deprecation;
-
-/**
- * @internal
- * @deprecated
- */
-final class VertexState
-{
-    public const NOT_VISITED = 0;
-    public const IN_PROGRESS = 1;
-    public const VISITED     = 2;
-
-    private function __construct()
-    {
-        Deprecation::triggerIfCalledFromOutside(
-            'doctrine/orm',
-            'https://github.com/doctrine/orm/pull/10547',
-            'The %s class is deprecated and will be removed in ORM 3.0',
-            self::class
-        );
-    }
-}

lib/Doctrine/ORM/Internal/CommitOrderCalculator.php

@@ -1,177 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Internal;
-
-use Doctrine\Deprecations\Deprecation;
-use Doctrine\ORM\Internal\CommitOrder\Edge;
-use Doctrine\ORM\Internal\CommitOrder\Vertex;
-use Doctrine\ORM\Internal\CommitOrder\VertexState;
-use Doctrine\ORM\Mapping\ClassMetadata;
-
-use function array_reverse;
-
-/**
- * CommitOrderCalculator implements topological sorting, which is an ordering
- * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
- * using a depth-first searching (DFS) to traverse the graph built in memory.
- * This algorithm have a linear running time based on nodes (V) and dependency
- * between the nodes (E), resulting in a computational complexity of O(V + E).
- *
- * @deprecated
- */
-class CommitOrderCalculator
-{
-    /** @deprecated */
-    public const NOT_VISITED = VertexState::NOT_VISITED;
-
-    /** @deprecated */
-    public const IN_PROGRESS = VertexState::IN_PROGRESS;
-
-    /** @deprecated */
-    public const VISITED = VertexState::VISITED;
-
-    /**
-     * Matrix of nodes (aka. vertex).
-     *
-     * Keys are provided hashes and values are the node definition objects.
-     *
-     * @var array<string, Vertex>
-     */
-    private $nodeList = [];
-
-    /**
-     * Volatile variable holding calculated nodes during sorting process.
-     *
-     * @psalm-var list<ClassMetadata>
-     */
-    private $sortedNodeList = [];
-
-    public function __construct()
-    {
-        Deprecation::triggerIfCalledFromOutside(
-            'doctrine/orm',
-            'https://github.com/doctrine/orm/pull/10547',
-            'The %s class is deprecated and will be removed in ORM 3.0',
-            self::class
-        );
-    }
-
-    /**
-     * Checks for node (vertex) existence in graph.
-     *
-     * @param string $hash
-     *
-     * @return bool
-     */
-    public function hasNode($hash)
-    {
-        return isset($this->nodeList[$hash]);
-    }
-
-    /**
-     * Adds a new node (vertex) to the graph, assigning its hash and value.
-     *
-     * @param string        $hash
-     * @param ClassMetadata $node
-     *
-     * @return void
-     */
-    public function addNode($hash, $node)
-    {
-        $this->nodeList[$hash] = new Vertex($hash, $node);
-    }
-
-    /**
-     * Adds a new dependency (edge) to the graph using their hashes.
-     *
-     * @param string $fromHash
-     * @param string $toHash
-     * @param int    $weight
-     *
-     * @return void
-     */
-    public function addDependency($fromHash, $toHash, $weight)
-    {
-        $this->nodeList[$fromHash]->dependencyList[$toHash]
-            = new Edge($fromHash, $toHash, $weight);
-    }
-
-    /**
-     * Return a valid order list of all current nodes.
-     * The desired topological sorting is the reverse post order of these searches.
-     *
-     * {@internal Highly performance-sensitive method.}
-     *
-     * @psalm-return list<ClassMetadata>
-     */
-    public function sort()
-    {
-        foreach ($this->nodeList as $vertex) {
-            if ($vertex->state !== VertexState::NOT_VISITED) {
-                continue;
-            }
-
-            $this->visit($vertex);
-        }
-
-        $sortedList = $this->sortedNodeList;
-
-        $this->nodeList       = [];
-        $this->sortedNodeList = [];
-
-        return array_reverse($sortedList);
-    }
-
-    /**
-     * Visit a given node definition for reordering.
-     *
-     * {@internal Highly performance-sensitive method.}
-     */
-    private function visit(Vertex $vertex): void
-    {
-        $vertex->state = VertexState::IN_PROGRESS;
-
-        foreach ($vertex->dependencyList as $edge) {
-            $adjacentVertex = $this->nodeList[$edge->to];
-
-            switch ($adjacentVertex->state) {
-                case VertexState::VISITED:
-                    // Do nothing, since node was already visited
-                    break;
-
-                case VertexState::IN_PROGRESS:
-                    if (
-                        isset($adjacentVertex->dependencyList[$vertex->hash]) &&
-                        $adjacentVertex->dependencyList[$vertex->hash]->weight < $edge->weight
-                    ) {
-                        // If we have some non-visited dependencies in the in-progress dependency, we
-                        // need to visit them before adding the node.
-                        foreach ($adjacentVertex->dependencyList as $adjacentEdge) {
-                            $adjacentEdgeVertex = $this->nodeList[$adjacentEdge->to];
-
-                            if ($adjacentEdgeVertex->state === VertexState::NOT_VISITED) {
-                                $this->visit($adjacentEdgeVertex);
-                            }
-                        }
-
-                        $adjacentVertex->state = VertexState::VISITED;
-
-                        $this->sortedNodeList[] = $adjacentVertex->value;
-                    }
-
-                    break;
-
-                case VertexState::NOT_VISITED:
-                    $this->visit($adjacentVertex);
-            }
-        }
-
-        if ($vertex->state !== VertexState::VISITED) {
-            $vertex->state = VertexState::VISITED;
-
-            $this->sortedNodeList[] = $vertex->value;
-        }
-    }
-}

lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php

@@ -24,6 +24,7 @@ use Doctrine\ORM\Id\UuidGenerator;
 use Doctrine\ORM\Mapping\Exception\CannotGenerateIds;
 use Doctrine\ORM\Mapping\Exception\InvalidCustomGenerator;
 use Doctrine\ORM\Mapping\Exception\UnknownGeneratorType;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\Persistence\Mapping\AbstractClassMetadataFactory;
 use Doctrine\Persistence\Mapping\ClassMetadata as ClassMetadataInterface;
 use Doctrine\Persistence\Mapping\Driver\MappingDriver;
@@ -38,6 +39,7 @@ use function end;
 use function explode;
 use function get_class;
 use function in_array;
+use function is_a;
 use function is_subclass_of;
 use function str_contains;
 use function strlen;
@@ -71,9 +73,17 @@ class ClassMetadataFactory extends AbstractClassMetadataFactory
     /** @var mixed[] */
     private $embeddablesActiveNesting = [];
 
+    private const NON_IDENTITY_DEFAULT_STRATEGY = [
+        'Doctrine\DBAL\Platforms\PostgreSqlPlatform' => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
+        Platforms\OraclePlatform::class => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
+        Platforms\PostgreSQLPlatform::class => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
+    ];
+
     /** @return void */
     public function setEntityManager(EntityManagerInterface $em)
     {
+        parent::setProxyClassNameResolver(new DefaultProxyClassNameResolver());
+
         $this->em = $em;
     }
 
@@ -630,7 +640,7 @@ class ClassMetadataFactory extends AbstractClassMetadataFactory
                         'https://github.com/doctrine/orm/issues/8850',
                         <<<'DEPRECATION'
 Context: Loading metadata for class %s
-Problem: Using the IDENTITY generator strategy with platform "%s" is deprecated and will not be possible in Doctrine ORM 3.0.
+Problem: Using identity columns emulated with a sequence is deprecated and will not be possible in Doctrine ORM 3.0.
 Solution: Use the SEQUENCE generator strategy instead.
 DEPRECATION
                             ,
@@ -725,14 +735,40 @@ DEPRECATION
         }
     }
 
-    /** @psalm-return ClassMetadata::GENERATOR_TYPE_SEQUENCE|ClassMetadata::GENERATOR_TYPE_IDENTITY */
+    /** @psalm-return ClassMetadata::GENERATOR_TYPE_* */
     private function determineIdGeneratorStrategy(AbstractPlatform $platform): int
     {
-        if (
-            $platform instanceof Platforms\OraclePlatform
-            || $platform instanceof Platforms\PostgreSQLPlatform
-        ) {
-            return ClassMetadata::GENERATOR_TYPE_SEQUENCE;
+        assert($this->em !== null);
+        foreach ($this->em->getConfiguration()->getIdentityGenerationPreferences() as $platformFamily => $strategy) {
+            if (is_a($platform, $platformFamily)) {
+                return $strategy;
+            }
+        }
+
+        foreach (self::NON_IDENTITY_DEFAULT_STRATEGY as $platformFamily => $strategy) {
+            if (is_a($platform, $platformFamily)) {
+                if ($platform instanceof Platforms\PostgreSQLPlatform || is_a($platform, 'Doctrine\DBAL\Platforms\PostgreSqlPlatform')) {
+                    Deprecation::trigger(
+                        'doctrine/orm',
+                        'https://github.com/doctrine/orm/issues/8893',
+                        <<<'DEPRECATION'
+Relying on non-optimal defaults for ID generation is deprecated, and IDENTITY
+results in SERIAL, which is not recommended.
+Instead, configure identifier generation strategies explicitly through
+configuration.
+We currently recommend "SEQUENCE" for "%s", so you should use
+$configuration->setIdentityGenerationPreferences([
+    "%s" => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
+]);
+DEPRECATION
+                        ,
+                        $platformFamily,
+                        $platformFamily
+                    );
+                }
+
+                return $strategy;
+            }
         }
 
         if ($platform->supportsIdentityColumns()) {

lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php

@@ -30,6 +30,8 @@ use function is_numeric;
 
 /**
  * The AnnotationDriver reads the mapping metadata from docblock annotations.
+ *
+ * @deprecated This class will be removed in 3.0 without replacement.
  */
 class AnnotationDriver extends CompatibilityAnnotationDriver
 {

lib/Doctrine/ORM/Mapping/Driver/AttributeReader.php

@@ -69,8 +69,7 @@ final class AttributeReader
             ));
         }
 
-        return $this->getPropertyAttributes($property)[$attributeName]
-            ?? ($this->isRepeatable($attributeName) ? new RepeatableAttributeCollection() : null);
+        return $this->getPropertyAttributes($property)[$attributeName] ?? null;
     }
 
     /**

lib/Doctrine/ORM/Mapping/Driver/XmlDriver.php

@@ -128,7 +128,7 @@ class XmlDriver extends FileDriver
 
         // Evaluate named queries
         if (isset($xmlRoot->{'named-queries'})) {
-            foreach ($xmlRoot->{'named-queries'}->{'named-query'} as $namedQueryElement) {
+            foreach ($xmlRoot->{'named-queries'}->{'named-query'} ?? [] as $namedQueryElement) {
                 $metadata->addNamedQuery(
                     [
                         'name'  => (string) $namedQueryElement['name'],
@@ -140,7 +140,7 @@ class XmlDriver extends FileDriver
 
         // Evaluate native named queries
         if (isset($xmlRoot->{'named-native-queries'})) {
-            foreach ($xmlRoot->{'named-native-queries'}->{'named-native-query'} as $nativeQueryElement) {
+            foreach ($xmlRoot->{'named-native-queries'}->{'named-native-query'} ?? [] as $nativeQueryElement) {
                 $metadata->addNamedNativeQuery(
                     [
                         'name'              => isset($nativeQueryElement['name']) ? (string) $nativeQueryElement['name'] : null,
@@ -154,7 +154,7 @@ class XmlDriver extends FileDriver
 
         // Evaluate sql result set mapping
         if (isset($xmlRoot->{'sql-result-set-mappings'})) {
-            foreach ($xmlRoot->{'sql-result-set-mappings'}->{'sql-result-set-mapping'} as $rsmElement) {
+            foreach ($xmlRoot->{'sql-result-set-mappings'}->{'sql-result-set-mapping'} ?? [] as $rsmElement) {
                 $entities = [];
                 $columns  = [];
                 foreach ($rsmElement as $entityElement) {
@@ -240,7 +240,7 @@ class XmlDriver extends FileDriver
         // Evaluate <indexes...>
         if (isset($xmlRoot->indexes)) {
             $metadata->table['indexes'] = [];
-            foreach ($xmlRoot->indexes->index as $indexXml) {
+            foreach ($xmlRoot->indexes->index ?? [] as $indexXml) {
                 $index = [];
 
                 if (isset($indexXml['columns']) && ! empty($indexXml['columns'])) {
@@ -283,7 +283,7 @@ class XmlDriver extends FileDriver
         // Evaluate <unique-constraints..>
         if (isset($xmlRoot->{'unique-constraints'})) {
             $metadata->table['uniqueConstraints'] = [];
-            foreach ($xmlRoot->{'unique-constraints'}->{'unique-constraint'} as $uniqueXml) {
+            foreach ($xmlRoot->{'unique-constraints'}->{'unique-constraint'} ?? [] as $uniqueXml) {
                 $unique = [];
 
                 if (isset($uniqueXml['columns']) && ! empty($uniqueXml['columns'])) {
@@ -370,7 +370,7 @@ class XmlDriver extends FileDriver
 
         // Evaluate <id ...> mappings
         $associationIds = [];
-        foreach ($xmlRoot->id as $idElement) {
+        foreach ($xmlRoot->id ?? [] as $idElement) {
             if (isset($idElement['association-key']) && $this->evaluateBoolean($idElement['association-key'])) {
                 $associationIds[(string) $idElement['name']] = true;
                 continue;
@@ -439,7 +439,7 @@ class XmlDriver extends FileDriver
                     if (isset($oneToOneElement->{'join-column'})) {
                         $joinColumns[] = $this->joinColumnToArray($oneToOneElement->{'join-column'});
                     } elseif (isset($oneToOneElement->{'join-columns'})) {
-                        foreach ($oneToOneElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
+                        foreach ($oneToOneElement->{'join-columns'}->{'join-column'} ?? [] as $joinColumnElement) {
                             $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
                         }
                     }
@@ -490,7 +490,7 @@ class XmlDriver extends FileDriver
 
                 if (isset($oneToManyElement->{'order-by'})) {
                     $orderBy = [];
-                    foreach ($oneToManyElement->{'order-by'}->{'order-by-field'} as $orderByField) {
+                    foreach ($oneToManyElement->{'order-by'}->{'order-by-field'} ?? [] as $orderByField) {
                         $orderBy[(string) $orderByField['name']] = isset($orderByField['direction'])
                             ? (string) $orderByField['direction']
                             : Criteria::ASC;
@@ -542,7 +542,7 @@ class XmlDriver extends FileDriver
                 if (isset($manyToOneElement->{'join-column'})) {
                     $joinColumns[] = $this->joinColumnToArray($manyToOneElement->{'join-column'});
                 } elseif (isset($manyToOneElement->{'join-columns'})) {
-                    foreach ($manyToOneElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
+                    foreach ($manyToOneElement->{'join-columns'}->{'join-column'} ?? [] as $joinColumnElement) {
                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
                     }
                 }
@@ -601,11 +601,11 @@ class XmlDriver extends FileDriver
                         $joinTable['options'] = $this->parseOptions($joinTableElement->options->children());
                     }
 
-                    foreach ($joinTableElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
+                    foreach ($joinTableElement->{'join-columns'}->{'join-column'} ?? [] as $joinColumnElement) {
                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                     }
 
-                    foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} as $joinColumnElement) {
+                    foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} ?? [] as $joinColumnElement) {
                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                     }
 
@@ -618,7 +618,7 @@ class XmlDriver extends FileDriver
 
                 if (isset($manyToManyElement->{'order-by'})) {
                     $orderBy = [];
-                    foreach ($manyToManyElement->{'order-by'}->{'order-by-field'} as $orderByField) {
+                    foreach ($manyToManyElement->{'order-by'}->{'order-by-field'} ?? [] as $orderByField) {
                         $orderBy[(string) $orderByField['name']] = isset($orderByField['direction'])
                             ? (string) $orderByField['direction']
                             : Criteria::ASC;
@@ -644,9 +644,9 @@ class XmlDriver extends FileDriver
 
         // Evaluate association-overrides
         if (isset($xmlRoot->{'attribute-overrides'})) {
-            foreach ($xmlRoot->{'attribute-overrides'}->{'attribute-override'} as $overrideElement) {
+            foreach ($xmlRoot->{'attribute-overrides'}->{'attribute-override'} ?? [] as $overrideElement) {
                 $fieldName = (string) $overrideElement['name'];
-                foreach ($overrideElement->field as $field) {
+                foreach ($overrideElement->field ?? [] as $field) {
                     $mapping              = $this->columnToArray($field);
                     $mapping['fieldName'] = $fieldName;
                     $metadata->setAttributeOverride($fieldName, $mapping);
@@ -656,14 +656,14 @@ class XmlDriver extends FileDriver
 
         // Evaluate association-overrides
         if (isset($xmlRoot->{'association-overrides'})) {
-            foreach ($xmlRoot->{'association-overrides'}->{'association-override'} as $overrideElement) {
+            foreach ($xmlRoot->{'association-overrides'}->{'association-override'} ?? [] as $overrideElement) {
                 $fieldName = (string) $overrideElement['name'];
                 $override  = [];
 
                 // Check for join-columns
                 if (isset($overrideElement->{'join-columns'})) {
                     $joinColumns = [];
-                    foreach ($overrideElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
+                    foreach ($overrideElement->{'join-columns'}->{'join-column'} ?? [] as $joinColumnElement) {
                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
                     }
 
@@ -685,13 +685,13 @@ class XmlDriver extends FileDriver
                     }
 
                     if (isset($joinTableElement->{'join-columns'})) {
-                        foreach ($joinTableElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
+                        foreach ($joinTableElement->{'join-columns'}->{'join-column'} ?? [] as $joinColumnElement) {
                             $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                         }
                     }
 
                     if (isset($joinTableElement->{'inverse-join-columns'})) {
-                        foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} as $joinColumnElement) {
+                        foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} ?? [] as $joinColumnElement) {
                             $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                         }
                     }
@@ -715,14 +715,14 @@ class XmlDriver extends FileDriver
 
         // Evaluate <lifecycle-callbacks...>
         if (isset($xmlRoot->{'lifecycle-callbacks'})) {
-            foreach ($xmlRoot->{'lifecycle-callbacks'}->{'lifecycle-callback'} as $lifecycleCallback) {
+            foreach ($xmlRoot->{'lifecycle-callbacks'}->{'lifecycle-callback'} ?? [] as $lifecycleCallback) {
                 $metadata->addLifecycleCallback((string) $lifecycleCallback['method'], constant('Doctrine\ORM\Events::' . (string) $lifecycleCallback['type']));
             }
         }
 
         // Evaluate entity listener
         if (isset($xmlRoot->{'entity-listeners'})) {
-            foreach ($xmlRoot->{'entity-listeners'}->{'entity-listener'} as $listenerElement) {
+            foreach ($xmlRoot->{'entity-listeners'}->{'entity-listener'} ?? [] as $listenerElement) {
                 $className = (string) $listenerElement['class'];
                 // Evaluate the listener using naming convention.
                 if ($listenerElement->count() === 0) {
@@ -744,16 +744,14 @@ class XmlDriver extends FileDriver
     /**
      * Parses (nested) option elements.
      *
-     * @param SimpleXMLElement $options The XML element.
-     *
      * @return mixed[] The options array.
      * @psalm-return array<int|string, array<int|string, mixed|string>|bool|string>
      */
-    private function parseOptions(SimpleXMLElement $options): array
+    private function parseOptions(?SimpleXMLElement $options): array
     {
         $array = [];
 
-        foreach ($options as $option) {
+        foreach ($options ?? [] as $option) {
             if ($option->count()) {
                 $value = $this->parseOptions($option->children());
             } else {
@@ -816,7 +814,7 @@ class XmlDriver extends FileDriver
         }
 
         if (isset($joinColumnElement['options'])) {
-            $joinColumn['options'] = $this->parseOptions($joinColumnElement['options']->children());
+            $joinColumn['options'] = $this->parseOptions($joinColumnElement['options'] ? $joinColumnElement['options']->children() : null);
         }
 
         return $joinColumn;
@@ -944,7 +942,10 @@ class XmlDriver extends FileDriver
     private function getCascadeMappings(SimpleXMLElement $cascadeElement): array
     {
         $cascades = [];
-        foreach ($cascadeElement->children() as $action) {
+        $children = $cascadeElement->children();
+        assert($children !== null);
+
+        foreach ($children as $action) {
             // According to the JPA specifications, XML uses "cascade-persist"
             // instead of "persist". Here, both variations
             // are supported because YAML, Annotation and Attribute use "persist"
@@ -969,19 +970,19 @@ class XmlDriver extends FileDriver
 
         if (isset($xmlElement->entity)) {
             foreach ($xmlElement->entity as $entityElement) {
-                /** @psalm-var class-string */
+                /** @psalm-var class-string $entityName */
                 $entityName          = (string) $entityElement['name'];
                 $result[$entityName] = $entityElement;
             }
         } elseif (isset($xmlElement->{'mapped-superclass'})) {
             foreach ($xmlElement->{'mapped-superclass'} as $mappedSuperClass) {
-                /** @psalm-var class-string */
+                /** @psalm-var class-string $className */
                 $className          = (string) $mappedSuperClass['name'];
                 $result[$className] = $mappedSuperClass;
             }
         } elseif (isset($xmlElement->embeddable)) {
             foreach ($xmlElement->embeddable as $embeddableElement) {
-                /** @psalm-var class-string */
+                /** @psalm-var class-string $embeddableName */
                 $embeddableName          = (string) $embeddableElement['name'];
                 $result[$embeddableName] = $embeddableElement;
             }

lib/Doctrine/ORM/Mapping/NamedNativeQueries.php

@@ -8,6 +8,8 @@ namespace Doctrine\ORM\Mapping;
  * Is used to specify an array of native SQL named queries.
  * The NamedNativeQueries annotation can be applied to an entity or mapped superclass.
  *
+ * @deprecated Named queries won't be supported in ORM 3.
+ *
  * @Annotation
  * @Target("CLASS")
  */

lib/Doctrine/ORM/Mapping/NamedNativeQuery.php

@@ -8,6 +8,8 @@ namespace Doctrine\ORM\Mapping;
  * Is used to specify a native SQL named query.
  * The NamedNativeQuery annotation can be applied to an entity or mapped superclass.
  *
+ * @deprecated Named queries won't be supported in ORM 3.
+ *
  * @Annotation
  * @Target("ANNOTATION")
  */

lib/Doctrine/ORM/Mapping/NamedQueries.php

@@ -5,6 +5,8 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Mapping;
 
 /**
+ * @deprecated Named queries won't be supported in ORM 3.
+ *
  * @Annotation
  * @Target("CLASS")
  */

lib/Doctrine/ORM/Mapping/NamedQuery.php

@@ -5,6 +5,8 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Mapping;
 
 /**
+ * @deprecated Named queries won't be supported in ORM 3.
+ *
  * @Annotation
  * @Target("ANNOTATION")
  */

lib/Doctrine/ORM/Mapping/UnderscoreNamingStrategy.php

@@ -30,7 +30,10 @@ class UnderscoreNamingStrategy implements NamingStrategy
     /** @var int */
     private $case;
 
-    /** @var string */
+    /**
+     * @var string
+     * @psalm-var non-empty-string
+     */
     private $pattern;
 
     /**

lib/Doctrine/ORM/NativeQuery.php

@@ -11,8 +11,10 @@ use function ksort;
 
 /**
  * Represents a native SQL query.
+ *
+ * @final
  */
-final class NativeQuery extends AbstractQuery
+class NativeQuery extends AbstractQuery
 {
     /** @var string */
     private $sql;

lib/Doctrine/ORM/ORMInvalidArgumentException.php

@@ -15,6 +15,7 @@ use function func_num_args;
 use function get_debug_type;
 use function gettype;
 use function implode;
+use function is_scalar;
 use function method_exists;
 use function reset;
 use function spl_object_id;
@@ -261,6 +262,32 @@ EXCEPTION
         return new self(sprintf('Entity name must be a string, %s given', get_debug_type($entityName)));
     }
 
+    /** @param mixed $value */
+    public static function invalidAutoGenerateMode($value): self
+    {
+        return new self(sprintf('Invalid auto generate mode "%s" given.', is_scalar($value) ? (string) $value : get_debug_type($value)));
+    }
+
+    public static function missingPrimaryKeyValue(string $className, string $idField): self
+    {
+        return new self(sprintf('Missing value for primary key %s on %s', $idField, $className));
+    }
+
+    public static function proxyDirectoryRequired(): self
+    {
+        return new self('You must configure a proxy directory. See docs for details');
+    }
+
+    public static function proxyNamespaceRequired(): self
+    {
+        return new self('You must configure a proxy namespace');
+    }
+
+    public static function proxyDirectoryNotWritable(string $proxyDirectory): self
+    {
+        return new self(sprintf('Your proxy directory "%s" must be writable', $proxyDirectory));
+    }
+
     /**
      * Helper method to show an object as string.
      *

lib/Doctrine/ORM/ORMSetup.php

@@ -101,10 +101,11 @@ final class ORMSetup
         array $paths,
         bool $isDevMode = false,
         ?string $proxyDir = null,
-        ?CacheItemPoolInterface $cache = null
+        ?CacheItemPoolInterface $cache = null,
+        bool $reportFieldsWhereDeclared = false
     ): Configuration {
         $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
-        $config->setMetadataDriverImpl(new AttributeDriver($paths));
+        $config->setMetadataDriverImpl(new AttributeDriver($paths, $reportFieldsWhereDeclared));
 
         return $config;
     }

lib/Doctrine/ORM/Persisters/Entity/BasicEntityPersister.php

@@ -7,7 +7,6 @@ namespace Doctrine\ORM\Persisters\Entity;
 use BackedEnum;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\Common\Collections\Expr\Comparison;
-use Doctrine\Common\Util\ClassUtils;
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\LockMode;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
@@ -26,6 +25,7 @@ use Doctrine\ORM\Persisters\Exception\InvalidOrientation;
 use Doctrine\ORM\Persisters\Exception\UnrecognizedField;
 use Doctrine\ORM\Persisters\SqlExpressionVisitor;
 use Doctrine\ORM\Persisters\SqlValueVisitor;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 use Doctrine\ORM\Query;
 use Doctrine\ORM\Query\QueryException;
 use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
@@ -1264,7 +1264,7 @@ class BasicEntityPersister implements EntityPersister
             }
 
             $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
-            $isAssocFromOneEager     = $assoc['type'] !== ClassMetadata::MANY_TO_MANY && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
+            $isAssocFromOneEager     = $assoc['type'] & ClassMetadata::TO_ONE && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
 
             if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
                 continue;
@@ -2028,7 +2028,7 @@ class BasicEntityPersister implements EntityPersister
             return [$value->value];
         }
 
-        $valueClass = ClassUtils::getClass($value);
+        $valueClass = DefaultProxyClassNameResolver::getClass($value);
 
         if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
             return [$value];

lib/Doctrine/ORM/Proxy/Autoloader.php

@@ -6,7 +6,6 @@ namespace Doctrine\ORM\Proxy;
 
 use Doctrine\Common\Proxy\Autoloader as BaseAutoloader;
 
-/** @deprecated use \Doctrine\Common\Proxy\Autoloader instead */
 class Autoloader extends BaseAutoloader
 {
 }

lib/Doctrine/ORM/Proxy/DefaultProxyClassNameResolver.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Proxy;
+
+use Doctrine\Persistence\Mapping\ProxyClassNameResolver;
+use Doctrine\Persistence\Proxy;
+
+use function get_class;
+use function strrpos;
+use function substr;
+
+/**
+ * Class-related functionality for objects that might or not be proxy objects
+ * at the moment.
+ */
+final class DefaultProxyClassNameResolver implements ProxyClassNameResolver
+{
+    public function resolveClassName(string $className): string
+    {
+        $pos = strrpos($className, '\\' . Proxy::MARKER . '\\');
+
+        if ($pos === false) {
+            return $className;
+        }
+
+        return substr($className, $pos + Proxy::MARKER_LENGTH + 2);
+    }
+
+    /**
+     * @param object $object
+     *
+     * @return class-string
+     */
+    public static function getClass($object): string
+    {
+        return (new self())->resolveClassName(get_class($object));
+    }
+}

lib/Doctrine/ORM/Proxy/ProxyFactory.php

@@ -9,30 +9,94 @@ use Doctrine\Common\Proxy\AbstractProxyFactory;
 use Doctrine\Common\Proxy\Proxy as CommonProxy;
 use Doctrine\Common\Proxy\ProxyDefinition;
 use Doctrine\Common\Proxy\ProxyGenerator;
-use Doctrine\Common\Util\ClassUtils;
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\EntityNotFoundException;
+use Doctrine\ORM\ORMInvalidArgumentException;
 use Doctrine\ORM\Persisters\Entity\EntityPersister;
 use Doctrine\ORM\Proxy\Proxy as LegacyProxy;
 use Doctrine\ORM\UnitOfWork;
 use Doctrine\ORM\Utility\IdentifierFlattener;
 use Doctrine\Persistence\Mapping\ClassMetadata;
+use Doctrine\Persistence\Proxy;
 use ReflectionProperty;
 use Symfony\Component\VarExporter\ProxyHelper;
-use Symfony\Component\VarExporter\VarExporter;
 use Throwable;
 
+use function array_combine;
 use function array_flip;
+use function array_intersect_key;
+use function bin2hex;
+use function chmod;
+use function class_exists;
+use function dirname;
+use function file_exists;
+use function file_put_contents;
+use function filemtime;
+use function is_bool;
+use function is_dir;
+use function is_int;
+use function is_writable;
+use function ltrim;
+use function mkdir;
+use function preg_match_all;
+use function random_bytes;
+use function rename;
+use function rtrim;
 use function str_replace;
 use function strpos;
+use function strrpos;
+use function strtr;
 use function substr;
-use function uksort;
+use function ucfirst;
+
+use const DIRECTORY_SEPARATOR;
+use const PHP_VERSION_ID;
 
 /**
  * This factory is used to create proxy objects for entities at runtime.
  */
 class ProxyFactory extends AbstractProxyFactory
 {
+    /**
+     * Never autogenerate a proxy and rely that it was generated by some
+     * process before deployment.
+     */
+    public const AUTOGENERATE_NEVER = 0;
+
+    /**
+     * Always generates a new proxy in every request.
+     *
+     * This is only sane during development.
+     */
+    public const AUTOGENERATE_ALWAYS = 1;
+
+    /**
+     * Autogenerate the proxy class when the proxy file does not exist.
+     *
+     * This strategy causes a file_exists() call whenever any proxy is used the
+     * first time in a request.
+     */
+    public const AUTOGENERATE_FILE_NOT_EXISTS = 2;
+
+    /**
+     * Generate the proxy classes using eval().
+     *
+     * This strategy is only sane for development, and even then it gives me
+     * the creeps a little.
+     */
+    public const AUTOGENERATE_EVAL = 3;
+
+    /**
+     * Autogenerate the proxy class when the proxy file does not exist or
+     * when the proxied file changed.
+     *
+     * This strategy causes a file_exists() call whenever any proxy is used the
+     * first time in a request. When the proxied file is changed, the proxy will
+     * be updated.
+     */
+    public const AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED = 4;
+
     private const PROXY_CLASS_TEMPLATE = <<<'EOPHP'
 <?php
 
@@ -45,15 +109,6 @@ class <proxyShortClassName> extends \<className> implements \<baseProxyInterface
 {
     <useLazyGhostTrait>
 
-    public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null)
-    {
-        if ($cloner !== null) {
-            return;
-        }
-
-        self::createLazyGhost($initializer, <skippedProperties>, $this);
-    }
-
     public function __isInitialized(): bool
     {
         return isset($this->lazyObjectState) && $this->isLazyObjectInitialized();
@@ -73,9 +128,15 @@ EOPHP;
     /** @var UnitOfWork The UnitOfWork this factory uses to retrieve persisters */
     private $uow;
 
+    /** @var string */
+    private $proxyDir;
+
     /** @var string */
     private $proxyNs;
 
+    /** @var self::AUTOGENERATE_* */
+    private $autoGenerate;
+
     /**
      * The IdentifierFlattener used for manipulating identifiers
      *
@@ -83,8 +144,11 @@ EOPHP;
      */
     private $identifierFlattener;
 
-    /** @var ProxyDefinition[] */
-    private $definitions = [];
+    /** @var array<class-string, Closure> */
+    private $proxyFactories = [];
+
+    /** @var bool */
+    private $isLazyGhostObjectEnabled = true;
 
     /**
      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
@@ -97,23 +161,40 @@ EOPHP;
      */
     public function __construct(EntityManagerInterface $em, $proxyDir, $proxyNs, $autoGenerate = self::AUTOGENERATE_NEVER)
     {
-        $proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs);
+        if (! $em->getConfiguration()->isLazyGhostObjectEnabled()) {
+            if (PHP_VERSION_ID >= 80100) {
+                Deprecation::trigger(
+                    'doctrine/orm',
+                    'https://github.com/doctrine/orm/pull/10837/',
+                    'Not enabling lazy ghost objects is deprecated and will not be supported in Doctrine ORM 3.0. Ensure Doctrine\ORM\Configuration::setLazyGhostObjectEnabled(true) is called to enable them.'
+                );
+            }
 
-        if ($em->getConfiguration()->isLazyGhostObjectEnabled()) {
-            $proxyGenerator->setPlaceholder('baseProxyInterface', InternalProxy::class);
-            $proxyGenerator->setPlaceholder('useLazyGhostTrait', Closure::fromCallable([$this, 'generateUseLazyGhostTrait']));
-            $proxyGenerator->setPlaceholder('skippedProperties', Closure::fromCallable([$this, 'generateSkippedProperties']));
-            $proxyGenerator->setPlaceholder('serializeImpl', Closure::fromCallable([$this, 'generateSerializeImpl']));
-            $proxyGenerator->setProxyClassTemplate(self::PROXY_CLASS_TEMPLATE);
-        } else {
+            $this->isLazyGhostObjectEnabled = false;
+
+            $proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs);
             $proxyGenerator->setPlaceholder('baseProxyInterface', LegacyProxy::class);
+
+            parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate);
         }
 
-        parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate);
+        if (! $proxyDir) {
+            throw ORMInvalidArgumentException::proxyDirectoryRequired();
+        }
+
+        if (! $proxyNs) {
+            throw ORMInvalidArgumentException::proxyNamespaceRequired();
+        }
+
+        if (is_int($autoGenerate) ? $autoGenerate < 0 || $autoGenerate > 4 : ! is_bool($autoGenerate)) {
+            throw ORMInvalidArgumentException::invalidAutoGenerateMode($autoGenerate);
+        }
 
         $this->em                  = $em;
         $this->uow                 = $em->getUnitOfWork();
+        $this->proxyDir            = $proxyDir;
         $this->proxyNs             = $proxyNs;
+        $this->autoGenerate        = (int) $autoGenerate;
         $this->identifierFlattener = new IdentifierFlattener($this->uow, $em->getMetadataFactory());
     }
 
@@ -122,19 +203,57 @@ EOPHP;
      */
     public function getProxy($className, array $identifier)
     {
-        $proxy = parent::getProxy($className, $identifier);
-
-        if (! $this->em->getConfiguration()->isLazyGhostObjectEnabled()) {
-            return $proxy;
+        if (! $this->isLazyGhostObjectEnabled) {
+            return parent::getProxy($className, $identifier);
         }
 
-        $initializer = $this->definitions[$className]->initializer;
+        $proxyFactory = $this->proxyFactories[$className] ?? $this->getProxyFactory($className);
 
-        $proxy->__construct(static function (InternalProxy $object) use ($initializer, $proxy): void {
-            $initializer($object, $proxy);
-        });
+        return $proxyFactory($identifier);
+    }
 
-        return $proxy;
+    /**
+     * Generates proxy classes for all given classes.
+     *
+     * @param ClassMetadata[] $classes  The classes (ClassMetadata instances) for which to generate proxies.
+     * @param string|null     $proxyDir The target directory of the proxy classes. If not specified, the
+     *                                  directory configured on the Configuration of the EntityManager used
+     *                                  by this factory is used.
+     *
+     * @return int Number of generated proxies.
+     */
+    public function generateProxyClasses(array $classes, $proxyDir = null)
+    {
+        if (! $this->isLazyGhostObjectEnabled) {
+            return parent::generateProxyClasses($classes, $proxyDir);
+        }
+
+        $generated = 0;
+
+        foreach ($classes as $class) {
+            if ($this->skipClass($class)) {
+                continue;
+            }
+
+            $proxyFileName  = $this->getProxyFileName($class->getName(), $proxyDir ?: $this->proxyDir);
+            $proxyClassName = self::generateProxyClassName($class->getName(), $this->proxyNs);
+
+            $this->generateProxyClass($class, $proxyFileName, $proxyClassName);
+
+            ++$generated;
+        }
+
+        return $generated;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated ProxyFactory::resetUninitializedProxy() is deprecated and will be removed in version 3.0 of doctrine/orm.
+     */
+    public function resetUninitializedProxy(CommonProxy $proxy)
+    {
+        return parent::resetUninitializedProxy($proxy);
     }
 
     /**
@@ -149,23 +268,19 @@ EOPHP;
 
     /**
      * {@inheritDoc}
+     *
+     * @deprecated ProxyFactory::createProxyDefinition() is deprecated and will be removed in version 3.0 of doctrine/orm.
      */
     protected function createProxyDefinition($className)
     {
         $classMetadata   = $this->em->getClassMetadata($className);
         $entityPersister = $this->uow->getEntityPersister($className);
 
-        if ($this->em->getConfiguration()->isLazyGhostObjectEnabled()) {
-            $initializer = $this->createLazyInitializer($classMetadata, $entityPersister);
-            $cloner      = static function (): void {
-            };
-        } else {
-            $initializer = $this->createInitializer($classMetadata, $entityPersister);
-            $cloner      = $this->createCloner($classMetadata, $entityPersister);
-        }
+        $initializer = $this->createInitializer($classMetadata, $entityPersister);
+        $cloner      = $this->createCloner($classMetadata, $entityPersister);
 
-        return $this->definitions[$className] = new ProxyDefinition(
-            ClassUtils::generateProxyClassName($className, $this->proxyNs),
+        return new ProxyDefinition(
+            self::generateProxyClassName($className, $this->proxyNs),
             $classMetadata->getIdentifierFieldNames(),
             $classMetadata->getReflectionProperties(),
             $initializer,
@@ -176,6 +291,8 @@ EOPHP;
     /**
      * Creates a closure capable of initializing a proxy
      *
+     * @deprecated ProxyFactory::createInitializer() is deprecated and will be removed in version 3.0 of doctrine/orm.
+     *
      * @psalm-return Closure(CommonProxy):void
      *
      * @throws EntityNotFoundException
@@ -241,16 +358,16 @@ EOPHP;
      *
      * @throws EntityNotFoundException
      */
-    private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
+    private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister, IdentifierFlattener $identifierFlattener): Closure
     {
-        return function (InternalProxy $proxy, InternalProxy $original) use ($entityPersister, $classMetadata): void {
+        return static function (InternalProxy $proxy, InternalProxy $original) use ($entityPersister, $classMetadata, $identifierFlattener): void {
             $identifier = $classMetadata->getIdentifierValues($original);
             $entity     = $entityPersister->loadById($identifier, $original);
 
             if ($entity === null) {
                 throw EntityNotFoundException::fromClassNameAndIdentifier(
                     $classMetadata->getName(),
-                    $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
+                    $identifierFlattener->flattenIdentifier($classMetadata, $identifier)
                 );
             }
 
@@ -265,7 +382,6 @@ EOPHP;
                     continue;
                 }
 
-                $property->setAccessible(true);
                 $property->setValue($proxy, $property->getValue($entity));
             }
         };
@@ -274,6 +390,8 @@ EOPHP;
     /**
      * Creates a closure capable of finalizing state a cloned proxy
      *
+     * @deprecated ProxyFactory::createCloner() is deprecated and will be removed in version 3.0 of doctrine/orm.
+     *
      * @psalm-return Closure(CommonProxy):void
      *
      * @throws EntityNotFoundException
@@ -310,25 +428,18 @@ EOPHP;
         };
     }
 
-    private function generateUseLazyGhostTrait(ClassMetadata $class): string
+    private function getProxyFileName(string $className, string $baseDirectory): string
     {
-        $code = ProxyHelper::generateLazyGhost($class->getReflectionClass());
-        $code = substr($code, 7 + (int) strpos($code, "\n{"));
-        $code = substr($code, 0, (int) strpos($code, "\n}"));
-        $code = str_replace('LazyGhostTrait;', str_replace("\n    ", "\n", 'LazyGhostTrait {
-            initializeLazyObject as __load;
-            setLazyObjectAsInitialized as public __setInitialized;
-            isLazyObjectInitialized as private;
-            createLazyGhost as private;
-            resetLazyObject as private;
-        }'), $code);
+        $baseDirectory = $baseDirectory ?: $this->proxyDir;
 
-        return $code;
+        return rtrim($baseDirectory, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . InternalProxy::MARKER
+            . str_replace('\\', '', $className) . '.php';
     }
 
-    private function generateSkippedProperties(ClassMetadata $class): string
+    private function getProxyFactory(string $className): Closure
     {
         $skippedProperties = [];
+        $class             = $this->em->getClassMetadata($className);
         $identifiers       = array_flip($class->getIdentifierFieldNames());
         $filter            = ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED | ReflectionProperty::IS_PRIVATE;
         $reflector         = $class->getReflectionClass();
@@ -350,11 +461,123 @@ EOPHP;
             $reflector = $reflector->getParentClass();
         }
 
-        uksort($skippedProperties, 'strnatcmp');
+        $className        = $class->getName(); // aliases and case sensitivity
+        $entityPersister  = $this->uow->getEntityPersister($className);
+        $initializer      = $this->createLazyInitializer($class, $entityPersister, $this->identifierFlattener);
+        $proxyClassName   = $this->loadProxyClass($class);
+        $identifierFields = array_intersect_key($class->getReflectionProperties(), $identifiers);
 
-        $code = VarExporter::export($skippedProperties);
-        $code = str_replace(VarExporter::export($class->getName()), 'parent::class', $code);
-        $code = str_replace("\n", "\n        ", $code);
+        $proxyFactory = Closure::bind(static function (array $identifier) use ($initializer, $skippedProperties, $identifierFields, $className): InternalProxy {
+            $proxy = self::createLazyGhost(static function (InternalProxy $object) use ($initializer, &$proxy): void {
+                $initializer($object, $proxy);
+            }, $skippedProperties);
+
+            foreach ($identifierFields as $idField => $reflector) {
+                if (! isset($identifier[$idField])) {
+                    throw ORMInvalidArgumentException::missingPrimaryKeyValue($className, $idField);
+                }
+
+                $reflector->setValue($proxy, $identifier[$idField]);
+            }
+
+            return $proxy;
+        }, null, $proxyClassName);
+
+        return $this->proxyFactories[$className] = $proxyFactory;
+    }
+
+    private function loadProxyClass(ClassMetadata $class): string
+    {
+        $proxyClassName = self::generateProxyClassName($class->getName(), $this->proxyNs);
+
+        if (class_exists($proxyClassName, false)) {
+            return $proxyClassName;
+        }
+
+        if ($this->autoGenerate === self::AUTOGENERATE_EVAL) {
+            $this->generateProxyClass($class, null, $proxyClassName);
+
+            return $proxyClassName;
+        }
+
+        $fileName = $this->getProxyFileName($class->getName(), $this->proxyDir);
+
+        switch ($this->autoGenerate) {
+            case self::AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED:
+                if (file_exists($fileName) && filemtime($fileName) >= filemtime($class->getReflectionClass()->getFileName())) {
+                    break;
+                }
+                // no break
+            case self::AUTOGENERATE_FILE_NOT_EXISTS:
+                if (file_exists($fileName)) {
+                    break;
+                }
+                // no break
+            case self::AUTOGENERATE_ALWAYS:
+                $this->generateProxyClass($class, $fileName, $proxyClassName);
+                break;
+        }
+
+        require $fileName;
+
+        return $proxyClassName;
+    }
+
+    private function generateProxyClass(ClassMetadata $class, ?string $fileName, string $proxyClassName): void
+    {
+        $i            = strrpos($proxyClassName, '\\');
+        $placeholders = [
+            '<className>' => $class->getName(),
+            '<namespace>' => substr($proxyClassName, 0, $i),
+            '<proxyShortClassName>' => substr($proxyClassName, 1 + $i),
+            '<baseProxyInterface>' => InternalProxy::class,
+        ];
+
+        preg_match_all('(<([a-zA-Z]+)>)', self::PROXY_CLASS_TEMPLATE, $placeholderMatches);
+
+        foreach (array_combine($placeholderMatches[0], $placeholderMatches[1]) as $placeholder => $name) {
+            $placeholders[$placeholder] ?? $placeholders[$placeholder] = $this->{'generate' . ucfirst($name)}($class);
+        }
+
+        $proxyCode = strtr(self::PROXY_CLASS_TEMPLATE, $placeholders);
+
+        if (! $fileName) {
+            if (! class_exists($proxyClassName)) {
+                eval(substr($proxyCode, 5));
+            }
+
+            return;
+        }
+
+        $parentDirectory = dirname($fileName);
+
+        if (! is_dir($parentDirectory) && ! @mkdir($parentDirectory, 0775, true)) {
+            throw ORMInvalidArgumentException::proxyDirectoryNotWritable($this->proxyDir);
+        }
+
+        if (! is_writable($parentDirectory)) {
+            throw ORMInvalidArgumentException::proxyDirectoryNotWritable($this->proxyDir);
+        }
+
+        $tmpFileName = $fileName . '.' . bin2hex(random_bytes(12));
+
+        file_put_contents($tmpFileName, $proxyCode);
+        @chmod($tmpFileName, 0664);
+        rename($tmpFileName, $fileName);
+    }
+
+    private function generateUseLazyGhostTrait(ClassMetadata $class): string
+    {
+        $code = ProxyHelper::generateLazyGhost($class->getReflectionClass());
+        $code = substr($code, 7 + (int) strpos($code, "\n{"));
+        $code = substr($code, 0, (int) strpos($code, "\n}"));
+        $code = str_replace('LazyGhostTrait;', str_replace("\n    ", "\n", 'LazyGhostTrait {
+            initializeLazyObject as __load;
+            setLazyObjectAsInitialized as public __setInitialized;
+            isLazyObjectInitialized as private;
+            createLazyGhost as private;
+            resetLazyObject as private;
+        }'), $code);
 
         return $code;
     }
@@ -365,7 +588,7 @@ EOPHP;
         $properties = $reflector->hasMethod('__serialize') ? 'parent::__serialize()' : '(array) $this';
 
         $code = '$properties = ' . $properties . ';
-        unset($properties["\0" . self::class . "\0lazyObjectState"], $properties[\'__isCloning\']);
+        unset($properties["\0" . self::class . "\0lazyObjectState"]);
 
         ';
 
@@ -387,4 +610,9 @@ EOPHP;
 
         return $data;';
     }
+
+    private static function generateProxyClassName(string $className, string $proxyNamespace): string
+    {
+        return rtrim($proxyNamespace, '\\') . '\\' . Proxy::MARKER . '\\' . ltrim($className, '\\');
+    }
 }

lib/Doctrine/ORM/Query.php

@@ -44,8 +44,10 @@ use function stripos;
 
 /**
  * A Query object represents a DQL query.
+ *
+ * @final
  */
-final class Query extends AbstractQuery
+class Query extends AbstractQuery
 {
     /**
      * A query object is in CLEAN state when it has NO unparsed/unprocessed DQL parts.

lib/Doctrine/ORM/Query/AST/ConditionalFactor.php

@@ -9,7 +9,7 @@ namespace Doctrine\ORM\Query\AST;
  *
  * @link    www.doctrine-project.org
  */
-class ConditionalFactor extends Node
+class ConditionalFactor extends Node implements Phase2OptimizableConditional
 {
     /** @var bool */
     public $not = false;

lib/Doctrine/ORM/Query/AST/ConditionalPrimary.php

@@ -9,12 +9,12 @@ namespace Doctrine\ORM\Query\AST;
  *
  * @link    www.doctrine-project.org
  */
-class ConditionalPrimary extends Node
+class ConditionalPrimary extends Node implements Phase2OptimizableConditional
 {
     /** @var Node|null */
     public $simpleConditionalExpression;
 
-    /** @var ConditionalExpression|null */
+    /** @var ConditionalExpression|Phase2OptimizableConditional|null */
     public $conditionalExpression;
 
     /** @return bool */

lib/Doctrine/ORM/Query/AST/ConditionalTerm.php

@@ -9,7 +9,7 @@ namespace Doctrine\ORM\Query\AST;
  *
  * @link    www.doctrine-project.org
  */
-class ConditionalTerm extends Node
+class ConditionalTerm extends Node implements Phase2OptimizableConditional
 {
     /** @var mixed[] */
     public $conditionalFactors = [];

lib/Doctrine/ORM/Query/AST/HavingClause.php

@@ -6,10 +6,10 @@ namespace Doctrine\ORM\Query\AST;
 
 class HavingClause extends Node
 {
-    /** @var ConditionalExpression */
+    /** @var ConditionalExpression|Phase2OptimizableConditional */
     public $conditionalExpression;
 
-    /** @param ConditionalExpression $conditionalExpression */
+    /** @param ConditionalExpression|Phase2OptimizableConditional $conditionalExpression */
     public function __construct($conditionalExpression)
     {
         $this->conditionalExpression = $conditionalExpression;

lib/Doctrine/ORM/Query/AST/Join.php

@@ -25,7 +25,7 @@ class Join extends Node
     /** @var Node|null */
     public $joinAssociationDeclaration = null;
 
-    /** @var ConditionalExpression|null */
+    /** @var ConditionalExpression|Phase2OptimizableConditional|null */
     public $conditionalExpression = null;
 
     /**

lib/Doctrine/ORM/Query/AST/Phase2OptimizableConditional.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query\AST;
+
+/**
+ * Marks types that can be used in place of a ConditionalExpression as a phase
+ * 2 optimization.
+ *
+ * @internal
+ *
+ * @psalm-inheritors ConditionalPrimary|ConditionalFactor|ConditionalTerm
+ */
+interface Phase2OptimizableConditional
+{
+}

lib/Doctrine/ORM/Query/AST/WhenClause.php

@@ -11,15 +11,15 @@ namespace Doctrine\ORM\Query\AST;
  */
 class WhenClause extends Node
 {
-    /** @var ConditionalExpression */
+    /** @var ConditionalExpression|Phase2OptimizableConditional */
     public $caseConditionExpression;
 
     /** @var mixed */
     public $thenScalarExpression = null;
 
     /**
-     * @param ConditionalExpression $caseConditionExpression
-     * @param mixed                 $thenScalarExpression
+     * @param ConditionalExpression|Phase2OptimizableConditional $caseConditionExpression
+     * @param mixed                                              $thenScalarExpression
      */
     public function __construct($caseConditionExpression, $thenScalarExpression)
     {

lib/Doctrine/ORM/Query/AST/WhereClause.php

@@ -11,10 +11,10 @@ namespace Doctrine\ORM\Query\AST;
  */
 class WhereClause extends Node
 {
-    /** @var ConditionalExpression|ConditionalTerm */
+    /** @var ConditionalExpression|Phase2OptimizableConditional */
     public $conditionalExpression;
 
-    /** @param ConditionalExpression $conditionalExpression */
+    /** @param ConditionalExpression|Phase2OptimizableConditional $conditionalExpression */
     public function __construct($conditionalExpression)
     {
         $this->conditionalExpression = $conditionalExpression;

lib/Doctrine/ORM/Query/Exec/AbstractSqlExecutor.php

@@ -9,6 +9,12 @@ use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\Result;
 use Doctrine\DBAL\Types\Type;
 
+use function array_diff;
+use function array_keys;
+use function array_map;
+use function array_values;
+use function str_replace;
+
 /**
  * Base class for SQL statement executors.
  *
@@ -18,12 +24,24 @@ use Doctrine\DBAL\Types\Type;
  */
 abstract class AbstractSqlExecutor
 {
-    /** @var list<string>|string */
+    /**
+     * @deprecated use $sqlStatements instead
+     *
+     * @var list<string>|string
+     */
     protected $_sqlStatements;
 
+    /** @var list<string>|string */
+    protected $sqlStatements;
+
     /** @var QueryCacheProfile */
     protected $queryCacheProfile;
 
+    public function __construct()
+    {
+        $this->_sqlStatements = &$this->sqlStatements;
+    }
+
     /**
      * Gets the SQL statements that are executed by the executor.
      *
@@ -31,21 +49,18 @@ abstract class AbstractSqlExecutor
      */
     public function getSqlStatements()
     {
-        return $this->_sqlStatements;
+        return $this->sqlStatements;
     }
 
-    /** @return void */
-    public function setQueryCacheProfile(QueryCacheProfile $qcp)
+    public function setQueryCacheProfile(QueryCacheProfile $qcp): void
     {
         $this->queryCacheProfile = $qcp;
     }
 
     /**
      * Do not use query cache
-     *
-     * @return void
      */
-    public function removeQueryCacheProfile()
+    public function removeQueryCacheProfile(): void
     {
         $this->queryCacheProfile = null;
     }
@@ -60,4 +75,28 @@ abstract class AbstractSqlExecutor
      * @return Result|int
      */
     abstract public function execute(Connection $conn, array $params, array $types);
+
+    /** @return list<string> */
+    public function __sleep(): array
+    {
+        /* Two reasons for this:
+           - we do not need to serialize the deprecated property, we can
+             rebuild the reference to the new property in __wakeup()
+           - not having the legacy property in the serialized data means the
+             serialized representation becomes compatible with 3.0.x, meaning
+             there will not be a deprecation warning about a missing property
+             when unserializing data */
+        return array_values(array_diff(array_map(static function (string $prop): string {
+            return str_replace("\0*\0", '', $prop);
+        }, array_keys((array) $this)), ['_sqlStatements']));
+    }
+
+    public function __wakeup(): void
+    {
+        if ($this->_sqlStatements !== null && $this->sqlStatements === null) {
+            $this->sqlStatements = $this->_sqlStatements;
+        }
+
+        $this->_sqlStatements = &$this->sqlStatements;
+    }
 }

lib/Doctrine/ORM/Query/Exec/MultiTableDeleteExecutor.php

@@ -45,6 +45,8 @@ class MultiTableDeleteExecutor extends AbstractSqlExecutor
      */
     public function __construct(AST\Node $AST, $sqlWalker)
     {
+        parent::__construct();
+
         $em            = $sqlWalker->getEntityManager();
         $conn          = $em->getConnection();
         $platform      = $conn->getDatabasePlatform();
@@ -83,8 +85,8 @@ class MultiTableDeleteExecutor extends AbstractSqlExecutor
         // 3. Create and store DELETE statements
         $classNames = array_merge($primaryClass->parentClasses, [$primaryClass->name], $primaryClass->subClasses);
         foreach (array_reverse($classNames) as $className) {
-            $tableName              = $quoteStrategy->getTableName($em->getClassMetadata($className), $platform);
-            $this->_sqlStatements[] = 'DELETE FROM ' . $tableName
+            $tableName             = $quoteStrategy->getTableName($em->getClassMetadata($className), $platform);
+            $this->sqlStatements[] = 'DELETE FROM ' . $tableName
                     . ' WHERE (' . $idColumnList . ') IN (' . $idSubselect . ')';
         }
 
@@ -117,7 +119,7 @@ class MultiTableDeleteExecutor extends AbstractSqlExecutor
             $numDeleted = $conn->executeStatement($this->insertSql, $params, $types);
 
             // Execute DELETE statements
-            foreach ($this->_sqlStatements as $sql) {
+            foreach ($this->sqlStatements as $sql) {
                 $conn->executeStatement($sql);
             }
         } catch (Throwable $exception) {

lib/Doctrine/ORM/Query/Exec/MultiTableUpdateExecutor.php

@@ -50,6 +50,8 @@ class MultiTableUpdateExecutor extends AbstractSqlExecutor
      */
     public function __construct(AST\Node $AST, $sqlWalker)
     {
+        parent::__construct();
+
         $em            = $sqlWalker->getEntityManager();
         $conn          = $em->getConnection();
         $platform      = $conn->getDatabasePlatform();
@@ -119,7 +121,7 @@ class MultiTableUpdateExecutor extends AbstractSqlExecutor
             }
 
             if ($affected) {
-                $this->_sqlStatements[$i] = $updateSql . ' WHERE (' . $idColumnList . ') IN (' . $idSubselect . ')';
+                $this->sqlStatements[$i] = $updateSql . ' WHERE (' . $idColumnList . ') IN (' . $idSubselect . ')';
             }
         }
 
@@ -163,7 +165,7 @@ class MultiTableUpdateExecutor extends AbstractSqlExecutor
             );
 
             // Execute UPDATE statements
-            foreach ($this->_sqlStatements as $key => $statement) {
+            foreach ($this->sqlStatements as $key => $statement) {
                 $paramValues = [];
                 $paramTypes  = [];
 

lib/Doctrine/ORM/Query/Exec/SingleSelectExecutor.php

@@ -18,7 +18,9 @@ class SingleSelectExecutor extends AbstractSqlExecutor
 {
     public function __construct(SelectStatement $AST, SqlWalker $sqlWalker)
     {
-        $this->_sqlStatements = $sqlWalker->walkSelectStatement($AST);
+        parent::__construct();
+
+        $this->sqlStatements = $sqlWalker->walkSelectStatement($AST);
     }
 
     /**
@@ -28,6 +30,6 @@ class SingleSelectExecutor extends AbstractSqlExecutor
      */
     public function execute(Connection $conn, array $params, array $types)
     {
-        return $conn->executeQuery($this->_sqlStatements, $params, $types, $this->queryCacheProfile);
+        return $conn->executeQuery($this->sqlStatements, $params, $types, $this->queryCacheProfile);
     }
 }

lib/Doctrine/ORM/Query/Exec/SingleTableDeleteUpdateExecutor.php

@@ -22,10 +22,12 @@ class SingleTableDeleteUpdateExecutor extends AbstractSqlExecutor
     /** @param SqlWalker $sqlWalker */
     public function __construct(AST\Node $AST, $sqlWalker)
     {
+        parent::__construct();
+
         if ($AST instanceof AST\UpdateStatement) {
-            $this->_sqlStatements = $sqlWalker->walkUpdateStatement($AST);
+            $this->sqlStatements = $sqlWalker->walkUpdateStatement($AST);
         } elseif ($AST instanceof AST\DeleteStatement) {
-            $this->_sqlStatements = $sqlWalker->walkDeleteStatement($AST);
+            $this->sqlStatements = $sqlWalker->walkDeleteStatement($AST);
         }
     }
 
@@ -40,6 +42,6 @@ class SingleTableDeleteUpdateExecutor extends AbstractSqlExecutor
             $conn->ensureConnectedToPrimary();
         }
 
-        return $conn->executeStatement($this->_sqlStatements, $params, $types);
+        return $conn->executeStatement($this->sqlStatements, $params, $types);
     }
 }

lib/Doctrine/ORM/Query/ParserResult.php

@@ -141,7 +141,9 @@ class ParserResult
     {
         foreach (self::LEGACY_PROPERTY_MAPPING as $property => $legacyProperty) {
             $this->$property = $data[sprintf("\0%s\0%s", self::class, $legacyProperty)]
+                ?? $data[self::class][$legacyProperty]
                 ?? $data[sprintf("\0%s\0%s", self::class, $property)]
+                ?? $data[self::class][$property]
                 ?? $this->$property
                 ?? null;
         }

lib/Doctrine/ORM/Query/QueryException.php

@@ -204,6 +204,14 @@ class QueryException extends ORMException
         );
     }
 
+    public static function eagerFetchJoinWithNotAllowed(string $sourceEntity, string $fieldName): QueryException
+    {
+        return new self(
+            'Associations with fetch-mode=EAGER may not be using WITH conditions in
+             "' . $sourceEntity . '#' . $fieldName . '".'
+        );
+    }
+
     public static function iterateWithMixedResultNotAllowed(): QueryException
     {
         return new self('Iterating a query with mixed results (using scalars) is not supported.');

lib/Doctrine/ORM/Query/ResultSetMappingBuilder.php

@@ -154,6 +154,11 @@ class ResultSetMappingBuilder extends ResultSetMapping
             }
 
             $this->addFieldResult($alias, $columnAlias, $propertyName);
+
+            $enumType = $classMetadata->getFieldMapping($propertyName)['enumType'] ?? null;
+            if (! empty($enumType)) {
+                $this->addEnumResult($columnAlias, $enumType);
+            }
         }
 
         foreach ($classMetadata->associationMappings as $associationMapping) {

lib/Doctrine/ORM/Query/SqlWalker.php

@@ -1010,9 +1010,9 @@ class SqlWalker implements TreeWalker
     /**
      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
      *
-     * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
-     * @param int                            $joinType
-     * @param AST\ConditionalExpression      $condExpr
+     * @param AST\JoinAssociationDeclaration                             $joinAssociationDeclaration
+     * @param int                                                        $joinType
+     * @param AST\ConditionalExpression|AST\Phase2OptimizableConditional $condExpr
      * @psalm-param AST\Join::JOIN_TYPE_* $joinType
      *
      * @return string
@@ -1047,7 +1047,9 @@ class SqlWalker implements TreeWalker
             }
         }
 
-        $targetTableJoin = null;
+        if ($relation['fetch'] === ClassMetadata::FETCH_EAGER && $condExpr !== null) {
+            throw QueryException::eagerFetchJoinWithNotAllowed($assoc['sourceEntity'], $assoc['fieldName']);
+        }
 
         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
@@ -2048,7 +2050,7 @@ class SqlWalker implements TreeWalker
     /**
      * Walk down a ConditionalExpression AST node, thereby generating the appropriate SQL.
      *
-     * @param AST\ConditionalExpression $condExpr
+     * @param AST\ConditionalExpression|AST\Phase2OptimizableConditional $condExpr
      *
      * @return string
      *
@@ -2068,7 +2070,7 @@ class SqlWalker implements TreeWalker
     /**
      * Walks down a ConditionalTerm AST node, thereby generating the appropriate SQL.
      *
-     * @param AST\ConditionalTerm $condTerm
+     * @param AST\ConditionalTerm|AST\ConditionalFactor|AST\ConditionalPrimary $condTerm
      *
      * @return string
      *
@@ -2088,7 +2090,7 @@ class SqlWalker implements TreeWalker
     /**
      * Walks down a ConditionalFactor AST node, thereby generating the appropriate SQL.
      *
-     * @param AST\ConditionalFactor $factor
+     * @param AST\ConditionalFactor|AST\ConditionalPrimary $factor
      *
      * @return string The SQL.
      *

lib/Doctrine/ORM/Tools/Console/Command/ClearCache/CollectionRegionCommand.php

@@ -6,6 +6,7 @@ namespace Doctrine\ORM\Tools\Console\Command\ClearCache;
 
 use Doctrine\ORM\Cache;
 use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use InvalidArgumentException;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
@@ -20,6 +21,8 @@ use function sprintf;
  */
 class CollectionRegionCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -58,12 +61,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/ClearCache/EntityRegionCommand.php

@@ -6,6 +6,7 @@ namespace Doctrine\ORM\Tools\Console\Command\ClearCache;
 
 use Doctrine\ORM\Cache;
 use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use InvalidArgumentException;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
@@ -20,6 +21,8 @@ use function sprintf;
  */
 class EntityRegionCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -57,12 +60,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/ClearCache/MetadataCommand.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Tools\Console\Command\ClearCache;
 
 use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use InvalidArgumentException;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
@@ -18,6 +19,8 @@ use Symfony\Component\Console\Style\SymfonyStyle;
  */
 class MetadataCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -31,12 +34,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/ClearCache/QueryCommand.php

@@ -9,6 +9,7 @@ use Doctrine\Common\Cache\ClearableCache;
 use Doctrine\Common\Cache\FlushableCache;
 use Doctrine\Common\Cache\XcacheCache;
 use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use InvalidArgumentException;
 use LogicException;
 use Symfony\Component\Cache\Adapter\ApcuAdapter;
@@ -28,6 +29,8 @@ use function sprintf;
  */
 class QueryCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -55,12 +58,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/ClearCache/QueryRegionCommand.php

@@ -6,6 +6,7 @@ namespace Doctrine\ORM\Tools\Console\Command\ClearCache;
 
 use Doctrine\ORM\Cache;
 use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use InvalidArgumentException;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
@@ -20,6 +21,8 @@ use function sprintf;
  */
 class QueryRegionCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -56,12 +59,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/ClearCache/ResultCommand.php

@@ -10,6 +10,7 @@ use Doctrine\Common\Cache\FlushableCache;
 use Doctrine\Common\Cache\XcacheCache;
 use Doctrine\ORM\Configuration;
 use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use InvalidArgumentException;
 use LogicException;
 use Symfony\Component\Cache\Adapter\ApcuAdapter;
@@ -29,6 +30,8 @@ use function sprintf;
  */
 class ResultCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -56,12 +59,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/ConvertDoctrine1SchemaCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command;
 
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Doctrine\ORM\Tools\ConvertDoctrine1Schema;
 use Doctrine\ORM\Tools\EntityGenerator;
 use Doctrine\ORM\Tools\Export\ClassMetadataExporter;
@@ -34,6 +35,8 @@ use const PHP_EOL;
  */
 class ConvertDoctrine1SchemaCommand extends Command
 {
+    use CommandCompatibility;
+
     /** @var EntityGenerator|null */
     private $entityGenerator = null;
 
@@ -87,12 +90,7 @@ class ConvertDoctrine1SchemaCommand extends Command
              ->setHelp('Converts Doctrine 1.x schema into a Doctrine 2.x schema.');
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = new SymfonyStyle($input, $output);
         $ui->getErrorStyle()->warning('Command ' . $this->getName() . ' is deprecated and will be removed in Doctrine ORM 3.0.');

lib/Doctrine/ORM/Tools/Console/Command/ConvertMappingCommand.php

@@ -6,6 +6,7 @@ namespace Doctrine\ORM\Tools\Console\Command;
 
 use Doctrine\DBAL\Connection;
 use Doctrine\ORM\Mapping\Driver\DatabaseDriver;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Doctrine\ORM\Tools\Console\MetadataFilter;
 use Doctrine\ORM\Tools\DisconnectedClassMetadataFactory;
 use Doctrine\ORM\Tools\EntityGenerator;
@@ -37,6 +38,8 @@ use function strtolower;
  */
 class ConvertMappingCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -84,12 +87,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = new SymfonyStyle($input, $output);
         $ui->getErrorStyle()->warning('Command ' . $this->getName() . ' is deprecated and will be removed in Doctrine ORM 3.0.');

lib/Doctrine/ORM/Tools/Console/Command/EnsureProductionSettingsCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command;
 
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -19,6 +20,8 @@ use Throwable;
  */
 class EnsureProductionSettingsCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -29,12 +32,7 @@ class EnsureProductionSettingsCommand extends AbstractEntityManagerCommand
              ->setHelp('Verify that Doctrine is properly configured for a production environment.');
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
         $ui->warning('This console command has been deprecated and will be removed in a future version of Doctrine ORM.');

lib/Doctrine/ORM/Tools/Console/Command/GenerateEntitiesCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command;
 
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Doctrine\ORM\Tools\Console\MetadataFilter;
 use Doctrine\ORM\Tools\DisconnectedClassMetadataFactory;
 use Doctrine\ORM\Tools\EntityGenerator;
@@ -28,6 +29,8 @@ use function sprintf;
  */
 class GenerateEntitiesCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -67,12 +70,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
         $ui->warning('Command ' . $this->getName() . ' is deprecated and will be removed in Doctrine ORM 3.0.');

lib/Doctrine/ORM/Tools/Console/Command/GenerateProxiesCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command;
 
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Doctrine\ORM\Tools\Console\MetadataFilter;
 use InvalidArgumentException;
 use Symfony\Component\Console\Input\InputArgument;
@@ -26,6 +27,8 @@ use function sprintf;
  */
 class GenerateProxiesCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -38,12 +41,7 @@ class GenerateProxiesCommand extends AbstractEntityManagerCommand
              ->setHelp('Generates proxy classes for entity classes.');
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/GenerateRepositoriesCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command;
 
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Doctrine\ORM\Tools\Console\MetadataFilter;
 use Doctrine\ORM\Tools\EntityRepositoryGenerator;
 use InvalidArgumentException;
@@ -27,6 +28,8 @@ use function sprintf;
  */
 class GenerateRepositoriesCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -39,12 +42,7 @@ class GenerateRepositoriesCommand extends AbstractEntityManagerCommand
              ->setHelp('Generate repository classes from your mapping information.');
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
         $ui->warning('Command ' . $this->getName() . ' is deprecated and will be removed in Doctrine ORM 3.0.');

lib/Doctrine/ORM/Tools/Console/Command/InfoCommand.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Tools\Console\Command;
 
 use Doctrine\ORM\Mapping\MappingException;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -20,6 +21,8 @@ use function sprintf;
  */
 class InfoCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -34,12 +37,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 

lib/Doctrine/ORM/Tools/Console/Command/RunDqlCommand.php

@@ -4,7 +4,8 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command;
 
-use Doctrine\Common\Util\Debug;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
+use Doctrine\ORM\Tools\Debug;
 use LogicException;
 use RuntimeException;
 use Symfony\Component\Console\Input\InputArgument;
@@ -27,6 +28,8 @@ use function strtoupper;
  */
 class RunDqlCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -58,12 +61,7 @@ EOT
              );
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = new SymfonyStyle($input, $output);
 
@@ -118,7 +116,7 @@ EOT
 
         $resultSet = $query->execute([], constant($hydrationMode));
 
-        $ui->text(Debug::dump($resultSet, (int) $input->getOption('depth'), true, false));
+        $ui->text(Debug::dump($resultSet, (int) $input->getOption('depth')));
 
         return 0;
     }

lib/Doctrine/ORM/Tools/Console/Command/SchemaTool/AbstractCommand.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Tools\Console\Command\SchemaTool;
 
 use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Doctrine\ORM\Tools\SchemaTool;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -17,6 +18,8 @@ use Symfony\Component\Console\Style\SymfonyStyle;
  */
 abstract class AbstractCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /**
      * @param mixed[] $metadatas
      *
@@ -24,12 +27,7 @@ abstract class AbstractCommand extends AbstractEntityManagerCommand
      */
     abstract protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas, SymfonyStyle $ui);
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = new SymfonyStyle($input, $output);
 

lib/Doctrine/ORM/Tools/Console/Command/ValidateSchemaCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command;
 
+use Doctrine\ORM\Tools\Console\CommandCompatibility;
 use Doctrine\ORM\Tools\SchemaValidator;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
@@ -20,6 +21,8 @@ use function sprintf;
  */
 class ValidateSchemaCommand extends AbstractEntityManagerCommand
 {
+    use CommandCompatibility;
+
     /** @return void */
     protected function configure()
     {
@@ -28,20 +31,16 @@ class ValidateSchemaCommand extends AbstractEntityManagerCommand
              ->addOption('em', null, InputOption::VALUE_REQUIRED, 'Name of the entity manager to operate on')
              ->addOption('skip-mapping', null, InputOption::VALUE_NONE, 'Skip the mapping validation check')
              ->addOption('skip-sync', null, InputOption::VALUE_NONE, 'Skip checking if the mapping is in sync with the database')
+             ->addOption('skip-property-types', null, InputOption::VALUE_NONE, 'Skip checking if property types match the Doctrine types')
              ->setHelp('Validate that the mapping files are correct and in sync with the database.');
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @return int
-     */
-    protected function execute(InputInterface $input, OutputInterface $output)
+    private function doExecute(InputInterface $input, OutputInterface $output): int
     {
         $ui = (new SymfonyStyle($input, $output))->getErrorStyle();
 
         $em        = $this->getEntityManager($input);
-        $validator = new SchemaValidator($em);
+        $validator = new SchemaValidator($em, ! $input->getOption('skip-property-types'));
         $exit      = 0;
 
         $ui->section('Mapping');

lib/Doctrine/ORM/Tools/Console/CommandCompatibility.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Tools\Console;
+
+use ReflectionMethod;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+if ((new ReflectionMethod(Command::class, 'execute'))->hasReturnType()) {
+    /** @internal */
+    trait CommandCompatibility
+    {
+        protected function execute(InputInterface $input, OutputInterface $output): int
+        {
+            return $this->doExecute($input, $output);
+        }
+    }
+} else {
+    /** @internal */
+    trait CommandCompatibility
+    {
+        /**
+         * {@inheritDoc}
+         *
+         * @return int
+         */
+        protected function execute(InputInterface $input, OutputInterface $output)
+        {
+            return $this->doExecute($input, $output);
+        }
+    }
+}

lib/Doctrine/ORM/Tools/Console/Helper/EntityManagerHelper.php

@@ -6,7 +6,34 @@ namespace Doctrine\ORM\Tools\Console\Helper;
 
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
+use ReflectionMethod;
 use Symfony\Component\Console\Helper\Helper;
+use Symfony\Component\Console\Helper\HelperInterface;
+
+if ((new ReflectionMethod(HelperInterface::class, 'getName'))->hasReturnType()) {
+    /** @internal */
+    trait EntityManagerHelperCompatibility
+    {
+        public function getName(): string
+        {
+            return 'entityManager';
+        }
+    }
+} else {
+    /** @internal */
+    trait EntityManagerHelperCompatibility
+    {
+        /**
+         * {@inheritDoc}
+         *
+         * @return string
+         */
+        public function getName()
+        {
+            return 'entityManager';
+        }
+    }
+}
 
 /**
  * Doctrine CLI Connection Helper.
@@ -15,6 +42,8 @@ use Symfony\Component\Console\Helper\Helper;
  */
 class EntityManagerHelper extends Helper
 {
+    use EntityManagerHelperCompatibility;
+
     /**
      * Doctrine ORM EntityManagerInterface.
      *
@@ -43,14 +72,4 @@ class EntityManagerHelper extends Helper
     {
         return $this->_em;
     }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @return string
-     */
-    public function getName()
-    {
-        return 'entityManager';
-    }
 }

lib/Doctrine/ORM/Tools/Debug.php

@@ -0,0 +1,168 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Tools;
+
+use ArrayIterator;
+use ArrayObject;
+use DateTimeInterface;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
+use Doctrine\Persistence\Proxy;
+use stdClass;
+
+use function array_keys;
+use function count;
+use function end;
+use function explode;
+use function extension_loaded;
+use function get_class;
+use function html_entity_decode;
+use function ini_get;
+use function ini_set;
+use function is_array;
+use function is_object;
+use function ob_end_clean;
+use function ob_get_contents;
+use function ob_start;
+use function strip_tags;
+use function var_dump;
+
+/**
+ * Static class containing most used debug methods.
+ *
+ * @internal
+ *
+ * @link   www.doctrine-project.org
+ */
+final class Debug
+{
+    /**
+     * Private constructor (prevents instantiation).
+     */
+    private function __construct()
+    {
+    }
+
+    /**
+     * Prints a dump of the public, protected and private properties of $var.
+     *
+     * @link https://xdebug.org/
+     *
+     * @param mixed $var      The variable to dump.
+     * @param int   $maxDepth The maximum nesting level for object properties.
+     */
+    public static function dump($var, int $maxDepth = 2): string
+    {
+        $html = ini_get('html_errors');
+
+        if ($html !== '1') {
+            ini_set('html_errors', 'on');
+        }
+
+        if (extension_loaded('xdebug')) {
+            $previousDepth = ini_get('xdebug.var_display_max_depth');
+            ini_set('xdebug.var_display_max_depth', (string) $maxDepth);
+        }
+
+        try {
+            $var = self::export($var, $maxDepth);
+
+            ob_start();
+            var_dump($var);
+
+            $dump = ob_get_contents();
+
+            ob_end_clean();
+
+            $dumpText = strip_tags(html_entity_decode($dump));
+        } finally {
+            ini_set('html_errors', $html);
+
+            if (isset($previousDepth)) {
+                ini_set('xdebug.var_display_max_depth', $previousDepth);
+            }
+        }
+
+        return $dumpText;
+    }
+
+    /**
+     * @param mixed $var
+     *
+     * @return mixed
+     */
+    public static function export($var, int $maxDepth)
+    {
+        if ($var instanceof Collection) {
+            $var = $var->toArray();
+        }
+
+        if (! $maxDepth) {
+            return is_object($var) ? get_class($var)
+                : (is_array($var) ? 'Array(' . count($var) . ')' : $var);
+        }
+
+        if (is_array($var)) {
+            $return = [];
+
+            foreach ($var as $k => $v) {
+                $return[$k] = self::export($v, $maxDepth - 1);
+            }
+
+            return $return;
+        }
+
+        if (! is_object($var)) {
+            return $var;
+        }
+
+        $return = new stdClass();
+        if ($var instanceof DateTimeInterface) {
+            $return->__CLASS__ = get_class($var);
+            $return->date      = $var->format('c');
+            $return->timezone  = $var->getTimezone()->getName();
+
+            return $return;
+        }
+
+        $return->__CLASS__ = DefaultProxyClassNameResolver::getClass($var);
+
+        if ($var instanceof Proxy) {
+            $return->__IS_PROXY__          = true;
+            $return->__PROXY_INITIALIZED__ = $var->__isInitialized();
+        }
+
+        if ($var instanceof ArrayObject || $var instanceof ArrayIterator) {
+            $return->__STORAGE__ = self::export($var->getArrayCopy(), $maxDepth - 1);
+        }
+
+        return self::fillReturnWithClassAttributes($var, $return, $maxDepth);
+    }
+
+    /**
+     * Fill the $return variable with class attributes
+     * Based on obj2array function from {@see https://secure.php.net/manual/en/function.get-object-vars.php#47075}
+     *
+     * @param object $var
+     *
+     * @return mixed
+     */
+    private static function fillReturnWithClassAttributes($var, stdClass $return, int $maxDepth)
+    {
+        $clone = (array) $var;
+
+        foreach (array_keys($clone) as $key) {
+            $aux  = explode("\0", (string) $key);
+            $name = end($aux);
+            if ($aux[0] === '') {
+                $name .= ':' . ($aux[1] === '*' ? 'protected' : $aux[1] . ':private');
+            }
+
+            $return->$name = self::export($clone[$key], $maxDepth - 1);
+        }
+
+        return $return;
+    }
+}

lib/Doctrine/ORM/Tools/EntityGenerator.php

@@ -1376,7 +1376,7 @@ public function __construct(<params>)
         $this->staticReflection[$metadata->name]['methods'][] = strtolower($methodName);
 
         $var      = sprintf('%sMethodTemplate', $type);
-        $template = static::$$var;
+        $template = (string) static::$$var;
 
         $methodTypeHint = '';
         $types          = Type::getTypesMap();
@@ -1695,7 +1695,7 @@ public function __construct(<params>)
             }
 
             if (isset($fieldMapping['options']['comment']) && $fieldMapping['options']['comment']) {
-                $options[] = '"comment"="' . str_replace('"', '""', $fieldMapping['options']['comment']) . '"';
+                $options[] = '"comment"="' . str_replace('"', '""', (string) $fieldMapping['options']['comment']) . '"';
             }
 
             if (isset($fieldMapping['options']['collation']) && $fieldMapping['options']['collation']) {

lib/Doctrine/ORM/Tools/Pagination/LimitSubqueryOutputWalker.php

@@ -15,7 +15,6 @@ use Doctrine\ORM\Mapping\QuoteStrategy;
 use Doctrine\ORM\OptimisticLockException;
 use Doctrine\ORM\Query;
 use Doctrine\ORM\Query\AST\OrderByClause;
-use Doctrine\ORM\Query\AST\PartialObjectExpression;
 use Doctrine\ORM\Query\AST\PathExpression;
 use Doctrine\ORM\Query\AST\SelectExpression;
 use Doctrine\ORM\Query\AST\SelectStatement;
@@ -335,7 +334,7 @@ class LimitSubqueryOutputWalker extends SqlWalker
 
         // Add select items which were not excluded to the AST's select clause.
         foreach ($selects as $idVar => $fields) {
-            $AST->selectClause->selectExpressions[] = new SelectExpression(new PartialObjectExpression($idVar, array_keys($fields)), null, true);
+            $AST->selectClause->selectExpressions[] = new SelectExpression($idVar, null, true);
         }
     }
 
@@ -374,8 +373,7 @@ class LimitSubqueryOutputWalker extends SqlWalker
         string $innerSql
     ): string {
         [$searchPatterns, $replacements] = $this->generateSqlAliasReplacements();
-
-        $orderByItems = [];
+        $orderByItems                    = [];
 
         foreach ($orderByClause->orderByItems as $orderByItem) {
             // Walk order by item to get string representation of it and
@@ -404,7 +402,7 @@ class LimitSubqueryOutputWalker extends SqlWalker
 
     /**
      * @return string[][]
-     * @psalm-return array{0: list<string>, 1: list<string>}
+     * @psalm-return array{0: list<non-empty-string>, 1: list<string>}
      */
     private function generateSqlAliasReplacements(): array
     {

lib/Doctrine/ORM/Tools/Pagination/LimitSubqueryWalker.php

@@ -50,12 +50,14 @@ class LimitSubqueryWalker extends TreeWalkerAdapter
             throw new RuntimeException('Paginating an entity with foreign key as identifier only works when using the Output Walkers. Call Paginator#setUseOutputWalkers(true) before iterating the paginator.');
         }
 
-        $this->_getQuery()->setHint(
+        $query = $this->_getQuery();
+
+        $query->setHint(
             self::IDENTIFIER_TYPE,
             Type::getType($rootClass->fieldMappings[$identifier]['type'])
         );
 
-        $this->_getQuery()->setHint(self::FORCE_DBAL_TYPE_CONVERSION, true);
+        $query->setHint(self::FORCE_DBAL_TYPE_CONVERSION, true);
 
         $pathExpression = new PathExpression(
             PathExpression::TYPE_STATE_FIELD | PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION,
@@ -66,7 +68,7 @@ class LimitSubqueryWalker extends TreeWalkerAdapter
         $pathExpression->type = PathExpression::TYPE_STATE_FIELD;
 
         $AST->selectClause->selectExpressions = [new SelectExpression($pathExpression, '_dctrn_id')];
-        $AST->selectClause->isDistinct        = true;
+        $AST->selectClause->isDistinct        = ($query->getHints()[Paginator::HINT_ENABLE_DISTINCT] ?? true) === true;
 
         if (! isset($AST->orderByClause)) {
             return;

lib/Doctrine/ORM/Tools/Pagination/Paginator.php

@@ -34,6 +34,8 @@ class Paginator implements Countable, IteratorAggregate
 {
     use SQLResultCasing;
 
+    public const HINT_ENABLE_DISTINCT = 'paginator.distinct.enable';
+
     /** @var Query */
     private $query;
 

lib/Doctrine/ORM/Tools/Pagination/WhereInWalker.php

@@ -6,7 +6,6 @@ namespace Doctrine\ORM\Tools\Pagination;
 
 use Doctrine\ORM\Query\AST\ArithmeticExpression;
 use Doctrine\ORM\Query\AST\ConditionalExpression;
-use Doctrine\ORM\Query\AST\ConditionalFactor;
 use Doctrine\ORM\Query\AST\ConditionalPrimary;
 use Doctrine\ORM\Query\AST\ConditionalTerm;
 use Doctrine\ORM\Query\AST\InListExpression;
@@ -96,10 +95,7 @@ class WhereInWalker extends TreeWalkerAdapter
                         ),
                     ]
                 );
-            } elseif (
-                $AST->whereClause->conditionalExpression instanceof ConditionalExpression
-                || $AST->whereClause->conditionalExpression instanceof ConditionalFactor
-            ) {
+            } else {
                 $tmpPrimary                              = new ConditionalPrimary();
                 $tmpPrimary->conditionalExpression       = $AST->whereClause->conditionalExpression;
                 $AST->whereClause->conditionalExpression = new ConditionalTerm(

lib/Doctrine/ORM/Tools/SchemaValidator.php

@@ -4,36 +4,84 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools;
 
+use BackedEnum;
+use Doctrine\DBAL\Types\AsciiStringType;
+use Doctrine\DBAL\Types\BigIntType;
+use Doctrine\DBAL\Types\BooleanType;
+use Doctrine\DBAL\Types\DecimalType;
+use Doctrine\DBAL\Types\FloatType;
+use Doctrine\DBAL\Types\GuidType;
+use Doctrine\DBAL\Types\IntegerType;
+use Doctrine\DBAL\Types\JsonType;
+use Doctrine\DBAL\Types\SimpleArrayType;
+use Doctrine\DBAL\Types\SmallIntType;
+use Doctrine\DBAL\Types\StringType;
+use Doctrine\DBAL\Types\TextType;
 use Doctrine\DBAL\Types\Type;
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataInfo;
+use ReflectionEnum;
+use ReflectionNamedType;
 
 use function array_diff;
+use function array_filter;
 use function array_key_exists;
+use function array_map;
+use function array_push;
 use function array_search;
 use function array_values;
+use function assert;
 use function class_exists;
 use function class_parents;
 use function count;
 use function get_class;
 use function implode;
 use function in_array;
+use function interface_exists;
+use function is_a;
+use function sprintf;
+
+use const PHP_VERSION_ID;
 
 /**
  * Performs strict validation of the mapping schema
  *
  * @link        www.doctrine-project.com
+ *
+ * @psalm-import-type FieldMapping from ClassMetadata
  */
 class SchemaValidator
 {
     /** @var EntityManagerInterface */
     private $em;
 
-    public function __construct(EntityManagerInterface $em)
+    /** @var bool */
+    private $validatePropertyTypes;
+
+    /**
+     * It maps built-in Doctrine types to PHP types
+     */
+    private const BUILTIN_TYPES_MAP = [
+        AsciiStringType::class => 'string',
+        BigIntType::class => 'string',
+        BooleanType::class => 'bool',
+        DecimalType::class => 'string',
+        FloatType::class => 'float',
+        GuidType::class => 'string',
+        IntegerType::class => 'int',
+        JsonType::class => 'array',
+        SimpleArrayType::class => 'array',
+        SmallIntType::class => 'int',
+        StringType::class => 'string',
+        TextType::class => 'string',
+    ];
+
+    public function __construct(EntityManagerInterface $em, bool $validatePropertyTypes = true)
     {
-        $this->em = $em;
+        $this->em                    = $em;
+        $this->validatePropertyTypes = $validatePropertyTypes;
     }
 
     /**
@@ -92,6 +140,11 @@ class SchemaValidator
             }
         }
 
+        // PHP 7.4 introduces the ability to type properties, so we can't validate them in previous versions
+        if (PHP_VERSION_ID >= 70400 && $this->validatePropertyTypes) {
+            array_push($ce, ...$this->validatePropertiesTypes($class));
+        }
+
         if ($class->isEmbeddedClass && count($class->associationMappings) > 0) {
             $ce[] = "Embeddable '" . $class->name . "' does not support associations";
 
@@ -304,4 +357,122 @@ class SchemaValidator
 
         return $schemaTool->getUpdateSchemaSql($allMetadata, true);
     }
+
+    /** @return list<string> containing the found issues */
+    private function validatePropertiesTypes(ClassMetadataInfo $class): array
+    {
+        return array_values(
+            array_filter(
+                array_map(
+                    /** @param FieldMapping $fieldMapping */
+                    function (array $fieldMapping) use ($class): ?string {
+                        $fieldName = $fieldMapping['fieldName'];
+                        assert(isset($class->reflFields[$fieldName]));
+                        $propertyType = $class->reflFields[$fieldName]->getType();
+
+                        // If the field type is not a built-in type, we cannot check it
+                        if (! Type::hasType($fieldMapping['type'])) {
+                            return null;
+                        }
+
+                        // If the property type is not a named type, we cannot check it
+                        if (! ($propertyType instanceof ReflectionNamedType) || $propertyType->getName() === 'mixed') {
+                            return null;
+                        }
+
+                        $metadataFieldType = $this->findBuiltInType(Type::getType($fieldMapping['type']));
+
+                        //If the metadata field type is not a mapped built-in type, we cannot check it
+                        if ($metadataFieldType === null) {
+                            return null;
+                        }
+
+                        $propertyType = $propertyType->getName();
+
+                        // If the property type is the same as the metadata field type, we are ok
+                        if ($propertyType === $metadataFieldType) {
+                            return null;
+                        }
+
+                        if (is_a($propertyType, BackedEnum::class, true)) {
+                            $backingType = (string) (new ReflectionEnum($propertyType))->getBackingType();
+
+                            if ($metadataFieldType !== $backingType) {
+                                return sprintf(
+                                    "The field '%s#%s' has the property type '%s' with a backing type of '%s' that differs from the metadata field type '%s'.",
+                                    $class->name,
+                                    $fieldName,
+                                    $propertyType,
+                                    $backingType,
+                                    $metadataFieldType
+                                );
+                            }
+
+                            if (! isset($fieldMapping['enumType']) || $propertyType === $fieldMapping['enumType']) {
+                                return null;
+                            }
+
+                            return sprintf(
+                                "The field '%s#%s' has the property type '%s' that differs from the metadata enumType '%s'.",
+                                $class->name,
+                                $fieldName,
+                                $propertyType,
+                                $fieldMapping['enumType']
+                            );
+                        }
+
+                        if (
+                            isset($fieldMapping['enumType'])
+                            && $propertyType !== $fieldMapping['enumType']
+                            && interface_exists($propertyType)
+                            && is_a($fieldMapping['enumType'], $propertyType, true)
+                        ) {
+                            $backingType = (string) (new ReflectionEnum($fieldMapping['enumType']))->getBackingType();
+
+                            if ($metadataFieldType === $backingType) {
+                                return null;
+                            }
+
+                            return sprintf(
+                                "The field '%s#%s' has the metadata enumType '%s' with a backing type of '%s' that differs from the metadata field type '%s'.",
+                                $class->name,
+                                $fieldName,
+                                $fieldMapping['enumType'],
+                                $backingType,
+                                $metadataFieldType
+                            );
+                        }
+
+                        if (
+                            $fieldMapping['type'] === 'json'
+                            && in_array($propertyType, ['string', 'int', 'float', 'bool', 'true', 'false', 'null'], true)
+                        ) {
+                            return null;
+                        }
+
+                        return sprintf(
+                            "The field '%s#%s' has the property type '%s' that differs from the metadata field type '%s' returned by the '%s' DBAL type.",
+                            $class->name,
+                            $fieldName,
+                            $propertyType,
+                            $metadataFieldType,
+                            $fieldMapping['type']
+                        );
+                    },
+                    $class->fieldMappings
+                )
+            )
+        );
+    }
+
+    /**
+     * The exact DBAL type must be used (no subclasses), since consumers of doctrine/orm may have their own
+     * customization around field types.
+     */
+    private function findBuiltInType(Type $type): ?string
+    {
+        $typeName = get_class($type);
+
+        return self::BUILTIN_TYPES_MAP[$typeName] ?? null;
+    }
 }

lib/Doctrine/ORM/UnitOfWork.php

@@ -23,10 +23,10 @@ use Doctrine\ORM\Event\PreFlushEventArgs;
 use Doctrine\ORM\Event\PrePersistEventArgs;
 use Doctrine\ORM\Event\PreRemoveEventArgs;
 use Doctrine\ORM\Event\PreUpdateEventArgs;
+use Doctrine\ORM\Exception\EntityIdentityCollisionException;
 use Doctrine\ORM\Exception\ORMException;
 use Doctrine\ORM\Exception\UnexpectedAssociationValue;
 use Doctrine\ORM\Id\AssignedGenerator;
-use Doctrine\ORM\Internal\CommitOrderCalculator;
 use Doctrine\ORM\Internal\HydrationCompleteHandler;
 use Doctrine\ORM\Internal\TopologicalSort;
 use Doctrine\ORM\Mapping\ClassMetadata;
@@ -51,6 +51,7 @@ use RuntimeException;
 use Throwable;
 use UnexpectedValueException;
 
+use function array_chunk;
 use function array_combine;
 use function array_diff_key;
 use function array_filter;
@@ -314,6 +315,9 @@ class UnitOfWork implements PropertyChangedListener
      */
     private $eagerLoadingEntities = [];
 
+    /** @var array<string, array<string, mixed>> */
+    private $eagerLoadingCollections = [];
+
     /** @var bool */
     protected $hasCache = false;
 
@@ -692,6 +696,7 @@ class UnitOfWork implements PropertyChangedListener
             if ($class->isCollectionValuedAssociation($name) && $value !== null) {
                 if ($value instanceof PersistentCollection) {
                     if ($value->getOwner() === $entity) {
+                        $actualData[$name] = $value;
                         continue;
                     }
 
@@ -1162,13 +1167,13 @@ class UnitOfWork implements PropertyChangedListener
      */
     private function executeInserts(): void
     {
-        $entities = $this->computeInsertExecutionOrder();
+        $entities         = $this->computeInsertExecutionOrder();
+        $eventsToDispatch = [];
 
         foreach ($entities as $entity) {
             $oid       = spl_object_id($entity);
             $class     = $this->em->getClassMetadata(get_class($entity));
             $persister = $this->getEntityPersister($class->name);
-            $invoke    = $this->listenersInvoker->getSubscribedSystems($class, Events::postPersist);
 
             $persister->addInsert($entity);
 
@@ -1195,10 +1200,24 @@ class UnitOfWork implements PropertyChangedListener
                 $this->addToEntityIdentifiersAndEntityMap($class, $oid, $entity);
             }
 
+            $invoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postPersist);
+
             if ($invoke !== ListenersInvoker::INVOKE_NONE) {
-                $this->listenersInvoker->invoke($class, Events::postPersist, $entity, new PostPersistEventArgs($entity, $this->em), $invoke);
+                $eventsToDispatch[] = ['class' => $class, 'entity' => $entity, 'invoke' => $invoke];
             }
         }
+
+        // Defer dispatching `postPersist` events to until all entities have been inserted and post-insert
+        // IDs have been assigned.
+        foreach ($eventsToDispatch as $event) {
+            $this->listenersInvoker->invoke(
+                $event['class'],
+                Events::postPersist,
+                $event['entity'],
+                new PostPersistEventArgs($event['entity'], $this->em),
+                $event['invoke']
+            );
+        }
     }
 
     /**
@@ -1268,7 +1287,8 @@ class UnitOfWork implements PropertyChangedListener
      */
     private function executeDeletions(): void
     {
-        $entities = $this->computeDeleteExecutionOrder();
+        $entities         = $this->computeDeleteExecutionOrder();
+        $eventsToDispatch = [];
 
         foreach ($entities as $entity) {
             $oid       = spl_object_id($entity);
@@ -1293,9 +1313,20 @@ class UnitOfWork implements PropertyChangedListener
             }
 
             if ($invoke !== ListenersInvoker::INVOKE_NONE) {
-                $this->listenersInvoker->invoke($class, Events::postRemove, $entity, new PostRemoveEventArgs($entity, $this->em), $invoke);
+                $eventsToDispatch[] = ['class' => $class, 'entity' => $entity, 'invoke' => $invoke];
             }
         }
+
+        // Defer dispatching `postRemove` events to until all entities have been removed.
+        foreach ($eventsToDispatch as $event) {
+            $this->listenersInvoker->invoke(
+                $event['class'],
+                Events::postRemove,
+                $event['entity'],
+                new PostRemoveEventArgs($event['entity'], $this->em),
+                $event['invoke']
+            );
+        }
     }
 
     /** @return list<object> */
@@ -1623,6 +1654,7 @@ class UnitOfWork implements PropertyChangedListener
      * the entity in question is already managed.
      *
      * @throws ORMInvalidArgumentException
+     * @throws EntityIdentityCollisionException
      *
      * @ignore
      */
@@ -1634,27 +1666,38 @@ class UnitOfWork implements PropertyChangedListener
 
         if (isset($this->identityMap[$className][$idHash])) {
             if ($this->identityMap[$className][$idHash] !== $entity) {
-                throw new RuntimeException(sprintf(
+                if ($this->em->getConfiguration()->isRejectIdCollisionInIdentityMapEnabled()) {
+                    throw EntityIdentityCollisionException::create($this->identityMap[$className][$idHash], $entity, $idHash);
+                }
+
+                Deprecation::trigger(
+                    'doctrine/orm',
+                    'https://github.com/doctrine/orm/pull/10785',
                     <<<'EXCEPTION'
 While adding an entity of class %s with an ID hash of "%s" to the identity map,
-another object of class %s was already present for the same ID. This exception
-is a safeguard against an internal inconsistency - IDs should uniquely map to
-entity object instances. This problem may occur if:
+another object of class %s was already present for the same ID. This will trigger
+an exception in ORM 3.0.
+
+IDs should uniquely map to entity object instances. This problem may occur if:
 
 - you use application-provided IDs and reuse ID values;
-- database-provided IDs are reassigned after truncating the database without 
-  clearing the EntityManager;
-- you might have been using EntityManager#getReference() to create a reference 
-  for a nonexistent ID that was subsequently (by the RDBMS) assigned to another 
-  entity. 
+- database-provided IDs are reassigned after truncating the database without
+clearing the EntityManager;
+- you might have been using EntityManager#getReference() to create a reference
+for a nonexistent ID that was subsequently (by the RDBMS) assigned to another
+entity.
 
-Otherwise, it might be an ORM-internal inconsistency, please report it. 
+Otherwise, it might be an ORM-internal inconsistency, please report it.
+
+To opt-in to the new exception, call
+\Doctrine\ORM\Configuration::setRejectIdCollisionInIdentityMap on the entity
+manager's configuration.
 EXCEPTION
                     ,
                     get_class($entity),
                     $idHash,
                     get_class($this->identityMap[$className][$idHash])
-                ));
+                );
             }
 
             return false;
@@ -2681,16 +2724,6 @@ EXCEPTION
         }
     }
 
-    /**
-     * Gets the CommitOrderCalculator used by the UnitOfWork to order commits.
-     *
-     * @return CommitOrderCalculator
-     */
-    public function getCommitOrderCalculator()
-    {
-        return new Internal\CommitOrderCalculator();
-    }
-
     /**
      * Clears the UnitOfWork.
      *
@@ -2720,6 +2753,7 @@ EXCEPTION
             $this->pendingCollectionElementRemovals =
             $this->visitedCollections               =
             $this->eagerLoadingEntities             =
+            $this->eagerLoadingCollections          =
             $this->orphanRemovals                   = [];
         } else {
             Deprecation::triggerIfCalledFromOutside(
@@ -2909,6 +2943,10 @@ EXCEPTION
                 continue;
             }
 
+            if (! isset($hints['fetchMode'][$class->name][$field])) {
+                $hints['fetchMode'][$class->name][$field] = $assoc['fetch'];
+            }
+
             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
 
             switch (true) {
@@ -2972,10 +3010,6 @@ EXCEPTION
                         break;
                     }
 
-                    if (! isset($hints['fetchMode'][$class->name][$field])) {
-                        $hints['fetchMode'][$class->name][$field] = $assoc['fetch'];
-                    }
-
                     // Foreign key is set
                     // Check identity map first
                     // FIXME: Can break easily with composite keys if join column values are in
@@ -3014,14 +3048,18 @@ EXCEPTION
                                 // We are negating the condition here. Other cases will assume it is valid!
                                 case $hints['fetchMode'][$class->name][$field] !== ClassMetadata::FETCH_EAGER:
                                     $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $normalizedAssociatedId);
+                                    $this->registerManaged($newValue, $associatedId, []);
                                     break;
 
                                 // Deferred eager load only works for single identifier classes
-                                case isset($hints[self::HINT_DEFEREAGERLOAD]) && ! $targetClass->isIdentifierComposite:
+                                case isset($hints[self::HINT_DEFEREAGERLOAD]) &&
+                                    $hints[self::HINT_DEFEREAGERLOAD] &&
+                                    ! $targetClass->isIdentifierComposite:
                                     // TODO: Is there a faster approach?
                                     $this->eagerLoadingEntities[$targetClass->rootEntityName][$relatedIdHash] = current($normalizedAssociatedId);
 
                                     $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $normalizedAssociatedId);
+                                    $this->registerManaged($newValue, $associatedId, []);
                                     break;
 
                                 default:
@@ -3029,13 +3067,6 @@ EXCEPTION
                                     $newValue = $this->em->find($assoc['targetEntity'], $normalizedAssociatedId);
                                     break;
                             }
-
-                            if ($newValue === null) {
-                                break;
-                            }
-
-                            $this->registerManaged($newValue, $associatedId, []);
-                            break;
                     }
 
                     $this->originalEntityData[$oid][$field] = $newValue;
@@ -3072,9 +3103,13 @@ EXCEPTION
                     $reflField = $class->reflFields[$field];
                     $reflField->setValue($entity, $pColl);
 
-                    if ($assoc['fetch'] === ClassMetadata::FETCH_EAGER) {
-                        $this->loadCollection($pColl);
-                        $pColl->takeSnapshot();
+                    if ($hints['fetchMode'][$class->name][$field] === ClassMetadata::FETCH_EAGER) {
+                        if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
+                            $this->scheduleCollectionForBatchLoading($pColl, $class);
+                        } elseif ($assoc['type'] === ClassMetadata::MANY_TO_MANY) {
+                            $this->loadCollection($pColl);
+                            $pColl->takeSnapshot();
+                        }
                     }
 
                     $this->originalEntityData[$oid][$field] = $pColl;
@@ -3091,7 +3126,7 @@ EXCEPTION
     /** @return void */
     public function triggerEagerLoads()
     {
-        if (! $this->eagerLoadingEntities) {
+        if (! $this->eagerLoadingEntities && ! $this->eagerLoadingCollections) {
             return;
         }
 
@@ -3104,11 +3139,69 @@ EXCEPTION
                 continue;
             }
 
-            $class = $this->em->getClassMetadata($entityName);
+            $class   = $this->em->getClassMetadata($entityName);
+            $batches = array_chunk($ids, $this->em->getConfiguration()->getEagerFetchBatchSize());
 
-            $this->getEntityPersister($entityName)->loadAll(
-                array_combine($class->identifier, [array_values($ids)])
-            );
+            foreach ($batches as $batchedIds) {
+                $this->getEntityPersister($entityName)->loadAll(
+                    array_combine($class->identifier, [$batchedIds])
+                );
+            }
+        }
+
+        $eagerLoadingCollections       = $this->eagerLoadingCollections; // avoid recursion
+        $this->eagerLoadingCollections = [];
+
+        foreach ($eagerLoadingCollections as $group) {
+            $this->eagerLoadCollections($group['items'], $group['mapping']);
+        }
+    }
+
+    /**
+     * Load all data into the given collections, according to the specified mapping
+     *
+     * @param PersistentCollection[] $collections
+     * @param array<string, mixed>   $mapping
+     * @psalm-param array{targetEntity: class-string, sourceEntity: class-string, mappedBy: string, indexBy: string|null} $mapping
+     */
+    private function eagerLoadCollections(array $collections, array $mapping): void
+    {
+        $targetEntity = $mapping['targetEntity'];
+        $class        = $this->em->getClassMetadata($mapping['sourceEntity']);
+        $mappedBy     = $mapping['mappedBy'];
+
+        $batches = array_chunk($collections, $this->em->getConfiguration()->getEagerFetchBatchSize(), true);
+
+        foreach ($batches as $collectionBatch) {
+            $entities = [];
+
+            foreach ($collectionBatch as $collection) {
+                $entities[] = $collection->getOwner();
+            }
+
+            $found = $this->getEntityPersister($targetEntity)->loadAll([$mappedBy => $entities]);
+
+            $targetClass    = $this->em->getClassMetadata($targetEntity);
+            $targetProperty = $targetClass->getReflectionProperty($mappedBy);
+
+            foreach ($found as $targetValue) {
+                $sourceEntity = $targetProperty->getValue($targetValue);
+
+                $id     = $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($sourceEntity));
+                $idHash = implode(' ', $id);
+
+                if (isset($mapping['indexBy'])) {
+                    $indexByProperty = $targetClass->getReflectionProperty($mapping['indexBy']);
+                    $collectionBatch[$idHash]->hydrateSet($indexByProperty->getValue($targetValue), $targetValue);
+                } else {
+                    $collectionBatch[$idHash]->add($targetValue);
+                }
+            }
+        }
+
+        foreach ($collections as $association) {
+            $association->setInitialized(true);
+            $association->takeSnapshot();
         }
     }
 
@@ -3139,6 +3232,33 @@ EXCEPTION
         $collection->setInitialized(true);
     }
 
+    /**
+     * Schedule this collection for batch loading at the end of the UnitOfWork
+     */
+    private function scheduleCollectionForBatchLoading(PersistentCollection $collection, ClassMetadata $sourceClass): void
+    {
+        $mapping = $collection->getMapping();
+        $name    = $mapping['sourceEntity'] . '#' . $mapping['fieldName'];
+
+        if (! isset($this->eagerLoadingCollections[$name])) {
+            $this->eagerLoadingCollections[$name] = [
+                'items'   => [],
+                'mapping' => $mapping,
+            ];
+        }
+
+        $owner = $collection->getOwner();
+        assert($owner !== null);
+
+        $id     = $this->identifierFlattener->flattenIdentifier(
+            $sourceClass,
+            $sourceClass->getIdentifierValues($owner)
+        );
+        $idHash = implode(' ', $id);
+
+        $this->eagerLoadingCollections[$name]['items'][$idHash] = $collection;
+    }
+
     /**
      * Gets the identity map of the UnitOfWork.
      *