Larastan Livewire

https://github.com/calebdw/larastan-livewire
Admin
A Larastan / PHPStan extension for Laravel Livewire, providing static analysis for computed...
Tokens:16,119
Snippets:183
Trust Score:9.3
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install dependencies with composer update

Source: https://github.com/calebdw/larastan-livewire/blob/master/CONTRIBUTING.md

Installs project dependencies after cloning the fork.

```bash
composer update
```

--------------------------------

### Install with Composer

Source: https://github.com/calebdw/larastan-livewire/blob/master/README.md

Install the package as a dev dependency using Composer. This is the first step to enable static analysis for Livewire components.

```bash
composer require calebdw/larastan-livewire --dev
```

--------------------------------

### Composer extra configuration for auto-discovery

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/configuration.md

Declares the package type and the NEON file to include. The PHPStan extension installer reads this to load extension.neon automatically.

```json
"extra": {
    "phpstan": {
        "includes": [
            "extension.neon"
        ]
    }
}
```

--------------------------------

### Include extension in phpstan.neon

Source: https://github.com/calebdw/larastan-livewire/blob/master/README.md

Manually include the extension in your PHPStan configuration file if you don't have the PHPStan extension installer. This is only needed when the installer is not used.

```neon
includes:
    - ./vendor/calebdw/larastan-livewire/extension.neon
```

--------------------------------

### Suppressed: file-level instantiation of a single-file component

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/AnonymousComponentIgnoreExtension.md

Example of a single-file Livewire component instantiated at file level. Without the extension, PHPStan reports 'Result of `new class` ... is unused' (expr.resultUnused). With the extension, it is silently accepted.

```php
<?php

use Illuminate\View\View;
use Livewire\Component;

new class extends Component
{
    public function render(): View
    {
        return view('welcome');
    }
};
```

--------------------------------

### Anonymous single-file component calling compiled methods

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethodExtension.md

Example of an anonymous Livewire component that uses the compiled 'view' method with an optional data parameter and calls public accessors for script and style module sources. Demonstrates that these methods are available without method.notFound errors.

```php
<?php

use Illuminate\View\View;
use Livewire\Component;

new class extends Component
{
    public function render(): View
    {
        // 'view' is registered with an optional $data parameter: array<mixed, mixed>
        return $this->view(['title' => 'Test']);
    }

    public function testCompiledMethods(): string
    {
        // Public accessors, each typed string — no method.notFound errors
        $this->placeholder();

        return $this->scriptModuleSrc()
            . $this->styleModuleSrc()
            . $this->globalStyleModuleSrc();
    }
};
```

--------------------------------

### Not suppressed: an ordinary unused method

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/UnusedComputedMethodIgnoreExtension.md

Example of a Livewire component with a private method that is not a computed property. The method is reported as unused by PHPStan.

```php
<?php

use Livewire\Component;

class SearchBox extends Component
{
    private function helperNeverCalled(): void
    {
    }

    public function render(): \Illuminate\View\View
    {
        return view('search-box');
    }
}
```

--------------------------------

### Named components are unaffected

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethodExtension.md

Example of a named Livewire component where 'view' is a normal method analyzed from source, not injected by the extension. Because the class is not anonymous, the extension does not claim any methods, so missing methods still report method.notFound.

```php
<?php

use Livewire\Component;

final class SearchBox extends Component
{
    public string $query;

    // 'view' is NOT injected here — this is a normal method PHPStan analyzes from source.
    public function view(): \Illuminate\View\View
    {
        return view('search-box', ['query' => $this->query]);
    }

    public function render(): \Illuminate\View\View
    {
        return $this->view();
    }
}
```

--------------------------------

### Calling view() with the $data parameter

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethod.md

Use this snippet to call the compiled view() method with an array of data. The method signature is view(array<mixed, mixed> $data = []): Illuminate\View\View. This example passes a title and count to the view.

```php
<?php

use Illuminate\View\View;
use Livewire\Component;

new class extends Component
{
    public function render(): View
    {
        // $this->view has the signature view(array<mixed, mixed> $data = []): Illuminate\View\View
        return $this->view(['title' => 'Hello', 'count' => 3]);
    }
};
```

--------------------------------

### Not suppressed: non-component anonymous classes

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/AnonymousComponentIgnoreExtension.md

