├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── all_tests.yml
├── .gitignore
├── LICENSE
├── README.md
├── composer.json
├── ecs.php
├── extension.neon
├── phpstan.neon
├── phpunit.xml
├── psalm.xml
├── src
    └── Parser
    │   └── AttributeParser.php
└── tests
    ├── AssertAttributeTest.php
    ├── AssertIfFalseAttributeTest.php
    ├── AssertIfTrueAttributeTest.php
    ├── BaseAttributeTestCase.php
    ├── DefineTypeAttributeTest.php
    ├── DeprecatedAttributeTest.php
    ├── ImmutableAttributeTest.php
    ├── ImportTypeAttributeTest.php
    ├── ImpureAttributeTest.php
    ├── InternalAttributeTest.php
    ├── IsReadOnlyAttributeTest.php
    ├── MethodAttributeTest.php
    ├── MixinAttributeTest.php
    ├── ParamAttributeTest.php
    ├── ParamOutAttributeTest.php
    ├── PropertyAttributeTest.php
    ├── PropertyReadAttributeTest.php
    ├── PropertyWriteAttributeTest.php
    ├── PureAttributeTest.php
    ├── RequireExtendsAttributeTest.php
    ├── RequireImplementsAttributeTest.php
    ├── ReturnsAttributeTest.php
    ├── SelfOutAttributeTest.php
    ├── TemplateAttributeTest.php
    ├── TemplateContravariantAttributeTest.php
    ├── TemplateCovariantAttributeTest.php
    ├── TemplateExtendsAttributeTest.php
    ├── TemplateImplementsAttributeTest.php
    ├── TemplateUseAttributeTest.php
    ├── ThrowsAttributeTest.php
    ├── TypeAttributeTest.php
    ├── conf
        ├── deprecated.neon
        ├── readonly.neon
        └── throws.neon
    └── data
        ├── Assert
            ├── FunctionAssertAttribute.php
            ├── InvalidMethodAssertAttribute.php
            └── MethodAssertAttribute.php
        ├── AssertIfFalse
            ├── FunctionAssertIfFalseAttribute.php
            ├── InvalidMethodAssertIfFalseAttribute.php
            └── MethodAssertIfFalseAttribute.php
        ├── AssertIfTrue
            ├── FunctionAssertIfTrueAttribute.php
            ├── InvalidMethodAssertIfTrueAttribute.php
            └── MethodAssertIfTrueAttribute.php
        ├── DefineType
            ├── ClassDefineTypeAttribute.php
            ├── InterfaceDefineTypeAttribute.php
            ├── InvalidClassDefineTypeAttribute.php
            └── TraitDefineTypeAttribute.php
        ├── Deprecated
            ├── ClassDeprecatedAttribute.php
            ├── FunctionDeprecatedAttribute.php
            ├── InterfaceDeprecatedAttribute.php
            ├── InvalidMethodDeprecatedAttribute.php
            ├── MethodDeprecatedAttribute.php
            ├── PropertyDeprecatedAttribute.php
            └── TraitDeprecatedAttribute.php
        ├── Immutable
            ├── ClassImmutableAttribute.php
            ├── InterfaceImmutableAttribute.php
            ├── InvalidClassImmutableAttribute.php
            └── TraitImmutableAttribute.php
        ├── ImportType
            ├── ClassImportTypeAttribute.php
            ├── InterfaceImportTypeAttribute.php
            ├── InvalidClassImportTypeAttribute.php
            └── TraitImportTypeAttribute.php
        ├── Impure
            ├── FunctionImpureAttribute.php
            ├── InvalidMethodImpureAttribute.php
            └── MethodImpureAttribute.php
        ├── Internal
            ├── ClassInternalAttribute.php
            ├── FunctionInternalAttribute.php
            ├── InterfaceInternalAttribute.php
            ├── InvalidMethodInternalAttribute.php
            ├── MethodInternalAttribute.php
            ├── PropertyInternalAttribute.php
            └── TraitInternalAttribute.php
        ├── IsReadOnly
            ├── InvalidPropertyIsReadOnlyAttribute.php
            └── PropertyIsReadOnlyAttribute.php
        ├── Method
            ├── ClassMethodAttribute.php
            ├── InterfaceMethodAttribute.php
            ├── InvalidClassMethodAttribute.php
            └── TraitMethodAttribute.php
        ├── Mixin
            ├── ClassMixinAttribute.php
            ├── InterfaceMixinAttribute.php
            ├── InvalidClassMixinAttribute.php
            └── TraitMixinAttribute.php
        ├── Param
            ├── FunctionParamAttribute.php
            ├── InvalidMethodParamAttribute.php
            └── MethodParamAttribute.php
        ├── ParamOut
            ├── FunctionParamOutAttribute.php
            ├── InvalidMethodParamOutAttribute.php
            └── MethodParamOutAttribute.php
        ├── Property
            ├── ClassPropertyAttribute.php
            ├── InterfacePropertyAttribute.php
            ├── InvalidClassPropertyAttribute.php
            └── TraitPropertyAttribute.php
        ├── PropertyRead
            ├── ClassPropertyReadAttribute.php
            ├── InterfacePropertyReadAttribute.php
            ├── InvalidClassPropertyReadAttribute.php
            └── TraitPropertyReadAttribute.php
        ├── PropertyWrite
            ├── ClassPropertyWriteAttribute.php
            ├── InterfacePropertyWriteAttribute.php
            ├── InvalidClassPropertyWriteAttribute.php
            └── TraitPropertyWriteAttribute.php
        ├── Pure
            ├── FunctionPureAttribute.php
            ├── InvalidMethodPureAttribute.php
            └── MethodPureAttribute.php
        ├── RequireExtends
            ├── InvalidTraitRequireExtendsAttribute.php
            └── TraitRequireExtendsAttribute.php
        ├── RequireImplements
            ├── InvalidTraitRequireImplementsAttribute.php
            └── TraitRequireImplementsAttribute.php
        ├── Returns
            ├── FunctionReturnsAttribute.php
            ├── InvalidMethodReturnsAttribute.php
            └── MethodReturnsAttribute.php
        ├── SelfOut
            ├── InvalidMethodSelfOutAttribute.php
            └── MethodSelfOutAttribute.php
        ├── Template
            ├── ClassTemplateAttribute.php
            ├── FunctionTemplateAttribute.php
            ├── InterfaceTemplateAttribute.php
            ├── InvalidMethodTemplateAttribute.php
            ├── MethodTemplateAttribute.php
            └── TraitTemplateAttribute.php
        ├── TemplateContravariant
            ├── ClassTemplateContravariantAttribute.php
            ├── InterfaceTemplateContravariantAttribute.php
            ├── InvalidClassTemplateContravariantAttribute.php
            └── TraitTemplateContravariantAttribute.php
        ├── TemplateCovariant
            ├── ClassTemplateCovariantAttribute.php
            ├── InterfaceTemplateCovariantAttribute.php
            ├── InvalidClassTemplateCovariantAttribute.php
            └── TraitTemplateCovariantAttribute.php
        ├── TemplateExtends
            ├── ClassTemplateExtendsAttribute.php
            └── InvalidClassTemplateExtendsAttribute.php
        ├── TemplateImplements
            ├── InterfaceTemplateImplementsAttribute.php
            └── InvalidInterfaceTemplateImplementsAttribute.php
        ├── TemplateUse
            ├── InvalidTraitTemplateUseAttribute.php
            └── TraitTemplateUseAttribute.php
        ├── Throws
            ├── FunctionThrowsAttribute.php
            ├── InvalidMethodThrowsAttribute.php
            └── MethodThrowsAttribute.php
        └── Type
            ├── InvalidPropertyTypeAttribute.php
            └── PropertyTypeAttribute.php


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: [carlos-granados]
2 | 


--------------------------------------------------------------------------------
/.github/workflows/all_tests.yml:
--------------------------------------------------------------------------------
 1 | name: "All Tests"
 2 | 
 3 | on:
 4 |     pull_request:
 5 |     push:
 6 | 
 7 | jobs:
 8 |     test:
 9 |         name: "Run all checks for all supported PHP versions"
