In my project I have multiple objectmanagers.

This currently leads to errors like:

Internal error: The class 'X' was not found in the chain configured namespaces ...

because its using the wrong objectManager (the one returned in object-manager.php) for some entities.

Adds a type parameter TResult on the Doctrine\ORM\Query and Doctrine\ORM\AbstractQuery stubs. This parameter represents the type of the results returned by the getResult() and execute() family of methods, when in HYDRATE_OBJECT mode.

Also adds a DynamicReturnTypeExtension on EntityManager::createQuery() so that TResult is infered from the query string.

As the hydration mode influences the return type of the getResult() and execute() family of methods, we can not just declare that these methods return TResult yet. This will require a DynamicReturnTypeExtension (next PR).

(see issue #221 and the fully functional dev branch with the DynamicReturnTypeExtension)

This allow

$rootAlias = current($query->getQueryBuilder()->getRootAliases());

$queryBuilder->where($rootAlias . '.statusId IN (:statusIds)')

Since version 0.12.18 I have a weird error:

QueryBuilder: [Syntax Error] line 0, col -1: Error: Expected IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression, got end of string.
DQL: SELECT

It is reported in code that uses the QueryBuilder::setParameters() method. I first replaced those calls with several QueryBuilder::setParameter() calls and the errors were not reported anymore, but it was an unsatisfactory solution.

I noticed that in that version, a new stub was added for the QueryBuilder::setParameters() method so I tried editing it. When replacing @return static with @return self, the errors were not reported anymore. I have no idea why this fixes the issue though so please let me know if there's a better way.

Since I updated to the latest version I'm getting this error (but strangely it's only at 1 place in my entire project):

Unable to resolve the template type T in call to method Doctrine\ORM\EntityManager::getRepository()

The line that triggers it:

$repository = $entityManager->getRepository(ApiKeyProjection::class);

By doing it like this, we don't need to instantiate the object manager at all which makes PHPStan run faster and more reliable. Very often I had to manually clear my Symfony cache and re-run PHPStan.

Unfortunately, BetterReflection doesn't support attributes yet so therefore we need to use native ReflectionClass.

See https://github.com/phpstan/phpstan/discussions/5863#discussioncomment-1823297

With the recent addition of literal-types to QueryBuilder (https://github.com/phpstan/phpstan-doctrine/pull/327), I'm getting warnings when passing class-string there: Parameter #1 $from of method Doctrine\ORM\QueryBuilder::from() expects literal-string, class-string given

This is the simplified example to reproduce the issue:

    /**
     * @param class-string $className
     */
    public function getSortable(
        string $className,
    ): ?Sortable
    {
        return $this
            ->entityManager
            ->createQueryBuilder()
            ->select('sortable')
            ->from($className, 'sortable')
            ->getQuery()
            ->getOneOrNullResult();
    }

What is do you think is the correct way to handle this? To me it seems that class-string is more specific type than the literal-string.

cc @VincentLanglet

Continuing on from PR 298, for Issue 294.

I'm starting with:

• Failing tests, confirming these functions don't return a literal-string when there is no Object Manager.
• Changed the requirements to phpstan/phpstan:^1.6.
• Changed selectSingle to selectFromArgs.

I'll continue this next week, but thought I should upload what I've got so far just incase I'm going in the wrong direction.

Previous Diff.

"Implement the logic in stubs with the help of conditional return types"... "The conditional return type for the methods would look like this: @return ($x is literal-string ? literal-string : string)"

I recently decided to give PHPStan a go, but I'm getting over 1,000 errors for type mismatches on my Doctrine entities, such as:

type mapping mismatch: property can contain int|null but database expects int

Perhaps I'm missing something, but I don't believe these should be type mismatches. To provide an example:

class MyEntity
{
    /**
     * @ORM\Column(name="id", type="integer", nullable=false)
     * @ORM\Id
     * @var int|null
     */
    private $id;

    public function getId(): ?int
    {
        return $this->id;
    }
}

$entity = new MyEntity();
$entity->getId(); // this can return null if the entity is not yet hydrated

I understand seeing a type mismatch if the property annotation has nullable=true and the docblock does not include null, this makes sense.

However, there are absolutely times where a property with a NOT NULL constraint on the database column may contain a null value on the entity's property. It seems PHPStan is making the assumption that an entity is always going to be hydrated, but this simply isn't the case. When you create a new entity, all the properties are going to be null regardless of if the database expects those fields to contain NULL values or not.

I would like to suggest a rule to have following functions allowed to have fetch(), fetchAll(), fetchColumn() and rowCount() chained after execute() without getting the errors

Cannot call method fetch() on Doctrine\DBAL\Driver\Statement|int.
Cannot call method fetchAll() on Doctrine\DBAL\Driver\Statement|int.
Cannot call method fetchColumn() on Doctrine\DBAL\Driver\Statement|int.
Cannot call method rowCount() on Doctrine\DBAL\Driver\Statement|int.

The execute() returns int when a count('*') is made instead of a select('*'), therefor with two possible return types PHPStan complains about this.

Code Example

$queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->tableName);
$queueRec = $queryBuilder
    ->select('*')
    ->from($this->tableName)
    ->where(
        $queryBuilder->expr()->eq('qid', $queryBuilder->createNamedParameter($queueId))
    )
    ->execute()
    ->fetch();