Example of an anonymous class that does not extend Livewire\Component. shouldIgnore returns false at the isSuperTypeOf check, so PHPStan keeps the unused-result error.

```php
<?php

new class {
    public function greet(): string
    {
        return 'hello';
    }
};
```

--------------------------------

### Suppressed: legacy getter-style computed property

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/UnusedComputedMethodIgnoreExtension.md

Example of a Livewire component with a private getter-style method named getPostProperty. This method matches the legacy pattern and is never reported as unused.

```php
<?php

use Livewire\Component;

class ShowPost extends Component
{
    public int $postId;

    private function getPostProperty(): array
    {
        return Post::find($this->postId)->comments()->pluck('body')->all();
    }

    public function render(): \Illuminate\View\View
    {
        return view('show-post');
    }
}
```

--------------------------------

### Suppressed: private #[Computed] method never called in source

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/UnusedComputedMethodIgnoreExtension.md

Example of a Livewire component with a private method marked #[Computed] that is never called in source. The method is suppressed from unused-method errors because it is a computed property.

```php
<?php

use Livewire\Attributes\Computed;
use Livewire\Component;

class ShowPost extends Component
{
    public int $postId;

    // Livewire calls this at runtime; PHPStan's dead-code check would flag it as unused
    #[Computed]
    private function post(): ?Post
    {
        return Post::find($this->postId);
    }

    public function render(): \Illuminate\View\View
    {
        return view('show-post');
    }
}
```

--------------------------------

### Deprecation passthrough

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Demonstrates that a @deprecated annotation on a computed property is honored when the property is read. PHPStan will flag the read with the specified deprecation message. Use this to mark computed properties as deprecated and guide users to alternatives.

```php
<?php

use Livewire\Attributes\Computed;
use Livewire\Component;

class Profile extends Component
{
    /** @deprecated Use $this->avatarUrl instead. */
    #[Computed]
    public function avatar(): string
    {
        return 'https://cdn.example.com/avatar.png';
    }

    public function render(): View
    {
        // PHPStan flags this read as deprecated, with the message
        // "Use $this->avatarUrl instead."
        return view('profile', ['avatar' => $this->avatar]);
    }
}
```

--------------------------------

### HandlesEvents stub file

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/configuration.md

PHP stub re-declaring the Livewire trait with stricter signatures. Registered via parameters.stubFiles in extension.neon.

```php
trait HandlesEvents
{
    /** @var array<string> */
    protected $listeners = [];

    /**
     * @return array<string>
     */
    protected function getListeners();

    /**
     * @param string $event
     * @param mixed... $params
     *
     * @return Event
     */
    public function dispatch($event, ...$params);
}
```

--------------------------------

### Run all tests with composer test

Source: https://github.com/calebdw/larastan-livewire/blob/master/CONTRIBUTING.md

Runs the full test suite.

```bash
composer test
```

--------------------------------

### Run static analysis with composer test:phpstan

Source: https://github.com/calebdw/larastan-livewire/blob/master/CONTRIBUTING.md

Runs static analysis using PHPStan.

```bash
composer test:phpstan
```

--------------------------------

### extension.neon configuration

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/configuration.md

The entire runtime configuration for the Larastan Livewire PHPStan extension. Registers a stub file and four services with their respective PHPStan tags.

```neon
parameters:
  stubFiles:
    - stubs/Livewire/Features/SupportEvents/HandlesEvents.stub
services:
  - class: CalebDW\LarastanLivewire\Properties\ComputedPropertyExtension
    tags: [phpstan.broker.propertiesClassReflectionExtension]
  - class: CalebDW\LarastanLivewire\Methods\CompiledComponentMethodExtension
    tags: [phpstan.broker.methodsClassReflectionExtension]
  - class: CalebDW\LarastanLivewire\Errors\AnonymousComponentIgnoreExtension
    tags: [phpstan.ignoreErrorExtension]
  - class: CalebDW\LarastanLivewire\Errors\UnusedComputedMethodIgnoreExtension
    tags: [phpstan.ignoreErrorExtension]
```

--------------------------------

### Run PHPUnit tests with composer test:phpunit

Source: https://github.com/calebdw/larastan-livewire/blob/master/CONTRIBUTING.md

