Deprecate the doctrine binary (#9661)

* 2.11.x:
  ScalarColumnHydrator: prevent early-bail on falsy values (#9663)

.github/workflows/continuous-integration.yml

@@ -42,7 +42,7 @@ jobs:
         uses: "shivammathur/setup-php@v2"
         with:
           php-version: "${{ matrix.php-version }}"
-          extensions: "pdo, pdo_sqlite"
+          extensions: "apcu, pdo, pdo_sqlite"
           coverage: "pcov"
           ini-values: "zend.assertions=1"
 

.github/workflows/static-analysis.yml

@@ -21,7 +21,15 @@ jobs:
           - "8.1"
         dbal-version:
           - "default"
-          - "2.13"
+        persistence-version:
+          - "default"
+        include:
+          - php-version: "8.1"
+            dbal-version: "2.13"
+            persistence-version: "default"
+          - php-version: "8.1"
+            dbal-version: "default"
+            persistence-version: "2.5"
 
     steps:
       - name: "Checkout code"
@@ -37,6 +45,10 @@ jobs:
         run: "composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update"
         if: "${{ matrix.dbal-version != 'default' }}"
 
+      - name: "Require specific persistence version"
+        run: "composer require doctrine/persistence ^${{ matrix.persistence-version }} --no-update"
+        if: "${{ matrix.persistence-version != 'default' }}"
+
       - name: "Install dependencies with Composer"
         uses: "ramsey/composer-install@v1"
         with:
@@ -44,12 +56,16 @@ jobs:
 
       - name: "Run a static analysis with phpstan/phpstan"
         run: "vendor/bin/phpstan analyse"
-        if: "${{ matrix.dbal-version == 'default' }}"
+        if: "${{ matrix.dbal-version == 'default' && matrix.persistence-version == 'default'}}"
 
       - name: "Run a static analysis with phpstan/phpstan"
         run: "vendor/bin/phpstan analyse -c phpstan-dbal2.neon"
         if: "${{ matrix.dbal-version == '2.13' }}"
 
+      - name: "Run a static analysis with phpstan/phpstan"
+        run: "vendor/bin/phpstan analyse -c phpstan-persistence2.neon"
+        if: "${{ matrix.dbal-version == 'default' && matrix.persistence-version != 'default'}}"
+
   static-analysis-psalm:
     name: "Static Analysis with Psalm"
     runs-on: "ubuntu-20.04"

CONTRIBUTING.md

@@ -37,8 +37,7 @@ will have to run a composer installation in the project:
 ```sh
 git clone git@github.com:doctrine/orm.git
 cd orm
-curl -sS https://getcomposer.org/installer | php --
-./composer.phar install
+composer install
 ```
 
 To run the testsuite against another database, copy the ``phpunit.xml.dist``

README.md

@@ -3,6 +3,8 @@
 | [![Build status][3.0 image]][3.0] | [![Build status][2.12 image]][2.12] | [![Build status][2.11 image]][2.11] |
 | [![Coverage Status][3.0 coverage image]][3.0 coverage]| [![Coverage Status][2.12 coverage image]][2.12 coverage] | [![Coverage Status][2.11 coverage image]][2.11 coverage]  |
 
+[<h1 align="center">🇺🇦 UKRAINE NEEDS YOUR HELP NOW!</h1>](https://www.doctrine-project.org/stop-war.html)
+
 Doctrine 2 is an object-relational mapper (ORM) for PHP 7.1+ that provides transparent persistence
 for PHP objects. It sits on top of a powerful database abstraction layer (DBAL). One of its key features
 is the option to write database queries in a proprietary object oriented SQL dialect called Doctrine Query Language (DQL),
@@ -13,7 +15,7 @@ without requiring unnecessary code duplication.
 ## More resources:
 
 * [Website](http://www.doctrine-project.org)
-* [Documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/index.html)
+* [Documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/stable/index.html)
 
 
   [3.0 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.0.x

SECURITY.md

@@ -10,8 +10,8 @@ we cannot protect you from SQL injection.
 Please read the documentation chapter on Security in Doctrine DBAL and ORM to
 understand the assumptions we make.
 
-- [DBAL Security Page](https://www.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/security.html)
-- [ORM Security Page](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/security.html)
+- [DBAL Security Page](https://www.doctrine-project.org/projects/doctrine-dbal/en/stable/reference/security.html)
+- [ORM Security Page](https://www.doctrine-project.org/projects/doctrine-orm/en/stable/reference/security.html)
 
 If you find a Security bug in Doctrine, please report it on Jira and change the
 Security Level to "Security Issues". It will be visible to Doctrine Core

UPGRADE.md

@@ -1,3 +1,109 @@
+# Upgrade to 2.12
+
+## Deprecated the `doctrine` binary.
+
+The documentation explains how the console tools can be bootstrapped for
+standalone usage.
+
+The method `ConsoleRunner::printCliConfigTemplate()` is deprecated because it
+was only useful in the context of the `doctrine` binary.
+
+## Deprecate omitting `$class` argument to `ORMInvalidArgumentException::invalidIdentifierBindingEntity()`
+
+To make it easier to identify understand the cause for that exception, it is
+deprecated to omit the class name when calling
+`ORMInvalidArgumentException::invalidIdentifierBindingEntity()`.
+
+## Deprecate `Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper`
+
+Using a console helper to provide the ORM's console commands with one or
+multiple entity managers had been deprecated with 2.9 already. This leaves
+The `EntityManagerHelper` class with no purpose which is why it is now
+deprecated too. Applications that still rely on the `em` console helper, can
+easily recreate that class in their own codebase.
+
+## Deprecate custom repository classes that don't extend `EntityRepository`
+
+Although undocumented, it is currently possible to configure a custom repository
+class that implements `ObjectRepository` but does not extend the
+`EntityRepository` base class.
+
+This is now deprecated. Please extend `EntityRepository` instead.
+
+## Deprecated more APIs related to entity namespace aliases
+
+```diff
+-$config = $entityManager->getConfiguration();
+-$config->addEntityNamespace('CMS', 'My\App\Cms');
++use My\App\Cms\CmsUser;
+
+-$entityManager->getRepository('CMS:CmsUser');
++$entityManager->getRepository(CmsUser::class);
+```
+
+## BC Break: `AttributeDriver` and `AnnotationDriver` no longer extends parent class from `doctrine/persistence`
+
+Both these classes used to extend an abstract `AnnotationDriver` class defined
+in `doctrine/persistence`, and no longer do.
+
+## Deprecate `AttributeDriver::getReader()` and `AnnotationDriver::getReader()`
+
+That method was inherited from the abstract `AnnotationDriver` class of
+`doctrine/persistence`, and does not seem to serve any purpose.
+
+## Un-deprecate `Doctrine\ORM\Proxy\Proxy`
+
+Because no forward-compatible new proxy solution had been implemented yet, the
+current proxy mechanism is not considered deprecated anymore for the time
+being. This applies to the following interfaces/classes:
+
+* `Doctrine\ORM\Proxy\Proxy`
+* `Doctrine\ORM\Proxy\ProxyFactory`
+
+These methods have been un-deprecated:
+
+* `Doctrine\ORM\Configuration::getAutoGenerateProxyClasses()`
+* `Doctrine\ORM\Configuration::getProxyDir()`
+* `Doctrine\ORM\Configuration::getProxyNamespace()`
+
+Note that the `Doctrine\ORM\Proxy\Autoloader` remains deprecated and will be removed in 3.0.
+
+## Deprecate helper methods from `AbstractCollectionPersister`
+
+The following protected methods of
+`Doctrine\ORM\Cache\Persister\Collection\AbstractCollectionPersister`
+are not in use anymore and will be removed.
+
+* `evictCollectionCache()`
+* `evictElementCache()`
+
+## Deprecate `Doctrine\ORM\Query\TreeWalkerChainIterator`
+
+This class won't have a replacement.
+
+## Deprecate `OnClearEventArgs::getEntityClass()` and `OnClearEventArgs::clearsAllEntities()`
+
+These methods will be removed in 3.0 along with the ability to partially clear
+the entity manager.
+
+## Deprecate `Doctrine\ORM\Configuration::newDefaultAnnotationDriver`
+
+This functionality has been moved to the new `ORMSetup` class. Call
+`Doctrine\ORM\ORMSetup::createDefaultAnnotationDriver()` to create
+a new annotation driver.
+
+## Deprecate `Doctrine\ORM\Tools\Setup`
+
+In our effort to migrate from Doctrine Cache to PSR-6, the `Setup` class which
+accepted a Doctrine Cache instance in each method has been deprecated.
+
+The replacement is `Doctrine\ORM\ORMSetup` which accepts a PSR-6
+cache instead.
+
+## Deprecate `Doctrine\ORM\Cache\MultiGetRegion`
+
+The interface will be merged with `Doctrine\ORM\Cache\Region` in 3.0.
+
 # Upgrade to 2.11
 
 ## Rename `AbstractIdGenerator::generate()` to `generateId()`
@@ -289,8 +395,8 @@ If you would still like to perform batching operations over small `UnitOfWork`
 instances, it is suggested to follow these paths instead:
 
  * eagerly use `EntityManager#clear()` in conjunction with a specific second level
-   cache configuration (see http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/second-level-cache.html)
- * use an explicit change tracking policy (see http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/change-tracking-policies.html)
+   cache configuration (see http://docs.doctrine-project.org/projects/doctrine-orm/en/stable/reference/second-level-cache.html)
+ * use an explicit change tracking policy (see http://docs.doctrine-project.org/projects/doctrine-orm/en/stable/reference/change-tracking-policies.html)
 
 ## Deprecated `YAML` mapping drivers.
 

bin/doctrine-pear.php

@@ -1,5 +1,15 @@
 <?php
 
+fwrite(
+    STDERR,
+    '[Warning] The use of this script is discouraged. See'
+    . ' https://www.doctrine-project.org/projects/doctrine-orm/en/current/reference/tools.html#doctrine-console'
+    . ' for instructions on bootstrapping the console runner.'
+    . PHP_EOL
+);
+
+echo PHP_EOL . PHP_EOL;
+
 require_once 'Doctrine/Common/ClassLoader.php';
 
 $classLoader = new \Doctrine\Common\ClassLoader('Doctrine');

bin/doctrine.php

@@ -3,6 +3,16 @@
 use Symfony\Component\Console\Helper\HelperSet;
 use Doctrine\ORM\Tools\Console\ConsoleRunner;
 
+fwrite(
+    STDERR,
+    '[Warning] The use of this script is discouraged. See'
+    . ' https://www.doctrine-project.org/projects/doctrine-orm/en/current/reference/tools.html#doctrine-console'
+    . ' for instructions on bootstrapping the console runner.'
+    . PHP_EOL
+);
+
+echo PHP_EOL . PHP_EOL;
+
 $autoloadFiles = [
     __DIR__ . '/../vendor/autoload.php',
     __DIR__ . '/../../../autoload.php'

composer.json

@@ -31,19 +31,20 @@
         "doctrine/event-manager": "^1.1",
         "doctrine/inflector": "^1.4 || ^2.0",
         "doctrine/instantiator": "^1.3",
-        "doctrine/lexer": "^1.0",
-        "doctrine/persistence": "^2.2",
+        "doctrine/lexer": "^1.2.3",
+        "doctrine/persistence": "^2.4 || ^3",
         "psr/cache": "^1 || ^2 || ^3",
         "symfony/console": "^3.0 || ^4.0 || ^5.0 || ^6.0",
         "symfony/polyfill-php72": "^1.23",
-        "symfony/polyfill-php80": "^1.15"
+        "symfony/polyfill-php80": "^1.16"
     },
     "require-dev": {
         "doctrine/annotations": "^1.13",
         "doctrine/coding-standard": "^9.0",
         "phpbench/phpbench": "^0.16.10 || ^1.0",
-        "phpstan/phpstan": "1.4.6",
+        "phpstan/phpstan": "~1.4.10 || 1.5.0",
         "phpunit/phpunit": "^7.5 || ^8.5 || ^9.4",
+        "psr/log": "^1 || ^2 || ^3",
         "squizlabs/php_codesniffer": "3.6.2",
         "symfony/cache": "^4.4 || ^5.4 || ^6.0",
         "symfony/yaml": "^3.4 || ^4.0 || ^5.0 || ^6.0",

docs/en/conf.py

@@ -1,201 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Doctrine 2 ORM documentation build configuration file, created by
-# sphinx-quickstart on Fri Dec  3 18:10:24 2010.
-#
-# This file is execfile()d with the current directory set to its containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-import sys, os, datetime
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-sys.path.append(os.path.abspath('_exts'))
-
-# -- General configuration -----------------------------------------------------
-
-# Add any Sphinx extension module names here, as strings. They can be extensions
-# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['configurationblock']
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix of source filenames.
-source_suffix = '.rst'
-
-# The encoding of source files.
-#source_encoding = 'utf-8'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = u'Doctrine 2 ORM'
-copyright = u'2010-%y, Doctrine Project Team'.format(datetime.date.today)
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '2'
-# The full version, including alpha/beta/rc tags.
-release = '2'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-language = 'en'
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#today = ''
-# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
-
-# List of documents that shouldn't be included in the build.
-#unused_docs = []
-
-# List of directories, relative to source directory, that shouldn't be searched
-# for source files.
-exclude_trees = ['_build']
-
-# The reST default role (used for this markup: `text`) to use for all documents.
-#default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-show_authors = True
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
-
-
-# -- Options for HTML output ---------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  Major themes that come with
-# Sphinx are currently 'default' and 'sphinxdoc'.
-html_theme = 'doctrine'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = ['_theme']
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#html_logo = None
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#html_additional_pages = {}
-
-# If false, no module index is generated.
-#html_use_modindex = True
-
-# If false, no index is generated.
-#html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
-
-# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = ''
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'Doctrine2ORMdoc'
-
-
-# -- Options for LaTeX output --------------------------------------------------
-
-# The paper size ('letter' or 'a4').
-#latex_paper_size = 'letter'
-
-# The font size ('10pt', '11pt' or '12pt').
-#latex_font_size = '10pt'
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title, author, documentclass [howto/manual]).
-latex_documents = [
-  ('index', 'Doctrine2ORM.tex', u'Doctrine 2 ORM Documentation',
-   u'Doctrine Project Team', 'manual'),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#latex_logo = None
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#latex_use_parts = False
-
-# Additional stuff for the LaTeX preamble.
-#latex_preamble = ''
-
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
-
-# If false, no module index is generated.
-#latex_use_modindex = True
-
-primary_domain = "dcorm"
-
-def linkcode_resolve(domain, info):
-    if domain == 'dcorm':
-        return 'http://'
-    return None

docs/en/cookbook/dql-user-defined-functions.rst

@@ -131,8 +131,8 @@ generation of a DateDiff FunctionNode somewhere in the AST of the
 dql statement.
 
 The ``ArithmeticPrimary`` method call is the most common
-denominator of valid EBNF tokens taken from the
-`DQL EBNF grammar <https://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/dql-doctrine-query-language.html#ebnf>`_
+denominator of valid EBNF tokens taken from the :ref:`DQL EBNF grammar
+<dql_ebnf_grammar>`
 that matches our requirements for valid input into the DateDiff Dql
 function. Picking the right tokens for your methods is a tricky
 business, but the EBNF grammar is pretty helpful finding it, as is

docs/en/cookbook/implementing-wakeup-or-clone.rst

@@ -3,8 +3,8 @@ Implementing Wakeup or Clone
 
 .. sectionauthor:: Roman Borschel (roman@code-factory.org)
 
-As explained in the
-`restrictions for entity classes in the manual <https://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/architecture.html#entities>`_,
+As explained in the :ref:`restrictions for entity classes in the manual
+<terminology_entities>`,
 it is usually not allowed for an entity to implement ``__wakeup``
 or ``__clone``, because Doctrine makes special use of them.
 However, it is quite easy to make use of these methods in a safe

docs/en/reference/advanced-configuration.rst

@@ -12,6 +12,7 @@ steps of configuration.
 
     use Doctrine\ORM\Configuration;
     use Doctrine\ORM\EntityManager;
+    use Doctrine\ORM\ORMSetup;
     use Symfony\Component\Cache\Adapter\ArrayAdapter;
     use Symfony\Component\Cache\Adapter\PhpFilesAdapter;
 
@@ -27,7 +28,7 @@ steps of configuration.
 
     $config = new Configuration;
     $config->setMetadataCache($metadataCache);
-    $driverImpl = $config->newDefaultAnnotationDriver('/path/to/lib/MyProject/Entities');
+    $driverImpl = ORMSetup::createDefaultAnnotationDriver('/path/to/lib/MyProject/Entities');
     $config->setMetadataDriverImpl($driverImpl);
     $config->setQueryCache($queryCache);
     $config->setProxyDir('/path/to/myproject/lib/MyProject/Proxies');
@@ -129,7 +130,9 @@ the ``Doctrine\ORM\Configuration``:
 .. code-block:: php
 
     <?php
-    $driverImpl = $config->newDefaultAnnotationDriver('/path/to/lib/MyProject/Entities');
+    use Doctrine\ORM\ORMSetup;
+
+    $driverImpl = ORMSetup::createDefaultAnnotationDriver('/path/to/lib/MyProject/Entities');
     $config->setMetadataDriverImpl($driverImpl);
 
 The path information to the entities is required for the annotation
@@ -454,18 +457,5 @@ Setting up the Console
 ----------------------
 
 Doctrine uses the Symfony Console component for generating the command
-line interface. You can take a look at the ``vendor/bin/doctrine.php``
-script and the ``Doctrine\ORM\Tools\Console\ConsoleRunner`` command
-for inspiration how to setup the cli.
-
-In general the required code looks like this:
-
-.. code-block:: php
-
-    <?php
-    $cli = new Application('Doctrine Command Line Interface', \Doctrine\ORM\Version::VERSION);
-    $cli->setCatchExceptions(true);
-    $cli->setHelperSet($helperSet);
-    Doctrine\ORM\Tools\Console\ConsoleRunner::addCommands($cli);
-    $cli->run();
-
+line interface. You can take a look at the
+:doc:`tools chapter <../reference/tools>` for inspiration how to setup the cli.

docs/en/reference/architecture.rst

@@ -66,6 +66,8 @@ The root namespace of the ORM package is ``Doctrine\ORM``.
 Terminology
 -----------
 
+.. _terminology_entities:
+
 Entities
 ~~~~~~~~
 

docs/en/reference/configuration.rst

@@ -41,8 +41,8 @@ access point to ORM functionality provided by Doctrine.
     // bootstrap.php
     require_once "vendor/autoload.php";
 
-    use Doctrine\ORM\Tools\Setup;
     use Doctrine\ORM\EntityManager;
+    use Doctrine\ORM\ORMSetup;
 
     $paths = array("/path/to/entity-files");
     $isDevMode = false;
@@ -55,16 +55,21 @@ access point to ORM functionality provided by Doctrine.
         'dbname'   => 'foo',
     );
 
-    $config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode);
+    $config = ORMSetup::createAnnotationMetadataConfiguration($paths, $isDevMode);
     $entityManager = EntityManager::create($dbParams, $config);
 
+.. note::
+
+    The ``ORMSetup`` class has been introduced with ORM 2.12. It's predecessor ``Setup`` is deprecated and will
+    be removed in version 3.0.
+
 Or if you prefer XML:
 
 .. code-block:: php
 
     <?php
     $paths = array("/path/to/xml-mappings");
-    $config = Setup::createXMLMetadataConfiguration($paths, $isDevMode);
+    $config = ORMSetup::createXMLMetadataConfiguration($paths, $isDevMode);
     $entityManager = EntityManager::create($dbParams, $config);
 
 Or if you prefer YAML:
@@ -73,7 +78,7 @@ Or if you prefer YAML:
 
     <?php
     $paths = array("/path/to/yml-mappings");
-    $config = Setup::createYAMLMetadataConfiguration($paths, $isDevMode);
+    $config = ORMSetup::createYAMLMetadataConfiguration($paths, $isDevMode);
     $entityManager = EntityManager::create($dbParams, $config);
 
 .. note::
@@ -83,44 +88,29 @@ Or if you prefer YAML:
     
         "symfony/yaml": "*"
 
-Inside the ``Setup`` methods several assumptions are made:
+Inside the ``ORMSetup`` methods several assumptions are made:
 
--  If ``$isDevMode`` is true caching is done in memory with the ``ArrayCache``. Proxy objects are recreated on every request.
--  If ``$isDevMode`` is false, check for Caches in the order APC, Xcache, Memcache (127.0.0.1:11211), Redis (127.0.0.1:6379) unless `$cache` is passed as fourth argument.
+-  If ``$isDevMode`` is true caching is done in memory with the ``ArrayAdapter``. Proxy objects are recreated on every request.
+-  If ``$isDevMode`` is false, check for Caches in the order APCu, Redis (127.0.0.1:6379), Memcache (127.0.0.1:11211) unless `$cache` is passed as fourth argument.
 -  If ``$isDevMode`` is false, set then proxy classes have to be explicitly created through the command line.
 -  If third argument `$proxyDir` is not set, use the systems temporary directory.
 
+.. note::
+
+    In order to have ``ORMSetup`` configure the cache automatically, the library ``symfony/cache``
+    has to be installed as a dependency.
+
 If you want to configure Doctrine in more detail, take a look at the :doc:`Advanced Configuration <reference/advanced-configuration>` section.
 
 .. note::
 
     You can learn more about the database connection configuration in the
-    `Doctrine DBAL connection configuration reference <https://docs.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/configuration.html>`_.
+    `Doctrine DBAL connection configuration reference <https://docs.doctrine-project.org/projects/doctrine-dbal/en/stable/reference/configuration.html>`_.
 
 Setting up the Commandline Tool
 -------------------------------
 
 Doctrine ships with a number of command line tools that are very helpful
-during development. You can call this command from the Composer binary
-directory:
-
-.. code-block:: sh
-
-    $ php vendor/bin/doctrine
-
-You need to register your applications EntityManager to the console tool
-to make use of the tasks by creating a ``cli-config.php`` file with the
-following content:
-
-.. code-block:: php
-
-    <?php
-    use Doctrine\ORM\Tools\Console\ConsoleRunner;
-
-    // replace with file to your own project bootstrap
-    require_once 'bootstrap.php';
-
-    // replace with mechanism to retrieve EntityManager in your app
-    $entityManager = GetEntityManager();
-
-    return ConsoleRunner::createHelperSet($entityManager);
+during development. In order to make use of them, create an executable PHP
+script in your project as described in the
+:doc:`tools chapter <../reference/tools>`.

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

@@ -1531,6 +1531,8 @@ Given that there are 10 users and corresponding addresses in the database the ex
     a one-by-one basis once they are accessed.
 
 
+.. _dql_ebnf_grammar:
+
 EBNF
 ----
 

docs/en/reference/events.rst

@@ -142,33 +142,33 @@ Events Overview
 | Event                                                           | Dispatched by         | Lifecycle | Passed                              |
 |                                                                 |                       | Callback  | Argument                            |
 +=================================================================+=======================+===========+=====================================+
-| :ref:`preRemove<reference-events-pre-remove>`                   | ``$em->remove()``     | Yes       | `_LifecycleEventArgs`_              |
+| :ref:`preRemove<reference-events-pre-remove>`                   | ``$em->remove()``     | Yes       | `LifecycleEventArgs`_               |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postRemove<reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `_LifecycleEventArgs`_              |
+| :ref:`postRemove<reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `LifecycleEventArgs`_               |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`prePersist<reference-events-pre-persist>`                 | ``$em->persist()``    | Yes       | `_LifecycleEventArgs`_              |
+| :ref:`prePersist<reference-events-pre-persist>`                 | ``$em->persist()``    | Yes       | `LifecycleEventArgs`_               |
 |                                                                 | on *initial* persist  |           |                                     |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postPersist<reference-events-post-update-remove-persist>` | ``$em->flush()``      | Yes       | `_LifecycleEventArgs`_              |
+| :ref:`postPersist<reference-events-post-update-remove-persist>` | ``$em->flush()``      | Yes       | `LifecycleEventArgs`_               |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`preUpdate<reference-events-pre-update>`                   | ``$em->flush()``      | Yes       | `_PreUpdateEventArgs`_              |
+| :ref:`preUpdate<reference-events-pre-update>`                   | ``$em->flush()``      | Yes       | `PreUpdateEventArgs`_               |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postUpdate<reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `_LifecycleEventArgs`_              |
+| :ref:`postUpdate<reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `LifecycleEventArgs`_               |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postLoad<reference-events-post-load>`                     | Loading from database | Yes       | `_LifecycleEventArgs`_              |
+| :ref:`postLoad<reference-events-post-load>`                     | Loading from database | Yes       | `LifecycleEventArgs`_               |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`loadClassMetadata<reference-events-load-class-metadata>`  | Loading of mapping    | No        | `_LoadClassMetadataEventArgs`       |
+| :ref:`loadClassMetadata<reference-events-load-class-metadata>`  | Loading of mapping    | No        | `LoadClassMetadataEventArgs`_       |
 |                                                                 | metadata              |           |                                     |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| ``onClassMetadataNotFound``                                     | ``MappingException``  | No        | `_OnClassMetadataNotFoundEventArgs` |
+| ``onClassMetadataNotFound``                                     | ``MappingException``  | No        | `OnClassMetadataNotFoundEventArgs`_ |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`preFlush<reference-events-pre-flush>`                     | ``$em->flush()``      | Yes       | `_PreFlushEventArgs`_               |
+| :ref:`preFlush<reference-events-pre-flush>`                     | ``$em->flush()``      | Yes       | `PreFlushEventArgs`_                |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`onFlush<reference-events-on-flush>`                       | ``$em->flush()``      | No        | `_OnFlushEventArgs`                 |
+| :ref:`onFlush<reference-events-on-flush>`                       | ``$em->flush()``      | No        | `OnFlushEventArgs`_                 |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postFlush<reference-events-post-flush>`                   | ``$em->flush()``      | No        | `_PostFlushEventArgs`               |
+| :ref:`postFlush<reference-events-post-flush>`                   | ``$em->flush()``      | No        | `PostFlushEventArgs`_               |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`onClear<reference-events-on-clear>`                       | ``$em->clear()``      | No        | `_OnClearEventArgs`                 |
+| :ref:`onClear<reference-events-on-clear>`                       | ``$em->clear()``      | No        | `OnClearEventArgs`_                 |
 +-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
 
 Naming convention

docs/en/reference/tools.rst

@@ -7,24 +7,10 @@ Doctrine Console
 The Doctrine Console is a Command Line Interface tool for simplifying common
 administration tasks during the development of a project that uses ORM.
 
-Take a look at the :doc:`Installation and Configuration <configuration>`
-chapter for more information how to setup the console command.
+For the following examples, we will set up the CLI as ``bin/doctrine``.
 
-Display Help Information
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-Type ``php vendor/bin/doctrine`` on the command line and you should see an
-overview of the available commands or use the --help flag to get
-information on the available commands. If you want to know more
-about the use of generate entities for example, you can call:
-
-.. code-block:: php
-
-    $> php vendor/bin/doctrine orm:generate-entities --help
-
-
-Configuration
-~~~~~~~~~~~~~
+Setting Up the Console
+~~~~~~~~~~~~~~~~~~~~~~
 
 Whenever the ``doctrine`` command line tool is invoked, it can
 access all Commands that were registered by a developer. There is no
@@ -34,25 +20,33 @@ Doctrine DBAL and ORM. If you want to use additional commands you
 have to register them yourself.
 
 All the commands of the Doctrine Console require access to the
-``EntityManager``. You have to inject it into the console application with
-``ConsoleRunner::createHelperSet``. Whenever you invoke the Doctrine
-binary, it searches the current directory for the file ``cli-config.php``.
-This file contains the project-specific configuration.
+``EntityManager``. You have to inject it into the console application.
 
-Here is an example of a the project-specific ``cli-config.php``:
+Here is an example of a the project-specific ``bin/doctrine`` binary.
 
 .. code-block:: php
 
+    #!/usr/bin/env php
     <?php
-    use Doctrine\ORM\Tools\Console\ConsoleRunner;
 
-    // replace this with the path to your own project bootstrap file.
+    use Doctrine\ORM\Tools\Console\ConsoleRunner;
+    use Doctrine\ORM\Tools\Console\EntityManagerProvider\SingleManagerProvider;
+
+    // replace with path to your own project bootstrap file
     require_once 'bootstrap.php';
 
     // replace with mechanism to retrieve EntityManager in your app
     $entityManager = GetEntityManager();
 
-    return ConsoleRunner::createHelperSet($entityManager);
+    $commands = [
+        // If you want to add your own custom console commands,
+        // you can do so here.
+    ];
+
+    ConsoleRunner::run(
+        new SingleManagerProvider($entityManager),
+        $commands
+    );
 
 .. note::
 
@@ -60,6 +54,18 @@ Here is an example of a the project-specific ``cli-config.php``:
     and use their facilities to access the Doctrine EntityManager and
     Connection Resources.
 
+Display Help Information
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Type ``php bin/doctrine`` on the command line and you should see an
+overview of the available commands or use the ``--help`` flag to get
+information on the available commands. If you want to know more
+about the use of generate entities for example, you can call:
+
+::
+
+    $> php bin/doctrine orm:generate-entities --help
+
 Command Overview
 ~~~~~~~~~~~~~~~~
 
@@ -189,38 +195,35 @@ To create the schema use the ``create`` command:
 
 .. code-block:: php
 
-    $ php doctrine orm:schema-tool:create
+    $ php bin/doctrine orm:schema-tool:create
 
 To drop the schema use the ``drop`` command:
 
 .. code-block:: php
 
-    $ php doctrine orm:schema-tool:drop
+    $ php bin/doctrine orm:schema-tool:drop
 
 If you want to drop and then recreate the schema then use both
 options:
 
 .. code-block:: php
 
-    $ php doctrine orm:schema-tool:drop
-    $ php doctrine orm:schema-tool:create
+    $ php bin/doctrine orm:schema-tool:drop
+    $ php bin/doctrine orm:schema-tool:create
 
 As you would think, if you want to update your schema use the
 ``update`` command:
 
 .. code-block:: php
 
-    $ php doctrine orm:schema-tool:update
+    $ php bin/doctrine orm:schema-tool:update
 
 All of the above commands also accept a ``--dump-sql`` option that
 will output the SQL for the ran operation.
 
 .. code-block:: php
 
-    $ php doctrine orm:schema-tool:create --dump-sql
-
-Before using the orm:schema-tool commands, remember to configure
-your cli-config.php properly.
+    $ php bin/doctrine orm:schema-tool:create --dump-sql
 
 Entity Generation
 -----------------
@@ -229,9 +232,9 @@ Generate entity classes and method stubs from your mapping information.
 
 .. code-block:: php
 
-    $ php doctrine orm:generate-entities
-    $ php doctrine orm:generate-entities --update-entities
-    $ php doctrine orm:generate-entities --regenerate-entities
+    $ php bin/doctrine orm:generate-entities
+    $ php bin/doctrine orm:generate-entities --update-entities
+    $ php bin/doctrine orm:generate-entities --regenerate-entities
 
 This command is not suited for constant usage. It is a little helper and does
 not support all the mapping edge cases very well. You still have to put work
@@ -316,7 +319,7 @@ convert to and the path to generate it:
 
 .. code-block:: php
 
-    $ php doctrine orm:convert-mapping xml /path/to/mapping-path-converted-to-xml
+    $ php bin/doctrine orm:convert-mapping xml /path/to/mapping-path-converted-to-xml
 
 Reverse Engineering
 -------------------
@@ -366,7 +369,7 @@ You can also reverse engineer a database using the
 
 .. code-block:: php
 
-    $ php doctrine orm:convert-mapping --from-database yml /path/to/mapping-path-converted-to-yml
+    $ php bin/doctrine orm:convert-mapping --from-database yml /path/to/mapping-path-converted-to-yml
 
 .. note::
 
@@ -393,6 +396,11 @@ You can either use the Doctrine Command Line Tool:
 
     doctrine orm:validate-schema
 
+If the validation fails, you can change the verbosity level to
+check the detected errors:
+
+    doctrine orm:validate-schema -v
+
 Or you can trigger the validation manually:
 
 .. code-block:: php

docs/en/tutorials/getting-started.rst

@@ -137,8 +137,8 @@ step:
 
     <?php
     // bootstrap.php
-    use Doctrine\ORM\Tools\Setup;
     use Doctrine\ORM\EntityManager;
+    use Doctrine\ORM\ORMSetup;
 
     require_once "vendor/autoload.php";
 
@@ -147,10 +147,10 @@ step:
     $proxyDir = null;
     $cache = null;
     $useSimpleAnnotationReader = false;
-    $config = Setup::createAnnotationMetadataConfiguration(array(__DIR__."/src"), $isDevMode, $proxyDir, $cache, $useSimpleAnnotationReader);
-    // or if you prefer yaml or XML
-    // $config = Setup::createXMLMetadataConfiguration(array(__DIR__."/config/xml"), $isDevMode);
-    // $config = Setup::createYAMLMetadataConfiguration(array(__DIR__."/config/yaml"), $isDevMode);
+    $config = ORMSetup::createAnnotationMetadataConfiguration(array(__DIR__."/src"), $isDevMode, $proxyDir, $cache, $useSimpleAnnotationReader);
+    // or if you prefer YAML or XML
+    // $config = ORMSetup::createXMLMetadataConfiguration(array(__DIR__."/config/xml"), $isDevMode);
+    // $config = ORMSetup::createYAMLMetadataConfiguration(array(__DIR__."/config/yaml"), $isDevMode);
 
     // database configuration parameters
     $conn = array(
@@ -173,7 +173,7 @@ The ``require_once`` statement sets up the class autoloading for Doctrine and
 its dependencies using Composer's autoloader.
 
 The second block consists of the instantiation of the ORM
-``Configuration`` object using the Setup helper. It assumes a bunch
+``Configuration`` object using the ``ORMSetup`` helper. It assumes a bunch
 of defaults that you don't have to bother about for now. You can
 read up on the configuration details in the
 :doc:`reference chapter on configuration <../reference/configuration>`.
@@ -191,22 +191,35 @@ Generating the Database Schema
 
 Doctrine has a command-line interface that allows you to access the SchemaTool,
 a component that can generate a relational database schema based entirely on the
-defined entity classes and their metadata. For this tool to work, a
-``cli-config.php`` file must exist in the project root directory:
+defined entity classes and their metadata. For this tool to work, you need to
+create an executable console script as described in the
+:doc:`tools chapter <../reference/tools>`.
+
+If you created the ``bootstrap.php`` file as described in the previous section,
+that script could look like this:
 
 .. code-block:: php
 
+    #!/usr/bin/env php
     <?php
-    // cli-config.php
-    require_once "bootstrap.php";
+    // bin/doctrine
 
-    return \Doctrine\ORM\Tools\Console\ConsoleRunner::createHelperSet($entityManager);
+    use Doctrine\ORM\Tools\Console\ConsoleRunner;
+    use Doctrine\ORM\Tools\Console\EntityManagerProvider\SingleManagerProvider;
 
-Now call the Doctrine command-line tool:
+    // Adjust this path to your actual bootstrap.php
+    require __DIR__ . 'path/to/your/bootstrap.php';
+
+    ConsoleRunner::run(
+        new SingleManagerProvider($entityManager)
+    );
+
+In the following examples, we will assume that this script has been created as
+``bin/doctrine``.
 
 ::
 
-    $ vendor/bin/doctrine orm:schema-tool:create
+    $ php bin/doctrine orm:schema-tool:create
 
 Since we haven't added any entity metadata in ``src`` yet, you'll see a message
 stating "No Metadata Classes to process." In the next section, we'll create a
@@ -218,14 +231,14 @@ You can easily recreate the database using the following commands:
 
 ::
 
-    $ vendor/bin/doctrine orm:schema-tool:drop --force
-    $ vendor/bin/doctrine orm:schema-tool:create
+    $ php bin/doctrine orm:schema-tool:drop --force
+    $ php bin/doctrine orm:schema-tool:create
 
 Or you can use the update functionality:
 
 ::
 
-    $ vendor/bin/doctrine orm:schema-tool:update --force
+    $ php bin/doctrine orm:schema-tool:update --force
 
 The updating of databases uses a diff algorithm for a given
 database schema. This is a cornerstone of the ``Doctrine\DBAL`` package,
@@ -571,7 +584,7 @@ let's update the database schema:
 
 ::
 
-    $ vendor/bin/doctrine orm:schema-tool:update --force --dump-sql
+    $ php bin/doctrine orm:schema-tool:update --force --dump-sql
 
 Specifying both flags ``--force`` and ``--dump-sql`` will cause the DDL
 statements to be executed and then printed to the screen.
@@ -1268,7 +1281,7 @@ class that holds the owning sides.
 Update your database schema by running:
 ::
 
-    $ vendor/bin/doctrine orm:schema-tool:update --force
+    $ php bin/doctrine orm:schema-tool:update --force
 
 
 Implementing more Requirements

lib/Doctrine/ORM/AbstractQuery.php

@@ -4,11 +4,13 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM;
 
+use BackedEnum;
 use Countable;
 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;
@@ -424,15 +426,20 @@ abstract class AbstractQuery
             return $value->name;
         }
 
+        if ($value instanceof BackedEnum) {
+            return $value->value;
+        }
+
         if (! is_object($value)) {
             return $value;
         }
 
         try {
+            $class = ClassUtils::getClass($value);
             $value = $this->_em->getUnitOfWork()->getSingleIdentifierValue($value);
 
             if ($value === null) {
-                throw ORMInvalidArgumentException::invalidIdentifierBindingEntity();
+                throw ORMInvalidArgumentException::invalidIdentifierBindingEntity($class);
             }
         } catch (MappingException | ORMMappingException $e) {
             /* Silence any mapping exceptions. These can occur if the object in

lib/Doctrine/ORM/Cache.php

@@ -141,6 +141,8 @@ interface Cache
      * Evicts all cached query results under the given name, or default query cache if the region name is NULL.
      *
      * @param string|null $regionName The cache name associated to the queries being cached.
+     *
+     * @return void
      */
     public function evictQueryRegion($regionName = null);
 

lib/Doctrine/ORM/Cache/AssociationCacheEntry.php

@@ -10,20 +10,26 @@ namespace Doctrine\ORM\Cache;
 class AssociationCacheEntry implements CacheEntry
 {
     /**
+     * The entity identifier
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string, mixed> The entity identifier
+     * @var array<string, mixed>
      */
     public $identifier;
 
     /**
+     * The entity class name
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string The entity class name
+     * @var string
+     * @psalm-var class-string
      */
     public $class;
 
     /**
      * @param string               $class      The entity class.
      * @param array<string, mixed> $identifier The entity identifier.
+     * @psalm-param class-string $class
      */
     public function __construct($class, array $identifier)
     {

lib/Doctrine/ORM/Cache/CacheException.php

@@ -25,6 +25,8 @@ class CacheException extends ORMException
     }
 
     /**
+     * @deprecated This method is not used anymore.
+     *
      * @param string $entityName
      *
      * @return CacheException
@@ -45,6 +47,8 @@ class CacheException extends ORMException
     }
 
     /**
+     * @deprecated This method is not used anymore.
+     *
      * @param string $entityName
      * @param string $field
      *

lib/Doctrine/ORM/Cache/CacheFactory.php

@@ -31,9 +31,7 @@ interface CacheFactory
     /**
      * Build a collection persister for the given relation mapping.
      *
-     * @param EntityManagerInterface $em        The entity manager.
-     * @param CollectionPersister    $persister The collection persister that will be cached.
-     * @param mixed[]                $mapping   The association mapping.
+     * @param mixed[] $mapping The association mapping.
      *
      * @return CachedCollectionPersister
      */
@@ -42,8 +40,7 @@ interface CacheFactory
     /**
      * Build a query cache based on the given region name
      *
-     * @param EntityManagerInterface $em         The Entity manager.
-     * @param string                 $regionName The region name.
+     * @param string|null $regionName The region name.
      *
      * @return QueryCache The built query cache.
      */
@@ -52,9 +49,6 @@ interface CacheFactory
     /**
      * Build an entity hydrator
      *
-     * @param EntityManagerInterface $em       The Entity manager.
-     * @param ClassMetadata          $metadata The entity metadata.
-     *
      * @return EntityHydrator The built entity hydrator.
      */
     public function buildEntityHydrator(EntityManagerInterface $em, ClassMetadata $metadata);
@@ -62,8 +56,7 @@ interface CacheFactory
     /**
      * Build a collection hydrator
      *
-     * @param EntityManagerInterface $em      The Entity manager.
-     * @param mixed[]                $mapping The association mapping.
+     * @param mixed[] $mapping The association mapping.
      *
      * @return CollectionHydrator The built collection hydrator.
      */

lib/Doctrine/ORM/Cache/CacheKey.php

@@ -11,8 +11,10 @@ namespace Doctrine\ORM\Cache;
 abstract class CacheKey
 {
     /**
+     * Unique identifier
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string Unique identifier
+     * @var string
      */
     public $hash;
 }

lib/Doctrine/ORM/Cache/CollectionCacheEntry.php

@@ -10,8 +10,10 @@ namespace Doctrine\ORM\Cache;
 class CollectionCacheEntry implements CacheEntry
 {
     /**
+     * The list of entity identifiers hold by the collection
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var CacheKey[] The list of entity identifiers hold by the collection
+     * @var CacheKey[]
      */
     public $identifiers;
 

lib/Doctrine/ORM/Cache/CollectionCacheKey.php

@@ -15,20 +15,27 @@ use function strtolower;
 class CollectionCacheKey extends CacheKey
 {
     /**
+     * The owner entity identifier
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string, mixed> The owner entity identifier
+     * @var array<string, mixed>
      */
     public $ownerIdentifier;
 
     /**
+     * The owner entity class
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string The owner entity class
+     * @var string
+     * @psalm-var class-string
      */
     public $entityClass;
 
     /**
+     * The association name
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string The association name
+     * @var string
      */
     public $association;
 
@@ -36,6 +43,7 @@ class CollectionCacheKey extends CacheKey
      * @param string               $entityClass     The entity class.
      * @param string               $association     The field name that represents the association.
      * @param array<string, mixed> $ownerIdentifier The identifier of the owning entity.
+     * @psalm-param class-string $entityClass
      */
     public function __construct($entityClass, $association, array $ownerIdentifier)
     {

lib/Doctrine/ORM/Cache/CollectionHydrator.php

@@ -14,8 +14,6 @@ use Doctrine\ORM\PersistentCollection;
 interface CollectionHydrator
 {
     /**
-     * @param ClassMetadata            $metadata   The entity metadata.
-     * @param CollectionCacheKey       $key        The cached collection key.
      * @param array|mixed[]|Collection $collection The collection.
      *
      * @return CollectionCacheEntry
@@ -23,11 +21,6 @@ interface CollectionHydrator
     public function buildCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, $collection);
 
     /**
-     * @param ClassMetadata        $metadata   The owning entity metadata.
-     * @param CollectionCacheKey   $key        The cached collection key.
-     * @param CollectionCacheEntry $entry      The cached collection entry.
-     * @param PersistentCollection $collection The collection to load the cache into.
-     *
      * @return mixed[]|null
      */
     public function loadCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, CollectionCacheEntry $entry, PersistentCollection $collection);

lib/Doctrine/ORM/Cache/DefaultCache.php

@@ -29,7 +29,10 @@ class DefaultCache implements Cache
      /** @var CacheFactory */
     private $cacheFactory;
 
-    /** @var QueryCache[] */
+    /**
+     * @var QueryCache[]
+     * @psalm-var array<string, QueryCache>
+     */
     private $queryCaches = [];
 
     /** @var QueryCache|null */
@@ -260,8 +263,7 @@ class DefaultCache implements Cache
     }
 
     /**
-     * @param ClassMetadata $metadata   The entity metadata.
-     * @param mixed         $identifier The entity identifier.
+     * @param mixed $identifier The entity identifier.
      */
     private function buildEntityCacheKey(ClassMetadata $metadata, $identifier): EntityCacheKey
     {
@@ -273,9 +275,7 @@ class DefaultCache implements Cache
     }
 
     /**
-     * @param ClassMetadata $metadata        The entity metadata.
-     * @param string        $association     The field name that represents the association.
-     * @param mixed         $ownerIdentifier The identifier of the owning entity.
+     * @param mixed $ownerIdentifier The identifier of the owning entity.
      */
     private function buildCollectionCacheKey(
         ClassMetadata $metadata,
@@ -290,18 +290,20 @@ class DefaultCache implements Cache
     }
 
     /**
-     * @param ClassMetadata $metadata   The entity metadata.
-     * @param mixed         $identifier The entity identifier.
+     * @param mixed $identifier The entity identifier.
      *
      * @return array<string, mixed>
      */
     private function toIdentifierArray(ClassMetadata $metadata, $identifier): array
     {
-        if (is_object($identifier) && $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($identifier))) {
-            $identifier = $this->uow->getSingleIdentifierValue($identifier);
+        if (is_object($identifier)) {
+            $class = ClassUtils::getClass($identifier);
+            if ($this->em->getMetadataFactory()->hasMetadataFor($class)) {
+                $identifier = $this->uow->getSingleIdentifierValue($identifier);
 
-            if ($identifier === null) {
-                throw ORMInvalidArgumentException::invalidIdentifierBindingEntity();
+                if ($identifier === null) {
+                    throw ORMInvalidArgumentException::invalidIdentifierBindingEntity($class);
+                }
             }
         }
 

lib/Doctrine/ORM/Cache/DefaultQueryCache.php

@@ -384,7 +384,8 @@ class DefaultQueryCache implements QueryCache
     /**
      * @param object $entity
      *
-     * @return array<object>|object
+     * @return mixed[]|object|null
+     * @psalm-return list<mixed>|object|null
      */
     private function getAssociationValue(
         ResultSetMapping $rsm,
@@ -411,10 +412,11 @@ class DefaultQueryCache implements QueryCache
     }
 
     /**
-     * @param mixed        $value
-     * @param array<mixed> $path
+     * @param mixed $value
+     * @psalm-param array<array-key, array{field: string, class: string}> $path
      *
-     * @return mixed
+     * @return mixed[]|object|null
+     * @psalm-return list<mixed>|object|null
      */
     private function getAssociationPathValue($value, array $path)
     {

lib/Doctrine/ORM/Cache/EntityCacheEntry.php

@@ -14,14 +14,18 @@ use function array_map;
 class EntityCacheEntry implements CacheEntry
 {
     /**
+     * The entity map data
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string,mixed> The entity map data
+     * @var array<string,mixed>
      */
     public $data;
 
     /**
+     * The entity class name
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string The entity class name
+     * @var string
      * @psalm-var class-string
      */
     public $class;

lib/Doctrine/ORM/Cache/EntityCacheKey.php

@@ -15,20 +15,26 @@ use function strtolower;
 class EntityCacheKey extends CacheKey
 {
     /**
+     * The entity identifier
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string, mixed> The entity identifier
+     * @var array<string, mixed>
      */
     public $identifier;
 
     /**
+     * The entity class name
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string The entity class name
+     * @var string
+     * @psalm-var class-string
      */
     public $entityClass;
 
     /**
      * @param string               $entityClass The entity class name. In a inheritance hierarchy it should always be the root entity class.
      * @param array<string, mixed> $identifier  The entity identifier
+     * @psalm-param class-string $entityClass
      */
     public function __construct($entityClass, array $identifier)
     {

lib/Doctrine/ORM/Cache/Logging/CacheLogger.php

@@ -18,6 +18,8 @@ interface CacheLogger
      *
      * @param string         $regionName The name of the cache region.
      * @param EntityCacheKey $key        The cache key of the entity.
+     *
+     * @return void
      */
     public function entityCachePut($regionName, EntityCacheKey $key);
 
@@ -26,6 +28,8 @@ interface CacheLogger
      *
      * @param string         $regionName The name of the cache region.
      * @param EntityCacheKey $key        The cache key of the entity.
+     *
+     * @return void
      */
     public function entityCacheHit($regionName, EntityCacheKey $key);
 
@@ -34,6 +38,8 @@ interface CacheLogger
      *
      * @param string         $regionName The name of the cache region.
      * @param EntityCacheKey $key        The cache key of the entity.
+     *
+     * @return void
      */
     public function entityCacheMiss($regionName, EntityCacheKey $key);
 
@@ -42,6 +48,8 @@ interface CacheLogger
      *
      * @param string             $regionName The name of the cache region.
      * @param CollectionCacheKey $key        The cache key of the collection.
+     *
+     * @return void
      */
     public function collectionCachePut($regionName, CollectionCacheKey $key);
 
@@ -50,6 +58,8 @@ interface CacheLogger
      *
      * @param string             $regionName The name of the cache region.
      * @param CollectionCacheKey $key        The cache key of the collection.
+     *
+     * @return void
      */
     public function collectionCacheHit($regionName, CollectionCacheKey $key);
 
@@ -58,6 +68,8 @@ interface CacheLogger
      *
      * @param string             $regionName The name of the cache region.
      * @param CollectionCacheKey $key        The cache key of the collection.
+     *
+     * @return void
      */
     public function collectionCacheMiss($regionName, CollectionCacheKey $key);
 
@@ -66,6 +78,8 @@ interface CacheLogger
      *
      * @param string        $regionName The name of the cache region.
      * @param QueryCacheKey $key        The cache key of the query.
+     *
+     * @return void
      */
     public function queryCachePut($regionName, QueryCacheKey $key);
 
@@ -74,6 +88,8 @@ interface CacheLogger
      *
      * @param string        $regionName The name of the cache region.
      * @param QueryCacheKey $key        The cache key of the query.
+     *
+     * @return void
      */
     public function queryCacheHit($regionName, QueryCacheKey $key);
 
@@ -82,6 +98,8 @@ interface CacheLogger
      *
      * @param string        $regionName The name of the cache region.
      * @param QueryCacheKey $key        The cache key of the query.
+     *
+     * @return void
      */
     public function queryCacheMiss($regionName, QueryCacheKey $key);
 }

lib/Doctrine/ORM/Cache/Logging/CacheLoggerChain.php

@@ -10,7 +10,7 @@ use Doctrine\ORM\Cache\QueryCacheKey;
 
 class CacheLoggerChain implements CacheLogger
 {
-    /** @var array<CacheLogger> */
+    /** @var array<string, CacheLogger> */
     private $loggers = [];
 
     /**
@@ -34,7 +34,7 @@ class CacheLoggerChain implements CacheLogger
     }
 
     /**
-     * @return array<CacheLogger>
+     * @return array<string, CacheLogger>
      */
     public function getLoggers()
     {

lib/Doctrine/ORM/Cache/Logging/StatisticsCacheLogger.php

@@ -15,13 +15,13 @@ use function array_sum;
  */
 class StatisticsCacheLogger implements CacheLogger
 {
-    /** @var int[] */
+    /** @var array<string, int> */
     private $cacheMissCountMap = [];
 
-    /** @var int[] */
+    /** @var array<string, int> */
     private $cacheHitCountMap = [];
 
-    /** @var int[] */
+    /** @var array<string, int> */
     private $cachePutCountMap = [];
 
     /**
@@ -29,9 +29,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function collectionCacheMiss($regionName, CollectionCacheKey $key)
     {
-        $this->cacheMissCountMap[$regionName] = isset($this->cacheMissCountMap[$regionName])
-            ? $this->cacheMissCountMap[$regionName] + 1
-            : 1;
+        $this->cacheMissCountMap[$regionName]
+            = ($this->cacheMissCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -39,9 +38,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function collectionCacheHit($regionName, CollectionCacheKey $key)
     {
-        $this->cacheHitCountMap[$regionName] = isset($this->cacheHitCountMap[$regionName])
-            ? $this->cacheHitCountMap[$regionName] + 1
-            : 1;
+        $this->cacheHitCountMap[$regionName]
+            = ($this->cacheHitCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -49,9 +47,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function collectionCachePut($regionName, CollectionCacheKey $key)
     {
-        $this->cachePutCountMap[$regionName] = isset($this->cachePutCountMap[$regionName])
-            ? $this->cachePutCountMap[$regionName] + 1
-            : 1;
+        $this->cachePutCountMap[$regionName]
+            = ($this->cachePutCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -59,9 +56,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function entityCacheMiss($regionName, EntityCacheKey $key)
     {
-        $this->cacheMissCountMap[$regionName] = isset($this->cacheMissCountMap[$regionName])
-            ? $this->cacheMissCountMap[$regionName] + 1
-            : 1;
+        $this->cacheMissCountMap[$regionName]
+            = ($this->cacheMissCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -69,9 +65,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function entityCacheHit($regionName, EntityCacheKey $key)
     {
-        $this->cacheHitCountMap[$regionName] = isset($this->cacheHitCountMap[$regionName])
-            ? $this->cacheHitCountMap[$regionName] + 1
-            : 1;
+        $this->cacheHitCountMap[$regionName]
+            = ($this->cacheHitCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -79,9 +74,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function entityCachePut($regionName, EntityCacheKey $key)
     {
-        $this->cachePutCountMap[$regionName] = isset($this->cachePutCountMap[$regionName])
-            ? $this->cachePutCountMap[$regionName] + 1
-            : 1;
+        $this->cachePutCountMap[$regionName]
+            = ($this->cachePutCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -89,9 +83,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function queryCacheHit($regionName, QueryCacheKey $key)
     {
-        $this->cacheHitCountMap[$regionName] = isset($this->cacheHitCountMap[$regionName])
-            ? $this->cacheHitCountMap[$regionName] + 1
-            : 1;
+        $this->cacheHitCountMap[$regionName]
+            = ($this->cacheHitCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -99,9 +92,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function queryCacheMiss($regionName, QueryCacheKey $key)
     {
-        $this->cacheMissCountMap[$regionName] = isset($this->cacheMissCountMap[$regionName])
-            ? $this->cacheMissCountMap[$regionName] + 1
-            : 1;
+        $this->cacheMissCountMap[$regionName]
+            = ($this->cacheMissCountMap[$regionName] ?? 0) + 1;
     }
 
     /**
@@ -109,9 +101,8 @@ class StatisticsCacheLogger implements CacheLogger
      */
     public function queryCachePut($regionName, QueryCacheKey $key)
     {
-        $this->cachePutCountMap[$regionName] = isset($this->cachePutCountMap[$regionName])
-            ? $this->cachePutCountMap[$regionName] + 1
-            : 1;
+        $this->cachePutCountMap[$regionName]
+            = ($this->cachePutCountMap[$regionName] ?? 0) + 1;
     }
 
     /**

lib/Doctrine/ORM/Cache/MultiGetRegion.php

@@ -8,6 +8,8 @@ namespace Doctrine\ORM\Cache;
  * Defines a region that supports multi-get reading.
  *
  * With one method call we can get multiple items.
+ *
+ * @deprecated Implement {@see Region} instead.
  */
 interface MultiGetRegion
 {

lib/Doctrine/ORM/Cache/Persister/CachedPersister.php

@@ -13,11 +13,15 @@ interface CachedPersister
 {
     /**
      * Perform whatever processing is encapsulated here after completion of the transaction.
+     *
+     * @return void
      */
     public function afterTransactionComplete();
 
     /**
      * Perform whatever processing is encapsulated here after completion of the rolled-back.
+     *
+     * @return void
      */
     public function afterTransactionRolledBack();
 

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

@@ -7,6 +7,7 @@ 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;
 use Doctrine\ORM\Cache\EntityCacheKey;
@@ -108,7 +109,7 @@ abstract class AbstractCollectionPersister implements CachedCollectionPersister
     }
 
     /**
-     * @return object[]|null
+     * {@inheritdoc}
      */
     public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key)
     {
@@ -224,10 +225,18 @@ abstract class AbstractCollectionPersister implements CachedCollectionPersister
     /**
      * Clears cache entries related to the current collection
      *
+     * @deprecated This method is not used anymore.
+     *
      * @return void
      */
     protected function evictCollectionCache(PersistentCollection $collection)
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/9512',
+            'The method %s() is deprecated and will be removed without replacement.'
+        );
+
         $key = new CollectionCacheKey(
             $this->sourceEntity->rootEntityName,
             $this->association['fieldName'],
@@ -242,13 +251,22 @@ abstract class AbstractCollectionPersister implements CachedCollectionPersister
     }
 
     /**
+     * @deprecated This method is not used anymore.
+     *
      * @param string $targetEntity
      * @param object $element
+     * @psalm-param class-string $targetEntity
      *
      * @return void
      */
     protected function evictElementCache($targetEntity, $element)
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/9512',
+            'The method %s() is deprecated and will be removed without replacement.'
+        );
+
         $targetPersister = $this->uow->getEntityPersister($targetEntity);
         assert($targetPersister instanceof CachedEntityPersister);
         $targetRegion = $targetPersister->getCacheRegion();

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

@@ -29,14 +29,14 @@ interface CachedCollectionPersister extends CachedPersister, CollectionPersister
     /**
      * Loads a collection from cache
      *
-     * @return PersistentCollection|null
+     * @return mixed[]|null
      */
     public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key);
 
     /**
      * Stores a collection into cache
      *
-     * @param array|mixed[]|Collection $elements
+     * @param mixed[]|Collection $elements
      *
      * @return void
      */

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

@@ -15,10 +15,7 @@ use function spl_object_id;
 class ReadWriteCachedCollectionPersister extends AbstractCollectionPersister
 {
     /**
-     * @param CollectionPersister    $persister   The collection persister that will be cached.
-     * @param ConcurrentRegion       $region      The collection region.
-     * @param EntityManagerInterface $em          The entity manager.
-     * @param mixed[]                $association The association mapping.
+     * @param mixed[] $association The association mapping.
      */
     public function __construct(CollectionPersister $persister, ConcurrentRegion $region, EntityManagerInterface $em, array $association)
     {

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

@@ -251,8 +251,8 @@ abstract class AbstractEntityPersister implements CachedEntityPersister
      * @param string            $query
      * @param string[]|Criteria $criteria
      * @param string[]          $orderBy
-     * @param int               $limit
-     * @param int               $offset
+     * @param int|null          $limit
+     * @param int|null          $offset
      *
      * @return string
      */

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

@@ -15,12 +15,6 @@ use Doctrine\ORM\Persisters\Entity\EntityPersister;
  */
 class ReadWriteCachedEntityPersister extends AbstractEntityPersister
 {
-    /**
-     * @param EntityPersister        $persister The entity persister to cache.
-     * @param ConcurrentRegion       $region    The entity cache region.
-     * @param EntityManagerInterface $em        The entity manager.
-     * @param ClassMetadata          $class     The entity metadata.
-     */
     public function __construct(EntityPersister $persister, ConcurrentRegion $region, EntityManagerInterface $em, ClassMetadata $class)
     {
         parent::__construct($persister, $region, $em, $class);

lib/Doctrine/ORM/Cache/QueryCacheEntry.php

@@ -12,20 +12,24 @@ use function microtime;
 class QueryCacheEntry implements CacheEntry
 {
     /**
+     * List of entity identifiers
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string, mixed> List of entity identifiers
+     * @var array<string, mixed>
      */
     public $result;
 
     /**
+     * Time creation of this cache entry
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var float Time creation of this cache entry
+     * @var float
      */
     public $time;
 
     /**
      * @param array<string, mixed> $result
-     * @param float                $time
+     * @param float|null           $time
      */
     public function __construct($result, $time = null)
     {

lib/Doctrine/ORM/Cache/QueryCacheKey.php

@@ -12,8 +12,10 @@ use Doctrine\ORM\Cache;
 class QueryCacheKey extends CacheKey
 {
     /**
+     * Cache key lifetime
+     *
      * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var int Cache key lifetime
+     * @var int
      */
     public $lifetime;
 

lib/Doctrine/ORM/Cache/TimestampCacheEntry.php

@@ -18,7 +18,7 @@ class TimestampCacheEntry implements CacheEntry
     public $time;
 
     /**
-     * @param float $time
+     * @param float|null $time
      */
     public function __construct($time = null)
     {

lib/Doctrine/ORM/Cache/TimestampRegion.php

@@ -10,9 +10,9 @@ namespace Doctrine\ORM\Cache;
 interface TimestampRegion extends Region
 {
     /**
-     * Update an specific key into the cache region.
+     * Update a specific key into the cache region.
      *
-     * @param CacheKey $key The key of the item to update the timestamp.
+     * @return void
      *
      * @throws LockException Indicates a problem accessing the region.
      */

lib/Doctrine/ORM/Configuration.php

@@ -12,6 +12,7 @@ use Doctrine\Common\Cache\ArrayCache;
 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\Common\Proxy\AbstractProxyFactory;
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Cache\CacheConfiguration;
@@ -23,6 +24,7 @@ use Doctrine\ORM\Cache\Exception\QueryCacheUsesNonPersistentCache;
 use Doctrine\ORM\Exception\InvalidEntityRepository;
 use Doctrine\ORM\Exception\NamedNativeQueryNotFound;
 use Doctrine\ORM\Exception\NamedQueryNotFound;
+use Doctrine\ORM\Exception\NotSupported;
 use Doctrine\ORM\Exception\ProxyClassesAlwaysRegenerating;
 use Doctrine\ORM\Exception\UnknownEntityNamespace;
 use Doctrine\ORM\Internal\Hydration\AbstractHydrator;
@@ -34,6 +36,8 @@ use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
 use Doctrine\ORM\Mapping\EntityListenerResolver;
 use Doctrine\ORM\Mapping\NamingStrategy;
 use Doctrine\ORM\Mapping\QuoteStrategy;
+use Doctrine\ORM\Proxy\ProxyFactory;
+use Doctrine\ORM\Query\Filter\SQLFilter;
 use Doctrine\ORM\Query\ResultSetMapping;
 use Doctrine\ORM\Repository\DefaultRepositoryFactory;
 use Doctrine\ORM\Repository\RepositoryFactory;
@@ -41,9 +45,9 @@ use Doctrine\Persistence\Mapping\Driver\MappingDriver;
 use Doctrine\Persistence\ObjectRepository;
 use LogicException;
 use Psr\Cache\CacheItemPoolInterface;
-use ReflectionClass;
 
 use function class_exists;
+use function is_a;
 use function method_exists;
 use function sprintf;
 use function strtolower;
@@ -54,6 +58,8 @@ use function trim;
  * It combines all configuration options from DBAL & ORM.
  *
  * Internal note: When adding a new configuration option just write a getter/setter pair.
+ *
+ * @psalm-import-type AutogenerateMode from ProxyFactory
  */
 class Configuration extends \Doctrine\DBAL\Configuration
 {
@@ -75,10 +81,6 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /**
      * Gets the directory where Doctrine generates any necessary proxy class files.
      *
-     * @deprecated 2.7 We're switch to `ocramius/proxy-manager` and this method isn't applicable any longer
-     *
-     * @see https://github.com/Ocramius/ProxyManager
-     *
      * @return string|null
      */
     public function getProxyDir()
@@ -89,11 +91,8 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /**
      * Gets the strategy for automatically generating proxy classes.
      *
-     * @deprecated 2.7 We're switch to `ocramius/proxy-manager` and this method isn't applicable any longer
-     *
-     * @see https://github.com/Ocramius/ProxyManager
-     *
      * @return int Possible values are constants of Doctrine\Common\Proxy\AbstractProxyFactory.
+     * @psalm-return AutogenerateMode
      */
     public function getAutoGenerateProxyClasses()
     {
@@ -116,10 +115,6 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /**
      * Gets the namespace where proxy classes reside.
      *
-     * @deprecated 2.7 We're switch to `ocramius/proxy-manager` and this method isn't applicable any longer
-     *
-     * @see https://github.com/Ocramius/ProxyManager
-     *
      * @return string|null
      */
     public function getProxyNamespace()
@@ -156,6 +151,8 @@ class Configuration extends \Doctrine\DBAL\Configuration
      * Adds a new default annotation driver with a correctly configured annotation reader. If $useSimpleAnnotationReader
      * is true, the notation `@Entity` will work, otherwise, the notation `@ORM\Entity` will be supported.
      *
+     * @deprecated Use {@see ORMSetup::createDefaultAnnotationDriver()} instead.
+     *
      * @param string|string[] $paths
      * @param bool            $useSimpleAnnotationReader
      * @psalm-param string|list<string> $paths
@@ -164,6 +161,14 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function newDefaultAnnotationDriver($paths = [], $useSimpleAnnotationReader = true)
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/9443',
+            '%s is deprecated, call %s::createDefaultAnnotationDriver() instead.',
+            __METHOD__,
+            ORMSetup::class
+        );
+
         if (! class_exists(AnnotationReader::class)) {
             throw new LogicException(sprintf(
                 'The annotation metadata driver cannot be enabled because the "doctrine/annotations" library'
@@ -193,6 +198,8 @@ class Configuration extends \Doctrine\DBAL\Configuration
     }
 
     /**
+     * @deprecated No replacement planned.
+     *
      * Adds a namespace under a certain alias.
      *
      * @param string $alias
@@ -202,6 +209,21 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function addEntityNamespace($alias, $namespace)
     {
+        if (class_exists(PersistentObject::class)) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/issues/8818',
+                'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
+                $alias
+            );
+        } else {
+            NotSupported::createForPersistence3(sprintf(
+                'Using short namespace alias "%s" by calling %s',
+                $alias,
+                __METHOD__
+            ));
+        }
+
         $this->_attributes['entityNamespaces'][$alias] = $namespace;
     }
 
@@ -548,7 +570,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
             throw QueryCacheUsesNonPersistentCache::fromDriver($queryCacheImpl);
         }
 
-        if ($this->getAutoGenerateProxyClasses()) {
+        if ($this->getAutoGenerateProxyClasses() !== AbstractProxyFactory::AUTOGENERATE_NEVER) {
             throw ProxyClassesAlwaysRegenerating::create();
         }
 
@@ -794,6 +816,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
      *
      * @param string $name      The name of the filter.
      * @param string $className The class name of the filter.
+     * @psalm-param class-string<SQLFilter> $className
      *
      * @return void
      */
@@ -809,7 +832,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
      *
      * @return string|null The class name of the filter, or null if it is not
      *  defined.
-     * @psalm-return ?class-string
+     * @psalm-return class-string<SQLFilter>|null
      */
     public function getFilterClassName($name)
     {
@@ -820,6 +843,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
      * Sets default repository class.
      *
      * @param string $className
+     * @psalm-param class-string<EntityRepository> $className
      *
      * @return void
      *
@@ -827,12 +851,20 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function setDefaultRepositoryClassName($className)
     {
-        $reflectionClass = new ReflectionClass($className);
-
-        if (! $reflectionClass->implementsInterface(ObjectRepository::class)) {
+        if (! class_exists($className) || ! is_a($className, ObjectRepository::class, true)) {
             throw InvalidEntityRepository::fromClassName($className);
         }
 
+        if (! is_a($className, EntityRepository::class, true)) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/9533',
+                'Configuring %s as default repository class is deprecated because it does not extend %s.',
+                $className,
+                EntityRepository::class
+            );
+        }
+
         $this->_attributes['defaultRepositoryClassName'] = $className;
     }
 
@@ -840,7 +872,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
      * Get default repository class.
      *
      * @return string
-     * @psalm-return class-string
+     * @psalm-return class-string<EntityRepository>
      */
     public function getDefaultRepositoryClassName()
     {

lib/Doctrine/ORM/Decorator/EntityManagerDecorator.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Decorator;
 
 use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\EntityRepository;
 use Doctrine\ORM\Query\ResultSetMapping;
 use Doctrine\Persistence\ObjectManagerDecorator;
 
@@ -43,6 +44,28 @@ abstract class EntityManagerDecorator extends ObjectManagerDecorator implements
         return $this->wrapped->getExpressionBuilder();
     }
 
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-param class-string<T> $className
+     *
+     * @psalm-return EntityRepository<T>
+     *
+     * @template T of object
+     */
+    public function getRepository($className)
+    {
+        return $this->wrapped->getRepository($className);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getClassMetadata($className)
+    {
+        return $this->wrapped->getClassMetadata($className);
+    }
+
     /**
      * {@inheritdoc}
      */

lib/Doctrine/ORM/EntityManager.php

@@ -4,9 +4,11 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM;
 
+use BackedEnum;
 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;
@@ -17,6 +19,8 @@ use Doctrine\ORM\Exception\InvalidHydrationMode;
 use Doctrine\ORM\Exception\MismatchedEventManager;
 use Doctrine\ORM\Exception\MissingIdentifierField;
 use Doctrine\ORM\Exception\MissingMappingDriverImplementation;
+use Doctrine\ORM\Exception\NotSupported;
+use Doctrine\ORM\Exception\ORMException;
 use Doctrine\ORM\Exception\UnrecognizedIdentifierFields;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
@@ -32,6 +36,7 @@ use Throwable;
 
 use function array_keys;
 use function call_user_func;
+use function class_exists;
 use function get_debug_type;
 use function gettype;
 use function is_array;
@@ -40,6 +45,7 @@ use function is_object;
 use function is_string;
 use function ltrim;
 use function sprintf;
+use function strpos;
 
 /**
  * The EntityManager is the central access point to ORM functionality.
@@ -59,7 +65,7 @@ use function sprintf;
  *     $entityManager = EntityManager::create($dbParams, $config);
  *
  * For more information see
- * {@link http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/configuration.html}
+ * {@link http://docs.doctrine-project.org/projects/doctrine-orm/en/stable/reference/configuration.html}
  *
  * You should never attempt to inherit from the EntityManager: Inheritance
  * is not a valid extension point for the EntityManager. Instead you
@@ -432,11 +438,14 @@ use function sprintf;
         }
 
         foreach ($id as $i => $value) {
-            if (is_object($value) && $this->metadataFactory->hasMetadataFor(ClassUtils::getClass($value))) {
-                $id[$i] = $this->unitOfWork->getSingleIdentifierValue($value);
+            if (is_object($value)) {
+                $className = ClassUtils::getClass($value);
+                if ($this->metadataFactory->hasMetadataFor($className)) {
+                    $id[$i] = $this->unitOfWork->getSingleIdentifierValue($value);
 
-                if ($id[$i] === null) {
-                    throw ORMInvalidArgumentException::invalidIdentifierBindingEntity();
+                    if ($id[$i] === null) {
+                        throw ORMInvalidArgumentException::invalidIdentifierBindingEntity($className);
+                    }
                 }
             }
         }
@@ -448,7 +457,12 @@ use function sprintf;
                 throw MissingIdentifierField::fromFieldAndClass($identifier, $class->name);
             }
 
-            $sortedId[$identifier] = $id[$identifier];
+            if ($id[$identifier] instanceof BackedEnum) {
+                $sortedId[$identifier] = $id[$identifier]->value;
+            } else {
+                $sortedId[$identifier] = $id[$identifier];
+            }
+
             unset($id[$identifier]);
         }
 
@@ -778,11 +792,39 @@ use function sprintf;
      * @return ObjectRepository|EntityRepository The repository class.
      * @psalm-return EntityRepository<T>
      *
-     * @template T
+     * @template T of object
      */
     public function getRepository($entityName)
     {
-        return $this->repositoryFactory->getRepository($this, $entityName);
+        if (strpos($entityName, ':') !== false) {
+            if (class_exists(PersistentObject::class)) {
+                Deprecation::trigger(
+                    'doctrine/orm',
+                    'https://github.com/doctrine/orm/issues/8818',
+                    'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
+                    $entityName
+                );
+            } else {
+                NotSupported::createForPersistence3(sprintf(
+                    'Using short namespace alias "%s" when calling %s',
+                    $entityName,
+                    __METHOD__
+                ));
+            }
+        }
+
+        $repository = $this->repositoryFactory->getRepository($this, $entityName);
+        if (! $repository instanceof EntityRepository) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/9533',
+                'Not returning an instance of %s from %s::getRepository() is deprecated and will cause a TypeError on 3.0.',
+                EntityRepository::class,
+                get_debug_type($this->repositoryFactory)
+            );
+        }
+
+        return $repository;
     }
 
     /**

lib/Doctrine/ORM/EntityManagerInterface.php

@@ -9,6 +9,7 @@ use DateTimeInterface;
 use Doctrine\Common\EventManager;
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\LockMode;
+use Doctrine\ORM\Exception\ORMException;
 use Doctrine\ORM\Internal\Hydration\AbstractHydrator;
 use Doctrine\ORM\Proxy\ProxyFactory;
 use Doctrine\ORM\Query\Expr;
@@ -31,7 +32,7 @@ interface EntityManagerInterface extends ObjectManager
      *
      * @psalm-return EntityRepository<T>
      *
-     * @template T
+     * @template T of object
      */
     public function getRepository($className);
 

lib/Doctrine/ORM/EntityRepository.php

@@ -5,22 +5,25 @@ declare(strict_types=1);
 namespace Doctrine\ORM;
 
 use BadMethodCallException;
-use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\Collections\AbstractLazyCollection;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\Common\Collections\Selectable;
+use Doctrine\Common\Persistence\PersistentObject;
 use Doctrine\DBAL\LockMode;
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\Inflector\Inflector;
 use Doctrine\Inflector\InflectorFactory;
+use Doctrine\ORM\Exception\NotSupported;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Query\ResultSetMappingBuilder;
 use Doctrine\ORM\Repository\Exception\InvalidMagicMethodCall;
 use Doctrine\Persistence\ObjectRepository;
 
 use function array_slice;
+use function class_exists;
 use function lcfirst;
 use function sprintf;
-use function strpos;
+use function str_starts_with;
 use function substr;
 
 /**
@@ -30,28 +33,42 @@ use function substr;
  * This class is designed for inheritance and users can subclass this class to
  * write their own repositories with business-specific methods to locate entities.
  *
- * @template T
+ * @template T of object
  * @template-implements Selectable<int,T>
  * @template-implements ObjectRepository<T>
  */
 class EntityRepository implements ObjectRepository, Selectable
 {
-    /** @var string */
+    /**
+     * @internal This property will be private in 3.0, call {@see getEntityName()} instead.
+     *
+     * @var string
+     * @psalm-var class-string<T>
+     */
     protected $_entityName;
 
-    /** @var EntityManagerInterface */
+    /**
+     * @internal This property will be private in 3.0, call {@see getEntityManager()} instead.
+     *
+     * @var EntityManagerInterface
+     */
     protected $_em;
 
-    /** @var ClassMetadata */
+    /**
+     * @internal This property will be private in 3.0, call {@see getClassMetadata()} instead.
+     *
+     * @var ClassMetadata
+     * @psalm-var ClassMetadata<T>
+     */
     protected $_class;
 
-    /** @var Inflector */
+    /** @var Inflector|null */
     private static $inflector;
 
     /**
-     * Initializes a new <tt>EntityRepository</tt>.
+     * @psalm-param ClassMetadata<T> $class
      */
-    public function __construct(EntityManagerInterface $em, Mapping\ClassMetadata $class)
+    public function __construct(EntityManagerInterface $em, ClassMetadata $class)
     {
         $this->_entityName = $class->name;
         $this->_em         = $em;
@@ -61,8 +78,8 @@ class EntityRepository implements ObjectRepository, Selectable
     /**
      * Creates a new QueryBuilder instance that is prepopulated for this entity name.
      *
-     * @param string $alias
-     * @param string $indexBy The index for the from.
+     * @param string      $alias
+     * @param string|null $indexBy The index for the from.
      *
      * @return QueryBuilder
      */
@@ -154,6 +171,13 @@ class EntityRepository implements ObjectRepository, Selectable
             __METHOD__
         );
 
+        if (! class_exists(PersistentObject::class)) {
+            throw NotSupported::createForPersistence3(sprintf(
+                'Partial clearing of entities for class %s',
+                $this->_class->rootEntityName
+            ));
+        }
+
         $this->_em->clear($this->_class->rootEntityName);
     }
 
@@ -246,15 +270,15 @@ class EntityRepository implements ObjectRepository, Selectable
      */
     public function __call($method, $arguments)
     {
-        if (strpos($method, 'findBy') === 0) {
+        if (str_starts_with($method, 'findBy')) {
             return $this->resolveMagicCall('findBy', substr($method, 6), $arguments);
         }
 
-        if (strpos($method, 'findOneBy') === 0) {
+        if (str_starts_with($method, 'findOneBy')) {
             return $this->resolveMagicCall('findOneBy', substr($method, 9), $arguments);
         }
 
-        if (strpos($method, 'countBy') === 0) {
+        if (str_starts_with($method, 'countBy')) {
             return $this->resolveMagicCall('count', substr($method, 7), $arguments);
         }
 
@@ -267,6 +291,7 @@ class EntityRepository implements ObjectRepository, Selectable
 
     /**
      * @return string
+     * @psalm-return class-string<T>
      */
     protected function getEntityName()
     {
@@ -274,7 +299,7 @@ class EntityRepository implements ObjectRepository, Selectable
     }
 
     /**
-     * @return string
+     * {@inheritdoc}
      */
     public function getClassName()
     {
@@ -290,7 +315,8 @@ class EntityRepository implements ObjectRepository, Selectable
     }
 
     /**
-     * @return Mapping\ClassMetadata
+     * @return ClassMetadata
+     * @psalm-return ClassMetadata<T>
      */
     protected function getClassMetadata()
     {
@@ -301,8 +327,8 @@ class EntityRepository implements ObjectRepository, Selectable
      * Select all elements from a selectable that match the expression and
      * return a new collection containing these elements.
      *
-     * @return LazyCriteriaCollection
-     * @psalm-return Collection<int, T>
+     * @return AbstractLazyCollection
+     * @psalm-return AbstractLazyCollection<int, T>&Selectable<int, T>
      */
     public function matching(Criteria $criteria)
     {

lib/Doctrine/ORM/Event/LifecycleEventArgs.php

@@ -11,7 +11,7 @@ use Doctrine\Persistence\Event\LifecycleEventArgs as BaseLifecycleEventArgs;
  * Lifecycle Events are triggered by the UnitOfWork during lifecycle transitions
  * of entities.
  *
- * @link   www.doctrine-project.org
+ * @extends BaseLifecycleEventArgs<EntityManagerInterface>
  */
 class LifecycleEventArgs extends BaseLifecycleEventArgs
 {

lib/Doctrine/ORM/Event/LoadClassMetadataEventArgs.php

@@ -11,8 +11,7 @@ use Doctrine\Persistence\Event\LoadClassMetadataEventArgs as BaseLoadClassMetada
 /**
  * Class that holds event arguments for a loadMetadata event.
  *
- * @method __construct(ClassMetadata $classMetadata, EntityManagerInterface $objectManager)
- * @method ClassMetadata getClassMetadata()
+ * @extends BaseLoadClassMetadataEventArgs<ClassMetadata<object>, EntityManagerInterface>
  */
 class LoadClassMetadataEventArgs extends BaseLoadClassMetadataEventArgs
 {

lib/Doctrine/ORM/Event/OnClassMetadataNotFoundEventArgs.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Event;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\Persistence\Event\ManagerEventArgs;
 use Doctrine\Persistence\Mapping\ClassMetadata;
 use Doctrine\Persistence\ObjectManager;
@@ -13,6 +14,8 @@ use Doctrine\Persistence\ObjectManager;
  *
  * This object is mutable by design, allowing callbacks having access to it to set the
  * found metadata in it, and therefore "cancelling" a `onClassMetadataNotFound` event
+ *
+ * @extends ManagerEventArgs<EntityManagerInterface>
  */
 class OnClassMetadataNotFoundEventArgs extends ManagerEventArgs
 {
@@ -23,7 +26,8 @@ class OnClassMetadataNotFoundEventArgs extends ManagerEventArgs
     private $foundMetadata;
 
     /**
-     * @param string $className
+     * @param string                 $className
+     * @param EntityManagerInterface $objectManager
      */
     public function __construct($className, ObjectManager $objectManager)
     {

lib/Doctrine/ORM/Event/OnClearEventArgs.php

@@ -42,6 +42,8 @@ class OnClearEventArgs extends EventArgs
     /**
      * Name of the entity class that is cleared, or empty if all are cleared.
      *
+     * @deprecated Clearing the entity manager partially is deprecated. This method will be removed in 3.0.
+     *
      * @return string|null
      */
     public function getEntityClass()
@@ -52,6 +54,8 @@ class OnClearEventArgs extends EventArgs
     /**
      * Checks if event clears all entities.
      *
+     * @deprecated Clearing the entity manager partially is deprecated. This method will be removed in 3.0.
+     *
      * @return bool
      */
     public function clearsAllEntities()

lib/Doctrine/ORM/Exception/InvalidEntityRepository.php

@@ -4,14 +4,14 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Exception;
 
-use Doctrine\Persistence\ObjectRepository;
+use Doctrine\ORM\EntityRepository;
 
 final class InvalidEntityRepository extends ORMException implements ConfigurationException
 {
     public static function fromClassName(string $className): self
     {
         return new self(
-            "Invalid repository class '" . $className . "'. It must be a " . ObjectRepository::class . '.'
+            "Invalid repository class '" . $className . "'. It must be a " . EntityRepository::class . '.'
         );
     }
 }

lib/Doctrine/ORM/Exception/NotSupported.php

@@ -4,6 +4,8 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Exception;
 
+use function sprintf;
+
 final class NotSupported extends ORMException
 {
     public static function create(): self
@@ -11,8 +13,29 @@ final class NotSupported extends ORMException
         return new self('This behaviour is (currently) not supported by Doctrine 2');
     }
 
-    public static function createForDbal3(): self
+    public static function createForDbal3(string $context): self
     {
-        return new self('Feature was deprecated in doctrine/dbal 2.x and is not supported by installed doctrine/dbal:3.x, please see the doctrine/deprecations logs for new alternative approaches.');
+        return new self(sprintf(
+            <<<'EXCEPTION'
+Context: %s
+Problem: Feature was deprecated in doctrine/dbal 2.x and is not supported by installed doctrine/dbal:3.x
+Solution: See the doctrine/deprecations logs for new alternative approaches.
+EXCEPTION
+            ,
+            $context
+        ));
+    }
+
+    public static function createForPersistence3(string $context): self
+    {
+        return new self(sprintf(
+            <<<'EXCEPTION'
+Context: %s
+Problem: Feature was deprecated in doctrine/persistence 2.x and is not supported by installed doctrine/persistence:3.x
+Solution: See the doctrine/deprecations logs for new alternative approaches.
+EXCEPTION
+            ,
+            $context
+        ));
     }
 }

lib/Doctrine/ORM/Exception/UnknownEntityNamespace.php

@@ -6,6 +6,9 @@ namespace Doctrine\ORM\Exception;
 
 use function sprintf;
 
+/**
+ * @deprecated No replacement planned.
+ */
 final class UnknownEntityNamespace extends ORMException implements ConfigurationException
 {
     public static function fromNamespaceAlias(string $entityNamespaceAlias): self

lib/Doctrine/ORM/Id/UuidGenerator.php

@@ -11,6 +11,7 @@ use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Exception\NotSupported;
 
 use function method_exists;
+use function sprintf;
 
 /**
  * Represents an ID generator that uses the database UUID expression
@@ -29,7 +30,10 @@ class UuidGenerator extends AbstractIdGenerator
         );
 
         if (! method_exists(AbstractPlatform::class, 'getGuidExpression')) {
-            throw NotSupported::createForDbal3();
+            throw NotSupported::createForDbal3(sprintf(
+                'Using the database to generate a UUID through %s',
+                self::class
+            ));
         }
     }
 

lib/Doctrine/ORM/Internal/Hydration/AbstractHydrator.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Internal\Hydration;
 
+use BackedEnum;
 use Doctrine\DBAL\Driver\ResultStatement;
 use Doctrine\DBAL\ForwardCompatibility\Result as ForwardCompatibilityResult;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
@@ -27,6 +28,7 @@ use function count;
 use function end;
 use function get_debug_type;
 use function in_array;
+use function is_array;
 use function sprintf;
 
 /**
@@ -429,7 +431,20 @@ abstract class AbstractHydrator
                     $type  = $cacheKeyInfo['type'];
                     $value = $type->convertToPHPValue($value, $this->_platform);
 
+                    // Reimplement ReflectionEnumProperty code
+                    if ($value !== null && isset($cacheKeyInfo['enumType'])) {
+                        $enumType = $cacheKeyInfo['enumType'];
+                        if (is_array($value)) {
+                            $value = array_map(static function ($value) use ($enumType): BackedEnum {
+                                return $enumType::from($value);
+                            }, $value);
+                        } else {
+                            $value = $enumType::from($value);
+                        }
+                    }
+
                     $rowData['scalars'][$fieldName] = $value;
+
                     break;
 
                 //case (isset($cacheKeyInfo['isMetaColumn'])):
@@ -572,6 +587,7 @@ abstract class AbstractHydrator
                     'fieldName' => $this->_rsm->scalarMappings[$key],
                     'type'      => Type::getType($this->_rsm->typeMappings[$key]),
                     'dqlAlias'  => '',
+                    'enumType'  => $this->_rsm->enumMappings[$key] ?? null,
                 ];
 
             case isset($this->_rsm->scalarMappings[$key]):
@@ -579,6 +595,7 @@ abstract class AbstractHydrator
                     'isScalar'  => true,
                     'fieldName' => $this->_rsm->scalarMappings[$key],
                     'type'      => Type::getType($this->_rsm->typeMappings[$key]),
+                    'enumType'  => $this->_rsm->enumMappings[$key] ?? null,
                 ];
 
             case isset($this->_rsm->metaMappings[$key]):

lib/Doctrine/ORM/Internal/Hydration/ObjectHydrator.php

@@ -394,8 +394,11 @@ class ObjectHydrator extends AbstractHydrator
                                     $reflFieldValue->hydrateSet($indexValue, $element);
                                     $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $indexValue;
                                 } else {
-                                    $reflFieldValue->hydrateAdd($element);
-                                    $reflFieldValue->last();
+                                    if (! $reflFieldValue->contains($element)) {
+                                        $reflFieldValue->hydrateAdd($element);
+                                        $reflFieldValue->last();
+                                    }
+
                                     $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $reflFieldValue->key();
                                 }
 

lib/Doctrine/ORM/Internal/Hydration/ScalarColumnHydrator.php

@@ -7,6 +7,7 @@ namespace Doctrine\ORM\Internal\Hydration;
 use Doctrine\DBAL\Driver\Exception;
 use Doctrine\ORM\Exception\MultipleSelectorsFoundException;
 
+use function array_column;
 use function count;
 
 /**
@@ -26,12 +27,8 @@ final class ScalarColumnHydrator extends AbstractHydrator
             throw MultipleSelectorsFoundException::create($this->resultSetMapping()->fieldMappings);
         }
 
-        $result = [];
+        $result = $this->statement()->fetchAllNumeric();
 
-        while ($row = $this->statement()->fetchOne()) {
-            $result[] = $row;
-        }
-
-        return $result;
+        return array_column($result, 0);
     }
 }

lib/Doctrine/ORM/LazyCriteriaCollection.php

@@ -11,11 +11,18 @@ use Doctrine\Common\Collections\Selectable;
 use Doctrine\ORM\Persisters\Entity\EntityPersister;
 use ReturnTypeWillChange;
 
+use function assert;
+
 /**
  * A lazy collection that allows a fast count when using criteria object
  * Once count gets executed once without collection being initialized, result
  * is cached and returned on subsequent calls until collection gets loaded,
  * then returning the number of loaded results.
+ *
+ * @template TKey of array-key
+ * @template TValue of object
+ * @extends AbstractLazyCollection<TKey, TValue>
+ * @implements Selectable<TKey, TValue>
  */
 class LazyCriteriaCollection extends AbstractLazyCollection implements Selectable
 {
@@ -72,6 +79,7 @@ class LazyCriteriaCollection extends AbstractLazyCollection implements Selectabl
      * Do an optimized search of an element
      *
      * @param object $element
+     * @psalm-param TValue $element
      *
      * @return bool
      */
@@ -90,6 +98,7 @@ class LazyCriteriaCollection extends AbstractLazyCollection implements Selectabl
     public function matching(Criteria $criteria)
     {
         $this->initialize();
+        assert($this->collection instanceof Selectable);
 
         return $this->collection->matching($criteria);
     }

lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php

@@ -35,8 +35,8 @@ use function end;
 use function explode;
 use function in_array;
 use function is_subclass_of;
+use function str_contains;
 use function strlen;
-use function strpos;
 use function strtolower;
 use function substr;
 
@@ -193,6 +193,10 @@ class ClassMetadataFactory extends AbstractClassMetadataFactory
                 $class->containsForeignIdentifier = true;
             }
 
+            if ($parent->containsEnumIdentifier) {
+                $class->containsEnumIdentifier = true;
+            }
+
             if (! empty($parent->namedQueries)) {
                 $this->addInheritedNamedQueries($class, $parent);
             }
@@ -338,7 +342,7 @@ class ClassMetadataFactory extends AbstractClassMetadataFactory
      */
     private function getShortName(string $className): string
     {
-        if (strpos($className, '\\') === false) {
+        if (! str_contains($className, '\\')) {
             return strtolower($className);
         }
 
@@ -718,7 +722,9 @@ class ClassMetadataFactory extends AbstractClassMetadataFactory
     }
 
     /**
-     * {@inheritDoc}
+     * @deprecated This method will be removed in ORM 3.0.
+     *
+     * @return class-string
      */
     protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
     {

lib/Doctrine/ORM/Mapping/ClassMetadataInfo.php

@@ -49,8 +49,8 @@ use function is_subclass_of;
 use function ltrim;
 use function method_exists;
 use function spl_object_id;
+use function str_contains;
 use function str_replace;
-use function strpos;
 use function strtolower;
 use function trait_exists;
 use function trim;
@@ -639,6 +639,15 @@ class ClassMetadataInfo implements ClassMetadata
      */
     public $containsForeignIdentifier = false;
 
+    /**
+     * READ-ONLY: Flag indicating whether the identifier/primary key contains at least one ENUM type.
+     *
+     * This flag is necessary because some code blocks require special treatment of this cases.
+     *
+     * @var bool
+     */
+    public $containsEnumIdentifier = false;
+
     /**
      * READ-ONLY: The ID generator used for generating IDs for this class.
      *
@@ -958,6 +967,10 @@ class ClassMetadataInfo implements ClassMetadata
             $serialized[] = 'containsForeignIdentifier';
         }
 
+        if ($this->containsEnumIdentifier) {
+            $serialized[] = 'containsEnumIdentifier';
+        }
+
         if ($this->isVersioned) {
             $serialized[] = 'isVersioned';
             $serialized[] = 'versionField';
@@ -1675,6 +1688,10 @@ class ClassMetadataInfo implements ClassMetadata
             if (! enum_exists($mapping['enumType'])) {
                 throw MappingException::nonEnumTypeMapped($this->name, $mapping['fieldName'], $mapping['enumType']);
             }
+
+            if (! empty($mapping['id'])) {
+                $this->containsEnumIdentifier = true;
+            }
         }
 
         return $mapping;
@@ -2671,7 +2688,7 @@ class ClassMetadataInfo implements ClassMetadata
     {
         if (isset($table['name'])) {
             // Split schema and table name from a table name like "myschema.mytable"
-            if (strpos($table['name'], '.') !== false) {
+            if (str_contains($table['name'], '.')) {
                 [$this->table['schema'], $table['name']] = explode('.', $table['name'], 2);
             }
 
@@ -2917,7 +2934,7 @@ class ClassMetadataInfo implements ClassMetadata
 
                         if (! isset($field['column'])) {
                             $fieldName = $field['name'];
-                            if (strpos($fieldName, '.')) {
+                            if (str_contains($fieldName, '.')) {
                                 [, $fieldName] = explode('.', $fieldName);
                             }
 
@@ -3701,7 +3718,7 @@ class ClassMetadataInfo implements ClassMetadata
             return $className;
         }
 
-        if (strpos($className, '\\') === false && $this->namespace) {
+        if (! str_contains($className, '\\') && $this->namespace) {
             return $this->namespace . '\\' . $className;
         }
 

lib/Doctrine/ORM/Mapping/DefaultNamingStrategy.php

@@ -4,7 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Mapping;
 
-use function strpos;
+use function str_contains;
 use function strrpos;
 use function strtolower;
 use function substr;
@@ -21,7 +21,7 @@ class DefaultNamingStrategy implements NamingStrategy
      */
     public function classToTableName($className)
     {
-        if (strpos($className, '\\') !== false) {
+        if (str_contains($className, '\\')) {
             return substr($className, strrpos($className, '\\') + 1);
         }
 

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

@@ -5,13 +5,16 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Mapping\Driver;
 
 use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\Reader;
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Events;
 use Doctrine\ORM\Mapping;
 use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
 use Doctrine\ORM\Mapping\ClassMetadataInfo;
 use Doctrine\ORM\Mapping\MappingException;
 use Doctrine\Persistence\Mapping\ClassMetadata;
-use Doctrine\Persistence\Mapping\Driver\AnnotationDriver as AbstractAnnotationDriver;
+use Doctrine\Persistence\Mapping\Driver\ColocatedMappingDriver;
+use Doctrine\Persistence\Mapping\Driver\MappingDriver;
 use ReflectionClass;
 use ReflectionMethod;
 use ReflectionProperty;
@@ -29,8 +32,19 @@ use function is_numeric;
 /**
  * The AnnotationDriver reads the mapping metadata from docblock annotations.
  */
-class AnnotationDriver extends AbstractAnnotationDriver
+class AnnotationDriver implements MappingDriver
 {
+    use ColocatedMappingDriver;
+
+    /**
+     * The annotation reader.
+     *
+     * @internal this property will be private in 3.0
+     *
+     * @var Reader
+     */
+    protected $reader;
+
     /**
      * @var int[]
      * @psalm-var array<class-string, int>
@@ -40,6 +54,20 @@ class AnnotationDriver extends AbstractAnnotationDriver
         Mapping\MappedSuperclass::class => 2,
     ];
 
+    /**
+     * Initializes a new AnnotationDriver that uses the given AnnotationReader for reading
+     * docblock annotations.
+     *
+     * @param Reader               $reader The AnnotationReader to use
+     * @param string|string[]|null $paths  One or multiple paths where mapping classes can be found.
+     */
+    public function __construct($reader, $paths = null)
+    {
+        $this->reader = $reader;
+
+        $this->addPaths((array) $paths);
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -786,6 +814,39 @@ class AnnotationDriver extends AbstractAnnotationDriver
         return $mapping;
     }
 
+    /**
+     * Retrieve the current annotation reader
+     *
+     * @return Reader
+     */
+    public function getReader()
+    {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/9587',
+            '%s is deprecated with no replacement',
+            __METHOD__
+        );
+
+        return $this->reader;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isTransient($className)
+    {
+        $classAnnotations = $this->reader->getClassAnnotations(new ReflectionClass($className));
+
+        foreach ($classAnnotations as $annot) {
+            if (isset($this->entityAnnotationClasses[get_class($annot)])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Factory method for the Annotation Driver.
      *

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

@@ -4,13 +4,15 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Mapping\Driver;
 
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Events;
 use Doctrine\ORM\Mapping;
 use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
 use Doctrine\ORM\Mapping\ClassMetadataInfo;
 use Doctrine\ORM\Mapping\MappingException;
 use Doctrine\Persistence\Mapping\ClassMetadata;
-use Doctrine\Persistence\Mapping\Driver\AnnotationDriver;
+use Doctrine\Persistence\Mapping\Driver\ColocatedMappingDriver;
+use Doctrine\Persistence\Mapping\Driver\MappingDriver;
 use LogicException;
 use ReflectionClass;
 use ReflectionMethod;
@@ -25,8 +27,10 @@ use function sprintf;
 
 use const PHP_VERSION_ID;
 
-class AttributeDriver extends AnnotationDriver
+class AttributeDriver implements MappingDriver
 {
+    use ColocatedMappingDriver;
+
     /** @var array<string,int> */
     // @phpcs:ignore
     protected $entityAnnotationClasses = [
@@ -34,6 +38,15 @@ class AttributeDriver extends AnnotationDriver
         Mapping\MappedSuperclass::class => 2,
     ];
 
+    /**
+     * The annotation reader.
+     *
+     * @internal this property will be private in 3.0
+     *
+     * @var AttributeReader
+     */
+    protected $reader;
+
     /**
      * @param array<string> $paths
      */
@@ -46,7 +59,27 @@ class AttributeDriver extends AnnotationDriver
             ));
         }
 
-        parent::__construct(new AttributeReader(), $paths);
+        $this->reader = new AttributeReader();
+        $this->addPaths($paths);
+    }
+
+    /**
+     * Retrieve the current annotation reader
+     *
+     * @deprecated no replacement planned.
+     *
+     * @return AttributeReader
+     */
+    public function getReader()
+    {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/9587',
+            '%s is deprecated with no replacement',
+            __METHOD__
+        );
+
+        return $this->reader;
     }
 
     /**
@@ -271,7 +304,7 @@ class AttributeDriver extends AnnotationDriver
             // Check for JoinColumn/JoinColumns annotations
             $joinColumns = [];
 
-            $joinColumnAttributes = $this->reader->getPropertyAnnotation($property, Mapping\JoinColumn::class);
+            $joinColumnAttributes = $this->reader->getPropertyAnnotationCollection($property, Mapping\JoinColumn::class);
 
             foreach ($joinColumnAttributes as $joinColumnAttribute) {
                 $joinColumns[] = $this->joinColumnToArray($joinColumnAttribute);
@@ -376,11 +409,11 @@ class AttributeDriver extends AnnotationDriver
                     ];
                 }
 
-                foreach ($this->reader->getPropertyAnnotation($property, Mapping\JoinColumn::class) as $joinColumn) {
+                foreach ($this->reader->getPropertyAnnotationCollection($property, Mapping\JoinColumn::class) as $joinColumn) {
                     $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
                 }
 
-                foreach ($this->reader->getPropertyAnnotation($property, Mapping\InverseJoinColumn::class) as $joinColumn) {
+                foreach ($this->reader->getPropertyAnnotationCollection($property, Mapping\InverseJoinColumn::class) as $joinColumn) {
                     $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
                 }
 

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

@@ -6,6 +6,7 @@ namespace Doctrine\ORM\Mapping\Driver;
 
 use Attribute;
 use Doctrine\ORM\Mapping\Annotation;
+use LogicException;
 use ReflectionAttribute;
 use ReflectionClass;
 use ReflectionMethod;
@@ -14,58 +15,93 @@ use ReflectionProperty;
 use function assert;
 use function is_string;
 use function is_subclass_of;
+use function sprintf;
 
 /**
  * @internal
  */
 final class AttributeReader
 {
-    /** @var array<string,bool> */
+    /** @var array<class-string<Annotation>,bool> */
     private array $isRepeatableAttribute = [];
 
-    /** @return array<Annotation|RepeatableAttributeCollection> */
+    /**
+     * @psalm-return class-string-map<T, T|RepeatableAttributeCollection<T>>
+     *
+     * @template T of Annotation
+     */
     public function getClassAnnotations(ReflectionClass $class): array
     {
         return $this->convertToAttributeInstances($class->getAttributes());
     }
 
-    /** @return Annotation|RepeatableAttributeCollection|null */
-    public function getClassAnnotation(ReflectionClass $class, $annotationName)
-    {
-        return $this->getClassAnnotations($class)[$annotationName]
-            ?? ($this->isRepeatable($annotationName) ? new RepeatableAttributeCollection() : null);
-    }
-
-    /** @return array<Annotation|RepeatableAttributeCollection> */
+    /**
+     * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
+     *
+     * @template T of Annotation
+     */
     public function getMethodAnnotations(ReflectionMethod $method): array
     {
         return $this->convertToAttributeInstances($method->getAttributes());
     }
 
-    /** @return Annotation|RepeatableAttributeCollection|null */
-    public function getMethodAnnotation(ReflectionMethod $method, $annotationName)
-    {
-        return $this->getMethodAnnotations($method)[$annotationName]
-            ?? ($this->isRepeatable($annotationName) ? new RepeatableAttributeCollection() : null);
-    }
-
-    /** @return array<Annotation|RepeatableAttributeCollection> */
+    /**
+     * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
+     *
+     * @template T of Annotation
+     */
     public function getPropertyAnnotations(ReflectionProperty $property): array
     {
         return $this->convertToAttributeInstances($property->getAttributes());
     }
 
-    /** @return Annotation|RepeatableAttributeCollection|null */
+    /**
+     * @param class-string<T> $annotationName The name of the annotation.
+     *
+     * @return T|null
+     *
+     * @template T of Annotation
+     */
     public function getPropertyAnnotation(ReflectionProperty $property, $annotationName)
     {
+        if ($this->isRepeatable($annotationName)) {
+            throw new LogicException(sprintf(
+                'The attribute "%s" is repeatable. Call getPropertyAnnotationCollection() instead.',
+                $annotationName
+            ));
+        }
+
         return $this->getPropertyAnnotations($property)[$annotationName]
             ?? ($this->isRepeatable($annotationName) ? new RepeatableAttributeCollection() : null);
     }
 
+    /**
+     * @param class-string<T> $annotationName The name of the annotation.
+     *
+     * @return RepeatableAttributeCollection<T>
+     *
+     * @template T of Annotation
+     */
+    public function getPropertyAnnotationCollection(
+        ReflectionProperty $property,
+        string $annotationName
+    ): RepeatableAttributeCollection {
+        if (! $this->isRepeatable($annotationName)) {
+            throw new LogicException(sprintf(
+                'The attribute "%s" is not repeatable. Call getPropertyAnnotation() instead.',
+                $annotationName
+            ));
+        }
+
+        return $this->getPropertyAnnotations($property)[$annotationName] ?? new RepeatableAttributeCollection();
+    }
+
     /**
      * @param array<ReflectionAttribute> $attributes
      *
-     * @return array<Annotation|RepeatableAttributeCollection>
+     * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
+     *
+     * @template T of Annotation
      */
     private function convertToAttributeInstances(array $attributes): array
     {
@@ -98,6 +134,9 @@ final class AttributeReader
         return $instances;
     }
 
+    /**
+     * @param class-string<Annotation> $attributeClassName
+     */
     private function isRepeatable(string $attributeClassName): bool
     {
         if (isset($this->isRepeatableAttribute[$attributeClassName])) {

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

@@ -8,7 +8,8 @@ use ArrayObject;
 use Doctrine\ORM\Mapping\Annotation;
 
 /**
- * @template-extends ArrayObject<int,Annotation>
+ * @template-extends ArrayObject<int, T>
+ * @template T of Annotation
  */
 final class RepeatableAttributeCollection extends ArrayObject
 {

lib/Doctrine/ORM/Mapping/ReflectionEnumProperty.php

@@ -9,10 +9,9 @@ use ReflectionProperty;
 use ReturnTypeWillChange;
 use ValueError;
 
-use function assert;
+use function array_map;
 use function get_class;
-use function is_int;
-use function is_string;
+use function is_array;
 
 class ReflectionEnumProperty extends ReflectionProperty
 {
@@ -41,7 +40,7 @@ class ReflectionEnumProperty extends ReflectionProperty
      *
      * @param object|null $object
      *
-     * @return int|string|null
+     * @return int|string|int[]|string[]|null
      */
     #[ReturnTypeWillChange]
     public function getValue($object = null)
@@ -56,32 +55,52 @@ class ReflectionEnumProperty extends ReflectionProperty
             return null;
         }
 
+        if (is_array($enum)) {
+            return array_map(static function (BackedEnum $item): mixed {
+                return $item->value;
+            }, $enum);
+        }
+
         return $enum->value;
     }
 
     /**
-     * @param object $object
-     * @param mixed  $value
+     * @param object                         $object
+     * @param int|string|int[]|string[]|null $value
      */
     public function setValue($object, $value = null): void
     {
         if ($value !== null) {
-            $enumType = $this->enumType;
-            try {
-                $value = $enumType::from($value);
-            } catch (ValueError $e) {
-                assert(is_string($value) || is_int($value));
-
-                throw MappingException::invalidEnumValue(
-                    get_class($object),
-                    $this->originalReflectionProperty->getName(),
-                    (string) $value,
-                    $enumType,
-                    $e
-                );
+            if (is_array($value)) {
+                $value = array_map(function ($item) use ($object): BackedEnum {
+                    return $this->initializeEnumValue($object, $item);
+                }, $value);
+            } else {
+                $value = $this->initializeEnumValue($object, $value);
             }
         }
 
         $this->originalReflectionProperty->setValue($object, $value);
     }
+
+    /**
+     * @param object     $object
+     * @param int|string $value
+     */
+    private function initializeEnumValue($object, $value): BackedEnum
+    {
+        $enumType = $this->enumType;
+
+        try {
+            return $enumType::from($value);
+        } catch (ValueError $e) {
+            throw MappingException::invalidEnumValue(
+                get_class($object),
+                $this->originalReflectionProperty->getName(),
+                (string) $value,
+                $enumType,
+                $e
+            );
+        }
+    }
 }

lib/Doctrine/ORM/Mapping/UnderscoreNamingStrategy.php

@@ -7,7 +7,7 @@ namespace Doctrine\ORM\Mapping;
 use Doctrine\Deprecations\Deprecation;
 
 use function preg_replace;
-use function strpos;
+use function str_contains;
 use function strrpos;
 use function strtolower;
 use function strtoupper;
@@ -79,7 +79,7 @@ class UnderscoreNamingStrategy implements NamingStrategy
      */
     public function classToTableName($className)
     {
-        if (strpos($className, '\\') !== false) {
+        if (str_contains($className, '\\')) {
             $className = substr($className, strrpos($className, '\\') + 1);
         }
 

lib/Doctrine/ORM/ORMInvalidArgumentException.php

@@ -4,11 +4,14 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM;
 
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use InvalidArgumentException;
 
 use function array_map;
 use function count;
+use function func_get_arg;
+use function func_num_args;
 use function get_debug_type;
 use function gettype;
 use function implode;
@@ -197,9 +200,27 @@ class ORMInvalidArgumentException extends InvalidArgumentException
     /**
      * @return ORMInvalidArgumentException
      */
-    public static function invalidIdentifierBindingEntity()
+    public static function invalidIdentifierBindingEntity(/* string $class */)
     {
-        return new self('Binding entities to query parameters only allowed for entities that have an identifier.');
+        if (func_num_args() === 0) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/9642',
+                'Omitting the class name in the exception method %s is deprecated.',
+                __METHOD__
+            );
+
+            return new self('Binding entities to query parameters only allowed for entities that have an identifier.');
+        }
+
+        return new self(sprintf(
+            <<<'EXCEPTION'
+Binding entities to query parameters only allowed for entities that have an identifier.
+Class "%s" does not have an identifier.
+EXCEPTION
+            ,
+            func_get_arg(0)
+        ));
     }
 
     /**
@@ -224,12 +245,21 @@ class ORMInvalidArgumentException extends InvalidArgumentException
     /**
      * Used when a given entityName hasn't the good type
      *
+     * @deprecated This method will be removed in 3.0.
+     *
      * @param mixed $entityName The given entity (which shouldn't be a string)
      *
      * @return self
      */
     public static function invalidEntityName($entityName)
     {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/9471',
+            '%s() is deprecated',
+            __METHOD__
+        );
+
         return new self(sprintf('Entity name must be a string, %s given', get_debug_type($entityName)));
     }
 

lib/Doctrine/ORM/ORMSetup.php

@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\PsrCachedReader;
+use Doctrine\Deprecations\Deprecation;
+use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
+use Doctrine\ORM\Mapping\Driver\AttributeDriver;
+use Doctrine\ORM\Mapping\Driver\XmlDriver;
+use Doctrine\ORM\Mapping\Driver\YamlDriver;
+use LogicException;
+use Psr\Cache\CacheItemPoolInterface;
+use Redis;
+use RuntimeException;
+use Symfony\Component\Cache\Adapter\ApcuAdapter;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Adapter\MemcachedAdapter;
+use Symfony\Component\Cache\Adapter\RedisAdapter;
+
+use function class_exists;
+use function extension_loaded;
+use function md5;
+use function sprintf;
+use function sys_get_temp_dir;
+
+final class ORMSetup
+{
+    /**
+     * Creates a configuration with an annotation metadata driver.
+     *
+     * @param string[] $paths
+     */
+    public static function createAnnotationMetadataConfiguration(
+        array $paths,
+        bool $isDevMode = false,
+        ?string $proxyDir = null,
+        ?CacheItemPoolInterface $cache = null
+    ): Configuration {
+        $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
+        $config->setMetadataDriverImpl(self::createDefaultAnnotationDriver($paths));
+
+        return $config;
+    }
+
+    /**
+     * Adds a new default annotation driver with a correctly configured annotation reader.
+     *
+     * @param string[] $paths
+     */
+    public static function createDefaultAnnotationDriver(
+        array $paths = [],
+        ?CacheItemPoolInterface $cache = null
+    ): AnnotationDriver {
+        if (! class_exists(AnnotationReader::class)) {
+            throw new LogicException(sprintf(
+                'The annotation metadata driver cannot be enabled because the "doctrine/annotations" library'
+                . ' is not installed. Please run "composer require doctrine/annotations" or choose a different'
+                . ' metadata driver.'
+            ));
+        }
+
+        $reader = new AnnotationReader();
+
+        if ($cache === null && class_exists(ArrayAdapter::class)) {
+            $cache = new ArrayAdapter();
+        }
+
+        if ($cache !== null) {
+            $reader = new PsrCachedReader($reader, $cache);
+        }
+
+        return new AnnotationDriver($reader, $paths);
+    }
+
+    /**
+     * Creates a configuration with an attribute metadata driver.
+     *
+     * @param string[] $paths
+     */
+    public static function createAttributeMetadataConfiguration(
+        array $paths,
+        bool $isDevMode = false,
+        ?string $proxyDir = null,
+        ?CacheItemPoolInterface $cache = null
+    ): Configuration {
+        $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
+        $config->setMetadataDriverImpl(new AttributeDriver($paths));
+
+        return $config;
+    }
+
+    /**
+     * Creates a configuration with an XML metadata driver.
+     *
+     * @param string[] $paths
+     */
+    public static function createXMLMetadataConfiguration(
+        array $paths,
+        bool $isDevMode = false,
+        ?string $proxyDir = null,
+        ?CacheItemPoolInterface $cache = null
+    ): Configuration {
+        $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
+        $config->setMetadataDriverImpl(new XmlDriver($paths));
+
+        return $config;
+    }
+
+    /**
+     * Creates a configuration with a YAML metadata driver.
+     *
+     * @deprecated YAML metadata mapping is deprecated and will be removed in 3.0
+     *
+     * @param string[] $paths
+     */
+    public static function createYAMLMetadataConfiguration(
+        array $paths,
+        bool $isDevMode = false,
+        ?string $proxyDir = null,
+        ?CacheItemPoolInterface $cache = null
+    ): Configuration {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/issues/8465',
+            'YAML mapping driver is deprecated and will be removed in Doctrine ORM 3.0, please migrate to attribute or XML driver.'
+        );
+
+        $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
+        $config->setMetadataDriverImpl(new YamlDriver($paths));
+
+        return $config;
+    }
+
+    /**
+     * Creates a configuration without a metadata driver.
+     */
+    public static function createConfiguration(
+        bool $isDevMode = false,
+        ?string $proxyDir = null,
+        ?CacheItemPoolInterface $cache = null
+    ): Configuration {
+        $proxyDir = $proxyDir ?: sys_get_temp_dir();
+
+        $cache = self::createCacheInstance($isDevMode, $proxyDir, $cache);
+
+        $config = new Configuration();
+
+        $config->setMetadataCache($cache);
+        $config->setQueryCache($cache);
+        $config->setResultCache($cache);
+        $config->setProxyDir($proxyDir);
+        $config->setProxyNamespace('DoctrineProxies');
+        $config->setAutoGenerateProxyClasses($isDevMode);
+
+        return $config;
+    }
+
+    private static function createCacheInstance(
+        bool $isDevMode,
+        string $proxyDir,
+        ?CacheItemPoolInterface $cache
+    ): CacheItemPoolInterface {
+        if ($cache !== null) {
+            return $cache;
+        }
+
+        if (! class_exists(ArrayAdapter::class)) {
+            throw new RuntimeException(
+                'The Doctrine setup tool cannot configure caches without symfony/cache.'
+                . ' Please add symfony/cache as explicit dependency or pass your own cache implementation.'
+            );
+        }
+
+        if ($isDevMode) {
+            return new ArrayAdapter();
+        }
+
+        $namespace = 'dc2_' . md5($proxyDir);
+
+        if (extension_loaded('apcu')) {
+            return new ApcuAdapter($namespace);
+        }
+
+        if (MemcachedAdapter::isSupported()) {
+            return new MemcachedAdapter(MemcachedAdapter::createConnection('memcached://127.0.0.1'), $namespace);
+        }
+
+        if (extension_loaded('redis')) {
+            $redis = new Redis();
+            $redis->connect('127.0.0.1');
+
+            return new RedisAdapter($redis, $namespace);
+        }
+
+        return new ArrayAdapter();
+    }
+
+    private function __construct()
+    {
+    }
+}

lib/Doctrine/ORM/Persisters/Collection/CollectionPersister.php

@@ -37,8 +37,8 @@ interface CollectionPersister
     /**
      * Slices elements.
      *
-     * @param int $offset
-     * @param int $length
+     * @param int      $offset
+     * @param int|null $length
      *
      * @return mixed[]
      */

lib/Doctrine/ORM/Persisters/Collection/ManyToManyPersister.php

@@ -501,7 +501,7 @@ class ManyToManyPersister extends AbstractCollectionPersister
      *
      * Internal note: Order of the parameters must be the same as the order of the columns in getInsertRowSql.
      *
-     * @param mixed $element
+     * @param object $element
      *
      * @return mixed[]
      * @psalm-return list<mixed>

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

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Persisters\Entity;
 
+use BackedEnum;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\Common\Collections\Expr\Comparison;
 use Doctrine\Common\Util\ClassUtils;
@@ -13,6 +14,7 @@ use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\DBAL\Result;
 use Doctrine\DBAL\Types\Type;
 use Doctrine\DBAL\Types\Types;
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\MappingException;
@@ -47,7 +49,7 @@ use function is_object;
 use function reset;
 use function spl_object_id;
 use function sprintf;
-use function strpos;
+use function str_contains;
 use function strtoupper;
 use function trim;
 
@@ -163,7 +165,7 @@ class BasicEntityPersister implements EntityPersister
      * The INSERT SQL statement used for entities handled by this persister.
      * This SQL is only generated once per request, if at all.
      *
-     * @var string
+     * @var string|null
      */
     private $insertSql;
 
@@ -1579,11 +1581,22 @@ class BasicEntityPersister implements EntityPersister
      */
     protected function getLockTablesSql($lockMode)
     {
+        if ($lockMode === null) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/9466',
+                'Passing null as argument to %s is deprecated, pass LockMode::NONE instead.',
+                __METHOD__
+            );
+
+            $lockMode = LockMode::NONE;
+        }
+
         return $this->platform->appendLockHint(
             'FROM '
             . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
             . $this->getSQLTableAlias($this->class->name),
-            $lockMode ?? LockMode::NONE
+            $lockMode
         );
     }
 
@@ -1732,7 +1745,7 @@ class BasicEntityPersister implements EntityPersister
             return $columns;
         }
 
-        if ($assoc !== null && strpos($field, ' ') === false && strpos($field, '(') === false) {
+        if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
             // very careless developers could potentially open up this normally hidden api for userland attacks,
             // therefore checking for spaces and function calls which are not allowed.
 
@@ -1976,15 +1989,18 @@ class BasicEntityPersister implements EntityPersister
      *
      * @param mixed $value
      *
-     * @return       array<mixed>
      * @psalm-return list<mixed>
      */
-    private function getIndividualValue($value)
+    private function getIndividualValue($value): array
     {
         if (! is_object($value)) {
             return [$value];
         }
 
+        if ($value instanceof BackedEnum) {
+            return [$value->value];
+        }
+
         $valueClass = ClassUtils::getClass($value);
 
         if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
@@ -2020,7 +2036,7 @@ class BasicEntityPersister implements EntityPersister
         $alias = $this->getSQLTableAlias($this->class->name);
 
         $sql = 'SELECT 1 '
-             . $this->getLockTablesSql(null)
+             . $this->getLockTablesSql(LockMode::NONE)
              . ' WHERE ' . $this->getSelectConditionSQL($criteria);
 
         [$params, $types] = $this->expandParameters($criteria);

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

@@ -32,17 +32,17 @@ interface EntityPersister
     /**
      * Get all queued inserts.
      *
-     * @psalm-return array<string|int, object>
+     * @return object[]
      */
     public function getInserts();
 
      /**
+      * Gets the INSERT SQL used by the persister to persist a new entity.
+      *
       * @return string
       *
-      * @TODO - It should not be here.
-      * But its necessary since JoinedSubclassPersister#executeInserts invoke the root persister.
-      *
-      * Gets the INSERT SQL used by the persister to persist a new entity.
+      * @TODO It should not be here.
+      *       But its necessary since JoinedSubclassPersister#executeInserts invoke the root persister.
       */
     public function getInsertSQL();
 

lib/Doctrine/ORM/Proxy/Proxy.php

@@ -8,8 +8,6 @@ use Doctrine\Common\Proxy\Proxy as BaseProxy;
 
 /**
  * Interface for proxy classes.
- *
- * @deprecated 2.7 This interface is being removed from the ORM and won't have any replacement, proxies will no longer implement it.
  */
 interface Proxy extends BaseProxy
 {

lib/Doctrine/ORM/Proxy/ProxyFactory.php

@@ -20,7 +20,7 @@ use Doctrine\Persistence\Mapping\ClassMetadata;
 /**
  * This factory is used to create proxy objects for entities at runtime.
  *
- * @deprecated 2.7 This class is being removed from the ORM and won't have any replacement
+ * @psalm-type AutogenerateMode = AbstractProxyFactory::AUTOGENERATE_NEVER|AbstractProxyFactory::AUTOGENERATE_ALWAYS|AbstractProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS|AbstractProxyFactory::AUTOGENERATE_EVAL|AbstractProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS_OR_CHANGED
  */
 class ProxyFactory extends AbstractProxyFactory
 {
@@ -48,7 +48,8 @@ class ProxyFactory extends AbstractProxyFactory
      * @param string                 $proxyDir     The directory to use for the proxy classes. It must exist.
      * @param string                 $proxyNs      The namespace to use for the proxy classes.
      * @param bool|int               $autoGenerate The strategy for automatically generating proxy classes. Possible
-     *               values are constants of Doctrine\Common\Proxy\AbstractProxyFactory.
+     *                                             values are constants of {@see AbstractProxyFactory}.
+     * @psalm-param bool|AutogenerateMode $autoGenerate
      */
     public function __construct(EntityManagerInterface $em, $proxyDir, $proxyNs, $autoGenerate = AbstractProxyFactory::AUTOGENERATE_NEVER)
     {

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

@@ -4,11 +4,6 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query\AST;
 
-/**
- * Description of AggregateExpression.
- *
- * @link    www.doctrine-project.org
- */
 class AggregateExpression extends Node
 {
     /** @var string */

lib/Doctrine/ORM/Query/AST/Functions/IdentityFunction.php

@@ -10,6 +10,7 @@ use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\QueryException;
 use Doctrine\ORM\Query\SqlWalker;
 
+use function assert;
 use function reset;
 use function sprintf;
 
@@ -23,7 +24,7 @@ class IdentityFunction extends FunctionNode
     /** @var PathExpression */
     public $pathExpression;
 
-    /** @var string */
+    /** @var string|null */
     public $fieldMapping;
 
     /**
@@ -31,14 +32,14 @@ class IdentityFunction extends FunctionNode
      */
     public function getSql(SqlWalker $sqlWalker)
     {
-        $platform      = $sqlWalker->getEntityManager()->getConnection()->getDatabasePlatform();
-        $quoteStrategy = $sqlWalker->getEntityManager()->getConfiguration()->getQuoteStrategy();
+        assert($this->pathExpression->field !== null);
+        $entityManager = $sqlWalker->getEntityManager();
+        $platform      = $entityManager->getConnection()->getDatabasePlatform();
+        $quoteStrategy = $entityManager->getConfiguration()->getQuoteStrategy();
         $dqlAlias      = $this->pathExpression->identificationVariable;
         $assocField    = $this->pathExpression->field;
-        $qComp         = $sqlWalker->getQueryComponent($dqlAlias);
-        $class         = $qComp['metadata'];
-        $assoc         = $class->associationMappings[$assocField];
-        $targetEntity  = $sqlWalker->getEntityManager()->getClassMetadata($assoc['targetEntity']);
+        $assoc         = $sqlWalker->getMetadataForDqlAlias($dqlAlias)->associationMappings[$assocField];
+        $targetEntity  = $entityManager->getClassMetadata($assoc['targetEntity']);
         $joinColumn    = reset($assoc['joinColumns']);
 
         if ($this->fieldMapping !== null) {
@@ -63,7 +64,7 @@ class IdentityFunction extends FunctionNode
         }
 
         // The table with the relation may be a subclass, so get the table name from the association definition
-        $tableName = $sqlWalker->getEntityManager()->getClassMetadata($assoc['sourceEntity'])->getTableName();
+        $tableName = $entityManager->getClassMetadata($assoc['sourceEntity'])->getTableName();
 
         $tableAlias = $sqlWalker->getSQLTableAlias($tableName, $dqlAlias);
         $columnName = $quoteStrategy->getJoinColumnName($joinColumn, $targetEntity, $platform);

lib/Doctrine/ORM/Query/AST/Functions/SizeFunction.php

@@ -10,6 +10,8 @@ use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
 
+use function assert;
+
 /**
  * "SIZE" "(" CollectionValuedPathExpression ")"
  *
@@ -27,18 +29,19 @@ class SizeFunction extends FunctionNode
      */
     public function getSql(SqlWalker $sqlWalker)
     {
-        $platform      = $sqlWalker->getEntityManager()->getConnection()->getDatabasePlatform();
-        $quoteStrategy = $sqlWalker->getEntityManager()->getConfiguration()->getQuoteStrategy();
+        assert($this->collectionPathExpression->field !== null);
+        $entityManager = $sqlWalker->getEntityManager();
+        $platform      = $entityManager->getConnection()->getDatabasePlatform();
+        $quoteStrategy = $entityManager->getConfiguration()->getQuoteStrategy();
         $dqlAlias      = $this->collectionPathExpression->identificationVariable;
         $assocField    = $this->collectionPathExpression->field;
 
-        $qComp = $sqlWalker->getQueryComponent($dqlAlias);
-        $class = $qComp['metadata'];
+        $class = $sqlWalker->getMetadataForDqlAlias($dqlAlias);
         $assoc = $class->associationMappings[$assocField];
         $sql   = 'SELECT COUNT(*) FROM ';
 
         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
-            $targetClass      = $sqlWalker->getEntityManager()->getClassMetadata($assoc['targetEntity']);
+            $targetClass      = $entityManager->getClassMetadata($assoc['targetEntity']);
             $targetTableAlias = $sqlWalker->getSQLTableAlias($targetClass->getTableName());
             $sourceTableAlias = $sqlWalker->getSQLTableAlias($class->getTableName(), $dqlAlias);
 
@@ -60,7 +63,7 @@ class SizeFunction extends FunctionNode
                       . $sourceTableAlias . '.' . $quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $platform);
             }
         } else { // many-to-many
-            $targetClass = $sqlWalker->getEntityManager()->getClassMetadata($assoc['targetEntity']);
+            $targetClass = $entityManager->getClassMetadata($assoc['targetEntity']);
 
             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
             $joinTable   = $owningAssoc['joinTable'];

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

@@ -10,11 +10,6 @@ use function is_numeric;
 use function strlen;
 use function substr;
 
-/**
- * Description of InputParameter.
- *
- * @link    www.doctrine-project.org
- */
 class InputParameter extends Node
 {
     /** @var bool */

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

@@ -16,7 +16,10 @@ class Join extends Node
     public const JOIN_TYPE_LEFTOUTER = 2;
     public const JOIN_TYPE_INNER     = 3;
 
-    /** @var int */
+    /**
+     * @var int
+     * @psalm-var self::JOIN_TYPE_*
+     */
     public $joinType = self::JOIN_TYPE_INNER;
 
     /** @var Node|null */
@@ -28,6 +31,7 @@ class Join extends Node
     /**
      * @param int  $joinType
      * @param Node $joinAssociationDeclaration
+     * @psalm-param self::JOIN_TYPE_* $joinType
      */
     public function __construct($joinType, $joinAssociationDeclaration)
     {

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

@@ -26,12 +26,4 @@ class JoinAssociationPathExpression extends Node
         $this->identificationVariable = $identificationVariable;
         $this->associationField       = $associationField;
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function dispatch($sqlWalker)
-    {
-        return $sqlWalker->walkPathExpression($this);
-    }
 }

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

@@ -4,6 +4,8 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query\AST;
 
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+
 /**
  * LikeExpression ::= StringExpression ["NOT"] "LIKE" string ["ESCAPE" char]
  *
@@ -12,21 +14,21 @@ namespace Doctrine\ORM\Query\AST;
 class LikeExpression extends Node
 {
     /** @var bool */
-    public $not;
+    public $not = false;
 
-    /** @var Node */
+    /** @var Node|string */
     public $stringExpression;
 
-    /** @var InputParameter */
+    /** @var InputParameter|FunctionNode|PathExpression|Literal */
     public $stringPattern;
 
     /** @var Literal|null */
     public $escapeChar;
 
     /**
-     * @param Node           $stringExpression
-     * @param InputParameter $stringPattern
-     * @param Literal|null   $escapeChar
+     * @param Node|string                                        $stringExpression
+     * @param InputParameter|FunctionNode|PathExpression|Literal $stringPattern
+     * @param Literal|null                                       $escapeChar
      */
     public function __construct($stringExpression, $stringPattern, $escapeChar = null)
     {

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

@@ -10,7 +10,10 @@ class Literal extends Node
     public const BOOLEAN = 2;
     public const NUMERIC = 3;
 
-    /** @var int */
+    /**
+     * @var int
+     * @psalm-var self::*
+     */
     public $type;
 
     /** @var mixed */
@@ -19,6 +22,7 @@ class Literal extends Node
     /**
      * @param int   $type
      * @param mixed $value
+     * @psalm-param self::* $type
      */
     public function __construct($type, $value)
     {

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

@@ -19,10 +19,16 @@ class PathExpression extends Node
     public const TYPE_SINGLE_VALUED_ASSOCIATION     = 4;
     public const TYPE_STATE_FIELD                   = 8;
 
-    /** @var int */
+    /**
+     * @var int|null
+     * @psalm-var self::TYPE_*|null
+     */
     public $type;
 
-    /** @var int */
+    /**
+     * @var int
+     * @psalm-var int-mask-of<self::TYPE_*>
+     */
     public $expectedType;
 
     /** @var string */
@@ -35,6 +41,7 @@ class PathExpression extends Node
      * @param int         $expectedType
      * @param string      $identificationVariable
      * @param string|null $field
+     * @psalm-param int-mask-of<self::TYPE_*> $expectedType
      */
     public function __construct($expectedType, $identificationVariable, $field = null)
     {

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

@@ -19,7 +19,10 @@ class Join
     public const ON   = 'ON';
     public const WITH = 'WITH';
 
-    /** @var string */
+    /**
+     * @var string
+     * @psalm-var self::INNER_JOIN|self::LEFT_JOIN
+     */
     protected $joinType;
 
     /** @var string */
@@ -28,7 +31,10 @@ class Join
     /** @var string|null */
     protected $alias;
 
-    /** @var string|null */
+    /**
+     * @var string|null
+     * @psalm-var self::ON|self::WITH|null
+     */
     protected $conditionType;
 
     /** @var string|Comparison|Composite|null */
@@ -44,6 +50,8 @@ class Join
      * @param string|null                      $conditionType The condition type constant. Either ON or WITH.
      * @param string|Comparison|Composite|null $condition     The condition for the join.
      * @param string|null                      $indexBy       The index for the join.
+     * @psalm-param self::INNER_JOIN|self::LEFT_JOIN $joinType
+     * @psalm-param self::ON|self::WITH|null $conditionType
      */
     public function __construct($joinType, $join, $alias = null, $conditionType = null, $condition = null, $indexBy = null)
     {
@@ -57,6 +65,7 @@ class Join
 
     /**
      * @return string
+     * @psalm-return self::INNER_JOIN|self::LEFT_JOIN
      */
     public function getJoinType()
     {
@@ -81,6 +90,7 @@ class Join
 
     /**
      * @return string|null
+     * @psalm-return self::ON|self::WITH|null
      */
     public function getConditionType()
     {

lib/Doctrine/ORM/Query/FilterCollection.php

@@ -47,13 +47,23 @@ class FilterCollection
      * Instances of enabled filters.
      *
      * @var SQLFilter[]
+     * @psalm-var array<string, SQLFilter>
      */
     private $enabledFilters = [];
 
-    /** @var string The filter hash from the last time the query was parsed. */
-    private $filterHash;
+    /**
+     * The filter hash from the last time the query was parsed.
+     *
+     * @var string
+     */
+    private $filterHash = '';
 
-    /** @var int The current state of this filter. */
+    /**
+     * The current state of this filter.
+     *
+     * @var int
+     * @psalm-var self::FILTERS_STATE_*
+     */
     private $filtersState = self::FILTERS_STATE_CLEAN;
 
     public function __construct(EntityManagerInterface $em)
@@ -66,6 +76,7 @@ class FilterCollection
      * Gets all the enabled filters.
      *
      * @return SQLFilter[] The enabled filters.
+     * @psalm-return array<string, SQLFilter>
      */
     public function getEnabledFilters()
     {
@@ -167,7 +178,9 @@ class FilterCollection
     }
 
     /**
-     * @return bool True, if the filter collection is clean.
+     * Checks if the filter collection is clean.
+     *
+     * @return bool
      */
     public function isClean()
     {

lib/Doctrine/ORM/Query/Lexer.php

@@ -5,15 +5,16 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query;
 
 use Doctrine\Common\Lexer\AbstractLexer;
+use Doctrine\Deprecations\Deprecation;
 
 use function constant;
 use function ctype_alpha;
 use function defined;
 use function is_numeric;
+use function str_contains;
 use function str_replace;
 use function stripos;
 use function strlen;
-use function strpos;
 use function strtoupper;
 use function substr;
 
@@ -44,6 +45,7 @@ class Lexer extends AbstractLexer
     public const T_CLOSE_CURLY_BRACE = 19;
 
     // All tokens that are identifiers or keywords that could be considered as identifiers should be >= 100
+    /** @deprecated No Replacement planned. */
     public const T_ALIASED_NAME         = 100;
     public const T_FULLY_QUALIFIED_NAME = 101;
     public const T_IDENTIFIER           = 102;
@@ -149,7 +151,7 @@ class Lexer extends AbstractLexer
         switch (true) {
             // Recognize numeric values
             case is_numeric($value):
-                if (strpos($value, '.') !== false || stripos($value, 'e') !== false) {
+                if (str_contains($value, '.') || stripos($value, 'e') !== false) {
                     return self::T_FLOAT;
                 }
 
@@ -173,11 +175,18 @@ class Lexer extends AbstractLexer
                     }
                 }
 
-                if (strpos($value, ':') !== false) {
+                if (str_contains($value, ':')) {
+                    Deprecation::trigger(
+                        'doctrine/orm',
+                        'https://github.com/doctrine/orm/issues/8818',
+                        'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
+                        $value
+                    );
+
                     return self::T_ALIASED_NAME;
                 }
 
-                if (strpos($value, '\\') !== false) {
+                if (str_contains($value, '\\')) {
                     return self::T_FULLY_QUALIFIED_NAME;
                 }
 

lib/Doctrine/ORM/Query/Parameter.php

@@ -54,9 +54,9 @@ class Parameter
     private $typeSpecified;
 
     /**
-     * @param string $name  Parameter name
-     * @param mixed  $value Parameter value
-     * @param mixed  $type  Parameter type
+     * @param string|int $name  Parameter name
+     * @param mixed      $value Parameter value
+     * @param mixed      $type  Parameter type
      */
     public function __construct($name, $value, $type = null)
     {

lib/Doctrine/ORM/Query/ParameterTypeInferer.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query;
 
+use BackedEnum;
 use DateInterval;
 use DateTimeImmutable;
 use DateTimeInterface;
@@ -54,8 +55,19 @@ class ParameterTypeInferer
             return Types::DATEINTERVAL;
         }
 
+        if ($value instanceof BackedEnum) {
+            return is_int($value->value)
+                ? Types::INTEGER
+                : Types::STRING;
+        }
+
         if (is_array($value)) {
-            return is_int(current($value))
+            $firstValue = current($value);
+            if ($firstValue instanceof BackedEnum) {
+                $firstValue = $firstValue->value;
+            }
+
+            return is_int($firstValue)
                 ? Connection::PARAM_INT_ARRAY
                 : Connection::PARAM_STR_ARRAY;
         }

lib/Doctrine/ORM/Query/Parser.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query;
 
+use Doctrine\Common\Lexer\AbstractLexer;
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\ClassMetadata;
@@ -60,6 +61,7 @@ use Doctrine\ORM\Query\AST\UpdateItem;
 use Doctrine\ORM\Query\AST\UpdateStatement;
 use Doctrine\ORM\Query\AST\WhenClause;
 use Doctrine\ORM\Query\AST\WhereClause;
+use LogicException;
 use ReflectionClass;
 
 use function array_intersect;
@@ -74,6 +76,7 @@ use function in_array;
 use function interface_exists;
 use function is_string;
 use function sprintf;
+use function str_contains;
 use function strlen;
 use function strpos;
 use function strrpos;
@@ -83,6 +86,17 @@ use function substr;
 /**
  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  * Parses a DQL query, reports any errors in it, and generates an AST.
+ *
+ * @psalm-import-type Token from AbstractLexer
+ * @psalm-type QueryComponent = array{
+ *                 metadata?: ClassMetadata<object>,
+ *                 parent?: string|null,
+ *                 relation?: mixed[]|null,
+ *                 map?: string|null,
+ *                 resultVariable?: AST\Node|string,
+ *                 nestingLevel: int,
+ *                 token: Token,
+ *             }
  */
 class Parser
 {
@@ -139,19 +153,19 @@ class Parser
      * and still need to be validated.
      */
 
-    /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
+    /** @psalm-var list<array{token: Token|null, expression: mixed, nestingLevel: int}> */
     private $deferredIdentificationVariables = [];
 
-    /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
+    /** @psalm-var list<array{token: Token|null, expression: AST\PartialObjectExpression, nestingLevel: int}> */
     private $deferredPartialObjectExpressions = [];
 
-    /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
+    /** @psalm-var list<array{token: Token|null, expression: AST\PathExpression, nestingLevel: int}> */
     private $deferredPathExpressions = [];
 
-    /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
+    /** @psalm-var list<array{token: Token|null, expression: mixed, nestingLevel: int}> */
     private $deferredResultVariables = [];
 
-    /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
+    /** @psalm-var list<array{token: Token|null, expression: AST\NewObjectExpression, nestingLevel: int}> */
     private $deferredNewObjectExpressions = [];
 
     /**
@@ -185,7 +199,7 @@ class Parser
     /**
      * Map of declared query components in the parsed query.
      *
-     * @psalm-var array<string, array<string, mixed>>
+     * @psalm-var array<string, QueryComponent>
      */
     private $queryComponents = [];
 
@@ -206,7 +220,7 @@ class Parser
     /**
      * The custom last tree walker, if any, that is responsible for producing the output.
      *
-     * @var class-string<TreeWalker>
+     * @var class-string<SqlWalker>|null
      */
     private $customOutputWalker;
 
@@ -231,6 +245,7 @@ class Parser
      * This tree walker will be run last over the AST, after any other walkers.
      *
      * @param string $className
+     * @psalm-param class-string<SqlWalker> $className
      *
      * @return void
      */
@@ -243,7 +258,7 @@ class Parser
      * Adds a custom tree walker for modifying the AST.
      *
      * @param string $className
-     * @psalm-param class-string $className
+     * @psalm-param class-string<TreeWalker> $className
      *
      * @return void
      */
@@ -472,7 +487,7 @@ class Parser
      *
      * @param string       $expected Expected string.
      * @param mixed[]|null $token    Got token.
-     * @psalm-param array<string, mixed>|null $token
+     * @psalm-param Token|null $token
      *
      * @return void
      * @psalm-return no-return
@@ -499,9 +514,10 @@ class Parser
      *
      * @param string       $message Optional message.
      * @param mixed[]|null $token   Optional token.
-     * @psalm-param array<string, mixed>|null $token
+     * @psalm-param Token|null $token
      *
      * @return void
+     * @psalm-return no-return
      *
      * @throws QueryException
      */
@@ -570,7 +586,7 @@ class Parser
     /**
      * Checks if the given token indicates a mathematical operator.
      *
-     * @psalm-param array<string, mixed>|null $token
+     * @psalm-param Token|null $token
      */
     private function isMathOperator(?array $token): bool
     {
@@ -670,7 +686,7 @@ class Parser
             $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
 
             // If the namespace is not given then assumes the first FROM entity namespace
-            if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
+            if (! str_contains($className, '\\') && ! class_exists($className) && str_contains($fromClassName, '\\')) {
                 $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
                 $fqcn      = $namespace . '\\' . $className;
 
@@ -708,7 +724,7 @@ class Parser
     {
         foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
             $expr  = $deferredItem['expression'];
-            $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
+            $class = $this->getMetadataForDqlAlias($expr->identificationVariable);
 
             foreach ($expr->partialFieldSet as $field) {
                 if (isset($class->fieldMappings[$field])) {
@@ -790,8 +806,7 @@ class Parser
         foreach ($this->deferredPathExpressions as $deferredItem) {
             $pathExpression = $deferredItem['expression'];
 
-            $qComp = $this->queryComponents[$pathExpression->identificationVariable];
-            $class = $qComp['metadata'];
+            $class = $this->getMetadataForDqlAlias($pathExpression->identificationVariable);
 
             $field = $pathExpression->field;
             if ($field === null) {
@@ -859,7 +874,7 @@ class Parser
         }
 
         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
-            if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
+            if (isset($this->queryComponents[$dqlAlias]) && ! isset($this->queryComponents[$dqlAlias]['parent'])) {
                 return;
             }
         }
@@ -1012,6 +1027,13 @@ class Parser
 
         $this->match(Lexer::T_ALIASED_NAME);
 
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/issues/8818',
+            'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
+            $this->lexer->token['value']
+        );
+
         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
 
         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
@@ -1095,11 +1117,11 @@ class Parser
         $this->match(Lexer::T_DOT);
         $this->match(Lexer::T_IDENTIFIER);
 
+        assert($this->lexer->token !== null);
         $field = $this->lexer->token['value'];
 
         // Validate association field
-        $qComp = $this->queryComponents[$identVariable];
-        $class = $qComp['metadata'];
+        $class = $this->getMetadataForDqlAlias($identVariable);
 
         if (! $class->hasAssociation($field)) {
             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
@@ -1115,6 +1137,7 @@ class Parser
      * PathExpression ::= IdentificationVariable {"." identifier}*
      *
      * @param int $expectedTypes
+     * @psalm-param int-mask-of<PathExpression::TYPE_*> $expectedTypes
      *
      * @return PathExpression
      */
@@ -1262,6 +1285,7 @@ class Parser
     public function UpdateClause()
     {
         $this->match(Lexer::T_UPDATE);
+        assert($this->lexer->lookahead !== null);
 
         $token              = $this->lexer->lookahead;
         $abstractSchemaName = $this->AbstractSchemaName();
@@ -1318,6 +1342,7 @@ class Parser
             $this->match(Lexer::T_FROM);
         }
 
+        assert($this->lexer->lookahead !== null);
         $token              = $this->lexer->lookahead;
         $abstractSchemaName = $this->AbstractSchemaName();
 
@@ -1786,6 +1811,7 @@ class Parser
             $this->match(Lexer::T_AS);
         }
 
+        assert($this->lexer->lookahead !== null);
         $token                       = $this->lexer->lookahead;
         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
         $classMetadata               = $this->em->getClassMetadata($abstractSchemaName);
@@ -1818,13 +1844,15 @@ class Parser
             $this->match(Lexer::T_AS);
         }
 
+        assert($this->lexer->lookahead !== null);
+
         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
 
         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
         $field                  = $joinAssociationPathExpression->associationField;
 
-        $class       = $this->queryComponents[$identificationVariable]['metadata'];
+        $class       = $this->getMetadataForDqlAlias($identificationVariable);
         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
 
         // Building queryComponent
@@ -1896,6 +1924,7 @@ class Parser
 
         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
 
+        assert($this->lexer->token !== null);
         // Defer PartialObjectExpression validation
         $this->deferredPartialObjectExpressions[] = [
             'expression'   => $partialObjectExpression,
@@ -2329,6 +2358,8 @@ class Parser
         $aliasResultVariable = null;
 
         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
+            assert($this->lexer->lookahead !== null);
+            assert($expression instanceof AST\Node || is_string($expression));
             $token               = $this->lexer->lookahead;
             $aliasResultVariable = $this->AliasResultVariable();
 
@@ -2425,6 +2456,7 @@ class Parser
         }
 
         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
+            assert($this->lexer->lookahead !== null);
             $token                             = $this->lexer->lookahead;
             $resultVariable                    = $this->AliasResultVariable();
             $expr->fieldIdentificationVariable = $resultVariable;
@@ -3620,4 +3652,13 @@ class Parser
 
         return $function;
     }
+
+    private function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
+    {
+        if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
+            throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
+        }
+
+        return $this->queryComponents[$dqlAlias]['metadata'];
+    }
 }

lib/Doctrine/ORM/Query/QueryException.php

@@ -7,12 +7,8 @@ namespace Doctrine\ORM\Query;
 use Doctrine\ORM\Exception\ORMException;
 use Doctrine\ORM\Query\AST\PathExpression;
 use Exception;
+use Stringable;
 
-/**
- * Description of QueryException.
- *
- * @link    www.doctrine-project.org
- */
 class QueryException extends ORMException
 {
     /**
@@ -127,7 +123,7 @@ class QueryException extends ORMException
     }
 
     /**
-     * @param object $pathExpr
+     * @param PathExpression $pathExpr
      *
      * @return QueryException
      */
@@ -139,7 +135,7 @@ class QueryException extends ORMException
     }
 
     /**
-     * @param string $literal
+     * @param string|Stringable $literal
      *
      * @return QueryException
      */

lib/Doctrine/ORM/Query/QueryExpressionVisitor.php

@@ -13,7 +13,7 @@ use RuntimeException;
 
 use function count;
 use function str_replace;
-use function strpos;
+use function str_starts_with;
 
 /**
  * Converts Collection expressions to Query expressions.
@@ -114,7 +114,7 @@ class QueryExpressionVisitor extends ExpressionVisitor
         $field = $this->queryAliases[0] . '.' . $comparison->getField();
 
         foreach ($this->queryAliases as $alias) {
-            if (strpos($comparison->getField() . '.', $alias . '.') === 0) {
+            if (str_starts_with($comparison->getField() . '.', $alias . '.')) {
                 $field = $comparison->getField();
                 break;
             }

lib/Doctrine/ORM/Query/ResultSetMapping.php

@@ -73,10 +73,18 @@ class ResultSetMapping
      * Maps column names in the result set to the alias/field name to use in the mapped result.
      *
      * @ignore
-     * @psalm-var array<string, string>
+     * @psalm-var array<string, string|int>
      */
     public $scalarMappings = [];
 
+    /**
+     * Maps scalar columns to enums
+     *
+     * @ignore
+     * @psalm-var array<string, string>
+     */
+    public $enumMappings = [];
+
     /**
      * Maps column names in the result set to the alias/field type to use in the mapped result.
      *
@@ -169,6 +177,7 @@ class ResultSetMapping
      *                                 results or joined entity results within this ResultSetMapping.
      * @param string|null $resultAlias The result alias with which the entity result should be
      *                                 placed in the result structure.
+     * @psalm-param class-string $class
      *
      * @return $this
      *
@@ -315,6 +324,7 @@ class ResultSetMapping
      *                                    the field $fieldName is defined on a subclass, specify that here.
      *                                    If not specified, the field is assumed to belong to the class
      *                                    designated by $alias.
+     * @psalm-param class-string|null $declaringClass
      *
      * @return $this
      *
@@ -344,6 +354,7 @@ class ResultSetMapping
      * @param string $parentAlias The alias of the entity result that is the parent of this joined result.
      * @param string $relation    The association field that connects the parent entity result
      *                            with the joined entity result.
+     * @psalm-param class-string $class
      *
      * @return $this
      *
@@ -361,9 +372,9 @@ class ResultSetMapping
     /**
      * Adds a scalar result mapping.
      *
-     * @param string $columnName The name of the column in the SQL result set.
-     * @param string $alias      The result alias with which the scalar result should be placed in the result structure.
-     * @param string $type       The column type
+     * @param string     $columnName The name of the column in the SQL result set.
+     * @param string|int $alias      The result alias with which the scalar result should be placed in the result structure.
+     * @param string     $type       The column type
      *
      * @return $this
      *
@@ -381,11 +392,26 @@ class ResultSetMapping
         return $this;
     }
 
+    /**
+     * Adds a scalar result mapping.
+     *
+     * @param string $columnName The name of the column in the SQL result set.
+     * @param string $enumType   The enum type
+     *
+     * @return $this
+     */
+    public function addEnumResult($columnName, $enumType)
+    {
+        $this->enumMappings[$columnName] = $enumType;
+
+        return $this;
+    }
+
     /**
      * Adds a metadata parameter mappings.
      *
-     * @param mixed  $parameter The parameter name in the SQL result set.
-     * @param string $attribute The metadata attribute.
+     * @param string|int $parameter The parameter name in the SQL result set.
+     * @param string     $attribute The metadata attribute.
      *
      * @return void
      */
@@ -426,7 +452,7 @@ class ResultSetMapping
      *
      * @param string $columnName The name of the column in the SQL result set.
      *
-     * @return string
+     * @return string|int
      */
     public function getScalarAlias($columnName)
     {
@@ -549,11 +575,11 @@ class ResultSetMapping
     /**
      * Adds a meta column (foreign key or discriminator column) to the result set.
      *
-     * @param string $alias              The result alias with which the meta result should be placed in the result structure.
-     * @param string $columnName         The name of the column in the SQL result set.
-     * @param string $fieldName          The name of the field on the declaring class.
-     * @param bool   $isIdentifierColumn
-     * @param string $type               The column type
+     * @param string      $alias              The result alias with which the meta result should be placed in the result structure.
+     * @param string      $columnName         The name of the column in the SQL result set.
+     * @param string      $fieldName          The name of the field on the declaring class.
+     * @param bool        $isIdentifierColumn
+     * @param string|null $type               The column type
      *
      * @return $this
      *

lib/Doctrine/ORM/Query/ResultSetMappingBuilder.php

@@ -11,11 +11,13 @@ use Doctrine\ORM\Mapping\ClassMetadataInfo;
 use Doctrine\ORM\Mapping\MappingException;
 use Doctrine\ORM\Utility\PersisterHelper;
 use InvalidArgumentException;
+use LogicException;
 
+use function assert;
 use function explode;
 use function in_array;
 use function sprintf;
-use function strpos;
+use function str_contains;
 use function strtolower;
 
 /**
@@ -57,11 +59,13 @@ class ResultSetMappingBuilder extends ResultSetMapping
      * Default column renaming mode.
      *
      * @var int
+     * @psalm-var self::COLUMN_RENAMING_*
      */
     private $defaultRenameMode;
 
     /**
      * @param int $defaultRenameMode
+     * @psalm-param self::COLUMN_RENAMING_* $defaultRenameMode
      */
     public function __construct(EntityManagerInterface $em, $defaultRenameMode = self::COLUMN_RENAMING_NONE)
     {
@@ -76,7 +80,9 @@ class ResultSetMappingBuilder extends ResultSetMapping
      * @param string   $alias          The unique alias to use for the root entity.
      * @param string[] $renamedColumns Columns that have been renamed (tableColumnName => queryColumnName).
      * @param int|null $renameMode     One of the COLUMN_RENAMING_* constants or array for BC reasons (CUSTOM).
+     * @psalm-param class-string $class
      * @psalm-param array<string, string> $renamedColumns
+     * @psalm-param self::COLUMN_RENAMING_*|null $renameMode
      *
      * @return void
      */
@@ -99,7 +105,9 @@ class ResultSetMappingBuilder extends ResultSetMapping
      *                                 with the joined entity result.
      * @param string[] $renamedColumns Columns that have been renamed (tableColumnName => queryColumnName).
      * @param int|null $renameMode     One of the COLUMN_RENAMING_* constants or array for BC reasons (CUSTOM).
+     * @psalm-param class-string $class
      * @psalm-param array<string, string> $renamedColumns
+     * @psalm-param self::COLUMN_RENAMING_*|null $renameMode
      *
      * @return void
      */
@@ -186,6 +194,8 @@ class ResultSetMappingBuilder extends ResultSetMapping
      * Gets column alias for a given column.
      *
      * @psalm-param array<string, string>  $customRenameColumns
+     *
+     * @psalm-assert self::COLUMN_RENAMING_* $mode
      */
     private function getColumnAlias(string $columnName, int $mode, array $customRenameColumns): string
     {
@@ -273,8 +283,10 @@ class ResultSetMappingBuilder extends ResultSetMapping
     public function addNamedNativeQueryResultClassMapping(ClassMetadataInfo $class, $resultClassName)
     {
         $classMetadata = $this->em->getClassMetadata($resultClassName);
-        $shortName     = $classMetadata->reflClass->getShortName();
-        $alias         = strtolower($shortName[0]) . '0';
+        assert($classMetadata->reflClass !== null);
+
+        $shortName = $classMetadata->reflClass->getShortName();
+        $alias     = strtolower($shortName[0]) . '0';
 
         $this->addEntityResult($class->name, $alias);
 
@@ -316,14 +328,19 @@ class ResultSetMappingBuilder extends ResultSetMapping
      */
     public function addNamedNativeQueryResultSetMapping(ClassMetadataInfo $class, $resultSetMappingName)
     {
+        if ($class->reflClass === null) {
+            throw new LogicException('Given class metadata has now class reflector.');
+        }
+
         $counter       = 0;
         $resultMapping = $class->getSqlResultSetMapping($resultSetMappingName);
         $rootShortName = $class->reflClass->getShortName();
         $rootAlias     = strtolower($rootShortName[0]) . $counter;
 
         if (isset($resultMapping['entities'])) {
-            foreach ($resultMapping['entities'] as $key => $entityMapping) {
+            foreach ($resultMapping['entities'] as $entityMapping) {
                 $classMetadata = $this->em->getClassMetadata($entityMapping['entityClass']);
+                assert($classMetadata->reflClass !== null);
 
                 if ($class->reflClass->name === $classMetadata->reflClass->name) {
                     $this->addEntityResult($classMetadata->name, $rootAlias);
@@ -381,7 +398,7 @@ class ResultSetMappingBuilder extends ResultSetMapping
                 $fieldName = $field['name'];
                 $relation  = null;
 
-                if (strpos($fieldName, '.') !== false) {
+                if (str_contains($fieldName, '.')) {
                     [$relation, $fieldName] = explode('.', $fieldName);
                 }
 

lib/Doctrine/ORM/Query/SqlWalker.php

@@ -17,12 +17,15 @@ use Doctrine\ORM\OptimisticLockException;
 use Doctrine\ORM\Query;
 use Doctrine\ORM\Utility\HierarchyDiscriminatorResolver;
 use Doctrine\ORM\Utility\PersisterHelper;
+use InvalidArgumentException;
+use LogicException;
 
 use function array_diff;
 use function array_filter;
 use function array_keys;
 use function array_map;
 use function array_merge;
+use function assert;
 use function count;
 use function implode;
 use function in_array;
@@ -40,6 +43,9 @@ use function trim;
 /**
  * The SqlWalker is a TreeWalker that walks over a DQL AST and constructs
  * the corresponding SQL.
+ *
+ * @psalm-import-type QueryComponent from Parser
+ * @psalm-consistent-constructor
  */
 class SqlWalker implements TreeWalker
 {
@@ -106,7 +112,7 @@ class SqlWalker implements TreeWalker
     /**
      * Map from result variable names to their SQL column alias names.
      *
-     * @psalm-var array<string, string|list<string>>
+     * @psalm-var array<string|int, string|list<string>>
      */
     private $scalarResultAliasMap = [];
 
@@ -127,21 +133,14 @@ class SqlWalker implements TreeWalker
     /**
      * Map of all components/classes that appear in the DQL query.
      *
-     * @psalm-var array<string, array{
-     *                metadata: ClassMetadata,
-     *                parent: string,
-     *                relation: mixed[],
-     *                map: mixed,
-     *                nestingLevel: int,
-     *                token: array
-     *            }>
+     * @psalm-var array<string, QueryComponent>
      */
     private $queryComponents;
 
     /**
      * A list of classes that appear in non-scalar SelectExpressions.
      *
-     * @psalm-var list<array{class: ClassMetadata, dqlAlias: string, resultAlias: string}>
+     * @psalm-var array<string, array{class: ClassMetadata, dqlAlias: string, resultAlias: string|null}>
      */
     private $selectedClasses = [];
 
@@ -175,7 +174,9 @@ class SqlWalker implements TreeWalker
     private $quoteStrategy;
 
     /**
-     * {@inheritDoc}
+     * @param Query        $query        The parsed Query.
+     * @param ParserResult $parserResult The result of the parsing process.
+     * @psalm-param array<string, QueryComponent> $queryComponents The query components (symbol table).
      */
     public function __construct($query, $parserResult, array $queryComponents)
     {
@@ -225,20 +226,22 @@ class SqlWalker implements TreeWalker
      * @param string $dqlAlias The DQL alias.
      *
      * @return mixed[]
-     * @psalm-return array{
-     *     metadata: ClassMetadata,
-     *     parent: string,
-     *     relation: mixed[],
-     *     map: mixed,
-     *     nestingLevel: int,
-     *     token: array
-     * }
+     * @psalm-return QueryComponent
      */
     public function getQueryComponent($dqlAlias)
     {
         return $this->queryComponents[$dqlAlias];
     }
 
+    public function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
+    {
+        if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
+            throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
+        }
+
+        return $this->queryComponents[$dqlAlias]['metadata'];
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -411,6 +414,7 @@ class SqlWalker implements TreeWalker
                 continue;
             }
 
+            assert(isset($qComp['metadata']));
             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
 
             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
@@ -444,7 +448,7 @@ class SqlWalker implements TreeWalker
         $sqlParts = [];
 
         foreach ($dqlAliases as $dqlAlias) {
-            $class = $this->queryComponents[$dqlAlias]['metadata'];
+            $class = $this->getMetadataForDqlAlias($dqlAlias);
 
             if (! $class->isInheritanceTypeSingleTable()) {
                 continue;
@@ -613,7 +617,7 @@ class SqlWalker implements TreeWalker
      */
     public function walkEntityIdentificationVariable($identVariable)
     {
-        $class      = $this->queryComponents[$identVariable]['metadata'];
+        $class      = $this->getMetadataForDqlAlias($identVariable);
         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
         $sqlParts   = [];
 
@@ -634,7 +638,7 @@ class SqlWalker implements TreeWalker
      */
     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
     {
-        $class = $this->queryComponents[$identificationVariable]['metadata'];
+        $class = $this->getMetadataForDqlAlias($identificationVariable);
 
         if (
             $fieldName !== null && $class->isInheritanceTypeJoined() &&
@@ -652,12 +656,13 @@ class SqlWalker implements TreeWalker
     public function walkPathExpression($pathExpr)
     {
         $sql = '';
+        assert($pathExpr->field !== null);
 
         switch ($pathExpr->type) {
             case AST\PathExpression::TYPE_STATE_FIELD:
                 $fieldName = $pathExpr->field;
                 $dqlAlias  = $pathExpr->identificationVariable;
-                $class     = $this->queryComponents[$dqlAlias]['metadata'];
+                $class     = $this->getMetadataForDqlAlias($dqlAlias);
 
                 if ($this->useSqlTableAliases) {
                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
@@ -671,7 +676,7 @@ class SqlWalker implements TreeWalker
                 //    Just use the foreign key, i.e. u.group_id
                 $fieldName = $pathExpr->field;
                 $dqlAlias  = $pathExpr->identificationVariable;
-                $class     = $this->queryComponents[$dqlAlias]['metadata'];
+                $class     = $this->getMetadataForDqlAlias($dqlAlias);
 
                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
@@ -724,9 +729,11 @@ class SqlWalker implements TreeWalker
             $resultAlias = $selectedClass['resultAlias'];
 
             // Register as entity or joined entity result
-            if ($this->queryComponents[$dqlAlias]['relation'] === null) {
+            if (! isset($this->queryComponents[$dqlAlias]['relation'])) {
                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
             } else {
+                assert(isset($this->queryComponents[$dqlAlias]['parent']));
+
                 $this->rsm->addJoinedEntityResult(
                     $class->name,
                     $dqlAlias,
@@ -864,6 +871,7 @@ class SqlWalker implements TreeWalker
     {
         $pathExpression = $indexBy->singleValuedPathExpression;
         $alias          = $pathExpression->identificationVariable;
+        assert($pathExpression->field !== null);
 
         switch ($pathExpression->type) {
             case AST\PathExpression::TYPE_STATE_FIELD:
@@ -873,7 +881,7 @@ class SqlWalker implements TreeWalker
             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
                 // Just use the foreign key, i.e. u.group_id
                 $fieldName = $pathExpression->field;
-                $class     = $this->queryComponents[$alias]['metadata'];
+                $class     = $this->getMetadataForDqlAlias($alias);
 
                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
@@ -956,6 +964,7 @@ class SqlWalker implements TreeWalker
      * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
      * @param int                            $joinType
      * @param AST\ConditionalExpression      $condExpr
+     * @psalm-param AST\Join::JOIN_TYPE_* $joinType
      *
      * @return string
      *
@@ -969,7 +978,8 @@ class SqlWalker implements TreeWalker
         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
         $indexBy                   = $joinAssociationDeclaration->indexBy;
 
-        $relation        = $this->queryComponents[$joinedDqlAlias]['relation'];
+        $relation = $this->queryComponents[$joinedDqlAlias]['relation'] ?? null;
+        assert($relation !== null);
         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
@@ -1321,10 +1331,10 @@ class SqlWalker implements TreeWalker
                     throw QueryException::invalidPathExpression($expr);
                 }
 
+                assert($expr->field !== null);
                 $fieldName = $expr->field;
                 $dqlAlias  = $expr->identificationVariable;
-                $qComp     = $this->queryComponents[$dqlAlias];
-                $class     = $qComp['metadata'];
+                $class     = $this->getMetadataForDqlAlias($dqlAlias);
 
                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
                 $tableName   = $class->isInheritanceTypeJoined()
@@ -1349,6 +1359,10 @@ class SqlWalker implements TreeWalker
                 if (! $hidden) {
                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
+
+                    if (! empty($fieldMapping['enumType'])) {
+                        $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
+                    }
                 }
 
                 break;
@@ -1418,8 +1432,7 @@ class SqlWalker implements TreeWalker
                     $partialFieldSet = [];
                 }
 
-                $queryComp   = $this->queryComponents[$dqlAlias];
-                $class       = $queryComp['metadata'];
+                $class       = $this->getMetadataForDqlAlias($dqlAlias);
                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
 
                 if (! isset($this->selectedClasses[$dqlAlias])) {
@@ -1590,12 +1603,12 @@ class SqlWalker implements TreeWalker
                     break;
 
                 case $e instanceof AST\PathExpression:
+                    assert($e->field !== null);
                     $dqlAlias     = $e->identificationVariable;
-                    $qComp        = $this->queryComponents[$dqlAlias];
-                    $class        = $qComp['metadata'];
-                    $fieldType    = $class->fieldMappings[$e->field]['type'];
+                    $class        = $this->getMetadataForDqlAlias($dqlAlias);
                     $fieldName    = $e->field;
                     $fieldMapping = $class->fieldMappings[$fieldName];
+                    $fieldType    = $fieldMapping['type'];
                     $col          = trim($e->dispatch($this));
 
                     if (isset($fieldMapping['requireSQLConversion'])) {
@@ -1730,7 +1743,7 @@ class SqlWalker implements TreeWalker
                 return $this->walkPathExpression($resultVariable);
             }
 
-            if (isset($resultVariable->pathExpression)) {
+            if ($resultVariable instanceof AST\Node && isset($resultVariable->pathExpression)) {
                 return $this->walkPathExpression($resultVariable->pathExpression);
             }
 
@@ -1740,14 +1753,14 @@ class SqlWalker implements TreeWalker
         // IdentificationVariable
         $sqlParts = [];
 
-        foreach ($this->queryComponents[$groupByItem]['metadata']->fieldNames as $field) {
+        foreach ($this->getMetadataForDqlAlias($groupByItem)->fieldNames as $field) {
             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
 
             $sqlParts[] = $this->walkPathExpression($item);
         }
 
-        foreach ($this->queryComponents[$groupByItem]['metadata']->associationMappings as $mapping) {
+        foreach ($this->getMetadataForDqlAlias($groupByItem)->associationMappings as $mapping) {
             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadataInfo::TO_ONE) {
                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
@@ -1830,7 +1843,7 @@ class SqlWalker implements TreeWalker
         if ($this->em->hasFilters()) {
             $filterClauses = [];
             foreach ($this->rootAliases as $dqlAlias) {
-                $class      = $this->queryComponents[$dqlAlias]['metadata'];
+                $class      = $this->getMetadataForDqlAlias($dqlAlias);
                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
 
                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
@@ -1937,11 +1950,12 @@ class SqlWalker implements TreeWalker
 
         $entityExpr   = $collMemberExpr->entityExpression;
         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
+        assert($collPathExpr->field !== null);
 
         $fieldName = $collPathExpr->field;
         $dqlAlias  = $collPathExpr->identificationVariable;
 
-        $class = $this->queryComponents[$dqlAlias]['metadata'];
+        $class = $this->getMetadataForDqlAlias($dqlAlias);
 
         switch (true) {
             // InputParameter
@@ -2081,7 +2095,7 @@ class SqlWalker implements TreeWalker
         $sql = '';
 
         $dqlAlias   = $instanceOfExpr->identificationVariable;
-        $discrClass = $class = $this->queryComponents[$dqlAlias]['metadata'];
+        $discrClass = $class = $this->getMetadataForDqlAlias($dqlAlias);
 
         if ($class->discriminatorColumn) {
             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
@@ -2152,9 +2166,15 @@ class SqlWalker implements TreeWalker
     public function walkLikeExpression($likeExpr)
     {
         $stringExpr = $likeExpr->stringExpression;
-        $leftExpr   = is_string($stringExpr) && isset($this->queryComponents[$stringExpr]['resultVariable'])
-            ? $this->walkResultVariable($stringExpr)
-            : $stringExpr->dispatch($this);
+        if (is_string($stringExpr)) {
+            if (! isset($this->queryComponents[$stringExpr]['resultVariable'])) {
+                throw new LogicException(sprintf('No result variable found for string expression "%s".', $stringExpr));
+            }
+
+            $leftExpr = $this->walkResultVariable($stringExpr);
+        } else {
+            $leftExpr = $stringExpr->dispatch($this);
+        }
 
         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
 
@@ -2323,6 +2343,10 @@ class SqlWalker implements TreeWalker
      */
     public function walkResultVariable($resultVariable)
     {
+        if (! isset($this->scalarResultAliasMap[$resultVariable])) {
+            throw new InvalidArgumentException(sprintf('Unknown result variable: %s', $resultVariable));
+        }
+
         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
 
         if (is_array($resultAlias)) {