My problem currently, as stated on twitter, I'm quite new to PHPStan and would not know where to start to add this rule.

If someone can point me into the direction how to implement this, I would happy to have a look at this, and I don't see it as a error with the current implementation of Doctrine select() and count().

Hope that someone can point me in the right direction.

Version: 1.2.6 to 1.2.8

Very buggy static analyse - sometimes PHPStan is ok and sometimes reports manz errors

Example code:

<?php declare(strict_types = 1);

namespace App\Entities;

use Doctrine\ORM\Mapping as ORM;
use App\Repositories\CountryRepository;

#[ORM\Entity(repositoryClass: CountryRepository::class)]
#[ORM\Table(name: 'countries')]
class Country
{

	#[ORM\Id]
	#[ORM\Column(type: 'integer')]
	#[ORM\GeneratedValue]
	private int $id;

	#[ORM\Column(type: 'string', nullable: false)]
	private string $code;

	#[ORM\Column(type: 'string', nullable: false)]
	private string $country;

	public function getId(): int
	{
		return $this->id;
	}

	public function getCode(): string
	{
		return $this->code;
	}

	public function getCountry(): string
	{
		return $this->country;
	}

	public function setCode(string $code): void
	{
		$this->code = $code;
	}

	public function setCountry(string $country): void
	{
		$this->country = $country;
	}

}
?>

<?php declare(strict_types = 1);

namespace App\Repositories;

use App\Entities\Country;
use App\Model\EntityRepository;

/**
 * @extends EntityRepository<Country>
 */
final class CountryRepository extends EntityRepository
{

}
?>

<?php declare(strict_types = 1);

namespace App\Model;

use Doctrine\ORM\EntityRepository as DoctrineEntityRepository;

/**
 * @template TEntityClass of object
 * @extends  DoctrineEntityRepository<TEntityClass>
 */
abstract class EntityRepository extends DoctrineEntityRepository
{

}

tests/object-manager.php

<?php declare(strict_types = 1);

return App\Bootstrap::boot()
	->createContainer()
	->getByType(App\Model\EntityManagerDecorator::class);

phpstan.neon

parameters:
	level: 8

	doctrine:
		repositoryClass: App\Model\EntityRepository
		objectManagerLoader: tests/object-manager.php

composer packages versions:

beberlei/doctrineextensions	v1.3.0
contributte/console v0.9.1
contributte/di	v0.5.1
doctrine/annotations	1.13.2
doctrine/cache	1.12.1
doctrine/collections	1.6.8
doctrine/common	3.2.1
doctrine/dbal	2.13.7
doctrine/deprecations	v0.5.3
doctrine/event-manager	1.1.1
doctrine/inflector	2.0.4
doctrine/instantiator	1.4.0
doctrine/lexer	1.2.2
doctrine/orm	2.11.1
doctrine/persistence	2.3.0
latte/latte	v2.10.8
nette/application	v3.0.8
nette/bootstrap	v3.0.2
nette/caching	v3.0.2
nette/component-model	v3.0.2
nette/di	v3.0.12
nette/finder	v2.5.3
nette/forms	v3.0.7
nette/http	v3.0.7
nette/mail	v3.1.8
nette/neon	v3.3.2
nette/php-generator	v3.6.5
nette/robot-loader	v3.4.1
nette/routing	v3.0.2
nette/safe-stream	v2.5.0
nette/security	v3.0.6
nette/schema	v1.2.2
nette/tokenizer	v3.1.0
nette/utils	v3.2.7
nettrine/annotations	v0.7.0
nettrine/cache	v0.3.0
nettrine/dbal	v0.7.0
nettrine/extensions-beberlei	v0.2.0
nettrine/orm	v0.8.2
psr/cache	3.0.0
psr/container	2.0.2
symfony/console	v5.4.3
symfony/deprecation-contracts	v3.0.0
symfony/polyfill-ctype	v1.24.0
symfony/polyfill-intl-grapheme	v1.24.0
symfony/polyfill-intl-normalizer	v1.24.0
symfony/polyfill-mbstring	v1.24.0
symfony/polyfill-php72	v1.24.0
symfony/polyfill-php73	v1.24.0
symfony/polyfill-php80	v1.24.0
symfony/service-contracts	v3.0.0
symfony/string	v6.0.3
tracy/tracy	v2.7.8