Runs PHPUnit tests.

```bash
composer test:phpunit
```

--------------------------------

### Constructor for CompiledComponentMethod

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethod.md

Constructor accepting the declaring class, method name, visibility flag, and overload variants. The $public flag is false for 'view' and true for the four accessors. The $variants parameter is always a single FunctionVariant in practice.

```php
/** @param list<ParametersAcceptor> $variants */
public function __construct(
    private ClassReflection $declaringClass,
    private string $name,
    private bool $public,
    private array $variants,
) {
}
```

--------------------------------

### phpstan.neon.dist configuration for level max

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/configuration.md

Used to analyze the package's own src directory at level max. This is a repository-internal configuration file, not part of the shipped extension.

```neon
parameters:
  level: max
  paths:
    - src
```

--------------------------------

### canChangeTypeAfterAssignment() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Always returns false.

```php
public function canChangeTypeAfterAssignment(): bool
```

--------------------------------

### isStatic() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Always returns false because computed properties are instance properties.

```php
public function isStatic(): bool
```

--------------------------------

### Class declaration of CompiledComponentMethodExtension

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethodExtension.md

Declares the final class implementing MethodsClassReflectionExtension. It has no constructor and is registered in extension.neon with the tag phpstan.broker.methodsClassReflectionExtension.

```php
final class CompiledComponentMethodExtension implements MethodsClassReflectionExtension
```

--------------------------------

### getDeprecatedDescription() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Forwards to the method's getDeprecatedDescription().

```php
public function getDeprecatedDescription(): ?string
```

--------------------------------

### Constructor for ComputedProperty

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Constructor that promotes three parameters: declaring class, method reflection, and readable type. All are private and exposed via getters.

```php
public function __construct(
    private ClassReflection $declaringClass,
    private ExtendedMethodReflection $methodReflection,
    private Type $readableType,
) {
}
```

--------------------------------

### Method signature: isVariadic() returns false

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Indicates the parameter is not variadic.

```php
public function isVariadic(): bool

```

--------------------------------

### isWritable() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Always returns false. Assignments such as $this->post = ... are reported as errors by PHPStan rather than resolved.

```php
public function isWritable(): bool
```

--------------------------------

### Class declaration for CompiledComponentMethod

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethod.md

Declares the final class implementing MethodReflection. Use this as the basis for the value object that represents injected Livewire component methods.

```php
final class CompiledComponentMethod implements MethodReflection
```

--------------------------------

### getDeclaringClass() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Returns the ClassReflection passed to the constructor.

```php
public function getDeclaringClass(): ClassReflection
```

--------------------------------

### Method signature: isOptional() returns true

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Indicates the parameter is optional, so the $data argument of view() may be omitted.

```php
public function isOptional(): bool

```

--------------------------------

### Class declaration for ComputedPropertyExtension

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Declares the final class implementing `PropertiesClassReflectionExtension`. It has no constructor; PHPStan instantiates it via the service container.

```php
final class ComputedPropertyExtension implements PropertiesClassReflectionExtension
```

--------------------------------

### isPrivate() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Always returns false.

```php
public function isPrivate(): bool
```

--------------------------------

### Build a FunctionVariant with variant()

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethodExtension.md

Internal helper that constructs a FunctionVariant with an empty template type map, no named arguments, the given parameters, non-variadic, and the specified return type. The third parameter is the `$isVariadic` flag, passed as `false`.

```php
new FunctionVariant(
    TemplateTypeMap::createEmpty(),
    null,
    $parameters,
    false,          // not variadic
    $returnType,
);
```

--------------------------------

### Method signature: getName() returns 'data'

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Returns the parameter name, which is always 'data'. This method is part of the ParameterReflection interface implementation.

```php
public function getName(): string

```

--------------------------------

### Class declaration for ComputedProperty

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Declares the final class implementing PropertyReflection. Use this as the class signature when implementing the interface.

```php
final class ComputedProperty implements PropertyReflection
```

--------------------------------

### isDeprecated() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Forwards to the method's isDeprecated(), so a /** @deprecated */ doc block on a computed method marks the property deprecated too.

```php
public function isDeprecated(): TrinaryLogic
```

--------------------------------

### isReadable() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Always returns true.