10 | 
11 |         runs-on: "ubuntu-22.04"
12 | 
13 |         strategy:
14 |             fail-fast: false
15 |             matrix:
16 |                 php-version:
17 |                     - "8.1"
18 |                     - "8.2"
19 |                     - "8.3"
20 |                     - "8.4"
21 | 
22 |         steps:
23 |             - name: "Checkout"
24 |               uses: "actions/checkout@v4"
25 | 
26 |             - name: "Install PHP"
27 |               uses: "shivammathur/setup-php@v2"
28 |               with:
29 |                   php-version: "${{ matrix.php-version }}"
30 |                   tools: composer
31 | 
32 |             - name: Get composer cache directory
33 |               id: composercache
34 |               run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
35 | 
36 |             - name: Cache dependencies
37 |               uses: actions/cache@v4
38 |               with:
39 |                   path: ${{ steps.composercache.outputs.dir }}
40 |                   key: "php-${{ matrix.php-version }}-${{ hashFiles('**/composer.lock') }}"
41 |                   restore-keys: "php-${{ matrix.php-version }}-${{ hashFiles('**/composer.lock') }}"
42 | 
43 |             - name: "Install composer dependencies"
44 |               run: "composer install --no-interaction --no-progress"
45 | 
46 |             - name: "Run tests"
47 |               run: "composer tests-without-psalm"
48 | 
49 |             - name: "Run Psalm"
50 |               if: matrix.php-version != '8.4' # Psalm does not fully support PHP 8.4 yet
51 |               run: "composer psalm"


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | composer.lock
3 | .idea
4 | .phpunit.cache
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 php-static-analysis
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # PHP Static Analysis Attributes PHPStan Extension
  2 | [![Continuous Integration](https://github.com/php-static-analysis/phpstan-extension/workflows/All%20Tests/badge.svg)](https://github.com/php-static-analysis/phpstan-extension/actions)
  3 | [![Latest Stable Version](https://poser.pugx.org/php-static-analysis/phpstan-extension/v/stable)](https://packagist.org/packages/php-static-analysis/phpstan-extension)
  4 | [![License](https://poser.pugx.org/php-static-analysis/phpstan-extension/license)](https://github.com/php-static-analysis/phpstan-extension/blob/main/LICENSE)
  5 | [![Total Downloads](https://poser.pugx.org/php-static-analysis/phpstan-extension/downloads)](https://packagist.org/packages/php-static-analysis/phpstan-extension/stats)
  6 | 
  7 | Since the release of PHP 8.0 more and more libraries, frameworks and tools have been updated to use attributes instead of annotations in PHPDocs.
  8 | 
  9 | However, static analysis tools like PHPStan have not made this transition to attributes and they still rely on annotations in PHPDocs for a lot of their functionality.
 10 | 
 11 | This is a PHPStan extension that allows PHPStan to understand a new set of attributes that replace the PHPDoc annotations. These attributes are defined in [this repository](https://github.com/php-static-analysis/attributes)
 12 | 
 13 | ## Example
 14 | 
 15 | In order to show how code would look with these attributes, we can look at the following example. This is how a class looks like with the current annotations:
 16 | 
 17 | ```php
 18 | <?php
 19 | 
 20 | class ArrayAdder
 21 | {
 22 |     /** @var array<string>  */
 23 |     private array $result;
 24 | 
 25 |     /**
 26 |      * @param array<string> $array1
 27 |      * @param array<string> $array2
 28 |      * @return array<string>
 29 |      */
 30 |     public function addArrays(array $array1, array $array2): array
 31 |     {
 32 |         $this->result = $array1 + $array2;
 33 |         return $this->result;
 34 |     }
 35 | }
 36 | ```
 37 | 
 38 | And this is how it would look like using the new attributes:
 39 | 
 40 | ```php
 41 | <?php
 42 | 
 43 | use PhpStaticAnalysis\Attributes\Type;
 44 | use PhpStaticAnalysis\Attributes\Param;
 45 | use PhpStaticAnalysis\Attributes\Returns;
 46 | 
 47 | class ArrayAdder
 48 | {
 49 |     #[Type('array<string>')]
 50 |     private array $result;
 51 | 
 52 |     #[Param(array1: 'array<string>')]
 53 |     #[Param(array2: 'array<string>')]
 54 |     #[Returns('array<string>')]
 55 |     public function addArrays(array $array1, array $array2): array
 56 |     {
 57 |         $this->array = $array1 + $array2;
 58 |         return $this->array;
 59 |     }
 60 | }
 61 | ```
 62 | 
 63 | ## Installation
 64 | 
 65 | First of all, to make the attributes available for your codebase use:
 66 | 
 67 | ```
 68 | composer require php-static-analysis/attributes
 69 | ```
 70 | 
 71 | To use this extension, require it in Composer:
 72 | 
 73 | ```
 74 | composer require --dev php-static-analysis/phpstan-extension
 75 | ```
 76 | 
 77 | If you also install [phpstan/extension-installer](https://github.com/phpstan/extension-installer) then you're all set!
 78 | 
 79 | <details>
 80 |   <summary>Manual installation</summary>
 81 | 
 82 | If you don't want to use `phpstan/extension-installer`, include `extension.neon` in your project's PHPStan config:
 83 | 
 84 | ```
 85 | includes:
 86 |     - vendor/php-static-analysis/phpstan-extension/extension.neon
 87 | ```
 88 | </details>
 89 | 
 90 | ## Using the extension
 91 | 
 92 | This extension works by interacting with the parser that PHPStan uses to parse the code and replacing the new Attributes with PHPDoc annotations that PHPStan can understand. The functionality provided by the attribute is exactly the same as the one provided by the corresponding PHPDoc annotation.
 93 | 
 94 | These are the available attributes and their corresponding PHPDoc annotations:
 95 | 
 96 | | Attribute                                                                                                         | PHPDoc Annotations                   |
 97 | |-------------------------------------------------------------------------------------------------------------------|--------------------------------------|
 98 | | [Assert](https://github.com/php-static-analysis/attributes/blob/main/doc/Assert.md)                               | `@assert`                            |
 99 | | [AssertIfFalse](https://github.com/php-static-analysis/attributes/blob/main/doc/AssertIfFalse.md)           | `@assert-if-false`                   |
100 | | [AssertIfTrue](https://github.com/php-static-analysis/attributes/blob/main/doc/AssertIfTrue.md)             | `@assert-if-true`                    |
101 | | [DefineType](https://github.com/php-static-analysis/attributes/blob/main/doc/DefineType.md)                       | `@type`                              |
102 | | [Deprecated](https://github.com/php-static-analysis/attributes/blob/main/doc/Deprecated.md)                       | `@deprecated`                        |
103 | | [Immmutable](https://github.com/php-static-analysis/attributes/blob/main/doc/Immmutable.md)                       | `@immmutable`                        |
104 | | [ImportType](https://github.com/php-static-analysis/attributes/blob/main/doc/ImportType.md)                       | `@import-type`                       |
105 | | [Impure](https://github.com/php-static-analysis/attributes/blob/main/doc/Impure.md)                               | `@impure`                            |
106 | | [Internal](https://github.com/php-static-analysis/attributes/blob/main/doc/Internal.md)                           | `@internal`                          |
107 | | [IsReadOnly](https://github.com/php-static-analysis/attributes/blob/main/doc/IsReadOnly.md)                       | `@readonly`                          |
108 | | [Method](https://github.com/php-static-analysis/attributes/blob/main/doc/Method.md)                               | `@method`                            |
109 | | [Mixin](https://github.com/php-static-analysis/attributes/blob/main/doc/Mixin.md)                                 | `@mixin`                             |
110 | | [Param](https://github.com/php-static-analysis/attributes/blob/main/doc/Param.md)                                 | `@param`                             |
111 | | [ParamOut](https://github.com/php-static-analysis/attributes/blob/main/doc/ParamOut.md)                           | `@param-out`                         |
112 | | [Property](https://github.com/php-static-analysis/attributes/blob/main/doc/Property.md)                           | `@property` `@var`                   |
113 | | [PropertyRead](https://github.com/php-static-analysis/attributes/blob/main/doc/PropertyRead.md)                   | `@property-read`                     |
114 | | [PropertyWrite](https://github.com/php-static-analysis/attributes/blob/main/doc/PropertyWrite.md)                 | `@property-write`                    |
115 | | [Pure](https://github.com/php-static-analysis/attributes/blob/main/doc/Pure.md)                                   | `@pure`                              |
116 | | [RequireExtends](https://github.com/php-static-analysis/attributes/blob/main/doc/RequireExtends.md)               | `@require-extends`                   |
117 | | [RequireImplements](https://github.com/php-static-analysis/attributes/blob/main/doc/RequireImplements.md)         | `@require-implements`                |
118 | | [Returns](https://github.com/php-static-analysis/attributes/blob/main/doc/Returns.md)                             | `@return`                            |
119 | | [SelfOut](https://github.com/php-static-analysis/attributes/blob/main/doc/SelfOut.md)                             | `@self-out` `@this-out`              |
120 | | [Template](https://github.com/php-static-analysis/attributes/blob/main/doc/Template.md)                           | `@template`                          |
121 | | [TemplateContravariant](https://github.com/php-static-analysis/attributes/blob/main/doc/TemplateContravariant.md) | `@template-contravariant`            |
122 | | [TemplateCovariant](https://github.com/php-static-analysis/attributes/blob/main/doc/TemplateCovariant.md)         | `@template-covariant`                |
123 | | [TemplateExtends](https://github.com/php-static-analysis/attributes/blob/main/doc/TemplateExtends.md)             | `@extends` `@template-extends`       |
124 | | [TemplateImplements](https://github.com/php-static-analysis/attributes/blob/main/doc/TemplateImplements.md)       | `@implements` `@template-implements` |
125 | | [TemplateUse](https://github.com/php-static-analysis/attributes/blob/main/doc/TemplateUse.md)                     | `@use` `@template-use`               |
126 | | [Throws](https://github.com/php-static-analysis/attributes/blob/main/doc/Throws.md)                               | `@throws`                            |
127 | | [Type](https://github.com/php-static-analysis/attributes/blob/main/doc/Type.md)                                   | `@var` `@return`                     |
128 | 
129 | ## Sponsor this project
130 | 
131 | If you would like to support the development of this project, please consider [sponsoring me](https://github.com/sponsors/carlos-granados)
132 | 
133 | 
134 | 
135 | 
136 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "php-static-analysis/phpstan-extension",
 3 |     "description": "PHPStan extension to read static analysis attributes",
 4 |     "type": "phpstan-extension",
 5 |     "keywords": ["dev", "static analysis"],
 6 |     "license": "MIT",
 7 |     "autoload": {
 8 |         "psr-4": {
 9 |             "PhpStaticAnalysis\\PHPStanExtension\\": "src/"
10 |         }
11 |     },
12 |     "autoload-dev": {
13 |         "psr-4": {
14 |             "test\\PhpStaticAnalysis\\PHPStanExtension\\": "tests/"
15 |         }
16 |     },
17 |     "authors": [
18 |         {
19 |             "name": "Carlos Granados",
20 |             "email": "carlos@fastdebug.io"
21 |         }
22 |     ],
23 |     "minimum-stability": "dev",
24 |     "prefer-stable": true,
25 |     "require": {
26 |         "php": ">=8.1",
27 |         "php-static-analysis/attributes": "^0.5.0 || dev-main",
28 |         "php-static-analysis/node-visitor": "^0.5.0 || dev-main",
29 |         "phpstan/phpstan": "^2.0",
30 |         "webmozart/assert": "^1.11"
31 |     },
32 |     "require-dev": {
33 |         "php-static-analysis/psalm-plugin": "^0.5.0 || dev-main",
34 |         "phpstan/phpstan-deprecation-rules": "^2.0",
35 |         "phpunit/phpunit": "^9.0",
36 |         "symplify/easy-coding-standard": "^12.1",
37 |         "vimeo/psalm": "^6"
38 |     },
39 |     "extra": {
40 |         "phpstan": {
41 |             "includes": [
42 |                 "extension.neon"
43 |             ]
44 |         }
45 |     },
46 |     "config": {
47 |         "sort-packages": true,
48 |         "allow-plugins": {
49 |             "php-static-analysis/psalm-plugin": true
50 |         }
51 |     },
52 |     "scripts": {
53 |         "phpstan": "phpstan analyse",
54 |         "phpstan-debug": "phpstan analyse --xdebug --debug",
55 |         "ecs": "ecs",
56 |         "ecs-fix": "ecs --fix",
57 |         "phpunit": "phpunit",
58 |         "psalm": "psalm",
59 |         "tests": [
60 |             "@ecs",
61 |             "@phpstan",
62 |             "@phpunit",
63 |             "@psalm"
64 |         ],
65 |         "tests-without-psalm": [
66 |             "@ecs",
67 |             "@phpstan",
68 |             "@phpunit"
69 |         ]
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/ecs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use PhpCsFixer\Fixer\Import\NoUnusedImportsFixer;
 6 | use Symplify\EasyCodingStandard\Config\ECSConfig;
 7 | 
 8 | return ECSConfig::configure()
 9 |     ->withPaths([
10 |         __DIR__ . '/src',
11 |         __DIR__ . '/tests',
12 |     ])
13 |     ->withPreparedSets(
14 |         psr12: true,
15 |     );
16 | 


--------------------------------------------------------------------------------
/extension.neon:
--------------------------------------------------------------------------------
 1 | services:
 2 | 	attributeParser:
 3 | 		class: PhpStaticAnalysis\PHPStanExtension\Parser\AttributeParser
 4 | 		arguments:
 5 | 			parser: @pathRoutingParser
 6 | 		autowired: false
 7 | 
 8 | 	defaultAnalysisParser:
 9 | 		class: PHPStan\Parser\CachedParser
10 | 		arguments:
11 | 			originalParser: @attributeParser
12 | 			cachedNodesByStringCountMax: %cache.nodesByStringCountMax%
13 | 		autowired: false
14 | 


--------------------------------------------------------------------------------
/phpstan.neon:
--------------------------------------------------------------------------------
 1 | includes:
 2 |     - extension.neon
 3 | 
 4 | parameters:
 5 |     level: max
 6 |     paths:
 7 |         - src
 8 |         - tests
 9 |     excludePaths:
10 |         - tests/data/*
11 |     ignoreErrors:
12 |         -
13 |             identifier: phpstanApi.classConstant
14 |             path: tests/BaseAttributeTestCase.php
15 |         -
16 |             identifier: phpstanApi.method
17 |             path: tests/BaseAttributeTestCase.php
18 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.6/phpunit.xsd"
 4 |          bootstrap="vendor/autoload.php"
 5 |          cacheResultFile=".phpunit.cache/test-results"
 6 |          executionOrder="depends,defects"
 7 |          beStrictAboutCoversAnnotation="true"
 8 |          beStrictAboutOutputDuringTests="true"
 9 |          beStrictAboutTodoAnnotatedTests="true"
10 |          convertDeprecationsToExceptions="true"
11 |          failOnRisky="true"
12 |          failOnWarning="true"
13 |          verbose="true">
14 |     <testsuites>
15 |         <testsuite name="default">
16 |             <directory>tests</directory>
17 |         </testsuite>
18 |     </testsuites>
19 | </phpunit>


--------------------------------------------------------------------------------
/psalm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <psalm
 3 |         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |         xmlns="https://getpsalm.org/schema/config"
 5 |         xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
 6 | 
 7 |         errorLevel="1"
 8 |         findUnusedBaselineEntry="true"
 9 |         findUnusedCode="false"
10 |         ensureOverrideAttribute="false"
11 | >
12 |     <projectFiles>
13 |         <directory name="src" />
14 |         <directory name="tests" />
15 |         <ignoreFiles>
16 |             <directory name="tests/data" />
17 |         </ignoreFiles>
18 |     </projectFiles>
19 | 
20 |     <plugins>
21 |         <pluginClass class="PhpStaticAnalysis\PsalmPlugin\Plugin" />
22 |     </plugins>
23 | </psalm>
24 | 


--------------------------------------------------------------------------------
/src/Parser/AttributeParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpStaticAnalysis\PHPStanExtension\Parser;
 6 | 
 7 | use PhpParser\Node\Stmt;
 8 | use PhpParser\NodeTraverser;
 9 | use PHPStan\Parser\Parser;
10 | use PhpStaticAnalysis\Attributes\Param;
11 | use PhpStaticAnalysis\Attributes\Returns;
12 | use PhpStaticAnalysis\NodeVisitor\AttributeNodeVisitor;
13 | use Webmozart\Assert\Assert;
14 | 
15 | final class AttributeParser implements Parser
16 | {
17 |     public function __construct(
18 |         private Parser $parser
19 |     ) {
20 |     }
21 | 
22 |     public function parseFile(string $file): array
23 |     {
24 |         $ast = $this->parser->parseFile($file);
25 |         return $this->traverseAst($ast);
26 |     }
27 | 
28 |     public function parseString(string $sourceCode): array
29 |     {
30 |         $ast = $this->parser->parseString($sourceCode);
31 |         return $this->traverseAst($ast);
32 |     }
33 | 
34 |     #[Param(ast: 'Stmt[]')]
35 |     #[Returns('Stmt[]')]
36 |     private function traverseAst(array $ast): array
37 |     {
38 |         $traverser = new NodeTraverser();
39 |         $nodeVisitor = new AttributeNodeVisitor(AttributeNodeVisitor::TOOL_PHPSTAN);
40 |         $traverser->addVisitor($nodeVisitor);
41 | 
42 |         $ast = $traverser->traverse($ast);
43 |         Assert::allIsInstanceOf($ast, Stmt::class);
44 |         return $ast;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/AssertAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class AssertAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodAssertAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Assert/MethodAssertAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testFunctionAssertAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Assert/FunctionAssertAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInvalidMethodAssertAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Assert/InvalidMethodAssertAttribute.php');
22 | 
23 |         $expectedErrors = [
24 |             'PHPDoc tag @phpstan-assert has invalid value (): Unexpected token "\n ", expected type at offset 22 on line 2' => 10,
25 |             'Attribute class PhpStaticAnalysis\Attributes\Assert does not have the property target.' => 14,
26 |         ];
27 | 
28 |         $this->checkExpectedErrors($errors, $expectedErrors);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/AssertIfFalseAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | use test\PhpStaticAnalysis\PHPStanExtension\BaseAttributeTestCase;
 5 | 
 6 | final class AssertIfFalseAttributeTest extends BaseAttributeTestCase
 7 | {
 8 |     public function testMethodAssertIfFalseAttribute(): void
 9 |     {
10 |         $errors = $this->analyse(__DIR__ . '/data/AssertIfFalse/MethodAssertIfFalseAttribute.php');
11 |         $this->assertCount(0, $errors);
12 |     }
13 | 
14 |     public function testFunctionAssertIfFalseAttribute(): void
15 |     {
16 |         $errors = $this->analyse(__DIR__ . '/data/AssertIfFalse/FunctionAssertIfFalseAttribute.php');
17 |         $this->assertCount(0, $errors);
18 |     }
19 | 
20 |     public function testInvalidMethodAssertIfFalseAttribute(): void
21 |     {
22 |         $errors = $this->analyse(__DIR__ . '/data/AssertIfFalse/InvalidMethodAssertIfFalseAttribute.php');
23 | 
24 |         $expectedErrors = [
25 |             'PHPDoc tag @phpstan-assert-if-false has invalid value (): Unexpected token "\n ", expected type at offset 31 on line 2' => 10,
26 |             'Attribute class PhpStaticAnalysis\Attributes\AssertIfFalse does not have the property target.' => 15,
27 |         ];
28 | 
29 |         $this->checkExpectedErrors($errors, $expectedErrors);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/tests/AssertIfTrueAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | use test\PhpStaticAnalysis\PHPStanExtension\BaseAttributeTestCase;
 5 | 
 6 | final class AssertIfTrueAttributeTest extends BaseAttributeTestCase
 7 | {
 8 |     public function testMethodAssertIfTrueAttribute(): void
 9 |     {
10 |         $errors = $this->analyse(__DIR__ . '/data/AssertIfTrue/MethodAssertIfTrueAttribute.php');
11 |         $this->assertCount(0, $errors);
12 |     }
13 | 
14 |     public function testFunctionAssertIfTrueAttribute(): void
15 |     {
16 |         $errors = $this->analyse(__DIR__ . '/data/AssertIfTrue/FunctionAssertIfTrueAttribute.php');
17 |         $this->assertCount(0, $errors);
18 |     }
19 | 
20 |     public function testInvalidMethodAssertIfTrueAttribute(): void
21 |     {
22 |         $errors = $this->analyse(__DIR__ . '/data/AssertIfTrue/InvalidMethodAssertIfTrueAttribute.php');
23 | 
24 |         $expectedErrors = [
25 |             'PHPDoc tag @phpstan-assert-if-true has invalid value (): Unexpected token "\n ", expected type at offset 30 on line 2' => 10,
26 |             'Attribute class PhpStaticAnalysis\Attributes\AssertIfTrue does not have the property target.' => 15,
27 |         ];
28 | 
29 |         $this->checkExpectedErrors($errors, $expectedErrors);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/tests/BaseAttributeTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | use PHPStan\Analyser\Analyser;
 6 | use PHPStan\Analyser\Error;
 7 | use PHPStan\File\FileHelper;
 8 | use PHPStan\Testing\PHPStanTestCase;
 9 | use PhpStaticAnalysis\Attributes\Param;
10 | use PhpStaticAnalysis\Attributes\Returns;
11 | 
12 | class BaseAttributeTestCase extends PHPStanTestCase
13 | {
14 |     #[Returns('Error[]')]
15 |     protected function analyse(string $file): array
16 |     {
17 |         $file = $this->getFileHelper()->normalizePath($file);
18 |         $analyser = self::getContainer()->getByType(Analyser::class);
19 |         $fileHelper = self::getContainer()->getByType(FileHelper::class);
20 |         $errors = $analyser->analyse([$file], null, null, true)->getErrors();
21 |         foreach ($errors as $error) {
22 |             $this->assertSame($fileHelper->normalizePath($file), $error->getFilePath());
23 |         }
24 | 
25 |         return $errors;
26 |     }
27 | 
28 |     #[Param(
29 |         errors: 'Error[]',
30 |         expectedErrors: 'array<string,int>',
31 |     )]
32 |     protected function checkExpectedErrors(
33 |         array $errors,
34 |         array $expectedErrors
35 |     ): void {
36 |         $this->assertCount(count($expectedErrors), $errors);
37 | 
38 |         $errorNum = 0;
39 |         foreach ($expectedErrors as $error => $line) {
40 |             $this->assertSame($error, $errors[$errorNum]->getMessage());
41 |             $this->assertSame($line, $errors[$errorNum]->getLine());
42 |             $errorNum++;
43 |         }
44 |     }
45 | 
46 |     public static function getAdditionalConfigFiles(): array
47 |     {
48 |         return [
49 |             __DIR__ . '/../extension.neon',
50 |         ];
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/DefineTypeAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class DefineTypeAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassDefineTypeAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/DefineType/ClassDefineTypeAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInterfaceDefineTypeAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/DefineType/InterfaceDefineTypeAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testTraitDefineTypeAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/DefineType/TraitDefineTypeAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassDefineTypeAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/DefineType/InvalidClassDefineTypeAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'Type alias has an invalid name: string.' => 7,
31 |             'PHPDoc tag @phpstan-type has invalid value (): Unexpected token "\n * ", expected type at offset 20 on line 2' => 8,
32 |             'PHPDoc tag @phpstan-type string has invalid value: Unexpected token "\n * ", expected type at offset 44 on line 3' => 9,
33 |             'PHPDoc tag @phpstan-type name has invalid value: Unexpected token "(", expected TOKEN_PHPDOC_EOL at offset 72 on line 4' => 10,
34 |             'Attribute class PhpStaticAnalysis\Attributes\DefineType does not have the method target.' => 12,
35 |         ];
36 | 
37 |         $this->checkExpectedErrors($errors, $expectedErrors);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/DeprecatedAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class DeprecatedAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassDeprecatedAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Deprecated/ClassDeprecatedAttribute.php');
10 |         $expectedErrors = [
11 |             'Instantiation of deprecated class test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated\ClassDeprecatedAttribute.' => 12,
12 |         ];
13 | 
14 |         $this->checkExpectedErrors($errors, $expectedErrors);
15 |     }
16 | 
17 |     public function testTraitDeprecatedAttribute(): void
18 |     {
19 |         $errors = $this->analyse(__DIR__ . '/data/Deprecated/TraitDeprecatedAttribute.php');
20 |         $this->assertCount(0, $errors);
21 |     }
22 | 
23 |     public function testInterfaceDeprecatedAttribute(): void
24 |     {
25 |         $errors = $this->analyse(__DIR__ . '/data/Deprecated/InterfaceDeprecatedAttribute.php');
26 |         $this->assertCount(0, $errors);
27 |     }
28 | 
29 |     public function testMethodDeprecatedAttribute(): void
30 |     {
31 |         $errors = $this->analyse(__DIR__ . '/data/Deprecated/MethodDeprecatedAttribute.php');
32 |         $expectedErrors = [
33 |             'Call to deprecated method returnDeprecated() of class test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated\MethodDeprecatedAttribute.' => 31,
34 |         ];
35 | 
36 |         $this->checkExpectedErrors($errors, $expectedErrors);
37 |     }
38 | 
39 |     public function testFunctionDeprecatedAttribute(): void
40 |     {
41 |         $errors = $this->analyse(__DIR__ . '/data/Deprecated/FunctionDeprecatedAttribute.php');
42 |         $this->assertCount(0, $errors);
43 |     }
44 | 
45 |     public function testPropertyDeprecatedAttribute(): void
46 |     {
47 |         $errors = $this->analyse(__DIR__ . '/data/Deprecated/PropertyDeprecatedAttribute.php');
48 |         $this->assertCount(0, $errors);
49 |     }
50 | 
51 |     public function testInvalidMethodDeprecatedAttribute(): void
52 |     {
53 |         $errors = $this->analyse(__DIR__ . '/data/Deprecated/InvalidMethodDeprecatedAttribute.php');
54 | 
55 |         $expectedErrors = [
56 |             'Attribute class PhpStaticAnalysis\Attributes\Deprecated does not have the parameter target.' => 12,
57 |         ];
58 | 
59 |         $this->checkExpectedErrors($errors, $expectedErrors);
60 |     }
61 | 
62 |     public static function getAdditionalConfigFiles(): array
63 |     {
64 |         return array_merge(
65 |             parent::getAdditionalConfigFiles(),
66 |             [
67 |                 __DIR__ . '/conf/deprecated.neon',
68 |             ]
69 |         );
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/tests/ImmutableAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | use test\PhpStaticAnalysis\PHPStanExtension\BaseAttributeTestCase;
 5 | 
 6 | final class ImmutableAttributeTest extends BaseAttributeTestCase
 7 | {
 8 |     public function testClassImmutableAttribute(): void
 9 |     {
10 |         $errors = $this->analyse(__DIR__ . '/data/Immutable/ClassImmutableAttribute.php');
11 |         $expectedErrors = [
12 |             '@readonly property cannot have a default value.' => 10,
13 |             '@readonly property test\PhpStaticAnalysis\PHPStanExtension\data\Immutable\ClassImmutableAttribute::$name is assigned outside of its declaring class.' => 14,
14 |         ];
15 | 
16 |         $this->checkExpectedErrors($errors, $expectedErrors);
17 |     }
18 | 
19 |     public function testTraitImmutableAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Immutable/TraitImmutableAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInterfaceImmutableAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/Immutable/InterfaceImmutableAttribute.php');
28 |         $this->assertCount(0, $errors);
29 |     }
30 | 
31 |     public function testInvalidClassImmutableAttribute(): void
32 |     {
33 |         $errors = $this->analyse(__DIR__ . '/data/Immutable/InvalidClassImmutableAttribute.php');
34 | 
35 |         $expectedErrors = [
36 |             'Attribute class PhpStaticAnalysis\Attributes\Immutable does not have the property target.' => 13,
37 |             '@readonly property cannot have a default value.' => 14,
38 |         ];
39 | 
40 |         $this->checkExpectedErrors($errors, $expectedErrors);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/tests/ImportTypeAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class ImportTypeAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassImportTypeAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/ImportType/ClassImportTypeAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInterfaceImportTypeAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/ImportType/InterfaceImportTypeAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testTraitImportTypeAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/ImportType/TraitImportTypeAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassImportTypeAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/ImportType/InvalidClassImportTypeAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'PHPDoc tag @phpstan-import-type has invalid value (Unexpected token "(", expected \'*/\' at offset 98 on line 4): Unexpected token "(", expected \'*/\' at offset 98 on line 4' => 11,
31 |             'Attribute class PhpStaticAnalysis\Attributes\ImportType does not have the method target.' => 13,
32 |         ];
33 | 
34 |         $this->checkExpectedErrors($errors, $expectedErrors);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/ImpureAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class ImpureAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodImpureAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Impure/MethodImpureAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testFunctionImpureAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Impure/FunctionImpureAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInvalidMethodImpureAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Impure/InvalidMethodImpureAttribute.php');
22 | 
23 |         $expectedErrors = [
24 |             'Attribute class PhpStaticAnalysis\Attributes\Impure does not have the property target.' => 11,
25 |         ];
26 | 
27 |         $this->checkExpectedErrors($errors, $expectedErrors);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/InternalAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class InternalAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassInternalAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Internal/ClassInternalAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testTraitInternalAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Internal/TraitInternalAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInterfaceInternalAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Internal/InterfaceInternalAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testMethodInternalAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/Internal/MethodInternalAttribute.php');
28 |         $this->assertCount(0, $errors);
29 |     }
30 | 
31 |     public function testFunctionInternalAttribute(): void
32 |     {
33 |         $errors = $this->analyse(__DIR__ . '/data/Internal/FunctionInternalAttribute.php');
34 |         $this->assertCount(0, $errors);
35 |     }
36 | 
37 |     public function testPropertyInternalAttribute(): void
38 |     {
39 |         $errors = $this->analyse(__DIR__ . '/data/Internal/PropertyInternalAttribute.php');
40 |         $this->assertCount(0, $errors);
41 |     }
42 | 
43 |     public function testInvalidMethodInternalAttribute(): void
44 |     {
45 |         $errors = $this->analyse(__DIR__ . '/data/Internal/InvalidMethodInternalAttribute.php');
46 |         $expectedErrors = [
47 |             'Attribute class PhpStaticAnalysis\Attributes\Internal does not have the parameter target.' => 15,
48 |         ];
49 | 
50 |         $this->checkExpectedErrors($errors, $expectedErrors);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/IsReadOnlyAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class IsReadOnlyAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testPropertyTypeAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/IsReadOnly/PropertyIsReadOnlyAttribute.php');
10 |         $expectedErrors = [
11 |             '@readonly property test\PhpStaticAnalysis\PHPStanExtension\data\IsReadOnly\PropertyIsReadOnlyAttribute::$name is assigned outside of its declaring class.' => 19,
12 |         ];
13 | 
14 |         $this->checkExpectedErrors($errors, $expectedErrors);
15 |     }
16 | 
17 |     public function testInvalidPropertyIsReadOnlyAttribute(): void
18 |     {
19 |         $errors = $this->analyse(__DIR__ . '/data/IsReadOnly/InvalidPropertyIsReadOnlyAttribute.php');
20 | 
21 |         $expectedErrors = [
22 |             'Attribute class PhpStaticAnalysis\Attributes\IsReadOnly does not have the method target.' => 16,
23 |         ];
24 | 
25 |         $this->checkExpectedErrors($errors, $expectedErrors);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/MethodAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class MethodAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassMethodAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Method/ClassMethodAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInterfaceMethodAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Method/InterfaceMethodAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testTraitMethodAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Method/TraitMethodAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassMethodAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/Method/InvalidClassMethodAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'PHPDoc tag @method has invalid value (): Unexpected token "\n * ", expected type at offset 14 on line 2' => 9,
31 |             'PHPDoc tag @method has invalid value (string): Unexpected token "\n * ", expected \'(\' at offset 32 on line 3' => 10,
32 |             'Attribute class PhpStaticAnalysis\Attributes\Method does not have the method target.' => 13,
33 |             'Call to an undefined method test\PhpStaticAnalysis\PHPStanExtension\data\Method\InvalidClassMethodAttribute::badFunction().' => 31,
34 |         ];
35 | 
36 |         $this->checkExpectedErrors($errors, $expectedErrors);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/MixinAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class MixinAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassMixinAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Mixin/ClassMixinAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInterfaceMixinAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Mixin/InterfaceMixinAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testTraitMixinAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Mixin/TraitMixinAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassMixinAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/Mixin/InvalidClassMixinAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'PHPDoc tag @mixin has invalid value (): Unexpected token "\n * ", expected type at offset 13 on line 2' => 8,
31 |             'PHPDoc tag @mixin has invalid value (count($a)): Unexpected token "(", expected TOKEN_HORIZONTAL_WS at offset 29 on line 3' => 9,
32 |             'Attribute class PhpStaticAnalysis\Attributes\Mixin does not have the method target.' => 11,
33 |         ];
34 | 
35 |         $this->checkExpectedErrors($errors, $expectedErrors);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/ParamAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class ParamAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodParamAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Param/MethodParamAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testFunctionParamAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Param/FunctionParamAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInvalidMethodParamAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Param/InvalidMethodParamAttribute.php');
22 | 
23 |         $expectedErrors = [
24 |             'PHPDoc tag @param has invalid value (): Unexpected token "\n ", expected type at offset 13 on line 2' => 10,
25 |             'PHPDoc tag @param has invalid value (string): Unexpected token "\n ", expected variable at offset 20 on line 2' => 16,
26 |             'PHPDoc tag @param has invalid value (count($a) $name): Unexpected token "(", expected variable at offset 19 on line 2' => 22,
27 |             'Attribute class PhpStaticAnalysis\Attributes\Param does not have the property target.' => 27,
28 |         ];
29 | 
30 |         $this->checkExpectedErrors($errors, $expectedErrors);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/ParamOutAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class ParamOutAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodParamOutAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/ParamOut/MethodParamOutAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testFunctionParamOutAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/ParamOut/FunctionParamOutAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInvalidMethodParamOutAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/ParamOut/InvalidMethodParamOutAttribute.php');
22 | 
23 |         $expectedErrors = [
24 |             'PHPDoc tag @param-out has invalid value (): Unexpected token "\n ", expected type at offset 17 on line 2' => 10,
25 |             'PHPDoc tag @param-out has invalid value (string): Unexpected token "\n ", expected variable at offset 24 on line 2' => 16,
26 |             'PHPDoc tag @param-out has invalid value (count($a) $name): Unexpected token "(", expected variable at offset 23 on line 2' => 22,
27 |             'Attribute class PhpStaticAnalysis\Attributes\ParamOut does not have the property target.' => 27,
28 |         ];
29 | 
30 |         $this->checkExpectedErrors($errors, $expectedErrors);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/PropertyAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class PropertyAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassPropertyAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Property/ClassPropertyAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInterfacePropertyAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Property/InterfacePropertyAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testTraitPropertyAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Property/TraitPropertyAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassPropertyAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/Property/InvalidClassPropertyAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'PHPDoc tag @property has invalid value (): Unexpected token "\n * ", expected type at offset 16 on line 2' => 8,
31 |             'PHPDoc tag @property has invalid value (string): Unexpected token "\n * ", expected variable at offset 36 on line 3' => 9,
32 |             'PHPDoc tag @property has invalid value (count($a) $name): Unexpected token "(", expected variable at offset 55 on line 4' => 10,
33 |             'Attribute class PhpStaticAnalysis\Attributes\Property does not have the method target.' => 12,
34 |         ];
35 | 
36 |         $this->checkExpectedErrors($errors, $expectedErrors);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/PropertyReadAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class PropertyReadAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassPropertyReadAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/PropertyRead/ClassPropertyReadAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInterfacePropertyReadAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/PropertyRead/InterfacePropertyReadAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testTraitPropertyReadAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/PropertyRead/TraitPropertyReadAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassPropertyReadAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/PropertyRead/InvalidClassPropertyReadAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'PHPDoc tag @property-read has invalid value (): Unexpected token "\n * ", expected type at offset 21 on line 2' => 8,
31 |             'PHPDoc tag @property-read has invalid value (string): Unexpected token "\n * ", expected variable at offset 46 on line 3' => 9,
32 |             'PHPDoc tag @property-read has invalid value (count($a) $name): Unexpected token "(", expected variable at offset 70 on line 4' => 10,
33 |             'Attribute class PhpStaticAnalysis\Attributes\PropertyRead does not have the method target.' => 13,
34 |             'Property test\PhpStaticAnalysis\PHPStanExtension\data\PropertyRead\ClassPropertyReadAttribute::$age is not writable.' => 21,
35 |         ];
36 | 
37 |         $this->checkExpectedErrors($errors, $expectedErrors);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/PropertyWriteAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class PropertyWriteAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassPropertyWriteAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/PropertyWrite/ClassPropertyWriteAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInterfacePropertyWriteAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/PropertyWrite/InterfacePropertyWriteAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testTraitPropertyWriteAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/PropertyWrite/TraitPropertyWriteAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassPropertyWriteAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/PropertyWrite/InvalidClassPropertyWriteAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'PHPDoc tag @property-write has invalid value (): Unexpected token "\n * ", expected type at offset 22 on line 2' => 8,
31 |             'PHPDoc tag @property-write has invalid value (string): Unexpected token "\n * ", expected variable at offset 48 on line 3' => 9,
32 |             'PHPDoc tag @property-write has invalid value (count($a) $name): Unexpected token "(", expected variable at offset 73 on line 4' => 10,
33 |             'Attribute class PhpStaticAnalysis\Attributes\PropertyWrite does not have the method target.' => 13,
34 |             'Property test\PhpStaticAnalysis\PHPStanExtension\data\PropertyWrite\ClassPropertyWriteAttribute::$age is not readable.' => 21,
35 |         ];
36 | 
37 |         $this->checkExpectedErrors($errors, $expectedErrors);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/PureAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class PureAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodPureAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Pure/MethodPureAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testFunctionPureAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Pure/FunctionPureAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInvalidMethodPureAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Pure/InvalidMethodPureAttribute.php');
22 | 
23 |         $expectedErrors = [
24 |             'Attribute class PhpStaticAnalysis\Attributes\Pure does not have the property target.' => 11,
25 |             'Method test\PhpStaticAnalysis\PHPStanExtension\data\Pure\InvalidMethodPureAttribute::getMoreName() is marked as pure but returns void.' => 14,
26 |         ];
27 | 
28 |         $this->checkExpectedErrors($errors, $expectedErrors);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/RequireExtendsAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class RequireExtendsAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassRequireExtendsAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/RequireExtends/TraitRequireExtendsAttribute.php');
10 |         $expectedErrors = [
11 |             'Trait test\PhpStaticAnalysis\PHPStanExtension\data\RequireExtends\TraitRequireExtendsAttribute requires using class to extend test\PhpStaticAnalysis\PHPStanExtension\data\RequireExtends\ClassRequireExtendsAttribute, but test\PhpStaticAnalysis\PHPStanExtension\data\RequireExtends\ClassRequireExtendsAttributeChild2 does not.' => 21,
12 |         ];
13 | 
14 |         $this->checkExpectedErrors($errors, $expectedErrors);
15 |     }
16 | 
17 |     public function testInvalidClassRequireExtendsAttribute(): void
18 |     {
19 |         $errors = $this->analyse(__DIR__ . '/data/RequireExtends/InvalidTraitRequireExtendsAttribute.php');
20 | 
21 |         $expectedErrors = [
22 |             'PHPDoc tag @phpstan-require-extends has invalid value (): Unexpected token "\n ", expected type at offset 31 on line 2' => 8,
23 |             'PHPDoc tag @phpstan-require-extends contains non-object type int.' => 12,
24 |             'PHPDoc tag @phpstan-require-extends can only be used once.' => 17,
25 |             'Attribute class PhpStaticAnalysis\Attributes\RequireExtends does not have the property target.' => 21,
26 |         ];
27 | 
28 |         $this->checkExpectedErrors($errors, $expectedErrors);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/RequireImplementsAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class RequireImplementsAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassRequireImplementsAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/RequireImplements/TraitRequireImplementsAttribute.php');
10 |         $expectedErrors = [
11 |             'Trait test\PhpStaticAnalysis\PHPStanExtension\data\RequireImplements\TraitRequireImplementsAttribute requires using class to implement test\PhpStaticAnalysis\PHPStanExtension\data\RequireImplements\InterfaceRequireImplementsAttribute3, but test\PhpStaticAnalysis\PHPStanExtension\data\RequireImplements\ClassRequireImplementsAttribute2 does not.' => 33,
12 |         ];
13 | 
14 |         $this->checkExpectedErrors($errors, $expectedErrors);
15 |     }
16 | 
17 |     public function testInvalidClassRequireImplementsAttribute(): void
18 |     {
19 |         $errors = $this->analyse(__DIR__ . '/data/RequireImplements/InvalidTraitRequireImplementsAttribute.php');
20 | 
21 |         $expectedErrors = [
22 |             'PHPDoc tag @phpstan-require-implements has invalid value (): Unexpected token "\n ", expected type at offset 34 on line 2' => 8,
23 |             'PHPDoc tag @phpstan-require-implements contains non-object type int.' => 12,
24 |             'Attribute class PhpStaticAnalysis\Attributes\RequireImplements does not have the property target.' => 15,
25 |         ];
26 | 
27 |         $this->checkExpectedErrors($errors, $expectedErrors);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/ReturnsAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class ReturnsAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodReturnsAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Returns/MethodReturnsAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testFunctionReturnsAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Returns/FunctionReturnsAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInvalidMethodReturnsAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Returns/InvalidMethodReturnsAttribute.php');
22 | 
23 |         $expectedErrors = [
24 |             'PHPDoc tag @return has invalid value (): Unexpected token "\n ", expected type at offset 14 on line 2' => 10,
25 |             'PHPDoc tag @return has invalid value ($a + $b): Unexpected token "$a", expected type at offset 15 on line 2' => 29,
26 |             'Attribute class PhpStaticAnalysis\Attributes\Returns does not have the property target.' => 34,
27 |         ];
28 | 
29 |         $this->checkExpectedErrors($errors, $expectedErrors);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/tests/SelfOutAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class SelfOutAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodSelfOutAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/SelfOut/MethodSelfOutAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInvalidMethodSelfOutAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/SelfOut/InvalidMethodSelfOutAttribute.php');
16 | 
17 |         $expectedErrors = [
18 |             'PHPDoc tag @phpstan-self-out has invalid value (): Unexpected token "\n ", expected type at offset 75 on line 4' => 15,
19 |             'Attribute class PhpStaticAnalysis\Attributes\SelfOut does not have the property target.' => 27,
20 |         ];
21 | 
22 |         $this->checkExpectedErrors($errors, $expectedErrors);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/TemplateAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class TemplateAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassTemplateAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Template/ClassTemplateAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testTraitTemplateAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Template/TraitTemplateAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInterfaceTemplateAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/Template/InterfaceTemplateAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testMethodTemplateAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/Template/MethodTemplateAttribute.php');
28 |         $this->assertCount(0, $errors);
29 |     }
30 | 
31 |     public function testFunctionTemplateAttribute(): void
32 |     {
33 |         $errors = $this->analyse(__DIR__ . '/data/Template/FunctionTemplateAttribute.php');
34 |         $this->assertCount(0, $errors);
35 |     }
36 | 
37 |     public function testInvalidMethodTemplateAttribute(): void
38 |     {
39 |         $errors = $this->analyse(__DIR__ . '/data/Template/InvalidMethodTemplateAttribute.php');
40 | 
41 |         $expectedErrors = [
42 |             'PHPDoc tag @template has invalid value (): Unexpected token "\n ", expected type at offset 16 on line 2' => 12,
43 |             'PHPDoc tag @template has invalid value (+5): Unexpected token "+5", expected type at offset 17 on line 2' => 18,
44 |             'Attribute class PhpStaticAnalysis\Attributes\Template does not have the property target.' => 23,
45 |         ];
46 | 
47 |         $this->checkExpectedErrors($errors, $expectedErrors);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/TemplateContravariantAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class TemplateContravariantAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassTemplateContravariantAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/TemplateContravariant/ClassTemplateContravariantAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testTraitTemplateContravariantAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/TemplateContravariant/TraitTemplateContravariantAttribute.php');
16 |         $this->assertCount(0, $errors);
17 |     }
18 | 
19 |     public function testInterfaceTemplateContravariantAttribute(): void
20 |     {
21 |         $errors = $this->analyse(__DIR__ . '/data/TemplateContravariant/InterfaceTemplateContravariantAttribute.php');
22 |         $this->assertCount(0, $errors);
23 |     }
24 | 
25 |     public function testInvalidClassTemplateContravariantAttribute(): void
26 |     {
27 |         $errors = $this->analyse(__DIR__ . '/data/TemplateContravariant/InvalidClassTemplateContravariantAttribute.php');
28 | 
29 |         $expectedErrors = [
30 |             'PHPDoc tag @template-contravariant has invalid value (): Unexpected token "\n * ", expected type at offset 30 on line 2' => 8,
31 |             'PHPDoc tag @template-contravariant has invalid value (+5): Unexpected token "+5", expected type at offset 58 on line 3' => 9,
32 |             'Attribute class PhpStaticAnalysis\Attributes\TemplateContravariant does not have the property target.' => 12,
33 |         ];
34 | 
35 |         $this->checkExpectedErrors($errors, $expectedErrors);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/TemplateCovariantAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class TemplateCovariantAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassTemplateCovariantAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/TemplateCovariant/ClassTemplateCovariantAttribute.php');
10 |         $expectedErrors = [
11 |             'PHPDoc tag @var with type TCreable is not subtype of native type object.' => 28,
12 |         ];
13 |         $this->checkExpectedErrors($errors, $expectedErrors);
14 |     }
15 | 
16 |     public function testTraitTemplateCovariantAttribute(): void
17 |     {
18 |         $errors = $this->analyse(__DIR__ . '/data/TemplateCovariant/TraitTemplateCovariantAttribute.php');
19 |         $this->assertCount(0, $errors);
20 |     }
21 | 
22 |     public function testInterfaceTemplateCovariantAttribute(): void
23 |     {
24 |         $errors = $this->analyse(__DIR__ . '/data/TemplateCovariant/InterfaceTemplateCovariantAttribute.php');
25 |         $this->assertCount(0, $errors);
26 |     }
27 | 
28 |     public function testInvalidClassTemplateCovariantAttribute(): void
29 |     {
30 |         $errors = $this->analyse(__DIR__ . '/data/TemplateCovariant/InvalidClassTemplateCovariantAttribute.php');
31 | 
32 |         $expectedErrors = [
33 |             'PHPDoc tag @template-covariant has invalid value (): Unexpected token "\n * ", expected type at offset 26 on line 2' => 8,
34 |             'PHPDoc tag @template-covariant has invalid value (+5): Unexpected token "+5", expected type at offset 50 on line 3' => 9,
35 |             'Attribute class PhpStaticAnalysis\Attributes\TemplateCovariant does not have the property target.' => 12,
36 |         ];
37 | 
38 |         $this->checkExpectedErrors($errors, $expectedErrors);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/tests/TemplateExtendsAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class TemplateExtendsAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testClassTemplateExtendsAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/TemplateExtends/ClassTemplateExtendsAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInvalidClassTemplateExtendsAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/TemplateExtends/InvalidClassTemplateExtendsAttribute.php');
16 | 
17 |         $expectedErrors = [
18 |             'Class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateExtends\InvalidClassTemplateExtendsAttributeChild extends generic class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateExtends\InvalidClassTemplateExtendsAttribute but does not specify its types: T' => 13,
19 |             'PHPDoc tag @template-extends has invalid value (): Unexpected token "\n ", expected type at offset 24 on line 2' => 14,
20 |             'Class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateExtends\InvalidClassTemplateExtendsAttributeChild2 extends generic class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateExtends\InvalidClassTemplateExtendsAttribute but does not specify its types: T' => 18,
21 |             'PHPDoc tag @template-extends has invalid value (+5): Unexpected token "+5", expected type at offset 25 on line 2' => 19,
22 |             'Attribute class PhpStaticAnalysis\Attributes\TemplateExtends does not have the property target.' => 27,
23 |         ];
24 | 
25 |         $this->checkExpectedErrors($errors, $expectedErrors);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/TemplateImplementsAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class TemplateImplementsAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testInterfaceTemplateImplementsAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/TemplateImplements/InterfaceTemplateImplementsAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInvalidInterfaceTemplateImplementsAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/TemplateImplements/InvalidInterfaceTemplateImplementsAttribute.php');
16 | 
17 |         $expectedErrors = [
18 |             'Class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateImplements\InvalidClassTemplateImplementsAttribute implements generic interface test\PhpStaticAnalysis\PHPStanExtension\data\TemplateImplements\InvalidInterfaceTemplateImplementsAttribute but does not specify its types: T' => 13,
19 |             'PHPDoc tag @template-implements has invalid value (): Unexpected token "\n ", expected type at offset 27 on line 2' => 14,
20 |             'Class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateImplements\InvalidClassTemplateImplementsAttribute2 implements generic interface test\PhpStaticAnalysis\PHPStanExtension\data\TemplateImplements\InvalidInterfaceTemplateImplementsAttribute but does not specify its types: T' => 18,
21 |             'PHPDoc tag @template-implements has invalid value (+5): Unexpected token "+5", expected type at offset 28 on line 2' => 19,
22 |             'Attribute class PhpStaticAnalysis\Attributes\TemplateImplements does not have the property target.' => 21,
23 |         ];
24 | 
25 |         $this->checkExpectedErrors($errors, $expectedErrors);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/TemplateUseAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class TemplateUseAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testTraitTemplateUseAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/TemplateUse/TraitTemplateUseAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInvalidTraitTemplateUseAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/TemplateUse/InvalidTraitTemplateUseAttribute.php');
16 | 
17 |         $expectedErrors = [
18 |             'Parameter #1 ...$traits of attribute class PhpStaticAnalysis\Attributes\TemplateUse constructor expects string, int given.' => 13,
19 |             'Class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateUse\InvalidClassTemplateUseAttribute uses generic trait test\PhpStaticAnalysis\PHPStanExtension\data\TemplateUse\InvalidTraitTemplateUseAttribute but does not specify its types: T' => 16,
20 |             'Class test\PhpStaticAnalysis\PHPStanExtension\data\TemplateUse\InvalidClassTemplateUseAttribute2 uses generic trait test\PhpStaticAnalysis\PHPStanExtension\data\TemplateUse\InvalidTraitTemplateUseAttribute but does not specify its types: T' => 22,
21 |             'Attribute class PhpStaticAnalysis\Attributes\TemplateUse does not have the property target.' => 24,
22 |         ];
23 | 
24 |         $this->checkExpectedErrors($errors, $expectedErrors);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/ThrowsAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class ThrowsAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testMethodThrowsAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Throws/MethodThrowsAttribute.php');
10 |         $expectedErrors = [
11 |             'Method test\PhpStaticAnalysis\PHPStanExtension\data\Throws\MethodThrowsAttribute::countNoErrorName() has Exception in PHPDoc @throws tag but it\'s not thrown.' => 72,
12 |         ];
13 | 
14 |         $this->checkExpectedErrors($errors, $expectedErrors);
15 |     }
16 | 
17 |     public function testFunctionThrowsAttribute(): void
18 |     {
19 |         $errors = $this->analyse(__DIR__ . '/data/Throws/FunctionThrowsAttribute.php');
20 |         $this->assertCount(0, $errors);
21 |     }
22 | 
23 |     public function testInvalidMethodThrowsAttribute(): void
24 |     {
25 |         $errors = $this->analyse(__DIR__ . '/data/Throws/InvalidMethodThrowsAttribute.php');
26 | 
27 |         $expectedErrors = [
28 |             'PHPDoc tag @throws has invalid value (): Unexpected token "\n ", expected type at offset 14 on line 2' => 11,
29 |             'Method test\PhpStaticAnalysis\PHPStanExtension\data\Throws\InvalidMethodThrowsAttribute::getOtherNameLength() has string in PHPDoc @throws tag but it\'s not thrown.' => 16,
30 |             'PHPDoc tag @throws with type string is not subtype of Throwable' => 16,
31 |             'Attribute class PhpStaticAnalysis\Attributes\Throws does not have the property target.' => 22,
32 |         ];
33 | 
34 |         $this->checkExpectedErrors($errors, $expectedErrors);
35 |     }
36 | 
37 |     public static function getAdditionalConfigFiles(): array
38 |     {
39 |         return array_merge(
40 |             parent::getAdditionalConfigFiles(),
41 |             [
42 |                 __DIR__ . '/conf/throws.neon',
43 |             ]
44 |         );
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/TypeAttributeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension;
 4 | 
 5 | final class TypeAttributeTest extends BaseAttributeTestCase
 6 | {
 7 |     public function testPropertyTypeAttribute(): void
 8 |     {
 9 |         $errors = $this->analyse(__DIR__ . '/data/Type/PropertyTypeAttribute.php');
10 |         $this->assertCount(0, $errors);
11 |     }
12 | 
13 |     public function testInvalidPropertyTypeAttribute(): void
14 |     {
15 |         $errors = $this->analyse(__DIR__ . '/data/Type/InvalidPropertyTypeAttribute.php');
16 | 
17 |         $expectedErrors = [
18 |             'PHPDoc tag @var has invalid value (): Unexpected token "\n ", expected type at offset 11 on line 2' => 10,
19 |             'PHPDoc tag @var has invalid value ($a + $b): Unexpected token "$a", expected type at offset 12 on line 2' => 20,
20 |             'Attribute class PhpStaticAnalysis\Attributes\Type does not have the parameter target.' => 23,
21 |         ];
22 | 
23 |         $this->checkExpectedErrors($errors, $expectedErrors);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/conf/deprecated.neon:
--------------------------------------------------------------------------------
1 | includes:
2 |     - ../../vendor/phpstan/phpstan-deprecation-rules/rules.neon
3 | 


--------------------------------------------------------------------------------
/tests/conf/readonly.neon:
--------------------------------------------------------------------------------
1 | parameters:
2 |     featureToggles:
3 |         readOnlyByPhpDoc: true
4 | 


--------------------------------------------------------------------------------
/tests/conf/throws.neon:
--------------------------------------------------------------------------------
1 | parameters:
2 | 	exceptions:
3 | 		check:
4 | 			tooWideThrowType: true


--------------------------------------------------------------------------------
/tests/data/Assert/FunctionAssertAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Assert;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Assert;
 7 | 
 8 | #[Assert(name: 'string')]
 9 | function checkString(mixed $name): void
10 | {
11 |     if (!is_string($name)) {
12 |         throw new Exception();
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/data/Assert/InvalidMethodAssertAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Assert;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Assert;
 6 | 
 7 | class InvalidMethodAssertAttribute
 8 | {
 9 |     #[Assert(0)]
10 |     public function checkString(mixed $name): void
11 |     {
12 |     }
13 | 
14 |     #[Assert(property: 'string')]
15 |     public string $property;
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/data/Assert/MethodAssertAttribute.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Assert;
  4 | 
  5 | use Exception;
  6 | use PhpStaticAnalysis\Attributes\Assert;
  7 | 
  8 | class MethodAssertAttribute
  9 | {
 10 |     #[Assert(name: 'string')] // checks name is string
 11 |     public function checkString(mixed $name): void
 12 |     {
 13 |         if (!is_string($name)) {
 14 |             throw new Exception();
 15 |         }
 16 |     }
 17 | 
 18 |     #[Assert(exception: Exception::class)]
 19 |     public function checkException(mixed $exception): void
 20 |     {
 21 |         if (!$exception instanceof Exception) {
 22 |             throw new Exception();
 23 |         }
 24 |     }
 25 | 
 26 |     #[Assert('string $name')]
 27 |     public function checkOtherString(mixed $name): void
 28 |     {
 29 |         if (!is_string($name)) {
 30 |             throw new Exception();
 31 |         }
 32 |     }
 33 | 
 34 |     /**
 35 |      * @deprecated
 36 |      */
 37 |     #[Assert(name: 'string')]
 38 |     public function checkAnotherString(mixed $name): void
 39 |     {
 40 |         if (!is_string($name)) {
 41 |             throw new Exception();
 42 |         }
 43 |     }
 44 | 
 45 |     /**
 46 |      * @assert int $name
 47 |      */
 48 |     #[Assert(name: 'string')]
 49 |     public function checkEvenMoreString(mixed $name): void
 50 |     {
 51 |         if (!is_string($name)) {
 52 |             throw new Exception();
 53 |         }
 54 |     }
 55 | 
 56 |     #[Assert(
 57 |         name1: 'string',
 58 |         name2: 'string'
 59 |     )]
 60 |     public function checkStrings(mixed $name1, mixed $name2): void
 61 |     {
 62 |         if (!is_string($name1) || !is_string($name2)) {
 63 |             throw new Exception();
 64 |         }
 65 |     }
 66 | 
 67 |     #[Assert(name1: 'string')]
 68 |     #[Assert(name2: 'string')]
 69 |     public function checkOtherStrings(mixed $name1, mixed $name2): void
 70 |     {
 71 |         if (!is_string($name1) || !is_string($name2)) {
 72 |             throw new Exception();
 73 |         }
 74 |     }
 75 | 
 76 |     /**
 77 |      * @assert string $name
 78 |      */
 79 |     public function checkMoreAndMoreString(mixed $name): void
 80 |     {
 81 |         if (!is_string($name)) {
 82 |             throw new Exception();
 83 |         }
 84 |     }
 85 | 
 86 |     public function checkStringInParam(
 87 |         #[Assert('string')]
 88 |         mixed $name
 89 |     ): void {
 90 |         if (!is_string($name)) {
 91 |             throw new Exception();
 92 |         }
 93 |     }
 94 | 
 95 |     public function checkStringInParamWithName(
 96 |         #[Assert(name: 'string')]
 97 |         mixed $name
 98 |     ): void {
 99 |         if (!is_string($name)) {
100 |             throw new Exception();
101 |         }
102 |     }
103 | 
104 |     public function checkStringInTwoParams(
105 |         #[Assert('string')]
106 |         mixed $name1,
107 |         #[Assert('string')]
108 |         mixed $name2
109 |     ): void {
110 |         if (!is_string($name1) || !is_string($name2)) {
111 |             throw new Exception();
112 |         }
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/tests/data/AssertIfFalse/FunctionAssertIfFalseAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\AssertIfFalse;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\AssertIfFalse;
 7 | 
 8 | #[AssertIfFalse(name: 'string')]
 9 | function checkString(mixed $name): bool
10 | {
11 |     return !is_string($name);
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/data/AssertIfFalse/InvalidMethodAssertIfFalseAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\AssertIfFalse;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\AssertIfFalse;
 6 | 
 7 | class InvalidMethodAssertIfFalseAttribute
 8 | {
 9 |     #[AssertIfFalse(0)]
10 |     public function checkString(mixed $name): bool
11 |     {
12 |         return false;
13 |     }
14 | 
15 |     #[AssertIfFalse(property: 'string')]
16 |     public string $property;
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/data/AssertIfFalse/MethodAssertIfFalseAttribute.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\AssertIfFalse;
  4 | 
  5 | use Exception;
  6 | use PhpStaticAnalysis\Attributes\AssertIfFalse;
  7 | 
  8 | class MethodAssertIfFalseAttribute
  9 | {
 10 |     private mixed $name = 'name';
 11 | 
 12 |     #[AssertIfFalse(name: 'string')] // checks name is string
 13 |     public function checkString(mixed $name): bool
 14 |     {
 15 |         return !is_string($name);
 16 |     }
 17 | 
 18 |     #[AssertIfFalse(exception: Exception::class)]
 19 |     public function checkException(mixed $exception): bool
 20 |     {
 21 |         return !$exception instanceof Exception;
 22 |     }
 23 | 
 24 |     #[AssertIfFalse('string $name')]
 25 |     public function checkOtherString(mixed $name): bool
 26 |     {
 27 |         return !is_string($name);
 28 |     }
 29 | 
 30 |     #[AssertIfFalse('string $this->name')]
 31 |     public function checkOtherPropertyString(mixed $name): bool
 32 |     {
 33 |         return !is_string($this->name);
 34 |     }
 35 | 
 36 |     /**
 37 |      * @deprecated
 38 |      */
 39 |     #[AssertIfFalse(name: 'string')]
 40 |     public function checkAnotherString(mixed $name): bool
 41 |     {
 42 |         return !is_string($name);
 43 |     }
 44 | 
 45 |     /**
 46 |      * @assert int $name
 47 |      */
 48 |     #[AssertIfFalse(name: 'string')]
 49 |     public function checkEvenMoreString(mixed $name): bool
 50 |     {
 51 |         return !is_string($name);
 52 |     }
 53 | 
 54 |     #[AssertIfFalse(
 55 |         name1: 'string',
 56 |         name2: 'string'
 57 |     )]
 58 |     public function checkStrings(mixed $name1, mixed $name2): bool
 59 |     {
 60 |         return !is_string($name1) || !is_string($name2);
 61 |     }
 62 | 
 63 |     #[AssertIfFalse(name1: 'string')]
 64 |     #[AssertIfFalse(name2: 'string')]
 65 |     public function checkOtherStrings(mixed $name1, mixed $name2): bool
 66 |     {
 67 |         return !is_string($name1) || !is_string($name2);
 68 |     }
 69 | 
 70 |     /**
 71 |      * @assert string $name
 72 |      */
 73 |     public function checkMoreAndMoreString(mixed $name): bool
 74 |     {
 75 |         return !is_string($name);
 76 |     }
 77 | 
 78 |     public function checkStringInParam(
 79 |         #[AssertIfFalse('string')]
 80 |         mixed $name
 81 |     ): bool {
 82 |         return !is_string($name);
 83 |     }
 84 | 
 85 |     public function checkStringInParamWithName(
 86 |         #[AssertIfFalse(name: 'string')]
 87 |         mixed $name
 88 |     ): bool {
 89 |         return !is_string($name);
 90 |     }
 91 | 
 92 |     public function checkStringInTwoParams(
 93 |         #[AssertIfFalse('string')]
 94 |         mixed $name1,
 95 |         #[AssertIfFalse('string')]
 96 |         mixed $name2
 97 |     ): bool {
 98 |         return !is_string($name1) || !is_string($name2);
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/tests/data/AssertIfTrue/FunctionAssertIfTrueAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\AssertIfTrue;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\AssertIfTrue;
 7 | 
 8 | #[AssertIfTrue(name: 'string')]
 9 | function checkString(mixed $name): bool
10 | {
11 |     return is_string($name);
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/data/AssertIfTrue/InvalidMethodAssertIfTrueAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\AssertIfTrue;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\AssertIfTrue;
 6 | 
 7 | class InvalidMethodAssertIfTrueAttribute
 8 | {
 9 |     #[AssertIfTrue(0)]
10 |     public function checkString(mixed $name): bool
11 |     {
12 |         return true;
13 |     }
14 | 
15 |     #[AssertIfTrue(property: 'string')]
16 |     public string $property;
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/data/AssertIfTrue/MethodAssertIfTrueAttribute.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\AssertIfTrue;
  4 | 
  5 | use Exception;
  6 | use PhpStaticAnalysis\Attributes\AssertIfTrue;
  7 | 
  8 | class MethodAssertIfTrueAttribute
  9 | {
 10 |     private mixed $name = 'name';
 11 | 
 12 |     #[AssertIfTrue(name: 'string')] // checks name is string
 13 |     public function checkString(mixed $name): bool
 14 |     {
 15 |         return is_string($name);
 16 |     }
 17 | 
 18 |     #[AssertIfTrue(exception: Exception::class)]
 19 |     public function checkException(mixed $exception): bool
 20 |     {
 21 |         return $exception instanceof Exception;
 22 |     }
 23 | 
 24 |     #[AssertIfTrue('string $name')]
 25 |     public function checkOtherString(mixed $name): bool
 26 |     {
 27 |         return is_string($name);
 28 |     }
 29 | 
 30 |     #[AssertIfTrue('string $this->name')]
 31 |     public function checkOtherPropertyString(mixed $name): bool
 32 |     {
 33 |         return is_string($this->name);
 34 |     }
 35 | 
 36 |     /**
 37 |      * @deprecated
 38 |      */
 39 |     #[AssertIfTrue(name: 'string')]
 40 |     public function checkAnotherString(mixed $name): bool
 41 |     {
 42 |         return is_string($name);
 43 |     }
 44 | 
 45 |     /**
 46 |      * @assert int $name
 47 |      */
 48 |     #[AssertIfTrue(name: 'string')]
 49 |     public function checkEvenMoreString(mixed $name): bool
 50 |     {
 51 |         return is_string($name);
 52 |     }
 53 | 
 54 |     #[AssertIfTrue(
 55 |         name1: 'string',
 56 |         name2: 'string'
 57 |     )]
 58 |     public function checkStrings(mixed $name1, mixed $name2): bool
 59 |     {
 60 |         return is_string($name1) && is_string($name2);
 61 |     }
 62 | 
 63 |     #[AssertIfTrue(name1: 'string')]
 64 |     #[AssertIfTrue(name2: 'string')]
 65 |     public function checkOtherStrings(mixed $name1, mixed $name2): bool
 66 |     {
 67 |         return is_string($name1) && is_string($name2);
 68 |     }
 69 | 
 70 |     /**
 71 |      * @assert string $name
 72 |      */
 73 |     public function checkMoreAndMoreString(mixed $name): bool
 74 |     {
 75 |         return is_string($name);
 76 |     }
 77 | 
 78 |     public function checkStringInParam(
 79 |         #[AssertIfTrue('string')]
 80 |         mixed $name
 81 |     ): bool {
 82 |         return is_string($name);
 83 |     }
 84 | 
 85 |     public function checkStringInParamWithName(
 86 |         #[AssertIfTrue(name: 'string')]
 87 |         mixed $name
 88 |     ): bool {
 89 |         return is_string($name);
 90 |     }
 91 | 
 92 |     public function checkStringInTwoParams(
 93 |         #[AssertIfTrue('string')]
 94 |         mixed $name1,
 95 |         #[AssertIfTrue('string')]
 96 |         mixed $name2
 97 |     ): bool {
 98 |         return is_string($name1) && is_string($name2);
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/tests/data/DefineType/ClassDefineTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\DefineType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | 
 8 | #[DefineType(UserAddress: 'array{street: string, city: string, zip: string}')] // this is an alias of the listed type
 9 | #[DefineType('UserName array{firstName: string, lastName: string}')]
10 | #[DefineType(
11 |     StringArray: 'string[]',
12 |     IntArray: 'int[]',
13 | )]
14 | class ClassDefineTypeAttribute
15 | {
16 |     #[Param(address: 'UserAddress')]
17 |     public function getZip($address): string
18 |     {
19 |         return $address['zip'];
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/tests/data/DefineType/InterfaceDefineTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\DefineType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | 
 7 | #[DefineType(StringArray: 'string[]')]
 8 | interface InterfaceDefineTypeAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/DefineType/InvalidClassDefineTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\DefineType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | 
 7 | #[DefineType(0)]
 8 | #[DefineType('string')]
 9 | #[DefineType(name: 'count($a)')]
10 | class InvalidClassDefineTypeAttribute
11 | {
12 |     #[DefineType('StringArray string[]')]
13 |     public function getName(): string
14 |     {
15 |         return "John";
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/data/DefineType/TraitDefineTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\DefineType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | 
 7 | #[DefineType(StringArray: 'string[]')]
 8 | trait TraitDefineTypeAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Deprecated/ClassDeprecatedAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Deprecated;
 6 | 
 7 | #[Deprecated] // Use NotDeprecatedClassInstead
 8 | class ClassDeprecatedAttribute
 9 | {
10 | }
11 | 
12 | $class = new ClassDeprecatedAttribute();
13 | 


--------------------------------------------------------------------------------
/tests/data/Deprecated/FunctionDeprecatedAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Deprecated;
 6 | 
 7 | #[Deprecated]
 8 | function returnDeprecated(): void
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Deprecated/InterfaceDeprecatedAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Deprecated;
 6 | 
 7 | #[Deprecated]
 8 | interface InterfaceDeprecatedAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Deprecated/InvalidMethodDeprecatedAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Deprecated;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | use PhpStaticAnalysis\Attributes\Returns;
 8 | 
 9 | class InvalidMethodDeprecatedAttribute
10 | {
11 |     public function getName(
12 |         #[Deprecated]
13 |         string $name
14 |     ): string {
15 |         return $name;
16 |     }
17 | 
18 |     #[Deprecated]
19 |     #[Deprecated]
20 |     public function getMoreName(): void
21 |     {
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/data/Deprecated/MethodDeprecatedAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Deprecated;
 6 | 
 7 | class MethodDeprecatedAttribute
 8 | {
 9 |     #[Deprecated]
10 |     public function returnDeprecated(): void
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @codeCoverageIgnore
16 |      */
17 |     #[Deprecated]
18 |     public function returnAnotherDeprecated(): void
19 |     {
20 |     }
21 | 
22 |     /**
23 |      * @deprecated
24 |      */
25 |     public function returnMoreDeprecateds(): void
26 |     {
27 |     }
28 | }
29 | 
30 | $class = new MethodDeprecatedAttribute();
31 | $class->returnDeprecated();
32 | 


--------------------------------------------------------------------------------
/tests/data/Deprecated/PropertyDeprecatedAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Deprecated;
 6 | 
 7 | class PropertyDeprecatedAttribute
 8 | {
 9 |     #[Deprecated]
10 |     public const NAME = 'name';
11 | 
12 |     #[Deprecated]
13 |     public string $name = '';
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/data/Deprecated/TraitDeprecatedAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Deprecated;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Deprecated;
 6 | 
 7 | #[Deprecated]
 8 | trait TraitDeprecatedAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Immutable/ClassImmutableAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Immutable;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Immutable;
 6 | 
 7 | #[Immutable] // All properties are read only
 8 | class ClassImmutableAttribute
 9 | {
10 |     public string $name = '';
11 | }
12 | 
13 | $class = new ClassImmutableAttribute();
14 | $class->name = 'John';
15 | 


--------------------------------------------------------------------------------
/tests/data/Immutable/InterfaceImmutableAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Immutable;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Immutable;
 6 | 
 7 | #[Immutable]
 8 | interface InterfaceImmutableAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Immutable/InvalidClassImmutableAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Immutable;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Immutable;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | use PhpStaticAnalysis\Attributes\Returns;
 8 | 
 9 | #[Immutable]
10 | #[Immutable]
11 | class InvalidClassImmutableAttribute
12 | {
13 |     #[Immutable]
14 |     public string $name = '';
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/data/Immutable/TraitImmutableAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Immutable;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Immutable;
 6 | 
 7 | #[Immutable]
 8 | trait TraitImmutableAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/ImportType/ClassImportTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\ImportType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | use PhpStaticAnalysis\Attributes\ImportType;
 7 | use PhpStaticAnalysis\Attributes\Param;
 8 | 
 9 | #[ImportType(UserAddress: TypeClass::class)] // we import this alias from another class
10 | #[ImportType('UserName from TypeClass')]
11 | #[ImportType(
12 |     StringArray: 'TypeClass',
13 |     IntArray: TypeClass::class,
14 | )]
15 | class ClassImportTypeAttribute
16 | {
17 |     #[Param(address: 'UserAddress')]
18 |     public function getZip($address): string
19 |     {
20 |         return $address['zip'];
21 |     }
22 | }
23 | 
24 | #[DefineType(UserAddress: 'array{street: string, city: string, zip: string}')]
25 | #[DefineType('UserName array{firstName: string, lastName: string}')]
26 | #[DefineType(StringArray: 'string[]')]
27 | #[DefineType(IntArray: 'int[]')]
28 | class TypeClass
29 | {
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/data/ImportType/InterfaceImportTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\ImportType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | use PhpStaticAnalysis\Attributes\ImportType;
 7 | 
 8 | #[ImportType(StringArray: StringClass::class)]
 9 | interface InterfaceImportTypeAttribute
10 | {
11 | }
12 | 
13 | #[DefineType(StringArray: 'string[]')]
14 | class StringClass
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/data/ImportType/InvalidClassImportTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\ImportType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | use PhpStaticAnalysis\Attributes\ImportType;
 7 | 
 8 | #[ImportType(0)]
 9 | #[ImportType('string')]
10 | #[ImportType(name: 'count($a)')]
11 | class InvalidClassImportTypeAttribute
12 | {
13 |     #[ImportType(StringArray: StringClass::class)]
14 |     public function getName(): string
15 |     {
16 |         return "John";
17 |     }
18 | }
19 | 
20 | #[DefineType(StringArray: 'string[]')]
21 | class StringClass
22 | {
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/data/ImportType/TraitImportTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\ImportType;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\DefineType;
 6 | use PhpStaticAnalysis\Attributes\ImportType;
 7 | 
 8 | #[ImportType(StringArray: StringClass::class)]
 9 | trait TraitImportTypeAttribute
10 | {
11 | }
12 | 
13 | #[DefineType(StringArray: 'string[]')]
14 | class StringClass
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/data/Impure/FunctionImpureAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Impure;
 6 | 
 7 | $i = 0;
 8 | 
 9 | #[Impure]
10 | function add(int $left): int
11 | {
12 |     global $i;
13 |     
14 |     $i += $left;
15 |     return $i;
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/data/Impure/InvalidMethodImpureAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Impure;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Impure;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | use PhpStaticAnalysis\Attributes\Returns;
 8 | 
 9 | class InvalidMethodImpureAttribute
10 | {
11 |     #[Impure]
12 |     public string $name = '';
13 | 
14 |     #[Impure]
15 |     #[Impure]
16 |     public function getMoreName(): void
17 |     {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/data/Impure/MethodImpureAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Impure;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Impure;
 6 | 
 7 | class MethodImpureAttribute
 8 | {
 9 |     public static int $i = 0;
10 | 
11 |     #[Impure]
12 |     public static function add(int $left): int
13 |     {
14 |         self::$i += $left;
15 |         return self::$i;
16 |     }
17 | 
18 |     /**
19 |      * @codeCoverageIgnore
20 |      */
21 |     #[Impure]
22 |     public function addAnother(int $left): int
23 |     {
24 |         self::$i += $left;
25 |         return self::$i;
26 |     }
27 | 
28 |     /**
29 |      * @impure
30 |      */
31 |     public function addMore(int $left): int
32 |     {
33 |         self::$i += $left;
34 |         return self::$i;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/data/Internal/ClassInternalAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Internal;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Internal;
 6 | 
 7 | #[Internal('newNamespace\test')] // Can only be accessed from the current namespace
 8 | class ClassInternalAttribute
 9 | {
10 |     #[Internal]
11 |     public function myFunction(): void
12 |     {
13 |     }
14 | }
15 | 
16 | namespace newNamespace\test;
17 | 
18 | class newClass
19 | {
20 |     public function newFunction(): void
21 |     {
22 |         $class = new \test\PhpStaticAnalysis\PHPStanExtension\data\Internal\ClassInternalAttribute();
23 | 
24 |         $class->myFunction();
25 |     }
26 | }
27 | 
28 | namespace newNamespace\other;
29 | 
30 | class otherClass
31 | {
32 |     public function otherFunction(): void
33 |     {
34 |         $class = new \test\PhpStaticAnalysis\PHPStanExtension\data\Internal\ClassInternalAttribute();
35 | 
36 |         $class->myFunction();
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/data/Internal/FunctionInternalAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Internal;
 6 | 
 7 | #[Internal]
 8 | function returnInternal(): void
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Internal/InterfaceInternalAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Internal;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Internal;
 6 | 
 7 | #[Internal]
 8 | interface InterfaceInternalAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Internal/InvalidMethodInternalAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Internal;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Internal;
 6 | 
 7 | class InvalidMethodInternalAttribute
 8 | {
 9 |     #[Internal(0)]
10 |     public function getName(): void
11 |     {
12 |     }
13 | 
14 |     public function getExtraName(
15 |         #[Internal]
16 |         string $name
17 |     ): string {
18 |         return $name;
19 |     }
20 | 
21 |     #[Internal]
22 |     #[Internal]
23 |     public function getMoreName(): void
24 |     {
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/data/Internal/MethodInternalAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Internal;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Internal;
 6 | 
 7 | class MethodInternalAttribute
 8 | {
 9 |     #[Internal]
10 |     public function returnInternal(): void
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @codeCoverageIgnore
16 |      */
17 |     #[Internal]
18 |     public function returnAnotherInternal(): void
19 |     {
20 |     }
21 | 
22 |     /**
23 |      * @internal
24 |      */
25 |     public function returnMoreInternals(): void
26 |     {
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/data/Internal/PropertyInternalAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Internal;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Internal;
 6 | 
 7 | class PropertyInternalAttribute
 8 | {
 9 |     #[Internal]
10 |     public const NAME = 'name';
11 | 
12 |     #[Internal]
13 |     public string $name = '';
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/data/Internal/TraitInternalAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Internal;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Internal;
 6 | 
 7 | #[Internal]
 8 | trait TraitInternalAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/IsReadOnly/InvalidPropertyIsReadOnlyAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\IsReadOnly;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\IsReadOnly;
 6 | 
 7 | class InvalidPropertyIsReadOnlyAttribute
 8 | {
 9 |     #[IsReadOnly(0)]
10 |     public string $invalidProperty;
11 | 
12 |     #[IsReadOnly]
13 |     #[IsReadOnly]
14 |     public string $otherInvalidProperty;
15 | 
16 |     #[IsReadOnly]
17 |     public function getString(): string
18 |     {
19 |         return 'hello';
20 |     }
21 | 
22 |     public function __construct()
23 |     {
24 |         $this->invalidProperty = 'Mike';
25 |         $this->otherInvalidProperty = 'John';
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/data/IsReadOnly/PropertyIsReadOnlyAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\IsReadOnly;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\IsReadOnly;
 6 | 
 7 | class PropertyIsReadOnlyAttribute
 8 | {
 9 |     #[IsReadOnly] // cannot be written to
10 |     public string $name;
11 | 
12 |     public function __construct()
13 |     {
14 |         $this->name = 'Mike';
15 |     }
16 | }
17 | 
18 | $p = new PropertyIsReadOnlyAttribute();
19 | $p->name = 'John';
20 | 


--------------------------------------------------------------------------------
/tests/data/Method/ClassMethodAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Method;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Method;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | 
 8 | #[Method('string getString()')] // get the main string
 9 | #[Method(
10 |     'void setString(string $text)',
11 |     'static string staticGetter()',
12 | )]
13 | class ClassMethodAttribute
14 | {
15 |     #[Param(arguments: 'mixed[]')]
16 |     public function __call(string $name, array $arguments): mixed
17 |     {
18 |         $callable = [$this, $name];
19 |         if (is_callable($callable)) {
20 |             return call_user_func_array($callable, $arguments);
21 |         }
22 |         return null;
23 |     }
24 | }
25 | 
26 | $class = new ClassMethodAttribute();
27 | $foo = $class->getString();
28 | $class->setString($foo);
29 | $bar = ClassMethodAttribute::staticGetter();
30 | 


--------------------------------------------------------------------------------
/tests/data/Method/InterfaceMethodAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Method;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Method;
 6 | 
 7 | #[Method('string getString()')]
 8 | interface InterfaceMethodAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Method/InvalidClassMethodAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Method;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Method;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | 
 8 | #[Method(0)]
 9 | #[Method('string')]
10 | #[Method('count($a)')]
11 | class InvalidClassMethodAttribute
12 | {
13 |     #[Method('string getString()')]
14 |     public function getName(): string
15 |     {
16 |         return "John";
17 |     }
18 | 
19 |     #[Param(arguments: 'mixed[]')]
20 |     public function __call(string $name, array $arguments): mixed
21 |     {
22 |         $callable = [$this, $name];
23 |         if (is_callable($callable)) {
24 |             return call_user_func_array($callable, $arguments);
25 |         }
26 |         return null;
27 |     }
28 | }
29 | 
30 | $class = new InvalidClassMethodAttribute();
31 | $class->badFunction();
32 | 


--------------------------------------------------------------------------------
/tests/data/Method/TraitMethodAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Method;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Method;
 6 | 
 7 | #[Method('string getString()')]
 8 | trait TraitMethodAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Mixin/ClassMixinAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Mixin;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Mixin;
 6 | 
 7 | class ClassMixinAttribute
 8 | {
 9 |     public function proxied(): void
10 |     {
11 |     }
12 | }
13 | 
14 | class MyClass
15 | {
16 | }
17 | 
18 | class Another
19 | {
20 | }
21 | 
22 | #[Mixin(ClassMixinAttribute::class)] // this is the proxied class
23 | #[Mixin(
24 |     MyClass::class,
25 |     Another::class,
26 | )]
27 | class ClassMixinAttributeProxy
28 | {
29 |     public function __call(string $name, mixed ...$arguments): void
30 |     {
31 |         (new ClassMixinAttribute())->$name(...$arguments);
32 |     }
33 | }
34 | 
35 | $proxy = new ClassMixinAttributeProxy();
36 | $proxy->proxied();
37 | 


--------------------------------------------------------------------------------
/tests/data/Mixin/InterfaceMixinAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Mixin;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Mixin;
 6 | 
 7 | #[Mixin('AClass')]
 8 | interface InterfaceMixinAttribute
 9 | {
10 | }
11 | 
12 | class AClass
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/data/Mixin/InvalidClassMixinAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Mixin;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Mixin;
 6 | 
 7 | #[Mixin(0)]
 8 | #[Mixin('count($a)')]
 9 | class InvalidClassMixinAttribute
10 | {
11 |     #[Mixin('A')]
12 |     public function getName(): string
13 |     {
14 |         return "John";
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/data/Mixin/TraitMixinAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Mixin;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Mixin;
 6 | 
 7 | class Other
 8 | {
 9 | }
10 | 
11 | #[Mixin('Other')]
12 | trait TraitMixinAttribute
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/data/Param/FunctionParamAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Param;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | 
 7 | #[Param(names: 'string[]')]
 8 | function countNames(array $names): int
 9 | {
10 |     return count($names);
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/data/Param/InvalidMethodParamAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Param;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | 
 7 | class InvalidMethodParamAttribute
 8 | {
 9 |     #[Param(0)]
10 |     public function getNameLength(string $name): int
11 |     {
12 |         return strlen($name);
13 |     }
14 | 
15 |     #[Param('string')]
16 |     public function getOtherNameLength(string $name): int
17 |     {
18 |         return strlen($name);
19 |     }
20 | 
21 |     #[Param(name: 'count($a)')]
22 |     public function getAnotherNameLength(string $name): int
23 |     {
24 |         return strlen($name);
25 |     }
26 | 
27 |     #[Param(property: 'string')]
28 |     public string $property;
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/data/Param/MethodParamAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Param;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | 
 8 | class MethodParamAttribute
 9 | {
10 |     #[Param(names: 'string[]')] // returns the number of names
11 |     public function countNames(array $names): int
12 |     {
13 |         return count($names);
14 |     }
15 | 
16 |     #[Param(exception: Exception::class)]
17 |     public function throwException($exception): void
18 |     {
19 |         throw $exception;
20 |     }
21 | 
22 |     #[Param('string[] $names')]
23 |     public function countUnnamedNames(array $names): int
24 |     {
25 |         return count($names);
26 |     }
27 | 
28 |     /**
29 |      * @deprecated
30 |      */
31 |     #[Param(names: 'string[]')]
32 |     public function countMoreNames(array $names): int
33 |     {
34 |         return count($names);
35 |     }
36 | 
37 |     /**
38 |      * @param int $names
39 |      */
40 |     #[Param(names: 'string[]')]
41 |     public function countEvenMoreNames(array $names): int
42 |     {
43 |         return count($names);
44 |     }
45 | 
46 |     #[Param(
47 |         names1: 'string[]',
48 |         names2: 'string[]'
49 |     )]
50 |     public function countTwoNames(array $names1, array $names2): int
51 |     {
52 |         return count($names1 + $names2);
53 |     }
54 | 
55 |     #[Param(names1: 'string[]')]
56 |     #[Param(names2: 'string[]')]
57 |     public function countTwoMoreNames(array $names1, array $names2): int
58 |     {
59 |         return count($names1 + $names2);
60 |     }
61 | 
62 |     #[Param(names: 'string ...')]
63 |     public function countVariadicNames(...$names): int
64 |     {
65 |         return count($names);
66 |     }
67 | 
68 |     /**
69 |      * @param string[] $names
70 |      */
71 |     public function countNamesAndNames(array $names): int
72 |     {
73 |         return count($names);
74 |     }
75 | 
76 |     public function countNamesInParam(
77 |         #[Param('string[]')]
78 |         array $names
79 |     ): int {
80 |         return count($names);
81 |     }
82 | 
83 |     public function countNamesInParamWithName(
84 |         #[Param(names: 'string[]')]
85 |         array $names
86 |     ): int {
87 |         return count($names);
88 |     }
89 | 
90 |     public function countNamesInTwoParams(
91 |         #[Param('string[]')]
92 |         array $names1,
93 |         #[Param('string[]')]
94 |         array $names2
95 |     ): int {
96 |         return count($names1) + count($names2);
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/tests/data/ParamOut/FunctionParamOutAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\ParamOut;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\ParamOut;
 6 | 
 7 | #[ParamOut(names: 'int')]
 8 | function setNames(mixed &$names): void
 9 | {
10 |     $names = 1;
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/data/ParamOut/InvalidMethodParamOutAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\ParamOut;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\ParamOut;
 6 | 
 7 | class InvalidMethodParamOutAttribute
 8 | {
 9 |     #[ParamOut(0)]
10 |     public function setName(mixed &$name): void
11 |     {
12 |         $name = 1;
13 |     }
14 | 
15 |     #[ParamOut('string')]
16 |     public function setOtherName(mixed &$name): void
17 |     {
18 |         $name = 1;
19 |     }
20 | 
21 |     #[ParamOut(name: 'count($a)')]
22 |     public function setAnotherName(mixed &$name): void
23 |     {
24 |         $name = 1;
25 |     }
26 | 
27 |     #[ParamOut(property: 'string')]
28 |     public string $property;
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/data/ParamOut/MethodParamOutAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\ParamOut;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\ParamOut;
 7 | 
 8 | class MethodParamOutAttribute
 9 | {
10 |     #[ParamOut(names: 'int')] // we specify the type of the reference parameter after running the function
11 |     public function setNames(mixed &$names): void
12 |     {
13 |         $names = 1;
14 |     }
15 | 
16 |     #[ParamOut(exception: Exception::class)]
17 |     public function setException(mixed &$exception): void
18 |     {
19 |         $exception = new Exception();
20 |     }
21 | 
22 |     #[ParamOut('int $names')]
23 |     public function setUnnamedNames(mixed &$names): void
24 |     {
25 |         $names = 1;
26 |     }
27 | 
28 |     /**
29 |      * @deprecated
30 |      */
31 |     #[ParamOut(names: 'int')]
32 |     public function setMoreNames(mixed &$names): void
33 |     {
34 |         $names = 1;
35 |     }
36 | 
37 |     /**
38 |      * @param-out string $names
39 |      */
40 |     #[ParamOut(names: 'int')]
41 |     public function setEvenMoreNames(mixed &$names): void
42 |     {
43 |         $names = 1;
44 |     }
45 | 
46 |     #[ParamOut(
47 |         names1: 'int',
48 |         names2: 'int'
49 |     )]
50 |     public function setTwoNames(mixed &$names1, mixed &$names2): void
51 |     {
52 |         $names1 = 1;
53 |         $names2 = 2;
54 |     }
55 | 
56 |     #[ParamOut(names1: 'int')]
57 |     #[ParamOut(names2: 'int')]
58 |     public function setTwoMoreNames(mixed &$names1, mixed &$names2): void
59 |     {
60 |         $names1 = 1;
61 |         $names2 = 2;
62 |     }
63 | 
64 |     /**
65 |      * @param-out int $names
66 |      */
67 |     public function setNamesAndNames(mixed &$names): void
68 |     {
69 |         $names = 1;
70 |     }
71 | 
72 |     public function setNamesInParamOut(
73 |         #[ParamOut('int')]
74 |         mixed &$names
75 |     ): void {
76 |         $names = 1;
77 |     }
78 | 
79 |     public function setNamesInParamOutWithName(
80 |         #[ParamOut(names: 'int')]
81 |         mixed &$names
82 |     ): void {
83 |         $names = 1;
84 |     }
85 | 
86 |     public function setNamesInTwoParamOuts(
87 |         #[ParamOut('int')]
88 |         mixed &$names1,
89 |         #[ParamOut('int')]
90 |         mixed &$names2
91 |     ): void {
92 |         $names1 = 1;
93 |         $names2 = 2;
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/tests/data/Property/ClassPropertyAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Property;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Property;
 7 | 
 8 | #[Property(name: 'string')] // the name of the user
 9 | #[Property(exception: Exception::class)]
10 | #[Property('int $age')]
11 | #[Property(
12 |     index1: 'string[]',
13 |     index2: 'string[]',
14 | )]
15 | class ClassPropertyAttribute
16 | {
17 |     #[Property('int[]')]
18 |     public array $nums;
19 | 
20 |     public function __get(string $name): mixed
21 |     {
22 |         return $name;
23 |     }
24 | 
25 |     public function __set(string $name, mixed $value)
26 |     {
27 |         $this->$name = $value;
28 |     }
29 | }
30 | 
31 | $class = new ClassPropertyAttribute();
32 | $foo = $class->name;
33 | $class->age = 7;
34 | $indexes = $class->index1 + $class->index2;
35 | 


--------------------------------------------------------------------------------
/tests/data/Property/InterfacePropertyAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Property;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Property;
 6 | 
 7 | #[Property(name: 'string')]
 8 | interface InterfacePropertyAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Property/InvalidClassPropertyAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Property;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Property;
 6 | 
 7 | #[Property(0)]
 8 | #[Property('string')]
 9 | #[Property(name: 'count($a)')]
10 | class InvalidClassPropertyAttribute
11 | {
12 |     #[Property('string')]
13 |     public function getName(): string
14 |     {
15 |         return "John";
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/data/Property/TraitPropertyAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Property;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Property;
 6 | 
 7 | #[Property(name: 'string')]
 8 | trait TraitPropertyAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/PropertyRead/ClassPropertyReadAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyRead;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\PropertyRead;
 7 | 
 8 | #[PropertyRead(name: 'string')] // cannot be written to
 9 | #[PropertyRead(exception: Exception::class)]
10 | #[PropertyRead('int $age')]
11 | #[PropertyRead(
12 |     index1: 'string[]',
13 |     index2: 'string[]',
14 | )]
15 | class ClassPropertyReadAttribute
16 | {
17 |     public function __get(string $name): mixed
18 |     {
19 |         return $name;
20 |     }
21 | }
22 | 
23 | $class = new ClassPropertyReadAttribute();
24 | $foo = $class->name;
25 | $bar = $class->age;
26 | $indexes = $class->index1 + $class->index2;
27 | 


--------------------------------------------------------------------------------
/tests/data/PropertyRead/InterfacePropertyReadAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyRead;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\PropertyRead;
 6 | 
 7 | #[PropertyRead(name: 'string')]
 8 | interface InterfacePropertyReadAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/PropertyRead/InvalidClassPropertyReadAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyRead;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\PropertyRead;
 6 | 
 7 | #[PropertyRead(0)]
 8 | #[PropertyRead('string')]
 9 | #[PropertyRead(name: 'count($a)')]
10 | #[PropertyRead(age: 'int')]
11 | class InvalidClassPropertyReadAttribute
12 | {
13 |     #[PropertyRead('string')]
14 |     public function getName(): string
15 |     {
16 |         return "John";
17 |     }
18 | }
19 | 
20 | $class = new ClassPropertyReadAttribute();
21 | $class->age = 7;
22 | 


--------------------------------------------------------------------------------
/tests/data/PropertyRead/TraitPropertyReadAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyRead;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\PropertyRead;
 6 | 
 7 | #[PropertyRead(name: 'string')]
 8 | trait TraitPropertyReadAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/PropertyWrite/ClassPropertyWriteAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyWrite;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\PropertyWrite;
 7 | 
 8 | #[PropertyWrite(name: 'string')] // cannot be read
 9 | #[PropertyWrite(exception: Exception::class)]
10 | #[PropertyWrite('int $age')]
11 | #[PropertyWrite(
12 |     index1: 'string[]',
13 |     index2: 'string[]',
14 | )]
15 | class ClassPropertyWriteAttribute
16 | {
17 |     public function __set(string $name, mixed $value)
18 |     {
19 |         $this->$name = $value;
20 |     }
21 | }
22 | 
23 | $class = new ClassPropertyWriteAttribute();
24 | $class->name = 'John';
25 | $class->age = 7;
26 | $class->index1 = [];
27 | $class->index2 = [];
28 | 


--------------------------------------------------------------------------------
/tests/data/PropertyWrite/InterfacePropertyWriteAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyWrite;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\PropertyWrite;
 6 | 
 7 | #[PropertyWrite(name: 'string')]
 8 | interface InterfacePropertyWriteAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/PropertyWrite/InvalidClassPropertyWriteAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyWrite;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\PropertyWrite;
 6 | 
 7 | #[PropertyWrite(0)]
 8 | #[PropertyWrite('string')]
 9 | #[PropertyWrite(name: 'count($a)')]
10 | #[PropertyWrite(age: 'int')]
11 | class InvalidClassPropertyWriteAttribute
12 | {
13 |     #[PropertyWrite('string')]
14 |     public function getName(): string
15 |     {
16 |         return "John";
17 |     }
18 | }
19 | 
20 | $class = new ClassPropertyWriteAttribute();
21 | $foo = $class->age;
22 | 


--------------------------------------------------------------------------------
/tests/data/PropertyWrite/TraitPropertyWriteAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\PropertyWrite;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\PropertyWrite;
 6 | 
 7 | #[PropertyWrite(name: 'string')]
 8 | trait TraitPropertyWriteAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/data/Pure/FunctionPureAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Pure;
 6 | 
 7 | #[Pure]
 8 | function add(int $left, int $right): int
 9 | {
10 |     return $left + $right;
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/data/Pure/InvalidMethodPureAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Pure;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Pure;
 7 | use PhpStaticAnalysis\Attributes\Returns;
 8 | 
 9 | class InvalidMethodPureAttribute
10 | {
11 |     #[Pure]
12 |     public string $name = '';
13 | 
14 |     #[Pure]
15 |     #[Pure]
16 |     public function getMoreName(): void
17 |     {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/data/Pure/MethodPureAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Pure;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Pure;
 6 | 
 7 | class MethodPureAttribute
 8 | {
 9 |     #[Pure]
10 |     public function add(int $left, int $right): int
11 |     {
12 |         return $left + $right;
13 |     }
14 | 
15 |     /**
16 |      * @codeCoverageIgnore
17 |      */
18 |     #[Pure]
19 |     public function addAnother(int $left, int $right): int
20 |     {
21 |         return $left + $right;
22 |     }
23 | 
24 |     /**
25 |      * @pure
26 |      */
27 |     public function addMore(int $left, int $right): int
28 |     {
29 |         return $left + $right;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/tests/data/RequireExtends/InvalidTraitRequireExtendsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\RequireExtends;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\RequireExtends;
 6 | 
 7 | #[RequireExtends(0)]
 8 | trait InvalidTraitRequireExtendsAttribute2
 9 | {
10 | }
11 | 
12 | #[RequireExtends('+5')]
13 | trait InvalidTraitRequireExtendsAttributeChild3
14 | {
15 | }
16 | 
17 | #[RequireExtends('InvalidClassRequireExtendsAttribute')]
18 | #[RequireExtends('InvalidClassRequireExtendsAttribute')]
19 | trait InvalidTraitRequireExtendsAttribute
20 | {
21 |     #[RequireExtends('InvalidClassRequireExtendsAttribute')]
22 |     public string $name = '';
23 | }
24 | 
25 | class InvalidClassRequireExtendsAttribute
26 | {
27 | }
28 | 
29 | class InvalidClassRequireExtendsAttributeChild extends InvalidClassRequireExtendsAttribute
30 | {
31 |     use InvalidTraitRequireExtendsAttribute;
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/data/RequireExtends/TraitRequireExtendsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\RequireExtends;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\RequireExtends;
 6 | 
 7 | #[RequireExtends(ClassRequireExtendsAttribute::class)] // the class using this trait needs to extend this class
 8 | trait TraitRequireExtendsAttribute
 9 | {
10 | }
11 | 
12 | class ClassRequireExtendsAttribute
13 | {
14 | }
15 | 
16 | class ClassRequireExtendsAttributeChild extends ClassRequireExtendsAttribute
17 | {
18 |     use TraitRequireExtendsAttribute;
19 | }
20 | 
21 | class ClassRequireExtendsAttributeChild2
22 | {
23 |     use TraitRequireExtendsAttribute;
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/data/RequireImplements/InvalidTraitRequireImplementsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\RequireImplements;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\RequireImplements;
 6 | 
 7 | #[RequireImplements(0)]
 8 | trait InvalidTraitRequireImplementsAttribute2
 9 | {
10 | }
11 | 
12 | #[RequireImplements('+5')]
13 | trait InvalidTraitRequireImplementsAttribute
14 | {
15 |     #[RequireImplements('InvalidInterfaceRequireImplementsAttribute')]
16 |     public string $name = '';
17 | }
18 | 
19 | interface InvalidInterfaceRequireImplementsAttribute
20 | {
21 | }
22 | 
23 | class InvalidClassRequireImplementsAttribute implements InvalidInterfaceRequireImplementsAttribute
24 | {
25 |     use InvalidTraitRequireImplementsAttribute;
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/data/RequireImplements/TraitRequireImplementsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\RequireImplements;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\RequireImplements;
 6 | 
 7 | #[RequireImplements(InterfaceRequireImplementsAttribute::class)] // the class that uses this trait needs to implement these interfaces
 8 | #[RequireImplements(
 9 |     InterfaceRequireImplementsAttribute2::class,
10 |     InterfaceRequireImplementsAttribute3::class
11 | )]
12 | trait TraitRequireImplementsAttribute
13 | {
14 | }
15 | 
16 | interface InterfaceRequireImplementsAttribute
17 | {
18 | }
19 | 
20 | interface InterfaceRequireImplementsAttribute2
21 | {
22 | }
23 | 
24 | interface InterfaceRequireImplementsAttribute3
25 | {
26 | }
27 | 
28 | class ClassRequireImplementsAttribute implements InterfaceRequireImplementsAttribute, InterfaceRequireImplementsAttribute2, InterfaceRequireImplementsAttribute3
29 | {
30 |     use TraitRequireImplementsAttribute;
31 | }
32 | 
33 | class ClassRequireImplementsAttribute2 implements InterfaceRequireImplementsAttribute, InterfaceRequireImplementsAttribute2
34 | {
35 |     use TraitRequireImplementsAttribute;
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/data/Returns/FunctionReturnsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Returns;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Returns;
 6 | 
 7 | #[Returns('string[]')]
 8 | function getNames(): array
 9 | {
10 |     return ['hello', 'world'];
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/data/Returns/InvalidMethodReturnsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Returns;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Returns;
 6 | 
 7 | class InvalidMethodReturnsAttribute
 8 | {
 9 |     #[Returns(0)]
10 |     public function getName(): string
11 |     {
12 |         return 'hello';
13 |     }
14 | 
15 |     #[Returns('string')]
16 |     #[Returns('string')]
17 |     public function getOtherName(): string
18 |     {
19 |         return 'hello';
20 |     }
21 | 
22 |     #[Returns('string', 'string')]
23 |     public function getEvenMoreNames(): string
24 |     {
25 |         return 'hello';
26 |     }
27 | 
28 |     #[Returns('$a + $b')]
29 |     public function getMoreAndMoreNames(): string
30 |     {
31 |         return 'hello';
32 |     }
33 | 
34 |     #[Returns('string')]
35 |     public string $property;
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/data/Returns/MethodReturnsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Returns;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | 
 8 | class MethodReturnsAttribute
 9 | {
10 |     #[Returns('string[]')] // the names of the users
11 |     public function getNames(): array
12 |     {
13 |         return ['hello', 'world'];
14 |     }
15 | 
16 |     #[Returns(Exception::class)]
17 |     public function getException()
18 |     {
19 |         return new Exception();
20 |     }
21 | 
22 |     /**
23 |      * @deprecated
24 |      */
25 |     #[Returns('string[]')]
26 |     public function getMoreNames(): array
27 |     {
28 |         return ['hello', 'world'];
29 |     }
30 | 
31 |     /**
32 |      * @return int
33 |      */
34 |     #[Returns('string[]')]
35 |     public function getEvenMoreNames(): array
36 |     {
37 |         return ['hello', 'world'];
38 |     }
39 | 
40 |     /**
41 |      * @return string[]
42 |      */
43 |     public function getNamesAndNames(): array
44 |     {
45 |         return ['hello', 'world'];
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/tests/data/SelfOut/InvalidMethodSelfOutAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\SelfOut;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\SelfOut;
 7 | use PhpStaticAnalysis\Attributes\Template;
 8 | 
 9 | #[Template('TValue')]
10 | class InvalidMethodSelfOutAttribute
11 | {
12 |     #[Template('TItemValue')]
13 |     #[Param(item: 'TItemValue')]
14 |     #[SelfOut(0)]
15 |     public function add($item): void
16 |     {
17 |     }
18 | 
19 |     #[Template('TItemValue')]
20 |     #[Param(item: 'TItemValue')]
21 |     #[SelfOut('self<TValue|TItemValue>')]
22 |     #[SelfOut('self<TValue|TItemValue>')]
23 |     public function addMore($item): void
24 |     {
25 |     }
26 | 
27 |     #[SelfOut('self<TValue|TItemValue>')]
28 |     public string $property;
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/data/SelfOut/MethodSelfOutAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\SelfOut;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\SelfOut;
 7 | use PhpStaticAnalysis\Attributes\Template;
 8 | 
 9 | #[Template('TValue')]
10 | class MethodSelfOutAttribute
11 | {
12 |     #[Template('TItemValue')]
13 |     #[Param(item: 'TItemValue')]
14 |     #[SelfOut('self<TValue|TItemValue>')] // we specify the new type
15 |     public function add($item): void
16 |     {
17 |     }
18 | 
19 |     /**
20 |      * @deprecated
21 |      */
22 |     #[Template('TItemValue')]
23 |     #[Param(item: 'TItemValue')]
24 |     #[SelfOut('self<TValue|TItemValue>')]
25 |     public function addMore($item): void
26 |     {
27 |     }
28 | 
29 |     /**
30 |      * @self-out self<TValue>
31 |      */
32 |     #[Template('TItemValue')]
33 |     #[Param(item: 'TItemValue')]
34 |     #[SelfOut('self<TValue|TItemValue>')]
35 |     public function addEvenMore($item): void
36 |     {
37 |     }
38 | 
39 |     /**
40 |      * @self-out self<TValue|TItemValue>
41 |      */
42 |     #[Template('TItemValue')]
43 |     #[Param(item: 'TItemValue')]
44 |     public function addMoreAndMore($item): void
45 |     {
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/tests/data/Template/ClassTemplateAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Template;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\Template;
 8 | 
 9 | #[Template('T')] // the type used in the class
10 | class ClassTemplateAttribute
11 | {
12 |     #[Param(param: 'T')]
13 |     #[Returns('T')]
14 |     public function returnTemplate($param)
15 |     {
16 |         return $param;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/data/Template/FunctionTemplateAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\Template;
 8 | 
 9 | #[Template('T')]
10 | #[Param(param: 'T')]
11 | #[Returns('T')]
12 | function returnTemplate($param)
13 | {
14 |     return $param;
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/data/Template/InterfaceTemplateAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Template;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\Template;
 8 | 
 9 | #[Template('T')]
10 | interface InterfaceTemplateAttribute
11 | {
12 |     #[Param(param: 'T')]
13 |     #[Returns('T')]
14 |     public function returnTemplate($param);
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/data/Template/InvalidMethodTemplateAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Template;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\Template;
 8 | 
 9 | class InvalidMethodTemplateAttribute
10 | {
11 |     #[Template(0)]
12 |     public function getName(): string
13 |     {
14 |         return 'Mike';
15 |     }
16 | 
17 |     #[Template('+5')]
18 |     public function getAnotherName(): string
19 |     {
20 |         return 'John';
21 |     }
22 | 
23 |     #[Template('T')]
24 |     public string $property;
25 | 
26 |     #[Template('T', 0)]
27 |     #[Param(param: 'T')]
28 |     #[Returns('T')]
29 |     public function getMoreName($param)
30 |     {
31 |         return $param;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/data/Template/MethodTemplateAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Template;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Param;
 7 | use PhpStaticAnalysis\Attributes\Returns;
 8 | use PhpStaticAnalysis\Attributes\Template;
 9 | 
10 | class MethodTemplateAttribute
11 | {
12 |     #[Template('T')]
13 |     #[Param(param: 'T')]
14 |     #[Returns('T')]
15 |     public function returnTemplate($param)
16 |     {
17 |         return $param;
18 |     }
19 | 
20 |     #[Template('T', Exception::class)]
21 |     #[Param(param: 'T')]
22 |     #[Returns('T')]
23 |     public function returnTemplateOfException($param)
24 |     {
25 |         return $param;
26 |     }
27 | 
28 |     /**
29 |      * @deprecated
30 |      */
31 |     #[Template('T')]
32 |     #[Param(param: 'T')]
33 |     #[Returns('T')]
34 |     public function returnAnotherTemplate($param)
35 |     {
36 |         return $param;
37 |     }
38 | 
39 |     /**
40 |      * @template T1
41 |      * @param T1 $param1
42 |      */
43 |     #[Template('T2')]
44 |     #[Param(param2: 'T2')]
45 |     #[Returns('T1')]
46 |     public function returnOneOfTheTemplates($param1, $param2)
47 |     {
48 |         return $param1;
49 |     }
50 | 
51 |     #[Template('T1')]
52 |     #[Template('T2')]
53 |     #[Param(param1: 'T1', param2: 'T2')]
54 |     #[Returns('T1')]
55 |     public function moreReturnOneOfTheTemplates($param1, $param2)
56 |     {
57 |         return $param1;
58 |     }
59 | 
60 |     /**
61 |      * @template T
62 |      * @param T $param
63 |      * @return T
64 |      */
65 |     public function returnMoreTemplates($param)
66 |     {
67 |         return $param;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/tests/data/Template/TraitTemplateAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Template;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\Template;
 8 | 
 9 | #[Template('T')]
10 | trait TraitTemplateAttribute
11 | {
12 |     #[Param(param: 'T')]
13 |     #[Returns('T')]
14 |     public function returnTemplate($param)
15 |     {
16 |         return $param;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/data/TemplateContravariant/ClassTemplateContravariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateContravariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\TemplateContravariant;
 8 | 
 9 | class ClassTemplateContravariantAttribute
10 | {
11 | }
12 | class ClassTemplateContravariantAttributeChild extends ClassTemplateContravariantAttribute
13 | {
14 | }
15 | 
16 | #[TemplateContravariant('TConsumable')] // can only be used in contra-variant position
17 | class Consumer
18 | {
19 |     #[Param(consumable: 'TConsumable')]
20 |     public function consume($consumable): void
21 |     {
22 |     }
23 | }
24 | 
25 | #[Returns('Consumer<ClassTemplateContravariantAttribute>')]
26 | function getClassTemplateContravariantAttributeConsumer(): Consumer
27 | {
28 |     return new Consumer();
29 | }
30 | 
31 | #[Param(consumer: 'Consumer<ClassTemplateContravariantAttributeChild>')]
32 | function someFunctionThatConsumes(Consumer $consumer): void
33 | {
34 |     $consumer->consume(new ClassTemplateContravariantAttributeChild());
35 | }
36 | 
37 | someFunctionThatConsumes(getClassTemplateContravariantAttributeConsumer());
38 | 


--------------------------------------------------------------------------------
/tests/data/TemplateContravariant/InterfaceTemplateContravariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateContravariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\TemplateContravariant;
 7 | 
 8 | #[TemplateContravariant('T')]
 9 | interface InterfaceTemplateContravariantAttribute
10 | {
11 |     #[Param(param: 'T')]
12 |     public function returnTemplateContravariant($param): void;
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/data/TemplateContravariant/InvalidClassTemplateContravariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateContravariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\TemplateContravariant;
 6 | 
 7 | #[TemplateContravariant(0)]
 8 | #[TemplateContravariant('+5')]
 9 | #[TemplateContravariant('T', 0)]
10 | class InvalidClassTemplateContravariantAttribute
11 | {
12 |     #[TemplateContravariant('T')]
13 |     public string $property;
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/data/TemplateContravariant/TraitTemplateContravariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateContravariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\TemplateContravariant;
 8 | 
 9 | #[TemplateContravariant('T')]
10 | trait TraitTemplateContravariantContravariantAttribute
11 | {
12 |     #[Param(param: 'T')]
13 |     #[Returns('T')]
14 |     public function returnTemplateContravariant($param)
15 |     {
16 |         return $param;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/data/TemplateCovariant/ClassTemplateCovariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateCovariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\TemplateCovariant;
 8 | 
 9 | class ClassTemplateCovariantAttribute
10 | {
11 | }
12 | class ClassTemplateCovariantAttributeChild extends ClassTemplateCovariantAttribute
13 | {
14 | }
15 | 
16 | #[TemplateCovariant('TCreable')] // can only be used in covariant position
17 | class Creator
18 | {
19 |     public function __construct(
20 |         private string $className
21 |     ) {
22 |     }
23 | 
24 |     #[Returns('TCreable')]
25 |     public function create()
26 |     {
27 |         /** @var TCreable $object */
28 |         $object = new $this->className();
29 |         return $object;
30 |     }
31 | }
32 | 
33 | #[Returns('Creator<ClassTemplateCovariantAttributeChild>')]
34 | function getClassTemplateCovariantAttributeCreator(): Creator
35 | {
36 |     return new Creator(ClassTemplateCovariantAttributeChild::class);
37 | }
38 | 
39 | #[Param(creator: 'Creator<ClassTemplateCovariantAttribute>')]
40 | function someFunctionThatCreates(Creator $creator): void
41 | {
42 |     $creator->create();
43 | }
44 | 
45 | someFunctionThatCreates(getClassTemplateCovariantAttributeCreator());
46 | 


--------------------------------------------------------------------------------
/tests/data/TemplateCovariant/InterfaceTemplateCovariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateCovariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Returns;
 6 | use PhpStaticAnalysis\Attributes\TemplateCovariant;
 7 | 
 8 | #[TemplateCovariant('T')]
 9 | interface InterfaceTemplateCovariantAttribute
10 | {
11 |     #[Returns('T')]
12 |     public function returnTemplateCovariant();
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/data/TemplateCovariant/InvalidClassTemplateCovariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateCovariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\TemplateCovariant;
 6 | 
 7 | #[TemplateCovariant(0)]
 8 | #[TemplateCovariant('+5')]
 9 | #[TemplateCovariant('T', 0)]
10 | class InvalidClassTemplateCovariantAttribute
11 | {
12 |     #[TemplateCovariant('T')]
13 |     public string $property;
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/data/TemplateCovariant/TraitTemplateCovariantAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateCovariant;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Param;
 6 | use PhpStaticAnalysis\Attributes\Returns;
 7 | use PhpStaticAnalysis\Attributes\TemplateCovariant;
 8 | 
 9 | #[TemplateCovariant('T')]
10 | trait TraitTemplateCovariantAttribute
11 | {
12 |     #[Param(param: 'T')]
13 |     #[Returns('T')]
14 |     public function returnTemplateCovariant($param)
15 |     {
16 |         return $param;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/data/TemplateExtends/ClassTemplateExtendsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateExtends;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Template;
 6 | use PhpStaticAnalysis\Attributes\TemplateExtends;
 7 | 
 8 | #[Template('T')]
 9 | class ClassTemplateExtendsAttribute
10 | {
11 | }
12 | 
13 | #[TemplateExtends('ClassTemplateExtendsAttribute<int>')] // this class extends the base template
14 | class ClassTemplateExtendsAttributeChild extends ClassTemplateExtendsAttribute
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/data/TemplateExtends/InvalidClassTemplateExtendsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateExtends;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Template;
 6 | use PhpStaticAnalysis\Attributes\TemplateExtends;
 7 | 
 8 | #[Template('T')]
 9 | class InvalidClassTemplateExtendsAttribute
10 | {
11 | }
12 | 
13 | #[TemplateExtends(0)]
14 | class InvalidClassTemplateExtendsAttributeChild extends InvalidClassTemplateExtendsAttribute
15 | {
16 | }
17 | 
18 | #[TemplateExtends('+5')]
19 | class InvalidClassTemplateExtendsAttributeChild2 extends InvalidClassTemplateExtendsAttribute
20 | {
21 | }
22 | 
23 | #[TemplateExtends('InvalidClassTemplateExtendsAttribute<int>')]
24 | #[TemplateExtends('InvalidClassTemplateExtendsAttribute<int>')]
25 | class InvalidClassTemplateExtendsAttributeChild3 extends InvalidClassTemplateExtendsAttribute
26 | {
27 |     #[TemplateExtends('InvalidClassTemplateExtendsAttribute<int>')]
28 |     public string $name = '';
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/data/TemplateImplements/InterfaceTemplateImplementsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateImplements;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Template;
 6 | use PhpStaticAnalysis\Attributes\TemplateImplements;
 7 | 
 8 | #[Template('T')]
 9 | interface InterfaceTemplateImplementsAttribute
10 | {
11 | }
12 | 
13 | #[Template('T')]
14 | interface InterfaceTemplateImplementsAttribute2
15 | {
16 | }
17 | 
18 | #[Template('T')]
19 | interface InterfaceTemplateImplementsAttribute3
20 | {
21 | }
22 | 
23 | #[TemplateImplements('InterfaceTemplateImplementsAttribute<int>')] // this class implements the base interface
24 | #[TemplateImplements(
25 |     'InterfaceTemplateImplementsAttribute2<int>',
26 |     'InterfaceTemplateImplementsAttribute3<int>'
27 | )]
28 | class ClassTemplateImplementsAttribute implements InterfaceTemplateImplementsAttribute, InterfaceTemplateImplementsAttribute2, InterfaceTemplateImplementsAttribute3
29 | {
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/data/TemplateImplements/InvalidInterfaceTemplateImplementsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateImplements;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Template;
 6 | use PhpStaticAnalysis\Attributes\TemplateImplements;
 7 | 
 8 | #[Template('T')]
 9 | interface InvalidInterfaceTemplateImplementsAttribute
10 | {
11 | }
12 | 
13 | #[TemplateImplements(0)]
14 | class InvalidClassTemplateImplementsAttribute implements InvalidInterfaceTemplateImplementsAttribute
15 | {
16 | }
17 | 
18 | #[TemplateImplements('+5')]
19 | class InvalidClassTemplateImplementsAttribute2 implements InvalidInterfaceTemplateImplementsAttribute
20 | {
21 |     #[TemplateImplements('InvalidInterfaceTemplateImplementsAttribute<int>')]
22 |     public string $name = '';
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/data/TemplateUse/InvalidTraitTemplateUseAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateUse;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Template;
 6 | use PhpStaticAnalysis\Attributes\TemplateUse;
 7 | 
 8 | #[Template('T')]
 9 | trait InvalidTraitTemplateUseAttribute
10 | {
11 | }
12 | 
13 | #[TemplateUse(0)]
14 | class InvalidClassTemplateUseAttribute
15 | {
16 |     use InvalidTraitTemplateUseAttribute;
17 | }
18 | 
19 | #[TemplateUse('+5')]
20 | class InvalidClassTemplateUseAttribute2
21 | {
22 |     use InvalidTraitTemplateUseAttribute;
23 | 
24 |     #[TemplateUse('InvalidTraitTemplateUseAttribute<int>')]
25 |     public string $name = '';
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/data/TemplateUse/TraitTemplateUseAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\TemplateUse;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Template;
 6 | use PhpStaticAnalysis\Attributes\TemplateUse;
 7 | 
 8 | #[Template('T')]
 9 | trait TraitTemplateUseAttribute
10 | {
11 | }
12 | 
13 | #[Template('T')]
14 | trait TraitTemplateUseAttribute2
15 | {
16 | }
17 | 
18 | #[Template('T')]
19 | trait TraitTemplateUseAttribute3
20 | {
21 | }
22 | 
23 | #[TemplateUse('TraitTemplateUseAttribute<int>')] // this class uses the base trait
24 | #[TemplateUse(
25 |     'TraitTemplateUseAttribute2<int>',
26 |     'TraitTemplateUseAttribute3<int>'
27 | )]
28 | class ClassTemplateUseAttribute
29 | {
30 |     use TraitTemplateUseAttribute;
31 |     use TraitTemplateUseAttribute2, TraitTemplateUseAttribute3;
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/data/Throws/FunctionThrowsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Throws;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Throws;
 7 | 
 8 | #[Throws(Exception::class)]
 9 | function countName(string $name): int
10 | {
11 |     if ($name == '') {
12 |         throw new Exception('Empty string!');
13 |     }
14 |     return strlen($name);
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/data/Throws/InvalidMethodThrowsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Throws;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Throws;
 7 | 
 8 | class InvalidMethodThrowsAttribute
 9 | {
10 |     #[Throws(0)]
11 |     public function getNameLength(string $name): int
12 |     {
13 |         return strlen($name);
14 |     }
15 | 
16 |     #[Throws('string')]
17 |     public function getOtherNameLength(string $name): int
18 |     {
19 |         return strlen($name);
20 |     }
21 | 
22 |     #[Throws(Exception::class)]
23 |     public string $property;
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/data/Throws/MethodThrowsAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Throws;
 4 | 
 5 | use Error;
 6 | use Exception;
 7 | use PhpStaticAnalysis\Attributes\Throws;
 8 | 
 9 | class MethodThrowsAttribute
10 | {
11 |     #[Throws(Exception::class)] // returns the number of names
12 |     public function countName(string $name): int
13 |     {
14 |         if ($name == '') {
15 |             throw new Exception('Empty string!');
16 |         }
17 |         return strlen($name);
18 |     }
19 | 
20 |     /**
21 |      * @deprecated
22 |      */
23 |     #[Throws(Exception::class)]
24 |     public function countMoreName(string $name): int
25 |     {
26 |         if ($name == '') {
27 |             throw new Exception('Empty string!');
28 |         }
29 |         return strlen($name);
30 |     }
31 | 
32 |     /**
33 |      * @throws Exception
34 |      */
35 |     #[Throws(Exception::class)]
36 |     public function countEvenMoreName(string $name): int
37 |     {
38 |         if ($name == '') {
39 |             throw new Exception('Empty string!');
40 |         }
41 |         return strlen($name);
42 |     }
43 | 
44 |     #[Throws(
45 |         Exception::class,
46 |         Error::class
47 |     )]
48 |     public function countTwoNames(string $name1, string $name2): int
49 |     {
50 |         if ($name1 == '') {
51 |             throw new Exception('Empty string!');
52 |         }
53 |         if ($name2 == '') {
54 |             throw new Error('Empty string!');
55 |         }
56 |         return strlen($name1 . $name2);
57 |     }
58 | 
59 |     #[Throws(Exception::class)]
60 |     #[Throws(Error::class)]
61 |     public function countOtherTwoNames(string $name1, string $name2): int
62 |     {
63 |         if ($name1 == '') {
64 |             throw new Exception('Empty string!');
65 |         }
66 |         if ($name2 == '') {
67 |             throw new Error('Empty string!');
68 |         }
69 |         return strlen($name1 . $name2);
70 |     }
71 | 
72 |     #[Throws(Exception::class)]
73 |     public function countNoErrorName(): void
74 |     {
75 |     }
76 | 
77 |     /**
78 |      * @throws Exception
79 |      */
80 |     public function countNameExtra(string $name): int
81 |     {
82 |         if ($name == '') {
83 |             throw new Exception('Empty string!');
84 |         }
85 |         return strlen($name);
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/tests/data/Type/InvalidPropertyTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Type;
 4 | 
 5 | use PhpStaticAnalysis\Attributes\Type;
 6 | 
 7 | class InvalidPropertyTypeAttribute
 8 | {
 9 |     #[Type(0)]
10 |     public string $invalidProperty;
11 | 
12 |     #[Type('string')]
13 |     #[Type('string')]
14 |     public string $otherInvalidProperty;
15 | 
16 |     #[Type('string', 'string')]
17 |     public string $anotherInvalidProperty;
18 | 
19 |     #[Type('$a + $b')]
20 |     public string $andAnotherinvalidProperty;
21 | 
22 |     public function getName(
23 |         #[Type('string')]
24 |         string $user
25 |     ): void {
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/data/Type/PropertyTypeAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace test\PhpStaticAnalysis\PHPStanExtension\data\Type;
 4 | 
 5 | use Exception;
 6 | use PhpStaticAnalysis\Attributes\Type;
 7 | 
 8 | #[Type('StringArray string[]')]
 9 | class PropertyTypeAttribute
10 | {
11 |     #[Type('string')]
12 |     public const ATTRIBUTE_NAME = 'Type';
13 | 
14 |     #[Type('int[]')] // number of items
15 |     public array $nums;
16 | 
17 |     #[Type(Exception::class)]
18 |     public $exception;
19 | 
20 |     /**
21 |      * @var string
22 |      */
23 |     public string $string;
24 | 
25 |     #[Type('string')]
26 |     public function getString(): string
27 |     {
28 |         return 'hello';
29 |     }
30 | }
31 | 


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