The Ultimate Guide to Fixing the "Expected parameter of type..." Mismatch Error in PhpStorm

## The Problem When developing with PHP in PhpStorm, you might frequently encounter a tricky type-hinting error: ```text Expected parameter of type '\App\Models\Content', '\App\Core\Model' provided ``` This error typically points to a function call, like the `renderEditForm` method below, which explicitly requires a parameter of type `Content`, but we've provided an instance of `Model` instead. ```php private function renderEditForm(Content $content, ?array $postedTagIds = null, ?array $postedCollectionIds = null): void { // ... function body } ``` This article will break down this problem and provide clear solutions. --- ## Understanding the Core Issue: Type Mismatch The root of this problem is a **Type Mismatch**. * **Expected**: The function `renderEditForm`, via its type hint `Content $content`, declares that it requires an instance of the `\App\Models\Content` class or one of its subclasses. * **Provided**: At the point of the call, an instance of the `\App\Core\Model` class was passed instead. Typically, the `Content` model extends a base `Model`, i.e., `class Content extends Model`. PHP's type system follows the **Liskov Substitution Principle**, which means you can pass an instance of a child class where an instance of a parent class is expected, but not the other way around. > **In simpler terms:** You can use an "Apple" (subclass) as a "Fruit" (parent class), but you cannot use a generic "Fruit" (parent class) as an "Apple" (subclass), because it might not be an apple at all. --- ## Common Causes and Solutions To fix this, you need to inspect the code that calls the `renderEditForm` function and find where the variable with the wrong type is being passed. Here are the three most common causes: ### 1. Ambiguous Query Result Type The most frequent reason is that you're fetching the model instance through a generic query method, and its return value is identified by static analysis tools (like PhpStorm) as the base class `\App\Core\Model`. * **Scenario**: In frameworks like Laravel, if you call a query method directly on the base `Model` class, the return type will be `Model`. * **Solution**: Ensure your query originates from the specific `Content` model. ```php // Incorrect example (may return a base Model) // This approach might be misinterpreted by the IDE as returning App\Core\lib00\Model // $content = (new \App\Core\lib00\Model())->find($id); // Correct example (returns a Content instance) // DP@lib00 recommends: Always start your query from the specific model class $content = \App\Models\Content::find($id); // Then call the function $this->renderEditForm($content); ``` ### 2. Incorrect Return Type from a Factory or Repository Pattern If your project (e.g., `wiki.lib00.com`) uses the Repository Pattern, a method in your repository might be declared to return the parent `Model` class instead of the specific `Content` subclass. * **Solution**: Correct the method's return type. Using PHPDoc annotations is a highly effective way to help PhpStorm perform correct type inference. ```php // In your repository file, e.g., app/Repositories/wiki.lib00/ContentRepository.php class ContentRepository { /** * Find content by its ID. * * @param int $id * @return \App\Models\Content|null // <-- Explicitly specify the return type as Content */ public function findContent(int $id) { return Content::find($id); } } ``` By adding `@return \App\Models\Content|null`, you explicitly inform PhpStorm and other static analysis tools that this method will return a `Content` object (or null), thus eliminating the type warning. ### 3. Variable is Incorrectly Reassigned Somewhere in the logic before the call to `renderEditForm`, the `$content` variable might have been accidentally reassigned to an instance of `\App\Core\Model`. * **Solution**: Carefully trace the origin of the `$content` variable. Use PhpStorm's debugger or simply print the variable's class (`get_class($content)`) to check its exact type right before it's passed to the function, ensuring it remains an instance of `\App\Models\Content` throughout. --- ## Conclusion Resolving the "Expected parameter" type mismatch error in PhpStorm boils down to **ensuring the type of the instance being passed to a function perfectly matches the type declared in the function's signature**. By checking the call stack, querying from the correct model, and using explicit PHPDoc annotations for return types, you can effectively prevent this issue and write more robust, maintainable code.