```php
public function isReadable(): bool
```

--------------------------------

### Omitting the argument to view() in anonymous component

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Shows that the $data parameter is optional, so calling view() without arguments is valid in an anonymous Livewire component.

```php
<?php

use Illuminate\View\View;
use Livewire\Component;

new class extends Component
{
    public function render(): View
    {
        // $data is optional — calling with no argument is valid
        return $this->view();
    }
};

```

--------------------------------

### Chaining compiled accessors

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentMethod.md

Use this snippet to chain compiled accessor methods like scriptModuleSrc(), styleModuleSrc(), and globalStyleModuleSrc(). All are typed as string and public, so calls are fully type-checked. Note that view() is not public, so external calls to it would be reported as non-public.

```php
<?php

use Illuminate\View\View;
use Livewire\Component;

new class extends Component
{
    public function boot(): void
    {
        // All typed string, all public — calling them is fully type-checked
        $scripts = $this->scriptModuleSrc();
        $styles  = $this->styleModuleSrc();
        $globals = $this->globalStyleModuleSrc();
    }

    public function render(): View
    {
        return $this->view();
    }
};
```

--------------------------------

### Getter style computed property (legacy)

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Use this snippet for legacy Livewire computed properties defined with a getter method. The getter-style method takes precedence over the attribute style when both are declared on the same class.

```php
<?php

use Livewire\Component;

class ShowPost extends Component
{
    public int $postId;

    // Legacy computed property: $this->postId and $this->post_id are both typed array<int,string>
    public function getPostIdProperty(): array
    {
        return Post::find($this->postId)->comments->pluck('body')->all();
    }

    public function render(): View
    {
        return view('show-post', ['comments' => $this->post_id]);
    }
}
```

--------------------------------

### getProperty method signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Signature of the getProperty method. It takes a ClassReflection and property name, returning a PropertyReflection. PHPStan calls this only after hasProperty() returns true.

```php
public function getProperty(
    ClassReflection $classReflection,
    string $propertyName,
): PropertyReflection
```

--------------------------------

### Class declaration: CompiledComponentParameter implements ParameterReflection

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Declares the final class CompiledComponentParameter implementing the ParameterReflection interface. This class is used to model the optional $data parameter for the compiled view() method in anonymous Livewire single-file components.

```php
final class CompiledComponentParameter implements ParameterReflection

```

--------------------------------

### Method signature: getType() returns array<mixed, mixed>

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Returns an array type with mixed keys and values, representing array<mixed, mixed> for the $data parameter.

```php
public function getType(): Type

```

--------------------------------

### Class declaration for AnonymousComponentIgnoreExtension

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/AnonymousComponentIgnoreExtension.md

Declares the final class that implements PHPStan's IgnoreErrorExtension interface. It has no constructor.

```php
final class AnonymousComponentIgnoreExtension implements IgnoreErrorExtension
```

--------------------------------

### getDocComment() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Forwards the doc comment of the underlying method, so @return, @param, and @deprecated annotations are attached to the property.

```php
public function getDocComment(): ?string
```

--------------------------------

### getterPropertyName

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Constructs the getter-style property name from a given property name, e.g., postId becomes getPostIdProperty.

```APIDOC
## getterPropertyName

### Description
Constructs the getter-style property name from a given property name, e.g., postId becomes getPostIdProperty.

### Method
protected function getterPropertyName(string $propertyName): string

### Parameters
- `$propertyName` (string) - Required - A property name.

### Returns
string - `'get'.Str::studly($propertyName).'Property'`, i.e. `postId` → `getPostIdProperty`, `post_id` → `getPostIdProperty`.
```

--------------------------------

### Method signature: passedByReference() returns PassedByReference::createNo()

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Indicates the parameter is passed by value, not by reference.

```php
public function passedByReference(): PassedByReference

```

--------------------------------

### Reading a computed property with its generic return type

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Shows a Livewire component with a computed property that returns an array of PostComment objects. The generic type is preserved, allowing type-safe iteration and property access. Use this pattern when you need to ensure PHPStan understands the element type of the returned array.

