How to override a falsy @method with a Psalm plugin?

[nikophil]

Hello,

Here is some code from the library Foundry: https://psalm.dev/r/7aa724d1ab

Foundry is a lib which helps to create fixtures, mainly in Symfony's projects.
We're hit by a problem with Psalm: is there any way for Psalm, given in the piece of code above, to not throw an error?

we want to keep the @method annotation, even if it is falsy, because Proxy is a @mixin and a generic class and this is still not understood by IDEs like PHPStorm, so we need this @method annotation for the IDE to provide autocompletion. Moreover this annotation is in code in userland, and we don't have control over it.

I'm looking for a solution in our side: maybe by creating a Psalm's plugin ? that's how we've resolved the problem with PHPStan, but I didn't managed to find the solution with Psalm.

Thank you for your help :)

[orklah]

Moreover this annotation is in code in userland, and we don't have control over it.

By that do you mean that you can't know in which class that annotation will be? Otherwise, I would have suggested to try stubbing the class, but if you don't have control over it, this possibility is out

[nikophil]

Hi, thanks for your answer

no, we don't know the class where is the annotation, all we know is that the class extends our abstract class Factory.

I think stubs are not an option since there could be dozens of children of Factory in userland, each of them with the falsy @method

[orklah]

Indeed. So yeah, plugins may be the solution.

I believe AfterClassLikeVisitInterface could be the solution, you'll have to retrieve the class storage then method storage to change those.

Beware, this plugin is called only when populating cache (which means you'll have to use --no-cache during development)

[nikophil]

thanks a lot @orklah for this hint, I'm gonna test this in few days, and let you know :)

[nikophil]

Hi @orklah
I think I'll need a little more hints about this 😅

let's take a precise case:
We got a method Factory::find() which is annotated:

/**
 * @template T of object
 */
abstract class Factory
{
    /**
     * @return Proxy<T>
     */
    final public static function find($criteria): Proxy

in the child class (in userland) here is how it is described:

/**
 * @extends Factory<Post>
 *
 * @method static Post|Proxy find(object|array|mixed $criteria)
 */
final class PostFactory extends Factory

Psalm reports the following error:

ERROR: ImplementedReturnTypeMismatch - path/to/PostFactory.php:16:19 - The inherited return type 'Zenstruck\Foundry\Proxy<Zenstruck\Foundry\Tests\Fixtures\Entity\Post>' for Zenstruck\Foundry\Factory::find is different to the implemented return type for Zenstruck\Foundry\Factory::find 'Zenstruck\Foundry\Proxy|Zenstruck\Foundry\Tests\Fixtures\Entity\Post'

seems legit: the parent returns a generic type, but the child returns an union type.

By playing around with AfterClassLikeVisit, I manage to localize this find() method:

final class AfterClassLikeVisit implements AfterClassLikeVisitInterface
{
    public static function afterClassLikeVisit(AfterClassLikeVisitEvent $event)
    {
        if (is_a($event->getStorage()->name, Factory::class, true)) {
            foreach ($event->getStorage()->methods as $method) {
                if ($method->cased_name === 'find') {
                    // what should I modify here? 
                }
            }
        }
    }
}

I've tried several things like that, but it's not working:

$method->return_type = $method->signature_return_type = new Type\Union(
    [
        new Type\Atomic\TGenericObject(
            Proxy::class,
            [new Type\Union([new Type\Atomic\TNamedObject(Post::class)])]
        ),
    ]
);

I also tried $method->has_docblock_return_type = false since what I want to achieve is to make psalm forget about the @method stuff.

When I dump the whole MethodStorage before modification, I was expecting to find a union type with Proxy|Post, flagged with from_docblock: true somewhere, but I don't find it.
Here is an exctract of the dump of the object:

^ Psalm\Storage\MethodStorage^ {
  +return_type: Psalm\Type\Union^ {
    -types: array:1 [
      "Zenstruck\Foundry\Proxy<T:Zenstruck\Foundry\Factory>" => Psalm\Type\Atomic\TGenericObject^ {
        +from_docblock: true
        +value: "Zenstruck\Foundry\Proxy"
        +type_params: array:1 [
          0 => Psalm\Type\Union^ {
            -types: array:1 [
              "T:Zenstruck\Foundry\Factory" => Psalm\Type\Atomic\TTemplateParam^ {
                +from_docblock: true
                +param_name: "T"
                +as: Psalm\Type\Union^ {
                  -types: array:1 [
                    "object" => Psalm\Type\Atomic\TObject^ {
                      +from_docblock: false
                    }
                  ]
                  +from_docblock: false
                }
                +defining_class: "Zenstruck\Foundry\Persistence\Factory"
              }
            ]
            +from_docblock: true
          }
        ]
      }
    ]
    +from_docblock: true
  }
  +return_type_location: Psalm\CodeLocation\DocblockTypeLocation^ {
    +file_path: "/app/src/Factory.php"
    +file_name: "src/Factory.php"
  }
  +signature_return_type: Psalm\Type\Union^ {
    -types: array:1 [
      "Zenstruck\Foundry\Proxy" => Psalm\Type\Atomic\TNamedObject^ {
        +from_docblock: false
        +value: "Zenstruck\Foundry\Proxy"
      }
    ]
    +from_docblock: false
  }
  +signature_return_type_location: Psalm\CodeLocation^ {#49751
    +file_path: "/app/src/Factory.php"
    +file_name: "src/Factory.php"
  }
}

The signature_return_type seems odd to me, seems the union type is missing Post 🤔

thanks for your help!

[orklah]

If you're trying to acces @method, I think they're in here instead:

psalm/src/Psalm/Storage/ClassLikeStorage.php

Line 242 in 086b943

public $pseudo_methods = [];

I think emptying that entire property should be enough to make Psalm be unaware of any @method on this class

[nikophil]

yes, you're totally right, everything is working, thanks!