├── .github
    └── workflows
    │   ├── build.yml
    │   └── semantic.yml
├── LICENSE.txt
├── README.md
├── benchmarks
    ├── completion.php
    └── parsing.php
├── bin
    └── php-language-server.php
├── composer.json
├── extra_stubs
    └── enum.php
├── package-lock.json
├── src
    ├── Cache
    │   ├── Cache.php
    │   ├── ClientCache.php
    │   └── FileSystemCache.php
    ├── Client
    │   ├── TextDocument.php
    │   ├── Window.php
    │   ├── WorkDoneProgress.php
    │   ├── Workspace.php
    │   └── XCache.php
    ├── ClientHandler.php
    ├── CompletionProvider.php
    ├── ComposerScripts.php
    ├── ContentRetriever
    │   ├── ClientContentRetriever.php
    │   ├── ContentRetriever.php
    │   └── FileSystemContentRetriever.php
    ├── ContentTooLargeException.php
    ├── Definition.php
    ├── DefinitionResolver.php
    ├── Factory
    │   ├── CompletionItemFactory.php
    │   ├── LocationFactory.php
    │   ├── RangeFactory.php
    │   └── SymbolInformationFactory.php
    ├── FilesFinder
    │   ├── ClientFilesFinder.php
    │   ├── FileSystemFilesFinder.php
    │   └── FilesFinder.php
    ├── FqnUtilities.php
    ├── IdGenerator.php
    ├── Index
    │   ├── AbstractAggregateIndex.php
    │   ├── DependenciesIndex.php
    │   ├── GlobalIndex.php
    │   ├── Index.php
    │   ├── ProjectIndex.php
    │   ├── ReadableIndex.php
    │   └── StubsIndex.php
    ├── Indexer.php
    ├── LanguageClient.php
    ├── LanguageServer.php
    ├── Message.php
    ├── ParserHelpers.php
    ├── PhpDocument.php
    ├── PhpDocumentLoader.php
    ├── ProtocolReader.php
    ├── ProtocolStreamReader.php
    ├── ProtocolStreamWriter.php
    ├── ProtocolWriter.php
    ├── Server
    │   ├── TextDocument.php
    │   └── Workspace.php
    ├── SignatureHelpProvider.php
    ├── SignatureInformationFactory.php
    ├── StderrLogger.php
    ├── TreeAnalyzer.php
    └── utils.php
└── tests
    ├── ClientHandlerTest.php
    ├── DefinitionResolverTest.php
    ├── Diagnostics
        └── InvalidThisUsageTest.php
    ├── Index
        └── IndexTest.php
    ├── LanguageServerTest.php
    ├── MockPhpDocument.php
    ├── MockProtocolStream.php
    ├── NodeVisitor
        └── DefinitionCollectorTest.php
    ├── PhpDocumentLoaderTest.php
    ├── PhpDocumentTest.php
    ├── ProtocolStreamReaderTest.php
    ├── ProtocolStreamWriterTest.php
    ├── Server
        ├── ServerTestCase.php
        ├── TextDocument
        │   ├── CompletionTest.php
        │   ├── Definition
        │   │   ├── GlobalFallbackTest.php
        │   │   ├── GlobalTest.php
        │   │   └── NamespacedTest.php
        │   ├── DidChangeTest.php
        │   ├── DidCloseTest.php
        │   ├── DocumentSymbolTest.php
        │   ├── HoverTest.php
        │   ├── ParseErrorsTest.php
        │   ├── References
        │   │   ├── GlobalFallbackTest.php
        │   │   ├── GlobalTest.php
        │   │   └── NamespacedTest.php
        │   └── SignatureHelpTest.php
        └── Workspace
        │   ├── DidChangeWatchedFilesTest.php
        │   └── SymbolTest.php
    ├── Utils
        ├── FileUriTest.php
        └── StripStringOverlapTest.php
    └── Validation
        ├── ValidationTest.php
        ├── cases
            ├── WithReturnTypehints.php
            ├── WithReturnTypehints.php.expected.json
            ├── anonymousClassMembersShouldNotBeSymbols.php
            ├── anonymousClassMembersShouldNotBeSymbols.php.expected.json
            ├── arrayValueShouldBeBoolean.php
            ├── arrayValueShouldBeBoolean.php.expected.json
            ├── caseStatement1.php
            ├── caseStatement1.php.expected.json
            ├── circularVar.php
            ├── circularVar.php.expected.json
            ├── classDefinition1.php
            ├── classDefinition1.php.expected.json
            ├── classProperty1.php
            ├── classProperty1.php.expected.json
            ├── constants.php
            ├── constants.php.expected.json
            ├── constants2.php
            ├── constants2.php.expected.json
            ├── constants3.php
            ├── constants3.php.expected.json
            ├── constants4.php
            ├── constants4.php.expected.json
            ├── constants5.php
            ├── constants5.php.expected.json
            ├── constantsInFunctionParamDefault.php
            ├── constantsInFunctionParamDefault.php.expected.json
            ├── docBlocksOnNamespaceDefinition.php
            ├── docBlocksOnNamespaceDefinition.php.expected.json
            ├── exceptions1.php
            ├── exceptions1.php.expected.json
            ├── forLoopReference1.php
            ├── forLoopReference1.php.expected.json
            ├── functionParamInters.php
            ├── functionParamInters.php.expected.json
            ├── functionParamUnion.php
            ├── functionParamUnion.php.expected.json
            ├── functionReturnInters.php
            ├── functionReturnInters.php.expected.json
            ├── functionReturnUnion.php
            ├── functionReturnUnion.php.expected.json
            ├── functionUse.php
            ├── functionUse.php.expected.json
            ├── functionUse2.php
            ├── functionUse2.php.expected.json
            ├── ifStatement1.php
            ├── ifStatement1.php.expected.json
            ├── interfaceProperty.php
            ├── interfaceProperty.php.expected.json
            ├── magicConstantsShouldBeGlobal.php
            ├── magicConstantsShouldBeGlobal.php.expected.json
            ├── magicConsts.php
            ├── magicConsts.php.expected.json
            ├── memberAccess1.php
            ├── memberAccess1.php.expected.json
            ├── memberAccess2.php
            ├── memberAccess2.php.expected.json
            ├── memberAccess3.php
            ├── memberAccess3.php.expected.json
            ├── memberAccess4.php
            ├── memberAccess4.php.expected.json
            ├── memberAccess5.php
            ├── memberAccess5.php.expected.json
            ├── memberCall1.php
            ├── memberCall1.php.expected.json
            ├── methodReturnType.php
            ├── methodReturnType.php.expected.json
            ├── multipleNamespaces.php
            ├── multipleNamespaces.php.expected.json
            ├── multiplePreceedingComments.php
            ├── multiplePreceedingComments.php.expected.json
            ├── nameToken.php
            ├── nameToken.php.expected.json
            ├── namespaces2.php
            ├── namespaces2.php.expected.json
            ├── namespaces3.php
            ├── namespaces3.php.expected.json
            ├── namespaces4.php
            ├── namespaces4.php.expected.json
            ├── namespaces5.php
            ├── namespaces5.php.expected.json
            ├── namespaces6.php
            ├── namespaces6.php.expected.json
            ├── namespaces7.php
            ├── namespaces7.php.expected.json
            ├── namespaces8.php
            ├── namespaces8.php.expected.json
            ├── namespaces9.php
            ├── namespaces9.php.expected.json
            ├── newStatic.php
            ├── newStatic.php.expected.json
            ├── objectCreation.php
            ├── objectCreation.php.expected.json
            ├── objectCreation2.php
            ├── objectCreation2.php.expected.json
            ├── objectCreation3.php
            ├── objectCreation3.php.expected.json
            ├── param1.php
            ├── param1.php.expected.json
            ├── parameterTypeResolution1.php
            ├── parameterTypeResolution1.php.expected.json
            ├── parent1.php
            ├── parent1.php.expected.json
            ├── parent2.php
            ├── parent2.php.expected.json
            ├── parent3.php
            ├── parent3.php.expected.json
            ├── promotedConstructor.php
            ├── promotedConstructor.php.expected.json
            ├── propertyName1.php
            ├── propertyName1.php.expected.json
            ├── propertyName2.php
            ├── propertyName2.php.expected.json
            ├── returnType.php
            ├── returnType.php.expected.json
            ├── scopedPropertyAccess.php
            ├── scopedPropertyAccess.php.expected.json
            ├── scopedPropertyAccess2.php
            ├── scopedPropertyAccess2.php.expected.json
            ├── scopedPropertyAccess3.php
            ├── scopedPropertyAccess3.php.expected.json
            ├── scopedPropertyAccess4.php
            ├── scopedPropertyAccess4.php.expected.json
            ├── scopedPropertyAccess5.php
            ├── scopedPropertyAccess5.php.expected.json
            ├── self1.php
            ├── self1.php.expected.json
            ├── self2.php
            ├── self2.php.expected.json
            ├── self3.php
            ├── self3.php.expected.json
            ├── self4.php
            ├── self4.php.expected.json
            ├── self5.php
            ├── self5.php.expected.json
            ├── static1.php
            ├── static1.php.expected.json
            ├── static2.php
            ├── static2.php.expected.json
            ├── static3.php
            ├── static3.php.expected.json
            ├── static4.php
            ├── static4.php.expected.json
            ├── staticInArray.php
            ├── staticInArray.php.expected.json
            ├── staticMethodReturnType.php
            ├── staticMethodReturnType.php.expected.json
            ├── stringVariable.php
            ├── stringVariable.php.expected.json
            ├── testQualifiedNameOutsideOfNamespace.php
            ├── testQualifiedNameOutsideOfNamespace.php.expected.json
            ├── trait1.php
            ├── trait1.php.expected.json
            ├── trait2.php
            ├── trait2.php.expected.json
            ├── trait3.php
            ├── trait3.php.expected.json
            ├── trait4.php
            ├── trait4.php.expected.json
            ├── verifyFqsenOnClassProperty.php
            └── verifyFqsenOnClassProperty.php.expected.json
        ├── cases81
            ├── enum1.php
            ├── enum1.php.expected.json
            ├── enum2.php
            ├── enum2.php.expected.json
            ├── enum3.php
            └── enum3.php.expected.json
        ├── cases82
            ├── dnfTypes1.php
            └── dnfTypes1.php.expected.json
        └── disabled.json


/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: build
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | env:
 6 |   FORCE_COLOR: 3
 7 | 
 8 | jobs:
 9 |   test:
10 |     if: github.event_name == 'pull_request' || github.ref == 'refs/heads/main'
11 |     runs-on: ${{ matrix.os }}
12 |     strategy:
13 |       matrix:
14 |         include:
15 |           - xdebug: xdebug-3.1.1 # renovate:keep-up-to-date
16 |             php: '7.4'
17 |             os: ubuntu-22.04
18 |           - xdebug: xdebug-3.1.1 # renovate:keep-up-to-date
19 |             php: '8.1'
20 |             os: ubuntu-22.04
21 |     steps:
22 |       - uses: actions/checkout@v2
23 |       - name: Setup Node.js
24 |         uses: actions/setup-node@v2
25 |         with:
26 |           node-version: '14.15.3' # renovate:keep-up-to-date
27 |       - name: Install npm dependencies
28 |         run: npm ci
29 |       - name: Setup PHP
30 |         uses: shivammathur/setup-php@v2
31 |         with:
32 |           php-version: ${{ matrix.php }}
33 |           extensions: ${{ matrix.xdebug }}, ast
34 |           tools: composer
35 |       - name: Composer Install
36 |         run: composer install --ignore-platform-reqs
37 |       - name: phpcs
38 |         run: ./vendor/bin/phpcs -n
39 | #      - name: phan
40 | #        run: ./vendor/bin/phan
41 |       - name: phpunit
42 |         run: vendor/bin/phpunit --coverage-clover=coverage.xml --colors=always
43 |       - name: Upload coverage to Codecov
44 |         uses: codecov/codecov-action@v2
45 | #  release:
46 | #    runs-on: ubuntu-18.04
47 | #    needs: test
48 | #    if: github.repository_owner == 'xdebug' && github.event_name == 'push' && github.ref == 'refs/heads/main'
49 | #    steps:
50 | #      - uses: actions/checkout@v2
51 | #      - name: Setup Node.js
52 | #        uses: actions/setup-node@v2
53 | #        with:
54 | #          node-version: '14.15.3' # renovate:keep-up-to-date
55 | #      - name: Install npm dependencies
56 | #        run: npm ci
57 | #      - name: Build VS Code extension
58 | #        run: npm run build
59 | #      - name: Release
60 | #        env:
61 | #          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
62 | #          VSCE_TOKEN: ${{ secrets.VSCE_TOKEN }}
63 | #        run: npm run semantic-release
64 | 


--------------------------------------------------------------------------------
/.github/workflows/semantic.yml:
--------------------------------------------------------------------------------
 1 | name: 'Semantic Pull Request'
 2 | 
 3 | on:
 4 |   pull_request_target:
 5 |     types:
 6 |       - opened
 7 |       - edited
 8 |       - synchronize
 9 | #  pull_request:
10 | #    types:
11 | #      - opened
12 | #      - edited
13 | #      - synchronize
14 | 
15 | jobs:
16 |   main:
17 |     name: Validate PR Title
18 |     runs-on: ubuntu-latest
19 |     steps:
20 |       - name: semantic-pull-request
21 |         uses: amannn/action-semantic-pull-request@v4
22 |         env:
23 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
24 |         with:
25 |           validateSingleCommit: false
26 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | ISC License
 2 | 
 3 | Copyright (c) 2016, Felix Frederick Becker
 4 | 
 5 | Permission to use, copy, modify, and/or distribute this software for any
 6 | purpose with or without fee is hereby granted, provided that the above
 7 | copyright notice and this permission notice appear in all copies.
 8 | 
 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 | 


--------------------------------------------------------------------------------
/benchmarks/parsing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace LanguageServer\Tests;
 4 | require __DIR__ . '/../vendor/autoload.php';
 5 | 
 6 | use Composer\XdebugHandler\XdebugHandler;
 7 | use Exception;
 8 | use LanguageServer\DefinitionResolver;
 9 | use LanguageServer\Index\Index;
10 | use LanguageServer\PhpDocument;
11 | use LanguageServer\StderrLogger;
12 | use Microsoft\PhpParser;
13 | use phpDocumentor\Reflection\DocBlockFactory;
14 | use RecursiveDirectoryIterator;
15 | use RecursiveIteratorIterator;
16 | 
17 | $logger = new StderrLogger();
18 | $xdebugHandler = new XdebugHandler('PHPLS');
19 | $xdebugHandler->setLogger($logger);
20 | $xdebugHandler->check();
21 | unset($xdebugHandler);
22 | 
23 | $totalSize = 0;
24 | 
25 | $frameworks = ["drupal", "wordpress", "php-language-server", "tolerant-php-parser", "math-php", "symfony", "codeigniter", "cakephp"];
26 | 
27 | foreach($frameworks as $framework) {
28 |     $iterator = new RecursiveDirectoryIterator(__DIR__ . "/../validation/frameworks/$framework");
29 |     $testProviderArray = array();
30 | 
31 |     foreach (new RecursiveIteratorIterator($iterator) as $file) {
32 |         if (strpos((string)$file, ".php") !== false) {
33 |             $totalSize += $file->getSize();
34 |             $testProviderArray[] = $file->getPathname();
35 |         }
36 |     }
37 | 
38 |     if (count($testProviderArray) === 0) {
39 |         throw new Exception("ERROR: Validation testsuite frameworks not found - run `git submodule update --init --recursive` to download.");
40 |     }
41 | 
42 |     $start = microtime(true);
43 | 
44 |     foreach ($testProviderArray as $idx => $testCaseFile) {
45 |         if (filesize($testCaseFile) > 10000) {
46 |             continue;
47 |         }
48 |         if ($idx % 500 === 0) {
49 |             echo $idx . '/' . count($testProviderArray) . PHP_EOL;
50 |         }
51 | 
52 |         $fileContents = file_get_contents($testCaseFile);
53 | 
54 |         $docBlockFactory = DocBlockFactory::createInstance();
55 |         $index = new Index;
56 |         $maxRecursion = [];
57 |         $definitions = [];
58 | 
59 |         $definitionResolver = new DefinitionResolver($index);
60 |         $parser = new PhpParser\Parser();
61 | 
62 |         $document = new PhpDocument($testCaseFile, $fileContents, $index, $parser, $docBlockFactory, $definitionResolver);
63 |     }
64 | 
65 |     echo "------------------------------\n";
66 | 
67 |     echo "Time [$framework]: " . (microtime(true) - $start) . PHP_EOL;
68 | }
69 | 
70 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "felixfbecker/language-server",
 3 |     "description": "PHP Implementation of the Visual Studio Code Language Server Protocol",
 4 |     "license": "ISC",
 5 |     "keywords": [
 6 |         "php",
 7 |         "language",
 8 |         "server",
 9 |         "microsoft",
10 |         "visual",
11 |         "studio",
12 |         "code",
13 |         "intellisense",
14 |         "autocompletion",
15 |         "refactor"
16 |     ],
17 |     "authors": [
18 |         {
19 |             "name": "Felix Becker",
20 |             "email": "felix.b@outlook.com"
21 |         }
22 |     ],
23 |     "repositories": [
24 |         {
25 |             "type": "git",
26 |             "url": "https://github.com/zobo/php-language-server-protocol"
27 |         },
28 |         {
29 |             "type": "git",
30 |             "url": "https://github.com/microsoft/tolerant-php-parser.git"
31 |         }
32 |     ],
33 |     "require": {
34 |         "php": ">=7.4",
35 |         "composer/xdebug-handler": "^1.0",
36 |         "felixfbecker/advanced-json-rpc": "^3.0.0",
37 |         "felixfbecker/language-server-protocol": "dev-main",
38 |         "jetbrains/phpstorm-stubs": "dev-master",
39 |         "microsoft/tolerant-php-parser": "dev-main as 0.1.2",
40 |         "netresearch/jsonmapper": "^1.0",
41 |         "phpdocumentor/reflection-docblock": "^5.2.2",
42 |         "psr/log": "^1.0",
43 |         "sabre/event": "^5.0",
44 |         "sabre/uri": "^2.0",
45 |         "webmozart/glob": "^4.6",
46 |         "webmozart/path-util": "^2.3"
47 |     },
48 |     "require-dev": {
49 |         "phan/phan": "^5.2",
50 |         "phpstan/phpstan": "^1.9",
51 |         "phpunit/phpunit": "^9.0",
52 |         "squizlabs/php_codesniffer": "^3.6"
53 |     },
54 |     "autoload": {
55 |         "psr-4": {
56 |             "LanguageServer\\": "src/"
57 |         },
58 |         "files" : [
59 |             "src/utils.php",
60 |             "src/FqnUtilities.php",
61 |             "src/ParserHelpers.php"
62 |         ]
63 |     },
64 |     "autoload-dev": {
65 |         "psr-4": {
66 |             "LanguageServer\\Tests\\": "tests/"
67 |         }
68 |     },
69 |     "bin": [
70 |         "bin/php-language-server.php"
71 |     ],
72 |     "scripts": {
73 |         "parse-stubs": "LanguageServer\\ComposerScripts::parseStubs",
74 |         "post-install-cmd": "@parse-stubs",
75 |         "post-update-cmd": "@parse-stubs",
76 |         "test": "vendor/bin/phpunit",
77 |         "lint": "vendor/bin/phpcs"
78 |     },
79 |     "config": {
80 |         "sort-packages": true
81 |     },
82 |     "minimum-stability": "dev",
83 |     "prefer-stable": true
84 | }
85 | 


--------------------------------------------------------------------------------
/extra_stubs/enum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * @since 8.1
 5 |  */
 6 | abstract class UnitEnum
 7 | {
 8 |     public readonly string $name;
 9 | 
10 |     /**
11 |      * Generates a list of cases on an enum
12 |      * @return static[] An array of all defined cases of this enumeration, in lexical order.
13 |      */
14 |     #[Pure]
15 |     public static function cases(): array {}
16 | }
17 | 
18 | /**
19 |  * @since 8.1
20 |  */
21 | abstract class BackedEnum extends UnitEnum
22 | {
23 |     public readonly int|string $value;
24 | 
25 |     /**
26 |      * Maps a scalar to an enum instance
27 |      * @param int|string $value The scalar value to map to an enum case.
28 |      * @return static A case instance of this enumeration.
29 |      */
30 |     #[Pure]
31 |     public static function from(int|string $value): static {}
32 | 
33 |     /**
34 |      * Maps a scalar to an enum instance or null
35 |      * @param int|string $value The scalar value to map to an enum case.
36 |      * @return static|null A case instance of this enumeration, or null if not found.
37 |      */
38 |     #[Pure]
39 |     public static function tryFrom(int|string $value): ?static {}
40 | }
41 | 
42 | /**
43 |  * @since 8.1
44 |  * @internal
45 |  *
46 |  * Internal interface to ensure precise type inference
47 |  */
48 | abstract class IntBackedEnum extends UnitEnum
49 | {
50 |     public readonly int $value;
51 | 
52 |     /**
53 |      * Maps a scalar to an enum instance
54 |      * @param int $value The scalar value to map to an enum case.
55 |      * @return static A case instance of this enumeration.
56 |      */
57 |     #[Pure]
58 |     public static function from(int $value): static {}
59 | 
60 |     /**
61 |      * Maps a scalar to an enum instance or null
62 |      * @param int $value The scalar value to map to an enum case.
63 |      * @return static|null A case instance of this enumeration, or null if not found.
64 |      */
65 |     #[Pure]
66 |     public static function tryFrom(int $value): ?static {}
67 | }
68 | 
69 | /**
70 |  * @since 8.1
71 |  * @internal
72 |  *
73 |  * Internal interface to ensure precise type inference
74 |  */
75 | abstract class StringBackedEnum extends UnitEnum
76 | {
77 |     public readonly string $value;
78 | 
79 |     /**
80 |      * Maps a scalar to an enum instance
81 |      * @param string $value The scalar value to map to an enum case.
82 |      * @return static A case instance of this enumeration.
83 |      */
84 |     #[Pure]
85 |     public static function from(string $value): static {}
86 | 
87 |     /**
88 |      * Maps a scalar to an enum instance or null
89 |      * @param string $value The scalar value to map to an enum case.
90 |      * @return static|null A case instance of this enumeration, or null if not found.
91 |      */
92 |     #[Pure]
93 |     public static function tryFrom(string $value): ?static {}
94 | }
95 | 