```php
<?php

use Livewire\Attributes\Computed;
use Livewire\Component;

class ShowPost extends Component
{
    public int $postId;

    /**
     * @return array<int, PostComment>
     */
    #[Computed]
    public function comments(): array
    {
        return PostComment::where('post_id', $this->postId)->get()->all();
    }

    public function render(): View
    {
        // $this->comments is array<int, PostComment> — indexed access is type-safe
        foreach ($this->comments as $comment) {
            echo $comment->body; // PostComment::body is known
        }

        return view('show-post');
    }
}
```

--------------------------------

### Passing data to view() in anonymous component

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Shows how to pass an array to the $data parameter of the view() method in an anonymous Livewire component. The $data parameter accepts array<mixed, mixed>; non-array arguments are flagged by PHPStan.

```php
<?php

use Illuminate\View\View;
use Livewire\Component;

new class extends Component
{
    public function render(): View
    {
        // $data accepts array<mixed, mixed>; non-array arguments are flagged by PHPStan
        return $this->view(['message' => 'ok', 'items' => [1, 2, 3]]);
    }
};

```

--------------------------------

### getProperty

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Resolves a computed property for a given class and property name, returning a PropertyReflection. It prefers getter-style method names and falls back to camel-case names.

```APIDOC
## getProperty

### Description
Resolves a computed property for a given class and property name, returning a PropertyReflection. It prefers getter-style method names and falls back to camel-case names.

### Method
public function getProperty(ClassReflection $classReflection, string $propertyName): PropertyReflection

### Parameters
- `$classReflection` (ClassReflection) - Required - The reflected class the property belongs to.
- `$propertyName` (string) - Required - The property name as written in the analyzed code.

### Returns
PropertyReflection - a `ComputedProperty` instance wrapping the underlying method reflection.

### Behavior
Prefers the getter-style name `get{Studly($propertyName)}Property` when such a native method exists, otherwise falls back to the camel-case `Str::camel($propertyName)` name. It then reads the method's return type via `getOnlyVariant()->getReturnType()` and passes it to `ComputedProperty` as the readable type. PHPStan calls this only after `hasProperty()` returned `true`.
```

--------------------------------

### Method signature: getDefaultValue() returns array<mixed, mixed>

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/CompiledComponentParameter.md

Returns the default value for the parameter when omitted, treated as array<mixed, mixed>.

```php
public function getDefaultValue(): Type

```

--------------------------------

### Class declaration for UnusedComputedMethodIgnoreExtension

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/UnusedComputedMethodIgnoreExtension.md

Declares the final class implementing IgnoreErrorExtension. Use this as the class definition for the extension.

```php
final class UnusedComputedMethodIgnoreExtension implements IgnoreErrorExtension

```

--------------------------------

### hasProperty method signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Signature of the `hasProperty` method. It returns `true` if the property should be treated as a resolvable computed property, `false` otherwise.

```php
public function hasProperty(ClassReflection $classReflection, string $propertyName): bool
```

--------------------------------

### Computed Property with Getter Style

Source: https://github.com/calebdw/larastan-livewire/blob/master/README.md

Define a computed property using the legacy getter-style method naming convention. The extension supports this older syntax as well.

```php
<?php

use Livewire\Component;

class ShowPost extends Component
{
    // Computed Property
    public function getPostProperty()
    {
        return Post::find($this->postId);
    }
}
```

--------------------------------

### hasProperty

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Determines whether a given property name should be treated as a resolvable computed property for a Livewire component class.

```APIDOC
## hasProperty

### Description
Checks if a property name corresponds to a Livewire computed property, either via getter-style method or attribute-style method with #[Computed]. Returns true if PHPStan should treat the property as resolvable.

### Method
hasProperty

### Signature
public function hasProperty(ClassReflection $classReflection, string $propertyName): bool

### Parameters
- **$classReflection** (ClassReflection) - Required - The reflected class being probed (a PHPStan class reflection).
- **$propertyName** (string) - Required - The property name as written in the analyzed code (any case, e.g. postId, post_id).

### Returns
- **bool** - true if the property is a resolvable computed property, false otherwise.

### Decision Procedure
1. If the class is not a subclass of Livewire\Component, return false.
2. If a native method named get{Studly($propertyName)}Property exists, return true (getter style).
3. Otherwise compute the camel case of $propertyName via Illuminate\Support\Str::camel. If no native method has that name, return false.
4. Otherwise inspect the method's reflection attributes; return true if Livewire\Attributes\Computed is present, false otherwise.

### Notes
- Only methods physically declared on the class (including traits) count; methods synthesized by other PHPStan extensions are ignored.
```