Dev Packages
nette/tester	v2.4.1
phpstan/extension-installer	1.1.0
phpstan/phpstan	1.4.4
phpstan/phpstan-deprecation-rules	1.0.0
phpstan/phpstan-doctrine	1.2.8
phpstan/phpstan-nette	1.0.0
phpstan/phpstan-strict-rules	1.1.0

Error report:

 ------ ----------------------------------------------------------------------- 
  Line   app/Entities/Country.php                                     
 ------ ----------------------------------------------------------------------- 
  16     Property App\Entities\Country::$id is never written, only    
         read.                                                                  
         💡 See:                                                                 
         https://phpstan.org/developing-extensions/always-read-written-propert  
         ies                                                                    
 ------ ----------------------------------------------------------------------- 

Hi,

I just upgraded from 1.3.29 to 1.3.31, and also doctrine/doctrine-bundle from 2.7.0 to 2.8.2 I have now errors with the repository->findOneBy method which returns now object|null instead of the expected entity or null. I use an objectManagerLoader, I include vendor/phpstan/phpstan-doctrine/extension.neon and vendor/phpstan/phpstan-doctrine/rules.neon. I tried with and without bleedingEdge.

The errors disappear when I downgrade the StubFilesExtensionLoader->getFiles() method and go back to the

return 
[
    $path . '/ORM/QueryBuilder.stub',
    $path . '/EntityRepository.stub',
];

I saw thatan other issue was created and solved by 1.3.30 but it's still not ok for me.

Follow up of https://github.com/phpstan/phpstan-doctrine/pull/404

Fix SingleScalarResult: to fix

$eventsCount = $this->entityManager->createQueryBuilder()
			->select('COUNT(cle.id)')
			->from(CountryLocalityEvent::class, 'cle')
			->andWhere('cle.user = ?', $user)
			->andWhere('cle.expirationTime > ?', DateTimeProvider::now())
			->getQuery()
			->getSingleScalarResult();

		return $eventsCount > 0;

Fix ArrayResult: to fix

$result = $this->entityManager->createQueryBuilder()
			->select('d.name, d.id')
			->from(Destination::class, 'd')
			->addOrderBy('d.name')
			->getQuery()
			->getArrayResult();

		$destinations = [];
		foreach ($result as $item) {
			$destinations[(string) $item['id']->toString()] = (string) $item['name'];
		}

For the last issue @ondrejmirtes,

$query = $this->entityManager->createQueryBuilder()
			->select('IDENTITY(n.related)')
			->from(DistrictNeighbour::class, 'n')
			->andWhere('n.center = ?', $districtId)
			->getQuery();

		return array_map(static fn (array $row): UuidInterface => $row['related'], $query->getArrayResult());

I wonder if it couldn't be a bug in your codebase.

• There is a Test for the Identity function checking it's indexed by 1, 2, 3, ... https://github.com/phpstan/phpstan-doctrine/blob/1.3.x/tests/Type/Doctrine/Query/QueryResultTypeWalkerTest.php#L1394-L1419
• Expectations are double-checked with the result from a database https://github.com/phpstan/phpstan-doctrine/blob/1.3.x/tests/Type/Doctrine/Query/QueryResultTypeWalkerTest.php#L215-L233

This fixes #202.

• Prevent Doctrine entities from containing private constructors
• At the same time, don't forbid non-constructor methods in Doctrine entities

What do you think about that?

Following error appeared after upgrading from 1.3.14 to 1.3.15. Easily fixable by using array and creating collection later, so I assume this is minor issue.

/**
 * @return Collection<int, Account>
 */
public function getAccounts(): Collection
{
    $accounts = new ArrayCollection();

    foreach ($this->users as $user) {
        $account = $user->getAccount();

        if (!$accounts->contains($account)) { // error: Negated boolean expression is always true. 
            $accounts->add($account);
        }
    }

    return $accounts;
}

I have a method as follows:

protected function foo(): void {
    $qb = $this->entityManager->createQueryBuilder();
    if (mt_rand(0, 1) === 0) {
        $qb->select('e.f1', 'e.f2');
    }
    else {
        $qb->select('e.f3', 'e.f4');
    }
    \PHPStan\dumpType($qb);
    $qb->select('e.f5', 'e.f6');
}

I get the following output:

  117    Dumped type: Doctrine\ORM\QueryBuilder|Doctrine\ORM\QueryBuilder
  118    Method Doctrine\ORM\QueryBuilder::select() invoked with 2 parameters, 0-1 required.

I only marginally know how the query builder code works, but I xdebugged it as far as to see that the union is done between two BranchingQueryBuilderType instances and they are not considered equal due to different methods having been called on them. So not collapsing the union seems expected, but then maybe the code that validates the select() call cannot handle unions or something like that.

I imagine that this is hard to reproduce, since it might depend on the exact Doctrine configuration. Let me know if I should attempt to create a full stand-alone example that triggers the issue.

Using phpstan/phpstan-doctrine 1.3.12 and phpstan/phpstan 1.8.4.