--------------------------------------------------------------------------------
/src/Cache/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Cache;
 5 | 
 6 | use Sabre\Event\Promise;
 7 | 
 8 | /**
 9 |  * A key/value store for caching purposes
10 |  */
11 | interface Cache
12 | {
13 |     /**
14 |      * Gets a value from the cache
15 |      *
16 |      * @param string $key
17 |      * @return Promise <mixed>
18 |      */
19 |     public function get(string $key): Promise;
20 | 
21 |     /**
22 |      * Sets a value in the cache
23 |      *
24 |      * @param string $key
25 |      * @param mixed  $value
26 |      * @return Promise
27 |      */
28 |     public function set(string $key, $value): Promise;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Cache/ClientCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Cache;
 5 | 
 6 | use LanguageServer\LanguageClient;
 7 | use Sabre\Event\Promise;
 8 | 
 9 | /**
10 |  * Caches content through a xcache/* requests
11 |  */
12 | class ClientCache implements Cache
13 | {
14 |     /**
15 |      * @var LanguageClient
16 |      */
17 |     public $client;
18 | 
19 |     /**
20 |      * @param LanguageClient $client
21 |      */
22 |     public function __construct(LanguageClient $client)
23 |     {
24 |         $this->client = $client;
25 |     }
26 | 
27 |     /**
28 |      * Gets a value from the cache
29 |      *
30 |      * @param string $key
31 |      * @return Promise <mixed>
32 |      */
33 |     public function get(string $key): Promise
34 |     {
35 |         return $this->client->xcache->get($key)->then('unserialize')->otherwise(function () {
36 |             // Ignore
37 |         });
38 |     }
39 | 
40 |     /**
41 |      * Sets a value in the cache
42 |      *
43 |      * @param string $key
44 |      * @param mixed  $value
45 |      * @return Promise
46 |      */
47 |     public function set(string $key, $value): Promise
48 |     {
49 |         return $this->client->xcache->set($key, serialize($value))->otherwise(function () {
50 |             // Ignore
51 |         });
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Cache/FileSystemCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Cache;
 5 | 
 6 | use Sabre\Event\Promise;
 7 | 
 8 | /**
 9 |  * Caches content on the file system
10 |  */
11 | class FileSystemCache implements Cache
12 | {
13 |     /**
14 |      * @var string
15 |      */
16 |     public $cacheDir;
17 | 
18 |     public function __construct()
19 |     {
20 |         if (strtoupper(substr(php_uname('s'), 0, 3)) === 'WIN') {
21 |             $this->cacheDir = getenv('LOCALAPPDATA') . '\\PHP Language Server\\';
22 |         } else if (getenv('XDG_CACHE_HOME')) {
23 |             $this->cacheDir = getenv('XDG_CACHE_HOME') . '/phpls/';
24 |         } else {
25 |             $this->cacheDir = getenv('HOME') . '/.phpls/';
26 |         }
27 |     }
28 | 
29 |     /**
30 |      * Gets a value from the cache
31 |      *
32 |      * @param string $key
33 |      * @return Promise <mixed>
34 |      */
35 |     public function get(string $key): Promise
36 |     {
37 |         try {
38 |             $file = $this->cacheDir . urlencode($key);
39 |             if (!file_exists($file)) {
40 |                 return Promise\resolve(null);
41 |             }
42 |             return Promise\resolve(unserialize(file_get_contents($file)));
43 |         } catch (\Exception $e) {
44 |             return Promise\resolve(null);
45 |         }
46 |     }
47 | 
48 |     /**
49 |      * Sets a value in the cache
50 |      *
51 |      * @param string $key
52 |      * @param mixed  $value
53 |      * @return Promise
54 |      */
55 |     public function set(string $key, $value): Promise
56 |     {
57 |         try {
58 |             $file = $this->cacheDir . urlencode($key);
59 |             if (!file_exists($this->cacheDir)) {
60 |                 mkdir($this->cacheDir);
61 |             }
62 |             file_put_contents($file, serialize($value));
63 |         } finally {
64 |             return Promise\resolve(null);
65 |         }
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Client/TextDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Client;
 5 | 
 6 | use LanguageServer\ClientHandler;
 7 | use LanguageServerProtocol\{Diagnostic, TextDocumentItem, TextDocumentIdentifier};
 8 | use Sabre\Event\Promise;
 9 | use JsonMapper;
10 | 
11 | /**
12 |  * Provides method handlers for all textDocument/* methods
13 |  */
14 | class TextDocument
15 | {
16 |     /**
17 |      * @var ClientHandler
18 |      */
19 |     private $handler;
20 | 
21 |     /**
22 |      * @var JsonMapper
23 |      */
24 |     private $mapper;
25 | 
26 |     public function __construct(ClientHandler $handler, JsonMapper $mapper)
27 |     {
28 |         $this->handler = $handler;
29 |         $this->mapper = $mapper;
30 |     }
31 | 
32 |     /**
33 |      * Diagnostics notification are sent from the server to the client to signal results of validation runs.
34 |      *
35 |      * @param string $uri
36 |      * @param Diagnostic[] $diagnostics
37 |      * @return Promise <void>
38 |      */
39 |     public function publishDiagnostics(string $uri, array $diagnostics): Promise
40 |     {
41 |         return $this->handler->notify('textDocument/publishDiagnostics', [
42 |             'uri' => $uri,
43 |             'diagnostics' => $diagnostics
44 |         ]);
45 |     }
46 | 
47 |     /**
48 |      * The content request is sent from a server to a client
49 |      * to request the current content of a text document identified by the URI
50 |      *
51 |      * @param TextDocumentIdentifier $textDocument The document to get the content for
52 |      * @return Promise <TextDocumentItem> The document's current content
53 |      */
54 |     public function xcontent(TextDocumentIdentifier $textDocument): Promise
55 |     {
56 |         return $this->handler->request(
57 |             'textDocument/xcontent',
58 |             ['textDocument' => $textDocument]
59 |         )->then(function ($result) {
60 |             return $this->mapper->map($result, new TextDocumentItem);
61 |         });
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Client/Window.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Client;
 5 | 
 6 | use LanguageServer\ClientHandler;
 7 | use Sabre\Event\Promise;
 8 | 
 9 | /**
10 |  * Provides method handlers for all window/* methods
11 |  */
12 | class Window
13 | {
14 |     /**
15 |      * @var ClientHandler
16 |      */
17 |     private $handler;
18 | 
19 |     public function __construct(ClientHandler $handler)
20 |     {
21 |         $this->handler = $handler;
22 |     }
23 | 
24 |     /**
25 |      * The show message notification is sent from a server to a client
26 |      * to ask the client to display a particular message in the user interface.
27 |      *
28 |      * @param int $type
29 |      * @param string $message
30 |      * @return Promise <void>
31 |      */
32 |     public function showMessage(int $type, string $message): Promise
33 |     {
34 |         return $this->handler->notify('window/showMessage', ['type' => $type, 'message' => $message]);
35 |     }
36 | 
37 |     /**
38 |      * The log message notification is sent from the server to the client to ask the client to log a particular message.
39 |      *
40 |      * @param int $type
41 |      * @param string $message
42 |      * @return Promise <void>
43 |      */
44 |     public function logMessage(int $type, string $message): Promise
45 |     {
46 |         return $this->handler->notify('window/logMessage', ['type' => $type, 'message' => $message]);
47 |     }
48 | 
49 |     /**
50 |      * https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#window_workDoneProgress_create
51 |      *
52 |      * @return Promise <WorkDoneProgress>
53 |      */
54 |     public function createWorkDoneProgress(): Promise
55 |     {
56 |         $token = uniqid("pls-");
57 | 
58 |         return $this->handler->request(
59 |             'window/workDoneProgress/create',
60 |             ['token' => $token]
61 |         )->then(function ($result) use ($token) {
62 |             // check result??
63 |             return new WorkDoneProgress($this->handler, $token);
64 |         })->otherwise(function () {
65 |             return null;
66 |         });
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Client/WorkDoneProgress.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Client;
 5 | 
 6 | use LanguageServer\ClientHandler;
 7 | use Sabre\Event\Promise;
 8 | 
 9 | class WorkDoneProgress
10 | {
11 |     /**
12 |      * @var ClientHandler
13 |      */
14 |     private $handler;
15 | 
16 |     /**
17 |      * ProgressToken
18 |      *
19 |      * @var string
20 |      */
21 |     private $token;
22 | 
23 |     public function __construct(ClientHandler $handler, string $token)
24 |     {
25 |         $this->handler = $handler;
26 |         $this->token = $token;
27 |     }
28 | 
29 |     public function beginProgress(string $title, string $message = null, int $percentage = null): Promise
30 |     {
31 |         return $this->handler->notify(
32 |             '$/progress',
33 |             [
34 |                 'token' => $this->token,
35 |                 'value' => [
36 |                     'kind' => 'begin',
37 |                     'title' => $title,
38 |                     // 'cancellable'
39 |                     'message' => $message,
40 |                     'percentage' => $percentage,
41 |                 ]
42 |             ]
43 |         );
44 |     }
45 | 
46 |     public function reportProgress(string $message = null, int $percentage = null): Promise
47 |     {
48 |         return $this->handler->notify(
49 |             '$/progress',
50 |             [
51 |                 'token' => $this->token,
52 |                 'value' => [
53 |                     'kind' => 'report',
54 |                     // 'cancellable'
55 |                     'message' => $message,
56 |                     'percentage' => $percentage,
57 |                 ]
58 |             ]
59 |         );
60 |     }
61 | 
62 |     public function endProgress(string $message = null): Promise
63 |     {
64 |         return $this->handler->notify(
65 |             '$/progress',
66 |             [
67 |                 'token' => $this->token,
68 |                 'value' => [
69 |                     'kind' => 'end',
70 |                     'message' => $message,
71 |                 ]
72 |             ]
73 |         );
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/Client/Workspace.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Client;
 5 | 
 6 | use LanguageServer\ClientHandler;
 7 | use LanguageServerProtocol\TextDocumentIdentifier;
 8 | use Sabre\Event\Promise;
 9 | use JsonMapper;
10 | 
11 | /**
12 |  * Provides method handlers for all workspace/* methods
13 |  */
14 | class Workspace
15 | {
16 |     /**
17 |      * @var ClientHandler
18 |      */
19 |     private $handler;
20 | 
21 |     /**
22 |      * @var JsonMapper
23 |      */
24 |     private $mapper;
25 | 
26 |     public function __construct(ClientHandler $handler, JsonMapper $mapper)
27 |     {
28 |         $this->handler = $handler;
29 |         $this->mapper = $mapper;
30 |     }
31 | 
32 |     /**
33 |      * Returns a list of all files in a directory
34 |      *
35 |      * @param string $base The base directory (defaults to the workspace)
36 |      * @return Promise <TextDocumentIdentifier[]> Array of documents
37 |      */
38 |     public function xfiles(string $base = null): Promise
39 |     {
40 |         return $this->handler->request(
41 |             'workspace/xfiles',
42 |             ['base' => $base]
43 |         )->then(function (array $textDocuments) {
44 |             return $this->mapper->mapArray($textDocuments, [], TextDocumentIdentifier::class);
45 |         });
46 |     }
47 | 
48 |     /**
49 |      * The workspace/configuration request is sent from the server to the client
50 |      * to fetch configuration settings from the client. The request can fetch
51 |      * several configuration settings in one roundtrip. The order of the
52 |      * returned configuration settings correspond to the order of the passed
53 |      * ConfigurationItems (e.g. the first item in the response is the result
54 |      * for the first configuration item in the params).
55 |      *
56 |      * @param  array{'section': string}[] $items Array of configuration items
57 |      * @return Promise <\stdClass[]> Array of configuration objects
58 |      */
59 |     public function configuration(array $items): Promise
60 |     {
61 |         return $this->handler->request(
62 |             'workspace/configuration',
63 |             ['items' => $items]
64 |         )->then(function (array $items) {
65 |             return $items;
66 |             //return $this->mapper->mapArray($items, [], ConfigurationItem::class);
67 |         });
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Client/XCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Client;
 5 | 
 6 | use LanguageServer\ClientHandler;
 7 | use Sabre\Event\Promise;
 8 | 
 9 | /**
10 |  * Provides method handlers for all xcache/* methods
11 |  */
12 | class XCache
13 | {
14 |     /**
15 |      * @var ClientHandler
16 |      */
17 |     private $handler;
18 | 
19 |     public function __construct(ClientHandler $handler)
20 |     {
21 |         $this->handler = $handler;
22 |     }
23 | 
24 |     /**
25 |      * @param string $key
26 |      * @return Promise <mixed>
27 |      */
28 |     public function get(string $key): Promise
29 |     {
30 |         return $this->handler->request('xcache/get', ['key' => $key]);
31 |     }
32 | 
33 |     /**
34 |      * @param string $key
35 |      * @param mixed  $value
36 |      * @return Promise <mixed>
37 |      */
38 |     public function set(string $key, $value): Promise
39 |     {
40 |         return $this->handler->notify('xcache/set', ['key' => $key, 'value' => $value]);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/ClientHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use AdvancedJsonRpc;
 7 | use Sabre\Event\Promise;
 8 | 
 9 | class ClientHandler
10 | {
11 |     /**
12 |      * @var ProtocolReader
13 |      */
14 |     public $protocolReader;
15 | 
16 |     /**
17 |      * @var ProtocolWriter
18 |      */
19 |     public $protocolWriter;
20 | 
21 |     /**
22 |      * @var IdGenerator
23 |      */
24 |     public $idGenerator;
25 | 
26 |     public function __construct(ProtocolReader $protocolReader, ProtocolWriter $protocolWriter)
27 |     {
28 |         $this->protocolReader = $protocolReader;
29 |         $this->protocolWriter = $protocolWriter;
30 |         $this->idGenerator = new IdGenerator;
31 |     }
32 | 
33 |     /**
34 |      * Sends a request to the client and returns a promise that is resolved with the result or rejected with the error
35 |      *
36 |      * @param string $method The method to call
37 |      * @param array|object $params The method parameters
38 |      * @return Promise <mixed> Resolved with the result of the request or rejected with an error
39 |      */
40 |     public function request(string $method, $params): Promise
41 |     {
42 |         $id = $this->idGenerator->generate();
43 |         return $this->protocolWriter->write(
44 |             new Message(
45 |                 new AdvancedJsonRpc\Request($id, $method, (object)$params)
46 |             )
47 |         )->then(function () use ($id) {
48 |             $promise = new Promise;
49 |             $listener = function (Message $msg) use ($id, $promise, &$listener) {
50 |                 if (AdvancedJsonRpc\Response::isResponse($msg->body) && $msg->body->id === $id) {
51 |                     // Received a response
52 |                     $this->protocolReader->removeListener('message', $listener);
53 |                     if (AdvancedJsonRpc\SuccessResponse::isSuccessResponse($msg->body)) {
54 |                         $promise->fulfill($msg->body->result);
55 |                     } else {
56 |                         $promise->reject($msg->body->error);
57 |                     }
58 |                 }
59 |             };
60 |             $this->protocolReader->on('message', $listener);
61 |             return $promise;
62 |         });
63 |     }
64 | 
65 |     /**
66 |      * Sends a notification to the client
67 |      *
68 |      * @param string $method The method to call
69 |      * @param array|object $params The method parameters
70 |      * @return Promise <null> Will be resolved as soon as the notification has been sent
71 |      */
72 |     public function notify(string $method, $params): Promise
73 |     {
74 |         return $this->protocolWriter->write(
75 |             new Message(
76 |                 new AdvancedJsonRpc\Notification($method, (object)$params)
77 |             )
78 |         );
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/ComposerScripts.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use LanguageServer\FilesFinder\FileSystemFilesFinder;
 7 | use LanguageServer\ContentRetriever\FileSystemContentRetriever;
 8 | use LanguageServer\Index\StubsIndex;
 9 | use phpDocumentor\Reflection\DocBlockFactory;
10 | use Webmozart\PathUtil\Path;
11 | use Sabre\Uri;
12 | use function Sabre\Event\coroutine;
13 | use Microsoft\PhpParser;
14 | 
15 | foreach ([__DIR__ . '/../../../autoload.php', __DIR__ . '/../autoload.php', __DIR__ . '/../vendor/autoload.php'] as $file) {
16 |     if (file_exists($file)) {
17 |         require $file;
18 |         break;
19 |     }
20 | }
21 | 
22 | class ComposerScripts
23 | {
24 |     public static function parseStubs()
25 |     {
26 |         coroutine(function () {
27 | 
28 |             $index = new StubsIndex;
29 | 
30 |             $finder = new FileSystemFilesFinder;
31 |             $contentRetriever = new FileSystemContentRetriever;
32 |             $docBlockFactory = DocBlockFactory::createInstance();
33 |             $parser = new PhpParser\Parser();
34 |             $definitionResolver = new DefinitionResolver($index);
35 | 
36 |             $stubsLocation = null;
37 |             foreach ([__DIR__ . '/../../../jetbrains/phpstorm-stubs', __DIR__ . '/../vendor/jetbrains/phpstorm-stubs'] as $dir) {
38 |                 if (file_exists($dir)) {
39 |                     $stubsLocation = Path::canonicalize($dir);
40 |                     break;
41 |                 }
42 |             }
43 |             if (!$stubsLocation) {
44 |                 throw new \Exception('jetbrains/phpstorm-stubs package not found');
45 |             }
46 | 
47 |             $uris = yield $finder->find("$stubsLocation/**/*.php");
48 | 
49 |             $uris = array_merge($uris, yield $finder->find(__DIR__ . '/../extra_stubs/*.php'));
50 | 
51 |             foreach ($uris as $uri) {
52 |                 echo "Parsing $uri\n";
53 |                 $content = yield $contentRetriever->retrieve($uri);
54 | 
55 |                 // Change URI to phpstubs://
56 |                 $parts = Uri\parse($uri);
57 |                 $parts['path'] = Path::makeRelative(uriToPath($uri), $stubsLocation);
58 |                 $parts['scheme'] = 'phpstubs';
59 |                 $uri = Uri\build($parts);
60 | 
61 |                 // Create a new document and add it to $index
62 |                 new PhpDocument($uri, $content, $index, $parser, $docBlockFactory, $definitionResolver);
63 |             }
64 | 
65 |             $index->setComplete();
66 | 
67 |             echo "Saving Index\n";
68 | 
69 |             $index->save();
70 | 
71 |             echo "Finished\n";
72 |         })->wait();
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/ContentRetriever/ClientContentRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\ContentRetriever;
 5 | 
 6 | use LanguageServer\LanguageClient;
 7 | use LanguageServerProtocol\{TextDocumentIdentifier, TextDocumentItem};
 8 | use Sabre\Event\Promise;
 9 | 
10 | /**
11 |  * Retrieves file content from the client through a textDocument/xcontent request
12 |  */
13 | class ClientContentRetriever implements ContentRetriever
14 | {
15 |     private LanguageClient $client;
16 |     
17 |     /**
18 |      * @param LanguageClient $client
19 |      */
20 |     public function __construct(LanguageClient $client)
21 |     {
22 |         $this->client = $client;
23 |     }
24 | 
25 |     /**
26 |      * Retrieves the content of a text document identified by the URI through a textDocument/xcontent request
27 |      *
28 |      * @param string $uri The URI of the document
29 |      * @return Promise <string> Resolved with the content as a string
30 |      */
31 |     public function retrieve(string $uri): Promise
32 |     {
33 |         return $this->client->textDocument->xcontent(new TextDocumentIdentifier($uri))
34 |             ->then(function (TextDocumentItem $textDocument) {
35 |                 return $textDocument->text;
36 |             });
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/ContentRetriever/ContentRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\ContentRetriever;
 5 | 
 6 | use Sabre\Event\Promise;
 7 | 
 8 | /**
 9 |  * Interface for retrieving the content of a text document
10 |  */
11 | interface ContentRetriever
12 | {
13 |     /**
14 |      * Retrieves the content of a text document identified by the URI
15 |      *
16 |      * @param string $uri The URI of the document
17 |      * @return Promise <string> Resolved with the content as a string
18 |      */
19 |     public function retrieve(string $uri): Promise;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/ContentRetriever/FileSystemContentRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\ContentRetriever;
 5 | 
 6 | use Sabre\Event\Promise;
 7 | use function LanguageServer\uriToPath;
 8 | 
 9 | /**
10 |  * Retrieves document content from the file system
11 |  */
12 | class FileSystemContentRetriever implements ContentRetriever
13 | {
14 |     /**
15 |      * Retrieves the content of a text document identified by the URI from the file system
16 |      *
17 |      * @param string $uri The URI of the document
18 |      * @return Promise <string> Resolved with the content as a string
19 |      */
20 |     public function retrieve(string $uri): Promise
21 |     {
22 |         return Promise\resolve(file_get_contents(uriToPath($uri)));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/ContentTooLargeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | /**
 7 |  * Thrown when the document content is not parsed because it exceeds the size limit
 8 |  */
 9 | class ContentTooLargeException extends \Exception
10 | {
11 |     /**
12 |      * The URI of the file that exceeded the limit
13 |      *
14 |      * @var string
15 |      */
16 |     public $uri;
17 | 
18 |     /**
19 |      * The size of the file in bytes
20 |      *
21 |      * @var int
22 |      */
23 |     public $size;
24 | 
25 |     /**
26 |      * The limit that was exceeded in bytes
27 |      *
28 |      * @var int
29 |      */
30 |     public $limit;
31 | 
32 |     /**
33 |      * @param string     $uri      The URI of the file that exceeded the limit
34 |      * @param int        $size     The size of the file in bytes
35 |      * @param int        $limit    The limit that was exceeded in bytes
36 |      * @param \Throwable $previous The previous exception used for the exception chaining.
37 |      */
38 |     public function __construct(string $uri, int $size, int $limit, \Throwable $previous = null)
39 |     {
40 |         $this->uri = $uri;
41 |         $this->size = $size;
42 |         $this->limit = $limit;
43 |         parent::__construct("$uri exceeds size limit of $limit bytes ($size)", 0, $previous);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Factory/CompletionItemFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace LanguageServer\Factory;
 4 | 
 5 | use LanguageServer\Definition;
 6 | use LanguageServerProtocol\CompletionItem;
 7 | use LanguageServerProtocol\CompletionItemKind;
 8 | use LanguageServerProtocol\SymbolKind;
 9 | 
10 | class CompletionItemFactory
11 | {
12 |     /**
13 |      * Creates a CompletionItem for a Definition
14 |      *
15 |      * @param Definition $def
16 |      * @return CompletionItem|null
17 |      */
18 |     public static function fromDefinition(Definition $def)
19 |     {
20 |         $item = new CompletionItem;
21 |         $item->label = $def->symbolInformation->name;
22 |         $item->kind = CompletionItemKind::fromSymbolKind($def->symbolInformation->kind);
23 |         if ($def->type) {
24 |             $item->detail = (string)$def->type;
25 |         } else if ($def->symbolInformation->containerName) {
26 |             $item->detail = $def->symbolInformation->containerName;
27 |         }
28 |         if ($def->documentation) {
29 |             $item->documentation = $def->documentation;
30 |         }
31 |         if ($def->isStatic && $def->symbolInformation->kind === SymbolKind::PROPERTY) {
32 |             $item->insertText = '$' . $def->symbolInformation->name;
33 |         }
34 |         return $item;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Factory/LocationFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace LanguageServer\Factory;
 4 | 
 5 | use LanguageServerProtocol\Location;
 6 | use LanguageServerProtocol\Position;
 7 | use LanguageServerProtocol\Range;
 8 | use Microsoft\PhpParser\Node;
 9 | use Microsoft\PhpParser\PositionUtilities;
10 | 
11 | class LocationFactory
12 | {
13 |     /**
14 |      * Returns the location of the node
15 |      *
16 |      * @param Node $node
17 |      * @return Location
18 |      */
19 |     public static function fromNode(Node $node): Location
20 |     {
21 |         $range = PositionUtilities::getRangeFromPosition(
22 |             $node->getStartPosition(),
23 |             $node->getWidth(),
24 |             $node->getFileContents()
25 |         );
26 | 
27 |         return new Location($node->getUri(), new Range(
28 |             new Position($range->start->line, $range->start->character),
29 |             new Position($range->end->line, $range->end->character)
30 |         ));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Factory/RangeFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace LanguageServer\Factory;
 4 | 
 5 | use LanguageServerProtocol\Position;
 6 | use LanguageServerProtocol\Range;
 7 | use Microsoft\PhpParser\Node;
 8 | use Microsoft\PhpParser\PositionUtilities;
 9 | 
10 | class RangeFactory
11 | {
12 |     /**
13 |      * Returns the range the node spans
14 |      *
15 |      * @param Node $node
16 |      * @return self
17 |      */
18 |     public static function fromNode(Node $node)
19 |     {
20 |         $range = PositionUtilities::getRangeFromPosition(
21 |             $node->getStartPosition(),
22 |             $node->getWidth(),
23 |             $node->getFileContents()
24 |         );
25 | 
26 |         return new Range(
27 |             new Position($range->start->line, $range->start->character),
28 |             new Position($range->end->line, $range->end->character)
29 |         );
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/FilesFinder/ClientFilesFinder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\FilesFinder;
 5 | 
 6 | use LanguageServer\LanguageClient;
 7 | use Sabre\Event\Promise;
 8 | use Webmozart\Glob\Glob;
 9 | use Webmozart\PathUtil\Path;
10 | use function LanguageServer\uriToPath;
11 | 
12 | /**
13 |  * Retrieves file content from the client through a textDocument/xcontent request
14 |  */
15 | class ClientFilesFinder implements FilesFinder
16 | {
17 |     /**
18 |      * @var LanguageClient
19 |      */
20 |     private $client;
21 | 
22 |     /**
23 |      * @param LanguageClient $client
24 |      */
25 |     public function __construct(LanguageClient $client)
26 |     {
27 |         $this->client = $client;
28 |     }
29 | 
30 |     /**
31 |      * Returns all files in the workspace that match a glob.
32 |      * If the client does not support workspace/files, it falls back to searching the file system directly.
33 |      *
34 |      * @param string $glob
35 |      * @return Promise <string[]> The URIs
36 |      */
37 |     public function find(string $glob): Promise
38 |     {
39 |         return $this->client->workspace->xfiles()->then(function (array $textDocuments) use ($glob) {
40 |             $uris = [];
41 |             foreach ($textDocuments as $textDocument) {
42 |                 $path = Path::normalize(uriToPath($textDocument->uri));
43 |                 if (Glob::match($path, $glob)) {
44 |                     $uris[] = $textDocument->uri;
45 |                 }
46 |             }
47 |             return $uris;
48 |         });
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/FilesFinder/FileSystemFilesFinder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\FilesFinder;
 5 | 
 6 | use Webmozart\Glob\Iterator\GlobIterator;
 7 | use Sabre\Event\Promise;
 8 | use function Sabre\Event\coroutine;
 9 | use function LanguageServer\{pathToUri, timeout};
10 | 
11 | class FileSystemFilesFinder implements FilesFinder
12 | {
13 |     /**
14 |      * Returns all files in the workspace that match a glob.
15 |      * If the client does not support workspace/xfiles, it falls back to searching the file system directly.
16 |      *
17 |      * @param string $glob
18 |      * @return Promise <string[]>
19 |      */
20 |     public function find(string $glob): Promise
21 |     {
22 |         return coroutine(function () use ($glob) {
23 |             $uris = [];
24 |             foreach (new GlobIterator($glob, 0, true) as $path) {
25 |                 // Exclude any directories that also match the glob pattern
26 |                 if (!is_dir($path)) {
27 |                     $uris[] = pathToUri($path);
28 |                 }
29 | 
30 |                 yield timeout();
31 |             }
32 |             return $uris;
33 |         });
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/FilesFinder/FilesFinder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\FilesFinder;
 5 | 
 6 | use Sabre\Event\Promise;
 7 | 
 8 | /**
 9 |  * Interface for finding files in the workspace
10 |  */
11 | interface FilesFinder
12 | {
13 |     /**
14 |      * Returns all files in the workspace that match a glob.
15 |      * If the client does not support workspace/xfiles, it falls back to searching the file system directly.
16 |      *
17 |      * @param string $glob
18 |      * @return Promise <string[]>
19 |      */
20 |     public function find(string $glob): Promise;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/IdGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | /**
 7 |  * Generates unique, incremental IDs for use as request IDs
 8 |  */
 9 | class IdGenerator
10 | {
11 |     /**
12 |      * @var int
13 |      */
14 |     public $counter = 1;
15 | 
16 |     /**
17 |      * Returns a unique ID
18 |      *
19 |      * @return int
20 |      */
21 |     public function generate()
22 |     {
23 |         return $this->counter++;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Index/DependenciesIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Index;
 5 | 
 6 | class DependenciesIndex extends AbstractAggregateIndex
 7 | {
 8 |     /**
 9 |      * Map from package name to index
10 |      *
11 |      * @var Index[]
12 |      */
13 |     protected $indexes = [];
14 | 
15 |     /**
16 |      * @return Index[]
17 |      */
18 |     protected function getIndexes(): array
19 |     {
20 |         return $this->indexes;
21 |     }
22 | 
23 |     /**
24 |      * @param string $packageName
25 |      * @return Index
26 |      */
27 |     public function getDependencyIndex(string $packageName): Index
28 |     {
29 |         if (!isset($this->indexes[$packageName])) {
30 |             $index = new Index;
31 |             $this->indexes[$packageName] = $index;
32 |             $this->registerIndex($index);
33 |         }
34 |         return $this->indexes[$packageName];
35 |     }
36 | 
37 |     /**
38 |      * @param string $packageName
39 |      * @param Index  $index
40 |      * @return void
41 |      */
42 |     public function setDependencyIndex(string $packageName, Index $index)
43 |     {
44 |         $this->indexes[$packageName] = $index;
45 |         $this->registerIndex($index);
46 |     }
47 | 
48 |     /**
49 |      * @param string $packageName
50 |      * @return void
51 |      */
52 |     public function removeDependencyIndex(string $packageName)
53 |     {
54 |         unset($this->indexes[$packageName]);
55 |     }
56 | 
57 |     /**
58 |      * @param string $packageName
59 |      * @return bool
60 |      */
61 |     public function hasDependencyIndex(string $packageName): bool
62 |     {
63 |         return isset($this->indexes[$packageName]);
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Index/GlobalIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Index;
 5 | 
 6 | /**
 7 |  * Aggregates definitions of the project and stubs
 8 |  */
 9 | class GlobalIndex extends AbstractAggregateIndex
10 | {
11 |     /**
12 |      * @var Index
13 |      */
14 |     private $stubsIndex;
15 | 
16 |     /**
17 |      * @var ProjectIndex
18 |      */
19 |     private $projectIndex;
20 | 
21 |     /**
22 |      * @param StubsIndex   $stubsIndex
23 |      * @param ProjectIndex $projectIndex
24 |      */
25 |     public function __construct(StubsIndex $stubsIndex, ProjectIndex $projectIndex)
26 |     {
27 |         $this->stubsIndex = $stubsIndex;
28 |         $this->projectIndex = $projectIndex;
29 |         parent::__construct();
30 |     }
31 | 
32 |     /**
33 |      * @return ReadableIndex[]
34 |      */
35 |     protected function getIndexes(): array
36 |     {
37 |         return [$this->stubsIndex, $this->projectIndex];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Index/ProjectIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Index;
 5 | 
 6 | use function LanguageServer\getPackageName;
 7 | 
 8 | /**
 9 |  * A project index manages the source and dependency indexes
10 |  */
11 | class ProjectIndex extends AbstractAggregateIndex
12 | {
13 |     /**
14 |      * The index for dependencies
15 |      *
16 |      * @var DependenciesIndex
17 |      */
18 |     private $dependenciesIndex;
19 | 
20 |     /**
21 |      * The Index for the project source
22 |      *
23 |      * @var Index
24 |      */
25 |     private $sourceIndex;
26 | 
27 |     private ?\stdClass $composerJson;
28 | 
29 |     public function __construct(Index $sourceIndex, DependenciesIndex $dependenciesIndex, \stdClass $composerJson = null)
30 |     {
31 |         $this->sourceIndex = $sourceIndex;
32 |         $this->dependenciesIndex = $dependenciesIndex;
33 |         $this->composerJson = $composerJson;
34 |         parent::__construct();
35 |     }
36 | 
37 |     /**
38 |      * @return ReadableIndex[]
39 |      */
40 |     protected function getIndexes(): array
41 |     {
42 |         return [$this->sourceIndex, $this->dependenciesIndex];
43 |     }
44 | 
45 |     /**
46 |      * @param string $uri
47 |      * @return Index
48 |      */
49 |     public function getIndexForUri(string $uri): Index
50 |     {
51 |         $packageName = getPackageName($uri, $this->composerJson);
52 |         if ($packageName) {
53 |             return $this->dependenciesIndex->getDependencyIndex($packageName);
54 |         }
55 |         return $this->sourceIndex;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Index/ReadableIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Index;
 5 | 
 6 | use LanguageServer\Definition;
 7 | use Sabre\Event\EmitterInterface;
 8 | 
 9 | /**
10 |  * The ReadableIndex interface provides methods to lookup definitions and references
11 |  *
12 |  * @event definition-added Emitted when a definition was added
13 |  * @event static-complete  Emitted when definitions and static references are complete
14 |  * @event complete         Emitted when the index is complete
15 |  */
16 | interface ReadableIndex extends EmitterInterface
17 | {
18 |     /**
19 |      * Returns true if this index is complete
20 |      *
21 |      * @return bool
22 |      */
23 |     public function isComplete(): bool;
24 | 
25 |     /**
26 |      * Returns true if definitions and static references are complete
27 |      *
28 |      * @return bool
29 |      */
30 |     public function isStaticComplete(): bool;
31 | 
32 |     /**
33 |      * Returns a Generator providing an associative array [string => Definition]
34 |      * that maps fully qualified symbol names to Definitions (global or not)
35 |      *
36 |      * @return \Generator yields Definition
37 |      */
38 |     public function getDefinitions(): \Generator;
39 | 
40 |     /**
41 |      * Returns a Generator that yields all the direct child Definitions of a given FQN
42 |      *
43 |      * @param string $fqn
44 |      * @return \Generator yields Definition
45 |      */
46 |     public function getChildDefinitionsForFqn(string $fqn): \Generator;
47 | 
48 |     /**
49 |      * Returns the Definition object by a specific FQN
50 |      *
51 |      * @param string $fqn
52 |      * @param bool $globalFallback Whether to fallback to global if the namespaced FQN was not found
53 |      * @return Definition|null
54 |      */
55 |     public function getDefinition(string $fqn, bool $globalFallback = false);
56 | 
57 |     /**
58 |      * Returns a Generator that yields all URIs in this index that reference a symbol
59 |      *
60 |      * @param string $fqn The fully qualified name of the symbol
61 |      * @return \Generator yields string
62 |      */
63 |     public function getReferenceUris(string $fqn): \Generator;
64 | }
65 | 


--------------------------------------------------------------------------------
/src/Index/StubsIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Index;
 5 | 
 6 | class StubsIndex extends Index
 7 | {
 8 |     /**
 9 |      * Reads the serialized StubsIndex from disk
10 |      *
11 |      * @return self
12 |      */
13 |     public static function read()
14 |     {
15 |         return unserialize(file_get_contents(__DIR__ . '/../../stubs'));
16 |     }
17 | 
18 |     /**
19 |      * Serializes and saves the StubsIndex
20 |      *
21 |      * @return void
22 |      */
23 |     public function save()
24 |     {
25 |         file_put_contents(__DIR__ . '/../../stubs', serialize($this));
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/LanguageClient.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use JsonMapper;
 7 | 
 8 | class LanguageClient
 9 | {
10 |     /**
11 |      * Handles textDocument/* methods
12 |      *
13 |      * @var Client\TextDocument
14 |      */
15 |     public $textDocument;
16 | 
17 |     /**
18 |      * Handles window/* methods
19 |      *
20 |      * @var Client\Window
21 |      */
22 |     public $window;
23 | 
24 |     /**
25 |      * Handles workspace/* methods
26 |      *
27 |      * @var Client\Workspace
28 |      */
29 |     public $workspace;
30 | 
31 |     /**
32 |      * Handles xcache/* methods
33 |      *
34 |      * @var Client\XCache
35 |      */
36 |     public $xcache;
37 | 
38 |     public function __construct(ProtocolReader $reader, ProtocolWriter $writer)
39 |     {
40 |         $handler = new ClientHandler($reader, $writer);
41 |         $mapper = new JsonMapper;
42 | 
43 |         $this->textDocument = new Client\TextDocument($handler, $mapper);
44 |         $this->window = new Client\Window($handler);
45 |         $this->workspace = new Client\Workspace($handler, $mapper);
46 |         $this->xcache = new Client\XCache($handler);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Message.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use AdvancedJsonRpc\Message as MessageBody;
 7 | use LanguageServer\Message;
 8 | 
 9 | class Message
10 | {
11 |     /**
12 |      * @var \AdvancedJsonRpc\Message
13 |      */
14 |     public $body;
15 | 
16 |     /**
17 |      * @var string[]
18 |      */
19 |     public $headers;
20 | 
21 |     /**
22 |      * Parses a message
23 |      *
24 |      * @param string $msg
25 |      * @return Message
26 |      */
27 |     public static function parse(string $msg): Message
28 |     {
29 |         $obj = new self;
30 |         $parts = explode("\r\n", $msg);
31 |         $obj->body = MessageBody::parse(array_pop($parts));
32 |         foreach ($parts as $line) {
33 |             if ($line) {
34 |                 $pair = explode(': ', $line);
35 |                 $obj->headers[$pair[0]] = $pair[1];
36 |             }
37 |         }
38 |         return $obj;
39 |     }
40 | 
41 |     /**
42 |      * @param \AdvancedJsonRpc\Message $body
43 |      * @param string[] $headers
44 |      */
45 |     public function __construct(MessageBody $body = null, array $headers = [])
46 |     {
47 |         $this->body = $body;
48 |         if (!isset($headers['Content-Type'])) {
49 |             $headers['Content-Type'] = 'application/vscode-jsonrpc; charset=utf8';
50 |         }
51 |         $this->headers = $headers;
52 |     }
53 | 
54 |     public function __toString(): string
55 |     {
56 |         $body = (string)$this->body;
57 |         $contentLength = strlen($body);
58 |         $this->headers['Content-Length'] = $contentLength;
59 |         $headers = '';
60 |         foreach ($this->headers as $name => $value) {
61 |             $headers .= "$name: $value\r\n";
62 |         }
63 |         return $headers . "\r\n" . $body;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/ProtocolReader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use Sabre\Event\EmitterInterface;
 7 | 
 8 | /**
 9 |  * Must emit a "message" event with a Protocol\Message object as parameter
10 |  * when a message comes in
11 |  *
12 |  * Must emit a "close" event when the stream closes
13 |  */
14 | interface ProtocolReader extends EmitterInterface
15 | {
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/src/ProtocolStreamReader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use LanguageServer\Message;
 7 | use AdvancedJsonRpc\Message as MessageBody;
 8 | use Sabre\Event\{Loop, Emitter};
 9 | 
10 | class ProtocolStreamReader extends Emitter implements ProtocolReader
11 | {
12 |     const PARSE_HEADERS = 1;
13 |     const PARSE_BODY = 2;
14 | 
15 |     private $input;
16 |     private $parsingMode = self::PARSE_HEADERS;
17 |     private $buffer = '';
18 |     private $headers = [];
19 |     private $contentLength;
20 | 
21 |     /**
22 |      * @param resource $input
23 |      */
24 |     public function __construct($input)
25 |     {
26 |         $this->input = $input;
27 | 
28 |         $this->on('close', function () {
29 |             Loop\removeReadStream($this->input);
30 |         });
31 | 
32 |         Loop\addReadStream($this->input, function () {
33 |             if (feof($this->input)) {
34 |                 // If stream_select reported a status change for this stream,
35 |                 // but the stream is EOF, it means it was closed.
36 |                 $this->emit('close');
37 |                 return;
38 |             }
39 |             while (($c = fgetc($this->input)) !== false && $c !== '') {
40 |                 $this->buffer .= $c;
41 |                 switch ($this->parsingMode) {
42 |                     case self::PARSE_HEADERS:
43 |                         if ($this->buffer === "\r\n") {
44 |                             $this->parsingMode = self::PARSE_BODY;
45 |                             $this->contentLength = (int)$this->headers['Content-Length'];
46 |                             $this->buffer = '';
47 |                         } else if (substr($this->buffer, -2) === "\r\n") {
48 |                             $parts = explode(':', $this->buffer);
49 |                             $this->headers[$parts[0]] = trim($parts[1]);
50 |                             $this->buffer = '';
51 |                         }
52 |                         break;
53 |                     case self::PARSE_BODY:
54 |                         if (strlen($this->buffer) === $this->contentLength) {
55 |                             $msg = new Message(MessageBody::parse($this->buffer), $this->headers);
56 |                             $this->emit('message', [$msg]);
57 |                             $this->parsingMode = self::PARSE_HEADERS;
58 |                             $this->headers = [];
59 |                             $this->buffer = '';
60 |                         }
61 |                         break;
62 |                 }
63 |             }
64 |         });
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/ProtocolStreamWriter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use LanguageServer\Message;
 7 | use Sabre\Event\{
 8 |     Loop,
 9 |     Promise
10 | };
11 | 
12 | class ProtocolStreamWriter implements ProtocolWriter
13 | {
14 |     /**
15 |      * @var resource $output
16 |      */
17 |     private $output;
18 | 
19 |     /**
20 |      * @var array $messages
21 |      */
22 |     private $messages = [];
23 | 
24 |     /**
25 |      * @param resource $output
26 |      */
27 |     public function __construct($output)
28 |     {
29 |         $this->output = $output;
30 |     }
31 | 
32 |     /**
33 |      * {@inheritdoc}
34 |      */
35 |     public function write(Message $msg): Promise
36 |     {
37 |         // if the message queue is currently empty, register a write handler.
38 |         if (empty($this->messages)) {
39 |             Loop\addWriteStream($this->output, function () {
40 |                 $this->flush();
41 |             });
42 |         }
43 | 
44 |         $promise = new Promise();
45 |         $this->messages[] = [
46 |             'message' => (string)$msg,
47 |             'promise' => $promise
48 |         ];
49 |         return $promise;
50 |     }
51 | 
52 |     /**
53 |      * Writes pending messages to the output stream.
54 |      *
55 |      * @return void
56 |      */
57 |     private function flush()
58 |     {
59 |         $keepWriting = true;
60 |         while ($keepWriting) {
61 |             $message = $this->messages[0]['message'];
62 |             $promise = $this->messages[0]['promise'];
63 | 
64 |             $bytesWritten = @fwrite($this->output, $message);
65 | 
66 |             if ($bytesWritten > 0) {
67 |                 $message = substr($message, $bytesWritten);
68 |             }
69 | 
70 |             // Determine if this message was completely sent
71 |             if (strlen($message) === 0) {
72 |                 array_shift($this->messages);
73 | 
74 |                 // This was the last message in the queue, remove the write handler.
75 |                 if (count($this->messages) === 0) {
76 |                     Loop\removeWriteStream($this->output);
77 |                     $keepWriting = false;
78 |                 }
79 | 
80 |                 $promise->fulfill();
81 |             } else {
82 |                 $this->messages[0]['message'] = $message;
83 |                 $keepWriting = false;
84 |             }
85 |         }
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/ProtocolWriter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | use LanguageServer\Message;
 7 | use Sabre\Event\Promise;
 8 | 
 9 | interface ProtocolWriter
10 | {
11 |     /**
12 |      * Sends a Message to the client
13 |      *
14 |      * @param Message $msg
15 |      * @return Promise Resolved when the message has been fully written out to the output stream
16 |      */
17 |     public function write(Message $msg): Promise;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/StderrLogger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer;
 5 | 
 6 | /**
 7 |  * Simple Logger that logs to STDERR
 8 |  */
 9 | class StderrLogger extends \Psr\Log\AbstractLogger implements \Psr\Log\LoggerInterface
10 | {
11 |     /**
12 |      * Logs with an arbitrary level.
13 |      *
14 |      * @param mixed  $level
15 |      * @param string $message
16 |      * @param array  $context
17 |      *
18 |      * @return void
19 |      */
20 |     public function log($level, $message, array $context = array())
21 |     {
22 |         $contextStr = empty($context) ? '' : ' ' . \json_encode($context, \JSON_UNESCAPED_SLASHES);
23 |         \fwrite(\STDERR, \str_pad(\strtoupper((string)$level), 10) . $message . $contextStr . \PHP_EOL);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/ClientHandlerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use LanguageServer\ClientHandler;
 8 | use LanguageServer\Message;
 9 | use AdvancedJsonRpc;
10 | use Sabre\Event\Loop;
11 | 
12 | class ClientHandlerTest extends TestCase
13 | {
14 |     public function testRequest()
15 |     {
16 |         $reader = new MockProtocolStream;
17 |         $writer = new MockProtocolStream;
18 |         $handler = new ClientHandler($reader, $writer);
19 |         $writer->once('message', function (Message $msg) use ($reader) {
20 |             // Respond to request
21 |             Loop\setTimeout(function () use ($reader, $msg) {
22 |                 $reader->write(new Message(new AdvancedJsonRpc\SuccessResponse($msg->body->id, 'pong')));
23 |             }, 0);
24 |         });
25 |         $handler->request('testMethod', ['ping'])->then(function ($result) {
26 |             $this->assertEquals('pong', $result);
27 |         })->wait();
28 |         // No event listeners
29 |         $this->assertEquals([], $reader->listeners('message'));
30 |         $this->assertEquals([], $writer->listeners('message'));
31 |     }
32 | 
33 |     public function testNotify()
34 |     {
35 |         $reader = new MockProtocolStream;
36 |         $writer = new MockProtocolStream;
37 |         $handler = new ClientHandler($reader, $writer);
38 |         $handler->notify('testMethod', ['ping'])->wait();
39 |         // No event listeners
40 |         $this->assertEquals([], $reader->listeners('message'));
41 |         $this->assertEquals([], $writer->listeners('message'));
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/DefinitionResolverTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use LanguageServer\Index\Index;
 8 | use LanguageServer\DefinitionResolver;
 9 | use Microsoft\PhpParser;
10 | 
11 | class DefinitionResolverTest extends TestCase
12 | {
13 |     public function testCreateDefinitionFromNode()
14 |     {
15 |         $parser = new PhpParser\Parser;
16 |         $doc = new MockPhpDocument;
17 |         $sourceFileNode = $parser->parseSourceFile("<?php\ndefine('TEST_DEFINE', true);", $doc->getUri());
18 | 
19 |         $index = new Index;
20 |         $definitionResolver = new DefinitionResolver($index);
21 |         $def = $definitionResolver->createDefinitionFromNode($sourceFileNode->statementList[1]->expression, '\TEST_DEFINE');
22 | 
23 |         $this->assertInstanceOf(\phpDocumentor\Reflection\Types\Boolean::class, $def->type);
24 |     }
25 | 
26 |     public function testGetTypeFromNode()
27 |     {
28 |         $parser = new PhpParser\Parser;
29 |         $doc = new MockPhpDocument;
30 |         $sourceFileNode = $parser->parseSourceFile("<?php\ndefine('TEST_DEFINE', true);", $doc->getUri());
31 | 
32 |         $index = new Index;
33 |         $definitionResolver = new DefinitionResolver($index);
34 |         $type = $definitionResolver->getTypeFromNode($sourceFileNode->statementList[1]->expression);
35 | 
36 |         $this->assertInstanceOf(\phpDocumentor\Reflection\Types\Boolean::class, $type);
37 |     }
38 | 
39 |     public function testGetDefinedFqnForIncompleteDefine()
40 |     {
41 |         // define('XXX') (only one argument) must not introduce a new symbol
42 |         $parser = new PhpParser\Parser;
43 |         $doc = new MockPhpDocument;
44 |         $sourceFileNode = $parser->parseSourceFile("<?php\ndefine('TEST_DEFINE');", $doc->getUri());
45 | 
46 |         $index = new Index;
47 |         $definitionResolver = new DefinitionResolver($index);
48 |         $fqn = $definitionResolver->getDefinedFqn($sourceFileNode->statementList[1]->expression);
49 | 
50 |         $this->assertNull($fqn);
51 |     }
52 | 
53 |     public function testGetDefinedFqnForDefine()
54 |     {
55 |         $parser = new PhpParser\Parser;
56 |         $doc = new MockPhpDocument;
57 |         $sourceFileNode = $parser->parseSourceFile("<?php\ndefine('TEST_DEFINE', true);", $doc->getUri());
58 | 
59 |         $index = new Index;
60 |         $definitionResolver = new DefinitionResolver($index);
61 |         $fqn = $definitionResolver->getDefinedFqn($sourceFileNode->statementList[1]->expression);
62 | 
63 |         $this->assertEquals('TEST_DEFINE', $fqn);
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/tests/Diagnostics/InvalidThisUsageTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Diagnostics;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use phpDocumentor\Reflection\DocBlockFactory;
 8 | use LanguageServer\{
 9 |     DefinitionResolver, TreeAnalyzer
10 | };
11 | use LanguageServer\Index\{Index};
12 | use LanguageServerProtocol\{
13 |     Diagnostic, DiagnosticSeverity, Position, Range
14 | };
15 | use function LanguageServer\pathToUri;
16 | use Microsoft\PhpParser\Parser;
17 | 
18 | class InvalidThisUsageTest extends TestCase
19 | {
20 |     /**
21 |      * Parse the given file and return diagnostics.
22 |      *
23 |      * @param string $path
24 |      * @return Diagnostic[]
25 |      */
26 |     private function collectDiagnostics(string $path): array
27 |     {
28 |         $uri = pathToUri($path);
29 |         $parser = new Parser();
30 | 
31 |         $docBlockFactory = DocBlockFactory::createInstance();
32 |         $index = new Index;
33 |         $definitionResolver = new DefinitionResolver($index);
34 |         $content = file_get_contents($path);
35 | 
36 |         $treeAnalyzer = new TreeAnalyzer($parser, $content, $docBlockFactory, $definitionResolver, $uri);
37 |         return $treeAnalyzer->getDiagnostics();
38 |     }
39 | 
40 |     /**
41 |      * Assertions about a diagnostic.
42 |      *
43 |      * @param Diagnostic|null $diagnostic
44 |      * @param int $message
45 |      * @param string $severity
46 |      * @param Range $range
47 |      */
48 |     private function assertDiagnostic($diagnostic, $message, $severity, $range)
49 |     {
50 |         $this->assertInstanceOf(Diagnostic::class, $diagnostic);
51 |         $this->assertEquals($message, $diagnostic->message);
52 |         $this->assertEquals($severity, $diagnostic->severity);
53 |         $this->assertEquals($range, $diagnostic->range);
54 |     }
55 | 
56 |     public function testThisInStaticMethodProducesError()
57 |     {
58 |         $diagnostics = $this->collectDiagnostics(
59 |             __DIR__ . '/../../fixtures/diagnostics/errors/this_in_static_method.php'
60 |         );
61 | 
62 |         $this->assertCount(1, $diagnostics);
63 |         $this->assertDiagnostic(
64 |             $diagnostics[0],
65 |             '$this can not be used in static methods.',
66 |             DiagnosticSeverity::ERROR,
67 |             new Range(
68 |                 new Position(6, 15),
69 |                 new Position(6, 20)
70 |             )
71 |         );
72 |     }
73 | 
74 |     public function testThisInMethodProducesNoError()
75 |     {
76 |         $diagnostics = $this->collectDiagnostics(
77 |             __DIR__ . '/../../fixtures/diagnostics/baselines/this_in_method.php'
78 |         );
79 | 
80 |         $this->assertCount(0, $diagnostics);
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/tests/Index/IndexTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace LanguageServer\Tests;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use LanguageServer\Index\Index;
 7 | use LanguageServer\Definition;
 8 | 
 9 | class IndexTest extends TestCase
10 | {
11 |     public function testGetSetMethodDefinition()
12 |     {
13 |         $index = new Index;
14 |         $index->setDefinition('SomeNamespace\SomeClass', new Definition);
15 |         $methodDefinition = new Definition;
16 |         $methodFqn = 'SomeNamespace\SomeClass->someMethod()';
17 |         $index->setDefinition($methodFqn, $methodDefinition);
18 |         $index->setDefinition('SomeNamespace\SomeClass->someProperty', new Definition);
19 |         $this->assertSame($methodDefinition, $index->getDefinition($methodFqn));
20 |     }
21 | 
22 |     public function testGetSetClassDefinition()
23 |     {
24 |         $index = new Index;
25 |         $definition = new Definition;
26 |         $fqn = 'SomeNamespace\SomeClass';
27 |         $index->setDefinition($fqn, $definition);
28 |         $this->assertSame($definition, $index->getDefinition($fqn));
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/MockPhpDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests;
 5 | 
 6 | /**
 7 |  * A fake document for tests
 8 |  */
 9 | class MockPhpDocument
10 | {
11 |     /**
12 |      * Returns fake uri
13 |      *
14 |      * @return string
15 |      */
16 |     public function getUri()
17 |     {
18 |         return 'file:///whatever';
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/MockProtocolStream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests;
 5 | 
 6 | use LanguageServer\{ProtocolReader, ProtocolWriter};
 7 | use LanguageServer\Message;
 8 | use Sabre\Event\{Loop, Emitter, Promise};
 9 | 
10 | /**
11 |  * A fake duplex protocol stream
12 |  */
13 | class MockProtocolStream extends Emitter implements ProtocolReader, ProtocolWriter
14 | {
15 |     /**
16 |      * Sends a Message to the client
17 |      *
18 |      * @param Message $msg
19 |      * @return void
20 |      */
21 |     public function write(Message $msg): Promise
22 |     {
23 |         Loop\nextTick(function () use ($msg) {
24 |             $this->emit('message', [Message::parse((string)$msg)]);
25 |         });
26 |         return Promise\resolve(null);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/PhpDocumentLoaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server;
 5 | 
 6 | use LanguageServer\{
 7 |     PhpDocument, PhpDocumentLoader, Project, DefinitionResolver
 8 | };
 9 | use LanguageServer\ContentRetriever\FileSystemContentRetriever;
10 | use LanguageServer\Index\{
11 |     DependenciesIndex, Index, ProjectIndex
12 | };
13 | use PHPUnit\Framework\TestCase;
14 | use function LanguageServer\pathToUri;
15 | 
16 | class PhpDocumentLoaderTest extends TestCase
17 | {
18 |     /**
19 |      * @var PhpDocumentLoader
20 |      */
21 |     private $loader;
22 | 
23 |     public function setUp(): void
24 |     {
25 |         $projectIndex = new ProjectIndex(new Index, new DependenciesIndex);
26 |         $this->loader = new PhpDocumentLoader(
27 |             new FileSystemContentRetriever,
28 |             $projectIndex,
29 |             new DefinitionResolver($projectIndex)
30 |         );
31 |     }
32 | 
33 |     public function testGetOrLoadLoadsDocument()
34 |     {
35 |         $document = $this->loader->getOrLoad(pathToUri(__FILE__))->wait();
36 | 
37 |         $this->assertNotNull($document);
38 |         $this->assertInstanceOf(PhpDocument::class, $document);
39 |     }
40 | 
41 |     public function testGetReturnsOpenedInstance()
42 |     {
43 |         $document1 = $this->loader->open(pathToUri(__FILE__), file_get_contents(__FILE__));
44 |         $document2 = $this->loader->get(pathToUri(__FILE__));
45 | 
46 |         $this->assertSame($document1, $document2);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/PhpDocumentTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server;
 5 | 
 6 | use LanguageServer\{
 7 |     PhpDocument, DefinitionResolver
 8 | };
 9 | use LanguageServer\Index\{
10 |     Index
11 | };
12 | use LanguageServerProtocol\{
13 |     Position
14 | };
15 | use Microsoft\PhpParser;
16 | use Microsoft\PhpParser\Node;
17 | use phpDocumentor\Reflection\DocBlockFactory;
18 | use PHPUnit\Framework\TestCase;
19 | use function LanguageServer\isVendored;
20 | 
21 | class PhpDocumentTest extends TestCase
22 | {
23 |     public function createDocument(string $uri, string $content)
24 |     {
25 |         $parser = new PhpParser\Parser();
26 |         $docBlockFactory = DocBlockFactory::createInstance();
27 |         $index = new Index;
28 |         $definitionResolver = new DefinitionResolver($index);
29 |         return new PhpDocument($uri, $content, $index, $parser, $docBlockFactory, $definitionResolver);
30 |     }
31 | 
32 |     public function testParsesVariableVariables()
33 |     {
34 |         $document = $this->createDocument('whatever', "<?php\n$\$a = 'foo';\n\$bar = 'baz';\n");
35 | 
36 |         $this->assertEquals([], $document->getDefinitions());
37 |     }
38 | 
39 |     public function testGetNodeAtPosition()
40 |     {
41 |         $document = $this->createDocument('whatever', "<?php\n$\$a = new SomeClass;");
42 |         $node = $document->getNodeAtPosition(new Position(1, 13));
43 |         $this->assertQualifiedName($node);
44 |         $this->assertEquals('SomeClass', (string)$node);
45 |     }
46 | 
47 |     private function assertQualifiedName($node)
48 |     {
49 |         $this->assertInstanceOf(Node\QualifiedName::class, $node);
50 |     }
51 | 
52 |     public function testIsVendored()
53 |     {
54 |         $document = $this->createDocument('file:///dir/vendor/x.php', "<?php\n$\$a = new SomeClass;");
55 |         $this->assertEquals(true, isVendored($document));
56 | 
57 |         $document = $this->createDocument('file:///c:/dir/vendor/x.php', "<?php\n$\$a = new SomeClass;");
58 |         $this->assertEquals(true, isVendored($document));
59 | 
60 |         $document = $this->createDocument('file:///vendor/x.php', "<?php\n$\$a = new SomeClass;");
61 |         $this->assertEquals(true, isVendored($document));
62 | 
63 |         $document = $this->createDocument('file:///dir/vendor.php', "<?php\n$\$a = new SomeClass;");
64 |         $this->assertEquals(false, isVendored($document));
65 | 
66 |         $document = $this->createDocument('file:///dir/x.php', "<?php\n$\$a = new SomeClass;");
67 |         $this->assertEquals(false, isVendored($document));
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/tests/ProtocolStreamReaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use LanguageServer\{LanguageServer, ProtocolStreamReader, ProtocolStreamWriter};
 8 | use LanguageServer\Message;
 9 | use AdvancedJsonRpc\{Request as RequestBody, Response as ResponseBody};
10 | use Sabre\Event\Loop;
11 | 
12 | class ProtocolStreamReaderTest extends TestCase
13 | {
14 |     public function testParsingWorksAndListenerIsCalled()
15 |     {
16 |         $tmpfile = tempnam('', '');
17 |         $writeHandle = fopen($tmpfile, 'w');
18 |         $reader = new ProtocolStreamReader(fopen($tmpfile, 'r'));
19 |         $msg = null;
20 |         $reader->on('message', function (Message $message) use (&$msg) {
21 |             $msg = $message;
22 |         });
23 |         $ret = fwrite($writeHandle, (string)new Message(new RequestBody(1, 'aMethod', ['arg' => 'Hello World'])));
24 |         Loop\tick();
25 |         $this->assertNotNull($msg);
26 |         $this->assertInstanceOf(Message::class, $msg);
27 |         $this->assertInstanceOf(RequestBody::class, $msg->body);
28 |         $this->assertEquals(1, $msg->body->id);
29 |         $this->assertEquals('aMethod', $msg->body->method);
30 |         $this->assertEquals((object)['arg' => 'Hello World'], $msg->body->params);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/ProtocolStreamWriterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use LanguageServer\ProtocolStreamWriter;
 8 | use LanguageServer\Message;
 9 | use AdvancedJsonRpc\{Request as RequestBody};
10 | use Sabre\Event\Loop;
11 | 
12 | class ProtocolStreamWriterTest extends TestCase
13 | {
14 |     public function testLargeMessageIsSent()
15 |     {
16 |         $tmpfile = tempnam('', '');
17 |         $writeHandle = fopen($tmpfile, 'w');
18 | 
19 |         stream_set_blocking($writeHandle, false);
20 | 
21 |         $writer = new ProtocolStreamWriter($writeHandle);
22 |         $msg = new Message(new RequestBody(1, 'aMethod', ['arg' => str_repeat('X', 100000)]));
23 |         $msgString = (string)$msg;
24 | 
25 |         $promise = $writer->write($msg);
26 | 
27 |         Loop\tick();
28 | 
29 |         $promise->wait();
30 | 
31 |         fclose($writeHandle);
32 | 
33 |         $this->assertEquals(strlen($msgString), filesize($tmpfile));
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Server/TextDocument/Definition/GlobalFallbackTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server\TextDocument\Definition;
 5 | 
 6 | use LanguageServer\Tests\MockProtocolStream;
 7 | use LanguageServer\Tests\Server\ServerTestCase;
 8 | use LanguageServer\{
 9 |     Server, LanguageClient, PhpDocumentLoader, DefinitionResolver
10 | };
11 | use LanguageServer\Index\{Index, ProjectIndex, DependenciesIndex};
12 | use LanguageServer\ContentRetriever\FileSystemContentRetriever;
13 | use LanguageServerProtocol\{TextDocumentIdentifier, Position, Range, Location};
14 | 
15 | class GlobalFallbackTest extends ServerTestCase
16 | {
17 |     public function setUp(): void
18 |     {
19 |         $projectIndex = new ProjectIndex(new Index, new DependenciesIndex);
20 |         $projectIndex->setComplete();
21 |         $client = new LanguageClient(new MockProtocolStream, new MockProtocolStream);
22 |         $definitionResolver = new DefinitionResolver($projectIndex);
23 |         $contentRetriever = new FileSystemContentRetriever;
24 |         $loader = new PhpDocumentLoader($contentRetriever, $projectIndex, $definitionResolver);
25 |         $this->textDocument = new Server\TextDocument($loader, $definitionResolver, $client, $projectIndex);
26 |         $loader->open('global_fallback', file_get_contents(__DIR__ . '/../../../../fixtures/global_fallback.php'));
27 |         $loader->open('global_symbols', file_get_contents(__DIR__ . '/../../../../fixtures/global_symbols.php'));
28 |     }
29 | 
30 |     public function testClassDoesNotFallback()
31 |     {
32 |         // $obj = new TestClass();
33 |         // Get definition for TestClass should not fall back to global
34 |         $result = $this->textDocument->definition(
35 |             new TextDocumentIdentifier('global_fallback'),
36 |             new Position(9, 16)
37 |         )->wait();
38 |         $this->assertEquals([], $result);
39 |     }
40 | 
41 |     public function testFallsBackForConstants()
42 |     {
43 |         // echo TEST_CONST;
44 |         // Get definition for TEST_CONST
45 |         $result = $this->textDocument->definition(
46 |             new TextDocumentIdentifier('global_fallback'),
47 |             new Position(6, 10)
48 |         )->wait();
49 |         $this->assertEquals(new Location('global_symbols', new Range(new Position(9, 6), new Position(9, 22))), $result);
50 |     }
51 | 
52 |     public function testFallsBackForFunctions()
53 |     {
54 |         // test_function();
55 |         // Get definition for test_function
56 |         $result = $this->textDocument->definition(
57 |             new TextDocumentIdentifier('global_fallback'),
58 |             new Position(5, 6)
59 |         )->wait();
60 |         $this->assertEquals(new Location('global_symbols', new Range(new Position(78, 0), new Position(81, 1))), $result);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/Server/TextDocument/Definition/NamespacedTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server\TextDocument\Definition;
 5 | 
 6 | use LanguageServerProtocol\{TextDocumentIdentifier, Location};
 7 | use function LanguageServer\pathToUri;
 8 | 
 9 | class NamespacedTest extends GlobalTest
10 | {
11 |     public function getReferenceLocations(string $fqn): array
12 |     {
13 |         return parent::getReferenceLocations('TestNamespace\\' . $fqn);
14 |     }
15 | 
16 |     public function getDefinitionLocation(string $fqn): Location
17 |     {
18 |         return parent::getDefinitionLocation('TestNamespace\\' . $fqn);
19 |     }
20 | 
21 |     public function testDefinitionForConstants()
22 |     {
23 |         // echo TEST_CONST;
24 |         // Get definition for TEST_CONST
25 |         $reference = $this->getReferenceLocations('TEST_CONST')[0];
26 |         $result = $this->textDocument->definition(
27 |             new TextDocumentIdentifier($reference->uri),
28 |             $reference->range->start
29 |         )->wait();
30 |         $this->assertEquals($this->getDefinitionLocation('TEST_CONST'), $result);
31 |     }
32 | 
33 |     public function testDefinitionForClassLikeUseStatement()
34 |     {
35 |         // use TestNamespace\TestClass;
36 |         // Get definition for TestClass
37 |         $reference = $this->getReferenceLocations('TestClass')[7];
38 |         $result = $this->textDocument->definition(
39 |             new TextDocumentIdentifier($reference->uri),
40 |             $reference->range->start
41 |         )->wait();
42 |         $this->assertEquals($this->getDefinitionLocation('TestClass'), $result);
43 |     }
44 | 
45 |     public function testDefinitionForClassLikeGroupUseStatement()
46 |     {
47 |         // use TestNamespace\{TestTrait, TestInterface};
48 |         // Get definition for TestInterface
49 |         $reference = $this->getReferenceLocations('TestClass')[1];
50 |         $result = $this->textDocument->definition(
51 |             new TextDocumentIdentifier($reference->uri),
52 |             $reference->range->start
53 |         )->wait();
54 |         $this->assertEquals($this->getDefinitionLocation('TestClass'), $result);
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/tests/Server/TextDocument/DidChangeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server\TextDocument;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use LanguageServer\Tests\MockProtocolStream;
 8 | use LanguageServer\{
 9 |     Server, LanguageClient, PhpDocumentLoader, DefinitionResolver
10 | };
11 | use LanguageServer\ContentRetriever\FileSystemContentRetriever;
12 | use LanguageServer\Index\{Index, ProjectIndex, DependenciesIndex};
13 | use LanguageServerProtocol\{
14 |     VersionedTextDocumentIdentifier,
15 |     TextDocumentContentChangeEvent,
16 |     Range,
17 |     Position
18 | };
19 | 
20 | class DidChangeTest extends TestCase
21 | {
22 |     public function test()
23 |     {
24 |         $projectIndex = new ProjectIndex(new Index, new DependenciesIndex);
25 |         $client = new LanguageClient(new MockProtocolStream, new MockProtocolStream);
26 |         $definitionResolver = new DefinitionResolver($projectIndex);
27 |         $loader = new PhpDocumentLoader(new FileSystemContentRetriever, $projectIndex, $definitionResolver);
28 |         $textDocument = new Server\TextDocument($loader, $definitionResolver, $client, $projectIndex);
29 |         $phpDocument = $loader->open('whatever', "<?php\necho 'Hello, World'\n");
30 | 
31 |         $identifier = new VersionedTextDocumentIdentifier('whatever');
32 |         $changeEvent = new TextDocumentContentChangeEvent();
33 |         $changeEvent->range = new Range(new Position(0, 0), new Position(9999, 9999));
34 |         $changeEvent->rangeLength = 9999;
35 |         $changeEvent->text = "<?php\necho 'Goodbye, World'\n";
36 | 
37 |         $textDocument->didChange($identifier, [$changeEvent]);
38 | 
39 |         $this->assertEquals("<?php\necho 'Goodbye, World'\n", $phpDocument->getContent());
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/tests/Server/TextDocument/DidCloseTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server\TextDocument;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use LanguageServer\Tests\MockProtocolStream;
 8 | use LanguageServer\{
 9 |     Server, LanguageClient, PhpDocumentLoader, DefinitionResolver
10 | };
11 | use LanguageServer\ContentRetriever\FileSystemContentRetriever;
12 | use LanguageServer\Index\{Index, ProjectIndex, DependenciesIndex};
13 | use LanguageServerProtocol\{TextDocumentItem, TextDocumentIdentifier};
14 | 
15 | class DidCloseTest extends TestCase
16 | {
17 |     public function test()
18 |     {
19 |         $projectIndex = new ProjectIndex(new Index, new DependenciesIndex);
20 |         $client = new LanguageClient(new MockProtocolStream, new MockProtocolStream);
21 |         $definitionResolver = new DefinitionResolver($projectIndex);
22 |         $loader = new PhpDocumentLoader(new FileSystemContentRetriever, $projectIndex, $definitionResolver);
23 |         $textDocument = new Server\TextDocument($loader, $definitionResolver, $client, $projectIndex);
24 |         $phpDocument = $loader->open('whatever', "<?php\necho 'Hello, World'\n");
25 | 
26 |         $textDocumentItem = new TextDocumentItem();
27 |         $textDocumentItem->uri = 'whatever';
28 |         $textDocumentItem->languageId = 'php';
29 |         $textDocumentItem->version = 1;
30 |         $textDocumentItem->text = 'hello world';
31 |         $textDocument->didOpen($textDocumentItem);
32 | 
33 |         $textDocument->didClose(new TextDocumentIdentifier($textDocumentItem->uri));
34 | 
35 |         $this->assertFalse($loader->isOpen($textDocumentItem->uri));
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Server/TextDocument/References/NamespacedTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server\TextDocument\References;
 5 | 
 6 | use LanguageServerProtocol\{TextDocumentIdentifier, Position, ReferenceContext, Location, Range};
 7 | use function LanguageServer\pathToUri;
 8 | 
 9 | class NamespacedTest extends GlobalTest
10 | {
11 |     protected function getReferenceLocations(string $fqn): array
12 |     {
13 |         return parent::getReferenceLocations('TestNamespace\\' . $fqn);
14 |     }
15 | 
16 |     protected function getDefinitionLocation(string $fqn): Location
17 |     {
18 |         return parent::getDefinitionLocation('TestNamespace\\' . $fqn);
19 |     }
20 | 
21 |     public function testReferencesForNamespaces()
22 |     {
23 |         // namespace TestNamespace;
24 |         // Get references for TestNamespace
25 |         $definition = parent::getDefinitionLocation('TestNamespace');
26 |         $result = $this->textDocument->references(
27 |             new ReferenceContext,
28 |             new TextDocumentIdentifier($definition->uri),
29 |             $definition->range->end
30 |         )->wait();
31 |         $this->assertEquals(parent::getReferenceLocations('TestNamespace'), $result);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/Server/Workspace/DidChangeWatchedFilesTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Server\Workspace;
 5 | 
 6 | use LanguageServer\ContentRetriever\FileSystemContentRetriever;
 7 | use LanguageServer\{DefinitionResolver, LanguageClient, PhpDocumentLoader, Server};
 8 | use LanguageServer\Index\{DependenciesIndex, Index, ProjectIndex};
 9 | use LanguageServerProtocol\{FileChangeType, FileEvent};
10 | use LanguageServer\Message;
11 | use LanguageServer\Tests\MockProtocolStream;
12 | use LanguageServer\Tests\Server\ServerTestCase;
13 | use LanguageServer\Server\Workspace;
14 | use Sabre\Event\Loop;
15 | 
16 | class DidChangeWatchedFilesTest extends ServerTestCase
17 | {
18 |     public function testDeletingFileClearsAllDiagnostics()
19 |     {
20 |         $client = new LanguageClient(new MockProtocolStream(), $writer = new MockProtocolStream());
21 |         $projectIndex = new ProjectIndex($sourceIndex = new Index(), $dependenciesIndex = new DependenciesIndex());
22 |         $definitionResolver = new DefinitionResolver($projectIndex);
23 |         $loader = new PhpDocumentLoader(new FileSystemContentRetriever(), $projectIndex, $definitionResolver);
24 |         $workspace = new Server\Workspace($client, $projectIndex, $dependenciesIndex, $sourceIndex, null, $loader, null);
25 | 
26 |         $fileEvent = new FileEvent('my uri', FileChangeType::DELETED);
27 | 
28 |         $isDiagnosticsCleared = false;
29 |         $writer->on('message', function (Message $message) use ($fileEvent, &$isDiagnosticsCleared) {
30 |             if ($message->body->method === "textDocument/publishDiagnostics") {
31 |                 $this->assertEquals($message->body->params->uri, $fileEvent->uri);
32 |                 $this->assertEquals($message->body->params->diagnostics, []);
33 |                 $isDiagnosticsCleared = true;
34 |             }
35 |         });
36 | 
37 |         $workspace->didChangeWatchedFiles([$fileEvent]);
38 |         Loop\tick(true);
39 | 
40 |         $this->assertTrue($isDiagnosticsCleared, "Deleting file should clear all diagnostics.");
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/tests/Utils/FileUriTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Utils;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use InvalidArgumentException;
 8 | use function LanguageServer\{pathToUri, uriToPath};
 9 | 
10 | class FileUriTest extends TestCase
11 | {
12 |     public function testPathToUri()
13 |     {
14 |         $uri = pathToUri('var/log');
15 |         $this->assertEquals('file:///var/log', $uri);
16 | 
17 |         $uri = pathToUri('/usr/local/bin');
18 |         $this->assertEquals('file:///usr/local/bin', $uri);
19 | 
20 |         $uri = pathToUri('a/b/c/test.txt');
21 |         $this->assertEquals('file:///a/b/c/test.txt', $uri);
22 | 
23 |         $uri = pathToUri('/d/e/f');
24 |         $this->assertEquals('file:///d/e/f', $uri);
25 | 
26 |         // special chars are escaped
27 |         $uri = pathToUri('c:/path/to/file/dürüm döner.php');
28 |         $this->assertEquals('file:///c:/path/to/file/d%C3%BCr%C3%BCm%20d%C3%B6ner.php', $uri);
29 | 
30 |         //backslashes are transformed
31 |         $uri = pathToUri('c:\\foo\\bar.baz');
32 |         $this->assertEquals('file:///c:/foo/bar.baz', $uri);
33 |     }
34 | 
35 |     public function testUriToPath()
36 |     {
37 |         $uri = 'file:///var/log';
38 |         $this->assertEquals('/var/log', uriToPath($uri));
39 | 
40 |         $uri = 'file:///usr/local/bin';
41 |         $this->assertEquals('/usr/local/bin', uriToPath($uri));
42 | 
43 |         $uri = 'file:///a/b/c/test.txt';
44 |         $this->assertEquals('/a/b/c/test.txt', uriToPath($uri));
45 | 
46 |         $uri = 'file:///d/e/f';
47 |         $this->assertEquals('/d/e/f', uriToPath($uri));
48 | 
49 |         $uri = 'file:///c:/path/to/file/d%C3%BCr%C3%BCm+d%C3%B6ner.php';
50 |         $this->assertEquals('c:\\path\\to\\file\\dürüm döner.php', uriToPath($uri));
51 | 
52 |         $uri = 'file:///c:/foo/bar.baz';
53 |         $this->assertEquals('c:\\foo\\bar.baz', uriToPath($uri));
54 | 
55 |         $uri = 'file:///c%3A/path/to/file/d%C3%BCr%C3%BCm+d%C3%B6ner.php';
56 |         $this->assertEquals('c:\\path\\to\\file\\dürüm döner.php', uriToPath($uri));
57 | 
58 |         $uri = 'file:///c%3A/foo/bar.baz';
59 |         $this->assertEquals('c:\\foo\\bar.baz', uriToPath($uri));
60 |     }
61 | 
62 |     public function testUriToPathForUnknownProtocol()
63 |     {
64 |         $this->expectException(InvalidArgumentException::class);
65 |         $uri = 'vfs:///whatever';
66 |         uriToPath($uri);
67 |     }
68 | 
69 |     public function testUriToPathForInvalidProtocol()
70 |     {
71 |         $this->expectException(InvalidArgumentException::class);
72 |         $uri = 'http://www.google.com';
73 |         uriToPath($uri);
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/tests/Utils/StripStringOverlapTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace LanguageServer\Tests\Utils;
 5 | 
 6 | use PHPUnit\Framework\TestCase;
 7 | use function LanguageServer\stripStringOverlap;
 8 | 
 9 | class StripStringOverlapTest extends TestCase
10 | {
11 |     public function testNoCharOverlaps()
12 |     {
13 |         $this->assertEquals('<?php', stripStringOverlap('bla', '<?php'));
14 |     }
15 | 
16 |     public function test1CharOverlaps()
17 |     {
18 |         $this->assertEquals('?php', stripStringOverlap('bla<', '<?php'));
19 |     }
20 | 
21 |     public function test2CharsOverlap()
22 |     {
23 |         $this->assertEquals('php', stripStringOverlap('bla<?', '<?php'));
24 |     }
25 | 
26 |     public function testEverythingOverlaps()
27 |     {
28 |         $this->assertEquals('', stripStringOverlap('bla<?php', '<?php'));
29 |     }
30 | 
31 |     public function testEmptyA()
32 |     {
33 |         $this->assertEquals('<?php', stripStringOverlap('', '<?php'));
34 |     }
35 | 
36 |     public function testEmptyB()
37 |     {
38 |         $this->assertEquals('', stripStringOverlap('bla', ''));
39 |     }
40 | 
41 |     public function testBothEmpty()
42 |     {
43 |         $this->assertEquals('', stripStringOverlap('', ''));
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/WithReturnTypehints.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fixtures\Prophecy;
 4 | 
 5 | class WithReturnTypehints extends EmptyClass
 6 | {
 7 |     public function getSelf(): self {
 8 |         return $this;
 9 |     }
10 | 
11 |     public function getName(): string {
12 |         return __CLASS__;
13 |     }
14 |     
15 |     public function getParent(): parent {
16 |         return $this;
17 |     }
18 |     
19 |     public function getStatic(): static {
20 |         return $this;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/anonymousClassMembersShouldNotBeSymbols.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | $a = new class () {
 5 |     public $a;
 6 |     const HI = 3;
 7 | 
 8 |     function b () {
 9 | 
10 |     }
11 | };


--------------------------------------------------------------------------------
/tests/Validation/cases/anonymousClassMembersShouldNotBeSymbols.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "MyNamespace": {
 5 |             "fqn": "MyNamespace",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "MyNamespace",
13 |                 "kind": 3,
14 |                 "location": {
15 |                     "uri": "./anonymousClassMembersShouldNotBeSymbols.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type": null,
20 |             "declarationLine": "namespace MyNamespace;",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         }
24 |     }
25 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/arrayValueShouldBeBoolean.php:
--------------------------------------------------------------------------------
1 | <?php
2 | class A {
3 |     protected $foo = ['hello' => TRUE];
4 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/arrayValueShouldBeBoolean.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "A": {
 5 |             "fqn": "A",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": true,
11 |             "symbolInformation": {
12 |                 "name": "A",
13 |                 "kind": 5,
14 |                 "location": {
15 |                     "uri": "./arrayValueShouldBeBoolean.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type": null,
20 |             "declarationLine": "class A {",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         },
24 |         "A->foo": {
25 |             "fqn": "A->foo",
26 |             "extends": [],
27 |             "isMember": true,
28 |             "roamed": false,
29 |             "isStatic": false,
30 |             "canBeInstantiated": false,
31 |             "symbolInformation": {
32 |                 "name": "foo",
33 |                 "kind": 7,
34 |                 "location": {
35 |                     "uri": "./arrayValueShouldBeBoolean.php"
36 |                 },
37 |                 "containerName": "A"
38 |             },
39 |             "type__tostring": "array<string,bool>",
40 |             "type": {},
41 |             "declarationLine": "protected $foo;",
42 |             "documentation": null,
43 |             "signatureInformation": null
44 |         }
45 |     }
46 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/caseStatement1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | switch ($a) {
5 |     case A:
6 | 
7 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/caseStatement1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\A": [
 4 |             "./caseStatement1.php"
 5 |         ],
 6 |         "A": [
 7 |             "./caseStatement1.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./caseStatement1.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/circularVar.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | function circularVar(string $var) {
4 | 	$var = $var;
5 | }
6 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/circularVar.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "circularVar()": {
 5 |             "fqn": "circularVar()",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": true,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "circularVar",
13 |                 "kind": 12,
14 |                 "location": {
15 |                     "uri": "./circularVar.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type__tostring": "mixed",
20 |             "type": {},
21 |             "declarationLine": "function circularVar(string $var)",
22 |             "documentation": null,
23 |             "signatureInformation": {
24 |                 "label": "(string $var)",
25 |                 "parameters": [
26 |                     {
27 |                         "label": "string $var"
28 |                     }
29 |                 ]
30 |             }
31 |         }
32 |     }
33 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/classDefinition1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace TestNamespace;
 4 | 
 5 | $a = new A;
 6 | 
 7 | echo $a->a;
 8 | 
 9 | class A {
10 |     public $a = 3;
11 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/classDefinition1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "TestNamespace\\A": [
 4 |             "./classDefinition1.php"
 5 |         ],
 6 |         "TestNamespace\\A->a": [
 7 |             "./classDefinition1.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "TestNamespace": {
12 |             "fqn": "TestNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "TestNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./classDefinition1.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace TestNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "TestNamespace\\A": {
32 |             "fqn": "TestNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./classDefinition1.php"
43 |                 },
44 |                 "containerName": "TestNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A {",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "TestNamespace\\A->a": {
52 |             "fqn": "TestNamespace\\A->a",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": false,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "a",
60 |                 "kind": 7,
61 |                 "location": {
62 |                     "uri": "./classDefinition1.php"
63 |                 },
64 |                 "containerName": "TestNamespace\\A"
65 |             },
66 |             "type__tostring": "int",
67 |             "type": {},
68 |             "declarationLine": "public $a;",
69 |             "documentation": null,
70 |             "signatureInformation": null
71 |         }
72 |     }
73 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/classProperty1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace TestNamespace;
 4 | 
 5 | use SomeNamespace\Goo;
 6 | 
 7 | class TestClass
 8 | {
 9 |     public $testProperty;
10 | 
11 |     public function testMethod($testParameter)
12 |     {
13 |         $testVariable = 123;
14 | 
15 |         if (empty($testParameter)) {
16 |             echo 'Empty';
17 |         }
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/constants.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A
 6 | {
 7 |     public static function suite()
 8 |     {
 9 |         return [
10 |             "hi" => BYE
11 |         ];
12 |     }
13 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\BYE": [
 4 |             "./constants.php"
 5 |         ],
 6 |         "BYE": [
 7 |             "./constants.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./constants.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./constants.php"
43 |                 },
44 |                 "containerName": "MyNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "MyNamespace\\A::suite()": {
52 |             "fqn": "MyNamespace\\A::suite()",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": true,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "suite",
60 |                 "kind": 6,
61 |                 "location": {
62 |                     "uri": "./constants.php"
63 |                 },
64 |                 "containerName": "MyNamespace\\A"
65 |             },
66 |             "type__tostring": "mixed",
67 |             "type": {},
68 |             "declarationLine": "public static function suite()",
69 |             "documentation": null,
70 |             "signatureInformation": {
71 |                 "label": "()",
72 |                 "parameters": []
73 |             }
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A
 6 | {
 7 |     public static function suite()
 8 |     {
 9 |         return [
10 |             BYE => "hi"
11 |         ];
12 |     }
13 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants2.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\BYE": [
 4 |             "./constants2.php"
 5 |         ],
 6 |         "BYE": [
 7 |             "./constants2.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./constants2.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./constants2.php"
43 |                 },
44 |                 "containerName": "MyNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "MyNamespace\\A::suite()": {
52 |             "fqn": "MyNamespace\\A::suite()",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": true,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "suite",
60 |                 "kind": 6,
61 |                 "location": {
62 |                     "uri": "./constants2.php"
63 |                 },
64 |                 "containerName": "MyNamespace\\A"
65 |             },
66 |             "type__tostring": "mixed",
67 |             "type": {},
68 |             "declarationLine": "public static function suite()",
69 |             "documentation": null,
70 |             "signatureInformation": {
71 |                 "label": "()",
72 |                 "parameters": []
73 |             }
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A
 6 | {
 7 |     public static function suite()
 8 |     {
 9 |         return array(T_NEW);
10 |     }
11 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants3.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\T_NEW": [
 4 |             "./constants3.php"
 5 |         ],
 6 |         "T_NEW": [
 7 |             "./constants3.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./constants3.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./constants3.php"
43 |                 },
44 |                 "containerName": "MyNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "MyNamespace\\A::suite()": {
52 |             "fqn": "MyNamespace\\A::suite()",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": true,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "suite",
60 |                 "kind": 6,
61 |                 "location": {
62 |                     "uri": "./constants3.php"
63 |                 },
64 |                 "containerName": "MyNamespace\\A"
65 |             },
66 |             "type__tostring": "mixed",
67 |             "type": {},
68 |             "declarationLine": "public static function suite()",
69 |             "documentation": null,
70 |             "signatureInformation": {
71 |                 "label": "()",
72 |                 "parameters": []
73 |             }
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A
 6 | {
 7 |     public function suite()
 8 |     {
 9 |         return HI;
10 |     }
11 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants4.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\HI": [
 4 |             "./constants4.php"
 5 |         ],
 6 |         "HI": [
 7 |             "./constants4.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./constants4.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./constants4.php"
43 |                 },
44 |                 "containerName": "MyNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "MyNamespace\\A->suite()": {
52 |             "fqn": "MyNamespace\\A->suite()",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": false,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "suite",
60 |                 "kind": 6,
61 |                 "location": {
62 |                     "uri": "./constants4.php"
63 |                 },
64 |                 "containerName": "MyNamespace\\A"
65 |             },
66 |             "type__tostring": "mixed",
67 |             "type": {},
68 |             "declarationLine": "public function suite()",
69 |             "documentation": null,
70 |             "signatureInformation": {
71 |                 "label": "()",
72 |                 "parameters": []
73 |             }
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants5.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | 
5 | class Mbstring
6 | {
7 |     const MB_CASE_FOLD = PHP_INT_MAX;
8 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constants5.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\PHP_INT_MAX": [
 4 |             "./constants5.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./constants5.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "MyNamespace\\Mbstring": {
29 |             "fqn": "MyNamespace\\Mbstring",
30 |             "extends": [],
31 |             "isMember": false,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": true,
35 |             "symbolInformation": {
36 |                 "name": "Mbstring",
37 |                 "kind": 5,
38 |                 "location": {
39 |                     "uri": "./constants5.php"
40 |                 },
41 |                 "containerName": "MyNamespace"
42 |             },
43 |             "type": null,
44 |             "declarationLine": "class Mbstring",
45 |             "documentation": null,
46 |             "signatureInformation": null
47 |         },
48 |         "MyNamespace\\Mbstring::MB_CASE_FOLD": {
49 |             "fqn": "MyNamespace\\Mbstring::MB_CASE_FOLD",
50 |             "extends": [],
51 |             "isMember": true,
52 |             "roamed": false,
53 |             "isStatic": false,
54 |             "canBeInstantiated": false,
55 |             "symbolInformation": {
56 |                 "name": "MB_CASE_FOLD",
57 |                 "kind": 14,
58 |                 "location": {
59 |                     "uri": "./constants5.php"
60 |                 },
61 |                 "containerName": "MyNamespace\\Mbstring"
62 |             },
63 |             "type__tostring": "\\MyNamespace\\PHP_INT_MAX",
64 |             "type": {},
65 |             "declarationLine": "const MB_CASE_FOLD = PHP_INT_MAX;",
66 |             "documentation": null,
67 |             "signatureInformation": null
68 |         }
69 |     }
70 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constantsInFunctionParamDefault.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | interface A {
4 |     function b ($a = MY_CONSTANT);
5 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/constantsInFunctionParamDefault.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MY_CONSTANT": [
 4 |             "./constantsInFunctionParamDefault.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "A": {
 9 |             "fqn": "A",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "A",
17 |                 "kind": 11,
18 |                 "location": {
19 |                     "uri": "./constantsInFunctionParamDefault.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "interface A {",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "A->b()": {
29 |             "fqn": "A->b()",
30 |             "extends": [],
31 |             "isMember": true,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": false,
35 |             "symbolInformation": {
36 |                 "name": "b",
37 |                 "kind": 6,
38 |                 "location": {
39 |                     "uri": "./constantsInFunctionParamDefault.php"
40 |                 },
41 |                 "containerName": "A"
42 |             },
43 |             "type__tostring": "mixed",
44 |             "type": {},
45 |             "declarationLine": "function b ($a = MY_CONSTANT);",
46 |             "documentation": null,
47 |             "signatureInformation": {
48 |                 "label": "(\\MY_CONSTANT $a = MY_CONSTANT)",
49 |                 "parameters": [
50 |                     {
51 |                         "label": "\\MY_CONSTANT $a = MY_CONSTANT"
52 |                     }
53 |                 ]
54 |             }
55 |         }
56 |     }
57 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/docBlocksOnNamespaceDefinition.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | /**
4 |  * This is a file comment, not NS comment
5 |  */
6 | namespace MyNamespace;
7 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/docBlocksOnNamespaceDefinition.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "MyNamespace": {
 5 |             "fqn": "MyNamespace",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "MyNamespace",
13 |                 "kind": 3,
14 |                 "location": {
15 |                     "uri": "./docBlocksOnNamespaceDefinition.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type": null,
20 |             "declarationLine": "namespace MyNamespace;",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         }
24 |     }
25 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/exceptions1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | 
5 | try {
6 | 
7 | } catch (Exception $e) {
8 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/exceptions1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\Exception": [
 4 |             "./exceptions1.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./exceptions1.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         }
28 |     }
29 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/forLoopReference1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class ForLoopReference1 {
 4 |     public function getThat() {
 5 |         for ($that = $this; null !== $that; $that = $that->foo()) {
 6 |         }
 7 |     }
 8 | 
 9 |     public function foo() {
10 |         return $this;
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/forLoopReference1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "ForLoopReference1->foo()": [
 4 |             "./_cases/forLoopReference1.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "ForLoopReference1": {
 9 |             "extends": [],
10 |             "isGlobal": true,
11 |             "isStatic": false,
12 |             "canBeInstantiated": true,
13 |             "symbolInformation": {
14 |                 "name": "ForLoopReference1",
15 |                 "kind": 5,
16 |                 "location": {
17 |                     "uri": "./_cases/forLoopReference1.php"
18 |                 },
19 |                 "containerName": ""
20 |             },
21 |             "type__class": "LanguageServer\\Tests\\ValidationTest",
22 |             "type": null,
23 |             "documentation": null
24 |         },
25 |         "ForLoopReference1->getThat()": {
26 |             "extends": [],
27 |             "isGlobal": false,
28 |             "isStatic": false,
29 |             "canBeInstantiated": false,
30 |             "symbolInformation": {
31 |                 "name": "getThat",
32 |                 "kind": 6,
33 |                 "location": {
34 |                     "uri": "./_cases/forLoopReference1.php"
35 |                 },
36 |                 "containerName": "ForLoopReference1"
37 |             },
38 |             "type__class": "phpDocumentor\\Reflection\\Types\\Mixed",
39 |             "type": {},
40 |             "documentation": null
41 |         },
42 |         "ForLoopReference1->foo()": {
43 |             "extends": [],
44 |             "isGlobal": false,
45 |             "isStatic": false,
46 |             "canBeInstantiated": false,
47 |             "symbolInformation": {
48 |                 "name": "foo",
49 |                 "kind": 6,
50 |                 "location": {
51 |                     "uri": "./_cases/forLoopReference1.php"
52 |                 },
53 |                 "containerName": "ForLoopReference1"
54 |             },
55 |             "type__class": "phpDocumentor\\Reflection\\Types\\Mixed",
56 |             "type": {},
57 |             "documentation": null
58 |         }
59 |     }
60 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/functionParamInters.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | function test1(int&string $par): void {}
4 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/functionParamInters.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "test1()": {
 5 |             "fqn": "test1()",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": true,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "test1",
13 |                 "kind": 12,
14 |                 "location": {
15 |                     "uri": "./functionParamInters.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type__tostring": "void",
20 |             "type": {},
21 |             "declarationLine": "function test1(int&string $par): void",
22 |             "documentation": null,
23 |             "signatureInformation": {
24 |                 "label": "(int&string $par)",
25 |                 "parameters": [
26 |                     {
27 |                         "label": "int&string $par"
28 |                     }
29 |                 ]
30 |             }
31 |         }
32 |     }
33 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/functionParamUnion.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | function test1(int|string $par): void {}
4 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/functionParamUnion.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "test1()": {
 5 |             "fqn": "test1()",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": true,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "test1",
13 |                 "kind": 12,
14 |                 "location": {
15 |                     "uri": "./functionParamUnion.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type__tostring": "void",
20 |             "type": {},
21 |             "declarationLine": "function test1(int|string $par): void",
22 |             "documentation": null,
23 |             "signatureInformation": {
24 |                 "label": "(int|string $par)",
25 |                 "parameters": [
26 |                     {
27 |                         "label": "int|string $par"
28 |                     }
29 |                 ]
30 |             }
31 |         }
32 |     }
33 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/functionReturnInters.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | function test1(): int&string {}
4 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/functionReturnInters.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "test1()": {
 5 |             "fqn": "test1()",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": true,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "test1",
13 |                 "kind": 12,
14 |                 "location": {
15 |                     "uri": "./functionReturnInters.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type__tostring": "int&string",
20 |             "type": {},
21 |             "declarationLine": "function test1(): int&string",
22 |             "documentation": null,
23 |             "signatureInformation": {
24 |                 "label": "()",
25 |                 "parameters": []
26 |             }
27 |         }
28 |     }
29 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/functionReturnUnion.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | function test1(): int|string {}
4 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/functionReturnUnion.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "test1()": {
 5 |             "fqn": "test1()",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": true,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "test1",
13 |                 "kind": 12,
14 |                 "location": {
15 |                     "uri": "./functionReturnUnion.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type__tostring": "int|string",
20 |             "type": {},
21 |             "declarationLine": "function test1(): int|string",
22 |             "documentation": null,
23 |             "signatureInformation": {
24 |                 "label": "()",
25 |                 "parameters": []
26 |             }
27 |         }
28 |     }
29 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/functionUse.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $a = new A;
4 | 
5 | $b = function () use ($a) {
6 |     echo $a->b();
7 | };


--------------------------------------------------------------------------------
/tests/Validation/cases/functionUse.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "A": [
 4 |             "./functionUse.php"
 5 |         ],
 6 |         "A->b()": [
 7 |             "./functionUse.php"
 8 |         ]
 9 |     },
10 |     "definitions": []
11 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/functionUse2.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | use function LanguageServer\{pathToUri, timeout};
5 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/functionUse2.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "LanguageServer": [
 4 |             "./functionUse2.php"
 5 |         ],
 6 |         "LanguageServer\\pathToUri()": [
 7 |             "./functionUse2.php"
 8 |         ],
 9 |         "LanguageServer\\timeout()": [
10 |             "./functionUse2.php"
11 |         ]
12 |     },
13 |     "definitions": []
14 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/ifStatement1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | if (A) {
5 | 
6 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/ifStatement1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\A": [
 4 |             "./ifStatement1.php"
 5 |         ],
 6 |         "A": [
 7 |             "./ifStatement1.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./ifStatement1.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/interfaceProperty.php:
--------------------------------------------------------------------------------
1 | <?php
2 | interface A  {
3 |     // props ignored in interface
4 |     var $a = 3;
5 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/interfaceProperty.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "A": {
 5 |             "fqn": "A",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "A",
13 |                 "kind": 11,
14 |                 "location": {
15 |                     "uri": "./interfaceProperty.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type": null,
20 |             "declarationLine": "interface A  {",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         }
24 |     }
25 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/magicConstantsShouldBeGlobal.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace B;
4 | 
5 | echo __FILE__;


--------------------------------------------------------------------------------
/tests/Validation/cases/magicConstantsShouldBeGlobal.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "B\\__FILE__": [
 4 |             "./magicConstantsShouldBeGlobal.php"
 5 |         ],
 6 |         "__FILE__": [
 7 |             "./magicConstantsShouldBeGlobal.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "B": {
12 |             "fqn": "B",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "B",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./magicConstantsShouldBeGlobal.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace B;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/magicConsts.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class A {
4 |     private static $deprecationsTriggered = array(
5 |         __CLASS__ => true
6 |     );
7 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/magicConsts.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "__CLASS__": [
 4 |             "./magicConsts.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "A": {
 9 |             "fqn": "A",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": true,
15 |             "symbolInformation": {
16 |                 "name": "A",
17 |                 "kind": 5,
18 |                 "location": {
19 |                     "uri": "./magicConsts.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "class A {",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "A::$deprecationsTriggered": {
29 |             "fqn": "A::$deprecationsTriggered",
30 |             "extends": [],
31 |             "isMember": true,
32 |             "roamed": false,
33 |             "isStatic": true,
34 |             "canBeInstantiated": false,
35 |             "symbolInformation": {
36 |                 "name": "deprecationsTriggered",
37 |                 "kind": 7,
38 |                 "location": {
39 |                     "uri": "./magicConsts.php"
40 |                 },
41 |                 "containerName": "A"
42 |             },
43 |             "type__tostring": "array<\\__CLASS__,bool>",
44 |             "type": {},
45 |             "declarationLine": "private static $deprecationsTriggered;",
46 |             "documentation": null,
47 |             "signatureInformation": null
48 |         }
49 |     }
50 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A {
 6 |     static function a() {
 7 |         $b = new a;
 8 |         $c = $b->a();
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\a": [
 4 |             "./memberAccess1.php"
 5 |         ],
 6 |         "MyNamespace\\a->a()": [
 7 |             "./memberAccess1.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./memberAccess1.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./memberAccess1.php"
43 |                 },
44 |                 "containerName": "MyNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A {",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "MyNamespace\\A::a()": {
52 |             "fqn": "MyNamespace\\A::a()",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": true,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "a",
60 |                 "kind": 6,
61 |                 "location": {
62 |                     "uri": "./memberAccess1.php"
63 |                 },
64 |                 "containerName": "MyNamespace\\A"
65 |             },
66 |             "type__tostring": "mixed",
67 |             "type": {},
68 |             "declarationLine": "static function a()",
69 |             "documentation": null,
70 |             "signatureInformation": {
71 |                 "label": "()",
72 |                 "parameters": []
73 |             }
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A {
 6 |     static function a() {
 7 |         $b = new a;
 8 |         $c = $b->a();
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess2.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\a": [
 4 |             "./memberAccess2.php"
 5 |         ],
 6 |         "MyNamespace\\a->a()": [
 7 |             "./memberAccess2.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./memberAccess2.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./memberAccess2.php"
43 |                 },
44 |                 "containerName": "MyNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A {",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "MyNamespace\\A::a()": {
52 |             "fqn": "MyNamespace\\A::a()",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": true,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "a",
60 |                 "kind": 6,
61 |                 "location": {
62 |                     "uri": "./memberAccess2.php"
63 |                 },
64 |                 "containerName": "MyNamespace\\A"
65 |             },
66 |             "type__tostring": "mixed",
67 |             "type": {},
68 |             "declarationLine": "static function a()",
69 |             "documentation": null,
70 |             "signatureInformation": {
71 |                 "label": "()",
72 |                 "parameters": []
73 |             }
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A {
 6 |     public static function getInitializer(ClassLoader $loader)
 7 |     {
 8 |         return \Closure::bind(function () use ($loader) {
 9 |             $loader->prefixesPsr0 = ComposerStaticInitIncludePath::$prefixesPsr0;
10 | 
11 |         }, null, ClassLoader::class);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A {
 6 |     public function testRequest()
 7 |     {
 8 |         $request = Request::create((new Url('httpkernel_test.empty'))->toString());
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess4.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\Request::create()": [
 4 |             "./memberAccess4.php"
 5 |         ],
 6 |         "MyNamespace\\Request": [
 7 |             "./memberAccess4.php"
 8 |         ],
 9 |         "MyNamespace\\Url->toString()": [
10 |             "./memberAccess4.php"
11 |         ],
12 |         "MyNamespace\\Url": [
13 |             "./memberAccess4.php"
14 |         ]
15 |     },
16 |     "definitions": {
17 |         "MyNamespace": {
18 |             "fqn": "MyNamespace",
19 |             "extends": [],
20 |             "isMember": false,
21 |             "roamed": false,
22 |             "isStatic": false,
23 |             "canBeInstantiated": false,
24 |             "symbolInformation": {
25 |                 "name": "MyNamespace",
26 |                 "kind": 3,
27 |                 "location": {
28 |                     "uri": "./memberAccess4.php"
29 |                 },
30 |                 "containerName": ""
31 |             },
32 |             "type": null,
33 |             "declarationLine": "namespace MyNamespace;",
34 |             "documentation": null,
35 |             "signatureInformation": null
36 |         },
37 |         "MyNamespace\\A": {
38 |             "fqn": "MyNamespace\\A",
39 |             "extends": [],
40 |             "isMember": false,
41 |             "roamed": false,
42 |             "isStatic": false,
43 |             "canBeInstantiated": true,
44 |             "symbolInformation": {
45 |                 "name": "A",
46 |                 "kind": 5,
47 |                 "location": {
48 |                     "uri": "./memberAccess4.php"
49 |                 },
50 |                 "containerName": "MyNamespace"
51 |             },
52 |             "type": null,
53 |             "declarationLine": "class A {",
54 |             "documentation": null,
55 |             "signatureInformation": null
56 |         },
57 |         "MyNamespace\\A->testRequest()": {
58 |             "fqn": "MyNamespace\\A->testRequest()",
59 |             "extends": [],
60 |             "isMember": true,
61 |             "roamed": false,
62 |             "isStatic": false,
63 |             "canBeInstantiated": false,
64 |             "symbolInformation": {
65 |                 "name": "testRequest",
66 |                 "kind": 6,
67 |                 "location": {
68 |                     "uri": "./memberAccess4.php"
69 |                 },
70 |                 "containerName": "MyNamespace\\A"
71 |             },
72 |             "type__tostring": "mixed",
73 |             "type": {},
74 |             "declarationLine": "public function testRequest()",
75 |             "documentation": null,
76 |             "signatureInformation": {
77 |                 "label": "()",
78 |                 "parameters": []
79 |             }
80 |         }
81 |     }
82 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess5.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class ParseErrorsTest {
 6 | 
 7 |     public function setUp()
 8 |     {
 9 |         $a = new class($this->args) { };
10 |     }
11 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/memberAccess5.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\ParseErrorsTest->args": [
 4 |             "./memberAccess5.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./memberAccess5.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "MyNamespace\\ParseErrorsTest": {
29 |             "fqn": "MyNamespace\\ParseErrorsTest",
30 |             "extends": [],
31 |             "isMember": false,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": true,
35 |             "symbolInformation": {
36 |                 "name": "ParseErrorsTest",
37 |                 "kind": 5,
38 |                 "location": {
39 |                     "uri": "./memberAccess5.php"
40 |                 },
41 |                 "containerName": "MyNamespace"
42 |             },
43 |             "type": null,
44 |             "declarationLine": "class ParseErrorsTest {",
45 |             "documentation": null,
46 |             "signatureInformation": null
47 |         },
48 |         "MyNamespace\\ParseErrorsTest->setUp()": {
49 |             "fqn": "MyNamespace\\ParseErrorsTest->setUp()",
50 |             "extends": [],
51 |             "isMember": true,
52 |             "roamed": false,
53 |             "isStatic": false,
54 |             "canBeInstantiated": false,
55 |             "symbolInformation": {
56 |                 "name": "setUp",
57 |                 "kind": 6,
58 |                 "location": {
59 |                     "uri": "./memberAccess5.php"
60 |                 },
61 |                 "containerName": "MyNamespace\\ParseErrorsTest"
62 |             },
63 |             "type__tostring": "mixed",
64 |             "type": {},
65 |             "declarationLine": "public function setUp()",
66 |             "documentation": null,
67 |             "signatureInformation": {
68 |                 "label": "()",
69 |                 "parameters": []
70 |             }
71 |         }
72 |     }
73 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/memberCall1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class ParseErrorsTest
 6 | {
 7 |     public function setAccount(AccountInterface $account)
 8 |     {
 9 |         // If the passed account is already proxied, use the actual account instead
10 |         // to prevent loops.
11 |         if ($account instanceof A) {
12 |             $account = $account->getAccount();
13 |         }
14 | 
15 |     }
16 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/methodReturnType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class FooClass extends EmptyClass
 4 | {
 5 |     public function foo(): FooClass {
 6 |         return $this;
 7 |     }
 8 | 
 9 |     /** @return self */
10 |     public function bar() { }
11 | 
12 |     /** @return static */
13 |     public function baz() { }
14 | 
15 |     /** @return parent */
16 |     public function buz() { }
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/multipleNamespaces.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace1;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | namespace MyNamespace2;
12 | 
13 | class A extends MyNamespace1\B {
14 |     function a () {
15 |         $a = $this->b();
16 |     }
17 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/multiplePreceedingComments.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Foo
 4 | {
 5 |     /**
 6 |      * Foo
 7 |      *
 8 |      * @return \Iterator
 9 |      */
10 |     // @codingStandardsIgnoreLine
11 |     public function fn()
12 |     {
13 |         return null;
14 |     }
15 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/multiplePreceedingComments.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "Foo": {
 5 |             "fqn": "Foo",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": true,
11 |             "symbolInformation": {
12 |                 "name": "Foo",
13 |                 "kind": 5,
14 |                 "location": {
15 |                     "uri": "./multiplePreceedingComments.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type": null,
20 |             "declarationLine": "class Foo",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         },
24 |         "Foo->fn()": {
25 |             "fqn": "Foo->fn()",
26 |             "extends": [],
27 |             "isMember": true,
28 |             "roamed": false,
29 |             "isStatic": false,
30 |             "canBeInstantiated": false,
31 |             "symbolInformation": {
32 |                 "name": "fn",
33 |                 "kind": 6,
34 |                 "location": {
35 |                     "uri": "./multiplePreceedingComments.php"
36 |                 },
37 |                 "containerName": "Foo"
38 |             },
39 |             "type__tostring": "\\Iterator",
40 |             "type": {},
41 |             "declarationLine": "public function fn()",
42 |             "documentation": "Foo",
43 |             "signatureInformation": {
44 |                 "label": "()",
45 |                 "documentation": "Foo",
46 |                 "parameters": []
47 |             }
48 |         }
49 |     }
50 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/nameToken.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class A {
4 |     function b() {
5 |         $a instanceof static;
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/nameToken.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "A": [
 4 |             "./nameToken.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "A": {
 9 |             "fqn": "A",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": true,
15 |             "symbolInformation": {
16 |                 "name": "A",
17 |                 "kind": 5,
18 |                 "location": {
19 |                     "uri": "./nameToken.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "class A {",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "A->b()": {
29 |             "fqn": "A->b()",
30 |             "extends": [],
31 |             "isMember": true,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": false,
35 |             "symbolInformation": {
36 |                 "name": "b",
37 |                 "kind": 6,
38 |                 "location": {
39 |                     "uri": "./nameToken.php"
40 |                 },
41 |                 "containerName": "A"
42 |             },
43 |             "type__tostring": "mixed",
44 |             "type": {},
45 |             "declarationLine": "function b()",
46 |             "documentation": null,
47 |             "signatureInformation": {
48 |                 "label": "()",
49 |                 "parameters": []
50 |             }
51 |         }
52 |     }
53 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces2.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace1;
4 | 
5 | use \NS1\C, \NS1\I, \NS1\T;
6 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces2.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "NS1\\C": [
 4 |             "./namespaces2.php"
 5 |         ],
 6 |         "NS1": [
 7 |             "./namespaces2.php"
 8 |         ],
 9 |         "NS1\\I": [
10 |             "./namespaces2.php"
11 |         ],
12 |         "NS1\\T": [
13 |             "./namespaces2.php"
14 |         ]
15 |     },
16 |     "definitions": {
17 |         "MyNamespace1": {
18 |             "fqn": "MyNamespace1",
19 |             "extends": [],
20 |             "isMember": false,
21 |             "roamed": false,
22 |             "isStatic": false,
23 |             "canBeInstantiated": false,
24 |             "symbolInformation": {
25 |                 "name": "MyNamespace1",
26 |                 "kind": 3,
27 |                 "location": {
28 |                     "uri": "./namespaces2.php"
29 |                 },
30 |                 "containerName": ""
31 |             },
32 |             "type": null,
33 |             "declarationLine": "namespace MyNamespace1;",
34 |             "documentation": null,
35 |             "signatureInformation": null
36 |         }
37 |     }
38 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces3.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | use  namespace\a\b as c;


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces3.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "a\\b": [
 4 |             "./_cases/namespaces3.php"
 5 |         ],
 6 |         "b": [
 7 |             "./_cases/namespaces3.php"
 8 |         ],
 9 |         "c": [
10 |             "./_cases/namespaces3.php"
11 |         ]
12 |     },
13 |     "definitions": []
14 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces4.php:
--------------------------------------------------------------------------------
1 | <?php
2 | use  \a\b as c;


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces4.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "a\\b": [
 4 |             "./namespaces4.php"
 5 |         ],
 6 |         "a": [
 7 |             "./namespaces4.php"
 8 |         ]
 9 |     },
10 |     "definitions": []
11 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces5.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace B;
3 | use LanguageServerProtocol\{TextDocumentIdentifier, Position, ReferenceContext, Location, Range};
4 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces5.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "LanguageServerProtocol": [
 4 |             "./namespaces5.php"
 5 |         ],
 6 |         "LanguageServerProtocol\\TextDocumentIdentifier": [
 7 |             "./namespaces5.php"
 8 |         ],
 9 |         "LanguageServerProtocol\\Position": [
10 |             "./namespaces5.php"
11 |         ],
12 |         "LanguageServerProtocol\\ReferenceContext": [
13 |             "./namespaces5.php"
14 |         ],
15 |         "LanguageServerProtocol\\Location": [
16 |             "./namespaces5.php"
17 |         ],
18 |         "LanguageServerProtocol\\Range": [
19 |             "./namespaces5.php"
20 |         ]
21 |     },
22 |     "definitions": {
23 |         "B": {
24 |             "fqn": "B",
25 |             "extends": [],
26 |             "isMember": false,
27 |             "roamed": false,
28 |             "isStatic": false,
29 |             "canBeInstantiated": false,
30 |             "symbolInformation": {
31 |                 "name": "B",
32 |                 "kind": 3,
33 |                 "location": {
34 |                     "uri": "./namespaces5.php"
35 |                 },
36 |                 "containerName": ""
37 |             },
38 |             "type": null,
39 |             "declarationLine": "namespace B;",
40 |             "documentation": null,
41 |             "signatureInformation": null
42 |         }
43 |     }
44 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces6.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace A \ B;


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces6.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "A\\B": {
 5 |             "fqn": "A\\B",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": false,
11 |             "symbolInformation": {
12 |                 "name": "A\\B",
13 |                 "kind": 3,
14 |                 "location": {
15 |                     "uri": "./namespaces6.php"
16 |                 },
17 |                 "containerName": "A"
18 |             },
19 |             "type": null,
20 |             "declarationLine": "namespace A \\ B;",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         }
24 |     }
25 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces7.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace {
3 | 
4 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces7.php.expected.json:
--------------------------------------------------------------------------------
1 | {
2 |     "references": [],
3 |     "definitions": []
4 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces8.php:
--------------------------------------------------------------------------------
1 | <?php
2 | declare(strict_types = 1);
3 | 
4 | namespace LanguageServer\Tests\Utils;
5 | 
6 | use function LanguageServer\{pathToUri, uriToPath};


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces8.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "LanguageServer": [
 4 |             "./namespaces8.php"
 5 |         ],
 6 |         "LanguageServer\\pathToUri()": [
 7 |             "./namespaces8.php"
 8 |         ],
 9 |         "LanguageServer\\uriToPath()": [
10 |             "./namespaces8.php"
11 |         ]
12 |     },
13 |     "definitions": {
14 |         "LanguageServer\\Tests\\Utils": {
15 |             "fqn": "LanguageServer\\Tests\\Utils",
16 |             "extends": [],
17 |             "isMember": false,
18 |             "roamed": false,
19 |             "isStatic": false,
20 |             "canBeInstantiated": false,
21 |             "symbolInformation": {
22 |                 "name": "LanguageServer\\Tests\\Utils",
23 |                 "kind": 3,
24 |                 "location": {
25 |                     "uri": "./namespaces8.php"
26 |                 },
27 |                 "containerName": "LanguageServer\\Tests"
28 |             },
29 |             "type": null,
30 |             "declarationLine": "namespace LanguageServer\\Tests\\Utils;",
31 |             "documentation": null,
32 |             "signatureInformation": null
33 |         }
34 |     }
35 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces9.php:
--------------------------------------------------------------------------------
1 | <?php
2 | declare(strict_types = 1);
3 | 
4 | namespace {
5 | 
6 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/namespaces9.php.expected.json:
--------------------------------------------------------------------------------
1 | {
2 |     "references": [],
3 |     "definitions": []
4 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/newStatic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class NewStatic {
 4 |     public static function main()
 5 |     {
 6 |         $command = new static;
 7 |         return $command->foo();
 8 |     }
 9 | 
10 |     private function foo() {
11 |     }
12 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/newStatic.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "static": [
 4 |             "\/Users\/roblou\/code\/php-language-server\/tests\/Validation\/..\/..\/validation\/frameworks\/_cases\/newStatic.php"
 5 |         ],
 6 |         "NewStatic->foo()": [
 7 |             "\/Users\/roblou\/code\/php-language-server\/tests\/Validation\/..\/..\/validation\/frameworks\/_cases\/newStatic.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "NewStatic": {
12 |             "extends": [],
13 |             "isGlobal": true,
14 |             "isStatic": false,
15 |             "canBeInstantiated": true,
16 |             "symbolInformation": {
17 |                 "name": "NewStatic",
18 |                 "kind": 5,
19 |                 "location": {
20 |                     "uri": "\/Users\/roblou\/code\/php-language-server\/tests\/Validation\/..\/..\/validation\/frameworks\/_cases\/newStatic.php"
21 |                 },
22 |                 "containerName": ""
23 |             },
24 |             "type__class": "LanguageServer\\Tests\\ValidationTest",
25 |             "type": null,
26 |             "documentation": null
27 |         },
28 |         "NewStatic::main()": {
29 |             "extends": [],
30 |             "isGlobal": false,
31 |             "isStatic": true,
32 |             "canBeInstantiated": false,
33 |             "symbolInformation": {
34 |                 "name": "main",
35 |                 "kind": 6,
36 |                 "location": {
37 |                     "uri": "\/Users\/roblou\/code\/php-language-server\/tests\/Validation\/..\/..\/validation\/frameworks\/_cases\/newStatic.php"
38 |                 },
39 |                 "containerName": "NewStatic"
40 |             },
41 |             "type__class": "phpDocumentor\\Reflection\\Types\\Mixed",
42 |             "type": {},
43 |             "documentation": null
44 |         },
45 |         "NewStatic->foo()": {
46 |             "extends": [],
47 |             "isGlobal": false,
48 |             "isStatic": false,
49 |             "canBeInstantiated": false,
50 |             "symbolInformation": {
51 |                 "name": "foo",
52 |                 "kind": 6,
53 |                 "location": {
54 |                     "uri": "\/Users\/roblou\/code\/php-language-server\/tests\/Validation\/..\/..\/validation\/frameworks\/_cases\/newStatic.php"
55 |                 },
56 |                 "containerName": "NewStatic"
57 |             },
58 |             "type__class": "phpDocumentor\\Reflection\\Types\\Mixed",
59 |             "type": {},
60 |             "documentation": null
61 |         }
62 |     }
63 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/objectCreation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A {
 6 |     function a () {
 7 |         $a = new $this->inline_diff_renderer;
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/objectCreation.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\A->inline_diff_renderer": [
 4 |             "./objectCreation.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./objectCreation.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "MyNamespace\\A": {
29 |             "fqn": "MyNamespace\\A",
30 |             "extends": [],
31 |             "isMember": false,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": true,
35 |             "symbolInformation": {
36 |                 "name": "A",
37 |                 "kind": 5,
38 |                 "location": {
39 |                     "uri": "./objectCreation.php"
40 |                 },
41 |                 "containerName": "MyNamespace"
42 |             },
43 |             "type": null,
44 |             "declarationLine": "class A {",
45 |             "documentation": null,
46 |             "signatureInformation": null
47 |         },
48 |         "MyNamespace\\A->a()": {
49 |             "fqn": "MyNamespace\\A->a()",
50 |             "extends": [],
51 |             "isMember": true,
52 |             "roamed": false,
53 |             "isStatic": false,
54 |             "canBeInstantiated": false,
55 |             "symbolInformation": {
56 |                 "name": "a",
57 |                 "kind": 6,
58 |                 "location": {
59 |                     "uri": "./objectCreation.php"
60 |                 },
61 |                 "containerName": "MyNamespace\\A"
62 |             },
63 |             "type__tostring": "mixed",
64 |             "type": {},
65 |             "declarationLine": "function a ()",
66 |             "documentation": null,
67 |             "signatureInformation": {
68 |                 "label": "()",
69 |                 "parameters": []
70 |             }
71 |         }
72 |     }
73 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/objectCreation2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | class B {
 5 | 
 6 | }
 7 | 
 8 | class A {
 9 |     function a () {
10 |         $a = (new B)->hi();
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/objectCreation3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class A {
 4 |     function a () {
 5 |         $client->textDocument = new class($this->args)
 6 |         {
 7 |         };
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/objectCreation3.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "A->args": [
 4 |             "./objectCreation3.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "A": {
 9 |             "fqn": "A",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": true,
15 |             "symbolInformation": {
16 |                 "name": "A",
17 |                 "kind": 5,
18 |                 "location": {
19 |                     "uri": "./objectCreation3.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "class A {",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "A->a()": {
29 |             "fqn": "A->a()",
30 |             "extends": [],
31 |             "isMember": true,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": false,
35 |             "symbolInformation": {
36 |                 "name": "a",
37 |                 "kind": 6,
38 |                 "location": {
39 |                     "uri": "./objectCreation3.php"
40 |                 },
41 |                 "containerName": "A"
42 |             },
43 |             "type__tostring": "mixed",
44 |             "type": {},
45 |             "declarationLine": "function a ()",
46 |             "documentation": null,
47 |             "signatureInformation": {
48 |                 "label": "()",
49 |                 "parameters": []
50 |             }
51 |         }
52 |     }
53 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/param1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | function init(Hi $view)
5 | {
6 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/param1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\Hi": [
 4 |             "./param1.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./param1.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "MyNamespace\\init()": {
29 |             "fqn": "MyNamespace\\init()",
30 |             "extends": [],
31 |             "isMember": false,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": false,
35 |             "symbolInformation": {
36 |                 "name": "init",
37 |                 "kind": 12,
38 |                 "location": {
39 |                     "uri": "./param1.php"
40 |                 },
41 |                 "containerName": "MyNamespace"
42 |             },
43 |             "type__tostring": "mixed",
44 |             "type": {},
45 |             "declarationLine": "function init(Hi $view)",
46 |             "documentation": null,
47 |             "signatureInformation": {
48 |                 "label": "(\\MyNamespace\\Hi $view)",
49 |                 "parameters": [
50 |                     {
51 |                         "label": "\\MyNamespace\\Hi $view"
52 |                     }
53 |                 ]
54 |             }
55 |         }
56 |     }
57 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/parameterTypeResolution1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class ParamType {
 4 |     public function setAccount(ParamType $account)
 5 |     {
 6 |         // If the passed account is already proxied, use the actual account instead
 7 |         // to prevent loops.
 8 |         if ($account instanceof static) {
 9 |             $account = $account->getAccount();
10 |         }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/parameterTypeResolution1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "ParamType": [
 4 |             "./_cases/parameterTypeResolution1.php"
 5 |         ],
 6 |         "static": [
 7 |             "./_cases/parameterTypeResolution1.php"
 8 |         ],
 9 |         "ParamType->getAccount()": [
10 |             "./_cases/parameterTypeResolution1.php"
11 |         ]
12 |     },
13 |     "definitions": {
14 |         "ParamType": {
15 |             "extends": [],
16 |             "isGlobal": true,
17 |             "isStatic": false,
18 |             "canBeInstantiated": true,
19 |             "symbolInformation": {
20 |                 "name": "ParamType",
21 |                 "kind": 5,
22 |                 "location": {
23 |                     "uri": "./_cases/parameterTypeResolution1.php"
24 |                 },
25 |                 "containerName": ""
26 |             },
27 |             "type__class": "LanguageServer\\Tests\\ValidationTest",
28 |             "type": null,
29 |             "documentation": null
30 |         },
31 |         "ParamType->setAccount()": {
32 |             "extends": [],
33 |             "isGlobal": false,
34 |             "isStatic": false,
35 |             "canBeInstantiated": false,
36 |             "symbolInformation": {
37 |                 "name": "setAccount",
38 |                 "kind": 6,
39 |                 "location": {
40 |                     "uri": "./_cases/parameterTypeResolution1.php"
41 |                 },
42 |                 "containerName": "ParamType"
43 |             },
44 |             "type__class": "phpDocumentor\\Reflection\\Types\\Mixed",
45 |             "type": {},
46 |             "documentation": null
47 |         },
48 |         "ParamType->getAccount()": {
49 |             "extends": [],
50 |             "isGlobal": false,
51 |             "isStatic": false,
52 |             "canBeInstantiated": false,
53 |             "symbolInformation": {
54 |                 "name": "getAccount",
55 |                 "kind": 6,
56 |                 "location": {
57 |                     "uri": "./_cases/parameterTypeResolution1.php"
58 |                 },
59 |                 "containerName": "ParamType"
60 |             },
61 |             "type__class": "phpDocumentor\\Reflection\\Types\\Mixed",
62 |             "type": {},
63 |             "documentation": null
64 |         }
65 |     }
66 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/parent1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = parent::b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/parent2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = PARENT::b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/parent3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = parent->b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/promotedConstructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace TestNamespace8;
 4 | 
 5 | class PromotedProperties {
 6 | 
 7 |     public function __construct(
 8 |         public $untyped,
 9 |         public string $name = 'Damjan',
10 |     ) {}
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/propertyName1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class MyClass
 4 | {
 5 | 
 6 |     /**
 7 |      * The name of the main property, or NULL if there is none.
 8 |      *
 9 |      * @var string
10 |      */
11 |     protected $mainPropertyName = NULL;
12 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/propertyName1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "MyClass": {
 5 |             "fqn": "MyClass",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": true,
11 |             "symbolInformation": {
12 |                 "name": "MyClass",
13 |                 "kind": 5,
14 |                 "location": {
15 |                     "uri": "./propertyName1.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type": null,
20 |             "declarationLine": "class MyClass",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         },
24 |         "MyClass->mainPropertyName": {
25 |             "fqn": "MyClass->mainPropertyName",
26 |             "extends": [],
27 |             "isMember": true,
28 |             "roamed": false,
29 |             "isStatic": false,
30 |             "canBeInstantiated": false,
31 |             "symbolInformation": {
32 |                 "name": "mainPropertyName",
33 |                 "kind": 7,
34 |                 "location": {
35 |                     "uri": "./propertyName1.php"
36 |                 },
37 |                 "containerName": "MyClass"
38 |             },
39 |             "type__tostring": "string",
40 |             "type": {},
41 |             "declarationLine": "protected $mainPropertyName;",
42 |             "documentation": "The name of the main property, or NULL if there is none.",
43 |             "signatureInformation": null
44 |         }
45 |     }
46 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/propertyName2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class MyClass
 4 | {
 5 | 
 6 |     /**
 7 |      * The name of the main property, or NULL if there is none.
 8 |      */
 9 |     protected $mainPropertyName = 'hello';
10 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/propertyName2.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": [],
 3 |     "definitions": {
 4 |         "MyClass": {
 5 |             "fqn": "MyClass",
 6 |             "extends": [],
 7 |             "isMember": false,
 8 |             "roamed": false,
 9 |             "isStatic": false,
10 |             "canBeInstantiated": true,
11 |             "symbolInformation": {
12 |                 "name": "MyClass",
13 |                 "kind": 5,
14 |                 "location": {
15 |                     "uri": "./propertyName2.php"
16 |                 },
17 |                 "containerName": ""
18 |             },
19 |             "type": null,
20 |             "declarationLine": "class MyClass",
21 |             "documentation": null,
22 |             "signatureInformation": null
23 |         },
24 |         "MyClass->mainPropertyName": {
25 |             "fqn": "MyClass->mainPropertyName",
26 |             "extends": [],
27 |             "isMember": true,
28 |             "roamed": false,
29 |             "isStatic": false,
30 |             "canBeInstantiated": false,
31 |             "symbolInformation": {
32 |                 "name": "mainPropertyName",
33 |                 "kind": 7,
34 |                 "location": {
35 |                     "uri": "./propertyName2.php"
36 |                 },
37 |                 "containerName": "MyClass"
38 |             },
39 |             "type__tostring": "string",
40 |             "type": {},
41 |             "declarationLine": "protected $mainPropertyName;",
42 |             "documentation": "The name of the main property, or NULL if there is none.",
43 |             "signatureInformation": null
44 |         }
45 |     }
46 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/returnType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace TestNamespace;
 4 | 
 5 | /**
 6 |  * Aute duis elit reprehenderit tempor cillum proident anim laborum eu laboris reprehenderit ea incididunt.
 7 |  *
 8 |  * @param TestClass $param Adipisicing non non cillum sint incididunt cillum enim mollit.
 9 |  * @return TestClass
10 |  */
11 | function whatever(TestClass $param): TestClass2 {
12 |     echo $param;
13 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/returnType.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "TestNamespace\\TestClass": [
 4 |             "./returnType.php"
 5 |         ],
 6 |         "TestNamespace\\TestClass2": [
 7 |             "./returnType.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "TestNamespace": {
12 |             "fqn": "TestNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "TestNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./returnType.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace TestNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "TestNamespace\\whatever()": {
32 |             "fqn": "TestNamespace\\whatever()",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": false,
38 |             "symbolInformation": {
39 |                 "name": "whatever",
40 |                 "kind": 12,
41 |                 "location": {
42 |                     "uri": "./returnType.php"
43 |                 },
44 |                 "containerName": "TestNamespace"
45 |             },
46 |             "type__tostring": "\\TestNamespace\\TestClass",
47 |             "type": {},
48 |             "declarationLine": "function whatever(TestClass $param): TestClass2",
49 |             "documentation": "Aute duis elit reprehenderit tempor cillum proident anim laborum eu laboris reprehenderit ea incididunt.",
50 |             "signatureInformation": {
51 |                 "label": "(\\TestNamespace\\TestClass $param)",
52 |                 "documentation": "Aute duis elit reprehenderit tempor cillum proident anim laborum eu laboris reprehenderit ea incididunt.",
53 |                 "parameters": [
54 |                     {
55 |                         "label": "\\TestNamespace\\TestClass $param",
56 |                         "documentation": "Adipisicing non non cillum sint incididunt cillum enim mollit."
57 |                     }
58 |                 ]
59 |             }
60 |         }
61 |     }
62 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A {
 6 |     static function a() {
 7 |         $a = A::a();
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\A::a()": [
 4 |             "./scopedPropertyAccess.php"
 5 |         ],
 6 |         "MyNamespace\\A": [
 7 |             "./scopedPropertyAccess.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./scopedPropertyAccess.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [],
34 |             "isMember": false,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": true,
38 |             "symbolInformation": {
39 |                 "name": "A",
40 |                 "kind": 5,
41 |                 "location": {
42 |                     "uri": "./scopedPropertyAccess.php"
43 |                 },
44 |                 "containerName": "MyNamespace"
45 |             },
46 |             "type": null,
47 |             "declarationLine": "class A {",
48 |             "documentation": null,
49 |             "signatureInformation": null
50 |         },
51 |         "MyNamespace\\A::a()": {
52 |             "fqn": "MyNamespace\\A::a()",
53 |             "extends": [],
54 |             "isMember": true,
55 |             "roamed": false,
56 |             "isStatic": true,
57 |             "canBeInstantiated": false,
58 |             "symbolInformation": {
59 |                 "name": "a",
60 |                 "kind": 6,
61 |                 "location": {
62 |                     "uri": "./scopedPropertyAccess.php"
63 |                 },
64 |                 "containerName": "MyNamespace\\A"
65 |             },
66 |             "type__tostring": "mixed",
67 |             "type": {},
68 |             "declarationLine": "static function a()",
69 |             "documentation": null,
70 |             "signatureInformation": {
71 |                 "label": "()",
72 |                 "parameters": []
73 |             }
74 |         }
75 |     }
76 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess2.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | 
5 | $process = new A;
6 | array($process::OUT, '123');


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess2.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\A": [
 4 |             "./scopedPropertyAccess2.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./scopedPropertyAccess2.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         }
28 |     }
29 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess3.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class A {
4 |     static $a = "hello";
5 | }
6 | echo A::$a;
7 | 
8 | $a = new


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess3.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "A": [
 4 |             "./scopedPropertyAccess3.php"
 5 |         ],
 6 |         "A::$a": [
 7 |             "./scopedPropertyAccess3.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "A": {
12 |             "fqn": "A",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": true,
18 |             "symbolInformation": {
19 |                 "name": "A",
20 |                 "kind": 5,
21 |                 "location": {
22 |                     "uri": "./scopedPropertyAccess3.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "class A {",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "A::$a": {
32 |             "fqn": "A::$a",
33 |             "extends": [],
34 |             "isMember": true,
35 |             "roamed": false,
36 |             "isStatic": true,
37 |             "canBeInstantiated": false,
38 |             "symbolInformation": {
39 |                 "name": "a",
40 |                 "kind": 7,
41 |                 "location": {
42 |                     "uri": "./scopedPropertyAccess3.php"
43 |                 },
44 |                 "containerName": "A"
45 |             },
46 |             "type__tostring": "string",
47 |             "type": {},
48 |             "declarationLine": "static $a;",
49 |             "documentation": null,
50 |             "signatureInformation": null
51 |         }
52 |     }
53 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess4.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | A::$a();


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess4.php.expected.json:
--------------------------------------------------------------------------------
1 | {
2 |     "references": {
3 |         "A": [
4 |             "./scopedPropertyAccess4.php"
5 |         ]
6 |     },
7 |     "definitions": []
8 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess5.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class TestClass implements TestInterface {
 4 |     /**
 5 |      * Lorem excepteur officia sit anim velit veniam enim.
 6 |      *
 7 |      * @var TestClass[]
 8 |      */
 9 |     public static $testProperty;
10 | }
11 | 
12 | echo TestClass::$testProperty;
13 | echo TestClass::$staticTestProperty[123]->testProperty;


--------------------------------------------------------------------------------
/tests/Validation/cases/scopedPropertyAccess5.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "TestInterface": [
 4 |             "./scopedPropertyAccess5.php"
 5 |         ],
 6 |         "TestClass": [
 7 |             "./scopedPropertyAccess5.php"
 8 |         ],
 9 |         "TestClass::$testProperty": [
10 |             "./scopedPropertyAccess5.php"
11 |         ],
12 |         "TestClass::$staticTestProperty": [
13 |             "./scopedPropertyAccess5.php"
14 |         ]
15 |     },
16 |     "definitions": {
17 |         "TestClass": {
18 |             "fqn": "TestClass",
19 |             "extends": [],
20 |             "isMember": false,
21 |             "roamed": false,
22 |             "isStatic": false,
23 |             "canBeInstantiated": true,
24 |             "symbolInformation": {
25 |                 "name": "TestClass",
26 |                 "kind": 5,
27 |                 "location": {
28 |                     "uri": "./scopedPropertyAccess5.php"
29 |                 },
30 |                 "containerName": ""
31 |             },
32 |             "type": null,
33 |             "declarationLine": "class TestClass implements TestInterface {",
34 |             "documentation": null,
35 |             "signatureInformation": null
36 |         },
37 |         "TestClass::$testProperty": {
38 |             "fqn": "TestClass::$testProperty",
39 |             "extends": [],
40 |             "isMember": true,
41 |             "roamed": false,
42 |             "isStatic": true,
43 |             "canBeInstantiated": false,
44 |             "symbolInformation": {
45 |                 "name": "testProperty",
46 |                 "kind": 7,
47 |                 "location": {
48 |                     "uri": "./scopedPropertyAccess5.php"
49 |                 },
50 |                 "containerName": "TestClass"
51 |             },
52 |             "type__tostring": "\\TestClass[]",
53 |             "type": {},
54 |             "declarationLine": "public static $testProperty;",
55 |             "documentation": "Lorem excepteur officia sit anim velit veniam enim.",
56 |             "signatureInformation": null
57 |         }
58 |     }
59 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/self1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         // TODO - should 'self' be included in references?
14 |         $a = self::b();
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/self2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = SELF::b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/self3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = self->b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/self4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A
 6 | {
 7 |     public static function suite()
 8 |     {
 9 |         $suite = new self('Database related tests');
10 |         $suite->addTestFile(__DIR__ . DS . 'Database' . DS . 'ConnectionTest.php');
11 | 
12 |     }
13 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/self5.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A
 6 | {
 7 |     public function typesProvider()
 8 |     {
 9 |         $self = $this;
10 |         $self->assertTrue("HI");
11 |     }
12 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/self5.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\A->assertTrue()": [
 4 |             "./self5.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./self5.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "MyNamespace\\A": {
29 |             "fqn": "MyNamespace\\A",
30 |             "extends": [],
31 |             "isMember": false,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": true,
35 |             "symbolInformation": {
36 |                 "name": "A",
37 |                 "kind": 5,
38 |                 "location": {
39 |                     "uri": "./self5.php"
40 |                 },
41 |                 "containerName": "MyNamespace"
42 |             },
43 |             "type": null,
44 |             "declarationLine": "class A",
45 |             "documentation": null,
46 |             "signatureInformation": null
47 |         },
48 |         "MyNamespace\\A->typesProvider()": {
49 |             "fqn": "MyNamespace\\A->typesProvider()",
50 |             "extends": [],
51 |             "isMember": true,
52 |             "roamed": false,
53 |             "isStatic": false,
54 |             "canBeInstantiated": false,
55 |             "symbolInformation": {
56 |                 "name": "typesProvider",
57 |                 "kind": 6,
58 |                 "location": {
59 |                     "uri": "./self5.php"
60 |                 },
61 |                 "containerName": "MyNamespace\\A"
62 |             },
63 |             "type__tostring": "mixed",
64 |             "type": {},
65 |             "declarationLine": "public function typesProvider()",
66 |             "documentation": null,
67 |             "signatureInformation": {
68 |                 "label": "()",
69 |                 "parameters": []
70 |             }
71 |         }
72 |     }
73 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/static1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = static::b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/static2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = STATIC::b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/static3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class B {
 6 |     function b() {
 7 | 
 8 |     }
 9 | }
10 | 
11 | class A extends B {
12 |     function a () {
13 |         $a = static->b();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/static4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class A extends B {
 6 |     function a () {
 7 |         $a = new static();
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/static4.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\B": [
 4 |             "./static4.php"
 5 |         ],
 6 |         "MyNamespace\\A": [
 7 |             "./static4.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./static4.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\A": {
32 |             "fqn": "MyNamespace\\A",
33 |             "extends": [
34 |                 "MyNamespace\\B"
35 |             ],
36 |             "isMember": false,
37 |             "roamed": false,
38 |             "isStatic": false,
39 |             "canBeInstantiated": true,
40 |             "symbolInformation": {
41 |                 "name": "A",
42 |                 "kind": 5,
43 |                 "location": {
44 |                     "uri": "./static4.php"
45 |                 },
46 |                 "containerName": "MyNamespace"
47 |             },
48 |             "type": null,
49 |             "declarationLine": "class A extends B {",
50 |             "documentation": null,
51 |             "signatureInformation": null
52 |         },
53 |         "MyNamespace\\A->a()": {
54 |             "fqn": "MyNamespace\\A->a()",
55 |             "extends": [],
56 |             "isMember": true,
57 |             "roamed": false,
58 |             "isStatic": false,
59 |             "canBeInstantiated": false,
60 |             "symbolInformation": {
61 |                 "name": "a",
62 |                 "kind": 6,
63 |                 "location": {
64 |                     "uri": "./static4.php"
65 |                 },
66 |                 "containerName": "MyNamespace\\A"
67 |             },
68 |             "type__tostring": "mixed",
69 |             "type": {},
70 |             "declarationLine": "function a ()",
71 |             "documentation": null,
72 |             "signatureInformation": {
73 |                 "label": "()",
74 |                 "parameters": []
75 |             }
76 |         }
77 |     }
78 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/staticInArray.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $expectedOutput = array(
4 |     array($process::OUT, '123'),
5 | );


--------------------------------------------------------------------------------
/tests/Validation/cases/staticInArray.php.expected.json:
--------------------------------------------------------------------------------
1 | {
2 |     "references": [],
3 |     "definitions": []
4 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/staticMethodReturnType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class FooClass {
 4 |     public static function staticFoo(): FooClass {
 5 |         return new FooClass();
 6 |     }
 7 | 
 8 |     public static function staticSelf(): self { }
 9 | 
10 |     public function bar() { }
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/stringVariable.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class B
4 | {
5 |     public $hi = 3;
6 |     function a () {
7 |         echo "$this->hi";
8 |     }
9 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/stringVariable.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "B->hi": [
 4 |             "./stringVariable.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "B": {
 9 |             "fqn": "B",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": true,
15 |             "symbolInformation": {
16 |                 "name": "B",
17 |                 "kind": 5,
18 |                 "location": {
19 |                     "uri": "./stringVariable.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "class B",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "B->hi": {
29 |             "fqn": "B->hi",
30 |             "extends": [],
31 |             "isMember": true,
32 |             "roamed": false,
33 |             "isStatic": false,
34 |             "canBeInstantiated": false,
35 |             "symbolInformation": {
36 |                 "name": "hi",
37 |                 "kind": 7,
38 |                 "location": {
39 |                     "uri": "./stringVariable.php"
40 |                 },
41 |                 "containerName": "B"
42 |             },
43 |             "type__tostring": "int",
44 |             "type": {},
45 |             "declarationLine": "public $hi;",
46 |             "documentation": null,
47 |             "signatureInformation": null
48 |         },
49 |         "B->a()": {
50 |             "fqn": "B->a()",
51 |             "extends": [],
52 |             "isMember": true,
53 |             "roamed": false,
54 |             "isStatic": false,
55 |             "canBeInstantiated": false,
56 |             "symbolInformation": {
57 |                 "name": "a",
58 |                 "kind": 6,
59 |                 "location": {
60 |                     "uri": "./stringVariable.php"
61 |                 },
62 |                 "containerName": "B"
63 |             },
64 |             "type__tostring": "mixed",
65 |             "type": {},
66 |             "declarationLine": "function a ()",
67 |             "documentation": null,
68 |             "signatureInformation": {
69 |                 "label": "()",
70 |                 "parameters": []
71 |             }
72 |         }
73 |     }
74 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/testQualifiedNameOutsideOfNamespace.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace SomeNamespace { }
4 | 
5 | NameOutsideOfNamespace;


--------------------------------------------------------------------------------
/tests/Validation/cases/testQualifiedNameOutsideOfNamespace.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "NameOutsideOfNamespace": [
 4 |             "./testQualifiedNameOutsideOfNamespace.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "SomeNamespace": {
 9 |             "fqn": "SomeNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "SomeNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./testQualifiedNameOutsideOfNamespace.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace SomeNamespace { }",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         }
28 |     }
29 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/trait1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | class TestClass {
4 |     use TestTrait;
5 | }
6 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/trait1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "TestTrait": [
 4 |             "./trait1.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "TestClass": {
 9 |             "fqn": "TestClass",
10 |             "extends": [
11 |                 "TestTrait"
12 |             ],
13 |             "isMember": false,
14 |             "roamed": false,
15 |             "isStatic": false,
16 |             "canBeInstantiated": true,
17 |             "symbolInformation": {
18 |                 "name": "TestClass",
19 |                 "kind": 5,
20 |                 "location": {
21 |                     "uri": "./trait1.php"
22 |                 },
23 |                 "containerName": ""
24 |             },
25 |             "type": null,
26 |             "declarationLine": "class TestClass {",
27 |             "documentation": null,
28 |             "signatureInformation": null
29 |         }
30 |     }
31 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/trait2.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | 
5 | class TestClass {
6 |     use TestTrait;
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/trait2.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "MyNamespace\\TestTrait": [
 4 |             "./trait2.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./trait2.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "MyNamespace\\TestClass": {
29 |             "fqn": "MyNamespace\\TestClass",
30 |             "extends": [
31 |                 "MyNamespace\\TestTrait"
32 |             ],
33 |             "isMember": false,
34 |             "roamed": false,
35 |             "isStatic": false,
36 |             "canBeInstantiated": true,
37 |             "symbolInformation": {
38 |                 "name": "TestClass",
39 |                 "kind": 5,
40 |                 "location": {
41 |                     "uri": "./trait2.php"
42 |                 },
43 |                 "containerName": "MyNamespace"
44 |             },
45 |             "type": null,
46 |             "declarationLine": "class TestClass {",
47 |             "documentation": null,
48 |             "signatureInformation": null
49 |         }
50 |     }
51 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/trait3.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace MyNamespace;
4 | 
5 | class TestClass {
6 |     use \OtherNamespace\TestTrait;
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/trait3.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "OtherNamespace\\TestTrait": [
 4 |             "./trait3.php"
 5 |         ]
 6 |     },
 7 |     "definitions": {
 8 |         "MyNamespace": {
 9 |             "fqn": "MyNamespace",
10 |             "extends": [],
11 |             "isMember": false,
12 |             "roamed": false,
13 |             "isStatic": false,
14 |             "canBeInstantiated": false,
15 |             "symbolInformation": {
16 |                 "name": "MyNamespace",
17 |                 "kind": 3,
18 |                 "location": {
19 |                     "uri": "./trait3.php"
20 |                 },
21 |                 "containerName": ""
22 |             },
23 |             "type": null,
24 |             "declarationLine": "namespace MyNamespace;",
25 |             "documentation": null,
26 |             "signatureInformation": null
27 |         },
28 |         "MyNamespace\\TestClass": {
29 |             "fqn": "MyNamespace\\TestClass",
30 |             "extends": [
31 |                 "OtherNamespace\\TestTrait"
32 |             ],
33 |             "isMember": false,
34 |             "roamed": false,
35 |             "isStatic": false,
36 |             "canBeInstantiated": true,
37 |             "symbolInformation": {
38 |                 "name": "TestClass",
39 |                 "kind": 5,
40 |                 "location": {
41 |                     "uri": "./trait3.php"
42 |                 },
43 |                 "containerName": "MyNamespace"
44 |             },
45 |             "type": null,
46 |             "declarationLine": "class TestClass {",
47 |             "documentation": null,
48 |             "signatureInformation": null
49 |         }
50 |     }
51 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/trait4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | use \ThirdNamespace\TestTrait;
 6 | 
 7 | class TestClass {
 8 |     use TestTrait;
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/trait4.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "ThirdNamespace\\TestTrait": [
 4 |             "./trait4.php"
 5 |         ],
 6 |         "ThirdNamespace": [
 7 |             "./trait4.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "MyNamespace": {
12 |             "fqn": "MyNamespace",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": false,
18 |             "symbolInformation": {
19 |                 "name": "MyNamespace",
20 |                 "kind": 3,
21 |                 "location": {
22 |                     "uri": "./trait4.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "namespace MyNamespace;",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "MyNamespace\\TestClass": {
32 |             "fqn": "MyNamespace\\TestClass",
33 |             "extends": [
34 |                 "ThirdNamespace\\TestTrait"
35 |             ],
36 |             "isMember": false,
37 |             "roamed": false,
38 |             "isStatic": false,
39 |             "canBeInstantiated": true,
40 |             "symbolInformation": {
41 |                 "name": "TestClass",
42 |                 "kind": 5,
43 |                 "location": {
44 |                     "uri": "./trait4.php"
45 |                 },
46 |                 "containerName": "MyNamespace"
47 |             },
48 |             "type": null,
49 |             "declarationLine": "class TestClass {",
50 |             "documentation": null,
51 |             "signatureInformation": null
52 |         }
53 |     }
54 | }


--------------------------------------------------------------------------------
/tests/Validation/cases/verifyFqsenOnClassProperty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Foo {
 4 |     protected $bar = CURLAUTH_BASIC;
 5 | 
 6 |     public function foo () {
 7 |         $this->bar = 'hello';
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases/verifyFqsenOnClassProperty.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "CURLAUTH_BASIC": [
 4 |             "./verifyFqsenOnClassProperty.php"
 5 |         ],
 6 |         "Foo->bar": [
 7 |             "./verifyFqsenOnClassProperty.php"
 8 |         ]
 9 |     },
10 |     "definitions": {
11 |         "Foo": {
12 |             "fqn": "Foo",
13 |             "extends": [],
14 |             "isMember": false,
15 |             "roamed": false,
16 |             "isStatic": false,
17 |             "canBeInstantiated": true,
18 |             "symbolInformation": {
19 |                 "name": "Foo",
20 |                 "kind": 5,
21 |                 "location": {
22 |                     "uri": "./verifyFqsenOnClassProperty.php"
23 |                 },
24 |                 "containerName": ""
25 |             },
26 |             "type": null,
27 |             "declarationLine": "class Foo {",
28 |             "documentation": null,
29 |             "signatureInformation": null
30 |         },
31 |         "Foo->bar": {
32 |             "fqn": "Foo->bar",
33 |             "extends": [],
34 |             "isMember": true,
35 |             "roamed": false,
36 |             "isStatic": false,
37 |             "canBeInstantiated": false,
38 |             "symbolInformation": {
39 |                 "name": "bar",
40 |                 "kind": 7,
41 |                 "location": {
42 |                     "uri": "./verifyFqsenOnClassProperty.php"
43 |                 },
44 |                 "containerName": "Foo"
45 |             },
46 |             "type__tostring": "\\",
47 |             "type": {},
48 |             "declarationLine": "protected $bar;",
49 |             "documentation": null,
50 |             "signatureInformation": null
51 |         },
52 |         "Foo->foo()": {
53 |             "fqn": "Foo->foo()",
54 |             "extends": [],
55 |             "isMember": true,
56 |             "roamed": false,
57 |             "isStatic": false,
58 |             "canBeInstantiated": false,
59 |             "symbolInformation": {
60 |                 "name": "foo",
61 |                 "kind": 6,
62 |                 "location": {
63 |                     "uri": "./verifyFqsenOnClassProperty.php"
64 |                 },
65 |                 "containerName": "Foo"
66 |             },
67 |             "type__tostring": "mixed",
68 |             "type": {},
69 |             "declarationLine": "public function foo ()",
70 |             "documentation": null,
71 |             "signatureInformation": {
72 |                 "label": "()",
73 |                 "parameters": []
74 |             }
75 |         }
76 |     }
77 | }


--------------------------------------------------------------------------------
/tests/Validation/cases81/enum1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | enum TestEnum : string
 6 | {
 7 |     case EnumCase1 = 'case1';
 8 |     case EnumCase2 = 'case2';
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases81/enum2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | enum Test2Enum : int
 6 | {
 7 |     case EnumCase1 = 1;
 8 |     case EnumCase2 = 2;
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases81/enum3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | enum Test3Enum
 6 | {
 7 |     case EnumCase1;
 8 |     case EnumCase2;
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Validation/cases82/dnfTypes1.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | function foo ((A&B)|C $x): (A&B)|C|(D&E) {}
4 | 


--------------------------------------------------------------------------------
/tests/Validation/cases82/dnfTypes1.php.expected.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "references": {
 3 |         "A": [
 4 |             ".82/dnfTypes1.php"
 5 |         ],
 6 |         "B": [
 7 |             ".82/dnfTypes1.php"
 8 |         ],
 9 |         "C": [
10 |             ".82/dnfTypes1.php"
11 |         ],
12 |         "D": [
13 |             ".82/dnfTypes1.php"
14 |         ],
15 |         "E": [
16 |             ".82/dnfTypes1.php"
17 |         ]
18 |     },
19 |     "definitions": {
20 |         "foo()": {
21 |             "fqn": "foo()",
22 |             "extends": [],
23 |             "isMember": false,
24 |             "roamed": true,
25 |             "isStatic": false,
26 |             "canBeInstantiated": false,
27 |             "symbolInformation": {
28 |                 "name": "foo",
29 |                 "kind": 12,
30 |                 "location": {
31 |                     "uri": ".82/dnfTypes1.php"
32 |                 },
33 |                 "containerName": ""
34 |             },
35 |             "type__tostring": "\\A&\\B|\\C|\\D&\\E",
36 |             "type": {},
37 |             "declarationLine": "function foo ((A&B)|C $x): (A&B)|C|(D&E)",
38 |             "documentation": null,
39 |             "signatureInformation": {
40 |                 "label": "(\\A&\\B|\\C $x)",
41 |                 "parameters": [
42 |                     {
43 |                         "label": "\\A&\\B|\\C $x"
44 |                     }
45 |                 ]
46 |             }
47 |         }
48 |     }
49 | }


--------------------------------------------------------------------------------
/tests/Validation/disabled.json:
--------------------------------------------------------------------------------
1 | [
2 |   "forLoopReference1.php",
3 |   "namespaces3.php",
4 |   "parameterTypeResolution1.php",
5 |   "parent2.php",
6 |   "newStatic.php"
7 | ]


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