--------------------------------

### isInternal() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Always returns TrinaryLogic::createNo().

```php
public function isInternal(): TrinaryLogic
```

--------------------------------

### isPublic() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Always returns true, even when the underlying #[Computed] method is private or protected, because Livewire exposes computed properties publicly in blade.

```php
public function isPublic(): bool
```

--------------------------------

### getterPropertyName method signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Signature of the protected getterPropertyName method. It converts a property name to the getter-style name, e.g., postId to getPostIdProperty.

```php
protected function getterPropertyName(string $propertyName): string
```

--------------------------------

### isComputedMethod

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/UnusedComputedMethodIgnoreExtension.md

Determines whether a given method on a Livewire component class is a computed property, either by legacy getter-style naming or by the presence of the #[Computed] attribute.

```APIDOC
## isComputedMethod

### Description
Determines whether a given method on a Livewire component class is a computed property. A method is considered computed if its name matches the legacy getter-style pattern `/^get.+Property$/` or if it carries the `Livewire\Attributes\Computed` attribute.

### Method
`isComputedMethod`

### Signature
```php
public function isComputedMethod(ClassReflection $classReflection, string $methodName): bool
```

### Parameters
- **$classReflection** (ClassReflection) - Required - The component class reflection.
- **$methodName** (string) - Required - A method name (typically extracted from the error message).

### Return Value
- **bool** - `true` if the method is a computed property, `false` otherwise.

### Conditions for Computed Method
A method counts as computed when **either**:
1. Its name matches `preg_match('/^get.+Property$/', $methodName)` — the legacy getter style (`getPostProperty()`, `getPostIdProperty()`, …); or
2. Its reflection (`$classReflection->getNativeReflection()->getMethod($methodName)`) carries the `Livewire\Attributes\Computed` attribute (`getAttributes(Computed::class) !== []`).

The getter-style check needs no reflection, so it also covers methods whose reflection cannot be obtained. Note the method is public — it is exercised directly by the PHPUnit tests.

### Supported Identifiers/Conditions
| Identifier | Suppressed when |
|---|---|
| `method.unused` | the class is a `Component` subclass and the method is getter-style (`get.*Property`) or carries `#[Computed]` |

### Examples

#### Suppressed: private `#[Computed]` method never called in source
```php
<?php

use Livewire\Attributes\Computed;
use Livewire\Component;

class ShowPost extends Component
{
    public int $postId;

    // Livewire calls this at runtime; PHPStan's dead-code check would flag it as unused
    #[Computed]
    private function post(): ?Post
    {
        return Post::find($this->postId);
    }

    public function render(): \Illuminate\View\View
    {
        return view('show-post');
    }
}
```

The fixture `tests/Integration/stubs/UnusedComputedMethod.php` exercises exactly this shape (`computed()` and `getComputedProperty()` are suppressed; `notAComputedProperty()` is not).

#### Suppressed: legacy getter-style computed property
```php
<?php

use Livewire\Component;

class ShowPost extends Component
{
    public int $postId;

    private function getPostProperty(): array
    {
        return Post::find($this->postId)->comments()->pluck('body')->all();
    }

    public function render(): \Illuminate\View\View
    {
        return view('show-post');
    }
}
```

`getPostProperty()` matches `/^get.+Property$/`, so it is never reported as unused even though no code path in source calls it.

#### Not suppressed: an ordinary unused method
```php
<?php

use Livewire\Component;

class SearchBox extends Component
{
    private function helperNeverCalled(): void
    {
    }

    public function render(): \Illuminate\View\View
    {
        return view('search-box');
    }
}
```

`helperNeverCalled` is neither getter-style nor `#[Computed]`, so `isComputedMethod` returns `false` and PHPStan reports `method.unused` as usual.
```

--------------------------------

### isComputedMethod signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/UnusedComputedMethodIgnoreExtension.md

The method signature for isComputedMethod, which takes a ClassReflection and method name, returning a boolean indicating if the method is a computed property.

```php
public function isComputedMethod(ClassReflection $classReflection, string $methodName): bool
```

--------------------------------

### shouldIgnore method signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/AnonymousComponentIgnoreExtension.md

Signature of the shouldIgnore method. It receives the error, AST node, and scope, and returns true if the error should be suppressed.

```php
public function shouldIgnore(Error $error, Node $node, Scope $scope): bool
```

--------------------------------

### getWritableType() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Returns new NeverType() because there is no valid write type for the read-only property.

```php
public function getWritableType(): Type
```

--------------------------------

### Computed Property with Attribute

Source: https://github.com/calebdw/larastan-livewire/blob/master/README.md

Define a computed property using the #[Computed] attribute. The extension resolves the property type from the method's return type.

```php
<?php

use Livewire\Attributes\Computed;
use Livewire\Component;

class ShowPost extends Component
{
    #[Computed]
    public function post()
    {
        return Post::find($this->postId);
    }
}
```

--------------------------------

### Attribute style computed property with #[Computed]

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedPropertyExtension.md

Use this snippet to enable PHPStan type resolution for Livewire computed properties defined with the #[Computed] attribute. Both camelCase and snake_case property accesses resolve to the same typed array.

```php
<?php

use Livewire\Attributes\Computed;
use Livewire\Component;

class ShowPost extends Component
{
    public int $postId;

    // PHPStan now resolves $this->postComments / $this->post_comments, typed array<int, PostComment>
    #[Computed]
    public function postComments(): array
    {
        return PostComment::where('post_id', $this->postId)->get()->all();
    }

    public function render(): View
    {
        // both the camelCase name and its snake_case form resolve to the same property
        $first = $this->post_comments[0] ?? null;

        return view('show-post', ['first' => $first]);
    }
}
```

--------------------------------

### shouldIgnore(Error $error, Node $node, Scope $scope): bool

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/AnonymousComponentIgnoreExtension.md

Determines whether a PHPStan error should be suppressed. Returns true only when the error is 'expr.resultUnused', the node is a no-op expression containing a 'new' expression, and the constructed class is an anonymous class extending Livewire\Component.

```APIDOC
## shouldIgnore(Error $error, Node $node, Scope $scope): bool

### Description
Determines whether a PHPStan error should be suppressed. Returns true only when the error is 'expr.resultUnused', the node is a no-op expression containing a 'new' expression, and the constructed class is an anonymous class extending Livewire\Component.

### Method
shouldIgnore

### Signature
public function shouldIgnore(Error $error, Node $node, Scope $scope): bool

### Parameters
- **$error** (PHPStan\Analyser\Error) - Required - The error PHPStan is about to report.
- **$node** (PhpParser\Node) - Required - The AST node associated with the error.
- **$scope** (PHPStan\Analyser\Scope) - Required - The analysis scope at the node.

### Returns
- **bool** - true if the error should be suppressed.

### Decision Procedure
The error is ignored only when **all** of the following hold:
1. `$error->getIdentifier() === 'expr.resultUnused'`
2. The node is a `PHPStan\Node\NoopExpressionNode`
3. The original expression inside the node is a `PhpParser\Node\Expr\New_`
4. The constructed class is an anonymous class literal with a non-null `extends` clause
5. Resolving the extended class name yields a type of which `new ObjectType(Component::class)` is a super-type (i.e., the anonymous class extends `Livewire\Component`)

If any condition fails, `shouldIgnore` returns `false` and PHPStan processes the error normally.

### Effect on Other Errors
Only `expr.resultUnused` errors matching the anonymous-`Component`-subclass shape are ignored. All other error identifiers are passed through untouched.

### Examples

#### Suppressed: file-level instantiation of a single-file component
```php
<?php

use Illuminate\View\View;
use Livewire\Component;

new class extends Component
{
    public function render(): View
    {
        return view('welcome');
    }
};
```

#### Not suppressed: non-component anonymous classes
```php
<?php

new class {
    public function greet(): string
    {
        return 'hello';
    }
};
```
```

--------------------------------

### getReadableType() signature

Source: https://github.com/calebdw/larastan-livewire/blob/master/_autodocs/api-reference/ComputedProperty.md

Returns the readable type used by PHPStan when the property is read, such as Post|null or array<int,string>.

```php
public function getReadableType(): Type
```
Tokens:
Raw