diff --git a/.gitignore b/.gitignore index 3d7735a..3b33340 100755 --- a/.gitignore +++ b/.gitignore @@ -9,6 +9,9 @@ php/vendor test/demo/vendor test/demo/cache test/demo/reported.json +test/multi-config-demo/vendor +test/multi-config-demo/cache +test/multi-config-demo/reported.json test/scratchpad **/reported.json user_config.json diff --git a/client/src/lib/commands.ts b/client/src/lib/commands.ts index 927af62..494d6fc 100644 --- a/client/src/lib/commands.ts +++ b/client/src/lib/commands.ts @@ -55,9 +55,30 @@ export function registerListeners( context.subscriptions.push( autoRegisterCommand( Commands.SCAN_PROJECT, + async () => { + await client.sendNotification(watcherNotification, { + operation: 'checkAllProjects', + }); + }, + commands + ) + ); + context.subscriptions.push( + autoRegisterCommand( + Commands.SCAN_CURRENT_PROJECT, async () => { await client.sendNotification(watcherNotification, { operation: 'checkProject', + file: vscode.window.activeTextEditor + ? { + content: + vscode.window.activeTextEditor.document.getText(), + uri: vscode.window.activeTextEditor.document.uri.toString(), + languageId: + vscode.window.activeTextEditor.document + .languageId, + } + : null, }); }, commands diff --git a/client/src/lib/editorConfig.ts b/client/src/lib/editorConfig.ts index 36f6f60..c09cb2b 100644 --- a/client/src/lib/editorConfig.ts +++ b/client/src/lib/editorConfig.ts @@ -20,6 +20,9 @@ export function getReadonlyEditorConfiguration(): ConfigWithoutPrefix; return { ...configuration, + configFiles: configuration.configFile + ? [configuration.configFile] + : configuration.configFiles, }; } @@ -52,6 +55,7 @@ export function registerEditorConfigurationListener( await client.sendNotification(watcherNotification, { operation: 'onConfigChange', + file: null, }); if (e.affectsConfiguration('phpstan.paths')) { diff --git a/client/src/lib/setup.ts b/client/src/lib/setup.ts index 93a706e..6b05980 100644 --- a/client/src/lib/setup.ts +++ b/client/src/lib/setup.ts @@ -70,6 +70,13 @@ export async function launchSetup(client: LanguageClient): Promise { state[key], ConfigurationTarget.Workspace ); + if (key === 'configFiles') { + await writableConfig.update( + 'phpstan.configFile', + undefined, + ConfigurationTarget.Workspace + ); + } } }; @@ -274,14 +281,14 @@ abstract class SetupSteps { } return `File does not exist container at \`${filePath}\``; }, - value: this._state.configFile, + value: this._state.configFiles[0], ignoreFocusOut: true, buttons: [SHOW_FILE_PICKER_BUTTON], shouldValidateInitially, }); if (typeof choice === 'string') { - this._state.configFile = choice; + this._state.configFiles = [choice]; return next; } @@ -292,12 +299,14 @@ abstract class SetupSteps { title: 'Select config file', }); if (file) { - this._state.configFile = this._workspaceFolders - ? path.relative( - this._workspaceFolders.default.fsPath, - file[0].fsPath - ) - : file[0].fsPath; + this._state.configFiles = [ + this._workspaceFolders + ? path.relative( + this._workspaceFolders.default.fsPath, + file[0].fsPath + ) + : file[0].fsPath, + ]; } return (input) => this._configFileStep(input, next, true); } @@ -706,7 +715,7 @@ class DockerSetupSteps extends SetupSteps { this._localState.lastFoundDockerConfigFile = configFile; return undefined; }, - value: this._state.configFile, + value: this._state.configFiles[0], ignoreFocusOut: true, }); diff --git a/client/src/notificationSenders/documentManager.ts b/client/src/notificationSenders/documentManager.ts index f0c0ffc..865ff3b 100644 --- a/client/src/notificationSenders/documentManager.ts +++ b/client/src/notificationSenders/documentManager.ts @@ -26,12 +26,15 @@ export class DocumentManager implements Disposable { if (e.isDirty) { return false; } - const configFiles = getReadonlyEditorConfiguration() - .configFile.split(',') - .map((e) => e.trim()); - for (const configFile of configFiles) { - if (e.uri.fsPath.includes(configFile)) { - return true; + for (const configFileString of getReadonlyEditorConfiguration() + .configFiles) { + const configFiles = configFileString + .split(',') + .map((e) => e.trim()); + for (const configFile of configFiles) { + if (e.uri.fsPath.includes(configFile)) { + return true; + } } } return false; @@ -49,6 +52,7 @@ export class DocumentManager implements Disposable { if (this._isConfigFile(e)) { await this._client.sendNotification(watcherNotification, { operation: 'onConfigChange', + file: this._toSendData(e), }); } if (this._shouldSyncDocument(e)) { diff --git a/package.json b/package.json index f2bf852..11415fa 100755 --- a/package.json +++ b/package.json @@ -57,15 +57,35 @@ }, "description": "PHPStan command. Use this instead of \"binPath\" if, for example, the phpstan binary is in your path" }, - "phpstan.configFile": { - "type": "string", - "default": "phpstan.neon,phpstan.neon.dist,phpstan.dist.neon", - "examples": [ - "phpstan.neon", - "backend/phpstan.neon", - "phpstan.neon,phpstan.neon.dist" + "phpstan.configFiles": { + "type": "array", + "items": { + "type": "string", + "examples": [ + "phpstan.neon", + "backend/phpstan.neon", + "phpstan.neon,phpstan.neon.dist" + ] + }, + "default": [ + "phpstan.neon,phpstan.neon.dist,phpstan.dist.neon" ], - "description": "Path to the config file (use a comma-separated list to resolve in order)" + "description": "Paths to all projects' config files (use a comma-separated list to resolve in order)", + "examples": [ + [ + "phpstan.neon" + ], + [ + "src/phpstan.neon", + "test/phpstan.neon" + ], + [ + "backend/phpstan.neon" + ], + [ + "phpstan.neon,phpstan.neon.dist" + ] + ] }, "phpstan.paths": { "type": "object", @@ -185,6 +205,10 @@ "command": "phpstan.scanProjectForErrors", "title": "Scan project for errors" }, + { + "command": "phpstan.scanCurrentProjectForErrors", + "title": "Scan current project for errors" + }, { "command": "phpstan.reload", "title": "Reload language server" @@ -213,6 +237,10 @@ "command": "cmd.phpstan.scanProjectForErrors", "title": "PHPStan: Scan project for errors" }, + { + "command": "cmd.phpstan.scanCurrentProjectForErrors", + "title": "PHPStan: Scan current project for errors" + }, { "command": "cmd.phpstan.reload", "title": "PHPStan: Reload language server" @@ -244,6 +272,10 @@ "command": "phpstan.scanProjectForErrors", "when": "false" }, + { + "command": "phpstan.scanCurrentProjectForErrors", + "when": "false" + }, { "command": "phpstan.reload", "when": "false" @@ -272,6 +304,10 @@ "command": "cmd.phpstan.scanProjectForErrors", "when": "true" }, + { + "command": "cmd.phpstan.scanCurrentProjectForErrors", + "when": "true" + }, { "command": "cmd.phpstan.reload", "when": "true" diff --git a/server/src/lib/checkConfigManager.ts b/server/src/lib/checkConfigManager.ts index dd87403..701d6e6 100644 --- a/server/src/lib/checkConfigManager.ts +++ b/server/src/lib/checkConfigManager.ts @@ -1,7 +1,9 @@ import { execute, getConfigFile, getPathMapper } from '../../../shared/util'; import { getEditorConfiguration } from './editorConfig'; -import { showErrorOnce } from './errorUtil'; +import { showError, showErrorOnce } from './errorUtil'; +import { isInPaths } from '../../../shared/neon'; import type { ClassConfig } from './types'; +import type { URI } from 'vscode-uri'; import * as fs from 'fs/promises'; import { constants } from 'fs'; import * as path from 'path'; @@ -15,7 +17,7 @@ export interface CheckConfig { args: string[]; memoryLimit: string; tmpDir: string | undefined; - operation: 'analyse' | 'diagnose'; + operation: 'analyse'; } export class ConfigurationManager { @@ -91,24 +93,43 @@ export class ConfigurationManager { private static async _getConfigFile( classConfig: ClassConfig, - cwd: string + cwd: string, + currentFile: URI | null ): Promise { const extensionConfig = await getEditorConfiguration(classConfig); - const absoluteConfigPath = await getConfigFile( - extensionConfig.configFile, - cwd - ); - if (!absoluteConfigPath) { - // Config file was set but not found - if (extensionConfig.configFile) { + + for (const configFile of extensionConfig.configFiles) { + const absoluteConfigPath = await getConfigFile(configFile, cwd); + if (!absoluteConfigPath) { + // Config file was set but not found await showErrorOnce( classConfig.connection, - `PHPStan: failed to find config file in "${extensionConfig.configFile}"` + `PHPStan: failed to find config file in "${configFile}"` ); + return null; + } + + if (extensionConfig.configFiles.length > 1) { + if (!currentFile) { + showError( + classConfig.connection, + 'PHPStan: multiple config files provided but no file is open' + ); + return null; + } + + if ( + currentFile.fsPath === absoluteConfigPath || + (await isInPaths(currentFile.fsPath, absoluteConfigPath)) + ) { + return absoluteConfigPath; + } + } else { + return absoluteConfigPath; } } - return absoluteConfigPath; + return null; } public static async getCwd( @@ -211,7 +232,8 @@ export class ConfigurationManager { public static async collectConfiguration( classConfig: ClassConfig, - operation: 'analyse' | 'diagnose', + operation: 'analyse', + currentFile: URI | null, onError: null | ((error: string) => void) ): Promise { // Settings @@ -233,7 +255,11 @@ export class ConfigurationManager { } return null; } - const configFile = await this._getConfigFile(classConfig, cwd); + const configFile = await this._getConfigFile( + classConfig, + cwd, + currentFile + ); if (!configFile) { if (onError) { onError('Failed to find config file'); diff --git a/server/src/lib/documentManager.ts b/server/src/lib/documentManager.ts index e087c14..4284c69 100644 --- a/server/src/lib/documentManager.ts +++ b/server/src/lib/documentManager.ts @@ -2,6 +2,7 @@ import type { WatcherNotificationFileData } from '../../../shared/notificationCh import type { PHPStanCheckManager } from './phpstan/checkManager'; import type { PartialDocument } from './phpstan/processRunner'; import { watcherNotification } from './notificationChannels'; +import { OperationStatus } from '../../../shared/statusBar'; import type { AsyncDisposable, ClassConfig } from './types'; import { assertUnreachable } from '../../../shared/util'; import type { Disposable } from 'vscode-languageserver'; @@ -106,10 +107,18 @@ export class DocumentManager implements AsyncDisposable { void this._clearData(checkManager); return; case 'checkProject': - return this._onScanProject(checkManager); + return this._onScanCurrentProject( + checkManager, + data.file + ); + case 'checkAllProjects': + return this._onScanAllProjects(checkManager); case 'onConfigChange': { checkManager.clearCheckIfChangedCache(); - return this._onConfigChange(checkManager); + return this._onConfigChange( + checkManager, + data.file + ); } } @@ -180,7 +189,12 @@ export class DocumentManager implements AsyncDisposable { if (e.languageId !== 'php' || e.uri.endsWith('.git')) { return; } - await checkManager.checkWithDebounce(e, 'Document changed', null); + await checkManager.checkWithDebounce( + e, + URI.parse(e.uri), + 'Document changed', + null + ); } private async _onDocumentSave( @@ -194,7 +208,12 @@ export class DocumentManager implements AsyncDisposable { if (e.languageId !== 'php' || e.uri.endsWith('.git')) { return; } - await checkManager.checkWithDebounce(e, 'Document saved', null); + await checkManager.checkWithDebounce( + e, + URI.parse(e.uri), + 'Document saved', + null + ); } private async _onDocumentActive( @@ -228,7 +247,12 @@ export class DocumentManager implements AsyncDisposable { return; } - await checkManager.checkWithDebounce(e, 'Document opened', null); + await checkManager.checkWithDebounce( + e, + URI.parse(e.uri), + 'Document opened', + null + ); } private async _onDocumentCheck( @@ -238,11 +262,17 @@ export class DocumentManager implements AsyncDisposable { if (e.languageId !== 'php' || e.uri.endsWith('.git')) { return; } - await checkManager.checkWithDebounce(e, 'Force trigger', null); + await checkManager.checkWithDebounce( + e, + URI.parse(e.uri), + 'Force trigger', + null + ); } private async _onConfigChange( - checkManager: PHPStanCheckManager + checkManager: PHPStanCheckManager, + e: WatcherNotificationFileData | null ): Promise { if (!(await this._enabled)) { return; @@ -252,6 +282,7 @@ export class DocumentManager implements AsyncDisposable { if (!editorConfig.singleFileMode) { await checkManager.checkWithDebounce( undefined, + e ? URI.parse(e.uri) : null, 'Config change', null ); @@ -259,16 +290,37 @@ export class DocumentManager implements AsyncDisposable { void this.watcher?.onConfigChange(); } - private async _onScanProject( - checkManager: PHPStanCheckManager + private async _onScanCurrentProject( + checkManager: PHPStanCheckManager, + e: WatcherNotificationFileData | null ): Promise { await checkManager.checkWithDebounce( undefined, + e ? URI.parse(e.uri) : null, 'Manual project scan', null ); } + private async _onScanAllProjects( + checkManager: PHPStanCheckManager + ): Promise { + const configFiles = (await getEditorConfiguration(this._classConfig)) + .configFiles; + + for (const configFile of configFiles) { + const status = await checkManager.check( + undefined, + URI.file(configFile), + 'Manual all-projects scan', + null + ); + if (status !== OperationStatus.SUCCESS) { + return; + } + } + } + private async _clearData(checkManager: PHPStanCheckManager): Promise { await checkManager.clear(); } diff --git a/server/src/lib/editorConfig.ts b/server/src/lib/editorConfig.ts index a9ba612..a30d211 100644 --- a/server/src/lib/editorConfig.ts +++ b/server/src/lib/editorConfig.ts @@ -30,6 +30,9 @@ export async function getEditorConfiguration( if (!tmpDir) { tmpDir = editorConfig.proTmpDir || editorConfig.tmpDir; } + const configFiles = editorConfig.configFile + ? [editorConfig.configFile] + : editorConfig.configFiles; return { ...editorConfig, binPath: replaceHomeDir( @@ -38,8 +41,8 @@ export async function getEditorConfiguration( binCommand: editorConfig.binCommand.map((part) => replaceHomeDir(replaceVariables(part, workspaceFolders)) ), - configFile: replaceHomeDir( - replaceVariables(editorConfig.configFile, workspaceFolders) + configFiles: configFiles.map((configFile) => + replaceHomeDir(replaceVariables(configFile, workspaceFolders)) ), paths: fromEntries( Object.entries(editorConfig.paths).map(([key, value]) => [ diff --git a/server/src/lib/phpstan/check.ts b/server/src/lib/phpstan/check.ts index 0595db1..90eb3f2 100644 --- a/server/src/lib/phpstan/check.ts +++ b/server/src/lib/phpstan/check.ts @@ -168,12 +168,14 @@ export class PHPStanCheck implements AsyncDisposable { public async check( applyErrors: boolean, onError: null | ((error: string) => void), + currentFile: URI | null, file?: WatcherNotificationFileData ): Promise> { // Get config const checkConfig = await ConfigurationManager.collectConfiguration( this._classConfig, 'analyse', + currentFile, onError ); if (!checkConfig) { diff --git a/server/src/lib/phpstan/checkManager.ts b/server/src/lib/phpstan/checkManager.ts index 556d3a7..78b43c9 100644 --- a/server/src/lib/phpstan/checkManager.ts +++ b/server/src/lib/phpstan/checkManager.ts @@ -13,6 +13,7 @@ import { executeCommand } from '../commands'; import { showError } from '../errorUtil'; import { ReturnResult } from '../result'; import { PHPStanCheck } from './check'; +import { URI } from 'vscode-uri'; interface CheckOperation { check: PHPStanCheck; @@ -182,6 +183,7 @@ export class PHPStanCheckManager implements AsyncDisposable { } private async _performProjectCheck( + currentFile: URI | null, onError: null | ((error: string) => void) ): Promise { // Prep check @@ -222,7 +224,7 @@ export class PHPStanCheckManager implements AsyncDisposable { ReturnResult, Promise> >({ - promise: check.check(true, onError), + promise: check.check(true, onError, currentFile), timeout: editorConfig.projectTimeout, onTimeout: async () => { await check.dispose(); @@ -279,7 +281,7 @@ export class PHPStanCheckManager implements AsyncDisposable { ReturnResult, Promise> >({ - promise: check.check(true, onError, file), + promise: check.check(true, onError, URI.parse(file.uri), file), timeout: editorConfig.timeout, onTimeout: async () => { await check.dispose(); @@ -307,6 +309,7 @@ export class PHPStanCheckManager implements AsyncDisposable { } private async _checkProject( + currentFile: URI | null, onError: null | ((error: string) => void) ): Promise { // Kill all current running instances @@ -334,7 +337,7 @@ export class PHPStanCheckManager implements AsyncDisposable { await this._withRecursivePromise( PROJECT_CHECK_STR, - this._performProjectCheck(onError) + this._performProjectCheck(currentFile, onError) ); return this._getFilePromise(PROJECT_CHECK_STR); } @@ -368,11 +371,12 @@ export class PHPStanCheckManager implements AsyncDisposable { private async _checkProjectIfFileChanged( file: WatcherNotificationFileData, + currentFile: URI | null, onError: null | ((error: string) => void) ): Promise { const projectCheck = this._operations.get(PROJECT_CHECK_STR); if (!projectCheck) { - return this._checkProject(onError); + return this._checkProject(currentFile, onError); } if (!file.content) { // Already checked if part of any operation @@ -389,11 +393,12 @@ export class PHPStanCheckManager implements AsyncDisposable { ); return OperationStatus.CANCELLED; } - return this._checkProject(onError); + return this._checkProject(currentFile, onError); } public async check( file: WatcherNotificationFileData | undefined, + currentFile: URI | null, cause: string, onError: null | ((error: string) => void) ): Promise { @@ -405,13 +410,14 @@ export class PHPStanCheckManager implements AsyncDisposable { `Checking: ${cause}` ); if (shouldCheckProject) { - return this._checkProject(onError); + return this._checkProject(currentFile, onError); } return this._checkFile(file, onError); } public async checkWithDebounce( file: WatcherNotificationFileData | undefined, + currentFile: URI | null, cause: string, onError: null | ((error: string) => void) ): Promise { @@ -420,7 +426,7 @@ export class PHPStanCheckManager implements AsyncDisposable { return this.debounceWithKey( shouldCheckProject ? PROJECT_CHECK_STR : file.uri, async () => { - await this.check(file, cause, onError); + await this.check(file, currentFile, cause, onError); } ); } @@ -439,7 +445,11 @@ export class PHPStanCheckManager implements AsyncDisposable { `Checking: ${cause}` ); if (!editorConfig.singleFileMode) { - await this._checkProjectIfFileChanged(file, null); + await this._checkProjectIfFileChanged( + file, + URI.parse(file.uri), + null + ); } else { await this._checkFile(file, null); } diff --git a/server/src/lib/phpstan/diagnose.ts b/server/src/lib/phpstan/diagnose.ts deleted file mode 100644 index ca1c92b..0000000 --- a/server/src/lib/phpstan/diagnose.ts +++ /dev/null @@ -1,61 +0,0 @@ -import type { StatusBarProgress } from '../../../../shared/notificationChannels'; -import { ConfigurationManager } from '../checkConfigManager'; -import type { AsyncDisposable, ClassConfig } from '../types'; -import { PHPStanRunner } from './processRunner'; -import { DIAGNOSE_GET_FILES } from '../log'; -import { ReturnResult } from '../result'; - -export type ProgressListener = (progress: StatusBarProgress) => void; - -export class PHPStanDiagnose implements AsyncDisposable { - private _done: boolean = false; - private _disposed: boolean = false; - public disposables: AsyncDisposable[] = []; - - public get done(): boolean { - return this._done; - } - - public constructor(private readonly _classConfig: ClassConfig) {} - - public async diagnose( - onError: null | ((error: string) => void) - ): Promise> { - // Get config - const checkConfig = await ConfigurationManager.collectConfiguration( - this._classConfig, - 'diagnose', - onError - ); - if (!checkConfig) { - return ReturnResult.error(); - } - - const runner = new PHPStanRunner(this._classConfig); - this.disposables.push(runner); - - if (this._disposed) { - return ReturnResult.canceled(); - } - - const result = await runner.runProcess( - checkConfig, - DIAGNOSE_GET_FILES, - false, - { - onError, - } - ); - - await this.dispose(); - this._done = true; - - return result; - } - - public async dispose(): Promise { - await Promise.all(this.disposables.map((d) => d.dispose())); - this.disposables = []; - this._disposed = true; - } -} diff --git a/server/src/lib/phpstan/pro/pro.ts b/server/src/lib/phpstan/pro/pro.ts index 18bf9ca..f5f230b 100644 --- a/server/src/lib/phpstan/pro/pro.ts +++ b/server/src/lib/phpstan/pro/pro.ts @@ -24,6 +24,7 @@ export async function launchPro( const launchConfig = await ConfigurationManager.collectConfiguration( classConfig, 'analyse', + null, null ); if (!launchConfig) { diff --git a/server/src/lib/test.ts b/server/src/lib/test.ts index 79c1fba..2f05481 100644 --- a/server/src/lib/test.ts +++ b/server/src/lib/test.ts @@ -30,6 +30,7 @@ export function listenTest( let error: string | undefined = undefined; const status = await checkManager.check( params.file, + null, 'test', (_error) => { error = _error; diff --git a/server/src/start/startIntegratedChecker.ts b/server/src/start/startIntegratedChecker.ts index d73d0b3..3749fbd 100644 --- a/server/src/start/startIntegratedChecker.ts +++ b/server/src/start/startIntegratedChecker.ts @@ -59,6 +59,7 @@ export function startIntegratedChecker( ) { void checkManager.checkWithDebounce( undefined, + null, 'Initial check', null ); diff --git a/shared/commands/defs.ts b/shared/commands/defs.ts index 40f9580..546ffbd 100644 --- a/shared/commands/defs.ts +++ b/shared/commands/defs.ts @@ -7,6 +7,7 @@ import type { export enum Commands { SCAN_FILE_FOR_ERRORS = 'phpstan.scanFileForErrors', SCAN_PROJECT = 'phpstan.scanProjectForErrors', + SCAN_CURRENT_PROJECT = 'phpstan.scanCurrentProjectForErrors', RELOAD = 'phpstan.reload', NEXT_ERROR = 'phpstan.nextError', PREVIOUS_ERROR = 'phpstan.previousError', @@ -23,6 +24,10 @@ export const commands: Record = { title: 'Scan project for errors', inCommandPalette: true, }, + [Commands.SCAN_CURRENT_PROJECT]: { + title: 'Scan current project for errors', + inCommandPalette: true, + }, [Commands.RELOAD]: { title: 'Reload language server', inCommandPalette: true, @@ -72,17 +77,26 @@ export const config = { 'PHPStan command. Use this instead of "binPath" if, for example, the phpstan binary is in your path', }, }, - 'phpstan.configFile': { + 'phpstan.configFiles': { jsonDefinition: { - type: 'string', - default: 'phpstan.neon,phpstan.neon.dist,phpstan.dist.neon', + type: 'array', + items: { + type: 'string', + examples: [ + 'phpstan.neon', + 'backend/phpstan.neon', + 'phpstan.neon,phpstan.neon.dist', + ], + }, + default: ['phpstan.neon,phpstan.neon.dist,phpstan.dist.neon'], + description: + "Paths to all projects' config files (use a comma-separated list to resolve in order)", examples: [ - 'phpstan.neon', - 'backend/phpstan.neon', - 'phpstan.neon,phpstan.neon.dist', + ['phpstan.neon'], + ['src/phpstan.neon', 'test/phpstan.neon'], + ['backend/phpstan.neon'], + ['phpstan.neon,phpstan.neon.dist'], ], - description: - 'Path to the config file (use a comma-separated list to resolve in order)', }, }, 'phpstan.paths': { diff --git a/shared/config.ts b/shared/config.ts index 0643394..e2c445a 100644 --- a/shared/config.ts +++ b/shared/config.ts @@ -11,9 +11,10 @@ export type ConfigSettings = Omit< 'phpstan.ignoreErrors': (string | RegExp)[]; }; +/** @deprecated */ export type DeprecatedConfigSettings = { // Legacy setting 'phpstan.proTmpDir'?: string; - /** @deprecated */ 'phpstan.enableLanguageServer'?: boolean; + 'phpstan.configFile'?: string; }; diff --git a/shared/neon.ts b/shared/neon.ts new file mode 100644 index 0000000..0751161 --- /dev/null +++ b/shared/neon.ts @@ -0,0 +1,134 @@ +import { decode, Map as NeonMap } from 'neon-js'; +import type { Neon } from 'neon-js'; +import fs from 'fs/promises'; +import path from 'path'; + +export async function readNeonFile(filePath: string): Promise { + const parsed = decode(await fs.readFile(filePath, 'utf8')); + + const output: Neon[] = [parsed]; + if (!(parsed instanceof NeonMap)) { + return output; + } + + if (parsed.has('includes')) { + const includes = parsed.get('includes'); + if (!(includes instanceof NeonMap) || !includes.isList()) { + return output; + } + + for (const file of includes.values()) { + if (typeof file !== 'string') { + continue; + } + + if (path.isAbsolute(file)) { + output.push(...(await readNeonFile(file))); + } else { + output.push( + ...(await readNeonFile( + path.join(path.dirname(filePath), file) + )) + ); + } + } + } + + return output; +} + +export async function getAnalyzePaths(filePath: string): Promise<{ + paths: string[]; + excludePaths: string[]; +}> { + const neonFiles = await readNeonFile(filePath); + + const parsePaths = (pathsMap: Neon): string[] => { + if (!(pathsMap instanceof NeonMap)) { + return []; + } + + const paths: string[] = []; + if (pathsMap.isList()) { + for (const path of pathsMap.values()) { + if (typeof path !== 'string') { + continue; + } + + paths.push(path); + } + return paths; + } + + if (pathsMap.has('analyse')) { + paths.push(...parsePaths(pathsMap.get('analyse'))); + } + if (pathsMap.has('analyseAndScan')) { + paths.push(...parsePaths(pathsMap.get('analyseAndScan'))); + } + + return paths; + }; + + const paths: string[] = []; + const excludePaths: string[] = []; + for (const neonFile of neonFiles) { + if (!(neonFile instanceof NeonMap)) { + continue; + } + + const parameters = neonFile.get('parameters'); + if (!(parameters instanceof NeonMap)) { + continue; + } + + if (parameters.has('paths')) { + paths.push(...parsePaths(parameters.get('paths'))); + } + if (parameters.has('excludePaths')) { + excludePaths.push(...parsePaths(parameters.get('excludePaths'))); + } + } + + return { + paths, + excludePaths, + }; +} + +export async function isInPaths( + filePath: string, + configFilePath: string +): Promise { + const { paths, excludePaths } = await getAnalyzePaths(configFilePath); + + function fnmatch(pattern: string, string: string): boolean { + // Escape special regex characters + let regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&'); + + // Convert shell wildcard characters to regex equivalents + regexPattern = regexPattern.replace(/\*/g, '.*').replace(/\?/g, '.'); + + // Add start and end anchors + regexPattern = '^' + regexPattern; + + // Create and test the regular expression + const regex = new RegExp(regexPattern); + return regex.test(string); + } + + const configFileDir = path.dirname(configFilePath); + for (const excludePath of excludePaths) { + if (fnmatch(path.join(configFileDir, excludePath), filePath)) { + return false; + } + } + + for (const includePath of paths) { + if (fnmatch(path.join(configFileDir, includePath), filePath)) { + return true; + } + } + + return false; +} diff --git a/shared/notificationChannels.ts b/shared/notificationChannels.ts index d16efa8..a7f1fad 100644 --- a/shared/notificationChannels.ts +++ b/shared/notificationChannels.ts @@ -47,9 +47,14 @@ export type WatcherNotificationType = } | { operation: 'checkProject'; + file: WatcherNotificationFileData | null; + } + | { + operation: 'checkAllProjects'; } | { operation: 'onConfigChange'; + file: WatcherNotificationFileData | null; } | { operation: 'clear'; diff --git a/test/cache/phpstan/cache/PHPStan/47/31/473162f1513a526888b91dbbd2b60f770628088f.php b/test/cache/phpstan/cache/PHPStan/47/31/473162f1513a526888b91dbbd2b60f770628088f.php new file mode 100644 index 0000000..a1b3785 --- /dev/null +++ b/test/cache/phpstan/cache/PHPStan/47/31/473162f1513a526888b91dbbd2b60f770628088f.php @@ -0,0 +1,25 @@ + 'v1', + 'data' => + array ( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php/DemoClass.php' => + array ( + 0 => 'b8afe744d312c0f350468bc372aa3e12b22de586', + 1 => + array ( + 0 => 'x', + 1 => 'democlass', + ), + 2 => + array ( + 0 => 'strunion', + ), + 3 => + array ( + ), + ), + ), +)); \ No newline at end of file diff --git a/test/cache/phpstan/cache/PHPStan/50/04/5004d54475cd43e9f4ca650cd897fcae2583bf27.php b/test/cache/phpstan/cache/PHPStan/50/04/5004d54475cd43e9f4ca650cd897fcae2583bf27.php new file mode 100644 index 0000000..97dcc12 --- /dev/null +++ b/test/cache/phpstan/cache/PHPStan/50/04/5004d54475cd43e9f4ca650cd897fcae2583bf27.php @@ -0,0 +1,25 @@ + 'v1', + 'data' => + array ( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/php/DemoClass.php' => + array ( + 0 => '3989ecade3ce0d217726867d5f28c9819f34110d', + 1 => + array ( + 0 => 'x', + 1 => 'democlass', + ), + 2 => + array ( + 0 => 'strunion', + ), + 3 => + array ( + ), + ), + ), +)); \ No newline at end of file diff --git a/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php b/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php new file mode 100644 index 0000000..a9238b3 --- /dev/null +++ b/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php @@ -0,0 +1,6872 @@ + [ + '04' => true, + '05' => true, + '06' => true, + '07' => true, + '08' => true, + '09' => true, + '010' => true, + '013' => true, + '014' => true, + '015' => true, + '016' => true, + '017' => true, + '018' => true, + '019' => true, + '082' => true, + ], + 'phpstan.stubFilesExtension' => ['039' => true, '040' => true, '042' => true, '043' => true], + 'phpstan.diagnoseExtension' => ['084' => true], + 'phpstan.broker.methodsClassReflectionExtension' => ['0101' => true, '0105' => true], + 'phpstan.broker.propertiesClassReflectionExtension' => ['0102' => true, '0107' => true, '0258' => true], + 'phpstan.broker.allowedSubTypesClassReflectionExtension' => ['0106' => true], + 'phpstan.broker.dynamicMethodReturnTypeExtension' => [ + '0108' => true, + '0109' => true, + '0206' => true, + '0217' => true, + '0223' => true, + '0224' => true, + '0228' => true, + '0260' => true, + '0287' => true, + '0313' => true, + '0314' => true, + '0321' => true, + '0322' => true, + '0323' => true, + '0324' => true, + '0325' => true, + '0326' => true, + ], + 'phpstan.broker.dynamicFunctionReturnTypeExtension' => [ + '0170' => true, + '0171' => true, + '0172' => true, + '0173' => true, + '0174' => true, + '0175' => true, + '0176' => true, + '0177' => true, + '0178' => true, + '0179' => true, + '0180' => true, + '0181' => true, + '0183' => true, + '0184' => true, + '0185' => true, + '0186' => true, + '0187' => true, + '0188' => true, + '0189' => true, + '0190' => true, + '0191' => true, + '0192' => true, + '0193' => true, + '0194' => true, + '0195' => true, + '0196' => true, + '0197' => true, + '0199' => true, + '0200' => true, + '0203' => true, + '0204' => true, + '0208' => true, + '0209' => true, + '0211' => true, + '0213' => true, + '0214' => true, + '0216' => true, + '0218' => true, + '0221' => true, + '0222' => true, + '0230' => true, + '0231' => true, + '0233' => true, + '0234' => true, + '0235' => true, + '0236' => true, + '0237' => true, + '0238' => true, + '0239' => true, + '0240' => true, + '0241' => true, + '0242' => true, + '0243' => true, + '0245' => true, + '0260' => true, + '0263' => true, + '0264' => true, + '0265' => true, + '0266' => true, + '0267' => true, + '0269' => true, + '0270' => true, + '0271' => true, + '0272' => true, + '0273' => true, + '0274' => true, + '0275' => true, + '0276' => true, + '0277' => true, + '0278' => true, + '0279' => true, + '0281' => true, + '0282' => true, + '0283' => true, + '0284' => true, + '0285' => true, + '0286' => true, + '0288' => true, + '0289' => true, + '0290' => true, + '0291' => true, + '0292' => true, + '0293' => true, + '0294' => true, + '0295' => true, + '0298' => true, + '0307' => true, + '0311' => true, + '0312' => true, + '0315' => true, + '0316' => true, + '0317' => true, + '0318' => true, + '0319' => true, + '0320' => true, + ], + 'phpstan.typeSpecifier.functionTypeSpecifyingExtension' => [ + '0182' => true, + '0198' => true, + '0212' => true, + '0247' => true, + '0257' => true, + '0261' => true, + '0262' => true, + '0280' => true, + '0296' => true, + '0297' => true, + '0299' => true, + '0300' => true, + '0301' => true, + '0302' => true, + '0303' => true, + '0304' => true, + '0305' => true, + '0306' => true, + '0308' => true, + '0310' => true, + ], + 'phpstan.dynamicFunctionThrowTypeExtension' => ['0201' => true, '0244' => true, '0246' => true], + 'phpstan.broker.dynamicStaticMethodReturnTypeExtension' => [ + '0202' => true, + '0205' => true, + '0207' => true, + '0220' => true, + '0321' => true, + '0327' => true, + ], + 'phpstan.dynamicStaticMethodThrowTypeExtension' => [ + '0219' => true, + '0225' => true, + '0227' => true, + '0253' => true, + '0254' => true, + '0255' => true, + '0256' => true, + '0259' => true, + ], + 'phpstan.dynamicMethodThrowTypeExtension' => ['0226' => true, '0229' => true], + 'phpstan.functionParameterOutTypeExtension' => ['0248' => true], + 'phpstan.functionParameterClosureTypeExtension' => ['0249' => true], + 'phpstan.typeSpecifier.methodTypeSpecifyingExtension' => ['0268' => true], + 'phpstan.rules.rule' => [ + '0340' => true, + '0344' => true, + '0345' => true, + '0346' => true, + '0347' => true, + '0348' => true, + '0349' => true, + '0351' => true, + '0352' => true, + '0353' => true, + '0354' => true, + '0355' => true, + '0356' => true, + '0357' => true, + '0358' => true, + '0360' => true, + '0363' => true, + '0364' => true, + '0365' => true, + '0366' => true, + '0367' => true, + '0374' => true, + '0380' => true, + '0383' => true, + '0386' => true, + '0387' => true, + '0388' => true, + '0390' => true, + '0394' => true, + '0395' => true, + '0396' => true, + '0397' => true, + '0398' => true, + '0399' => true, + '0400' => true, + '0401' => true, + '0402' => true, + '0408' => true, + '0409' => true, + '0410' => true, + '0411' => true, + '0412' => true, + '0424' => true, + '0425' => true, + '0426' => true, + '0427' => true, + '0428' => true, + '0429' => true, + '0430' => true, + '0433' => true, + '0434' => true, + '0435' => true, + '0437' => true, + '0438' => true, + '0439' => true, + '0440' => true, + '0441' => true, + '0442' => true, + '0443' => true, + '0444' => true, + '0448' => true, + '0452' => true, + '0456' => true, + '0460' => true, + '0461' => true, + 'rules.0' => true, + 'rules.1' => true, + 'rules.10' => true, + 'rules.100' => true, + 'rules.101' => true, + 'rules.102' => true, + 'rules.103' => true, + 'rules.104' => true, + 'rules.105' => true, + 'rules.106' => true, + 'rules.107' => true, + 'rules.108' => true, + 'rules.109' => true, + 'rules.11' => true, + 'rules.110' => true, + 'rules.111' => true, + 'rules.112' => true, + 'rules.113' => true, + 'rules.114' => true, + 'rules.115' => true, + 'rules.116' => true, + 'rules.117' => true, + 'rules.118' => true, + 'rules.119' => true, + 'rules.12' => true, + 'rules.120' => true, + 'rules.121' => true, + 'rules.122' => true, + 'rules.123' => true, + 'rules.124' => true, + 'rules.125' => true, + 'rules.126' => true, + 'rules.127' => true, + 'rules.128' => true, + 'rules.129' => true, + 'rules.13' => true, + 'rules.130' => true, + 'rules.131' => true, + 'rules.132' => true, + 'rules.133' => true, + 'rules.134' => true, + 'rules.135' => true, + 'rules.136' => true, + 'rules.137' => true, + 'rules.138' => true, + 'rules.139' => true, + 'rules.14' => true, + 'rules.140' => true, + 'rules.141' => true, + 'rules.142' => true, + 'rules.143' => true, + 'rules.144' => true, + 'rules.145' => true, + 'rules.146' => true, + 'rules.147' => true, + 'rules.148' => true, + 'rules.149' => true, + 'rules.15' => true, + 'rules.150' => true, + 'rules.151' => true, + 'rules.152' => true, + 'rules.153' => true, + 'rules.154' => true, + 'rules.155' => true, + 'rules.156' => true, + 'rules.157' => true, + 'rules.158' => true, + 'rules.159' => true, + 'rules.16' => true, + 'rules.160' => true, + 'rules.161' => true, + 'rules.162' => true, + 'rules.163' => true, + 'rules.164' => true, + 'rules.165' => true, + 'rules.17' => true, + 'rules.18' => true, + 'rules.19' => true, + 'rules.2' => true, + 'rules.20' => true, + 'rules.21' => true, + 'rules.22' => true, + 'rules.23' => true, + 'rules.24' => true, + 'rules.25' => true, + 'rules.26' => true, + 'rules.27' => true, + 'rules.28' => true, + 'rules.29' => true, + 'rules.3' => true, + 'rules.30' => true, + 'rules.31' => true, + 'rules.32' => true, + 'rules.33' => true, + 'rules.34' => true, + 'rules.35' => true, + 'rules.36' => true, + 'rules.37' => true, + 'rules.38' => true, + 'rules.39' => true, + 'rules.4' => true, + 'rules.40' => true, + 'rules.41' => true, + 'rules.42' => true, + 'rules.43' => true, + 'rules.44' => true, + 'rules.45' => true, + 'rules.46' => true, + 'rules.47' => true, + 'rules.48' => true, + 'rules.49' => true, + 'rules.5' => true, + 'rules.50' => true, + 'rules.51' => true, + 'rules.52' => true, + 'rules.53' => true, + 'rules.54' => true, + 'rules.55' => true, + 'rules.56' => true, + 'rules.57' => true, + 'rules.58' => true, + 'rules.59' => true, + 'rules.6' => true, + 'rules.60' => true, + 'rules.61' => true, + 'rules.62' => true, + 'rules.63' => true, + 'rules.64' => true, + 'rules.65' => true, + 'rules.66' => true, + 'rules.67' => true, + 'rules.68' => true, + 'rules.69' => true, + 'rules.7' => true, + 'rules.70' => true, + 'rules.71' => true, + 'rules.72' => true, + 'rules.73' => true, + 'rules.74' => true, + 'rules.75' => true, + 'rules.76' => true, + 'rules.77' => true, + 'rules.78' => true, + 'rules.79' => true, + 'rules.8' => true, + 'rules.80' => true, + 'rules.81' => true, + 'rules.82' => true, + 'rules.83' => true, + 'rules.84' => true, + 'rules.85' => true, + 'rules.86' => true, + 'rules.87' => true, + 'rules.88' => true, + 'rules.89' => true, + 'rules.9' => true, + 'rules.90' => true, + 'rules.91' => true, + 'rules.92' => true, + 'rules.93' => true, + 'rules.94' => true, + 'rules.95' => true, + 'rules.96' => true, + 'rules.97' => true, + 'rules.98' => true, + 'rules.99' => true, + ], + ]; + + protected $types = ['container' => '_PHPStan_4f7beffdf\Nette\DI\Container']; + protected $aliases = []; + + protected $wiring = [ + '_PHPStan_4f7beffdf\Nette\DI\Container' => [['container']], + 'PHPStan\Rules\Rule' => [ + [ + '0129', + '0130', + '0132', + '0133', + '0147', + '0338', + '0339', + '0340', + '0341', + '0342', + '0343', + '0344', + '0345', + '0346', + '0347', + '0348', + '0349', + '0350', + '0351', + '0352', + '0353', + '0354', + '0355', + '0356', + '0357', + '0358', + '0359', + '0360', + '0361', + '0362', + '0363', + '0364', + '0365', + '0366', + '0367', + '0369', + '0370', + '0371', + '0372', + '0373', + '0374', + '0375', + '0376', + '0377', + '0378', + '0380', + '0381', + '0382', + '0383', + '0384', + '0385', + '0386', + '0387', + '0388', + '0389', + '0390', + '0391', + '0392', + '0393', + '0394', + '0395', + '0396', + '0397', + '0398', + '0399', + '0400', + '0401', + '0402', + '0403', + '0404', + '0405', + '0406', + '0407', + '0408', + '0409', + '0410', + '0411', + '0412', + '0413', + '0416', + '0419', + '0422', + '0424', + '0425', + '0426', + '0427', + '0428', + '0429', + '0430', + '0431', + '0432', + '0433', + '0434', + '0435', + '0436', + '0437', + '0438', + '0439', + '0440', + '0441', + '0442', + '0443', + '0444', + '0447', + '0448', + '0449', + '0450', + '0451', + '0452', + '0453', + '0454', + '0455', + '0456', + '0457', + '0458', + '0459', + '0460', + '0461', + '0462', + ], + [ + 'rules.0', + 'rules.1', + 'rules.2', + 'rules.3', + 'rules.4', + 'rules.5', + 'rules.6', + 'rules.7', + 'rules.8', + 'rules.9', + 'rules.10', + 'rules.11', + 'rules.12', + 'rules.13', + 'rules.14', + 'rules.15', + 'rules.16', + 'rules.17', + 'rules.18', + 'rules.19', + 'rules.20', + 'rules.21', + 'rules.22', + 'rules.23', + 'rules.24', + 'rules.25', + 'rules.26', + 'rules.27', + 'rules.28', + 'rules.29', + 'rules.30', + 'rules.31', + 'rules.32', + 'rules.33', + 'rules.34', + 'rules.35', + 'rules.36', + 'rules.37', + 'rules.38', + 'rules.39', + 'rules.40', + 'rules.41', + 'rules.42', + 'rules.43', + 'rules.44', + 'rules.45', + 'rules.46', + 'rules.47', + 'rules.48', + 'rules.49', + 'rules.50', + 'rules.51', + 'rules.52', + 'rules.53', + 'rules.54', + 'rules.55', + 'rules.56', + 'rules.57', + 'rules.58', + 'rules.59', + 'rules.60', + 'rules.61', + 'rules.62', + 'rules.63', + 'rules.64', + 'rules.65', + 'rules.66', + 'rules.67', + 'rules.68', + 'rules.69', + 'rules.70', + 'rules.71', + 'rules.72', + 'rules.73', + 'rules.74', + 'rules.75', + 'rules.76', + 'rules.77', + 'rules.78', + 'rules.79', + 'rules.80', + 'rules.81', + 'rules.82', + 'rules.83', + 'rules.84', + 'rules.85', + 'rules.86', + 'rules.87', + 'rules.88', + 'rules.89', + 'rules.90', + 'rules.91', + 'rules.92', + 'rules.93', + 'rules.94', + 'rules.95', + 'rules.96', + 'rules.97', + 'rules.98', + 'rules.99', + 'rules.100', + 'rules.101', + 'rules.102', + 'rules.103', + 'rules.104', + 'rules.105', + 'rules.106', + 'rules.107', + 'rules.108', + 'rules.109', + 'rules.110', + 'rules.111', + 'rules.112', + 'rules.113', + 'rules.114', + 'rules.115', + 'rules.116', + 'rules.117', + 'rules.118', + 'rules.119', + 'rules.120', + 'rules.121', + 'rules.122', + 'rules.123', + 'rules.124', + 'rules.125', + 'rules.126', + 'rules.127', + 'rules.128', + 'rules.129', + 'rules.130', + 'rules.131', + 'rules.132', + 'rules.133', + 'rules.134', + 'rules.135', + 'rules.136', + 'rules.137', + 'rules.138', + 'rules.139', + 'rules.140', + 'rules.141', + 'rules.142', + 'rules.143', + 'rules.144', + 'rules.145', + 'rules.146', + 'rules.147', + 'rules.148', + 'rules.149', + 'rules.150', + 'rules.151', + 'rules.152', + 'rules.153', + 'rules.154', + 'rules.155', + 'rules.156', + 'rules.157', + 'rules.158', + 'rules.159', + 'rules.160', + 'rules.161', + 'rules.162', + 'rules.163', + 'rules.164', + 'rules.165', + ], + ], + 'PHPStan\Rules\Debug\DumpTypeRule' => [['rules.0']], + 'PHPStan\Rules\Debug\FileAssertRule' => [['rules.1']], + 'PHPStan\Rules\Api\ApiInstantiationRule' => [['rules.2']], + 'PHPStan\Rules\Api\ApiClassExtendsRule' => [['rules.3']], + 'PHPStan\Rules\Api\ApiClassImplementsRule' => [['rules.4']], + 'PHPStan\Rules\Api\ApiInterfaceExtendsRule' => [['rules.5']], + 'PHPStan\Rules\Api\ApiMethodCallRule' => [['rules.6']], + 'PHPStan\Rules\Api\ApiStaticCallRule' => [['rules.7']], + 'PHPStan\Rules\Api\ApiTraitUseRule' => [['rules.8']], + 'PHPStan\Rules\Api\GetTemplateTypeRule' => [['rules.9']], + 'PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule' => [['rules.10']], + 'PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule' => [['rules.11']], + 'PHPStan\Rules\Arrays\EmptyArrayItemRule' => [['rules.12']], + 'PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule' => [['rules.13']], + 'PHPStan\Rules\Cast\UnsetCastRule' => [['rules.14']], + 'PHPStan\Rules\Classes\AllowedSubTypesRule' => [['rules.15']], + 'PHPStan\Rules\Classes\ClassAttributesRule' => [['rules.16']], + 'PHPStan\Rules\Classes\ClassConstantAttributesRule' => [['rules.17']], + 'PHPStan\Rules\Classes\ClassConstantRule' => [['rules.18']], + 'PHPStan\Rules\Classes\DuplicateDeclarationRule' => [['rules.19']], + 'PHPStan\Rules\Classes\EnumSanityRule' => [['rules.20']], + 'PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule' => [['rules.21']], + 'PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule' => [['rules.22']], + 'PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule' => [['rules.23']], + 'PHPStan\Rules\Classes\ExistingClassInTraitUseRule' => [['rules.24']], + 'PHPStan\Rules\Classes\InstantiationRule' => [['rules.25']], + 'PHPStan\Rules\Classes\InstantiationCallableRule' => [['rules.26']], + 'PHPStan\Rules\Classes\InvalidPromotedPropertiesRule' => [['rules.27']], + 'PHPStan\Rules\Classes\LocalTypeAliasesRule' => [['rules.28']], + 'PHPStan\Rules\Classes\LocalTypeTraitAliasesRule' => [['rules.29']], + 'PHPStan\Rules\Classes\NewStaticRule' => [['rules.30']], + 'PHPStan\Rules\Classes\NonClassAttributeClassRule' => [['rules.31']], + 'PHPStan\Rules\Classes\ReadOnlyClassRule' => [['rules.32']], + 'PHPStan\Rules\Classes\TraitAttributeClassRule' => [['rules.33']], + 'PHPStan\Rules\Constants\DynamicClassConstantFetchRule' => [['rules.34']], + 'PHPStan\Rules\Constants\FinalConstantRule' => [['rules.35']], + 'PHPStan\Rules\Constants\NativeTypedClassConstantRule' => [['rules.36']], + 'PHPStan\Rules\EnumCases\EnumCaseAttributesRule' => [['rules.37']], + 'PHPStan\Rules\Exceptions\NoncapturingCatchRule' => [['rules.38']], + 'PHPStan\Rules\Exceptions\ThrowExpressionRule' => [['rules.39']], + 'PHPStan\Rules\Functions\ArrowFunctionAttributesRule' => [['rules.40']], + 'PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule' => [['rules.41']], + 'PHPStan\Rules\Functions\ClosureAttributesRule' => [['rules.42']], + 'PHPStan\Rules\Functions\DefineParametersRule' => [['rules.43']], + 'PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule' => [['rules.44']], + 'PHPStan\Rules\Functions\CallToFunctionParametersRule' => [['rules.45']], + 'PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule' => [['rules.46']], + 'PHPStan\Rules\Functions\ExistingClassesInTypehintsRule' => [['rules.47']], + 'PHPStan\Rules\Functions\FunctionAttributesRule' => [['rules.48']], + 'PHPStan\Rules\Functions\InnerFunctionRule' => [['rules.49']], + 'PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule' => [['rules.50']], + 'PHPStan\Rules\Functions\ParamAttributesRule' => [['rules.51']], + 'PHPStan\Rules\Functions\PrintfParametersRule' => [['rules.52']], + 'PHPStan\Rules\Functions\RedefinedParametersRule' => [['rules.53']], + 'PHPStan\Rules\Functions\ReturnNullsafeByRefRule' => [['rules.54']], + 'PHPStan\Rules\Ignore\IgnoreParseErrorRule' => [['rules.55']], + 'PHPStan\Rules\Functions\VariadicParametersDeclarationRule' => [['rules.56']], + 'PHPStan\Rules\Keywords\ContinueBreakInLoopRule' => [['rules.57']], + 'PHPStan\Rules\Keywords\DeclareStrictTypesRule' => [['rules.58']], + 'PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule' => [['rules.59']], + 'PHPStan\Rules\Methods\AbstractPrivateMethodRule' => [['rules.60']], + 'PHPStan\Rules\Methods\CallMethodsRule' => [['rules.61']], + 'PHPStan\Rules\Methods\CallStaticMethodsRule' => [['rules.62']], + 'PHPStan\Rules\Methods\ConstructorReturnTypeRule' => [['rules.63']], + 'PHPStan\Rules\Methods\ExistingClassesInTypehintsRule' => [['rules.64']], + 'PHPStan\Rules\Methods\FinalPrivateMethodRule' => [['rules.65']], + 'PHPStan\Rules\Methods\MethodCallableRule' => [['rules.66']], + 'PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule' => [['rules.67']], + 'PHPStan\Rules\Methods\MissingMethodImplementationRule' => [['rules.68']], + 'PHPStan\Rules\Methods\MethodAttributesRule' => [['rules.69']], + 'PHPStan\Rules\Methods\StaticMethodCallableRule' => [['rules.70']], + 'PHPStan\Rules\Names\UsedNamesRule' => [['rules.71']], + 'PHPStan\Rules\Operators\InvalidAssignVarRule' => [['rules.72']], + 'PHPStan\Rules\Properties\AccessPropertiesInAssignRule' => [['rules.73']], + 'PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule' => [['rules.74']], + 'PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule' => [['rules.75']], + 'PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule' => [['rules.76']], + 'PHPStan\Rules\Properties\PropertiesInInterfaceRule' => [['rules.77']], + 'PHPStan\Rules\Properties\PropertyAttributesRule' => [['rules.78']], + 'PHPStan\Rules\Properties\ReadOnlyPropertyRule' => [['rules.79']], + 'PHPStan\Rules\Traits\ConflictingTraitConstantsRule' => [['rules.80']], + 'PHPStan\Rules\Traits\ConstantsInTraitsRule' => [['rules.81']], + 'PHPStan\Rules\Types\InvalidTypesInUnionRule' => [['rules.82']], + 'PHPStan\Rules\Variables\UnsetRule' => [['rules.83']], + 'PHPStan\Rules\Whitespace\FileWhitespaceRule' => [['rules.84']], + 'PHPStan\Rules\Classes\UnusedConstructorParametersRule' => [['rules.85']], + 'PHPStan\Rules\Constants\ConstantRule' => [['rules.86']], + 'PHPStan\Rules\Functions\UnusedClosureUsesRule' => [['rules.87']], + 'PHPStan\Rules\Variables\EmptyRule' => [['rules.88']], + 'PHPStan\Rules\Variables\IssetRule' => [['rules.89']], + 'PHPStan\Rules\Variables\NullCoalesceRule' => [['rules.90']], + 'PHPStan\Rules\Cast\EchoRule' => [['rules.91']], + 'PHPStan\Rules\Cast\InvalidCastRule' => [['rules.92']], + 'PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule' => [['rules.93']], + 'PHPStan\Rules\Cast\PrintRule' => [['rules.94']], + 'PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule' => [['rules.95']], + 'PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule' => [['rules.96']], + 'PHPStan\Rules\Constants\ValueAssignedToClassConstantRule' => [['rules.97']], + 'PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule' => [['rules.98']], + 'PHPStan\Rules\Generics\ClassAncestorsRule' => [['rules.99']], + 'PHPStan\Rules\Generics\ClassTemplateTypeRule' => [['rules.100']], + 'PHPStan\Rules\Generics\EnumAncestorsRule' => [['rules.101']], + 'PHPStan\Rules\Generics\EnumTemplateTypeRule' => [['rules.102']], + 'PHPStan\Rules\Generics\FunctionTemplateTypeRule' => [['rules.103']], + 'PHPStan\Rules\Generics\FunctionSignatureVarianceRule' => [['rules.104']], + 'PHPStan\Rules\Generics\InterfaceAncestorsRule' => [['rules.105']], + 'PHPStan\Rules\Generics\InterfaceTemplateTypeRule' => [['rules.106']], + 'PHPStan\Rules\Generics\MethodTemplateTypeRule' => [['rules.107']], + 'PHPStan\Rules\Generics\MethodTagTemplateTypeRule' => [['rules.108']], + 'PHPStan\Rules\Generics\MethodSignatureVarianceRule' => [['rules.109']], + 'PHPStan\Rules\Generics\TraitTemplateTypeRule' => [['rules.110']], + 'PHPStan\Rules\Generics\UsedTraitsRule' => [['rules.111']], + 'PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule' => [['rules.112']], + 'PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule' => [['rules.113']], + 'PHPStan\Rules\Operators\InvalidComparisonOperationRule' => [['rules.114']], + 'PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule' => [['rules.115']], + 'PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule' => [['rules.116']], + 'PHPStan\Rules\PhpDoc\FunctionAssertRule' => [['rules.117']], + 'PHPStan\Rules\PhpDoc\MethodAssertRule' => [['rules.118']], + 'PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule' => [['rules.119']], + 'PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule' => [['rules.120']], + 'PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule' => [['rules.121']], + 'PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule' => [['rules.122']], + 'PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule' => [['rules.123']], + 'PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule' => [['rules.124']], + 'PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule' => [['rules.125']], + 'PHPStan\Rules\Classes\RequireImplementsRule' => [['rules.126']], + 'PHPStan\Rules\Classes\RequireExtendsRule' => [['rules.127']], + 'PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule' => [['rules.128']], + 'PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule' => [['rules.129']], + 'PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule' => [['rules.130']], + 'PHPStan\Rules\Arrays\ArrayDestructuringRule' => [['rules.131']], + 'PHPStan\Rules\Arrays\IterableInForeachRule' => [['rules.132']], + 'PHPStan\Rules\Arrays\OffsetAccessAssignmentRule' => [['rules.133']], + 'PHPStan\Rules\Arrays\OffsetAccessAssignOpRule' => [['rules.134']], + 'PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule' => [['rules.135']], + 'PHPStan\Rules\Arrays\UnpackIterableInArrayRule' => [['rules.136']], + 'PHPStan\Rules\Exceptions\ThrowExprTypeRule' => [['rules.137']], + 'PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule' => [['rules.138']], + 'PHPStan\Rules\Functions\ClosureReturnTypeRule' => [['rules.139']], + 'PHPStan\Rules\Functions\ReturnTypeRule' => [['rules.140']], + 'PHPStan\Rules\Generators\YieldTypeRule' => [['rules.141']], + 'PHPStan\Rules\Methods\ReturnTypeRule' => [['rules.142']], + 'PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule' => [['rules.143']], + 'PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule' => [['rules.144']], + 'PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule' => [['rules.145']], + 'PHPStan\Rules\Properties\TypesAssignedToPropertiesRule' => [['rules.146']], + 'PHPStan\Rules\Variables\ThrowTypeRule' => [['rules.147']], + 'PHPStan\Rules\Variables\VariableCloningRule' => [['rules.148']], + 'PHPStan\Rules\Arrays\DeadForeachRule' => [['rules.149']], + 'PHPStan\Rules\DeadCode\UnreachableStatementRule' => [['rules.150']], + 'PHPStan\Rules\DeadCode\UnusedPrivateConstantRule' => [['rules.151']], + 'PHPStan\Rules\DeadCode\UnusedPrivateMethodRule' => [['rules.152']], + 'PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule' => [['rules.153']], + 'PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule' => [['rules.154']], + 'PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule' => [['rules.155']], + 'PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule' => [['rules.156']], + 'PHPStan\Rules\Methods\NullsafeMethodCallRule' => [['rules.157']], + 'PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule' => [['rules.158']], + 'PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule' => [['rules.159']], + 'PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule' => [['rules.160']], + 'PHPStan\Rules\DateTimeInstantiationRule' => [['rules.161']], + 'PHPStan\Rules\Constants\MissingClassConstantTypehintRule' => [['rules.162']], + 'PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule' => [['rules.163']], + 'PHPStan\Rules\Methods\MissingMethodReturnTypehintRule' => [['rules.164']], + 'PHPStan\Rules\Properties\MissingPropertyTypehintRule' => [['rules.165']], + 'PhpParser\BuilderFactory' => [['01']], + 'PHPStan\Parser\LexerFactory' => [['02']], + 'PhpParser\NodeVisitorAbstract' => [ + [ + '03', + '04', + '05', + '06', + '07', + '08', + '09', + '010', + '011', + '012', + '013', + '014', + '015', + '016', + '017', + '018', + '019', + '067', + '082', + '091', + ], + ], + 'PhpParser\NodeVisitor' => [ + [ + '03', + '04', + '05', + '06', + '07', + '08', + '09', + '010', + '011', + '012', + '013', + '014', + '015', + '016', + '017', + '018', + '019', + '067', + '082', + '091', + ], + ], + 'PhpParser\NodeVisitor\NameResolver' => [['03']], + 'PHPStan\Parser\AnonymousClassVisitor' => [['04']], + 'PHPStan\Parser\ArrayFilterArgVisitor' => [['05']], + 'PHPStan\Parser\ArrayMapArgVisitor' => [['06']], + 'PHPStan\Parser\ArrayWalkArgVisitor' => [['07']], + 'PHPStan\Parser\ClosureArgVisitor' => [['08']], + 'PHPStan\Parser\ClosureBindToVarVisitor' => [['09']], + 'PHPStan\Parser\ClosureBindArgVisitor' => [['010']], + 'PHPStan\Parser\CurlSetOptArgVisitor' => [['011']], + 'PHPStan\Parser\TypeTraverserInstanceofVisitor' => [['012']], + 'PHPStan\Parser\ArrowFunctionArgVisitor' => [['013']], + 'PHPStan\Parser\MagicConstantParamDefaultVisitor' => [['014']], + 'PHPStan\Parser\NewAssignedToPropertyVisitor' => [['015']], + 'PHPStan\Parser\ParentStmtTypesVisitor' => [['016']], + 'PHPStan\Parser\TryCatchTypeVisitor' => [['017']], + 'PHPStan\Parser\LastConditionVisitor' => [['018']], + 'PhpParser\NodeVisitor\NodeConnectingVisitor' => [['019']], + 'PHPStan\Node\Printer\ExprPrinter' => [['020']], + 'PhpParser\PrettyPrinter\Standard' => [['021']], + 'PhpParser\PrettyPrinterAbstract' => [['021']], + 'PHPStan\Node\Printer\Printer' => [['021']], + 'PHPStan\Broker\AnonymousClassNameHelper' => [['022']], + 'PHPStan\Php\PhpVersion' => [['023']], + 'PHPStan\Php\PhpVersionFactory' => [['024']], + 'PHPStan\Php\PhpVersionFactoryFactory' => [['025']], + 'PHPStan\PhpDocParser\Lexer\Lexer' => [['026']], + 'PHPStan\PhpDocParser\Parser\TypeParser' => [['027']], + 'PHPStan\PhpDocParser\Parser\ConstExprParser' => [['028']], + 'PHPStan\PhpDocParser\Parser\PhpDocParser' => [['029']], + 'PHPStan\PhpDoc\ConstExprParserFactory' => [['030']], + 'PHPStan\PhpDoc\PhpDocInheritanceResolver' => [['031']], + 'PHPStan\PhpDoc\PhpDocNodeResolver' => [['032']], + 'PHPStan\PhpDoc\PhpDocStringResolver' => [['033']], + 'PHPStan\PhpDoc\ConstExprNodeResolver' => [['034']], + 'PHPStan\PhpDoc\TypeNodeResolver' => [['035']], + 'PHPStan\PhpDoc\TypeNodeResolverExtensionRegistryProvider' => [['036']], + 'PHPStan\PhpDoc\TypeStringResolver' => [['037']], + 'PHPStan\PhpDoc\StubValidator' => [['038']], + 'PHPStan\PhpDoc\StubFilesExtension' => [['039', '040', '042', '043']], + 'PHPStan\PhpDoc\CountableStubFilesExtension' => [['039']], + 'PHPStan\PhpDoc\SocketSelectStubFilesExtension' => [['040']], + 'PHPStan\PhpDoc\StubFilesProvider' => [['041']], + 'PHPStan\PhpDoc\DefaultStubFilesProvider' => [['041']], + 'PHPStan\PhpDoc\JsonValidateStubFilesExtension' => [['042']], + 'PHPStan\PhpDoc\ReflectionEnumStubFilesExtension' => [['043']], + 'PHPStan\Analyser\Analyser' => [['044']], + 'PHPStan\Analyser\AnalyserResultFinalizer' => [['045']], + 'PHPStan\Analyser\FileAnalyser' => [['046']], + 'PHPStan\Analyser\LocalIgnoresProcessor' => [['047']], + 'PHPStan\Analyser\RuleErrorTransformer' => [['048']], + 'PHPStan\Analyser\Ignore\IgnoredErrorHelper' => [['049']], + 'PHPStan\Analyser\Ignore\IgnoreLexer' => [['050']], + 'PHPStan\Analyser\InternalScopeFactory' => [['051']], + 'PHPStan\Analyser\LazyInternalScopeFactory' => [['051']], + 'PHPStan\Analyser\ScopeFactory' => [['052']], + 'PHPStan\Analyser\NodeScopeResolver' => [['053']], + 'PHPStan\Analyser\ConstantResolver' => [['054']], + 'PHPStan\Analyser\ConstantResolverFactory' => [['055']], + 'PHPStan\Analyser\ResultCache\ResultCacheManagerFactory' => [['056']], + 'PHPStan\Analyser\ResultCache\ResultCacheClearer' => [['057']], + 'PHPStan\Cache\Cache' => [['058']], + 'PHPStan\Collectors\Registry' => [['059']], + 'PHPStan\Collectors\RegistryFactory' => [['060']], + 'PHPStan\Command\AnalyseApplication' => [['061']], + 'PHPStan\Command\AnalyserRunner' => [['062']], + 'PHPStan\Command\FixerApplication' => [['063']], + 'PHPStan\Dependency\DependencyResolver' => [['064']], + 'PHPStan\Dependency\ExportedNodeFetcher' => [['065']], + 'PHPStan\Dependency\ExportedNodeResolver' => [['066']], + 'PHPStan\Dependency\ExportedNodeVisitor' => [['067']], + 'PHPStan\DependencyInjection\Container' => [['068'], ['069']], + 'PHPStan\DependencyInjection\Nette\NetteContainer' => [['069']], + 'PHPStan\DependencyInjection\DerivativeContainerFactory' => [['070']], + 'PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider' => [['071']], + 'PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider' => [['072']], + 'PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider' => [['073']], + 'PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider' => [['074']], + 'PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider' => [['075']], + 'PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider' => [['076']], + 'PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider' => [['077']], + 'PHPStan\File\FileHelper' => [['078']], + 'PHPStan\File\FileExcluderFactory' => [['079']], + 'PHPStan\File\FileExcluderRawFactory' => [['080']], + 'PHPStan\File\FileExcluder' => [2 => ['fileExcluderAnalyse', 'fileExcluderScan']], + 'PHPStan\File\FileFinder' => [2 => ['fileFinderAnalyse', 'fileFinderScan']], + 'PHPStan\File\FileMonitor' => [['081']], + 'PHPStan\Parser\DeclarePositionVisitor' => [['082']], + 'PHPStan\Parallel\ParallelAnalyser' => [['083']], + 'PHPStan\Diagnose\DiagnoseExtension' => [0 => ['084'], 2 => [1 => 'phpstanDiagnoseExtension']], + 'PHPStan\Parallel\Scheduler' => [['084']], + 'PHPStan\Parser\FunctionCallStatementFinder' => [['085']], + 'PHPStan\Process\CpuCoreCounter' => [['086']], + 'PHPStan\Reflection\FunctionReflectionFactory' => [['087']], + 'PHPStan\Reflection\InitializerExprTypeResolver' => [['088']], + 'PHPStan\Reflection\MethodsClassReflectionExtension' => [['089', '099', '0101', '0103', '0105']], + 'PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension' => [['089']], + 'PHPStan\Reflection\PropertiesClassReflectionExtension' => [['090', '0100', '0102', '0103', '0107', '0258']], + 'PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension' => [['090']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor' => [['091']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher' => [['092']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker' => [['093']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory' => [['094']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository' => [['095']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory' => [['096']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory' => [['097']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository' => [['098']], + 'PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension' => [['099']], + 'PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension' => [['0100']], + 'PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension' => [['0101']], + 'PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension' => [['0102']], + 'PHPStan\Reflection\Php\PhpClassReflectionExtension' => [['0103']], + 'PHPStan\Reflection\Php\PhpMethodReflectionFactory' => [['0104']], + 'PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension' => [['0105']], + 'PHPStan\Reflection\AllowedSubTypesClassReflectionExtension' => [['0106']], + 'PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension' => [['0106']], + 'PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension' => [['0107']], + 'PHPStan\Type\DynamicMethodReturnTypeExtension' => [ + [ + '0108', + '0109', + '0206', + '0217', + '0223', + '0224', + '0228', + '0260', + '0287', + '0313', + '0314', + '0321', + '0322', + '0323', + '0324', + '0325', + '0326', + ], + ], + 'PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension' => [['0108', '0109']], + 'PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider' => [['0110']], + 'PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider' => [['0111']], + 'PHPStan\Reflection\SignatureMap\SignatureMapParser' => [['0112']], + 'PHPStan\Reflection\SignatureMap\SignatureMapProvider' => [['0116'], ['0113', '0114']], + 'PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider' => [['0113']], + 'PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider' => [['0114']], + 'PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory' => [['0115']], + 'PHPStan\Rules\Api\ApiRuleHelper' => [['0117']], + 'PHPStan\Rules\AttributesCheck' => [['0118']], + 'PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck' => [['0119']], + 'PHPStan\Rules\ClassNameCheck' => [['0120']], + 'PHPStan\Rules\ClassCaseSensitivityCheck' => [['0121']], + 'PHPStan\Rules\ClassForbiddenNameCheck' => [['0122']], + 'PHPStan\Rules\Classes\LocalTypeAliasesCheck' => [['0123']], + 'PHPStan\Rules\Classes\MethodTagCheck' => [['0124']], + 'PHPStan\Rules\Classes\PropertyTagCheck' => [['0125']], + 'PHPStan\Rules\Comparison\ConstantConditionRuleHelper' => [['0126']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper' => [['0127']], + 'PHPStan\Rules\Exceptions\ExceptionTypeResolver' => [1 => ['0128'], [1 => 'exceptionTypeResolver']], + 'PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver' => [['0128']], + 'PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule' => [['0129']], + 'PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule' => [['0130']], + 'PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck' => [['0131']], + 'PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule' => [['0132']], + 'PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule' => [['0133']], + 'PHPStan\Rules\Exceptions\TooWideThrowTypeCheck' => [['0134']], + 'PHPStan\Rules\FunctionCallParametersCheck' => [['0135']], + 'PHPStan\Rules\FunctionDefinitionCheck' => [['0136']], + 'PHPStan\Rules\FunctionReturnTypeCheck' => [['0137']], + 'PHPStan\Rules\ParameterCastableToStringCheck' => [['0138']], + 'PHPStan\Rules\Generics\CrossCheckInterfacesHelper' => [['0139']], + 'PHPStan\Rules\Generics\GenericAncestorsCheck' => [['0140']], + 'PHPStan\Rules\Generics\GenericObjectTypeCheck' => [['0141']], + 'PHPStan\Rules\Generics\TemplateTypeCheck' => [['0142']], + 'PHPStan\Rules\Generics\VarianceCheck' => [['0143']], + 'PHPStan\Rules\IssetCheck' => [['0144']], + 'PHPStan\Rules\Methods\MethodCallCheck' => [['0145']], + 'PHPStan\Rules\Methods\StaticMethodCallCheck' => [['0146']], + 'PHPStan\Rules\Methods\MethodSignatureRule' => [['0147']], + 'PHPStan\Rules\Methods\MethodParameterComparisonHelper' => [['0148']], + 'PHPStan\Rules\MissingTypehintCheck' => [['0149']], + 'PHPStan\Rules\NullsafeCheck' => [['0150']], + 'PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtensionProvider' => [['0151']], + 'PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider' => [['0151']], + 'PHPStan\Rules\Methods\AlwaysUsedMethodExtensionProvider' => [['0152']], + 'PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider' => [['0152']], + 'PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper' => [['0153']], + 'PHPStan\Rules\PhpDoc\AssertRuleHelper' => [['0154']], + 'PHPStan\Rules\PhpDoc\UnresolvableTypeHelper' => [['0155']], + 'PHPStan\Rules\PhpDoc\GenericCallableRuleHelper' => [['0156']], + 'PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper' => [['0157']], + 'PHPStan\Rules\Playground\NeverRuleHelper' => [['0158']], + 'PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider' => [['0159']], + 'PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider' => [['0159']], + 'PHPStan\Rules\Properties\PropertyDescriptor' => [['0160']], + 'PHPStan\Rules\Properties\PropertyReflectionFinder' => [['0161']], + 'PHPStan\Rules\Pure\FunctionPurityCheck' => [['0162']], + 'PHPStan\Rules\RuleLevelHelper' => [['0163']], + 'PHPStan\Rules\UnusedFunctionParametersCheck' => [['0164']], + 'PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck' => [['0165']], + 'PHPStan\Type\FileTypeMapper' => [['0166']], + 'PHPStan\Type\TypeAliasResolver' => [['0167']], + 'PHPStan\Type\TypeAliasResolverProvider' => [['0168']], + 'PHPStan\Type\BitwiseFlagHelper' => [['0169']], + 'PHPStan\Type\DynamicFunctionReturnTypeExtension' => [ + [ + '0170', + '0171', + '0172', + '0173', + '0174', + '0175', + '0176', + '0177', + '0178', + '0179', + '0180', + '0181', + '0183', + '0184', + '0185', + '0186', + '0187', + '0188', + '0189', + '0190', + '0191', + '0192', + '0193', + '0194', + '0195', + '0196', + '0197', + '0199', + '0200', + '0203', + '0204', + '0208', + '0209', + '0211', + '0213', + '0214', + '0216', + '0218', + '0221', + '0222', + '0230', + '0231', + '0233', + '0234', + '0235', + '0236', + '0237', + '0238', + '0239', + '0240', + '0241', + '0242', + '0243', + '0245', + '0260', + '0263', + '0264', + '0265', + '0266', + '0267', + '0269', + '0270', + '0271', + '0272', + '0273', + '0274', + '0275', + '0276', + '0277', + '0278', + '0279', + '0281', + '0282', + '0283', + '0284', + '0285', + '0286', + '0288', + '0289', + '0290', + '0291', + '0292', + '0293', + '0294', + '0295', + '0298', + '0307', + '0311', + '0312', + '0315', + '0316', + '0317', + '0318', + '0319', + '0320', + ], + ], + 'PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension' => [['0170']], + 'PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension' => [['0171']], + 'PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension' => [['0172']], + 'PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension' => [['0173']], + 'PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension' => [['0174']], + 'PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension' => [['0175']], + 'PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension' => [['0176']], + 'PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension' => [['0177']], + 'PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension' => [['0178']], + 'PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension' => [['0179']], + 'PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension' => [['0180']], + 'PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension' => [['0181']], + 'PHPStan\Type\FunctionTypeSpecifyingExtension' => [ + [ + '0182', + '0198', + '0212', + '0247', + '0257', + '0261', + '0262', + '0280', + '0296', + '0297', + '0299', + '0300', + '0301', + '0302', + '0303', + '0304', + '0305', + '0306', + '0308', + '0310', + ], + ], + 'PHPStan\Analyser\TypeSpecifierAwareExtension' => [ + [ + '0182', + '0198', + '0212', + '0247', + '0257', + '0261', + '0262', + '0268', + '0280', + '0296', + '0297', + '0299', + '0300', + '0301', + '0302', + '0303', + '0304', + '0305', + '0306', + '0308', + '0310', + '0312', + ], + ], + 'PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension' => [['0182']], + 'PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension' => [['0183']], + 'PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension' => [['0184']], + 'PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension' => [['0185']], + 'PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension' => [['0186']], + 'PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension' => [['0187']], + 'PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension' => [['0188']], + 'PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension' => [['0189']], + 'PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension' => [['0190']], + 'PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension' => [['0191']], + 'PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension' => [['0192']], + 'PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension' => [['0193']], + 'PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension' => [['0194']], + 'PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension' => [['0195']], + 'PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension' => [['0196']], + 'PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension' => [['0197']], + 'PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension' => [['0198']], + 'PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension' => [['0199']], + 'PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension' => [['0200']], + 'PHPStan\Type\DynamicFunctionThrowTypeExtension' => [['0201', '0244', '0246']], + 'PHPStan\Type\Php\AssertThrowTypeExtension' => [['0201']], + 'PHPStan\Type\DynamicStaticMethodReturnTypeExtension' => [['0202', '0205', '0207', '0220', '0321', '0327']], + 'PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension' => [['0202']], + 'PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension' => [['0203']], + 'PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension' => [['0204']], + 'PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension' => [['0205']], + 'PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension' => [['0206']], + 'PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension' => [['0207']], + 'PHPStan\Type\Php\CompactFunctionReturnTypeExtension' => [['0208']], + 'PHPStan\Type\Php\ConstantFunctionReturnTypeExtension' => [['0209']], + 'PHPStan\Type\Php\ConstantHelper' => [['0210']], + 'PHPStan\Type\Php\CountFunctionReturnTypeExtension' => [['0211']], + 'PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension' => [['0212']], + 'PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension' => [['0213']], + 'PHPStan\Type\Php\CurlInitReturnTypeExtension' => [['0214']], + 'PHPStan\Type\Php\DateFunctionReturnTypeHelper' => [['0215']], + 'PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension' => [['0216']], + 'PHPStan\Type\Php\DateFormatMethodReturnTypeExtension' => [['0217']], + 'PHPStan\Type\Php\DateFunctionReturnTypeExtension' => [['0218']], + 'PHPStan\Type\DynamicStaticMethodThrowTypeExtension' => [ + ['0219', '0225', '0227', '0253', '0254', '0255', '0256', '0259'], + ], + 'PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension' => [['0219']], + 'PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension' => [['0220']], + 'PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension' => [['0221']], + 'PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension' => [['0222']], + 'PHPStan\Type\Php\DateTimeModifyReturnTypeExtension' => [['0223', '0224']], + 'PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension' => [['0225']], + 'PHPStan\Type\DynamicMethodThrowTypeExtension' => [['0226', '0229']], + 'PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension' => [['0226']], + 'PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension' => [['0227']], + 'PHPStan\Type\Php\DsMapDynamicReturnTypeExtension' => [['0228']], + 'PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension' => [['0229']], + 'PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension' => [['0230']], + 'PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension' => [['0231']], + 'PHPStan\Type\Php\FilterFunctionReturnTypeHelper' => [['0232']], + 'PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension' => [['0233']], + 'PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension' => [['0234']], + 'PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension' => [['0235']], + 'PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension' => [['0236']], + 'PHPStan\Type\Php\GetClassDynamicReturnTypeExtension' => [['0237']], + 'PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension' => [['0238']], + 'PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension' => [['0239']], + 'PHPStan\Type\Php\GettypeFunctionReturnTypeExtension' => [['0240']], + 'PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension' => [['0241']], + 'PHPStan\Type\Php\HashFunctionsReturnTypeExtension' => [['0242']], + 'PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension' => [['0243']], + 'PHPStan\Type\Php\IntdivThrowTypeExtension' => [['0244']], + 'PHPStan\Type\Php\IniGetReturnTypeExtension' => [['0245']], + 'PHPStan\Type\Php\JsonThrowTypeExtension' => [['0246']], + 'PHPStan\Type\Php\PregMatchTypeSpecifyingExtension' => [['0247']], + 'PHPStan\Type\FunctionParameterOutTypeExtension' => [['0248']], + 'PHPStan\Type\Php\PregMatchParameterOutTypeExtension' => [['0248']], + 'PHPStan\Type\FunctionParameterClosureTypeExtension' => [['0249']], + 'PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension' => [['0249']], + 'PHPStan\Type\Php\RegexArrayShapeMatcher' => [['0250']], + 'PHPStan\Type\Regex\RegexGroupParser' => [['0251']], + 'PHPStan\Type\Regex\RegexExpressionHelper' => [['0252']], + 'PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension' => [['0253']], + 'PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension' => [['0254']], + 'PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension' => [['0255']], + 'PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension' => [['0256']], + 'PHPStan\Type\Php\StrContainingTypeSpecifyingExtension' => [['0257']], + 'PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension' => [['0258']], + 'PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension' => [['0259']], + 'PHPStan\Type\Php\StatDynamicReturnTypeExtension' => [['0260']], + 'PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension' => [['0261']], + 'PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension' => [['0262']], + 'PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension' => [['0263']], + 'PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension' => [['0264']], + 'PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension' => [['0265']], + 'PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension' => [['0266']], + 'PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension' => [['0267']], + 'PHPStan\Type\MethodTypeSpecifyingExtension' => [['0268']], + 'PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension' => [['0268']], + 'PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension' => [['0269']], + 'PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension' => [['0270']], + 'PHPStan\Type\Php\LtrimFunctionReturnTypeExtension' => [['0271']], + 'PHPStan\Type\Php\MbFunctionsReturnTypeExtension' => [['0272']], + 'PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension' => [['0273']], + 'PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension' => [['0274']], + 'PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension' => [['0275']], + 'PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension' => [['0276']], + 'PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension' => [['0277']], + 'PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension' => [['0278']], + 'PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension' => [['0279']], + 'PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension' => [['0280']], + 'PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension' => [['0281']], + 'PHPStan\Type\Php\StrlenFunctionReturnTypeExtension' => [['0282']], + 'PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension' => [['0283']], + 'PHPStan\Type\Php\StrPadFunctionReturnTypeExtension' => [['0284']], + 'PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension' => [['0285']], + 'PHPStan\Type\Php\SubstrDynamicReturnTypeExtension' => [['0286']], + 'PHPStan\Type\Php\ThrowableReturnTypeExtension' => [['0287']], + 'PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension' => [['0288']], + 'PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension' => [['0289']], + 'PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension' => [['0290']], + 'PHPStan\Type\Php\PowFunctionReturnTypeExtension' => [['0291']], + 'PHPStan\Type\Php\RoundFunctionReturnTypeExtension' => [['0292']], + 'PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension' => [['0293']], + 'PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension' => [['0294']], + 'PHPStan\Type\Php\RangeFunctionReturnTypeExtension' => [['0295']], + 'PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension' => [['0296']], + 'PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension' => [['0297']], + 'PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension' => [['0298']], + 'PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension' => [['0299']], + 'PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension' => [['0300']], + 'PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension' => [['0301']], + 'PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension' => [['0302']], + 'PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension' => [['0303']], + 'PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension' => [['0304']], + 'PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension' => [['0305']], + 'PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension' => [['0306']], + 'PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension' => [['0307']], + 'PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension' => [['0308']], + 'PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper' => [['0309']], + 'PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension' => [['0310']], + 'PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension' => [['0311']], + 'PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension' => [['0312']], + 'PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension' => [['0313']], + 'PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension' => [['0314']], + 'PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension' => [['0315']], + 'PHPStan\Type\Php\StrTokFunctionReturnTypeExtension' => [['0316']], + 'PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension' => [['0317']], + 'PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension' => [['0318']], + 'PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension' => [['0319']], + 'PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension' => [['0320']], + 'PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension' => [['0321']], + 'PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension' => [['0322', '0323', '0324', '0325', '0326']], + 'PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension' => [['0327']], + 'PHPStan\Type\ClosureTypeFactory' => [['0328']], + 'PHPStan\Type\Constant\OversizedArrayBuilder' => [['0329']], + 'PHPStan\Rules\Functions\PrintfHelper' => [['0330']], + 'PHPStan\Analyser\TypeSpecifier' => [['typeSpecifier']], + 'PHPStan\Analyser\TypeSpecifierFactory' => [['typeSpecifierFactory']], + 'PHPStan\File\RelativePathHelper' => [ + 0 => ['relativePathHelper'], + 2 => [1 => 'simpleRelativePathHelper', 'parentDirectoryRelativePathHelper'], + ], + 'PHPStan\File\ParentDirectoryRelativePathHelper' => [2 => ['parentDirectoryRelativePathHelper']], + 'PHPStan\Reflection\ReflectionProvider' => [['reflectionProvider'], ['broker'], [2 => 'betterReflectionProvider']], + 'PHPStan\Broker\Broker' => [['broker']], + 'PHPStan\Broker\BrokerFactory' => [['brokerFactory']], + 'PHPStan\Cache\CacheStorage' => [2 => ['cacheStorage']], + 'PHPStan\Cache\FileCacheStorage' => [2 => ['cacheStorage']], + 'PHPStan\Parser\Parser' => [ + 2 => [ + 'currentPhpVersionRichParser', + 'currentPhpVersionSimpleParser', + 'currentPhpVersionSimpleDirectParser', + 'defaultAnalysisParser', + 'php8Parser', + 'pathRoutingParser', + ], + ], + 'PHPStan\Parser\RichParser' => [2 => ['currentPhpVersionRichParser']], + 'PHPStan\Parser\CleaningParser' => [2 => ['currentPhpVersionSimpleParser']], + 'PHPStan\Parser\SimpleParser' => [2 => ['currentPhpVersionSimpleDirectParser', 'php8Parser']], + 'PHPStan\Parser\CachedParser' => [2 => ['defaultAnalysisParser']], + 'PhpParser\Parser' => [2 => ['phpParserDecorator', 'currentPhpVersionPhpParser', 'php8PhpParser']], + 'PHPStan\Parser\PhpParserDecorator' => [2 => ['phpParserDecorator']], + 'PhpParser\Lexer' => [2 => ['currentPhpVersionLexer', 'php8Lexer']], + 'PhpParser\ParserAbstract' => [2 => ['currentPhpVersionPhpParser', 'php8PhpParser']], + 'PhpParser\Parser\Php7' => [2 => ['currentPhpVersionPhpParser', 'php8PhpParser']], + 'PHPStan\Rules\Registry' => [['registry']], + 'PHPStan\Rules\LazyRegistry' => [['registry']], + 'PHPStan\PhpDoc\StubPhpDocProvider' => [['stubPhpDocProvider']], + 'PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory' => [['reflectionProviderFactory']], + 'PHPStan\BetterReflection\SourceLocator\Type\SourceLocator' => [2 => ['betterReflectionSourceLocator']], + 'PHPStan\BetterReflection\Reflector\Reflector' => [ + 0 => ['originalBetterReflectionReflector'], + 2 => [ + 1 => 'betterReflectionReflector', + 'betterReflectionClassReflector', + 'betterReflectionFunctionReflector', + 'betterReflectionConstantReflector', + 'nodeScopeResolverReflector', + ], + ], + 'PHPStan\BetterReflection\Reflector\DefaultReflector' => [['originalBetterReflectionReflector']], + 'PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector' => [ + 2 => ['betterReflectionReflector', 'nodeScopeResolverReflector'], + ], + 'PHPStan\BetterReflection\Reflector\ClassReflector' => [2 => ['betterReflectionClassReflector']], + 'PHPStan\BetterReflection\Reflector\FunctionReflector' => [2 => ['betterReflectionFunctionReflector']], + 'PHPStan\BetterReflection\Reflector\ConstantReflector' => [2 => ['betterReflectionConstantReflector']], + 'PHPStan\Reflection\BetterReflection\BetterReflectionProvider' => [2 => ['betterReflectionProvider']], + 'PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory' => [['0331']], + 'PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory' => [['0332']], + 'PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory' => [['0333']], + 'PHPStan\BetterReflection\SourceLocator\SourceStubber\SourceStubber' => [1 => ['0334', '0335']], + 'PHPStan\BetterReflection\SourceLocator\SourceStubber\PhpStormStubsSourceStubber' => [['0334']], + 'PHPStan\BetterReflection\SourceLocator\SourceStubber\ReflectionSourceStubber' => [['0335']], + 'PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory' => [['0336']], + 'PhpParser\Lexer\Emulative' => [2 => ['php8Lexer']], + 'PHPStan\Parser\PathRoutingParser' => [2 => ['pathRoutingParser']], + 'PHPStan\Diagnose\PHPStanDiagnoseExtension' => [2 => ['phpstanDiagnoseExtension']], + 'PHPStan\Command\ErrorFormatter\ErrorFormatter' => [ + [ + 'errorFormatter.raw', + 'errorFormatter.table', + 'errorFormatter.checkstyle', + 'errorFormatter.json', + 'errorFormatter.junit', + 'errorFormatter.prettyJson', + 'errorFormatter.gitlab', + 'errorFormatter.github', + 'errorFormatter.teamcity', + ], + ['0337'], + ], + 'PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter' => [['0337']], + 'PHPStan\Command\ErrorFormatter\RawErrorFormatter' => [['errorFormatter.raw']], + 'PHPStan\Command\ErrorFormatter\TableErrorFormatter' => [['errorFormatter.table']], + 'PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter' => [['errorFormatter.checkstyle']], + 'PHPStan\Command\ErrorFormatter\JsonErrorFormatter' => [['errorFormatter.json', 'errorFormatter.prettyJson']], + 'PHPStan\Command\ErrorFormatter\JunitErrorFormatter' => [['errorFormatter.junit']], + 'PHPStan\Command\ErrorFormatter\GitlabErrorFormatter' => [['errorFormatter.gitlab']], + 'PHPStan\Command\ErrorFormatter\GithubErrorFormatter' => [['errorFormatter.github']], + 'PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter' => [['errorFormatter.teamcity']], + 'PHPStan\Rules\Api\ApiClassConstFetchRule' => [['0338']], + 'PHPStan\Rules\Api\ApiInstanceofRule' => [['0339']], + 'PHPStan\Rules\Api\ApiInstanceofTypeRule' => [['0340']], + 'PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule' => [['0341']], + 'PHPStan\Rules\Api\RuntimeReflectionFunctionRule' => [['0342']], + 'PHPStan\Rules\Api\RuntimeReflectionInstantiationRule' => [['0343']], + 'PHPStan\Rules\Classes\ExistingClassInClassExtendsRule' => [['0344']], + 'PHPStan\Rules\Classes\ExistingClassInInstanceOfRule' => [['0345']], + 'PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule' => [['0346']], + 'PHPStan\Rules\Functions\CallToNonExistentFunctionRule' => [['0347']], + 'PHPStan\Rules\Constants\OverridingConstantRule' => [['0348']], + 'PHPStan\Rules\Methods\OverridingMethodRule' => [['0349']], + 'PHPStan\Rules\Methods\ConsistentConstructorRule' => [['0350']], + 'PHPStan\Rules\Missing\MissingReturnRule' => [['0351']], + 'PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule' => [['0352']], + 'PHPStan\Rules\Namespaces\ExistingNamesInUseRule' => [['0353']], + 'PHPStan\Rules\Operators\InvalidIncDecOperationRule' => [['0354']], + 'PHPStan\Rules\Properties\AccessPropertiesRule' => [['0355']], + 'PHPStan\Rules\Properties\AccessStaticPropertiesRule' => [['0356']], + 'PHPStan\Rules\Properties\ExistingClassesInPropertiesRule' => [['0357']], + 'PHPStan\Rules\Functions\FunctionCallableRule' => [['0358']], + 'PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule' => [['0359']], + 'PHPStan\Rules\Properties\OverridingPropertyRule' => [['0360']], + 'PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule' => [['0361']], + 'PHPStan\Rules\Properties\UninitializedPropertyRule' => [['0362']], + 'PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule' => [['0363']], + 'PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule' => [['0364']], + 'PHPStan\Rules\Variables\CompactVariablesRule' => [['0365']], + 'PHPStan\Rules\Variables\DefinedVariableRule' => [['0366']], + 'PHPStan\Rules\Regexp\RegularExpressionPatternRule' => [['0367']], + 'PHPStan\Reflection\ConstructorsHelper' => [['0368']], + 'PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule' => [['0369']], + 'PHPStan\Rules\Constants\MagicConstantContextRule' => [['0370']], + 'PHPStan\Rules\Functions\UselessFunctionReturnValueRule' => [['0371']], + 'PHPStan\Rules\Functions\PrintfArrayParametersRule' => [['0372']], + 'PHPStan\Rules\Regexp\RegularExpressionQuotingRule' => [['0373']], + 'PHPStan\Rules\Classes\MixinRule' => [['0374']], + 'PHPStan\Rules\Classes\MethodTagRule' => [['0375']], + 'PHPStan\Rules\Classes\MethodTagTraitRule' => [['0376']], + 'PHPStan\Rules\Classes\PropertyTagRule' => [['0377']], + 'PHPStan\Rules\Classes\PropertyTagTraitRule' => [['0378']], + 'PHPStan\Rules\PhpDoc\RequireExtendsCheck' => [['0379']], + 'PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule' => [['0380']], + 'PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule' => [['0381']], + 'PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule' => [['0382']], + 'PHPStan\Rules\Functions\CallCallablesRule' => [['0383']], + 'PHPStan\Rules\Methods\IllegalConstructorMethodCallRule' => [['0384']], + 'PHPStan\Rules\Methods\IllegalConstructorStaticCallRule' => [['0385']], + 'PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule' => [['0386']], + 'PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule' => [['0387']], + 'PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule' => [['0388']], + 'PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule' => [['0389']], + 'PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule' => [['0390']], + 'PHPStan\Rules\Generics\PropertyVarianceRule' => [['0391']], + 'PHPStan\Rules\Pure\PureFunctionRule' => [['0392']], + 'PHPStan\Rules\Pure\PureMethodRule' => [['0393']], + 'PHPStan\Rules\Operators\InvalidBinaryOperationRule' => [['0394']], + 'PHPStan\Rules\Operators\InvalidUnaryOperationRule' => [['0395']], + 'PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule' => [['0396']], + 'PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule' => [['0397']], + 'PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule' => [['0398']], + 'PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule' => [['0399']], + 'PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule' => [['0400']], + 'PHPStan\Rules\Generators\YieldFromTypeRule' => [['0401']], + 'PHPStan\Rules\Generators\YieldInGeneratorRule' => [['0402']], + 'PHPStan\Rules\Arrays\ArrayUnpackingRule' => [['0403']], + 'PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule' => [['0404']], + 'PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule' => [['0405']], + 'PHPStan\Rules\Variables\ParameterOutAssignedTypeRule' => [['0406']], + 'PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule' => [['0407']], + 'PHPStan\Rules\Classes\ImpossibleInstanceOfRule' => [['0408']], + 'PHPStan\Rules\Comparison\BooleanAndConstantConditionRule' => [['0409']], + 'PHPStan\Rules\Comparison\BooleanOrConstantConditionRule' => [['0410']], + 'PHPStan\Rules\Comparison\BooleanNotConstantConditionRule' => [['0411']], + 'PHPStan\Rules\DeadCode\NoopRule' => [['0412']], + 'PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule' => [['0413']], + 'PHPStan\Collectors\Collector' => [['0414', '0415', '0417', '0418', '0420', '0421', '0423', '0445', '0446']], + 'PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector' => [['0414']], + 'PHPStan\Rules\DeadCode\PossiblyPureNewCollector' => [['0415']], + 'PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule' => [['0416']], + 'PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector' => [['0417']], + 'PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector' => [['0418']], + 'PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule' => [['0419']], + 'PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector' => [['0420']], + 'PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector' => [['0421']], + 'PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule' => [['0422']], + 'PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector' => [['0423']], + 'PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule' => [['0424']], + 'PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule' => [['0425']], + 'PHPStan\Rules\Comparison\ElseIfConstantConditionRule' => [['0426']], + 'PHPStan\Rules\Comparison\IfConstantConditionRule' => [['0427']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule' => [['0428']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule' => [['0429']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule' => [['0430']], + 'PHPStan\Rules\Comparison\LogicalXorConstantConditionRule' => [['0431']], + 'PHPStan\Rules\DeadCode\BetterNoopRule' => [['0432']], + 'PHPStan\Rules\Comparison\MatchExpressionRule' => [['0433']], + 'PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule' => [['0434']], + 'PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule' => [['0435']], + 'PHPStan\Rules\Comparison\ConstantLooseComparisonRule' => [['0436']], + 'PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule' => [['0437']], + 'PHPStan\Rules\Comparison\UnreachableIfBranchesRule' => [['0438']], + 'PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule' => [['0439']], + 'PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule' => [['0440']], + 'PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule' => [['0441']], + 'PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule' => [['0442']], + 'PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule' => [['0443']], + 'PHPStan\Rules\Properties\NullsafePropertyFetchRule' => [['0444']], + 'PHPStan\Rules\Traits\TraitDeclarationCollector' => [['0445']], + 'PHPStan\Rules\Traits\TraitUseCollector' => [['0446']], + 'PHPStan\Rules\Traits\NotAnalysedTraitRule' => [['0447']], + 'PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule' => [['0448']], + 'PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule' => [['0449']], + 'PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule' => [['0450']], + 'PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule' => [['0451']], + 'PHPStan\Rules\Functions\RandomIntParametersRule' => [['0452']], + 'PHPStan\Rules\Functions\ArrayFilterRule' => [['0453']], + 'PHPStan\Rules\Functions\ArrayValuesRule' => [['0454']], + 'PHPStan\Rules\Functions\CallUserFuncRule' => [['0455']], + 'PHPStan\Rules\Functions\ImplodeFunctionRule' => [['0456']], + 'PHPStan\Rules\Functions\ParameterCastableToStringRule' => [['0457']], + 'PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule' => [['0458']], + 'PHPStan\Rules\Functions\SortParameterCastableToStringRule' => [['0459']], + 'PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule' => [['0460']], + 'PHPStan\Rules\Methods\MissingMethodParameterTypehintRule' => [['0461']], + 'PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule' => [['0462']], + ]; + + + public function __construct(array $params = []) + { + parent::__construct($params); + } + + + public function createService01(): PhpParser\BuilderFactory + { + return new PhpParser\BuilderFactory; + } + + + public function createService02(): PHPStan\Parser\LexerFactory + { + return new PHPStan\Parser\LexerFactory($this->getService('023')); + } + + + public function createService03(): PhpParser\NodeVisitor\NameResolver + { + return new PhpParser\NodeVisitor\NameResolver(options: ['preserveOriginalNames' => true]); + } + + + public function createService04(): PHPStan\Parser\AnonymousClassVisitor + { + return new PHPStan\Parser\AnonymousClassVisitor; + } + + + public function createService05(): PHPStan\Parser\ArrayFilterArgVisitor + { + return new PHPStan\Parser\ArrayFilterArgVisitor; + } + + + public function createService06(): PHPStan\Parser\ArrayMapArgVisitor + { + return new PHPStan\Parser\ArrayMapArgVisitor; + } + + + public function createService07(): PHPStan\Parser\ArrayWalkArgVisitor + { + return new PHPStan\Parser\ArrayWalkArgVisitor; + } + + + public function createService08(): PHPStan\Parser\ClosureArgVisitor + { + return new PHPStan\Parser\ClosureArgVisitor; + } + + + public function createService09(): PHPStan\Parser\ClosureBindToVarVisitor + { + return new PHPStan\Parser\ClosureBindToVarVisitor; + } + + + public function createService010(): PHPStan\Parser\ClosureBindArgVisitor + { + return new PHPStan\Parser\ClosureBindArgVisitor; + } + + + public function createService011(): PHPStan\Parser\CurlSetOptArgVisitor + { + return new PHPStan\Parser\CurlSetOptArgVisitor; + } + + + public function createService012(): PHPStan\Parser\TypeTraverserInstanceofVisitor + { + return new PHPStan\Parser\TypeTraverserInstanceofVisitor; + } + + + public function createService013(): PHPStan\Parser\ArrowFunctionArgVisitor + { + return new PHPStan\Parser\ArrowFunctionArgVisitor; + } + + + public function createService014(): PHPStan\Parser\MagicConstantParamDefaultVisitor + { + return new PHPStan\Parser\MagicConstantParamDefaultVisitor; + } + + + public function createService015(): PHPStan\Parser\NewAssignedToPropertyVisitor + { + return new PHPStan\Parser\NewAssignedToPropertyVisitor; + } + + + public function createService016(): PHPStan\Parser\ParentStmtTypesVisitor + { + return new PHPStan\Parser\ParentStmtTypesVisitor; + } + + + public function createService017(): PHPStan\Parser\TryCatchTypeVisitor + { + return new PHPStan\Parser\TryCatchTypeVisitor; + } + + + public function createService018(): PHPStan\Parser\LastConditionVisitor + { + return new PHPStan\Parser\LastConditionVisitor; + } + + + public function createService019(): PhpParser\NodeVisitor\NodeConnectingVisitor + { + return new PhpParser\NodeVisitor\NodeConnectingVisitor; + } + + + public function createService020(): PHPStan\Node\Printer\ExprPrinter + { + return new PHPStan\Node\Printer\ExprPrinter($this->getService('021')); + } + + + public function createService021(): PHPStan\Node\Printer\Printer + { + return new PHPStan\Node\Printer\Printer; + } + + + public function createService022(): PHPStan\Broker\AnonymousClassNameHelper + { + return new PHPStan\Broker\AnonymousClassNameHelper($this->getService('078'), $this->getService('simpleRelativePathHelper')); + } + + + public function createService023(): PHPStan\Php\PhpVersion + { + return $this->getService('024')->create(); + } + + + public function createService024(): PHPStan\Php\PhpVersionFactory + { + return $this->getService('025')->create(); + } + + + public function createService025(): PHPStan\Php\PhpVersionFactoryFactory + { + return new PHPStan\Php\PhpVersionFactoryFactory(null, ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo']); + } + + + public function createService026(): PHPStan\PhpDocParser\Lexer\Lexer + { + return new PHPStan\PhpDocParser\Lexer\Lexer; + } + + + public function createService027(): PHPStan\PhpDocParser\Parser\TypeParser + { + return new PHPStan\PhpDocParser\Parser\TypeParser($this->getService('028'), false); + } + + + public function createService028(): PHPStan\PhpDocParser\Parser\ConstExprParser + { + return $this->getService('030')->create(); + } + + + public function createService029(): PHPStan\PhpDocParser\Parser\PhpDocParser + { + return new PHPStan\PhpDocParser\Parser\PhpDocParser( + $this->getService('027'), + $this->getService('028'), + false, + true, + ['lines' => false] + ); + } + + + public function createService030(): PHPStan\PhpDoc\ConstExprParserFactory + { + return new PHPStan\PhpDoc\ConstExprParserFactory(false); + } + + + public function createService031(): PHPStan\PhpDoc\PhpDocInheritanceResolver + { + return new PHPStan\PhpDoc\PhpDocInheritanceResolver($this->getService('0166'), $this->getService('stubPhpDocProvider')); + } + + + public function createService032(): PHPStan\PhpDoc\PhpDocNodeResolver + { + return new PHPStan\PhpDoc\PhpDocNodeResolver($this->getService('035'), $this->getService('034'), $this->getService('0155')); + } + + + public function createService033(): PHPStan\PhpDoc\PhpDocStringResolver + { + return new PHPStan\PhpDoc\PhpDocStringResolver($this->getService('026'), $this->getService('029')); + } + + + public function createService034(): PHPStan\PhpDoc\ConstExprNodeResolver + { + return new PHPStan\PhpDoc\ConstExprNodeResolver($this->getService('0110'), $this->getService('088')); + } + + + public function createService035(): PHPStan\PhpDoc\TypeNodeResolver + { + return new PHPStan\PhpDoc\TypeNodeResolver( + $this->getService('036'), + $this->getService('0110'), + $this->getService('0168'), + $this->getService('054'), + $this->getService('088') + ); + } + + + public function createService036(): PHPStan\PhpDoc\TypeNodeResolverExtensionRegistryProvider + { + return new PHPStan\PhpDoc\LazyTypeNodeResolverExtensionRegistryProvider($this->getService('068')); + } + + + public function createService037(): PHPStan\PhpDoc\TypeStringResolver + { + return new PHPStan\PhpDoc\TypeStringResolver($this->getService('026'), $this->getService('027'), $this->getService('035')); + } + + + public function createService038(): PHPStan\PhpDoc\StubValidator + { + return new PHPStan\PhpDoc\StubValidator($this->getService('070'), false); + } + + + public function createService039(): PHPStan\PhpDoc\CountableStubFilesExtension + { + return new PHPStan\PhpDoc\CountableStubFilesExtension(false); + } + + + public function createService040(): PHPStan\PhpDoc\SocketSelectStubFilesExtension + { + return new PHPStan\PhpDoc\SocketSelectStubFilesExtension($this->getService('023')); + } + + + public function createService041(): PHPStan\PhpDoc\DefaultStubFilesProvider + { + return new PHPStan\PhpDoc\DefaultStubFilesProvider( + $this->getService('068'), + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionAttribute.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClass.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClassConstant.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionFunctionAbstract.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionMethod.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionParameter.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionProperty.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/iterable.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ArrayObject.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/WeakReference.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ext-ds.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ImagickPixel.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/PDOStatement.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/date.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ibm_db2.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/mysqli.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/zip.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/dom.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/spl.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/SplObjectStorage.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/Exception.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/arrayFunctions.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/core.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/typeCheckingFunctions.stub', + ], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'] + ); + } + + + public function createService042(): PHPStan\PhpDoc\JsonValidateStubFilesExtension + { + return new PHPStan\PhpDoc\JsonValidateStubFilesExtension($this->getService('023')); + } + + + public function createService043(): PHPStan\PhpDoc\ReflectionEnumStubFilesExtension + { + return new PHPStan\PhpDoc\ReflectionEnumStubFilesExtension($this->getService('023')); + } + + + public function createService044(): PHPStan\Analyser\Analyser + { + return new PHPStan\Analyser\Analyser( + $this->getService('046'), + $this->getService('registry'), + $this->getService('059'), + $this->getService('053'), + 50 + ); + } + + + public function createService045(): PHPStan\Analyser\AnalyserResultFinalizer + { + return new PHPStan\Analyser\AnalyserResultFinalizer( + $this->getService('registry'), + $this->getService('048'), + $this->getService('052'), + $this->getService('047'), + true + ); + } + + + public function createService046(): PHPStan\Analyser\FileAnalyser + { + return new PHPStan\Analyser\FileAnalyser( + $this->getService('052'), + $this->getService('053'), + $this->getService('defaultAnalysisParser'), + $this->getService('064'), + $this->getService('048'), + $this->getService('047') + ); + } + + + public function createService047(): PHPStan\Analyser\LocalIgnoresProcessor + { + return new PHPStan\Analyser\LocalIgnoresProcessor; + } + + + public function createService048(): PHPStan\Analyser\RuleErrorTransformer + { + return new PHPStan\Analyser\RuleErrorTransformer; + } + + + public function createService049(): PHPStan\Analyser\Ignore\IgnoredErrorHelper + { + return new PHPStan\Analyser\Ignore\IgnoredErrorHelper($this->getService('078'), [], true); + } + + + public function createService050(): PHPStan\Analyser\Ignore\IgnoreLexer + { + return new PHPStan\Analyser\Ignore\IgnoreLexer; + } + + + public function createService051(): PHPStan\Analyser\LazyInternalScopeFactory + { + return new PHPStan\Analyser\LazyInternalScopeFactory('PHPStan\Analyser\MutatingScope', $this->getService('068')); + } + + + public function createService052(): PHPStan\Analyser\ScopeFactory + { + return new PHPStan\Analyser\ScopeFactory($this->getService('051')); + } + + + public function createService053(): PHPStan\Analyser\NodeScopeResolver + { + return new PHPStan\Analyser\NodeScopeResolver( + $this->getService('reflectionProvider'), + $this->getService('088'), + $this->getService('nodeScopeResolverReflector'), + $this->getService('071'), + $this->getService('073'), + $this->getService('defaultAnalysisParser'), + $this->getService('0166'), + $this->getService('stubPhpDocProvider'), + $this->getService('023'), + $this->getService('0116'), + $this->getService('031'), + $this->getService('078'), + $this->getService('typeSpecifier'), + $this->getService('076'), + $this->getService('0159'), + $this->getService('077'), + $this->getService('052'), + true, + true, + [], + [], + ['stdClass'], + true, + true, + false, + false, + false, + false + ); + } + + + public function createService054(): PHPStan\Analyser\ConstantResolver + { + return $this->getService('055')->create(); + } + + + public function createService055(): PHPStan\Analyser\ConstantResolverFactory + { + return new PHPStan\Analyser\ConstantResolverFactory($this->getService('0110'), $this->getService('068')); + } + + + public function createService056(): PHPStan\Analyser\ResultCache\ResultCacheManagerFactory + { + return new class ($this) implements PHPStan\Analyser\ResultCache\ResultCacheManagerFactory { + private $container; + + + public function __construct(Container_9bdc8b8877 $container) + { + $this->container = $container; + } + + + public function create(): PHPStan\Analyser\ResultCache\ResultCacheManager + { + return new PHPStan\Analyser\ResultCache\ResultCacheManager( + $this->container->getService('065'), + $this->container->getService('fileFinderScan'), + $this->container->getService('reflectionProvider'), + $this->container->getService('041'), + $this->container->getService('078'), + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCache.php', + $this->container->getParameter('analysedPaths'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + '9', + null, + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionUnionType.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionAttribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/Attribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionIntersectionType.php', + ], + [], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/php'], + false + ); + } + }; + } + + + public function createService057(): PHPStan\Analyser\ResultCache\ResultCacheClearer + { + return new PHPStan\Analyser\ResultCache\ResultCacheClearer('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCache.php'); + } + + + public function createService058(): PHPStan\Cache\Cache + { + return new PHPStan\Cache\Cache($this->getService('cacheStorage')); + } + + + public function createService059(): PHPStan\Collectors\Registry + { + return $this->getService('060')->create(); + } + + + public function createService060(): PHPStan\Collectors\RegistryFactory + { + return new PHPStan\Collectors\RegistryFactory($this->getService('068')); + } + + + public function createService061(): PHPStan\Command\AnalyseApplication + { + return new PHPStan\Command\AnalyseApplication( + $this->getService('062'), + $this->getService('045'), + $this->getService('038'), + $this->getService('056'), + $this->getService('049'), + $this->getService('041') + ); + } + + + public function createService062(): PHPStan\Command\AnalyserRunner + { + return new PHPStan\Command\AnalyserRunner( + $this->getService('084'), + $this->getService('044'), + $this->getService('083'), + $this->getService('086') + ); + } + + + public function createService063(): PHPStan\Command\FixerApplication + { + return new PHPStan\Command\FixerApplication( + $this->getService('081'), + $this->getService('049'), + $this->getService('041'), + $this->getParameter('analysedPaths'), + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + ($this->getParameter('sysGetTempDir')) . '/phpstan-fixer', + ['1.1.1.2'], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/phpstan.neon', + ], + null, + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionUnionType.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionAttribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/Attribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionIntersectionType.php', + ], + null, + '9' + ); + } + + + public function createService064(): PHPStan\Dependency\DependencyResolver + { + return new PHPStan\Dependency\DependencyResolver( + $this->getService('078'), + $this->getService('reflectionProvider'), + $this->getService('066'), + $this->getService('0166') + ); + } + + + public function createService065(): PHPStan\Dependency\ExportedNodeFetcher + { + return new PHPStan\Dependency\ExportedNodeFetcher($this->getService('defaultAnalysisParser'), $this->getService('067')); + } + + + public function createService066(): PHPStan\Dependency\ExportedNodeResolver + { + return new PHPStan\Dependency\ExportedNodeResolver($this->getService('0166'), $this->getService('020')); + } + + + public function createService067(): PHPStan\Dependency\ExportedNodeVisitor + { + return new PHPStan\Dependency\ExportedNodeVisitor($this->getService('066')); + } + + + public function createService068(): PHPStan\DependencyInjection\Container + { + return new PHPStan\DependencyInjection\MemoizingContainer($this->getService('069')); + } + + + public function createService069(): PHPStan\DependencyInjection\Nette\NetteContainer + { + return new PHPStan\DependencyInjection\Nette\NetteContainer($this); + } + + + public function createService070(): PHPStan\DependencyInjection\DerivativeContainerFactory + { + return new PHPStan\DependencyInjection\DerivativeContainerFactory( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan', + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/phpstan.neon', + ], + $this->getParameter('analysedPaths'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + $this->getParameter('analysedPathsFromConfig'), + '9', + null, + null + ); + } + + + public function createService071(): PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Reflection\LazyClassReflectionExtensionRegistryProvider($this->getService('068')); + } + + + public function createService072(): PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Type\LazyDynamicReturnTypeExtensionRegistryProvider($this->getService('068')); + } + + + public function createService073(): PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider + { + return new PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider($this->getService('068')); + } + + + public function createService074(): PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Type\LazyExpressionTypeResolverExtensionRegistryProvider($this->getService('068')); + } + + + public function createService075(): PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Type\LazyOperatorTypeSpecifyingExtensionRegistryProvider($this->getService('068')); + } + + + public function createService076(): PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider + { + return new PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider($this->getService('068')); + } + + + public function createService077(): PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider + { + return new PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider($this->getService('068')); + } + + + public function createService078(): PHPStan\File\FileHelper + { + return new PHPStan\File\FileHelper('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'); + } + + + public function createService079(): PHPStan\File\FileExcluderFactory + { + return new PHPStan\File\FileExcluderFactory($this->getService('080'), [], null); + } + + + public function createService080(): PHPStan\File\FileExcluderRawFactory + { + return new class ($this) implements PHPStan\File\FileExcluderRawFactory { + private $container; + + + public function __construct(Container_9bdc8b8877 $container) + { + $this->container = $container; + } + + + public function create(array $analyseExcludes): PHPStan\File\FileExcluder + { + return new PHPStan\File\FileExcluder($this->container->getService('078'), $analyseExcludes, false); + } + }; + } + + + public function createService081(): PHPStan\File\FileMonitor + { + return new PHPStan\File\FileMonitor($this->getService('fileFinderAnalyse')); + } + + + public function createService082(): PHPStan\Parser\DeclarePositionVisitor + { + return new PHPStan\Parser\DeclarePositionVisitor; + } + + + public function createService083(): PHPStan\Parallel\ParallelAnalyser + { + return new PHPStan\Parallel\ParallelAnalyser(50, 600.0, 134217728); + } + + + public function createService084(): PHPStan\Parallel\Scheduler + { + return new PHPStan\Parallel\Scheduler(20, 32, 2); + } + + + public function createService085(): PHPStan\Parser\FunctionCallStatementFinder + { + return new PHPStan\Parser\FunctionCallStatementFinder; + } + + + public function createService086(): PHPStan\Process\CpuCoreCounter + { + return new PHPStan\Process\CpuCoreCounter; + } + + + public function createService087(): PHPStan\Reflection\FunctionReflectionFactory + { + return new class ($this) implements PHPStan\Reflection\FunctionReflectionFactory { + private $container; + + + public function __construct(Container_9bdc8b8877 $container) + { + $this->container = $container; + } + + + public function create( + PHPStan\BetterReflection\Reflection\Adapter\ReflectionFunction $reflection, + PHPStan\Type\Generic\TemplateTypeMap $templateTypeMap, + array $phpDocParameterTypes, + ?PHPStan\Type\Type $phpDocReturnType, + ?PHPStan\Type\Type $phpDocThrowType, + ?string $deprecatedDescription, + bool $isDeprecated, + bool $isInternal, + bool $isFinal, + ?string $filename, + ?bool $isPure, + PHPStan\Reflection\Assertions $asserts, + bool $acceptsNamedArguments, + ?string $phpDocComment, + array $phpDocParameterOutTypes, + array $phpDocParameterImmediatelyInvokedCallable, + array $phpDocParameterClosureThisTypes + ): PHPStan\Reflection\Php\PhpFunctionReflection { + return new PHPStan\Reflection\Php\PhpFunctionReflection( + $this->container->getService('088'), + $reflection, + $this->container->getService('defaultAnalysisParser'), + $this->container->getService('085'), + $this->container->getService('058'), + $templateTypeMap, + $phpDocParameterTypes, + $phpDocReturnType, + $phpDocThrowType, + $deprecatedDescription, + $isDeprecated, + $isInternal, + $isFinal, + $filename, + $isPure, + $asserts, + $acceptsNamedArguments, + $phpDocComment, + $phpDocParameterOutTypes, + $phpDocParameterImmediatelyInvokedCallable, + $phpDocParameterClosureThisTypes + ); + } + }; + } + + + public function createService088(): PHPStan\Reflection\InitializerExprTypeResolver + { + return new PHPStan\Reflection\InitializerExprTypeResolver( + $this->getService('054'), + $this->getService('0110'), + $this->getService('023'), + $this->getService('075'), + $this->getService('0329'), + false + ); + } + + + public function createService089(): PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension + { + return new PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension; + } + + + public function createService090(): PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension + { + return new PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension; + } + + + public function createService091(): PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor; + } + + + public function createService092(): PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher( + $this->getService('091'), + $this->getService('defaultAnalysisParser') + ); + } + + + public function createService093(): PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker( + $this->getService('095'), + $this->getService('096'), + $this->getService('094'), + $this->getService('023') + ); + } + + + public function createService094(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory( + $this->getService('092'), + $this->getService('fileFinderScan'), + $this->getService('023'), + $this->getService('058') + ); + } + + + public function createService095(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository($this->getService('094')); + } + + + public function createService096(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory + { + return new class ($this) implements PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory { + private $container; + + + public function __construct(Container_9bdc8b8877 $container) + { + $this->container = $container; + } + + + public function create(PHPStan\BetterReflection\SourceLocator\Type\Composer\Psr\PsrAutoloaderMapping $mapping): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator($mapping, $this->container->getService('098')); + } + }; + } + + + public function createService097(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory + { + return new class ($this) implements PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory { + private $container; + + + public function __construct(Container_9bdc8b8877 $container) + { + $this->container = $container; + } + + + public function create(string $fileName): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator( + $this->container->getService('092'), + $fileName + ); + } + }; + } + + + public function createService098(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository($this->getService('097')); + } + + + public function createService099(): PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension + { + return new PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension; + } + + + public function createService0100(): PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension + { + return new PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension; + } + + + public function createService0101(): PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension + { + return new PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension([]); + } + + + public function createService0102(): PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension + { + return new PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension([]); + } + + + public function createService0103(): PHPStan\Reflection\Php\PhpClassReflectionExtension + { + return new PHPStan\Reflection\Php\PhpClassReflectionExtension( + $this->getService('052'), + $this->getService('053'), + $this->getService('0104'), + $this->getService('031'), + $this->getService('089'), + $this->getService('090'), + $this->getService('0116'), + $this->getService('defaultAnalysisParser'), + $this->getService('stubPhpDocProvider'), + $this->getService('0110'), + $this->getService('0166'), + false + ); + } + + + public function createService0104(): PHPStan\Reflection\Php\PhpMethodReflectionFactory + { + return new class ($this) implements PHPStan\Reflection\Php\PhpMethodReflectionFactory { + private $container; + + + public function __construct(Container_9bdc8b8877 $container) + { + $this->container = $container; + } + + + public function create( + PHPStan\Reflection\ClassReflection $declaringClass, + ?PHPStan\Reflection\ClassReflection $declaringTrait, + PHPStan\Reflection\Php\BuiltinMethodReflection $reflection, + PHPStan\Type\Generic\TemplateTypeMap $templateTypeMap, + array $phpDocParameterTypes, + ?PHPStan\Type\Type $phpDocReturnType, + ?PHPStan\Type\Type $phpDocThrowType, + ?string $deprecatedDescription, + bool $isDeprecated, + bool $isInternal, + bool $isFinal, + ?bool $isPure, + PHPStan\Reflection\Assertions $asserts, + ?PHPStan\Type\Type $selfOutType, + ?string $phpDocComment, + array $phpDocParameterOutTypes, + array $immediatelyInvokedCallableParameters = [], + array $phpDocClosureThisTypeParameters = [], + bool $acceptsNamedArguments = true + ): PHPStan\Reflection\Php\PhpMethodReflection { + return new PHPStan\Reflection\Php\PhpMethodReflection( + $this->container->getService('088'), + $declaringClass, + $declaringTrait, + $reflection, + $this->container->getService('reflectionProvider'), + $this->container->getService('defaultAnalysisParser'), + $this->container->getService('085'), + $this->container->getService('058'), + $templateTypeMap, + $phpDocParameterTypes, + $phpDocReturnType, + $phpDocThrowType, + $deprecatedDescription, + $isDeprecated, + $isInternal, + $isFinal, + $isPure, + $asserts, + $acceptsNamedArguments, + $selfOutType, + $phpDocComment, + $phpDocParameterOutTypes, + $immediatelyInvokedCallableParameters, + $phpDocClosureThisTypeParameters + ); + } + }; + } + + + public function createService0105(): PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension + { + return new PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension; + } + + + public function createService0106(): PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension + { + return new PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension; + } + + + public function createService0107(): PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension + { + return new PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension( + $this->getService('reflectionProvider'), + ['stdClass'], + $this->getService('090') + ); + } + + + public function createService0108(): PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension + { + return new PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension( + $this->getService('023'), + 'PHPStan\Reflection\ClassReflection', + 'getNativeReflection' + ); + } + + + public function createService0109(): PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension + { + return new PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension( + $this->getService('023'), + 'PHPStan\Reflection\Php\BuiltinMethodReflection', + 'getDeclaringClass' + ); + } + + + public function createService0110(): PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider + { + return new PHPStan\Reflection\ReflectionProvider\LazyReflectionProviderProvider($this->getService('068')); + } + + + public function createService0111(): PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider + { + return new PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider( + $this->getService('0116'), + $this->getService('betterReflectionReflector'), + $this->getService('0166'), + $this->getService('stubPhpDocProvider') + ); + } + + + public function createService0112(): PHPStan\Reflection\SignatureMap\SignatureMapParser + { + return new PHPStan\Reflection\SignatureMap\SignatureMapParser($this->getService('037')); + } + + + public function createService0113(): PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider + { + return new PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider( + $this->getService('0112'), + $this->getService('088'), + $this->getService('023'), + false + ); + } + + + public function createService0114(): PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider + { + return new PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider( + $this->getService('0113'), + $this->getService('092'), + $this->getService('0166'), + $this->getService('023'), + $this->getService('088') + ); + } + + + public function createService0115(): PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory + { + return new PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory( + $this->getService('023'), + $this->getService('0113'), + $this->getService('0114') + ); + } + + + public function createService0116(): PHPStan\Reflection\SignatureMap\SignatureMapProvider + { + return $this->getService('0115')->create(); + } + + + public function createService0117(): PHPStan\Rules\Api\ApiRuleHelper + { + return new PHPStan\Rules\Api\ApiRuleHelper; + } + + + public function createService0118(): PHPStan\Rules\AttributesCheck + { + return new PHPStan\Rules\AttributesCheck( + $this->getService('reflectionProvider'), + $this->getService('0135'), + $this->getService('0120'), + false + ); + } + + + public function createService0119(): PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck + { + return new PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck($this->getService('0163'), true, false, false, false); + } + + + public function createService0120(): PHPStan\Rules\ClassNameCheck + { + return new PHPStan\Rules\ClassNameCheck($this->getService('0121'), $this->getService('0122')); + } + + + public function createService0121(): PHPStan\Rules\ClassCaseSensitivityCheck + { + return new PHPStan\Rules\ClassCaseSensitivityCheck($this->getService('reflectionProvider'), false); + } + + + public function createService0122(): PHPStan\Rules\ClassForbiddenNameCheck + { + return new PHPStan\Rules\ClassForbiddenNameCheck($this->getService('068')); + } + + + public function createService0123(): PHPStan\Rules\Classes\LocalTypeAliasesCheck + { + return new PHPStan\Rules\Classes\LocalTypeAliasesCheck( + [], + $this->getService('reflectionProvider'), + $this->getService('035'), + $this->getService('0149'), + $this->getService('0120'), + $this->getService('0155'), + $this->getService('0141'), + true, + true, + false + ); + } + + + public function createService0124(): PHPStan\Rules\Classes\MethodTagCheck + { + return new PHPStan\Rules\Classes\MethodTagCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true + ); + } + + + public function createService0125(): PHPStan\Rules\Classes\PropertyTagCheck + { + return new PHPStan\Rules\Classes\PropertyTagCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true + ); + } + + + public function createService0126(): PHPStan\Rules\Comparison\ConstantConditionRuleHelper + { + return new PHPStan\Rules\Comparison\ConstantConditionRuleHelper($this->getService('0127'), true, false); + } + + + public function createService0127(): PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper( + $this->getService('reflectionProvider'), + $this->getService('typeSpecifier'), + ['stdClass'], + true, + false + ); + } + + + public function createService0128(): PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver + { + return new PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver($this->getService('reflectionProvider'), [], [], [], []); + } + + + public function createService0129(): PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule + { + return new PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule($this->getService('0131')); + } + + + public function createService0130(): PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule + { + return new PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule($this->getService('0131')); + } + + + public function createService0131(): PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck + { + return new PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck($this->getService('exceptionTypeResolver')); + } + + + public function createService0132(): PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule + { + return new PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule($this->getService('0134')); + } + + + public function createService0133(): PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule + { + return new PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule($this->getService('0166'), $this->getService('0134')); + } + + + public function createService0134(): PHPStan\Rules\Exceptions\TooWideThrowTypeCheck + { + return new PHPStan\Rules\Exceptions\TooWideThrowTypeCheck; + } + + + public function createService0135(): PHPStan\Rules\FunctionCallParametersCheck + { + return new PHPStan\Rules\FunctionCallParametersCheck( + $this->getService('0163'), + $this->getService('0150'), + $this->getService('023'), + $this->getService('0155'), + $this->getService('0161'), + true, + true, + true, + true, + false + ); + } + + + public function createService0136(): PHPStan\Rules\FunctionDefinitionCheck + { + return new PHPStan\Rules\FunctionDefinitionCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0155'), + $this->getService('023'), + true, + false, + false + ); + } + + + public function createService0137(): PHPStan\Rules\FunctionReturnTypeCheck + { + return new PHPStan\Rules\FunctionReturnTypeCheck($this->getService('0163')); + } + + + public function createService0138(): PHPStan\Rules\ParameterCastableToStringCheck + { + return new PHPStan\Rules\ParameterCastableToStringCheck($this->getService('0163')); + } + + + public function createService0139(): PHPStan\Rules\Generics\CrossCheckInterfacesHelper + { + return new PHPStan\Rules\Generics\CrossCheckInterfacesHelper; + } + + + public function createService0140(): PHPStan\Rules\Generics\GenericAncestorsCheck + { + return new PHPStan\Rules\Generics\GenericAncestorsCheck( + $this->getService('reflectionProvider'), + $this->getService('0141'), + $this->getService('0143'), + $this->getService('0155'), + true, + [ + 'DatePeriod', + 'CallbackFilterIterator', + 'FilterIterator', + 'RecursiveCallbackFilterIterator', + 'AppendIterator', + 'NoRewindIterator', + 'LimitIterator', + 'InfiniteIterator', + 'CachingIterator', + 'RegexIterator', + 'ReflectionEnum', + ], + false + ); + } + + + public function createService0141(): PHPStan\Rules\Generics\GenericObjectTypeCheck + { + return new PHPStan\Rules\Generics\GenericObjectTypeCheck; + } + + + public function createService0142(): PHPStan\Rules\Generics\TemplateTypeCheck + { + return new PHPStan\Rules\Generics\TemplateTypeCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0167'), + true + ); + } + + + public function createService0143(): PHPStan\Rules\Generics\VarianceCheck + { + return new PHPStan\Rules\Generics\VarianceCheck(false, false); + } + + + public function createService0144(): PHPStan\Rules\IssetCheck + { + return new PHPStan\Rules\IssetCheck($this->getService('0160'), $this->getService('0161'), true, true, false); + } + + + public function createService0145(): PHPStan\Rules\Methods\MethodCallCheck + { + return new PHPStan\Rules\Methods\MethodCallCheck( + $this->getService('reflectionProvider'), + $this->getService('0163'), + false, + true + ); + } + + + public function createService0146(): PHPStan\Rules\Methods\StaticMethodCallCheck + { + return new PHPStan\Rules\Methods\StaticMethodCallCheck( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('0120'), + false, + true + ); + } + + + public function createService0147(): PHPStan\Rules\Methods\MethodSignatureRule + { + return new PHPStan\Rules\Methods\MethodSignatureRule($this->getService('0103'), false, false, false); + } + + + public function createService0148(): PHPStan\Rules\Methods\MethodParameterComparisonHelper + { + return new PHPStan\Rules\Methods\MethodParameterComparisonHelper($this->getService('023'), false); + } + + + public function createService0149(): PHPStan\Rules\MissingTypehintCheck + { + return new PHPStan\Rules\MissingTypehintCheck( + false, + true, + true, + false, + [ + 'DatePeriod', + 'CallbackFilterIterator', + 'FilterIterator', + 'RecursiveCallbackFilterIterator', + 'AppendIterator', + 'NoRewindIterator', + 'LimitIterator', + 'InfiniteIterator', + 'CachingIterator', + 'RegexIterator', + 'ReflectionEnum', + ] + ); + } + + + public function createService0150(): PHPStan\Rules\NullsafeCheck + { + return new PHPStan\Rules\NullsafeCheck; + } + + + public function createService0151(): PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider + { + return new PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider($this->getService('068')); + } + + + public function createService0152(): PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider + { + return new PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider($this->getService('068')); + } + + + public function createService0153(): PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper + { + return new PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper; + } + + + public function createService0154(): PHPStan\Rules\PhpDoc\AssertRuleHelper + { + return new PHPStan\Rules\PhpDoc\AssertRuleHelper($this->getService('088')); + } + + + public function createService0155(): PHPStan\Rules\PhpDoc\UnresolvableTypeHelper + { + return new PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; + } + + + public function createService0156(): PHPStan\Rules\PhpDoc\GenericCallableRuleHelper + { + return new PHPStan\Rules\PhpDoc\GenericCallableRuleHelper($this->getService('0142')); + } + + + public function createService0157(): PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper + { + return new PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper(false, false); + } + + + public function createService0158(): PHPStan\Rules\Playground\NeverRuleHelper + { + return new PHPStan\Rules\Playground\NeverRuleHelper; + } + + + public function createService0159(): PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider + { + return new PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider($this->getService('068')); + } + + + public function createService0160(): PHPStan\Rules\Properties\PropertyDescriptor + { + return new PHPStan\Rules\Properties\PropertyDescriptor; + } + + + public function createService0161(): PHPStan\Rules\Properties\PropertyReflectionFinder + { + return new PHPStan\Rules\Properties\PropertyReflectionFinder; + } + + + public function createService0162(): PHPStan\Rules\Pure\FunctionPurityCheck + { + return new PHPStan\Rules\Pure\FunctionPurityCheck; + } + + + public function createService0163(): PHPStan\Rules\RuleLevelHelper + { + return new PHPStan\Rules\RuleLevelHelper($this->getService('reflectionProvider'), true, false, true, true, false, false, false); + } + + + public function createService0164(): PHPStan\Rules\UnusedFunctionParametersCheck + { + return new PHPStan\Rules\UnusedFunctionParametersCheck($this->getService('reflectionProvider')); + } + + + public function createService0165(): PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck + { + return new PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck; + } + + + public function createService0166(): PHPStan\Type\FileTypeMapper + { + return new PHPStan\Type\FileTypeMapper( + $this->getService('0110'), + $this->getService('defaultAnalysisParser'), + $this->getService('033'), + $this->getService('032'), + $this->getService('022'), + $this->getService('078') + ); + } + + + public function createService0167(): PHPStan\Type\TypeAliasResolver + { + return new PHPStan\Type\UsefulTypeAliasResolver( + [], + $this->getService('037'), + $this->getService('035'), + $this->getService('reflectionProvider') + ); + } + + + public function createService0168(): PHPStan\Type\TypeAliasResolverProvider + { + return new PHPStan\Type\LazyTypeAliasResolverProvider($this->getService('068')); + } + + + public function createService0169(): PHPStan\Type\BitwiseFlagHelper + { + return new PHPStan\Type\BitwiseFlagHelper($this->getService('reflectionProvider')); + } + + + public function createService0170(): PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension; + } + + + public function createService0171(): PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension; + } + + + public function createService0172(): PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0173(): PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0174(): PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0175(): PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0176(): PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension; + } + + + public function createService0177(): PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0178(): PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0179(): PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension; + } + + + public function createService0180(): PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0181(): PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension; + } + + + public function createService0182(): PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension; + } + + + public function createService0183(): PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension; + } + + + public function createService0184(): PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension; + } + + + public function createService0185(): PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0186(): PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension; + } + + + public function createService0187(): PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension; + } + + + public function createService0188(): PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension; + } + + + public function createService0189(): PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension; + } + + + public function createService0190(): PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension; + } + + + public function createService0191(): PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension; + } + + + public function createService0192(): PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension; + } + + + public function createService0193(): PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension; + } + + + public function createService0194(): PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension; + } + + + public function createService0195(): PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension; + } + + + public function createService0196(): PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension; + } + + + public function createService0197(): PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0198(): PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension; + } + + + public function createService0199(): PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0200(): PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension; + } + + + public function createService0201(): PHPStan\Type\Php\AssertThrowTypeExtension + { + return new PHPStan\Type\Php\AssertThrowTypeExtension; + } + + + public function createService0202(): PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension; + } + + + public function createService0203(): PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension; + } + + + public function createService0204(): PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension + { + return new PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension($this->getService('023')); + } + + + public function createService0205(): PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension; + } + + + public function createService0206(): PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension; + } + + + public function createService0207(): PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension; + } + + + public function createService0208(): PHPStan\Type\Php\CompactFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\CompactFunctionReturnTypeExtension(true); + } + + + public function createService0209(): PHPStan\Type\Php\ConstantFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ConstantFunctionReturnTypeExtension($this->getService('0210')); + } + + + public function createService0210(): PHPStan\Type\Php\ConstantHelper + { + return new PHPStan\Type\Php\ConstantHelper; + } + + + public function createService0211(): PHPStan\Type\Php\CountFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\CountFunctionReturnTypeExtension; + } + + + public function createService0212(): PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension; + } + + + public function createService0213(): PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0214(): PHPStan\Type\Php\CurlInitReturnTypeExtension + { + return new PHPStan\Type\Php\CurlInitReturnTypeExtension($this->getService('023')); + } + + + public function createService0215(): PHPStan\Type\Php\DateFunctionReturnTypeHelper + { + return new PHPStan\Type\Php\DateFunctionReturnTypeHelper; + } + + + public function createService0216(): PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension($this->getService('0215')); + } + + + public function createService0217(): PHPStan\Type\Php\DateFormatMethodReturnTypeExtension + { + return new PHPStan\Type\Php\DateFormatMethodReturnTypeExtension($this->getService('0215')); + } + + + public function createService0218(): PHPStan\Type\Php\DateFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\DateFunctionReturnTypeExtension($this->getService('0215')); + } + + + public function createService0219(): PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension($this->getService('023')); + } + + + public function createService0220(): PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension; + } + + + public function createService0221(): PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension; + } + + + public function createService0222(): PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension; + } + + + public function createService0223(): PHPStan\Type\Php\DateTimeModifyReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeModifyReturnTypeExtension($this->getService('023'), 'DateTime'); + } + + + public function createService0224(): PHPStan\Type\Php\DateTimeModifyReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeModifyReturnTypeExtension($this->getService('023'), 'DateTimeImmutable'); + } + + + public function createService0225(): PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension($this->getService('023')); + } + + + public function createService0226(): PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension + { + return new PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension($this->getService('023')); + } + + + public function createService0227(): PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension($this->getService('023')); + } + + + public function createService0228(): PHPStan\Type\Php\DsMapDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DsMapDynamicReturnTypeExtension; + } + + + public function createService0229(): PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension + { + return new PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension; + } + + + public function createService0230(): PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension; + } + + + public function createService0231(): PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0232(): PHPStan\Type\Php\FilterFunctionReturnTypeHelper + { + return new PHPStan\Type\Php\FilterFunctionReturnTypeHelper($this->getService('reflectionProvider'), $this->getService('023')); + } + + + public function createService0233(): PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension($this->getService('0232')); + } + + + public function createService0234(): PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension($this->getService('0232')); + } + + + public function createService0235(): PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension( + $this->getService('0232'), + $this->getService('reflectionProvider') + ); + } + + + public function createService0236(): PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension; + } + + + public function createService0237(): PHPStan\Type\Php\GetClassDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\GetClassDynamicReturnTypeExtension; + } + + + public function createService0238(): PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension; + } + + + public function createService0239(): PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0240(): PHPStan\Type\Php\GettypeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GettypeFunctionReturnTypeExtension; + } + + + public function createService0241(): PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension; + } + + + public function createService0242(): PHPStan\Type\Php\HashFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\HashFunctionsReturnTypeExtension($this->getService('023')); + } + + + public function createService0243(): PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0244(): PHPStan\Type\Php\IntdivThrowTypeExtension + { + return new PHPStan\Type\Php\IntdivThrowTypeExtension; + } + + + public function createService0245(): PHPStan\Type\Php\IniGetReturnTypeExtension + { + return new PHPStan\Type\Php\IniGetReturnTypeExtension; + } + + + public function createService0246(): PHPStan\Type\Php\JsonThrowTypeExtension + { + return new PHPStan\Type\Php\JsonThrowTypeExtension($this->getService('reflectionProvider'), $this->getService('0169')); + } + + + public function createService0247(): PHPStan\Type\Php\PregMatchTypeSpecifyingExtension + { + return new PHPStan\Type\Php\PregMatchTypeSpecifyingExtension($this->getService('0250')); + } + + + public function createService0248(): PHPStan\Type\Php\PregMatchParameterOutTypeExtension + { + return new PHPStan\Type\Php\PregMatchParameterOutTypeExtension($this->getService('0250')); + } + + + public function createService0249(): PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension + { + return new PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension($this->getService('0250')); + } + + + public function createService0250(): PHPStan\Type\Php\RegexArrayShapeMatcher + { + return new PHPStan\Type\Php\RegexArrayShapeMatcher( + $this->getService('0251'), + $this->getService('0252'), + $this->getService('023') + ); + } + + + public function createService0251(): PHPStan\Type\Regex\RegexGroupParser + { + return new PHPStan\Type\Regex\RegexGroupParser($this->getService('023'), $this->getService('0252')); + } + + + public function createService0252(): PHPStan\Type\Regex\RegexExpressionHelper + { + return new PHPStan\Type\Regex\RegexExpressionHelper($this->getService('088')); + } + + + public function createService0253(): PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension; + } + + + public function createService0254(): PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0255(): PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0256(): PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0257(): PHPStan\Type\Php\StrContainingTypeSpecifyingExtension + { + return new PHPStan\Type\Php\StrContainingTypeSpecifyingExtension; + } + + + public function createService0258(): PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension + { + return new PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension; + } + + + public function createService0259(): PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension; + } + + + public function createService0260(): PHPStan\Type\Php\StatDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\StatDynamicReturnTypeExtension; + } + + + public function createService0261(): PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension + { + return new PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension; + } + + + public function createService0262(): PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension + { + return new PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension($this->getService('0161')); + } + + + public function createService0263(): PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0264(): PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension; + } + + + public function createService0265(): PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0266(): PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension; + } + + + public function createService0267(): PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension($this->getService('0169')); + } + + + public function createService0268(): PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension; + } + + + public function createService0269(): PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension; + } + + + public function createService0270(): PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension; + } + + + public function createService0271(): PHPStan\Type\Php\LtrimFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\LtrimFunctionReturnTypeExtension; + } + + + public function createService0272(): PHPStan\Type\Php\MbFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\MbFunctionsReturnTypeExtension($this->getService('023')); + } + + + public function createService0273(): PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension; + } + + + public function createService0274(): PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0275(): PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0276(): PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension; + } + + + public function createService0277(): PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension; + } + + + public function createService0278(): PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension; + } + + + public function createService0279(): PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension; + } + + + public function createService0280(): PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension; + } + + + public function createService0281(): PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension; + } + + + public function createService0282(): PHPStan\Type\Php\StrlenFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrlenFunctionReturnTypeExtension; + } + + + public function createService0283(): PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension; + } + + + public function createService0284(): PHPStan\Type\Php\StrPadFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrPadFunctionReturnTypeExtension; + } + + + public function createService0285(): PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension; + } + + + public function createService0286(): PHPStan\Type\Php\SubstrDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\SubstrDynamicReturnTypeExtension; + } + + + public function createService0287(): PHPStan\Type\Php\ThrowableReturnTypeExtension + { + return new PHPStan\Type\Php\ThrowableReturnTypeExtension; + } + + + public function createService0288(): PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension; + } + + + public function createService0289(): PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0290(): PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension; + } + + + public function createService0291(): PHPStan\Type\Php\PowFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\PowFunctionReturnTypeExtension; + } + + + public function createService0292(): PHPStan\Type\Php\RoundFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\RoundFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0293(): PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension; + } + + + public function createService0294(): PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension; + } + + + public function createService0295(): PHPStan\Type\Php\RangeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\RangeFunctionReturnTypeExtension; + } + + + public function createService0296(): PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension; + } + + + public function createService0297(): PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension; + } + + + public function createService0298(): PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension; + } + + + public function createService0299(): PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension + { + return new PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension; + } + + + public function createService0300(): PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension + { + return new PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension($this->getService('0210')); + } + + + public function createService0301(): PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension; + } + + + public function createService0302(): PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension; + } + + + public function createService0303(): PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension(false); + } + + + public function createService0304(): PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension($this->getService('0261')); + } + + + public function createService0305(): PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension; + } + + + public function createService0306(): PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension($this->getService('0309')); + } + + + public function createService0307(): PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension; + } + + + public function createService0308(): PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension($this->getService('0309')); + } + + + public function createService0309(): PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper + { + return new PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper; + } + + + public function createService0310(): PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension; + } + + + public function createService0311(): PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension( + $this->getService('reflectionProvider'), + $this->getService('0169') + ); + } + + + public function createService0312(): PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension( + $this->getService('reflectionProvider'), + true, + ['stdClass'], + false + ); + } + + + public function createService0313(): PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension + { + return new PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension; + } + + + public function createService0314(): PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension + { + return new PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension; + } + + + public function createService0315(): PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0316(): PHPStan\Type\Php\StrTokFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrTokFunctionReturnTypeExtension; + } + + + public function createService0317(): PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension; + } + + + public function createService0318(): PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension; + } + + + public function createService0319(): PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension; + } + + + public function createService0320(): PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension; + } + + + public function createService0321(): PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension + { + return new PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension; + } + + + public function createService0322(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionClass'); + } + + + public function createService0323(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionClassConstant'); + } + + + public function createService0324(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionFunctionAbstract'); + } + + + public function createService0325(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionParameter'); + } + + + public function createService0326(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionProperty'); + } + + + public function createService0327(): PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension + { + return new PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension; + } + + + public function createService0328(): PHPStan\Type\ClosureTypeFactory + { + return new PHPStan\Type\ClosureTypeFactory( + $this->getService('088'), + $this->getService('0335'), + $this->getService('originalBetterReflectionReflector'), + $this->getService('currentPhpVersionPhpParser') + ); + } + + + public function createService0329(): PHPStan\Type\Constant\OversizedArrayBuilder + { + return new PHPStan\Type\Constant\OversizedArrayBuilder; + } + + + public function createService0330(): PHPStan\Rules\Functions\PrintfHelper + { + return new PHPStan\Rules\Functions\PrintfHelper($this->getService('023')); + } + + + public function createService0331(): PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory + { + return new PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory( + $this->getService('phpParserDecorator'), + $this->getService('php8PhpParser'), + $this->getService('0334'), + $this->getService('0335'), + $this->getService('098'), + $this->getService('095'), + $this->getService('093'), + $this->getService('096'), + $this->getService('092'), + [], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/php'], + $this->getParameter('analysedPaths'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + $this->getParameter('analysedPathsFromConfig'), + false + ); + } + + + public function createService0332(): PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory + { + return new class ($this) implements PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory { + private $container; + + + public function __construct(Container_9bdc8b8877 $container) + { + $this->container = $container; + } + + + public function create(PHPStan\BetterReflection\Reflector\Reflector $reflector): PHPStan\Reflection\BetterReflection\BetterReflectionProvider + { + return new PHPStan\Reflection\BetterReflection\BetterReflectionProvider( + $this->container->getService('0110'), + $this->container->getService('088'), + $this->container->getService('071'), + $reflector, + $this->container->getService('0166'), + $this->container->getService('031'), + $this->container->getService('023'), + $this->container->getService('0111'), + $this->container->getService('stubPhpDocProvider'), + $this->container->getService('087'), + $this->container->getService('relativePathHelper'), + $this->container->getService('022'), + $this->container->getService('078'), + $this->container->getService('0334'), + $this->container->getService('0116'), + ['stdClass'] + ); + } + }; + } + + + public function createService0333(): PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory + { + return new PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory( + $this->getService('php8PhpParser'), + $this->getService('021'), + $this->getService('023') + ); + } + + + public function createService0334(): PHPStan\BetterReflection\SourceLocator\SourceStubber\PhpStormStubsSourceStubber + { + return $this->getService('0333')->create(); + } + + + public function createService0335(): PHPStan\BetterReflection\SourceLocator\SourceStubber\ReflectionSourceStubber + { + return $this->getService('0336')->create(); + } + + + public function createService0336(): PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory + { + return new PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory( + $this->getService('021'), + $this->getService('023') + ); + } + + + public function createService0337(): PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter( + $this->getService('errorFormatter.github'), + $this->getService('errorFormatter.teamcity') + ); + } + + + public function createService0338(): PHPStan\Rules\Api\ApiClassConstFetchRule + { + return new PHPStan\Rules\Api\ApiClassConstFetchRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createService0339(): PHPStan\Rules\Api\ApiInstanceofRule + { + return new PHPStan\Rules\Api\ApiInstanceofRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createService0340(): PHPStan\Rules\Api\ApiInstanceofTypeRule + { + return new PHPStan\Rules\Api\ApiInstanceofTypeRule($this->getService('reflectionProvider'), false, false); + } + + + public function createService0341(): PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule + { + return new PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule($this->getService('068')); + } + + + public function createService0342(): PHPStan\Rules\Api\RuntimeReflectionFunctionRule + { + return new PHPStan\Rules\Api\RuntimeReflectionFunctionRule($this->getService('reflectionProvider')); + } + + + public function createService0343(): PHPStan\Rules\Api\RuntimeReflectionInstantiationRule + { + return new PHPStan\Rules\Api\RuntimeReflectionInstantiationRule($this->getService('reflectionProvider')); + } + + + public function createService0344(): PHPStan\Rules\Classes\ExistingClassInClassExtendsRule + { + return new PHPStan\Rules\Classes\ExistingClassInClassExtendsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createService0345(): PHPStan\Rules\Classes\ExistingClassInInstanceOfRule + { + return new PHPStan\Rules\Classes\ExistingClassInInstanceOfRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + true + ); + } + + + public function createService0346(): PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule + { + return new PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + true + ); + } + + + public function createService0347(): PHPStan\Rules\Functions\CallToNonExistentFunctionRule + { + return new PHPStan\Rules\Functions\CallToNonExistentFunctionRule($this->getService('reflectionProvider'), false); + } + + + public function createService0348(): PHPStan\Rules\Constants\OverridingConstantRule + { + return new PHPStan\Rules\Constants\OverridingConstantRule(true); + } + + + public function createService0349(): PHPStan\Rules\Methods\OverridingMethodRule + { + return new PHPStan\Rules\Methods\OverridingMethodRule( + $this->getService('023'), + $this->getService('0147'), + true, + $this->getService('0148'), + $this->getService('0103'), + false, + false, + false + ); + } + + + public function createService0350(): PHPStan\Rules\Methods\ConsistentConstructorRule + { + return new PHPStan\Rules\Methods\ConsistentConstructorRule($this->getService('0148')); + } + + + public function createService0351(): PHPStan\Rules\Missing\MissingReturnRule + { + return new PHPStan\Rules\Missing\MissingReturnRule(false, true); + } + + + public function createService0352(): PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule + { + return new PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + false + ); + } + + + public function createService0353(): PHPStan\Rules\Namespaces\ExistingNamesInUseRule + { + return new PHPStan\Rules\Namespaces\ExistingNamesInUseRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + false + ); + } + + + public function createService0354(): PHPStan\Rules\Operators\InvalidIncDecOperationRule + { + return new PHPStan\Rules\Operators\InvalidIncDecOperationRule($this->getService('0163'), false, false); + } + + + public function createService0355(): PHPStan\Rules\Properties\AccessPropertiesRule + { + return new PHPStan\Rules\Properties\AccessPropertiesRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + true, + false + ); + } + + + public function createService0356(): PHPStan\Rules\Properties\AccessStaticPropertiesRule + { + return new PHPStan\Rules\Properties\AccessStaticPropertiesRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('0120') + ); + } + + + public function createService0357(): PHPStan\Rules\Properties\ExistingClassesInPropertiesRule + { + return new PHPStan\Rules\Properties\ExistingClassesInPropertiesRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0155'), + $this->getService('023'), + true, + false + ); + } + + + public function createService0358(): PHPStan\Rules\Functions\FunctionCallableRule + { + return new PHPStan\Rules\Functions\FunctionCallableRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('023'), + false, + true + ); + } + + + public function createService0359(): PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule + { + return new PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule($this->getService('0368')); + } + + + public function createService0360(): PHPStan\Rules\Properties\OverridingPropertyRule + { + return new PHPStan\Rules\Properties\OverridingPropertyRule(true, false); + } + + + public function createService0361(): PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule + { + return new PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule; + } + + + public function createService0362(): PHPStan\Rules\Properties\UninitializedPropertyRule + { + return new PHPStan\Rules\Properties\UninitializedPropertyRule($this->getService('0368')); + } + + + public function createService0363(): PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule + { + return new PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule( + $this->getService('0163'), + $this->getService('0160'), + $this->getService('0161'), + false + ); + } + + + public function createService0364(): PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule + { + return new PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule( + $this->getService('0160'), + $this->getService('0161'), + $this->getService('0163'), + false + ); + } + + + public function createService0365(): PHPStan\Rules\Variables\CompactVariablesRule + { + return new PHPStan\Rules\Variables\CompactVariablesRule(true); + } + + + public function createService0366(): PHPStan\Rules\Variables\DefinedVariableRule + { + return new PHPStan\Rules\Variables\DefinedVariableRule(true, true); + } + + + public function createService0367(): PHPStan\Rules\Regexp\RegularExpressionPatternRule + { + return new PHPStan\Rules\Regexp\RegularExpressionPatternRule($this->getService('0252')); + } + + + public function createService0368(): PHPStan\Reflection\ConstructorsHelper + { + return new PHPStan\Reflection\ConstructorsHelper($this->getService('068'), []); + } + + + public function createService0369(): PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule + { + return new PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule($this->getService('023')); + } + + + public function createService0370(): PHPStan\Rules\Constants\MagicConstantContextRule + { + return new PHPStan\Rules\Constants\MagicConstantContextRule; + } + + + public function createService0371(): PHPStan\Rules\Functions\UselessFunctionReturnValueRule + { + return new PHPStan\Rules\Functions\UselessFunctionReturnValueRule($this->getService('reflectionProvider')); + } + + + public function createService0372(): PHPStan\Rules\Functions\PrintfArrayParametersRule + { + return new PHPStan\Rules\Functions\PrintfArrayParametersRule($this->getService('0330'), $this->getService('reflectionProvider')); + } + + + public function createService0373(): PHPStan\Rules\Regexp\RegularExpressionQuotingRule + { + return new PHPStan\Rules\Regexp\RegularExpressionQuotingRule($this->getService('reflectionProvider'), $this->getService('0252')); + } + + + public function createService0374(): PHPStan\Rules\Classes\MixinRule + { + return new PHPStan\Rules\Classes\MixinRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true, + false + ); + } + + + public function createService0375(): PHPStan\Rules\Classes\MethodTagRule + { + return new PHPStan\Rules\Classes\MethodTagRule($this->getService('0124')); + } + + + public function createService0376(): PHPStan\Rules\Classes\MethodTagTraitRule + { + return new PHPStan\Rules\Classes\MethodTagTraitRule($this->getService('0124'), $this->getService('reflectionProvider')); + } + + + public function createService0377(): PHPStan\Rules\Classes\PropertyTagRule + { + return new PHPStan\Rules\Classes\PropertyTagRule($this->getService('0125')); + } + + + public function createService0378(): PHPStan\Rules\Classes\PropertyTagTraitRule + { + return new PHPStan\Rules\Classes\PropertyTagTraitRule($this->getService('0125'), $this->getService('reflectionProvider')); + } + + + public function createService0379(): PHPStan\Rules\PhpDoc\RequireExtendsCheck + { + return new PHPStan\Rules\PhpDoc\RequireExtendsCheck($this->getService('0120'), true); + } + + + public function createService0380(): PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule + { + return new PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + true + ); + } + + + public function createService0381(): PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule + { + return new PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule; + } + + + public function createService0382(): PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule + { + return new PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule; + } + + + public function createService0383(): PHPStan\Rules\Functions\CallCallablesRule + { + return new PHPStan\Rules\Functions\CallCallablesRule($this->getService('0135'), $this->getService('0163'), true); + } + + + public function createService0384(): PHPStan\Rules\Methods\IllegalConstructorMethodCallRule + { + return new PHPStan\Rules\Methods\IllegalConstructorMethodCallRule; + } + + + public function createService0385(): PHPStan\Rules\Methods\IllegalConstructorStaticCallRule + { + return new PHPStan\Rules\Methods\IllegalConstructorStaticCallRule; + } + + + public function createService0386(): PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule + { + return new PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule($this->getService('026'), $this->getService('029'), false, false); + } + + + public function createService0387(): PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule + { + return new PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule( + $this->getService('0166'), + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true, + true + ); + } + + + public function createService0388(): PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule + { + return new PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule($this->getService('026'), $this->getService('029'), false); + } + + + public function createService0389(): PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule + { + return new PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule($this->getService('0157')); + } + + + public function createService0390(): PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule + { + return new PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule($this->getService('0166'), $this->getService('0157'), false); + } + + + public function createService0391(): PHPStan\Rules\Generics\PropertyVarianceRule + { + return new PHPStan\Rules\Generics\PropertyVarianceRule($this->getService('0143'), false); + } + + + public function createService0392(): PHPStan\Rules\Pure\PureFunctionRule + { + return new PHPStan\Rules\Pure\PureFunctionRule($this->getService('0162')); + } + + + public function createService0393(): PHPStan\Rules\Pure\PureMethodRule + { + return new PHPStan\Rules\Pure\PureMethodRule($this->getService('0162')); + } + + + public function createService0394(): PHPStan\Rules\Operators\InvalidBinaryOperationRule + { + return new PHPStan\Rules\Operators\InvalidBinaryOperationRule($this->getService('020'), $this->getService('0163'), false); + } + + + public function createService0395(): PHPStan\Rules\Operators\InvalidUnaryOperationRule + { + return new PHPStan\Rules\Operators\InvalidUnaryOperationRule($this->getService('0163'), false); + } + + + public function createService0396(): PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule + { + return new PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule($this->getService('0163'), true); + } + + + public function createService0397(): PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule + { + return new PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule(true); + } + + + public function createService0398(): PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule + { + return new PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule($this->getService('0163'), $this->getService('0119'), true); + } + + + public function createService0399(): PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule + { + return new PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule( + $this->getService('exceptionTypeResolver'), + false + ); + } + + + public function createService0400(): PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule + { + return new PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule( + $this->getService('exceptionTypeResolver'), + false + ); + } + + + public function createService0401(): PHPStan\Rules\Generators\YieldFromTypeRule + { + return new PHPStan\Rules\Generators\YieldFromTypeRule($this->getService('0163'), true); + } + + + public function createService0402(): PHPStan\Rules\Generators\YieldInGeneratorRule + { + return new PHPStan\Rules\Generators\YieldInGeneratorRule(true); + } + + + public function createService0403(): PHPStan\Rules\Arrays\ArrayUnpackingRule + { + return new PHPStan\Rules\Arrays\ArrayUnpackingRule($this->getService('023'), $this->getService('0163')); + } + + + public function createService0404(): PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule + { + return new PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule($this->getService('0161')); + } + + + public function createService0405(): PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule + { + return new PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule($this->getService('0161'), $this->getService('0368')); + } + + + public function createService0406(): PHPStan\Rules\Variables\ParameterOutAssignedTypeRule + { + return new PHPStan\Rules\Variables\ParameterOutAssignedTypeRule($this->getService('0163')); + } + + + public function createService0407(): PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule + { + return new PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule($this->getService('0163')); + } + + + public function createService0408(): PHPStan\Rules\Classes\ImpossibleInstanceOfRule + { + return new PHPStan\Rules\Classes\ImpossibleInstanceOfRule(false, true, false); + } + + + public function createService0409(): PHPStan\Rules\Comparison\BooleanAndConstantConditionRule + { + return new PHPStan\Rules\Comparison\BooleanAndConstantConditionRule($this->getService('0126'), true, false, false); + } + + + public function createService0410(): PHPStan\Rules\Comparison\BooleanOrConstantConditionRule + { + return new PHPStan\Rules\Comparison\BooleanOrConstantConditionRule($this->getService('0126'), true, false, false); + } + + + public function createService0411(): PHPStan\Rules\Comparison\BooleanNotConstantConditionRule + { + return new PHPStan\Rules\Comparison\BooleanNotConstantConditionRule($this->getService('0126'), true, false); + } + + + public function createService0412(): PHPStan\Rules\DeadCode\NoopRule + { + return new PHPStan\Rules\DeadCode\NoopRule($this->getService('020'), false); + } + + + public function createService0413(): PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule; + } + + + public function createService0414(): PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector + { + return new PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector; + } + + + public function createService0415(): PHPStan\Rules\DeadCode\PossiblyPureNewCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureNewCollector($this->getService('reflectionProvider')); + } + + + public function createService0416(): PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule; + } + + + public function createService0417(): PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector + { + return new PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector; + } + + + public function createService0418(): PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector($this->getService('reflectionProvider')); + } + + + public function createService0419(): PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule; + } + + + public function createService0420(): PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector + { + return new PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector; + } + + + public function createService0421(): PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector; + } + + + public function createService0422(): PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule; + } + + + public function createService0423(): PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector; + } + + + public function createService0424(): PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule + { + return new PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule($this->getService('0159'), [], [], false); + } + + + public function createService0425(): PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule + { + return new PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule($this->getService('0126'), true); + } + + + public function createService0426(): PHPStan\Rules\Comparison\ElseIfConstantConditionRule + { + return new PHPStan\Rules\Comparison\ElseIfConstantConditionRule($this->getService('0126'), true, false); + } + + + public function createService0427(): PHPStan\Rules\Comparison\IfConstantConditionRule + { + return new PHPStan\Rules\Comparison\IfConstantConditionRule($this->getService('0126'), true); + } + + + public function createService0428(): PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule($this->getService('0127'), false, true, false); + } + + + public function createService0429(): PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule($this->getService('0127'), false, true, false); + } + + + public function createService0430(): PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule($this->getService('0127'), false, true, false); + } + + + public function createService0431(): PHPStan\Rules\Comparison\LogicalXorConstantConditionRule + { + return new PHPStan\Rules\Comparison\LogicalXorConstantConditionRule($this->getService('0126'), true, false); + } + + + public function createService0432(): PHPStan\Rules\DeadCode\BetterNoopRule + { + return new PHPStan\Rules\DeadCode\BetterNoopRule($this->getService('020')); + } + + + public function createService0433(): PHPStan\Rules\Comparison\MatchExpressionRule + { + return new PHPStan\Rules\Comparison\MatchExpressionRule($this->getService('0126'), false, false, false, true); + } + + + public function createService0434(): PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule + { + return new PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule(true); + } + + + public function createService0435(): PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule + { + return new PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule(false, true, false); + } + + + public function createService0436(): PHPStan\Rules\Comparison\ConstantLooseComparisonRule + { + return new PHPStan\Rules\Comparison\ConstantLooseComparisonRule(false, true, false); + } + + + public function createService0437(): PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule + { + return new PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule($this->getService('0126'), true); + } + + + public function createService0438(): PHPStan\Rules\Comparison\UnreachableIfBranchesRule + { + return new PHPStan\Rules\Comparison\UnreachableIfBranchesRule($this->getService('0126'), true, false); + } + + + public function createService0439(): PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule + { + return new PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule($this->getService('0126'), true, false); + } + + + public function createService0440(): PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule + { + return new PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule($this->getService('0126'), true); + } + + + public function createService0441(): PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule + { + return new PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule($this->getService('0126'), true); + } + + + public function createService0442(): PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule( + $this->getService('reflectionProvider'), + false + ); + } + + + public function createService0443(): PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule(false, false); + } + + + public function createService0444(): PHPStan\Rules\Properties\NullsafePropertyFetchRule + { + return new PHPStan\Rules\Properties\NullsafePropertyFetchRule; + } + + + public function createService0445(): PHPStan\Rules\Traits\TraitDeclarationCollector + { + return new PHPStan\Rules\Traits\TraitDeclarationCollector; + } + + + public function createService0446(): PHPStan\Rules\Traits\TraitUseCollector + { + return new PHPStan\Rules\Traits\TraitUseCollector; + } + + + public function createService0447(): PHPStan\Rules\Traits\NotAnalysedTraitRule + { + return new PHPStan\Rules\Traits\NotAnalysedTraitRule; + } + + + public function createService0448(): PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule + { + return new PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule($this->getService('exceptionTypeResolver'), true); + } + + + public function createService0449(): PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule($this->getService('0165')); + } + + + public function createService0450(): PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule($this->getService('0165')); + } + + + public function createService0451(): PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule + { + return new PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule($this->getService('0159'), $this->getService('0161')); + } + + + public function createService0452(): PHPStan\Rules\Functions\RandomIntParametersRule + { + return new PHPStan\Rules\Functions\RandomIntParametersRule($this->getService('reflectionProvider'), true); + } + + + public function createService0453(): PHPStan\Rules\Functions\ArrayFilterRule + { + return new PHPStan\Rules\Functions\ArrayFilterRule($this->getService('reflectionProvider'), true); + } + + + public function createService0454(): PHPStan\Rules\Functions\ArrayValuesRule + { + return new PHPStan\Rules\Functions\ArrayValuesRule($this->getService('reflectionProvider'), true); + } + + + public function createService0455(): PHPStan\Rules\Functions\CallUserFuncRule + { + return new PHPStan\Rules\Functions\CallUserFuncRule($this->getService('reflectionProvider'), $this->getService('0135')); + } + + + public function createService0456(): PHPStan\Rules\Functions\ImplodeFunctionRule + { + return new PHPStan\Rules\Functions\ImplodeFunctionRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + false + ); + } + + + public function createService0457(): PHPStan\Rules\Functions\ParameterCastableToStringRule + { + return new PHPStan\Rules\Functions\ParameterCastableToStringRule( + $this->getService('reflectionProvider'), + $this->getService('0138') + ); + } + + + public function createService0458(): PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule + { + return new PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule( + $this->getService('reflectionProvider'), + $this->getService('0138') + ); + } + + + public function createService0459(): PHPStan\Rules\Functions\SortParameterCastableToStringRule + { + return new PHPStan\Rules\Functions\SortParameterCastableToStringRule( + $this->getService('reflectionProvider'), + $this->getService('0138') + ); + } + + + public function createService0460(): PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule + { + return new PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule($this->getService('0149'), false); + } + + + public function createService0461(): PHPStan\Rules\Methods\MissingMethodParameterTypehintRule + { + return new PHPStan\Rules\Methods\MissingMethodParameterTypehintRule($this->getService('0149'), false); + } + + + public function createService0462(): PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule + { + return new PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule($this->getService('0149')); + } + + + public function createServiceBetterReflectionClassReflector(): PHPStan\BetterReflection\Reflector\ClassReflector + { + return new PHPStan\BetterReflection\Reflector\ClassReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceBetterReflectionConstantReflector(): PHPStan\BetterReflection\Reflector\ConstantReflector + { + return new PHPStan\BetterReflection\Reflector\ConstantReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceBetterReflectionFunctionReflector(): PHPStan\BetterReflection\Reflector\FunctionReflector + { + return new PHPStan\BetterReflection\Reflector\FunctionReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceBetterReflectionProvider(): PHPStan\Reflection\BetterReflection\BetterReflectionProvider + { + return new PHPStan\Reflection\BetterReflection\BetterReflectionProvider( + $this->getService('0110'), + $this->getService('088'), + $this->getService('071'), + $this->getService('betterReflectionReflector'), + $this->getService('0166'), + $this->getService('031'), + $this->getService('023'), + $this->getService('0111'), + $this->getService('stubPhpDocProvider'), + $this->getService('087'), + $this->getService('relativePathHelper'), + $this->getService('022'), + $this->getService('078'), + $this->getService('0334'), + $this->getService('0116'), + ['stdClass'] + ); + } + + + public function createServiceBetterReflectionReflector(): PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector + { + return new PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector($this->getService('originalBetterReflectionReflector')); + } + + + public function createServiceBetterReflectionSourceLocator(): PHPStan\BetterReflection\SourceLocator\Type\SourceLocator + { + return $this->getService('0331')->create(); + } + + + public function createServiceBroker(): PHPStan\Broker\Broker + { + return $this->getService('brokerFactory')->create(); + } + + + public function createServiceBrokerFactory(): PHPStan\Broker\BrokerFactory + { + return new PHPStan\Broker\BrokerFactory($this->getService('068')); + } + + + public function createServiceCacheStorage(): PHPStan\Cache\FileCacheStorage + { + return new PHPStan\Cache\FileCacheStorage('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/cache/PHPStan'); + } + + + public function createServiceContainer(): Container_9bdc8b8877 + { + return $this; + } + + + public function createServiceCurrentPhpVersionLexer(): PhpParser\Lexer + { + return $this->getService('02')->create(); + } + + + public function createServiceCurrentPhpVersionPhpParser(): PhpParser\Parser\Php7 + { + return new PhpParser\Parser\Php7($this->getService('currentPhpVersionLexer')); + } + + + public function createServiceCurrentPhpVersionRichParser(): PHPStan\Parser\RichParser + { + return new PHPStan\Parser\RichParser( + $this->getService('currentPhpVersionPhpParser'), + $this->getService('currentPhpVersionLexer'), + $this->getService('03'), + $this->getService('068'), + $this->getService('050'), + false + ); + } + + + public function createServiceCurrentPhpVersionSimpleDirectParser(): PHPStan\Parser\SimpleParser + { + return new PHPStan\Parser\SimpleParser($this->getService('currentPhpVersionPhpParser'), $this->getService('03')); + } + + + public function createServiceCurrentPhpVersionSimpleParser(): PHPStan\Parser\CleaningParser + { + return new PHPStan\Parser\CleaningParser($this->getService('currentPhpVersionSimpleDirectParser'), $this->getService('023')); + } + + + public function createServiceDefaultAnalysisParser(): PHPStan\Parser\CachedParser + { + return new PHPStan\Parser\CachedParser($this->getService('pathRoutingParser'), 256); + } + + + public function createServiceErrorFormatter__checkstyle(): PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__github(): PHPStan\Command\ErrorFormatter\GithubErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\GithubErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__gitlab(): PHPStan\Command\ErrorFormatter\GitlabErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\GitlabErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__json(): PHPStan\Command\ErrorFormatter\JsonErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\JsonErrorFormatter(false); + } + + + public function createServiceErrorFormatter__junit(): PHPStan\Command\ErrorFormatter\JunitErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\JunitErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__prettyJson(): PHPStan\Command\ErrorFormatter\JsonErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\JsonErrorFormatter(true); + } + + + public function createServiceErrorFormatter__raw(): PHPStan\Command\ErrorFormatter\RawErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\RawErrorFormatter; + } + + + public function createServiceErrorFormatter__table(): PHPStan\Command\ErrorFormatter\TableErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\TableErrorFormatter( + $this->getService('relativePathHelper'), + $this->getService('simpleRelativePathHelper'), + $this->getService('0337'), + true, + null, + null + ); + } + + + public function createServiceErrorFormatter__teamcity(): PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceExceptionTypeResolver(): PHPStan\Rules\Exceptions\ExceptionTypeResolver + { + return $this->getService('0128'); + } + + + public function createServiceFileExcluderAnalyse(): PHPStan\File\FileExcluder + { + return $this->getService('079')->createAnalyseFileExcluder(); + } + + + public function createServiceFileExcluderScan(): PHPStan\File\FileExcluder + { + return $this->getService('079')->createScanFileExcluder(); + } + + + public function createServiceFileFinderAnalyse(): PHPStan\File\FileFinder + { + return new PHPStan\File\FileFinder($this->getService('fileExcluderAnalyse'), $this->getService('078'), ['php']); + } + + + public function createServiceFileFinderScan(): PHPStan\File\FileFinder + { + return new PHPStan\File\FileFinder($this->getService('fileExcluderScan'), $this->getService('078'), ['php']); + } + + + public function createServiceNodeScopeResolverReflector(): PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector + { + return $this->getService('betterReflectionReflector'); + } + + + public function createServiceOriginalBetterReflectionReflector(): PHPStan\BetterReflection\Reflector\DefaultReflector + { + return new PHPStan\BetterReflection\Reflector\DefaultReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceParentDirectoryRelativePathHelper(): PHPStan\File\ParentDirectoryRelativePathHelper + { + return new PHPStan\File\ParentDirectoryRelativePathHelper('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'); + } + + + public function createServicePathRoutingParser(): PHPStan\Parser\PathRoutingParser + { + return new PHPStan\Parser\PathRoutingParser( + $this->getService('078'), + $this->getService('currentPhpVersionRichParser'), + $this->getService('currentPhpVersionSimpleParser'), + $this->getService('php8Parser') + ); + } + + + public function createServicePhp8Lexer(): PhpParser\Lexer\Emulative + { + return $this->getService('02')->createEmulative(); + } + + + public function createServicePhp8Parser(): PHPStan\Parser\SimpleParser + { + return new PHPStan\Parser\SimpleParser($this->getService('php8PhpParser'), $this->getService('03')); + } + + + public function createServicePhp8PhpParser(): PhpParser\Parser\Php7 + { + return new PhpParser\Parser\Php7($this->getService('php8Lexer')); + } + + + public function createServicePhpParserDecorator(): PHPStan\Parser\PhpParserDecorator + { + return new PHPStan\Parser\PhpParserDecorator($this->getService('defaultAnalysisParser')); + } + + + public function createServicePhpstanDiagnoseExtension(): PHPStan\Diagnose\PHPStanDiagnoseExtension + { + return new PHPStan\Diagnose\PHPStanDiagnoseExtension( + $this->getService('023'), + $this->getService('078'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/phpstan.neon', + ] + ); + } + + + public function createServiceReflectionProvider(): PHPStan\Reflection\ReflectionProvider + { + return $this->getService('reflectionProviderFactory')->create(); + } + + + public function createServiceReflectionProviderFactory(): PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory + { + return new PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory($this->getService('betterReflectionProvider')); + } + + + public function createServiceRegistry(): PHPStan\Rules\LazyRegistry + { + return new PHPStan\Rules\LazyRegistry($this->getService('068')); + } + + + public function createServiceRelativePathHelper(): PHPStan\File\RelativePathHelper + { + return new PHPStan\File\FuzzyRelativePathHelper( + $this->getService('parentDirectoryRelativePathHelper'), + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + $this->getParameter('analysedPaths') + ); + } + + + public function createServiceRules__0(): PHPStan\Rules\Debug\DumpTypeRule + { + return new PHPStan\Rules\Debug\DumpTypeRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__1(): PHPStan\Rules\Debug\FileAssertRule + { + return new PHPStan\Rules\Debug\FileAssertRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__10(): PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule + { + return new PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule($this->getService('0117')); + } + + + public function createServiceRules__100(): PHPStan\Rules\Generics\ClassTemplateTypeRule + { + return new PHPStan\Rules\Generics\ClassTemplateTypeRule($this->getService('0142')); + } + + + public function createServiceRules__101(): PHPStan\Rules\Generics\EnumAncestorsRule + { + return new PHPStan\Rules\Generics\EnumAncestorsRule($this->getService('0140'), $this->getService('0139')); + } + + + public function createServiceRules__102(): PHPStan\Rules\Generics\EnumTemplateTypeRule + { + return new PHPStan\Rules\Generics\EnumTemplateTypeRule; + } + + + public function createServiceRules__103(): PHPStan\Rules\Generics\FunctionTemplateTypeRule + { + return new PHPStan\Rules\Generics\FunctionTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__104(): PHPStan\Rules\Generics\FunctionSignatureVarianceRule + { + return new PHPStan\Rules\Generics\FunctionSignatureVarianceRule($this->getService('0143')); + } + + + public function createServiceRules__105(): PHPStan\Rules\Generics\InterfaceAncestorsRule + { + return new PHPStan\Rules\Generics\InterfaceAncestorsRule($this->getService('0140'), $this->getService('0139')); + } + + + public function createServiceRules__106(): PHPStan\Rules\Generics\InterfaceTemplateTypeRule + { + return new PHPStan\Rules\Generics\InterfaceTemplateTypeRule($this->getService('0142')); + } + + + public function createServiceRules__107(): PHPStan\Rules\Generics\MethodTemplateTypeRule + { + return new PHPStan\Rules\Generics\MethodTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__108(): PHPStan\Rules\Generics\MethodTagTemplateTypeRule + { + return new PHPStan\Rules\Generics\MethodTagTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__109(): PHPStan\Rules\Generics\MethodSignatureVarianceRule + { + return new PHPStan\Rules\Generics\MethodSignatureVarianceRule($this->getService('0143')); + } + + + public function createServiceRules__11(): PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule + { + return new PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule($this->getService('020')); + } + + + public function createServiceRules__110(): PHPStan\Rules\Generics\TraitTemplateTypeRule + { + return new PHPStan\Rules\Generics\TraitTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__111(): PHPStan\Rules\Generics\UsedTraitsRule + { + return new PHPStan\Rules\Generics\UsedTraitsRule($this->getService('0166'), $this->getService('0140')); + } + + + public function createServiceRules__112(): PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule + { + return new PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule; + } + + + public function createServiceRules__113(): PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule + { + return new PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule; + } + + + public function createServiceRules__114(): PHPStan\Rules\Operators\InvalidComparisonOperationRule + { + return new PHPStan\Rules\Operators\InvalidComparisonOperationRule($this->getService('0163')); + } + + + public function createServiceRules__115(): PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule + { + return new PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule($this->getService('0153')); + } + + + public function createServiceRules__116(): PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule + { + return new PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule($this->getService('0153')); + } + + + public function createServiceRules__117(): PHPStan\Rules\PhpDoc\FunctionAssertRule + { + return new PHPStan\Rules\PhpDoc\FunctionAssertRule($this->getService('0154')); + } + + + public function createServiceRules__118(): PHPStan\Rules\PhpDoc\MethodAssertRule + { + return new PHPStan\Rules\PhpDoc\MethodAssertRule($this->getService('0154')); + } + + + public function createServiceRules__119(): PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule($this->getService('0155'), $this->getService('0141')); + } + + + public function createServiceRules__12(): PHPStan\Rules\Arrays\EmptyArrayItemRule + { + return new PHPStan\Rules\Arrays\EmptyArrayItemRule; + } + + + public function createServiceRules__120(): PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule($this->getService('0141'), $this->getService('0155')); + } + + + public function createServiceRules__121(): PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule( + $this->getService('0166'), + $this->getService('0141'), + $this->getService('0155'), + $this->getService('0156') + ); + } + + + public function createServiceRules__122(): PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule( + $this->getService('0141'), + $this->getService('0155'), + $this->getService('0156') + ); + } + + + public function createServiceRules__123(): PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule + { + return new PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule($this->getService('0166')); + } + + + public function createServiceRules__124(): PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule + { + return new PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule($this->getService('0166')); + } + + + public function createServiceRules__125(): PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule + { + return new PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule; + } + + + public function createServiceRules__126(): PHPStan\Rules\Classes\RequireImplementsRule + { + return new PHPStan\Rules\Classes\RequireImplementsRule; + } + + + public function createServiceRules__127(): PHPStan\Rules\Classes\RequireExtendsRule + { + return new PHPStan\Rules\Classes\RequireExtendsRule; + } + + + public function createServiceRules__128(): PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule + { + return new PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule; + } + + + public function createServiceRules__129(): PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule + { + return new PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule($this->getService('0379')); + } + + + public function createServiceRules__13(): PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule + { + return new PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule; + } + + + public function createServiceRules__130(): PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule + { + return new PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule( + $this->getService('reflectionProvider'), + $this->getService('0379') + ); + } + + + public function createServiceRules__131(): PHPStan\Rules\Arrays\ArrayDestructuringRule + { + return new PHPStan\Rules\Arrays\ArrayDestructuringRule($this->getService('0163'), $this->getService('0119')); + } + + + public function createServiceRules__132(): PHPStan\Rules\Arrays\IterableInForeachRule + { + return new PHPStan\Rules\Arrays\IterableInForeachRule($this->getService('0163')); + } + + + public function createServiceRules__133(): PHPStan\Rules\Arrays\OffsetAccessAssignmentRule + { + return new PHPStan\Rules\Arrays\OffsetAccessAssignmentRule($this->getService('0163')); + } + + + public function createServiceRules__134(): PHPStan\Rules\Arrays\OffsetAccessAssignOpRule + { + return new PHPStan\Rules\Arrays\OffsetAccessAssignOpRule($this->getService('0163')); + } + + + public function createServiceRules__135(): PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule + { + return new PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule($this->getService('0163')); + } + + + public function createServiceRules__136(): PHPStan\Rules\Arrays\UnpackIterableInArrayRule + { + return new PHPStan\Rules\Arrays\UnpackIterableInArrayRule($this->getService('0163')); + } + + + public function createServiceRules__137(): PHPStan\Rules\Exceptions\ThrowExprTypeRule + { + return new PHPStan\Rules\Exceptions\ThrowExprTypeRule($this->getService('0163')); + } + + + public function createServiceRules__138(): PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule + { + return new PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__139(): PHPStan\Rules\Functions\ClosureReturnTypeRule + { + return new PHPStan\Rules\Functions\ClosureReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__14(): PHPStan\Rules\Cast\UnsetCastRule + { + return new PHPStan\Rules\Cast\UnsetCastRule($this->getService('023')); + } + + + public function createServiceRules__140(): PHPStan\Rules\Functions\ReturnTypeRule + { + return new PHPStan\Rules\Functions\ReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__141(): PHPStan\Rules\Generators\YieldTypeRule + { + return new PHPStan\Rules\Generators\YieldTypeRule($this->getService('0163')); + } + + + public function createServiceRules__142(): PHPStan\Rules\Methods\ReturnTypeRule + { + return new PHPStan\Rules\Methods\ReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__143(): PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule + { + return new PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule($this->getService('0163')); + } + + + public function createServiceRules__144(): PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule + { + return new PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule($this->getService('0161'), $this->getService('0368')); + } + + + public function createServiceRules__145(): PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule + { + return new PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule($this->getService('0161')); + } + + + public function createServiceRules__146(): PHPStan\Rules\Properties\TypesAssignedToPropertiesRule + { + return new PHPStan\Rules\Properties\TypesAssignedToPropertiesRule($this->getService('0163'), $this->getService('0161')); + } + + + public function createServiceRules__147(): PHPStan\Rules\Variables\ThrowTypeRule + { + return new PHPStan\Rules\Variables\ThrowTypeRule($this->getService('0163')); + } + + + public function createServiceRules__148(): PHPStan\Rules\Variables\VariableCloningRule + { + return new PHPStan\Rules\Variables\VariableCloningRule($this->getService('0163')); + } + + + public function createServiceRules__149(): PHPStan\Rules\Arrays\DeadForeachRule + { + return new PHPStan\Rules\Arrays\DeadForeachRule; + } + + + public function createServiceRules__15(): PHPStan\Rules\Classes\AllowedSubTypesRule + { + return new PHPStan\Rules\Classes\AllowedSubTypesRule; + } + + + public function createServiceRules__150(): PHPStan\Rules\DeadCode\UnreachableStatementRule + { + return new PHPStan\Rules\DeadCode\UnreachableStatementRule; + } + + + public function createServiceRules__151(): PHPStan\Rules\DeadCode\UnusedPrivateConstantRule + { + return new PHPStan\Rules\DeadCode\UnusedPrivateConstantRule($this->getService('0151')); + } + + + public function createServiceRules__152(): PHPStan\Rules\DeadCode\UnusedPrivateMethodRule + { + return new PHPStan\Rules\DeadCode\UnusedPrivateMethodRule($this->getService('0152')); + } + + + public function createServiceRules__153(): PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule + { + return new PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule; + } + + + public function createServiceRules__154(): PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__155(): PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule($this->getService('0163')); + } + + + public function createServiceRules__156(): PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule( + $this->getService('0163'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__157(): PHPStan\Rules\Methods\NullsafeMethodCallRule + { + return new PHPStan\Rules\Methods\NullsafeMethodCallRule; + } + + + public function createServiceRules__158(): PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule; + } + + + public function createServiceRules__159(): PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule; + } + + + public function createServiceRules__16(): PHPStan\Rules\Classes\ClassAttributesRule + { + return new PHPStan\Rules\Classes\ClassAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__160(): PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule; + } + + + public function createServiceRules__161(): PHPStan\Rules\DateTimeInstantiationRule + { + return new PHPStan\Rules\DateTimeInstantiationRule; + } + + + public function createServiceRules__162(): PHPStan\Rules\Constants\MissingClassConstantTypehintRule + { + return new PHPStan\Rules\Constants\MissingClassConstantTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__163(): PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule + { + return new PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__164(): PHPStan\Rules\Methods\MissingMethodReturnTypehintRule + { + return new PHPStan\Rules\Methods\MissingMethodReturnTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__165(): PHPStan\Rules\Properties\MissingPropertyTypehintRule + { + return new PHPStan\Rules\Properties\MissingPropertyTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__17(): PHPStan\Rules\Classes\ClassConstantAttributesRule + { + return new PHPStan\Rules\Classes\ClassConstantAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__18(): PHPStan\Rules\Classes\ClassConstantRule + { + return new PHPStan\Rules\Classes\ClassConstantRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('0120'), + $this->getService('023') + ); + } + + + public function createServiceRules__19(): PHPStan\Rules\Classes\DuplicateDeclarationRule + { + return new PHPStan\Rules\Classes\DuplicateDeclarationRule; + } + + + public function createServiceRules__2(): PHPStan\Rules\Api\ApiInstantiationRule + { + return new PHPStan\Rules\Api\ApiInstantiationRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__20(): PHPStan\Rules\Classes\EnumSanityRule + { + return new PHPStan\Rules\Classes\EnumSanityRule; + } + + + public function createServiceRules__21(): PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule + { + return new PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__22(): PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule + { + return new PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__23(): PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule + { + return new PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__24(): PHPStan\Rules\Classes\ExistingClassInTraitUseRule + { + return new PHPStan\Rules\Classes\ExistingClassInTraitUseRule($this->getService('0120'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__25(): PHPStan\Rules\Classes\InstantiationRule + { + return new PHPStan\Rules\Classes\InstantiationRule( + $this->getService('reflectionProvider'), + $this->getService('0135'), + $this->getService('0120') + ); + } + + + public function createServiceRules__26(): PHPStan\Rules\Classes\InstantiationCallableRule + { + return new PHPStan\Rules\Classes\InstantiationCallableRule; + } + + + public function createServiceRules__27(): PHPStan\Rules\Classes\InvalidPromotedPropertiesRule + { + return new PHPStan\Rules\Classes\InvalidPromotedPropertiesRule($this->getService('023')); + } + + + public function createServiceRules__28(): PHPStan\Rules\Classes\LocalTypeAliasesRule + { + return new PHPStan\Rules\Classes\LocalTypeAliasesRule($this->getService('0123')); + } + + + public function createServiceRules__29(): PHPStan\Rules\Classes\LocalTypeTraitAliasesRule + { + return new PHPStan\Rules\Classes\LocalTypeTraitAliasesRule($this->getService('0123'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__3(): PHPStan\Rules\Api\ApiClassExtendsRule + { + return new PHPStan\Rules\Api\ApiClassExtendsRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__30(): PHPStan\Rules\Classes\NewStaticRule + { + return new PHPStan\Rules\Classes\NewStaticRule; + } + + + public function createServiceRules__31(): PHPStan\Rules\Classes\NonClassAttributeClassRule + { + return new PHPStan\Rules\Classes\NonClassAttributeClassRule; + } + + + public function createServiceRules__32(): PHPStan\Rules\Classes\ReadOnlyClassRule + { + return new PHPStan\Rules\Classes\ReadOnlyClassRule($this->getService('023')); + } + + + public function createServiceRules__33(): PHPStan\Rules\Classes\TraitAttributeClassRule + { + return new PHPStan\Rules\Classes\TraitAttributeClassRule; + } + + + public function createServiceRules__34(): PHPStan\Rules\Constants\DynamicClassConstantFetchRule + { + return new PHPStan\Rules\Constants\DynamicClassConstantFetchRule($this->getService('023'), $this->getService('0163')); + } + + + public function createServiceRules__35(): PHPStan\Rules\Constants\FinalConstantRule + { + return new PHPStan\Rules\Constants\FinalConstantRule($this->getService('023')); + } + + + public function createServiceRules__36(): PHPStan\Rules\Constants\NativeTypedClassConstantRule + { + return new PHPStan\Rules\Constants\NativeTypedClassConstantRule($this->getService('023')); + } + + + public function createServiceRules__37(): PHPStan\Rules\EnumCases\EnumCaseAttributesRule + { + return new PHPStan\Rules\EnumCases\EnumCaseAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__38(): PHPStan\Rules\Exceptions\NoncapturingCatchRule + { + return new PHPStan\Rules\Exceptions\NoncapturingCatchRule($this->getService('023')); + } + + + public function createServiceRules__39(): PHPStan\Rules\Exceptions\ThrowExpressionRule + { + return new PHPStan\Rules\Exceptions\ThrowExpressionRule($this->getService('023')); + } + + + public function createServiceRules__4(): PHPStan\Rules\Api\ApiClassImplementsRule + { + return new PHPStan\Rules\Api\ApiClassImplementsRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__40(): PHPStan\Rules\Functions\ArrowFunctionAttributesRule + { + return new PHPStan\Rules\Functions\ArrowFunctionAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__41(): PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule + { + return new PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule($this->getService('0150')); + } + + + public function createServiceRules__42(): PHPStan\Rules\Functions\ClosureAttributesRule + { + return new PHPStan\Rules\Functions\ClosureAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__43(): PHPStan\Rules\Functions\DefineParametersRule + { + return new PHPStan\Rules\Functions\DefineParametersRule($this->getService('023')); + } + + + public function createServiceRules__44(): PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule + { + return new PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule( + $this->getService('0136'), + $this->getService('023') + ); + } + + + public function createServiceRules__45(): PHPStan\Rules\Functions\CallToFunctionParametersRule + { + return new PHPStan\Rules\Functions\CallToFunctionParametersRule( + $this->getService('reflectionProvider'), + $this->getService('0135') + ); + } + + + public function createServiceRules__46(): PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule + { + return new PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule($this->getService('0136')); + } + + + public function createServiceRules__47(): PHPStan\Rules\Functions\ExistingClassesInTypehintsRule + { + return new PHPStan\Rules\Functions\ExistingClassesInTypehintsRule($this->getService('0136')); + } + + + public function createServiceRules__48(): PHPStan\Rules\Functions\FunctionAttributesRule + { + return new PHPStan\Rules\Functions\FunctionAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__49(): PHPStan\Rules\Functions\InnerFunctionRule + { + return new PHPStan\Rules\Functions\InnerFunctionRule; + } + + + public function createServiceRules__5(): PHPStan\Rules\Api\ApiInterfaceExtendsRule + { + return new PHPStan\Rules\Api\ApiInterfaceExtendsRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__50(): PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule + { + return new PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule; + } + + + public function createServiceRules__51(): PHPStan\Rules\Functions\ParamAttributesRule + { + return new PHPStan\Rules\Functions\ParamAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__52(): PHPStan\Rules\Functions\PrintfParametersRule + { + return new PHPStan\Rules\Functions\PrintfParametersRule($this->getService('0330'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__53(): PHPStan\Rules\Functions\RedefinedParametersRule + { + return new PHPStan\Rules\Functions\RedefinedParametersRule; + } + + + public function createServiceRules__54(): PHPStan\Rules\Functions\ReturnNullsafeByRefRule + { + return new PHPStan\Rules\Functions\ReturnNullsafeByRefRule($this->getService('0150')); + } + + + public function createServiceRules__55(): PHPStan\Rules\Ignore\IgnoreParseErrorRule + { + return new PHPStan\Rules\Ignore\IgnoreParseErrorRule; + } + + + public function createServiceRules__56(): PHPStan\Rules\Functions\VariadicParametersDeclarationRule + { + return new PHPStan\Rules\Functions\VariadicParametersDeclarationRule; + } + + + public function createServiceRules__57(): PHPStan\Rules\Keywords\ContinueBreakInLoopRule + { + return new PHPStan\Rules\Keywords\ContinueBreakInLoopRule; + } + + + public function createServiceRules__58(): PHPStan\Rules\Keywords\DeclareStrictTypesRule + { + return new PHPStan\Rules\Keywords\DeclareStrictTypesRule($this->getService('020')); + } + + + public function createServiceRules__59(): PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule + { + return new PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule; + } + + + public function createServiceRules__6(): PHPStan\Rules\Api\ApiMethodCallRule + { + return new PHPStan\Rules\Api\ApiMethodCallRule($this->getService('0117')); + } + + + public function createServiceRules__60(): PHPStan\Rules\Methods\AbstractPrivateMethodRule + { + return new PHPStan\Rules\Methods\AbstractPrivateMethodRule; + } + + + public function createServiceRules__61(): PHPStan\Rules\Methods\CallMethodsRule + { + return new PHPStan\Rules\Methods\CallMethodsRule($this->getService('0145'), $this->getService('0135')); + } + + + public function createServiceRules__62(): PHPStan\Rules\Methods\CallStaticMethodsRule + { + return new PHPStan\Rules\Methods\CallStaticMethodsRule($this->getService('0146'), $this->getService('0135')); + } + + + public function createServiceRules__63(): PHPStan\Rules\Methods\ConstructorReturnTypeRule + { + return new PHPStan\Rules\Methods\ConstructorReturnTypeRule; + } + + + public function createServiceRules__64(): PHPStan\Rules\Methods\ExistingClassesInTypehintsRule + { + return new PHPStan\Rules\Methods\ExistingClassesInTypehintsRule($this->getService('0136')); + } + + + public function createServiceRules__65(): PHPStan\Rules\Methods\FinalPrivateMethodRule + { + return new PHPStan\Rules\Methods\FinalPrivateMethodRule($this->getService('023')); + } + + + public function createServiceRules__66(): PHPStan\Rules\Methods\MethodCallableRule + { + return new PHPStan\Rules\Methods\MethodCallableRule($this->getService('0145'), $this->getService('023')); + } + + + public function createServiceRules__67(): PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule + { + return new PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule; + } + + + public function createServiceRules__68(): PHPStan\Rules\Methods\MissingMethodImplementationRule + { + return new PHPStan\Rules\Methods\MissingMethodImplementationRule; + } + + + public function createServiceRules__69(): PHPStan\Rules\Methods\MethodAttributesRule + { + return new PHPStan\Rules\Methods\MethodAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__7(): PHPStan\Rules\Api\ApiStaticCallRule + { + return new PHPStan\Rules\Api\ApiStaticCallRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__70(): PHPStan\Rules\Methods\StaticMethodCallableRule + { + return new PHPStan\Rules\Methods\StaticMethodCallableRule($this->getService('0146'), $this->getService('023')); + } + + + public function createServiceRules__71(): PHPStan\Rules\Names\UsedNamesRule + { + return new PHPStan\Rules\Names\UsedNamesRule; + } + + + public function createServiceRules__72(): PHPStan\Rules\Operators\InvalidAssignVarRule + { + return new PHPStan\Rules\Operators\InvalidAssignVarRule($this->getService('0150')); + } + + + public function createServiceRules__73(): PHPStan\Rules\Properties\AccessPropertiesInAssignRule + { + return new PHPStan\Rules\Properties\AccessPropertiesInAssignRule($this->getService('0355')); + } + + + public function createServiceRules__74(): PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule + { + return new PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule($this->getService('0356')); + } + + + public function createServiceRules__75(): PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule + { + return new PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule; + } + + + public function createServiceRules__76(): PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule + { + return new PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule($this->getService('0368')); + } + + + public function createServiceRules__77(): PHPStan\Rules\Properties\PropertiesInInterfaceRule + { + return new PHPStan\Rules\Properties\PropertiesInInterfaceRule; + } + + + public function createServiceRules__78(): PHPStan\Rules\Properties\PropertyAttributesRule + { + return new PHPStan\Rules\Properties\PropertyAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__79(): PHPStan\Rules\Properties\ReadOnlyPropertyRule + { + return new PHPStan\Rules\Properties\ReadOnlyPropertyRule($this->getService('023')); + } + + + public function createServiceRules__8(): PHPStan\Rules\Api\ApiTraitUseRule + { + return new PHPStan\Rules\Api\ApiTraitUseRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__80(): PHPStan\Rules\Traits\ConflictingTraitConstantsRule + { + return new PHPStan\Rules\Traits\ConflictingTraitConstantsRule($this->getService('088')); + } + + + public function createServiceRules__81(): PHPStan\Rules\Traits\ConstantsInTraitsRule + { + return new PHPStan\Rules\Traits\ConstantsInTraitsRule($this->getService('023')); + } + + + public function createServiceRules__82(): PHPStan\Rules\Types\InvalidTypesInUnionRule + { + return new PHPStan\Rules\Types\InvalidTypesInUnionRule; + } + + + public function createServiceRules__83(): PHPStan\Rules\Variables\UnsetRule + { + return new PHPStan\Rules\Variables\UnsetRule; + } + + + public function createServiceRules__84(): PHPStan\Rules\Whitespace\FileWhitespaceRule + { + return new PHPStan\Rules\Whitespace\FileWhitespaceRule; + } + + + public function createServiceRules__85(): PHPStan\Rules\Classes\UnusedConstructorParametersRule + { + return new PHPStan\Rules\Classes\UnusedConstructorParametersRule($this->getService('0164')); + } + + + public function createServiceRules__86(): PHPStan\Rules\Constants\ConstantRule + { + return new PHPStan\Rules\Constants\ConstantRule; + } + + + public function createServiceRules__87(): PHPStan\Rules\Functions\UnusedClosureUsesRule + { + return new PHPStan\Rules\Functions\UnusedClosureUsesRule($this->getService('0164')); + } + + + public function createServiceRules__88(): PHPStan\Rules\Variables\EmptyRule + { + return new PHPStan\Rules\Variables\EmptyRule($this->getService('0144')); + } + + + public function createServiceRules__89(): PHPStan\Rules\Variables\IssetRule + { + return new PHPStan\Rules\Variables\IssetRule($this->getService('0144')); + } + + + public function createServiceRules__9(): PHPStan\Rules\Api\GetTemplateTypeRule + { + return new PHPStan\Rules\Api\GetTemplateTypeRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__90(): PHPStan\Rules\Variables\NullCoalesceRule + { + return new PHPStan\Rules\Variables\NullCoalesceRule($this->getService('0144')); + } + + + public function createServiceRules__91(): PHPStan\Rules\Cast\EchoRule + { + return new PHPStan\Rules\Cast\EchoRule($this->getService('0163')); + } + + + public function createServiceRules__92(): PHPStan\Rules\Cast\InvalidCastRule + { + return new PHPStan\Rules\Cast\InvalidCastRule($this->getService('reflectionProvider'), $this->getService('0163')); + } + + + public function createServiceRules__93(): PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule + { + return new PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule($this->getService('020'), $this->getService('0163')); + } + + + public function createServiceRules__94(): PHPStan\Rules\Cast\PrintRule + { + return new PHPStan\Rules\Cast\PrintRule($this->getService('0163')); + } + + + public function createServiceRules__95(): PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule + { + return new PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule; + } + + + public function createServiceRules__96(): PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule + { + return new PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule; + } + + + public function createServiceRules__97(): PHPStan\Rules\Constants\ValueAssignedToClassConstantRule + { + return new PHPStan\Rules\Constants\ValueAssignedToClassConstantRule; + } + + + public function createServiceRules__98(): PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule + { + return new PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule; + } + + + public function createServiceRules__99(): PHPStan\Rules\Generics\ClassAncestorsRule + { + return new PHPStan\Rules\Generics\ClassAncestorsRule($this->getService('0140'), $this->getService('0139')); + } + + + public function createServiceSimpleRelativePathHelper(): PHPStan\File\RelativePathHelper + { + return new PHPStan\File\SimpleRelativePathHelper('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'); + } + + + public function createServiceStubPhpDocProvider(): PHPStan\PhpDoc\StubPhpDocProvider + { + return new PHPStan\PhpDoc\StubPhpDocProvider( + $this->getService('defaultAnalysisParser'), + $this->getService('0166'), + $this->getService('041') + ); + } + + + public function createServiceTypeSpecifier(): PHPStan\Analyser\TypeSpecifier + { + return $this->getService('typeSpecifierFactory')->create(); + } + + + public function createServiceTypeSpecifierFactory(): PHPStan\Analyser\TypeSpecifierFactory + { + return new PHPStan\Analyser\TypeSpecifierFactory($this->getService('068')); + } + + + public function initialize(): void + { + } + + + protected function getStaticParameters(): array + { + return [ + 'bootstrapFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionUnionType.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionAttribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/Attribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionIntersectionType.php', + ], + 'excludes_analyse' => [], + 'excludePaths' => null, + 'level' => 9, + 'paths' => ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/php'], + 'exceptions' => [ + 'implicitThrows' => true, + 'reportUncheckedExceptionDeadCatch' => true, + 'uncheckedExceptionRegexes' => [], + 'uncheckedExceptionClasses' => [], + 'checkedExceptionRegexes' => [], + 'checkedExceptionClasses' => [], + 'check' => ['missingCheckedExceptionInThrows' => false, 'tooWideThrowType' => false], + ], + 'featureToggles' => [ + 'bleedingEdge' => false, + 'disableRuntimeReflectionProvider' => true, + 'skipCheckGenericClasses' => [ + 'DatePeriod', + 'CallbackFilterIterator', + 'FilterIterator', + 'RecursiveCallbackFilterIterator', + 'AppendIterator', + 'NoRewindIterator', + 'LimitIterator', + 'InfiniteIterator', + 'CachingIterator', + 'RegexIterator', + 'ReflectionEnum', + ], + 'explicitMixedInUnknownGenericNew' => false, + 'explicitMixedForGlobalVariables' => false, + 'explicitMixedViaIsArray' => false, + 'arrayFilter' => false, + 'arrayUnpacking' => false, + 'arrayValues' => false, + 'nodeConnectingVisitorCompatibility' => true, + 'nodeConnectingVisitorRule' => false, + 'illegalConstructorMethodCall' => false, + 'disableCheckMissingIterableValueType' => false, + 'strictUnnecessaryNullsafePropertyFetch' => false, + 'looseComparison' => false, + 'consistentConstructor' => false, + 'checkUnresolvableParameterTypes' => false, + 'readOnlyByPhpDoc' => false, + 'phpDocParserRequireWhitespaceBeforeDescription' => false, + 'phpDocParserIncludeLines' => false, + 'enableIgnoreErrorsWithinPhpDocs' => false, + 'runtimeReflectionRules' => false, + 'notAnalysedTrait' => false, + 'curlSetOptTypes' => false, + 'listType' => false, + 'abstractTraitMethod' => false, + 'missingMagicSerializationRule' => false, + 'nullContextForVoidReturningFunctions' => false, + 'unescapeStrings' => false, + 'alwaysCheckTooWideReturnTypeFinalMethods' => false, + 'duplicateStubs' => false, + 'logicalXor' => false, + 'betterNoop' => false, + 'invarianceComposition' => false, + 'alwaysTrueAlwaysReported' => false, + 'disableUnreachableBranchesRules' => false, + 'varTagType' => false, + 'closureDefaultParameterTypeRule' => false, + 'newRuleLevelHelper' => false, + 'instanceofType' => false, + 'paramOutVariance' => false, + 'allInvalidPhpDocs' => false, + 'strictStaticMethodTemplateTypeVariance' => false, + 'propertyVariance' => false, + 'genericPrototypeMessage' => false, + 'stricterFunctionMap' => false, + 'invalidPhpDocTagLine' => false, + 'detectDeadTypeInMultiCatch' => false, + 'zeroFiles' => false, + 'projectServicesNotInAnalysedPaths' => false, + 'callUserFunc' => false, + 'finalByPhpDoc' => false, + 'magicConstantOutOfContext' => false, + 'paramOutType' => false, + 'pure' => false, + 'checkParameterCastableToStringFunctions' => false, + 'uselessReturnValue' => false, + 'printfArrayParameters' => false, + 'preciseMissingReturn' => false, + 'validatePregQuote' => false, + 'noImplicitWildcard' => false, + 'narrowPregMatches' => true, + 'tooWidePropertyType' => false, + 'explicitThrow' => false, + 'absentTypeChecks' => false, + ], + 'fileExtensions' => ['php'], + 'checkAdvancedIsset' => true, + 'checkAlwaysTrueCheckTypeFunctionCall' => false, + 'checkAlwaysTrueInstanceof' => false, + 'checkAlwaysTrueStrictComparison' => false, + 'checkAlwaysTrueLooseComparison' => false, + 'reportAlwaysTrueInLastCondition' => false, + 'checkClassCaseSensitivity' => true, + 'checkExplicitMixed' => true, + 'checkImplicitMixed' => false, + 'checkFunctionArgumentTypes' => true, + 'checkFunctionNameCase' => false, + 'checkGenericClassInNonGenericObjectType' => true, + 'checkInternalClassCaseSensitivity' => false, + 'checkMissingIterableValueType' => true, + 'checkMissingCallableSignature' => false, + 'checkMissingVarTagTypehint' => true, + 'checkArgumentsPassedByReference' => true, + 'checkMaybeUndefinedVariables' => true, + 'checkNullables' => true, + 'checkThisOnly' => false, + 'checkUnionTypes' => true, + 'checkBenevolentUnionTypes' => false, + 'checkExplicitMixedMissingReturn' => false, + 'checkPhpDocMissingReturn' => true, + 'checkPhpDocMethodSignatures' => true, + 'checkExtraArguments' => true, + 'checkMissingTypehints' => true, + 'checkTooWideReturnTypesInProtectedAndPublicMethods' => false, + 'checkUninitializedProperties' => false, + 'checkDynamicProperties' => false, + 'deprecationRulesInstalled' => false, + 'inferPrivatePropertyTypeFromConstructor' => false, + 'reportMaybes' => true, + 'reportMaybesInMethodSignatures' => false, + 'reportMaybesInPropertyPhpDocTypes' => false, + 'reportStaticMethodSignatures' => false, + 'reportWrongPhpDocTypeInVarTag' => false, + 'reportAnyTypeWideningInVarTag' => false, + 'reportPossiblyNonexistentGeneralArrayOffset' => false, + 'reportPossiblyNonexistentConstantArrayOffset' => false, + 'checkMissingOverrideMethodAttribute' => false, + 'mixinExcludeClasses' => [], + 'scanFiles' => [], + 'scanDirectories' => ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/php'], + 'parallel' => [ + 'jobSize' => 20, + 'processTimeout' => 600.0, + 'maximumNumberOfProcesses' => 32, + 'minimumNumberOfJobsPerProcess' => 2, + 'buffer' => 134217728, + ], + 'phpVersion' => null, + 'polluteScopeWithLoopInitialAssignments' => true, + 'polluteScopeWithAlwaysIterableForeach' => true, + 'propertyAlwaysWrittenTags' => [], + 'propertyAlwaysReadTags' => [], + 'additionalConstructors' => [], + 'treatPhpDocTypesAsCertain' => true, + 'usePathConstantsAsConstantString' => false, + 'rememberPossiblyImpureFunctionValues' => true, + 'tipsOfTheDay' => true, + 'reportMagicMethods' => true, + 'reportMagicProperties' => true, + 'ignoreErrors' => [], + 'internalErrorsCountLimit' => 50, + 'cache' => ['nodesByFileCountMax' => 1024, 'nodesByStringCountMax' => 256], + 'reportUnmatchedIgnoredErrors' => true, + 'scopeClass' => 'PHPStan\Analyser\MutatingScope', + 'typeAliases' => [], + 'universalObjectCratesClasses' => ['stdClass'], + 'stubFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionAttribute.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClass.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClassConstant.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionFunctionAbstract.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionMethod.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionParameter.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionProperty.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/iterable.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ArrayObject.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/WeakReference.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ext-ds.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ImagickPixel.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/PDOStatement.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/date.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ibm_db2.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/mysqli.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/zip.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/dom.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/spl.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/SplObjectStorage.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/Exception.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/arrayFunctions.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/core.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/typeCheckingFunctions.stub', + ], + 'earlyTerminatingMethodCalls' => [], + 'earlyTerminatingFunctionCalls' => [], + 'memoryLimitFile' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/.memory_limit', + 'tempResultCachePath' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCaches', + 'resultCachePath' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCache.php', + 'resultCacheChecksProjectExtensionFilesDependencies' => false, + 'staticReflectionClassNamePatterns' => [], + 'dynamicConstantNames' => [ + 'ICONV_IMPL', + 'LIBXML_VERSION', + 'LIBXML_DOTTED_VERSION', + 'Memcached::HAVE_ENCODING', + 'Memcached::HAVE_IGBINARY', + 'Memcached::HAVE_JSON', + 'Memcached::HAVE_MSGPACK', + 'Memcached::HAVE_SASL', + 'Memcached::HAVE_SESSION', + 'PHP_VERSION', + 'PHP_MAJOR_VERSION', + 'PHP_MINOR_VERSION', + 'PHP_RELEASE_VERSION', + 'PHP_VERSION_ID', + 'PHP_EXTRA_VERSION', + 'PHP_WINDOWS_VERSION_MAJOR', + 'PHP_WINDOWS_VERSION_MINOR', + 'PHP_WINDOWS_VERSION_BUILD', + 'PHP_ZTS', + 'PHP_DEBUG', + 'PHP_MAXPATHLEN', + 'PHP_OS', + 'PHP_OS_FAMILY', + 'PHP_SAPI', + 'PHP_EOL', + 'PHP_INT_MAX', + 'PHP_INT_MIN', + 'PHP_INT_SIZE', + 'PHP_FLOAT_DIG', + 'PHP_FLOAT_EPSILON', + 'PHP_FLOAT_MIN', + 'PHP_FLOAT_MAX', + 'DEFAULT_INCLUDE_PATH', + 'PEAR_INSTALL_DIR', + 'PEAR_EXTENSION_DIR', + 'PHP_EXTENSION_DIR', + 'PHP_PREFIX', + 'PHP_BINDIR', + 'PHP_BINARY', + 'PHP_MANDIR', + 'PHP_LIBDIR', + 'PHP_DATADIR', + 'PHP_SYSCONFDIR', + 'PHP_LOCALSTATEDIR', + 'PHP_CONFIG_FILE_PATH', + 'PHP_CONFIG_FILE_SCAN_DIR', + 'PHP_SHLIB_SUFFIX', + 'PHP_FD_SETSIZE', + 'OPENSSL_VERSION_NUMBER', + 'ZEND_DEBUG_BUILD', + 'ZEND_THREAD_SAFE', + ], + 'customRulesetUsed' => false, + 'editorUrl' => null, + 'editorUrlTitle' => null, + 'errorFormat' => null, + 'sourceLocatorPlaygroundMode' => false, + '__validate' => true, + 'tmpDir' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan', + 'debugMode' => true, + 'productionMode' => false, + 'tempDir' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan', + 'rootDir' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan', + 'currentWorkingDirectory' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + 'cliArgumentsVariablesRegistered' => true, + 'additionalConfigFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/phpstan.neon', + ], + 'allConfigFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/phpstan.neon', + ], + 'composerAutoloaderProjectPaths' => ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + 'generateBaselineFile' => null, + 'usedLevel' => '9', + 'cliAutoloadFile' => null, + ]; + } + + + protected function getDynamicParameter($key) + { + switch (true) { + case $key === 'analysedPaths': return null; + case $key === 'analysedPathsFromConfig': return null; + case $key === 'env': return null; + case $key === 'fixerTmpDir': return ($this->getParameter('sysGetTempDir')) . '/phpstan-fixer'; + case $key === 'sysGetTempDir': return sys_get_temp_dir(); + case $key === 'pro': return [ + 'dnsServers' => ['1.1.1.2'], + 'tmpDir' => ($this->getParameter('sysGetTempDir')) . '/phpstan-fixer', + ]; + default: return parent::getDynamicParameter($key); + }; + } + + + public function getParameters(): array + { + array_map(function ($key) { $this->getParameter($key); }, [ + 'analysedPaths', + 'analysedPathsFromConfig', + 'env', + 'fixerTmpDir', + 'sysGetTempDir', + 'pro', + ]); + return parent::getParameters(); + } +} diff --git a/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php.lock b/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php.lock new file mode 100644 index 0000000..e69de29 diff --git a/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php.meta b/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php.meta new file mode 100644 index 0000000..f0de0aa --- /dev/null +++ b/test/cache/phpstan/cache/nette.configurator/Container_9bdc8b8877.php.meta @@ -0,0 +1 @@ +a:6:{i:0;i:1;i:1;a:22:{s:119:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.neon";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon";i:1724750225;s:77:"/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/test/phpstan.neon";i:1726410431;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Extensions/ServicesExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Extensions/ParametersExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/bootstrap/src/Bootstrap/Extensions/PhpExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Extensions/ExtensionsExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/RulesExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ConditionalTagsExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ParametersSchemaExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ValidateIgnoredErrorsExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ValidateExcludePathsExtension.php";i:1724750225;}i:2;a:722:{s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Debug/DumpTypeRule.php";i:1724750225;s:121:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Rule.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Debug/FileAssertRule.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInstantiationRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiClassExtendsRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiClassImplementsRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInterfaceExtendsRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiMethodCallRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiStaticCallRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiTraitUseRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/GetTemplateTypeRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/PhpStanNamespaceIn3rdPartyPackageRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/DuplicateKeysInLiteralArraysRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/EmptyArrayItemRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessWithoutDimForReadingRule.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/UnsetCastRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/AllowedSubTypesRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ClassAttributesRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ClassConstantAttributesRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ClassConstantRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/DuplicateDeclarationRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/EnumSanityRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassesInClassImplementsRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassesInEnumImplementsRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassesInInterfaceExtendsRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassInTraitUseRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/InstantiationRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/InstantiationCallableRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/InvalidPromotedPropertiesRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/LocalTypeAliasesRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/LocalTypeTraitAliasesRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/NewStaticRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/NonClassAttributeClassRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ReadOnlyClassRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/TraitAttributeClassRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/DynamicClassConstantFetchRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/FinalConstantRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/NativeTypedClassConstantRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/EnumCases/EnumCaseAttributesRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/NoncapturingCatchRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowExpressionRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrowFunctionAttributesRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrowFunctionReturnNullsafeByRefRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ClosureAttributesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/DefineParametersRule.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallToFunctionParametersRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ExistingClassesInClosureTypehintsRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ExistingClassesInTypehintsRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/FunctionAttributesRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/InnerFunctionRule.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/InvalidLexicalVariablesInClosureUseRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ParamAttributesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/PrintfParametersRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/RedefinedParametersRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ReturnNullsafeByRefRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Ignore/IgnoreParseErrorRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/VariadicParametersDeclarationRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Keywords/ContinueBreakInLoopRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Keywords/DeclareStrictTypesRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/AbstractMethodInNonAbstractClassRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/AbstractPrivateMethodRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallMethodsRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallStaticMethodsRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ConstructorReturnTypeRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ExistingClassesInTypehintsRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/FinalPrivateMethodRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodCallableRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodVisibilityInInterfaceRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodImplementationRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodAttributesRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/StaticMethodCallableRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Names/UsedNamesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidAssignVarRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessPropertiesInAssignRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessStaticPropertiesInAssignRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/InvalidCallablePropertyTypeRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/MissingReadOnlyPropertyAssignRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertiesInInterfaceRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertyAttributesRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyPropertyRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/ConflictingTraitConstantsRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/ConstantsInTraitsRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Types/InvalidTypesInUnionRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/UnsetRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Whitespace/FileWhitespaceRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/UnusedConstructorParametersRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/ConstantRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/UnusedClosureUsesRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/EmptyRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/IssetRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/NullCoalesceRule.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/EchoRule.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/InvalidCastRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/InvalidPartOfEncapsedStringRule.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/PrintRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/AccessPrivateConstantThroughStaticRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/UsageOfVoidMatchExpressionRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/ValueAssignedToClassConstantRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/IncompatibleDefaultParameterTypeRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/ClassAncestorsRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/ClassTemplateTypeRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/EnumAncestorsRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/EnumTemplateTypeRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/FunctionTemplateTypeRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/FunctionSignatureVarianceRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/InterfaceAncestorsRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/InterfaceTemplateTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/MethodTemplateTypeRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/MethodTagTemplateTypeRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/MethodSignatureVarianceRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/TraitTemplateTypeRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/UsedTraitsRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallPrivateMethodThroughStaticRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/IncompatibleDefaultParameterTypeRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidComparisonOperationRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/FunctionConditionalReturnTypeRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/MethodConditionalReturnTypeRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/FunctionAssertRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/MethodAssertRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatibleSelfOutTypeRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatibleClassConstantPhpDocTypeRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidThrowsPhpDocValueRule.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatibleParamImmediatelyInvokedCallableRule.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessPrivatePropertyThroughStaticRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/RequireImplementsRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/RequireExtendsRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireImplementsDefinitionClassRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireExtendsDefinitionClassRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireExtendsDefinitionTraitRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/ArrayDestructuringRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/IterableInForeachRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessAssignmentRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessAssignOpRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessValueAssignmentRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/UnpackIterableInArrayRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowExprTypeRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrowFunctionReturnTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ClosureReturnTypeRule.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ReturnTypeRule.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generators/YieldTypeRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ReturnTypeRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/DefaultValueTypesAssignedToPropertiesRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyPropertyAssignRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyPropertyAssignRefRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/TypesAssignedToPropertiesRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/ThrowTypeRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/VariableCloningRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/DeadForeachRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnreachableStatementRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnusedPrivateConstantRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnusedPrivateMethodRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/OverwrittenExitPointByFinallyRule.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallToFunctionStatementWithoutSideEffectsRule.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallToMethodStatementWithoutSideEffectsRule.php";i:1724750225;s:174:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallToStaticMethodStatementWithoutSideEffectsRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/NullsafeMethodCallRule.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideArrowFunctionReturnTypehintRule.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideClosureReturnTypehintRule.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DateTimeInstantiationRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/MissingClassConstantTypehintRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/MissingFunctionReturnTypehintRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodReturnTypehintRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/MissingPropertyTypehintRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/LexerFactory.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NameResolver.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitorAbstract.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/AnonymousClassVisitor.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrayFilterArgVisitor.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrayMapArgVisitor.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrayWalkArgVisitor.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ClosureArgVisitor.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ClosureBindToVarVisitor.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ClosureBindArgVisitor.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/CurlSetOptArgVisitor.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/TypeTraverserInstanceofVisitor.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrowFunctionArgVisitor.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/MagicConstantParamDefaultVisitor.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/NewAssignedToPropertyVisitor.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ParentStmtTypesVisitor.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/TryCatchTypeVisitor.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/LastConditionVisitor.php";i:1724750225;s:178:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NodeConnectingVisitor.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Node/Printer/ExprPrinter.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Node/Printer/Printer.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinter/Standard.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Broker/AnonymousClassNameHelper.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Php/PhpVersionFactoryFactory.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Lexer/Lexer.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Parser/TypeParser.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Parser/PhpDocParser.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/ConstExprParserFactory.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/PhpDocInheritanceResolver.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/PhpDocNodeResolver.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/PhpDocStringResolver.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/ConstExprNodeResolver.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/TypeNodeResolver.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/TypeStringResolver.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubValidator.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/CountableStubFilesExtension.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubFilesExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/SocketSelectStubFilesExtension.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/DefaultStubFilesProvider.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubFilesProvider.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/JsonValidateStubFilesExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/ReflectionEnumStubFilesExtension.php";i:1724750225;s:128:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/Analyser.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/AnalyserResultFinalizer.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/FileAnalyser.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/LocalIgnoresProcessor.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/RuleErrorTransformer.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/Ignore/IgnoredErrorHelper.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/Ignore/IgnoreLexer.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/LazyInternalScopeFactory.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/InternalScopeFactory.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ScopeFactory.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/NodeScopeResolver.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ConstantResolverFactory.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ResultCache/ResultCacheClearer.php";i:1724750225;s:122:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Cache/Cache.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Collectors/RegistryFactory.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/AnalyseApplication.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/AnalyserRunner.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/FixerApplication.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/DependencyResolver.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/ExportedNodeFetcher.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/ExportedNodeResolver.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/ExportedNodeVisitor.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Nette/NetteContainer.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Container.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/DerivativeContainerFactory.php";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileHelper.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileExcluderFactory.php";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileFinder.php";i:1724750225;s:127:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileMonitor.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/DeclarePositionVisitor.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parallel/ParallelAnalyser.php";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parallel/Scheduler.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Diagnose/DiagnoseExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/FunctionCallStatementFinder.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Process/CpuCoreCounter.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/InitializerExprTypeResolver.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Annotations/AnnotationsMethodsClassReflectionExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/MethodsClassReflectionExtension.php";i:1724750225;s:179:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Annotations/AnnotationsPropertiesClassReflectionExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/PropertiesClassReflectionExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/FileNodesFetcher.php";i:1724750225;s:199:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/ComposerJsonAndInstalledJsonSourceLocatorMaker.php";i:1724750225;s:191:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedDirectorySourceLocatorFactory.php";i:1724750225;s:194:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedDirectorySourceLocatorRepository.php";i:1724750225;s:195:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedSingleFileSourceLocatorRepository.php";i:1724750225;s:184:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/RequireExtension/RequireExtendsMethodsClassReflectionExtension.php";i:1724750225;s:187:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/RequireExtension/RequireExtendsPropertiesClassReflectionExtension.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Mixin/MixinMethodsClassReflectionExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Mixin/MixinPropertiesClassReflectionExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpClassReflectionExtension.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/Soap/SoapClientMethodsClassReflectionExtension.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/EnumAllowedSubTypesClassReflectionExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/AllowedSubTypesClassReflectionExtension.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/UniversalObjectCratesClassReflectionExtension.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/PHPStan/NativeReflectionEnumReturnDynamicReturnTypeExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicMethodReturnTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/NativeFunctionReflectionProvider.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/SignatureMapParser.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/FunctionSignatureMapProvider.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/SignatureMapProvider.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/Php8SignatureMapProvider.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/SignatureMapProviderFactory.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiRuleHelper.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/AttributesCheck.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchCheck.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ClassNameCheck.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ClassCaseSensitivityCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ClassForbiddenNameCheck.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/LocalTypeAliasesCheck.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MethodTagCheck.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/PropertyTagCheck.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ConstantConditionRuleHelper.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeHelper.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/DefaultExceptionTypeResolver.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ExceptionTypeResolver.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/MissingCheckedExceptionInFunctionThrowsRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/MissingCheckedExceptionInMethodThrowsRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/MissingCheckedExceptionInThrowsCheck.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/TooWideFunctionThrowTypeRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/TooWideMethodThrowTypeRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/TooWideThrowTypeCheck.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/FunctionCallParametersCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/FunctionDefinitionCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/FunctionReturnTypeCheck.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ParameterCastableToStringCheck.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/CrossCheckInterfacesHelper.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/GenericAncestorsCheck.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/GenericObjectTypeCheck.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/TemplateTypeCheck.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/VarianceCheck.php";i:1724750225;s:127:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/IssetCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodCallCheck.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/StaticMethodCallCheck.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodSignatureRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodParameterComparisonHelper.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/MissingTypehintCheck.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/NullsafeCheck.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/LazyAlwaysUsedClassConstantsExtensionProvider.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/ConditionalReturnTypeRuleHelper.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/AssertRuleHelper.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/UnresolvableTypeHelper.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/GenericCallableRuleHelper.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/VarTagTypeRuleHelper.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Playground/NeverRuleHelper.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertyDescriptor.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertyReflectionFinder.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Pure/FunctionPurityCheck.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/RuleLevelHelper.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/UnusedFunctionParametersCheck.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideParameterOutTypeCheck.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FileTypeMapper.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/BitwiseFlagHelper.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/AbsFunctionDynamicReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicFunctionReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArgumentBasedFunctionReturnTypeExtension.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayIntersectKeyFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayChunkFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayColumnFunctionReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayCombineFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayCurrentDynamicReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFillFunctionReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFillKeysFunctionReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFilterFunctionReturnTypeReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFlipFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyDynamicReturnTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyExistsFunctionTypeSpecifyingExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FunctionTypeSpecifyingExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/TypeSpecifierAwareExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyFirstDynamicReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyLastDynamicReturnTypeExtension.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeysFunctionDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayMapFunctionReturnTypeExtension.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayMergeFunctionDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayNextDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayPopFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayRandFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayReduceFunctionReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayReplaceFunctionReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayReverseFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayShiftFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySliceFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySpliceFunctionReturnTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySearchFunctionDynamicReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySearchFunctionTypeSpecifyingExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayValuesFunctionDynamicReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySumFunctionDynamicReturnTypeExtension.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/AssertThrowTypeExtension.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicFunctionThrowTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/BackedEnumFromMethodDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicStaticMethodReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/Base64DecodeDynamicFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/BcMathStringOrNullReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClosureBindDynamicReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClosureBindToDynamicReturnTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClosureFromCallableDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CompactFunctionReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ConstantFunctionReturnTypeExtension.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ConstantHelper.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CountFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CountFunctionTypeSpecifyingExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CurlGetinfoFunctionDynamicReturnTypeExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CurlInitReturnTypeExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFunctionReturnTypeHelper.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFormatFunctionReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFormatMethodReturnTypeExtension.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFunctionReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateIntervalConstructorThrowTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicStaticMethodThrowTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateIntervalDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeCreateDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeDynamicReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeModifyReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeConstructorThrowTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeModifyMethodThrowTypeExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicMethodThrowTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeZoneConstructorThrowTypeExtension.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DsMapDynamicReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DsMapDynamicMethodThrowTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DioStatDynamicFunctionReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ExplodeFunctionDynamicReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterFunctionReturnTypeHelper.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterInputDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterVarDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterVarArrayDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetCalledClassDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetClassDynamicReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetDebugTypeFunctionReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetParentClassDynamicFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GettypeFunctionReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GettimeofdayDynamicFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/HashFunctionsReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/HighlightStringDynamicReturnTypeExtension.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IntdivThrowTypeExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IniGetReturnTypeExtension.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/JsonThrowTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregMatchTypeSpecifyingExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregMatchParameterOutTypeExtension.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FunctionParameterOutTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregReplaceCallbackClosureTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FunctionParameterClosureTypeExtension.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RegexArrayShapeMatcher.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Regex/RegexGroupParser.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Regex/RegexExpressionHelper.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionClassConstructorThrowTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionFunctionConstructorThrowTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionMethodConstructorThrowTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionPropertyConstructorThrowTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrContainingTypeSpecifyingExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementClassPropertyReflectionExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementConstructorThrowTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StatDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MethodExistsTypeSpecifyingExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PropertyExistsTypeSpecifyingExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MinMaxFunctionReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/NumberFormatFunctionDynamicReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PathinfoFunctionDynamicReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregFilterFunctionReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregSplitDynamicReturnTypeExtension.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionClassIsSubclassOfTypeSpecifyingExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/MethodTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReplaceFunctionsDynamicReturnTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayPointerFunctionsDynamicReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/LtrimFunctionReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbFunctionsReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbFunctionsReturnTypeExtensionTrait.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbConvertEncodingFunctionReturnTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbSubstituteCharacterDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbStrlenFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MicrotimeFunctionReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/HrtimeFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ImplodeFunctionReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/NonEmptyStringFunctionsReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SetTypeFunctionTypeSpecifyingExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrCaseFunctionsReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrlenFunctionReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrIncrementDecrementFunctionReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrPadFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrRepeatFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SubstrDynamicReturnTypeExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ThrowableReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ParseUrlFunctionDynamicReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/TriggerErrorDynamicReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/VersionCompareFunctionDynamicReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PowFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RoundFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrtotimeFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RandomIntFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RangeFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/AssertFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClassExistsFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClassImplementsFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DefineConstantTypeSpecifyingExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DefinedConstantTypeSpecifyingExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FunctionExistsFunctionTypeSpecifyingExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/InArrayFunctionTypeSpecifyingExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsArrayFunctionTypeSpecifyingExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsCallableFunctionTypeSpecifyingExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsIterableFunctionTypeSpecifyingExtension.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsSubclassOfFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IteratorToArrayFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsAFunctionTypeSpecifyingExtension.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsAFunctionTypeSpecifyingHelper.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CtypeDigitFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/JsonThrowOnErrorDynamicReturnTypeExtension.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/TypeSpecifyingFunctionsDynamicReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementAsXMLMethodReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementXpathMethodReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrSplitFunctionReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrTokFunctionReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SprintfFunctionDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SscanfFunctionDynamicReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrvalFamilyFunctionReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrWordCountFunctionDynamicReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/XMLReaderOpenReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionGetAttributesMethodReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DatePeriodConstructorReturnTypeExtension.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/ClosureTypeFactory.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Constant/OversizedArrayBuilder.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/PrintfHelper.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/TypeSpecifierFactory.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/ParentDirectoryRelativePathHelper.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/RelativePathHelper.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Broker/BrokerFactory.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Cache/FileCacheStorage.php";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Cache/CacheStorage.php";i:1724750225;s:128:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/RichParser.php";i:1724750225;s:124:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/Parser.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/CleaningParser.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/SimpleParser.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/CachedParser.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/PhpParserDecorator.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Parser.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Parser/Php7.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/LazyRegistry.php";i:1724750225;s:125:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Registry.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubPhpDocProvider.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider/ReflectionProviderFactory.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider.php";i:1724750225;s:175:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/DefaultReflector.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/Reflector.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/Reflector/MemoizingReflector.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/ClassReflector.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/FunctionReflector.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/ConstantReflector.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/BetterReflectionProvider.php";i:1724750225;s:175:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/BetterReflectionSourceLocatorFactory.php";i:1724750225;s:186:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceStubber/PhpStormStubsSourceStubberFactory.php";i:1724750225;s:203:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/SourceStubber/PhpStormStubsSourceStubber.php";i:1724750225;s:190:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/SourceStubber/SourceStubber.php";i:1724750225;s:183:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceStubber/ReflectionSourceStubberFactory.php";i:1724750225;s:200:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/SourceStubber/ReflectionSourceStubber.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/PathRoutingParser.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Diagnose/PHPStanDiagnoseExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/CiDetectedErrorFormatter.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/ErrorFormatter.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/RawErrorFormatter.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/TableErrorFormatter.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/CheckstyleErrorFormatter.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/JsonErrorFormatter.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/JunitErrorFormatter.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/GitlabErrorFormatter.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/GithubErrorFormatter.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/TeamcityErrorFormatter.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiClassConstFetchRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInstanceofRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInstanceofTypeRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/NodeConnectingVisitorAttributesRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/RuntimeReflectionFunctionRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/RuntimeReflectionInstantiationRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassInClassExtendsRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassInInstanceOfRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/CaughtExceptionExistenceRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallToNonExistentFunctionRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/OverridingConstantRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/OverridingMethodRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ConsistentConstructorRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Missing/MissingReturnRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Namespaces/ExistingNamesInGroupUseRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Namespaces/ExistingNamesInUseRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidIncDecOperationRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessPropertiesRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessStaticPropertiesRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ExistingClassesInPropertiesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/FunctionCallableRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/OverridingPropertyRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyByPhpDocPropertyRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/UninitializedPropertyRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/WritingToReadOnlyPropertiesRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadingWriteOnlyPropertiesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/CompactVariablesRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/DefinedVariableRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Regexp/RegularExpressionPatternRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ConstructorsHelper.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMagicSerializationMethodsRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/MagicConstantContextRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/UselessFunctionReturnValueRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/PrintfArrayParametersRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Regexp/RegularExpressionQuotingRule.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MixinRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MethodTagRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MethodTagTraitRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/PropertyTagRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/PropertyTagTraitRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireExtendsCheck.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireImplementsDefinitionTraitRule.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/IncompatibleArrowFunctionDefaultParameterTypeRule.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/IncompatibleClosureDefaultParameterTypeRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallCallablesRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/IllegalConstructorMethodCallRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/IllegalConstructorStaticCallRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidPhpDocTagValueRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidPHPStanDocTagRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/VarTagChangedExpressionTypeRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/WrongVariableNameInVarTagRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/PropertyVarianceRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Pure/PureFunctionRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Pure/PureMethodRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidBinaryOperationRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidUnaryOperationRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/InvalidKeyInArrayDimFetchRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/InvalidKeyInArrayItemRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchRule.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowsVoidFunctionWithExplicitThrowPointRule.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowsVoidMethodWithExplicitThrowPointRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generators/YieldFromTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generators/YieldInGeneratorRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/ArrayUnpackingRule.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRefRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/ParameterOutAssignedTypeRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/ParameterOutExecutionEndTypeRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ImpossibleInstanceOfRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/BooleanAndConstantConditionRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/BooleanOrConstantConditionRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/BooleanNotConstantConditionRule.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/NoopRule.php";i:1724750225;s:175:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToConstructorStatementWithoutImpurePointsRule.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/ConstructorWithoutImpurePointsCollector.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Collectors/Collector.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureNewCollector.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToFunctionStatementWithoutImpurePointsRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/FunctionWithoutImpurePointsCollector.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureFuncCallCollector.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToMethodStatementWithoutImpurePointsRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/MethodWithoutImpurePointsCollector.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureMethodCallCollector.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToStaticMethodStatementWithoutImpurePointsRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureStaticCallCollector.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnusedPrivatePropertyRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/DoWhileLoopConstantConditionRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ElseIfConstantConditionRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/IfConstantConditionRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/LogicalXorConstantConditionRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/BetterNoopRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/MatchExpressionRule.php";i:1724750225;s:174:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ConstantLooseComparisonRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/TernaryOperatorConstantConditionRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/UnreachableIfBranchesRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/UnreachableTernaryElseBranchRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/WhileLoopAlwaysFalseConditionRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/WhileLoopAlwaysTrueConditionRule.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallToConstructorStatementWithoutSideEffectsRule.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/NullsafePropertyFetchRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/TraitDeclarationCollector.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/TraitUseCollector.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/NotAnalysedTraitRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/CatchWithUnthrownExceptionRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideFunctionParameterOutTypeRule.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideMethodParameterOutTypeRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/RandomIntParametersRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrayFilterRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrayValuesRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallUserFuncRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ImplodeFunctionRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ParameterCastableToStringRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ImplodeParameterCastableToStringRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/SortParameterCastableToStringRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/MissingFunctionParameterTypehintRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodParameterTypehintRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodSelfOutTypeRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Container.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/utils/src/SmartObject.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Php/PhpVersionFactory.php";i:1724750225;s:125:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Php/PhpVersion.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Parser/ConstExprParser.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/TypeNodeResolverExtensionRegistryProvider.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ConstantResolver.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ResultCache/ResultCacheManager.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ResultCache/ResultCacheManagerFactory.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Collectors/Registry.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/MemoizingContainer.php";i:1724750225;s:186:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Reflection/ClassReflectionExtensionRegistryProvider.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyDynamicReturnTypeExtensionRegistryProvider.php";i:1724750225;s:178:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyParameterOutTypeExtensionProvider.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/ParameterOutTypeExtensionProvider.php";i:1724750225;s:187:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyExpressionTypeResolverExtensionRegistryProvider.php";i:1724750225;s:183:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/ExpressionTypeResolverExtensionRegistryProvider.php";i:1724750225;s:187:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyOperatorTypeSpecifyingExtensionRegistryProvider.php";i:1724750225;s:183:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyDynamicThrowTypeExtensionProvider.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/DynamicThrowTypeExtensionProvider.php";i:1724750225;s:177:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyParameterClosureTypeExtensionProvider.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/ParameterClosureTypeExtensionProvider.php";i:1724750225;s:128:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileExcluder.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileExcluderRawFactory.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpFunctionReflection.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/FunctionReflection.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/FunctionReflectionFactory.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedPsrAutoloaderLocator.php";i:1724750225;s:181:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/Type/SourceLocator.php";i:1724750225;s:189:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedPsrAutoloaderLocatorFactory.php";i:1724750225;s:185:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedSingleFileSourceLocator.php";i:1724750225;s:192:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedSingleFileSourceLocatorFactory.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpMethodReflection.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ExtendedMethodReflection.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ClassMemberReflection.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/MethodReflection.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpMethodReflectionFactory.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider/LazyReflectionProviderProvider.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider/ReflectionProviderProvider.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/UsefulTypeAliasResolver.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/TypeAliasResolver.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/LazyTypeAliasResolverProvider.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/TypeAliasResolverProvider.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/TypeSpecifier.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FuzzyRelativePathHelper.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/SimpleRelativePathHelper.php";i:1724750225;s:124:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Broker/Broker.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Lexer.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/BetterReflectionProviderFactory.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Lexer/Emulative.php";i:1724750225;}i:3;a:708:{i:0;s:32:"PHPStan\Rules\Debug\DumpTypeRule";i:1;s:18:"PHPStan\Rules\Rule";i:2;s:34:"PHPStan\Rules\Debug\FileAssertRule";i:3;s:38:"PHPStan\Rules\Api\ApiInstantiationRule";i:4;s:37:"PHPStan\Rules\Api\ApiClassExtendsRule";i:5;s:40:"PHPStan\Rules\Api\ApiClassImplementsRule";i:6;s:41:"PHPStan\Rules\Api\ApiInterfaceExtendsRule";i:7;s:35:"PHPStan\Rules\Api\ApiMethodCallRule";i:8;s:35:"PHPStan\Rules\Api\ApiStaticCallRule";i:9;s:33:"PHPStan\Rules\Api\ApiTraitUseRule";i:10;s:37:"PHPStan\Rules\Api\GetTemplateTypeRule";i:11;s:55:"PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule";i:12;s:53:"PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule";i:13;s:39:"PHPStan\Rules\Arrays\EmptyArrayItemRule";i:14;s:57:"PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule";i:15;s:32:"PHPStan\Rules\Cast\UnsetCastRule";i:16;s:41:"PHPStan\Rules\Classes\AllowedSubTypesRule";i:17;s:41:"PHPStan\Rules\Classes\ClassAttributesRule";i:18;s:49:"PHPStan\Rules\Classes\ClassConstantAttributesRule";i:19;s:39:"PHPStan\Rules\Classes\ClassConstantRule";i:20;s:46:"PHPStan\Rules\Classes\DuplicateDeclarationRule";i:21;s:36:"PHPStan\Rules\Classes\EnumSanityRule";i:22;s:58:"PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule";i:23;s:57:"PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule";i:24;s:59:"PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule";i:25;s:49:"PHPStan\Rules\Classes\ExistingClassInTraitUseRule";i:26;s:39:"PHPStan\Rules\Classes\InstantiationRule";i:27;s:47:"PHPStan\Rules\Classes\InstantiationCallableRule";i:28;s:51:"PHPStan\Rules\Classes\InvalidPromotedPropertiesRule";i:29;s:42:"PHPStan\Rules\Classes\LocalTypeAliasesRule";i:30;s:47:"PHPStan\Rules\Classes\LocalTypeTraitAliasesRule";i:31;s:35:"PHPStan\Rules\Classes\NewStaticRule";i:32;s:48:"PHPStan\Rules\Classes\NonClassAttributeClassRule";i:33;s:39:"PHPStan\Rules\Classes\ReadOnlyClassRule";i:34;s:45:"PHPStan\Rules\Classes\TraitAttributeClassRule";i:35;s:53:"PHPStan\Rules\Constants\DynamicClassConstantFetchRule";i:36;s:41:"PHPStan\Rules\Constants\FinalConstantRule";i:37;s:52:"PHPStan\Rules\Constants\NativeTypedClassConstantRule";i:38;s:46:"PHPStan\Rules\EnumCases\EnumCaseAttributesRule";i:39;s:46:"PHPStan\Rules\Exceptions\NoncapturingCatchRule";i:40;s:44:"PHPStan\Rules\Exceptions\ThrowExpressionRule";i:41;s:51:"PHPStan\Rules\Functions\ArrowFunctionAttributesRule";i:42;s:60:"PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule";i:43;s:45:"PHPStan\Rules\Functions\ClosureAttributesRule";i:44;s:44:"PHPStan\Rules\Functions\DefineParametersRule";i:45;s:67:"PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule";i:46;s:52:"PHPStan\Rules\Functions\CallToFunctionParametersRule";i:47;s:61:"PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule";i:48;s:54:"PHPStan\Rules\Functions\ExistingClassesInTypehintsRule";i:49;s:46:"PHPStan\Rules\Functions\FunctionAttributesRule";i:50;s:41:"PHPStan\Rules\Functions\InnerFunctionRule";i:51;s:63:"PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule";i:52;s:43:"PHPStan\Rules\Functions\ParamAttributesRule";i:53;s:44:"PHPStan\Rules\Functions\PrintfParametersRule";i:54;s:47:"PHPStan\Rules\Functions\RedefinedParametersRule";i:55;s:47:"PHPStan\Rules\Functions\ReturnNullsafeByRefRule";i:56;s:41:"PHPStan\Rules\Ignore\IgnoreParseErrorRule";i:57;s:57:"PHPStan\Rules\Functions\VariadicParametersDeclarationRule";i:58;s:46:"PHPStan\Rules\Keywords\ContinueBreakInLoopRule";i:59;s:45:"PHPStan\Rules\Keywords\DeclareStrictTypesRule";i:60;s:58:"PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule";i:61;s:47:"PHPStan\Rules\Methods\AbstractPrivateMethodRule";i:62;s:37:"PHPStan\Rules\Methods\CallMethodsRule";i:63;s:43:"PHPStan\Rules\Methods\CallStaticMethodsRule";i:64;s:47:"PHPStan\Rules\Methods\ConstructorReturnTypeRule";i:65;s:52:"PHPStan\Rules\Methods\ExistingClassesInTypehintsRule";i:66;s:44:"PHPStan\Rules\Methods\FinalPrivateMethodRule";i:67;s:40:"PHPStan\Rules\Methods\MethodCallableRule";i:68;s:53:"PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule";i:69;s:53:"PHPStan\Rules\Methods\MissingMethodImplementationRule";i:70;s:42:"PHPStan\Rules\Methods\MethodAttributesRule";i:71;s:46:"PHPStan\Rules\Methods\StaticMethodCallableRule";i:72;s:33:"PHPStan\Rules\Names\UsedNamesRule";i:73;s:44:"PHPStan\Rules\Operators\InvalidAssignVarRule";i:74;s:53:"PHPStan\Rules\Properties\AccessPropertiesInAssignRule";i:75;s:59:"PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule";i:76;s:56:"PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule";i:77;s:58:"PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule";i:78;s:50:"PHPStan\Rules\Properties\PropertiesInInterfaceRule";i:79;s:47:"PHPStan\Rules\Properties\PropertyAttributesRule";i:80;s:45:"PHPStan\Rules\Properties\ReadOnlyPropertyRule";i:81;s:50:"PHPStan\Rules\Traits\ConflictingTraitConstantsRule";i:82;s:42:"PHPStan\Rules\Traits\ConstantsInTraitsRule";i:83;s:43:"PHPStan\Rules\Types\InvalidTypesInUnionRule";i:84;s:33:"PHPStan\Rules\Variables\UnsetRule";i:85;s:43:"PHPStan\Rules\Whitespace\FileWhitespaceRule";i:86;s:53:"PHPStan\Rules\Classes\UnusedConstructorParametersRule";i:87;s:36:"PHPStan\Rules\Constants\ConstantRule";i:88;s:45:"PHPStan\Rules\Functions\UnusedClosureUsesRule";i:89;s:33:"PHPStan\Rules\Variables\EmptyRule";i:90;s:33:"PHPStan\Rules\Variables\IssetRule";i:91;s:40:"PHPStan\Rules\Variables\NullCoalesceRule";i:92;s:27:"PHPStan\Rules\Cast\EchoRule";i:93;s:34:"PHPStan\Rules\Cast\InvalidCastRule";i:94;s:50:"PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule";i:95;s:28:"PHPStan\Rules\Cast\PrintRule";i:96;s:60:"PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule";i:97;s:55:"PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule";i:98;s:56:"PHPStan\Rules\Constants\ValueAssignedToClassConstantRule";i:99;s:60:"PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule";i:100;s:41:"PHPStan\Rules\Generics\ClassAncestorsRule";i:101;s:44:"PHPStan\Rules\Generics\ClassTemplateTypeRule";i:102;s:40:"PHPStan\Rules\Generics\EnumAncestorsRule";i:103;s:43:"PHPStan\Rules\Generics\EnumTemplateTypeRule";i:104;s:47:"PHPStan\Rules\Generics\FunctionTemplateTypeRule";i:105;s:52:"PHPStan\Rules\Generics\FunctionSignatureVarianceRule";i:106;s:45:"PHPStan\Rules\Generics\InterfaceAncestorsRule";i:107;s:48:"PHPStan\Rules\Generics\InterfaceTemplateTypeRule";i:108;s:45:"PHPStan\Rules\Generics\MethodTemplateTypeRule";i:109;s:48:"PHPStan\Rules\Generics\MethodTagTemplateTypeRule";i:110;s:50:"PHPStan\Rules\Generics\MethodSignatureVarianceRule";i:111;s:44:"PHPStan\Rules\Generics\TraitTemplateTypeRule";i:112;s:37:"PHPStan\Rules\Generics\UsedTraitsRule";i:113;s:56:"PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule";i:114;s:58:"PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule";i:115;s:54:"PHPStan\Rules\Operators\InvalidComparisonOperationRule";i:116;s:54:"PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule";i:117;s:52:"PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule";i:118;s:39:"PHPStan\Rules\PhpDoc\FunctionAssertRule";i:119;s:37:"PHPStan\Rules\PhpDoc\MethodAssertRule";i:120;s:48:"PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule";i:121;s:60:"PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule";i:122;s:47:"PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule";i:123;s:55:"PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule";i:124;s:49:"PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule";i:125;s:68:"PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule";i:126;s:63:"PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule";i:127;s:43:"PHPStan\Rules\Classes\RequireImplementsRule";i:128;s:40:"PHPStan\Rules\Classes\RequireExtendsRule";i:129;s:57:"PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule";i:130;s:54:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule";i:131;s:54:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule";i:132;s:43:"PHPStan\Rules\Arrays\ArrayDestructuringRule";i:133;s:42:"PHPStan\Rules\Arrays\IterableInForeachRule";i:134;s:47:"PHPStan\Rules\Arrays\OffsetAccessAssignmentRule";i:135;s:45:"PHPStan\Rules\Arrays\OffsetAccessAssignOpRule";i:136;s:52:"PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule";i:137;s:46:"PHPStan\Rules\Arrays\UnpackIterableInArrayRule";i:138;s:42:"PHPStan\Rules\Exceptions\ThrowExprTypeRule";i:139;s:51:"PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule";i:140;s:45:"PHPStan\Rules\Functions\ClosureReturnTypeRule";i:141;s:38:"PHPStan\Rules\Functions\ReturnTypeRule";i:142;s:38:"PHPStan\Rules\Generators\YieldTypeRule";i:143;s:36:"PHPStan\Rules\Methods\ReturnTypeRule";i:144;s:66:"PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule";i:145;s:51:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule";i:146;s:54:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule";i:147;s:54:"PHPStan\Rules\Properties\TypesAssignedToPropertiesRule";i:148;s:37:"PHPStan\Rules\Variables\ThrowTypeRule";i:149;s:43:"PHPStan\Rules\Variables\VariableCloningRule";i:150;s:36:"PHPStan\Rules\Arrays\DeadForeachRule";i:151;s:47:"PHPStan\Rules\DeadCode\UnreachableStatementRule";i:152;s:48:"PHPStan\Rules\DeadCode\UnusedPrivateConstantRule";i:153;s:46:"PHPStan\Rules\DeadCode\UnusedPrivateMethodRule";i:154;s:58:"PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule";i:155;s:69:"PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule";i:156;s:65:"PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule";i:157;s:71:"PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule";i:158;s:44:"PHPStan\Rules\Methods\NullsafeMethodCallRule";i:159;s:69:"PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule";i:160;s:63:"PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule";i:161;s:64:"PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule";i:162;s:39:"PHPStan\Rules\DateTimeInstantiationRule";i:163;s:56:"PHPStan\Rules\Constants\MissingClassConstantTypehintRule";i:164;s:57:"PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule";i:165;s:53:"PHPStan\Rules\Methods\MissingMethodReturnTypehintRule";i:166;s:52:"PHPStan\Rules\Properties\MissingPropertyTypehintRule";i:167;s:24:"PhpParser\BuilderFactory";i:168;s:27:"PHPStan\Parser\LexerFactory";i:169;s:34:"PhpParser\NodeVisitor\NameResolver";i:170;s:29:"PhpParser\NodeVisitorAbstract";i:171;s:21:"PhpParser\NodeVisitor";i:172;s:36:"PHPStan\Parser\AnonymousClassVisitor";i:173;s:36:"PHPStan\Parser\ArrayFilterArgVisitor";i:174;s:33:"PHPStan\Parser\ArrayMapArgVisitor";i:175;s:34:"PHPStan\Parser\ArrayWalkArgVisitor";i:176;s:32:"PHPStan\Parser\ClosureArgVisitor";i:177;s:38:"PHPStan\Parser\ClosureBindToVarVisitor";i:178;s:36:"PHPStan\Parser\ClosureBindArgVisitor";i:179;s:35:"PHPStan\Parser\CurlSetOptArgVisitor";i:180;s:45:"PHPStan\Parser\TypeTraverserInstanceofVisitor";i:181;s:38:"PHPStan\Parser\ArrowFunctionArgVisitor";i:182;s:47:"PHPStan\Parser\MagicConstantParamDefaultVisitor";i:183;s:43:"PHPStan\Parser\NewAssignedToPropertyVisitor";i:184;s:37:"PHPStan\Parser\ParentStmtTypesVisitor";i:185;s:34:"PHPStan\Parser\TryCatchTypeVisitor";i:186;s:35:"PHPStan\Parser\LastConditionVisitor";i:187;s:43:"PhpParser\NodeVisitor\NodeConnectingVisitor";i:188;s:32:"PHPStan\Node\Printer\ExprPrinter";i:189;s:28:"PHPStan\Node\Printer\Printer";i:190;s:32:"PhpParser\PrettyPrinter\Standard";i:191;s:31:"PhpParser\PrettyPrinterAbstract";i:192;s:39:"PHPStan\Broker\AnonymousClassNameHelper";i:193;s:36:"PHPStan\Php\PhpVersionFactoryFactory";i:194;s:32:"PHPStan\PhpDocParser\Lexer\Lexer";i:195;s:38:"PHPStan\PhpDocParser\Parser\TypeParser";i:196;s:40:"PHPStan\PhpDocParser\Parser\PhpDocParser";i:197;s:37:"PHPStan\PhpDoc\ConstExprParserFactory";i:198;s:40:"PHPStan\PhpDoc\PhpDocInheritanceResolver";i:199;s:33:"PHPStan\PhpDoc\PhpDocNodeResolver";i:200;s:35:"PHPStan\PhpDoc\PhpDocStringResolver";i:201;s:36:"PHPStan\PhpDoc\ConstExprNodeResolver";i:202;s:31:"PHPStan\PhpDoc\TypeNodeResolver";i:203;s:33:"PHPStan\PhpDoc\TypeStringResolver";i:204;s:28:"PHPStan\PhpDoc\StubValidator";i:205;s:42:"PHPStan\PhpDoc\CountableStubFilesExtension";i:206;s:33:"PHPStan\PhpDoc\StubFilesExtension";i:207;s:45:"PHPStan\PhpDoc\SocketSelectStubFilesExtension";i:208;s:39:"PHPStan\PhpDoc\DefaultStubFilesProvider";i:209;s:32:"PHPStan\PhpDoc\StubFilesProvider";i:210;s:45:"PHPStan\PhpDoc\JsonValidateStubFilesExtension";i:211;s:47:"PHPStan\PhpDoc\ReflectionEnumStubFilesExtension";i:212;s:25:"PHPStan\Analyser\Analyser";i:213;s:40:"PHPStan\Analyser\AnalyserResultFinalizer";i:214;s:29:"PHPStan\Analyser\FileAnalyser";i:215;s:38:"PHPStan\Analyser\LocalIgnoresProcessor";i:216;s:37:"PHPStan\Analyser\RuleErrorTransformer";i:217;s:42:"PHPStan\Analyser\Ignore\IgnoredErrorHelper";i:218;s:35:"PHPStan\Analyser\Ignore\IgnoreLexer";i:219;s:41:"PHPStan\Analyser\LazyInternalScopeFactory";i:220;s:37:"PHPStan\Analyser\InternalScopeFactory";i:221;s:29:"PHPStan\Analyser\ScopeFactory";i:222;s:34:"PHPStan\Analyser\NodeScopeResolver";i:223;s:40:"PHPStan\Analyser\ConstantResolverFactory";i:224;s:47:"PHPStan\Analyser\ResultCache\ResultCacheClearer";i:225;s:19:"PHPStan\Cache\Cache";i:226;s:34:"PHPStan\Collectors\RegistryFactory";i:227;s:34:"PHPStan\Command\AnalyseApplication";i:228;s:30:"PHPStan\Command\AnalyserRunner";i:229;s:32:"PHPStan\Command\FixerApplication";i:230;s:37:"PHPStan\Dependency\DependencyResolver";i:231;s:38:"PHPStan\Dependency\ExportedNodeFetcher";i:232;s:39:"PHPStan\Dependency\ExportedNodeResolver";i:233;s:38:"PHPStan\Dependency\ExportedNodeVisitor";i:234;s:48:"PHPStan\DependencyInjection\Nette\NetteContainer";i:235;s:37:"PHPStan\DependencyInjection\Container";i:236;s:54:"PHPStan\DependencyInjection\DerivativeContainerFactory";i:237;s:23:"PHPStan\File\FileHelper";i:238;s:32:"PHPStan\File\FileExcluderFactory";i:239;s:23:"PHPStan\File\FileFinder";i:240;s:24:"PHPStan\File\FileMonitor";i:241;s:37:"PHPStan\Parser\DeclarePositionVisitor";i:242;s:33:"PHPStan\Parallel\ParallelAnalyser";i:243;s:26:"PHPStan\Parallel\Scheduler";i:244;s:34:"PHPStan\Diagnose\DiagnoseExtension";i:245;s:42:"PHPStan\Parser\FunctionCallStatementFinder";i:246;s:30:"PHPStan\Process\CpuCoreCounter";i:247;s:46:"PHPStan\Reflection\InitializerExprTypeResolver";i:248;s:73:"PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension";i:249;s:50:"PHPStan\Reflection\MethodsClassReflectionExtension";i:250;s:76:"PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension";i:251;s:53:"PHPStan\Reflection\PropertiesClassReflectionExtension";i:252;s:64:"PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor";i:253;s:66:"PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher";i:254;s:96:"PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker";i:255;s:88:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory";i:256;s:91:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository";i:257;s:92:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository";i:258;s:81:"PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension";i:259;s:84:"PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension";i:260;s:61:"PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension";i:261;s:64:"PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension";i:262;s:50:"PHPStan\Reflection\Php\PhpClassReflectionExtension";i:263;s:69:"PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension";i:264;s:66:"PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension";i:265;s:58:"PHPStan\Reflection\AllowedSubTypesClassReflectionExtension";i:266;s:68:"PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension";i:267;s:79:"PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension";i:268;s:45:"PHPStan\Type\DynamicMethodReturnTypeExtension";i:269;s:64:"PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider";i:270;s:50:"PHPStan\Reflection\SignatureMap\SignatureMapParser";i:271;s:60:"PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider";i:272;s:52:"PHPStan\Reflection\SignatureMap\SignatureMapProvider";i:273;s:56:"PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider";i:274;s:59:"PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory";i:275;s:31:"PHPStan\Rules\Api\ApiRuleHelper";i:276;s:29:"PHPStan\Rules\AttributesCheck";i:277;s:58:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck";i:278;s:28:"PHPStan\Rules\ClassNameCheck";i:279;s:39:"PHPStan\Rules\ClassCaseSensitivityCheck";i:280;s:37:"PHPStan\Rules\ClassForbiddenNameCheck";i:281;s:43:"PHPStan\Rules\Classes\LocalTypeAliasesCheck";i:282;s:36:"PHPStan\Rules\Classes\MethodTagCheck";i:283;s:38:"PHPStan\Rules\Classes\PropertyTagCheck";i:284;s:52:"PHPStan\Rules\Comparison\ConstantConditionRuleHelper";i:285;s:50:"PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper";i:286;s:53:"PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver";i:287;s:46:"PHPStan\Rules\Exceptions\ExceptionTypeResolver";i:288;s:68:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule";i:289;s:66:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule";i:290;s:61:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck";i:291;s:53:"PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule";i:292;s:51:"PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule";i:293;s:46:"PHPStan\Rules\Exceptions\TooWideThrowTypeCheck";i:294;s:41:"PHPStan\Rules\FunctionCallParametersCheck";i:295;s:37:"PHPStan\Rules\FunctionDefinitionCheck";i:296;s:37:"PHPStan\Rules\FunctionReturnTypeCheck";i:297;s:44:"PHPStan\Rules\ParameterCastableToStringCheck";i:298;s:49:"PHPStan\Rules\Generics\CrossCheckInterfacesHelper";i:299;s:44:"PHPStan\Rules\Generics\GenericAncestorsCheck";i:300;s:45:"PHPStan\Rules\Generics\GenericObjectTypeCheck";i:301;s:40:"PHPStan\Rules\Generics\TemplateTypeCheck";i:302;s:36:"PHPStan\Rules\Generics\VarianceCheck";i:303;s:24:"PHPStan\Rules\IssetCheck";i:304;s:37:"PHPStan\Rules\Methods\MethodCallCheck";i:305;s:43:"PHPStan\Rules\Methods\StaticMethodCallCheck";i:306;s:41:"PHPStan\Rules\Methods\MethodSignatureRule";i:307;s:53:"PHPStan\Rules\Methods\MethodParameterComparisonHelper";i:308;s:34:"PHPStan\Rules\MissingTypehintCheck";i:309;s:27:"PHPStan\Rules\NullsafeCheck";i:310;s:69:"PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider";i:311;s:65:"PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtensionProvider";i:312;s:59:"PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider";i:313;s:55:"PHPStan\Rules\Methods\AlwaysUsedMethodExtensionProvider";i:314;s:52:"PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper";i:315;s:37:"PHPStan\Rules\PhpDoc\AssertRuleHelper";i:316;s:43:"PHPStan\Rules\PhpDoc\UnresolvableTypeHelper";i:317;s:46:"PHPStan\Rules\PhpDoc\GenericCallableRuleHelper";i:318;s:41:"PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper";i:319;s:40:"PHPStan\Rules\Playground\NeverRuleHelper";i:320;s:65:"PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider";i:321;s:61:"PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider";i:322;s:43:"PHPStan\Rules\Properties\PropertyDescriptor";i:323;s:49:"PHPStan\Rules\Properties\PropertyReflectionFinder";i:324;s:38:"PHPStan\Rules\Pure\FunctionPurityCheck";i:325;s:29:"PHPStan\Rules\RuleLevelHelper";i:326;s:43:"PHPStan\Rules\UnusedFunctionParametersCheck";i:327;s:59:"PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck";i:328;s:27:"PHPStan\Type\FileTypeMapper";i:329;s:30:"PHPStan\Type\BitwiseFlagHelper";i:330;s:54:"PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension";i:331;s:47:"PHPStan\Type\DynamicFunctionReturnTypeExtension";i:332;s:57:"PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension";i:333;s:61:"PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension";i:334;s:54:"PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension";i:335;s:55:"PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension";i:336;s:56:"PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension";i:337;s:55:"PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension";i:338;s:53:"PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension";i:339;s:57:"PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension";i:340;s:65:"PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension";i:341;s:53:"PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension";i:342;s:51:"PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension";i:343;s:62:"PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension";i:344;s:44:"PHPStan\Type\FunctionTypeSpecifyingExtension";i:345;s:44:"PHPStan\Analyser\TypeSpecifierAwareExtension";i:346;s:56:"PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension";i:347;s:55:"PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension";i:348;s:60:"PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension";i:349;s:52:"PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension";i:350;s:61:"PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension";i:351;s:52:"PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension";i:352;s:52:"PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension";i:353;s:53:"PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension";i:354;s:55:"PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension";i:355;s:56:"PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension";i:356;s:56:"PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension";i:357;s:54:"PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension";i:358;s:54:"PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension";i:359;s:55:"PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension";i:360;s:62:"PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension";i:361;s:59:"PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension";i:362;s:62:"PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension";i:363;s:59:"PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension";i:364;s:41:"PHPStan\Type\Php\AssertThrowTypeExtension";i:365;s:46:"PHPStan\Type\DynamicFunctionThrowTypeExtension";i:366;s:63:"PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension";i:367;s:51:"PHPStan\Type\DynamicStaticMethodReturnTypeExtension";i:368;s:63:"PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension";i:369;s:54:"PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension";i:370;s:54:"PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension";i:371;s:56:"PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension";i:372;s:62:"PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension";i:373;s:51:"PHPStan\Type\Php\CompactFunctionReturnTypeExtension";i:374;s:52:"PHPStan\Type\Php\ConstantFunctionReturnTypeExtension";i:375;s:31:"PHPStan\Type\Php\ConstantHelper";i:376;s:49:"PHPStan\Type\Php\CountFunctionReturnTypeExtension";i:377;s:53:"PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension";i:378;s:62:"PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension";i:379;s:44:"PHPStan\Type\Php\CurlInitReturnTypeExtension";i:380;s:45:"PHPStan\Type\Php\DateFunctionReturnTypeHelper";i:381;s:54:"PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension";i:382;s:52:"PHPStan\Type\Php\DateFormatMethodReturnTypeExtension";i:383;s:48:"PHPStan\Type\Php\DateFunctionReturnTypeExtension";i:384;s:58:"PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension";i:385;s:50:"PHPStan\Type\DynamicStaticMethodThrowTypeExtension";i:386;s:55:"PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension";i:387;s:57:"PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension";i:388;s:51:"PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension";i:389;s:50:"PHPStan\Type\Php\DateTimeModifyReturnTypeExtension";i:390;s:54:"PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension";i:391;s:55:"PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension";i:392;s:44:"PHPStan\Type\DynamicMethodThrowTypeExtension";i:393;s:58:"PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension";i:394;s:48:"PHPStan\Type\Php\DsMapDynamicReturnTypeExtension";i:395;s:53:"PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension";i:396;s:58:"PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension";i:397;s:58:"PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension";i:398;s:47:"PHPStan\Type\Php\FilterFunctionReturnTypeHelper";i:399;s:54:"PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension";i:400;s:52:"PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension";i:401;s:57:"PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension";i:402;s:57:"PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension";i:403;s:51:"PHPStan\Type\Php\GetClassDynamicReturnTypeExtension";i:404;s:56:"PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension";i:405;s:65:"PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension";i:406;s:51:"PHPStan\Type\Php\GettypeFunctionReturnTypeExtension";i:407;s:63:"PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension";i:408;s:49:"PHPStan\Type\Php\HashFunctionsReturnTypeExtension";i:409;s:58:"PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension";i:410;s:41:"PHPStan\Type\Php\IntdivThrowTypeExtension";i:411;s:42:"PHPStan\Type\Php\IniGetReturnTypeExtension";i:412;s:39:"PHPStan\Type\Php\JsonThrowTypeExtension";i:413;s:49:"PHPStan\Type\Php\PregMatchTypeSpecifyingExtension";i:414;s:51:"PHPStan\Type\Php\PregMatchParameterOutTypeExtension";i:415;s:46:"PHPStan\Type\FunctionParameterOutTypeExtension";i:416;s:56:"PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension";i:417;s:50:"PHPStan\Type\FunctionParameterClosureTypeExtension";i:418;s:39:"PHPStan\Type\Php\RegexArrayShapeMatcher";i:419;s:35:"PHPStan\Type\Regex\RegexGroupParser";i:420;s:40:"PHPStan\Type\Regex\RegexExpressionHelper";i:421;s:61:"PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension";i:422;s:64:"PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension";i:423;s:62:"PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension";i:424;s:64:"PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension";i:425;s:53:"PHPStan\Type\Php\StrContainingTypeSpecifyingExtension";i:426;s:65:"PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension";i:427;s:62:"PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension";i:428;s:47:"PHPStan\Type\Php\StatDynamicReturnTypeExtension";i:429;s:52:"PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension";i:430;s:54:"PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension";i:431;s:50:"PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension";i:432;s:63:"PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension";i:433;s:59:"PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension";i:434;s:54:"PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension";i:435;s:52:"PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension";i:436;s:67:"PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension";i:437;s:42:"PHPStan\Type\MethodTypeSpecifyingExtension";i:438;s:59:"PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension";i:439;s:64:"PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension";i:440;s:49:"PHPStan\Type\Php\LtrimFunctionReturnTypeExtension";i:441;s:47:"PHPStan\Type\Php\MbFunctionsReturnTypeExtension";i:442;s:52:"PHPStan\Type\Php\MbFunctionsReturnTypeExtensionTrait";i:443;s:61:"PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension";i:444;s:64:"PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension";i:445;s:52:"PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension";i:446;s:53:"PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension";i:447;s:50:"PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension";i:448;s:51:"PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension";i:449;s:59:"PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension";i:450;s:55:"PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension";i:451;s:52:"PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension";i:452;s:50:"PHPStan\Type\Php\StrlenFunctionReturnTypeExtension";i:453;s:65:"PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension";i:454;s:50:"PHPStan\Type\Php\StrPadFunctionReturnTypeExtension";i:455;s:53:"PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension";i:456;s:49:"PHPStan\Type\Php\SubstrDynamicReturnTypeExtension";i:457;s:45:"PHPStan\Type\Php\ThrowableReturnTypeExtension";i:458;s:59:"PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension";i:459;s:55:"PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension";i:460;s:65:"PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension";i:461;s:47:"PHPStan\Type\Php\PowFunctionReturnTypeExtension";i:462;s:49:"PHPStan\Type\Php\RoundFunctionReturnTypeExtension";i:463;s:53:"PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension";i:464;s:53:"PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension";i:465;s:49:"PHPStan\Type\Php\RangeFunctionReturnTypeExtension";i:466;s:54:"PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension";i:467;s:59:"PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension";i:468;s:59:"PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension";i:469;s:54:"PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension";i:470;s:55:"PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension";i:471;s:62:"PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension";i:472;s:55:"PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension";i:473;s:55:"PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension";i:474;s:58:"PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension";i:475;s:58:"PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension";i:476;s:60:"PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension";i:477;s:59:"PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension";i:478;s:51:"PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension";i:479;s:48:"PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper";i:480;s:58:"PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension";i:481;s:59:"PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension";i:482;s:66:"PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension";i:483;s:63:"PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension";i:484;s:63:"PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension";i:485;s:52:"PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension";i:486;s:50:"PHPStan\Type\Php\StrTokFunctionReturnTypeExtension";i:487;s:58:"PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension";i:488;s:57:"PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension";i:489;s:56:"PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension";i:490;s:63:"PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension";i:491;s:49:"PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension";i:492;s:65:"PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension";i:493;s:57:"PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension";i:494;s:31:"PHPStan\Type\ClosureTypeFactory";i:495;s:43:"PHPStan\Type\Constant\OversizedArrayBuilder";i:496;s:36:"PHPStan\Rules\Functions\PrintfHelper";i:497;s:37:"PHPStan\Analyser\TypeSpecifierFactory";i:498;s:46:"PHPStan\File\ParentDirectoryRelativePathHelper";i:499;s:31:"PHPStan\File\RelativePathHelper";i:500;s:28:"PHPStan\Broker\BrokerFactory";i:501;s:30:"PHPStan\Cache\FileCacheStorage";i:502;s:26:"PHPStan\Cache\CacheStorage";i:503;s:25:"PHPStan\Parser\RichParser";i:504;s:21:"PHPStan\Parser\Parser";i:505;s:29:"PHPStan\Parser\CleaningParser";i:506;s:27:"PHPStan\Parser\SimpleParser";i:507;s:27:"PHPStan\Parser\CachedParser";i:508;s:33:"PHPStan\Parser\PhpParserDecorator";i:509;s:16:"PhpParser\Parser";i:510;s:21:"PhpParser\Parser\Php7";i:511;s:24:"PhpParser\ParserAbstract";i:512;s:26:"PHPStan\Rules\LazyRegistry";i:513;s:22:"PHPStan\Rules\Registry";i:514;s:33:"PHPStan\PhpDoc\StubPhpDocProvider";i:515;s:63:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory";i:516;s:37:"PHPStan\Reflection\ReflectionProvider";i:517;s:51:"PHPStan\BetterReflection\Reflector\DefaultReflector";i:518;s:44:"PHPStan\BetterReflection\Reflector\Reflector";i:519;s:64:"PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector";i:520;s:49:"PHPStan\BetterReflection\Reflector\ClassReflector";i:521;s:52:"PHPStan\BetterReflection\Reflector\FunctionReflector";i:522;s:52:"PHPStan\BetterReflection\Reflector\ConstantReflector";i:523;s:60:"PHPStan\Reflection\BetterReflection\BetterReflectionProvider";i:524;s:72:"PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory";i:525;s:83:"PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory";i:526;s:79:"PHPStan\BetterReflection\SourceLocator\SourceStubber\PhpStormStubsSourceStubber";i:527;s:66:"PHPStan\BetterReflection\SourceLocator\SourceStubber\SourceStubber";i:528;s:76:"PHPStan\BetterReflection\SourceLocator\SourceStubber\ReflectionSourceStubber";i:529;s:80:"PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory";i:530;s:32:"PHPStan\Parser\PathRoutingParser";i:531;s:41:"PHPStan\Diagnose\PHPStanDiagnoseExtension";i:532;s:55:"PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter";i:533;s:45:"PHPStan\Command\ErrorFormatter\ErrorFormatter";i:534;s:48:"PHPStan\Command\ErrorFormatter\RawErrorFormatter";i:535;s:50:"PHPStan\Command\ErrorFormatter\TableErrorFormatter";i:536;s:55:"PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter";i:537;s:49:"PHPStan\Command\ErrorFormatter\JsonErrorFormatter";i:538;s:50:"PHPStan\Command\ErrorFormatter\JunitErrorFormatter";i:539;s:51:"PHPStan\Command\ErrorFormatter\GitlabErrorFormatter";i:540;s:51:"PHPStan\Command\ErrorFormatter\GithubErrorFormatter";i:541;s:53:"PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter";i:542;s:40:"PHPStan\Rules\Api\ApiClassConstFetchRule";i:543;s:35:"PHPStan\Rules\Api\ApiInstanceofRule";i:544;s:39:"PHPStan\Rules\Api\ApiInstanceofTypeRule";i:545;s:53:"PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule";i:546;s:47:"PHPStan\Rules\Api\RuntimeReflectionFunctionRule";i:547;s:52:"PHPStan\Rules\Api\RuntimeReflectionInstantiationRule";i:548;s:53:"PHPStan\Rules\Classes\ExistingClassInClassExtendsRule";i:549;s:51:"PHPStan\Rules\Classes\ExistingClassInInstanceOfRule";i:550;s:53:"PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule";i:551;s:53:"PHPStan\Rules\Functions\CallToNonExistentFunctionRule";i:552;s:46:"PHPStan\Rules\Constants\OverridingConstantRule";i:553;s:42:"PHPStan\Rules\Methods\OverridingMethodRule";i:554;s:47:"PHPStan\Rules\Methods\ConsistentConstructorRule";i:555;s:39:"PHPStan\Rules\Missing\MissingReturnRule";i:556;s:52:"PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule";i:557;s:47:"PHPStan\Rules\Namespaces\ExistingNamesInUseRule";i:558;s:50:"PHPStan\Rules\Operators\InvalidIncDecOperationRule";i:559;s:45:"PHPStan\Rules\Properties\AccessPropertiesRule";i:560;s:51:"PHPStan\Rules\Properties\AccessStaticPropertiesRule";i:561;s:56:"PHPStan\Rules\Properties\ExistingClassesInPropertiesRule";i:562;s:44:"PHPStan\Rules\Functions\FunctionCallableRule";i:563;s:66:"PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule";i:564;s:47:"PHPStan\Rules\Properties\OverridingPropertyRule";i:565;s:53:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule";i:566;s:50:"PHPStan\Rules\Properties\UninitializedPropertyRule";i:567;s:56:"PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule";i:568;s:55:"PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule";i:569;s:44:"PHPStan\Rules\Variables\CompactVariablesRule";i:570;s:43:"PHPStan\Rules\Variables\DefinedVariableRule";i:571;s:49:"PHPStan\Rules\Regexp\RegularExpressionPatternRule";i:572;s:37:"PHPStan\Reflection\ConstructorsHelper";i:573;s:58:"PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule";i:574;s:48:"PHPStan\Rules\Constants\MagicConstantContextRule";i:575;s:54:"PHPStan\Rules\Functions\UselessFunctionReturnValueRule";i:576;s:49:"PHPStan\Rules\Functions\PrintfArrayParametersRule";i:577;s:49:"PHPStan\Rules\Regexp\RegularExpressionQuotingRule";i:578;s:31:"PHPStan\Rules\Classes\MixinRule";i:579;s:35:"PHPStan\Rules\Classes\MethodTagRule";i:580;s:40:"PHPStan\Rules\Classes\MethodTagTraitRule";i:581;s:37:"PHPStan\Rules\Classes\PropertyTagRule";i:582;s:42:"PHPStan\Rules\Classes\PropertyTagTraitRule";i:583;s:40:"PHPStan\Rules\PhpDoc\RequireExtendsCheck";i:584;s:57:"PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule";i:585;s:73:"PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule";i:586;s:67:"PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule";i:587;s:41:"PHPStan\Rules\Functions\CallCallablesRule";i:588;s:54:"PHPStan\Rules\Methods\IllegalConstructorMethodCallRule";i:589;s:54:"PHPStan\Rules\Methods\IllegalConstructorStaticCallRule";i:590;s:46:"PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule";i:591;s:48:"PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule";i:592;s:45:"PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule";i:593;s:52:"PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule";i:594;s:50:"PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule";i:595;s:43:"PHPStan\Rules\Generics\PropertyVarianceRule";i:596;s:35:"PHPStan\Rules\Pure\PureFunctionRule";i:597;s:33:"PHPStan\Rules\Pure\PureMethodRule";i:598;s:50:"PHPStan\Rules\Operators\InvalidBinaryOperationRule";i:599;s:49:"PHPStan\Rules\Operators\InvalidUnaryOperationRule";i:600;s:50:"PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule";i:601;s:46:"PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule";i:602;s:57:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule";i:603;s:69:"PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule";i:604;s:67:"PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule";i:605;s:42:"PHPStan\Rules\Generators\YieldFromTypeRule";i:606;s:45:"PHPStan\Rules\Generators\YieldInGeneratorRule";i:607;s:39:"PHPStan\Rules\Arrays\ArrayUnpackingRule";i:608;s:62:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule";i:609;s:59:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule";i:610;s:52:"PHPStan\Rules\Variables\ParameterOutAssignedTypeRule";i:611;s:56:"PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule";i:612;s:46:"PHPStan\Rules\Classes\ImpossibleInstanceOfRule";i:613;s:56:"PHPStan\Rules\Comparison\BooleanAndConstantConditionRule";i:614;s:55:"PHPStan\Rules\Comparison\BooleanOrConstantConditionRule";i:615;s:56:"PHPStan\Rules\Comparison\BooleanNotConstantConditionRule";i:616;s:31:"PHPStan\Rules\DeadCode\NoopRule";i:617;s:72:"PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule";i:618;s:62:"PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector";i:619;s:28:"PHPStan\Collectors\Collector";i:620;s:47:"PHPStan\Rules\DeadCode\PossiblyPureNewCollector";i:621;s:69:"PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule";i:622;s:59:"PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector";i:623;s:52:"PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector";i:624;s:67:"PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule";i:625;s:57:"PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector";i:626;s:54:"PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector";i:627;s:73:"PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule";i:628;s:54:"PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector";i:629;s:48:"PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule";i:630;s:57:"PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule";i:631;s:52:"PHPStan\Rules\Comparison\ElseIfConstantConditionRule";i:632;s:48:"PHPStan\Rules\Comparison\IfConstantConditionRule";i:633;s:60:"PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule";i:634;s:58:"PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule";i:635;s:64:"PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule";i:636;s:56:"PHPStan\Rules\Comparison\LogicalXorConstantConditionRule";i:637;s:37:"PHPStan\Rules\DeadCode\BetterNoopRule";i:638;s:44:"PHPStan\Rules\Comparison\MatchExpressionRule";i:639;s:71:"PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule";i:640;s:61:"PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule";i:641;s:52:"PHPStan\Rules\Comparison\ConstantLooseComparisonRule";i:642;s:61:"PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule";i:643;s:50:"PHPStan\Rules\Comparison\UnreachableIfBranchesRule";i:644;s:57:"PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule";i:645;s:58:"PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule";i:646;s:57:"PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule";i:647;s:70:"PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule";i:648;s:62:"PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule";i:649;s:50:"PHPStan\Rules\Properties\NullsafePropertyFetchRule";i:650;s:46:"PHPStan\Rules\Traits\TraitDeclarationCollector";i:651;s:38:"PHPStan\Rules\Traits\TraitUseCollector";i:652;s:41:"PHPStan\Rules\Traits\NotAnalysedTraitRule";i:653;s:55:"PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule";i:654;s:66:"PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule";i:655;s:64:"PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule";i:656;s:54:"PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule";i:657;s:47:"PHPStan\Rules\Functions\RandomIntParametersRule";i:658;s:39:"PHPStan\Rules\Functions\ArrayFilterRule";i:659;s:39:"PHPStan\Rules\Functions\ArrayValuesRule";i:660;s:40:"PHPStan\Rules\Functions\CallUserFuncRule";i:661;s:43:"PHPStan\Rules\Functions\ImplodeFunctionRule";i:662;s:53:"PHPStan\Rules\Functions\ParameterCastableToStringRule";i:663;s:60:"PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule";i:664;s:57:"PHPStan\Rules\Functions\SortParameterCastableToStringRule";i:665;s:60:"PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule";i:666;s:56:"PHPStan\Rules\Methods\MissingMethodParameterTypehintRule";i:667;s:50:"PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule";i:668;s:37:"_PHPStan_4f7beffdf\Nette\DI\Container";i:669;s:36:"_PHPStan_4f7beffdf\Nette\SmartObject";i:670;s:22:"PHPStan\Php\PhpVersion";i:671;s:29:"PHPStan\Php\PhpVersionFactory";i:672;s:43:"PHPStan\PhpDocParser\Parser\ConstExprParser";i:673;s:56:"PHPStan\PhpDoc\TypeNodeResolverExtensionRegistryProvider";i:674;s:33:"PHPStan\Analyser\ConstantResolver";i:675;s:47:"PHPStan\Analyser\ResultCache\ResultCacheManager";i:676;s:54:"PHPStan\Analyser\ResultCache\ResultCacheManagerFactory";i:677;s:27:"PHPStan\Collectors\Registry";i:678;s:79:"PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider";i:679;s:75:"PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider";i:680;s:66:"PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider";i:681;s:80:"PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider";i:682;s:80:"PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider";i:683;s:66:"PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider";i:684;s:70:"PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider";i:685;s:25:"PHPStan\File\FileExcluder";i:686;s:35:"PHPStan\File\FileExcluderRawFactory";i:687;s:44:"PHPStan\Reflection\Php\PhpFunctionReflection";i:688;s:37:"PHPStan\Reflection\FunctionReflection";i:689;s:44:"PHPStan\Reflection\FunctionReflectionFactory";i:690;s:79:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator";i:691;s:57:"PHPStan\BetterReflection\SourceLocator\Type\SourceLocator";i:692;s:86:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory";i:693;s:82:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator";i:694;s:89:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory";i:695;s:42:"PHPStan\Reflection\Php\PhpMethodReflection";i:696;s:43:"PHPStan\Reflection\ExtendedMethodReflection";i:697;s:40:"PHPStan\Reflection\ClassMemberReflection";i:698;s:35:"PHPStan\Reflection\MethodReflection";i:699;s:49:"PHPStan\Reflection\Php\PhpMethodReflectionFactory";i:700;s:64:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider";i:701;s:30:"PHPStan\Type\TypeAliasResolver";i:702;s:38:"PHPStan\Type\TypeAliasResolverProvider";i:703;s:30:"PHPStan\Analyser\TypeSpecifier";i:704;s:21:"PHPStan\Broker\Broker";i:705;s:15:"PhpParser\Lexer";i:706;s:67:"PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory";i:707;s:25:"PhpParser\Lexer\Emulative";}i:4;a:462:{i:0;s:71:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory::create";i:1;s:91:"PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory::create";i:2;s:88:"PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory::create";i:3;s:45:"PHPStan\Rules\Debug\DumpTypeRule::__construct";i:4;s:47:"PHPStan\Rules\Debug\FileAssertRule::__construct";i:5;s:51:"PHPStan\Rules\Api\ApiInstantiationRule::__construct";i:6;s:50:"PHPStan\Rules\Api\ApiClassExtendsRule::__construct";i:7;s:53:"PHPStan\Rules\Api\ApiClassImplementsRule::__construct";i:8;s:54:"PHPStan\Rules\Api\ApiInterfaceExtendsRule::__construct";i:9;s:48:"PHPStan\Rules\Api\ApiMethodCallRule::__construct";i:10;s:48:"PHPStan\Rules\Api\ApiStaticCallRule::__construct";i:11;s:46:"PHPStan\Rules\Api\ApiTraitUseRule::__construct";i:12;s:50:"PHPStan\Rules\Api\GetTemplateTypeRule::__construct";i:13;s:68:"PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule::__construct";i:14;s:66:"PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule::__construct";i:15;s:45:"PHPStan\Rules\Cast\UnsetCastRule::__construct";i:16;s:54:"PHPStan\Rules\Classes\ClassAttributesRule::__construct";i:17;s:62:"PHPStan\Rules\Classes\ClassConstantAttributesRule::__construct";i:18;s:52:"PHPStan\Rules\Classes\ClassConstantRule::__construct";i:19;s:71:"PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule::__construct";i:20;s:70:"PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule::__construct";i:21;s:72:"PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule::__construct";i:22;s:62:"PHPStan\Rules\Classes\ExistingClassInTraitUseRule::__construct";i:23;s:52:"PHPStan\Rules\Classes\InstantiationRule::__construct";i:24;s:64:"PHPStan\Rules\Classes\InvalidPromotedPropertiesRule::__construct";i:25;s:55:"PHPStan\Rules\Classes\LocalTypeAliasesRule::__construct";i:26;s:60:"PHPStan\Rules\Classes\LocalTypeTraitAliasesRule::__construct";i:27;s:52:"PHPStan\Rules\Classes\ReadOnlyClassRule::__construct";i:28;s:66:"PHPStan\Rules\Constants\DynamicClassConstantFetchRule::__construct";i:29;s:54:"PHPStan\Rules\Constants\FinalConstantRule::__construct";i:30;s:65:"PHPStan\Rules\Constants\NativeTypedClassConstantRule::__construct";i:31;s:59:"PHPStan\Rules\EnumCases\EnumCaseAttributesRule::__construct";i:32;s:59:"PHPStan\Rules\Exceptions\NoncapturingCatchRule::__construct";i:33;s:57:"PHPStan\Rules\Exceptions\ThrowExpressionRule::__construct";i:34;s:64:"PHPStan\Rules\Functions\ArrowFunctionAttributesRule::__construct";i:35;s:73:"PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule::__construct";i:36;s:58:"PHPStan\Rules\Functions\ClosureAttributesRule::__construct";i:37;s:57:"PHPStan\Rules\Functions\DefineParametersRule::__construct";i:38;s:80:"PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule::__construct";i:39;s:65:"PHPStan\Rules\Functions\CallToFunctionParametersRule::__construct";i:40;s:74:"PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule::__construct";i:41;s:67:"PHPStan\Rules\Functions\ExistingClassesInTypehintsRule::__construct";i:42;s:59:"PHPStan\Rules\Functions\FunctionAttributesRule::__construct";i:43;s:56:"PHPStan\Rules\Functions\ParamAttributesRule::__construct";i:44;s:57:"PHPStan\Rules\Functions\PrintfParametersRule::__construct";i:45;s:60:"PHPStan\Rules\Functions\ReturnNullsafeByRefRule::__construct";i:46;s:58:"PHPStan\Rules\Keywords\DeclareStrictTypesRule::__construct";i:47;s:50:"PHPStan\Rules\Methods\CallMethodsRule::__construct";i:48;s:56:"PHPStan\Rules\Methods\CallStaticMethodsRule::__construct";i:49;s:65:"PHPStan\Rules\Methods\ExistingClassesInTypehintsRule::__construct";i:50;s:57:"PHPStan\Rules\Methods\FinalPrivateMethodRule::__construct";i:51;s:53:"PHPStan\Rules\Methods\MethodCallableRule::__construct";i:52;s:55:"PHPStan\Rules\Methods\MethodAttributesRule::__construct";i:53;s:59:"PHPStan\Rules\Methods\StaticMethodCallableRule::__construct";i:54;s:57:"PHPStan\Rules\Operators\InvalidAssignVarRule::__construct";i:55;s:66:"PHPStan\Rules\Properties\AccessPropertiesInAssignRule::__construct";i:56;s:72:"PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule::__construct";i:57;s:71:"PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule::__construct";i:58;s:60:"PHPStan\Rules\Properties\PropertyAttributesRule::__construct";i:59;s:58:"PHPStan\Rules\Properties\ReadOnlyPropertyRule::__construct";i:60;s:63:"PHPStan\Rules\Traits\ConflictingTraitConstantsRule::__construct";i:61;s:55:"PHPStan\Rules\Traits\ConstantsInTraitsRule::__construct";i:62;s:66:"PHPStan\Rules\Classes\UnusedConstructorParametersRule::__construct";i:63;s:58:"PHPStan\Rules\Functions\UnusedClosureUsesRule::__construct";i:64;s:46:"PHPStan\Rules\Variables\EmptyRule::__construct";i:65;s:46:"PHPStan\Rules\Variables\IssetRule::__construct";i:66;s:53:"PHPStan\Rules\Variables\NullCoalesceRule::__construct";i:67;s:40:"PHPStan\Rules\Cast\EchoRule::__construct";i:68;s:47:"PHPStan\Rules\Cast\InvalidCastRule::__construct";i:69;s:63:"PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule::__construct";i:70;s:41:"PHPStan\Rules\Cast\PrintRule::__construct";i:71;s:54:"PHPStan\Rules\Generics\ClassAncestorsRule::__construct";i:72;s:57:"PHPStan\Rules\Generics\ClassTemplateTypeRule::__construct";i:73;s:53:"PHPStan\Rules\Generics\EnumAncestorsRule::__construct";i:74;s:60:"PHPStan\Rules\Generics\FunctionTemplateTypeRule::__construct";i:75;s:65:"PHPStan\Rules\Generics\FunctionSignatureVarianceRule::__construct";i:76;s:58:"PHPStan\Rules\Generics\InterfaceAncestorsRule::__construct";i:77;s:61:"PHPStan\Rules\Generics\InterfaceTemplateTypeRule::__construct";i:78;s:58:"PHPStan\Rules\Generics\MethodTemplateTypeRule::__construct";i:79;s:61:"PHPStan\Rules\Generics\MethodTagTemplateTypeRule::__construct";i:80;s:63:"PHPStan\Rules\Generics\MethodSignatureVarianceRule::__construct";i:81;s:57:"PHPStan\Rules\Generics\TraitTemplateTypeRule::__construct";i:82;s:50:"PHPStan\Rules\Generics\UsedTraitsRule::__construct";i:83;s:67:"PHPStan\Rules\Operators\InvalidComparisonOperationRule::__construct";i:84;s:67:"PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule::__construct";i:85;s:65:"PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule::__construct";i:86;s:52:"PHPStan\Rules\PhpDoc\FunctionAssertRule::__construct";i:87;s:50:"PHPStan\Rules\PhpDoc\MethodAssertRule::__construct";i:88;s:61:"PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule::__construct";i:89;s:73:"PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule::__construct";i:90;s:60:"PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule::__construct";i:91;s:68:"PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule::__construct";i:92;s:62:"PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule::__construct";i:93;s:81:"PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule::__construct";i:94;s:67:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule::__construct";i:95;s:67:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule::__construct";i:96;s:56:"PHPStan\Rules\Arrays\ArrayDestructuringRule::__construct";i:97;s:55:"PHPStan\Rules\Arrays\IterableInForeachRule::__construct";i:98;s:60:"PHPStan\Rules\Arrays\OffsetAccessAssignmentRule::__construct";i:99;s:58:"PHPStan\Rules\Arrays\OffsetAccessAssignOpRule::__construct";i:100;s:65:"PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule::__construct";i:101;s:59:"PHPStan\Rules\Arrays\UnpackIterableInArrayRule::__construct";i:102;s:55:"PHPStan\Rules\Exceptions\ThrowExprTypeRule::__construct";i:103;s:64:"PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule::__construct";i:104;s:58:"PHPStan\Rules\Functions\ClosureReturnTypeRule::__construct";i:105;s:51:"PHPStan\Rules\Functions\ReturnTypeRule::__construct";i:106;s:51:"PHPStan\Rules\Generators\YieldTypeRule::__construct";i:107;s:49:"PHPStan\Rules\Methods\ReturnTypeRule::__construct";i:108;s:79:"PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule::__construct";i:109;s:64:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule::__construct";i:110;s:67:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule::__construct";i:111;s:67:"PHPStan\Rules\Properties\TypesAssignedToPropertiesRule::__construct";i:112;s:50:"PHPStan\Rules\Variables\ThrowTypeRule::__construct";i:113;s:56:"PHPStan\Rules\Variables\VariableCloningRule::__construct";i:114;s:61:"PHPStan\Rules\DeadCode\UnusedPrivateConstantRule::__construct";i:115;s:59:"PHPStan\Rules\DeadCode\UnusedPrivateMethodRule::__construct";i:116;s:82:"PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule::__construct";i:117;s:78:"PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule::__construct";i:118;s:84:"PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule::__construct";i:119;s:69:"PHPStan\Rules\Constants\MissingClassConstantTypehintRule::__construct";i:120;s:70:"PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule::__construct";i:121;s:66:"PHPStan\Rules\Methods\MissingMethodReturnTypehintRule::__construct";i:122;s:65:"PHPStan\Rules\Properties\MissingPropertyTypehintRule::__construct";i:123;s:40:"PHPStan\Parser\LexerFactory::__construct";i:124;s:47:"PhpParser\NodeVisitor\NameResolver::__construct";i:125;s:45:"PHPStan\Node\Printer\ExprPrinter::__construct";i:126;s:41:"PHPStan\Node\Printer\Printer::__construct";i:127;s:52:"PHPStan\Broker\AnonymousClassNameHelper::__construct";i:128;s:37:"PHPStan\Php\PhpVersionFactory::create";i:129;s:44:"PHPStan\Php\PhpVersionFactoryFactory::create";i:130;s:49:"PHPStan\Php\PhpVersionFactoryFactory::__construct";i:131;s:45:"PHPStan\PhpDocParser\Lexer\Lexer::__construct";i:132;s:51:"PHPStan\PhpDocParser\Parser\TypeParser::__construct";i:133;s:45:"PHPStan\PhpDoc\ConstExprParserFactory::create";i:134;s:53:"PHPStan\PhpDocParser\Parser\PhpDocParser::__construct";i:135;s:50:"PHPStan\PhpDoc\ConstExprParserFactory::__construct";i:136;s:53:"PHPStan\PhpDoc\PhpDocInheritanceResolver::__construct";i:137;s:46:"PHPStan\PhpDoc\PhpDocNodeResolver::__construct";i:138;s:48:"PHPStan\PhpDoc\PhpDocStringResolver::__construct";i:139;s:49:"PHPStan\PhpDoc\ConstExprNodeResolver::__construct";i:140;s:44:"PHPStan\PhpDoc\TypeNodeResolver::__construct";i:141;s:73:"PHPStan\PhpDoc\LazyTypeNodeResolverExtensionRegistryProvider::__construct";i:142;s:46:"PHPStan\PhpDoc\TypeStringResolver::__construct";i:143;s:41:"PHPStan\PhpDoc\StubValidator::__construct";i:144;s:55:"PHPStan\PhpDoc\CountableStubFilesExtension::__construct";i:145;s:58:"PHPStan\PhpDoc\SocketSelectStubFilesExtension::__construct";i:146;s:52:"PHPStan\PhpDoc\DefaultStubFilesProvider::__construct";i:147;s:58:"PHPStan\PhpDoc\JsonValidateStubFilesExtension::__construct";i:148;s:60:"PHPStan\PhpDoc\ReflectionEnumStubFilesExtension::__construct";i:149;s:38:"PHPStan\Analyser\Analyser::__construct";i:150;s:53:"PHPStan\Analyser\AnalyserResultFinalizer::__construct";i:151;s:42:"PHPStan\Analyser\FileAnalyser::__construct";i:152;s:55:"PHPStan\Analyser\Ignore\IgnoredErrorHelper::__construct";i:153;s:54:"PHPStan\Analyser\LazyInternalScopeFactory::__construct";i:154;s:42:"PHPStan\Analyser\ScopeFactory::__construct";i:155;s:47:"PHPStan\Analyser\NodeScopeResolver::__construct";i:156;s:48:"PHPStan\Analyser\ConstantResolverFactory::create";i:157;s:53:"PHPStan\Analyser\ConstantResolverFactory::__construct";i:158;s:60:"PHPStan\Analyser\ResultCache\ResultCacheManager::__construct";i:159;s:60:"PHPStan\Analyser\ResultCache\ResultCacheClearer::__construct";i:160;s:32:"PHPStan\Cache\Cache::__construct";i:161;s:42:"PHPStan\Collectors\RegistryFactory::create";i:162;s:47:"PHPStan\Collectors\RegistryFactory::__construct";i:163;s:47:"PHPStan\Command\AnalyseApplication::__construct";i:164;s:43:"PHPStan\Command\AnalyserRunner::__construct";i:165;s:45:"PHPStan\Command\FixerApplication::__construct";i:166;s:50:"PHPStan\Dependency\DependencyResolver::__construct";i:167;s:51:"PHPStan\Dependency\ExportedNodeFetcher::__construct";i:168;s:52:"PHPStan\Dependency\ExportedNodeResolver::__construct";i:169;s:51:"PHPStan\Dependency\ExportedNodeVisitor::__construct";i:170;s:59:"PHPStan\DependencyInjection\MemoizingContainer::__construct";i:171;s:61:"PHPStan\DependencyInjection\Nette\NetteContainer::__construct";i:172;s:67:"PHPStan\DependencyInjection\DerivativeContainerFactory::__construct";i:173;s:96:"PHPStan\DependencyInjection\Reflection\LazyClassReflectionExtensionRegistryProvider::__construct";i:174;s:92:"PHPStan\DependencyInjection\Type\LazyDynamicReturnTypeExtensionRegistryProvider::__construct";i:175;s:83:"PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider::__construct";i:176;s:97:"PHPStan\DependencyInjection\Type\LazyExpressionTypeResolverExtensionRegistryProvider::__construct";i:177;s:97:"PHPStan\DependencyInjection\Type\LazyOperatorTypeSpecifyingExtensionRegistryProvider::__construct";i:178;s:83:"PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider::__construct";i:179;s:87:"PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider::__construct";i:180;s:36:"PHPStan\File\FileHelper::__construct";i:181;s:45:"PHPStan\File\FileExcluderFactory::__construct";i:182;s:38:"PHPStan\File\FileExcluder::__construct";i:183;s:59:"PHPStan\File\FileExcluderFactory::createAnalyseFileExcluder";i:184;s:56:"PHPStan\File\FileExcluderFactory::createScanFileExcluder";i:185;s:36:"PHPStan\File\FileFinder::__construct";i:187;s:37:"PHPStan\File\FileMonitor::__construct";i:188;s:46:"PHPStan\Parallel\ParallelAnalyser::__construct";i:189;s:39:"PHPStan\Parallel\Scheduler::__construct";i:190;s:57:"PHPStan\Reflection\Php\PhpFunctionReflection::__construct";i:191;s:59:"PHPStan\Reflection\InitializerExprTypeResolver::__construct";i:192;s:79:"PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher::__construct";i:193;s:109:"PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker::__construct";i:194;s:101:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory::__construct";i:195;s:104:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository::__construct";i:196;s:92:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator::__construct";i:197;s:95:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator::__construct";i:198;s:105:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository::__construct";i:199;s:74:"PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension::__construct";i:200;s:77:"PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension::__construct";i:201;s:63:"PHPStan\Reflection\Php\PhpClassReflectionExtension::__construct";i:202;s:55:"PHPStan\Reflection\Php\PhpMethodReflection::__construct";i:203;s:81:"PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension::__construct";i:204;s:92:"PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension::__construct";i:206;s:81:"PHPStan\Reflection\ReflectionProvider\LazyReflectionProviderProvider::__construct";i:207;s:77:"PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider::__construct";i:208;s:63:"PHPStan\Reflection\SignatureMap\SignatureMapParser::__construct";i:209;s:73:"PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider::__construct";i:210;s:69:"PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider::__construct";i:211;s:72:"PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory::__construct";i:212;s:67:"PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory::create";i:213;s:42:"PHPStan\Rules\AttributesCheck::__construct";i:214;s:71:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck::__construct";i:215;s:41:"PHPStan\Rules\ClassNameCheck::__construct";i:216;s:52:"PHPStan\Rules\ClassCaseSensitivityCheck::__construct";i:217;s:50:"PHPStan\Rules\ClassForbiddenNameCheck::__construct";i:218;s:56:"PHPStan\Rules\Classes\LocalTypeAliasesCheck::__construct";i:219;s:49:"PHPStan\Rules\Classes\MethodTagCheck::__construct";i:220;s:51:"PHPStan\Rules\Classes\PropertyTagCheck::__construct";i:221;s:65:"PHPStan\Rules\Comparison\ConstantConditionRuleHelper::__construct";i:222;s:63:"PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper::__construct";i:223;s:66:"PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver::__construct";i:224;s:81:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule::__construct";i:225;s:79:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule::__construct";i:226;s:74:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck::__construct";i:227;s:66:"PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule::__construct";i:228;s:64:"PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule::__construct";i:229;s:54:"PHPStan\Rules\FunctionCallParametersCheck::__construct";i:230;s:50:"PHPStan\Rules\FunctionDefinitionCheck::__construct";i:231;s:50:"PHPStan\Rules\FunctionReturnTypeCheck::__construct";i:232;s:57:"PHPStan\Rules\ParameterCastableToStringCheck::__construct";i:233;s:57:"PHPStan\Rules\Generics\GenericAncestorsCheck::__construct";i:234;s:53:"PHPStan\Rules\Generics\TemplateTypeCheck::__construct";i:235;s:49:"PHPStan\Rules\Generics\VarianceCheck::__construct";i:236;s:37:"PHPStan\Rules\IssetCheck::__construct";i:237;s:50:"PHPStan\Rules\Methods\MethodCallCheck::__construct";i:238;s:56:"PHPStan\Rules\Methods\StaticMethodCallCheck::__construct";i:239;s:54:"PHPStan\Rules\Methods\MethodSignatureRule::__construct";i:240;s:66:"PHPStan\Rules\Methods\MethodParameterComparisonHelper::__construct";i:241;s:47:"PHPStan\Rules\MissingTypehintCheck::__construct";i:242;s:82:"PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider::__construct";i:243;s:72:"PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider::__construct";i:244;s:50:"PHPStan\Rules\PhpDoc\AssertRuleHelper::__construct";i:245;s:59:"PHPStan\Rules\PhpDoc\GenericCallableRuleHelper::__construct";i:246;s:54:"PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper::__construct";i:247;s:78:"PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider::__construct";i:248;s:42:"PHPStan\Rules\RuleLevelHelper::__construct";i:249;s:56:"PHPStan\Rules\UnusedFunctionParametersCheck::__construct";i:250;s:40:"PHPStan\Type\FileTypeMapper::__construct";i:251;s:49:"PHPStan\Type\UsefulTypeAliasResolver::__construct";i:252;s:55:"PHPStan\Type\LazyTypeAliasResolverProvider::__construct";i:253;s:43:"PHPStan\Type\BitwiseFlagHelper::__construct";i:254;s:74:"PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension::__construct";i:255;s:67:"PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension::__construct";i:256;s:68:"PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension::__construct";i:257;s:69:"PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension::__construct";i:258;s:66:"PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension::__construct";i:259;s:70:"PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension::__construct";i:260;s:66:"PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension::__construct";i:261;s:73:"PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension::__construct";i:262;s:75:"PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension::__construct";i:263;s:75:"PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension::__construct";i:264;s:67:"PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension::__construct";i:265;s:64:"PHPStan\Type\Php\CompactFunctionReturnTypeExtension::__construct";i:266;s:65:"PHPStan\Type\Php\ConstantFunctionReturnTypeExtension::__construct";i:267;s:75:"PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension::__construct";i:268;s:57:"PHPStan\Type\Php\CurlInitReturnTypeExtension::__construct";i:269;s:67:"PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension::__construct";i:270;s:65:"PHPStan\Type\Php\DateFormatMethodReturnTypeExtension::__construct";i:271;s:61:"PHPStan\Type\Php\DateFunctionReturnTypeExtension::__construct";i:272;s:71:"PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension::__construct";i:273;s:63:"PHPStan\Type\Php\DateTimeModifyReturnTypeExtension::__construct";i:275;s:67:"PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension::__construct";i:276;s:68:"PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension::__construct";i:277;s:71:"PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension::__construct";i:278;s:71:"PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension::__construct";i:279;s:60:"PHPStan\Type\Php\FilterFunctionReturnTypeHelper::__construct";i:280;s:67:"PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension::__construct";i:281;s:65:"PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension::__construct";i:282;s:70:"PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension::__construct";i:283;s:78:"PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension::__construct";i:284;s:62:"PHPStan\Type\Php\HashFunctionsReturnTypeExtension::__construct";i:285;s:71:"PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension::__construct";i:286;s:52:"PHPStan\Type\Php\JsonThrowTypeExtension::__construct";i:287;s:62:"PHPStan\Type\Php\PregMatchTypeSpecifyingExtension::__construct";i:288;s:64:"PHPStan\Type\Php\PregMatchParameterOutTypeExtension::__construct";i:289;s:69:"PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension::__construct";i:290;s:52:"PHPStan\Type\Php\RegexArrayShapeMatcher::__construct";i:291;s:48:"PHPStan\Type\Regex\RegexGroupParser::__construct";i:292;s:53:"PHPStan\Type\Regex\RegexExpressionHelper::__construct";i:293;s:77:"PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension::__construct";i:294;s:75:"PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension::__construct";i:295;s:77:"PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension::__construct";i:296;s:67:"PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension::__construct";i:297;s:63:"PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension::__construct";i:298;s:72:"PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension::__construct";i:299;s:65:"PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension::__construct";i:300;s:60:"PHPStan\Type\Php\MbFunctionsReturnTypeExtension::__construct";i:301;s:77:"PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension::__construct";i:302;s:65:"PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension::__construct";i:303;s:68:"PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension::__construct";i:304;s:62:"PHPStan\Type\Php\RoundFunctionReturnTypeExtension::__construct";i:305;s:68:"PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension::__construct";i:306;s:68:"PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension::__construct";i:307;s:71:"PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension::__construct";i:308;s:73:"PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension::__construct";i:309;s:64:"PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension::__construct";i:310;s:72:"PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension::__construct";i:311;s:79:"PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension::__construct";i:312;s:65:"PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension::__construct";i:313;s:78:"PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension::__construct";i:318;s:44:"PHPStan\Type\ClosureTypeFactory::__construct";i:319;s:49:"PHPStan\Rules\Functions\PrintfHelper::__construct";i:320;s:49:"_PHPStan_4f7beffdf\Nette\DI\Container::getService";i:321;s:45:"PHPStan\Analyser\TypeSpecifierFactory::create";i:322;s:50:"PHPStan\Analyser\TypeSpecifierFactory::__construct";i:323;s:49:"PHPStan\File\FuzzyRelativePathHelper::__construct";i:324;s:50:"PHPStan\File\SimpleRelativePathHelper::__construct";i:325;s:59:"PHPStan\File\ParentDirectoryRelativePathHelper::__construct";i:326;s:36:"PHPStan\Broker\BrokerFactory::create";i:327;s:41:"PHPStan\Broker\BrokerFactory::__construct";i:328;s:43:"PHPStan\Cache\FileCacheStorage::__construct";i:329;s:38:"PHPStan\Parser\RichParser::__construct";i:330;s:42:"PHPStan\Parser\CleaningParser::__construct";i:331;s:40:"PHPStan\Parser\SimpleParser::__construct";i:332;s:40:"PHPStan\Parser\CachedParser::__construct";i:333;s:46:"PHPStan\Parser\PhpParserDecorator::__construct";i:334;s:35:"PHPStan\Parser\LexerFactory::create";i:335;s:37:"PhpParser\ParserAbstract::__construct";i:336;s:39:"PHPStan\Rules\LazyRegistry::__construct";i:337;s:46:"PHPStan\PhpDoc\StubPhpDocProvider::__construct";i:338;s:76:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory::__construct";i:340;s:80:"PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory::create";i:341;s:64:"PHPStan\BetterReflection\Reflector\DefaultReflector::__construct";i:342;s:77:"PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector::__construct";i:343;s:62:"PHPStan\BetterReflection\Reflector\ClassReflector::__construct";i:344;s:65:"PHPStan\BetterReflection\Reflector\FunctionReflector::__construct";i:345;s:65:"PHPStan\BetterReflection\Reflector\ConstantReflector::__construct";i:347;s:73:"PHPStan\Reflection\BetterReflection\BetterReflectionProvider::__construct";i:348;s:85:"PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory::__construct";i:350;s:96:"PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory::__construct";i:353;s:93:"PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory::__construct";i:354;s:44:"PHPStan\Parser\LexerFactory::createEmulative";i:357;s:45:"PHPStan\Parser\PathRoutingParser::__construct";i:358;s:54:"PHPStan\Diagnose\PHPStanDiagnoseExtension::__construct";i:359;s:68:"PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter::__construct";i:360;s:63:"PHPStan\Command\ErrorFormatter\TableErrorFormatter::__construct";i:361;s:68:"PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter::__construct";i:362;s:62:"PHPStan\Command\ErrorFormatter\JsonErrorFormatter::__construct";i:363;s:63:"PHPStan\Command\ErrorFormatter\JunitErrorFormatter::__construct";i:365;s:64:"PHPStan\Command\ErrorFormatter\GitlabErrorFormatter::__construct";i:366;s:64:"PHPStan\Command\ErrorFormatter\GithubErrorFormatter::__construct";i:367;s:66:"PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter::__construct";i:368;s:53:"PHPStan\Rules\Api\ApiClassConstFetchRule::__construct";i:369;s:48:"PHPStan\Rules\Api\ApiInstanceofRule::__construct";i:370;s:52:"PHPStan\Rules\Api\ApiInstanceofTypeRule::__construct";i:371;s:66:"PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule::__construct";i:372;s:60:"PHPStan\Rules\Api\RuntimeReflectionFunctionRule::__construct";i:373;s:65:"PHPStan\Rules\Api\RuntimeReflectionInstantiationRule::__construct";i:374;s:66:"PHPStan\Rules\Classes\ExistingClassInClassExtendsRule::__construct";i:375;s:64:"PHPStan\Rules\Classes\ExistingClassInInstanceOfRule::__construct";i:376;s:66:"PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule::__construct";i:377;s:66:"PHPStan\Rules\Functions\CallToNonExistentFunctionRule::__construct";i:378;s:59:"PHPStan\Rules\Constants\OverridingConstantRule::__construct";i:379;s:55:"PHPStan\Rules\Methods\OverridingMethodRule::__construct";i:380;s:60:"PHPStan\Rules\Methods\ConsistentConstructorRule::__construct";i:381;s:52:"PHPStan\Rules\Missing\MissingReturnRule::__construct";i:382;s:65:"PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule::__construct";i:383;s:60:"PHPStan\Rules\Namespaces\ExistingNamesInUseRule::__construct";i:384;s:63:"PHPStan\Rules\Operators\InvalidIncDecOperationRule::__construct";i:385;s:58:"PHPStan\Rules\Properties\AccessPropertiesRule::__construct";i:386;s:64:"PHPStan\Rules\Properties\AccessStaticPropertiesRule::__construct";i:387;s:69:"PHPStan\Rules\Properties\ExistingClassesInPropertiesRule::__construct";i:388;s:57:"PHPStan\Rules\Functions\FunctionCallableRule::__construct";i:389;s:79:"PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule::__construct";i:390;s:60:"PHPStan\Rules\Properties\OverridingPropertyRule::__construct";i:391;s:63:"PHPStan\Rules\Properties\UninitializedPropertyRule::__construct";i:392;s:69:"PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule::__construct";i:393;s:68:"PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule::__construct";i:394;s:57:"PHPStan\Rules\Variables\CompactVariablesRule::__construct";i:395;s:56:"PHPStan\Rules\Variables\DefinedVariableRule::__construct";i:396;s:62:"PHPStan\Rules\Regexp\RegularExpressionPatternRule::__construct";i:397;s:50:"PHPStan\Reflection\ConstructorsHelper::__construct";i:398;s:71:"PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule::__construct";i:399;s:67:"PHPStan\Rules\Functions\UselessFunctionReturnValueRule::__construct";i:400;s:62:"PHPStan\Rules\Functions\PrintfArrayParametersRule::__construct";i:401;s:62:"PHPStan\Rules\Regexp\RegularExpressionQuotingRule::__construct";i:402;s:44:"PHPStan\Rules\Classes\MixinRule::__construct";i:403;s:48:"PHPStan\Rules\Classes\MethodTagRule::__construct";i:404;s:53:"PHPStan\Rules\Classes\MethodTagTraitRule::__construct";i:405;s:50:"PHPStan\Rules\Classes\PropertyTagRule::__construct";i:406;s:55:"PHPStan\Rules\Classes\PropertyTagTraitRule::__construct";i:407;s:53:"PHPStan\Rules\PhpDoc\RequireExtendsCheck::__construct";i:408;s:70:"PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule::__construct";i:409;s:54:"PHPStan\Rules\Functions\CallCallablesRule::__construct";i:410;s:59:"PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule::__construct";i:411;s:61:"PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule::__construct";i:412;s:58:"PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule::__construct";i:413;s:65:"PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule::__construct";i:414;s:63:"PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule::__construct";i:415;s:56:"PHPStan\Rules\Generics\PropertyVarianceRule::__construct";i:416;s:48:"PHPStan\Rules\Pure\PureFunctionRule::__construct";i:417;s:46:"PHPStan\Rules\Pure\PureMethodRule::__construct";i:418;s:63:"PHPStan\Rules\Operators\InvalidBinaryOperationRule::__construct";i:419;s:62:"PHPStan\Rules\Operators\InvalidUnaryOperationRule::__construct";i:420;s:63:"PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule::__construct";i:421;s:59:"PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule::__construct";i:422;s:70:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule::__construct";i:423;s:82:"PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule::__construct";i:424;s:80:"PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule::__construct";i:425;s:55:"PHPStan\Rules\Generators\YieldFromTypeRule::__construct";i:426;s:58:"PHPStan\Rules\Generators\YieldInGeneratorRule::__construct";i:427;s:52:"PHPStan\Rules\Arrays\ArrayUnpackingRule::__construct";i:428;s:75:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule::__construct";i:429;s:72:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule::__construct";i:430;s:65:"PHPStan\Rules\Variables\ParameterOutAssignedTypeRule::__construct";i:431;s:69:"PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule::__construct";i:432;s:59:"PHPStan\Rules\Classes\ImpossibleInstanceOfRule::__construct";i:433;s:69:"PHPStan\Rules\Comparison\BooleanAndConstantConditionRule::__construct";i:434;s:68:"PHPStan\Rules\Comparison\BooleanOrConstantConditionRule::__construct";i:435;s:69:"PHPStan\Rules\Comparison\BooleanNotConstantConditionRule::__construct";i:436;s:44:"PHPStan\Rules\DeadCode\NoopRule::__construct";i:437;s:60:"PHPStan\Rules\DeadCode\PossiblyPureNewCollector::__construct";i:438;s:65:"PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector::__construct";i:439;s:67:"PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector::__construct";i:440;s:67:"PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector::__construct";i:441;s:61:"PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule::__construct";i:442;s:70:"PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule::__construct";i:443;s:65:"PHPStan\Rules\Comparison\ElseIfConstantConditionRule::__construct";i:444;s:61:"PHPStan\Rules\Comparison\IfConstantConditionRule::__construct";i:445;s:73:"PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule::__construct";i:446;s:71:"PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule::__construct";i:447;s:77:"PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule::__construct";i:448;s:69:"PHPStan\Rules\Comparison\LogicalXorConstantConditionRule::__construct";i:449;s:50:"PHPStan\Rules\DeadCode\BetterNoopRule::__construct";i:450;s:57:"PHPStan\Rules\Comparison\MatchExpressionRule::__construct";i:451;s:84:"PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule::__construct";i:452;s:74:"PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule::__construct";i:453;s:65:"PHPStan\Rules\Comparison\ConstantLooseComparisonRule::__construct";i:454;s:74:"PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule::__construct";i:455;s:63:"PHPStan\Rules\Comparison\UnreachableIfBranchesRule::__construct";i:456;s:70:"PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule::__construct";i:457;s:71:"PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule::__construct";i:458;s:70:"PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule::__construct";i:459;s:83:"PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule::__construct";i:460;s:75:"PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule::__construct";i:461;s:63:"PHPStan\Rules\Properties\NullsafePropertyFetchRule::__construct";i:462;s:68:"PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule::__construct";i:463;s:79:"PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule::__construct";i:464;s:77:"PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule::__construct";i:465;s:67:"PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule::__construct";i:466;s:60:"PHPStan\Rules\Functions\RandomIntParametersRule::__construct";i:467;s:52:"PHPStan\Rules\Functions\ArrayFilterRule::__construct";i:468;s:52:"PHPStan\Rules\Functions\ArrayValuesRule::__construct";i:469;s:53:"PHPStan\Rules\Functions\CallUserFuncRule::__construct";i:470;s:56:"PHPStan\Rules\Functions\ImplodeFunctionRule::__construct";i:471;s:66:"PHPStan\Rules\Functions\ParameterCastableToStringRule::__construct";i:472;s:73:"PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule::__construct";i:473;s:70:"PHPStan\Rules\Functions\SortParameterCastableToStringRule::__construct";i:474;s:73:"PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule::__construct";i:475;s:69:"PHPStan\Rules\Methods\MissingMethodParameterTypehintRule::__construct";i:476;s:63:"PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule::__construct";}i:5;s:32:"7b908ae75db9443012d417f414ac6f03";} \ No newline at end of file diff --git a/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php b/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php new file mode 100644 index 0000000..8b1aee6 --- /dev/null +++ b/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php @@ -0,0 +1,6872 @@ + [ + '04' => true, + '05' => true, + '06' => true, + '07' => true, + '08' => true, + '09' => true, + '010' => true, + '013' => true, + '014' => true, + '015' => true, + '016' => true, + '017' => true, + '018' => true, + '019' => true, + '082' => true, + ], + 'phpstan.stubFilesExtension' => ['039' => true, '040' => true, '042' => true, '043' => true], + 'phpstan.diagnoseExtension' => ['084' => true], + 'phpstan.broker.methodsClassReflectionExtension' => ['0101' => true, '0105' => true], + 'phpstan.broker.propertiesClassReflectionExtension' => ['0102' => true, '0107' => true, '0258' => true], + 'phpstan.broker.allowedSubTypesClassReflectionExtension' => ['0106' => true], + 'phpstan.broker.dynamicMethodReturnTypeExtension' => [ + '0108' => true, + '0109' => true, + '0206' => true, + '0217' => true, + '0223' => true, + '0224' => true, + '0228' => true, + '0260' => true, + '0287' => true, + '0313' => true, + '0314' => true, + '0321' => true, + '0322' => true, + '0323' => true, + '0324' => true, + '0325' => true, + '0326' => true, + ], + 'phpstan.broker.dynamicFunctionReturnTypeExtension' => [ + '0170' => true, + '0171' => true, + '0172' => true, + '0173' => true, + '0174' => true, + '0175' => true, + '0176' => true, + '0177' => true, + '0178' => true, + '0179' => true, + '0180' => true, + '0181' => true, + '0183' => true, + '0184' => true, + '0185' => true, + '0186' => true, + '0187' => true, + '0188' => true, + '0189' => true, + '0190' => true, + '0191' => true, + '0192' => true, + '0193' => true, + '0194' => true, + '0195' => true, + '0196' => true, + '0197' => true, + '0199' => true, + '0200' => true, + '0203' => true, + '0204' => true, + '0208' => true, + '0209' => true, + '0211' => true, + '0213' => true, + '0214' => true, + '0216' => true, + '0218' => true, + '0221' => true, + '0222' => true, + '0230' => true, + '0231' => true, + '0233' => true, + '0234' => true, + '0235' => true, + '0236' => true, + '0237' => true, + '0238' => true, + '0239' => true, + '0240' => true, + '0241' => true, + '0242' => true, + '0243' => true, + '0245' => true, + '0260' => true, + '0263' => true, + '0264' => true, + '0265' => true, + '0266' => true, + '0267' => true, + '0269' => true, + '0270' => true, + '0271' => true, + '0272' => true, + '0273' => true, + '0274' => true, + '0275' => true, + '0276' => true, + '0277' => true, + '0278' => true, + '0279' => true, + '0281' => true, + '0282' => true, + '0283' => true, + '0284' => true, + '0285' => true, + '0286' => true, + '0288' => true, + '0289' => true, + '0290' => true, + '0291' => true, + '0292' => true, + '0293' => true, + '0294' => true, + '0295' => true, + '0298' => true, + '0307' => true, + '0311' => true, + '0312' => true, + '0315' => true, + '0316' => true, + '0317' => true, + '0318' => true, + '0319' => true, + '0320' => true, + ], + 'phpstan.typeSpecifier.functionTypeSpecifyingExtension' => [ + '0182' => true, + '0198' => true, + '0212' => true, + '0247' => true, + '0257' => true, + '0261' => true, + '0262' => true, + '0280' => true, + '0296' => true, + '0297' => true, + '0299' => true, + '0300' => true, + '0301' => true, + '0302' => true, + '0303' => true, + '0304' => true, + '0305' => true, + '0306' => true, + '0308' => true, + '0310' => true, + ], + 'phpstan.dynamicFunctionThrowTypeExtension' => ['0201' => true, '0244' => true, '0246' => true], + 'phpstan.broker.dynamicStaticMethodReturnTypeExtension' => [ + '0202' => true, + '0205' => true, + '0207' => true, + '0220' => true, + '0321' => true, + '0327' => true, + ], + 'phpstan.dynamicStaticMethodThrowTypeExtension' => [ + '0219' => true, + '0225' => true, + '0227' => true, + '0253' => true, + '0254' => true, + '0255' => true, + '0256' => true, + '0259' => true, + ], + 'phpstan.dynamicMethodThrowTypeExtension' => ['0226' => true, '0229' => true], + 'phpstan.functionParameterOutTypeExtension' => ['0248' => true], + 'phpstan.functionParameterClosureTypeExtension' => ['0249' => true], + 'phpstan.typeSpecifier.methodTypeSpecifyingExtension' => ['0268' => true], + 'phpstan.rules.rule' => [ + '0340' => true, + '0344' => true, + '0345' => true, + '0346' => true, + '0347' => true, + '0348' => true, + '0349' => true, + '0351' => true, + '0352' => true, + '0353' => true, + '0354' => true, + '0355' => true, + '0356' => true, + '0357' => true, + '0358' => true, + '0360' => true, + '0363' => true, + '0364' => true, + '0365' => true, + '0366' => true, + '0367' => true, + '0374' => true, + '0380' => true, + '0383' => true, + '0386' => true, + '0387' => true, + '0388' => true, + '0390' => true, + '0394' => true, + '0395' => true, + '0396' => true, + '0397' => true, + '0398' => true, + '0399' => true, + '0400' => true, + '0401' => true, + '0402' => true, + '0408' => true, + '0409' => true, + '0410' => true, + '0411' => true, + '0412' => true, + '0424' => true, + '0425' => true, + '0426' => true, + '0427' => true, + '0428' => true, + '0429' => true, + '0430' => true, + '0433' => true, + '0434' => true, + '0435' => true, + '0437' => true, + '0438' => true, + '0439' => true, + '0440' => true, + '0441' => true, + '0442' => true, + '0443' => true, + '0444' => true, + '0448' => true, + '0452' => true, + '0456' => true, + '0460' => true, + '0461' => true, + 'rules.0' => true, + 'rules.1' => true, + 'rules.10' => true, + 'rules.100' => true, + 'rules.101' => true, + 'rules.102' => true, + 'rules.103' => true, + 'rules.104' => true, + 'rules.105' => true, + 'rules.106' => true, + 'rules.107' => true, + 'rules.108' => true, + 'rules.109' => true, + 'rules.11' => true, + 'rules.110' => true, + 'rules.111' => true, + 'rules.112' => true, + 'rules.113' => true, + 'rules.114' => true, + 'rules.115' => true, + 'rules.116' => true, + 'rules.117' => true, + 'rules.118' => true, + 'rules.119' => true, + 'rules.12' => true, + 'rules.120' => true, + 'rules.121' => true, + 'rules.122' => true, + 'rules.123' => true, + 'rules.124' => true, + 'rules.125' => true, + 'rules.126' => true, + 'rules.127' => true, + 'rules.128' => true, + 'rules.129' => true, + 'rules.13' => true, + 'rules.130' => true, + 'rules.131' => true, + 'rules.132' => true, + 'rules.133' => true, + 'rules.134' => true, + 'rules.135' => true, + 'rules.136' => true, + 'rules.137' => true, + 'rules.138' => true, + 'rules.139' => true, + 'rules.14' => true, + 'rules.140' => true, + 'rules.141' => true, + 'rules.142' => true, + 'rules.143' => true, + 'rules.144' => true, + 'rules.145' => true, + 'rules.146' => true, + 'rules.147' => true, + 'rules.148' => true, + 'rules.149' => true, + 'rules.15' => true, + 'rules.150' => true, + 'rules.151' => true, + 'rules.152' => true, + 'rules.153' => true, + 'rules.154' => true, + 'rules.155' => true, + 'rules.156' => true, + 'rules.157' => true, + 'rules.158' => true, + 'rules.159' => true, + 'rules.16' => true, + 'rules.160' => true, + 'rules.161' => true, + 'rules.162' => true, + 'rules.163' => true, + 'rules.164' => true, + 'rules.165' => true, + 'rules.17' => true, + 'rules.18' => true, + 'rules.19' => true, + 'rules.2' => true, + 'rules.20' => true, + 'rules.21' => true, + 'rules.22' => true, + 'rules.23' => true, + 'rules.24' => true, + 'rules.25' => true, + 'rules.26' => true, + 'rules.27' => true, + 'rules.28' => true, + 'rules.29' => true, + 'rules.3' => true, + 'rules.30' => true, + 'rules.31' => true, + 'rules.32' => true, + 'rules.33' => true, + 'rules.34' => true, + 'rules.35' => true, + 'rules.36' => true, + 'rules.37' => true, + 'rules.38' => true, + 'rules.39' => true, + 'rules.4' => true, + 'rules.40' => true, + 'rules.41' => true, + 'rules.42' => true, + 'rules.43' => true, + 'rules.44' => true, + 'rules.45' => true, + 'rules.46' => true, + 'rules.47' => true, + 'rules.48' => true, + 'rules.49' => true, + 'rules.5' => true, + 'rules.50' => true, + 'rules.51' => true, + 'rules.52' => true, + 'rules.53' => true, + 'rules.54' => true, + 'rules.55' => true, + 'rules.56' => true, + 'rules.57' => true, + 'rules.58' => true, + 'rules.59' => true, + 'rules.6' => true, + 'rules.60' => true, + 'rules.61' => true, + 'rules.62' => true, + 'rules.63' => true, + 'rules.64' => true, + 'rules.65' => true, + 'rules.66' => true, + 'rules.67' => true, + 'rules.68' => true, + 'rules.69' => true, + 'rules.7' => true, + 'rules.70' => true, + 'rules.71' => true, + 'rules.72' => true, + 'rules.73' => true, + 'rules.74' => true, + 'rules.75' => true, + 'rules.76' => true, + 'rules.77' => true, + 'rules.78' => true, + 'rules.79' => true, + 'rules.8' => true, + 'rules.80' => true, + 'rules.81' => true, + 'rules.82' => true, + 'rules.83' => true, + 'rules.84' => true, + 'rules.85' => true, + 'rules.86' => true, + 'rules.87' => true, + 'rules.88' => true, + 'rules.89' => true, + 'rules.9' => true, + 'rules.90' => true, + 'rules.91' => true, + 'rules.92' => true, + 'rules.93' => true, + 'rules.94' => true, + 'rules.95' => true, + 'rules.96' => true, + 'rules.97' => true, + 'rules.98' => true, + 'rules.99' => true, + ], + ]; + + protected $types = ['container' => '_PHPStan_4f7beffdf\Nette\DI\Container']; + protected $aliases = []; + + protected $wiring = [ + '_PHPStan_4f7beffdf\Nette\DI\Container' => [['container']], + 'PHPStan\Rules\Rule' => [ + [ + '0129', + '0130', + '0132', + '0133', + '0147', + '0338', + '0339', + '0340', + '0341', + '0342', + '0343', + '0344', + '0345', + '0346', + '0347', + '0348', + '0349', + '0350', + '0351', + '0352', + '0353', + '0354', + '0355', + '0356', + '0357', + '0358', + '0359', + '0360', + '0361', + '0362', + '0363', + '0364', + '0365', + '0366', + '0367', + '0369', + '0370', + '0371', + '0372', + '0373', + '0374', + '0375', + '0376', + '0377', + '0378', + '0380', + '0381', + '0382', + '0383', + '0384', + '0385', + '0386', + '0387', + '0388', + '0389', + '0390', + '0391', + '0392', + '0393', + '0394', + '0395', + '0396', + '0397', + '0398', + '0399', + '0400', + '0401', + '0402', + '0403', + '0404', + '0405', + '0406', + '0407', + '0408', + '0409', + '0410', + '0411', + '0412', + '0413', + '0416', + '0419', + '0422', + '0424', + '0425', + '0426', + '0427', + '0428', + '0429', + '0430', + '0431', + '0432', + '0433', + '0434', + '0435', + '0436', + '0437', + '0438', + '0439', + '0440', + '0441', + '0442', + '0443', + '0444', + '0447', + '0448', + '0449', + '0450', + '0451', + '0452', + '0453', + '0454', + '0455', + '0456', + '0457', + '0458', + '0459', + '0460', + '0461', + '0462', + ], + [ + 'rules.0', + 'rules.1', + 'rules.2', + 'rules.3', + 'rules.4', + 'rules.5', + 'rules.6', + 'rules.7', + 'rules.8', + 'rules.9', + 'rules.10', + 'rules.11', + 'rules.12', + 'rules.13', + 'rules.14', + 'rules.15', + 'rules.16', + 'rules.17', + 'rules.18', + 'rules.19', + 'rules.20', + 'rules.21', + 'rules.22', + 'rules.23', + 'rules.24', + 'rules.25', + 'rules.26', + 'rules.27', + 'rules.28', + 'rules.29', + 'rules.30', + 'rules.31', + 'rules.32', + 'rules.33', + 'rules.34', + 'rules.35', + 'rules.36', + 'rules.37', + 'rules.38', + 'rules.39', + 'rules.40', + 'rules.41', + 'rules.42', + 'rules.43', + 'rules.44', + 'rules.45', + 'rules.46', + 'rules.47', + 'rules.48', + 'rules.49', + 'rules.50', + 'rules.51', + 'rules.52', + 'rules.53', + 'rules.54', + 'rules.55', + 'rules.56', + 'rules.57', + 'rules.58', + 'rules.59', + 'rules.60', + 'rules.61', + 'rules.62', + 'rules.63', + 'rules.64', + 'rules.65', + 'rules.66', + 'rules.67', + 'rules.68', + 'rules.69', + 'rules.70', + 'rules.71', + 'rules.72', + 'rules.73', + 'rules.74', + 'rules.75', + 'rules.76', + 'rules.77', + 'rules.78', + 'rules.79', + 'rules.80', + 'rules.81', + 'rules.82', + 'rules.83', + 'rules.84', + 'rules.85', + 'rules.86', + 'rules.87', + 'rules.88', + 'rules.89', + 'rules.90', + 'rules.91', + 'rules.92', + 'rules.93', + 'rules.94', + 'rules.95', + 'rules.96', + 'rules.97', + 'rules.98', + 'rules.99', + 'rules.100', + 'rules.101', + 'rules.102', + 'rules.103', + 'rules.104', + 'rules.105', + 'rules.106', + 'rules.107', + 'rules.108', + 'rules.109', + 'rules.110', + 'rules.111', + 'rules.112', + 'rules.113', + 'rules.114', + 'rules.115', + 'rules.116', + 'rules.117', + 'rules.118', + 'rules.119', + 'rules.120', + 'rules.121', + 'rules.122', + 'rules.123', + 'rules.124', + 'rules.125', + 'rules.126', + 'rules.127', + 'rules.128', + 'rules.129', + 'rules.130', + 'rules.131', + 'rules.132', + 'rules.133', + 'rules.134', + 'rules.135', + 'rules.136', + 'rules.137', + 'rules.138', + 'rules.139', + 'rules.140', + 'rules.141', + 'rules.142', + 'rules.143', + 'rules.144', + 'rules.145', + 'rules.146', + 'rules.147', + 'rules.148', + 'rules.149', + 'rules.150', + 'rules.151', + 'rules.152', + 'rules.153', + 'rules.154', + 'rules.155', + 'rules.156', + 'rules.157', + 'rules.158', + 'rules.159', + 'rules.160', + 'rules.161', + 'rules.162', + 'rules.163', + 'rules.164', + 'rules.165', + ], + ], + 'PHPStan\Rules\Debug\DumpTypeRule' => [['rules.0']], + 'PHPStan\Rules\Debug\FileAssertRule' => [['rules.1']], + 'PHPStan\Rules\Api\ApiInstantiationRule' => [['rules.2']], + 'PHPStan\Rules\Api\ApiClassExtendsRule' => [['rules.3']], + 'PHPStan\Rules\Api\ApiClassImplementsRule' => [['rules.4']], + 'PHPStan\Rules\Api\ApiInterfaceExtendsRule' => [['rules.5']], + 'PHPStan\Rules\Api\ApiMethodCallRule' => [['rules.6']], + 'PHPStan\Rules\Api\ApiStaticCallRule' => [['rules.7']], + 'PHPStan\Rules\Api\ApiTraitUseRule' => [['rules.8']], + 'PHPStan\Rules\Api\GetTemplateTypeRule' => [['rules.9']], + 'PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule' => [['rules.10']], + 'PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule' => [['rules.11']], + 'PHPStan\Rules\Arrays\EmptyArrayItemRule' => [['rules.12']], + 'PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule' => [['rules.13']], + 'PHPStan\Rules\Cast\UnsetCastRule' => [['rules.14']], + 'PHPStan\Rules\Classes\AllowedSubTypesRule' => [['rules.15']], + 'PHPStan\Rules\Classes\ClassAttributesRule' => [['rules.16']], + 'PHPStan\Rules\Classes\ClassConstantAttributesRule' => [['rules.17']], + 'PHPStan\Rules\Classes\ClassConstantRule' => [['rules.18']], + 'PHPStan\Rules\Classes\DuplicateDeclarationRule' => [['rules.19']], + 'PHPStan\Rules\Classes\EnumSanityRule' => [['rules.20']], + 'PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule' => [['rules.21']], + 'PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule' => [['rules.22']], + 'PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule' => [['rules.23']], + 'PHPStan\Rules\Classes\ExistingClassInTraitUseRule' => [['rules.24']], + 'PHPStan\Rules\Classes\InstantiationRule' => [['rules.25']], + 'PHPStan\Rules\Classes\InstantiationCallableRule' => [['rules.26']], + 'PHPStan\Rules\Classes\InvalidPromotedPropertiesRule' => [['rules.27']], + 'PHPStan\Rules\Classes\LocalTypeAliasesRule' => [['rules.28']], + 'PHPStan\Rules\Classes\LocalTypeTraitAliasesRule' => [['rules.29']], + 'PHPStan\Rules\Classes\NewStaticRule' => [['rules.30']], + 'PHPStan\Rules\Classes\NonClassAttributeClassRule' => [['rules.31']], + 'PHPStan\Rules\Classes\ReadOnlyClassRule' => [['rules.32']], + 'PHPStan\Rules\Classes\TraitAttributeClassRule' => [['rules.33']], + 'PHPStan\Rules\Constants\DynamicClassConstantFetchRule' => [['rules.34']], + 'PHPStan\Rules\Constants\FinalConstantRule' => [['rules.35']], + 'PHPStan\Rules\Constants\NativeTypedClassConstantRule' => [['rules.36']], + 'PHPStan\Rules\EnumCases\EnumCaseAttributesRule' => [['rules.37']], + 'PHPStan\Rules\Exceptions\NoncapturingCatchRule' => [['rules.38']], + 'PHPStan\Rules\Exceptions\ThrowExpressionRule' => [['rules.39']], + 'PHPStan\Rules\Functions\ArrowFunctionAttributesRule' => [['rules.40']], + 'PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule' => [['rules.41']], + 'PHPStan\Rules\Functions\ClosureAttributesRule' => [['rules.42']], + 'PHPStan\Rules\Functions\DefineParametersRule' => [['rules.43']], + 'PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule' => [['rules.44']], + 'PHPStan\Rules\Functions\CallToFunctionParametersRule' => [['rules.45']], + 'PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule' => [['rules.46']], + 'PHPStan\Rules\Functions\ExistingClassesInTypehintsRule' => [['rules.47']], + 'PHPStan\Rules\Functions\FunctionAttributesRule' => [['rules.48']], + 'PHPStan\Rules\Functions\InnerFunctionRule' => [['rules.49']], + 'PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule' => [['rules.50']], + 'PHPStan\Rules\Functions\ParamAttributesRule' => [['rules.51']], + 'PHPStan\Rules\Functions\PrintfParametersRule' => [['rules.52']], + 'PHPStan\Rules\Functions\RedefinedParametersRule' => [['rules.53']], + 'PHPStan\Rules\Functions\ReturnNullsafeByRefRule' => [['rules.54']], + 'PHPStan\Rules\Ignore\IgnoreParseErrorRule' => [['rules.55']], + 'PHPStan\Rules\Functions\VariadicParametersDeclarationRule' => [['rules.56']], + 'PHPStan\Rules\Keywords\ContinueBreakInLoopRule' => [['rules.57']], + 'PHPStan\Rules\Keywords\DeclareStrictTypesRule' => [['rules.58']], + 'PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule' => [['rules.59']], + 'PHPStan\Rules\Methods\AbstractPrivateMethodRule' => [['rules.60']], + 'PHPStan\Rules\Methods\CallMethodsRule' => [['rules.61']], + 'PHPStan\Rules\Methods\CallStaticMethodsRule' => [['rules.62']], + 'PHPStan\Rules\Methods\ConstructorReturnTypeRule' => [['rules.63']], + 'PHPStan\Rules\Methods\ExistingClassesInTypehintsRule' => [['rules.64']], + 'PHPStan\Rules\Methods\FinalPrivateMethodRule' => [['rules.65']], + 'PHPStan\Rules\Methods\MethodCallableRule' => [['rules.66']], + 'PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule' => [['rules.67']], + 'PHPStan\Rules\Methods\MissingMethodImplementationRule' => [['rules.68']], + 'PHPStan\Rules\Methods\MethodAttributesRule' => [['rules.69']], + 'PHPStan\Rules\Methods\StaticMethodCallableRule' => [['rules.70']], + 'PHPStan\Rules\Names\UsedNamesRule' => [['rules.71']], + 'PHPStan\Rules\Operators\InvalidAssignVarRule' => [['rules.72']], + 'PHPStan\Rules\Properties\AccessPropertiesInAssignRule' => [['rules.73']], + 'PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule' => [['rules.74']], + 'PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule' => [['rules.75']], + 'PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule' => [['rules.76']], + 'PHPStan\Rules\Properties\PropertiesInInterfaceRule' => [['rules.77']], + 'PHPStan\Rules\Properties\PropertyAttributesRule' => [['rules.78']], + 'PHPStan\Rules\Properties\ReadOnlyPropertyRule' => [['rules.79']], + 'PHPStan\Rules\Traits\ConflictingTraitConstantsRule' => [['rules.80']], + 'PHPStan\Rules\Traits\ConstantsInTraitsRule' => [['rules.81']], + 'PHPStan\Rules\Types\InvalidTypesInUnionRule' => [['rules.82']], + 'PHPStan\Rules\Variables\UnsetRule' => [['rules.83']], + 'PHPStan\Rules\Whitespace\FileWhitespaceRule' => [['rules.84']], + 'PHPStan\Rules\Classes\UnusedConstructorParametersRule' => [['rules.85']], + 'PHPStan\Rules\Constants\ConstantRule' => [['rules.86']], + 'PHPStan\Rules\Functions\UnusedClosureUsesRule' => [['rules.87']], + 'PHPStan\Rules\Variables\EmptyRule' => [['rules.88']], + 'PHPStan\Rules\Variables\IssetRule' => [['rules.89']], + 'PHPStan\Rules\Variables\NullCoalesceRule' => [['rules.90']], + 'PHPStan\Rules\Cast\EchoRule' => [['rules.91']], + 'PHPStan\Rules\Cast\InvalidCastRule' => [['rules.92']], + 'PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule' => [['rules.93']], + 'PHPStan\Rules\Cast\PrintRule' => [['rules.94']], + 'PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule' => [['rules.95']], + 'PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule' => [['rules.96']], + 'PHPStan\Rules\Constants\ValueAssignedToClassConstantRule' => [['rules.97']], + 'PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule' => [['rules.98']], + 'PHPStan\Rules\Generics\ClassAncestorsRule' => [['rules.99']], + 'PHPStan\Rules\Generics\ClassTemplateTypeRule' => [['rules.100']], + 'PHPStan\Rules\Generics\EnumAncestorsRule' => [['rules.101']], + 'PHPStan\Rules\Generics\EnumTemplateTypeRule' => [['rules.102']], + 'PHPStan\Rules\Generics\FunctionTemplateTypeRule' => [['rules.103']], + 'PHPStan\Rules\Generics\FunctionSignatureVarianceRule' => [['rules.104']], + 'PHPStan\Rules\Generics\InterfaceAncestorsRule' => [['rules.105']], + 'PHPStan\Rules\Generics\InterfaceTemplateTypeRule' => [['rules.106']], + 'PHPStan\Rules\Generics\MethodTemplateTypeRule' => [['rules.107']], + 'PHPStan\Rules\Generics\MethodTagTemplateTypeRule' => [['rules.108']], + 'PHPStan\Rules\Generics\MethodSignatureVarianceRule' => [['rules.109']], + 'PHPStan\Rules\Generics\TraitTemplateTypeRule' => [['rules.110']], + 'PHPStan\Rules\Generics\UsedTraitsRule' => [['rules.111']], + 'PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule' => [['rules.112']], + 'PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule' => [['rules.113']], + 'PHPStan\Rules\Operators\InvalidComparisonOperationRule' => [['rules.114']], + 'PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule' => [['rules.115']], + 'PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule' => [['rules.116']], + 'PHPStan\Rules\PhpDoc\FunctionAssertRule' => [['rules.117']], + 'PHPStan\Rules\PhpDoc\MethodAssertRule' => [['rules.118']], + 'PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule' => [['rules.119']], + 'PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule' => [['rules.120']], + 'PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule' => [['rules.121']], + 'PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule' => [['rules.122']], + 'PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule' => [['rules.123']], + 'PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule' => [['rules.124']], + 'PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule' => [['rules.125']], + 'PHPStan\Rules\Classes\RequireImplementsRule' => [['rules.126']], + 'PHPStan\Rules\Classes\RequireExtendsRule' => [['rules.127']], + 'PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule' => [['rules.128']], + 'PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule' => [['rules.129']], + 'PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule' => [['rules.130']], + 'PHPStan\Rules\Arrays\ArrayDestructuringRule' => [['rules.131']], + 'PHPStan\Rules\Arrays\IterableInForeachRule' => [['rules.132']], + 'PHPStan\Rules\Arrays\OffsetAccessAssignmentRule' => [['rules.133']], + 'PHPStan\Rules\Arrays\OffsetAccessAssignOpRule' => [['rules.134']], + 'PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule' => [['rules.135']], + 'PHPStan\Rules\Arrays\UnpackIterableInArrayRule' => [['rules.136']], + 'PHPStan\Rules\Exceptions\ThrowExprTypeRule' => [['rules.137']], + 'PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule' => [['rules.138']], + 'PHPStan\Rules\Functions\ClosureReturnTypeRule' => [['rules.139']], + 'PHPStan\Rules\Functions\ReturnTypeRule' => [['rules.140']], + 'PHPStan\Rules\Generators\YieldTypeRule' => [['rules.141']], + 'PHPStan\Rules\Methods\ReturnTypeRule' => [['rules.142']], + 'PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule' => [['rules.143']], + 'PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule' => [['rules.144']], + 'PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule' => [['rules.145']], + 'PHPStan\Rules\Properties\TypesAssignedToPropertiesRule' => [['rules.146']], + 'PHPStan\Rules\Variables\ThrowTypeRule' => [['rules.147']], + 'PHPStan\Rules\Variables\VariableCloningRule' => [['rules.148']], + 'PHPStan\Rules\Arrays\DeadForeachRule' => [['rules.149']], + 'PHPStan\Rules\DeadCode\UnreachableStatementRule' => [['rules.150']], + 'PHPStan\Rules\DeadCode\UnusedPrivateConstantRule' => [['rules.151']], + 'PHPStan\Rules\DeadCode\UnusedPrivateMethodRule' => [['rules.152']], + 'PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule' => [['rules.153']], + 'PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule' => [['rules.154']], + 'PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule' => [['rules.155']], + 'PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule' => [['rules.156']], + 'PHPStan\Rules\Methods\NullsafeMethodCallRule' => [['rules.157']], + 'PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule' => [['rules.158']], + 'PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule' => [['rules.159']], + 'PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule' => [['rules.160']], + 'PHPStan\Rules\DateTimeInstantiationRule' => [['rules.161']], + 'PHPStan\Rules\Constants\MissingClassConstantTypehintRule' => [['rules.162']], + 'PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule' => [['rules.163']], + 'PHPStan\Rules\Methods\MissingMethodReturnTypehintRule' => [['rules.164']], + 'PHPStan\Rules\Properties\MissingPropertyTypehintRule' => [['rules.165']], + 'PhpParser\BuilderFactory' => [['01']], + 'PHPStan\Parser\LexerFactory' => [['02']], + 'PhpParser\NodeVisitorAbstract' => [ + [ + '03', + '04', + '05', + '06', + '07', + '08', + '09', + '010', + '011', + '012', + '013', + '014', + '015', + '016', + '017', + '018', + '019', + '067', + '082', + '091', + ], + ], + 'PhpParser\NodeVisitor' => [ + [ + '03', + '04', + '05', + '06', + '07', + '08', + '09', + '010', + '011', + '012', + '013', + '014', + '015', + '016', + '017', + '018', + '019', + '067', + '082', + '091', + ], + ], + 'PhpParser\NodeVisitor\NameResolver' => [['03']], + 'PHPStan\Parser\AnonymousClassVisitor' => [['04']], + 'PHPStan\Parser\ArrayFilterArgVisitor' => [['05']], + 'PHPStan\Parser\ArrayMapArgVisitor' => [['06']], + 'PHPStan\Parser\ArrayWalkArgVisitor' => [['07']], + 'PHPStan\Parser\ClosureArgVisitor' => [['08']], + 'PHPStan\Parser\ClosureBindToVarVisitor' => [['09']], + 'PHPStan\Parser\ClosureBindArgVisitor' => [['010']], + 'PHPStan\Parser\CurlSetOptArgVisitor' => [['011']], + 'PHPStan\Parser\TypeTraverserInstanceofVisitor' => [['012']], + 'PHPStan\Parser\ArrowFunctionArgVisitor' => [['013']], + 'PHPStan\Parser\MagicConstantParamDefaultVisitor' => [['014']], + 'PHPStan\Parser\NewAssignedToPropertyVisitor' => [['015']], + 'PHPStan\Parser\ParentStmtTypesVisitor' => [['016']], + 'PHPStan\Parser\TryCatchTypeVisitor' => [['017']], + 'PHPStan\Parser\LastConditionVisitor' => [['018']], + 'PhpParser\NodeVisitor\NodeConnectingVisitor' => [['019']], + 'PHPStan\Node\Printer\ExprPrinter' => [['020']], + 'PhpParser\PrettyPrinter\Standard' => [['021']], + 'PhpParser\PrettyPrinterAbstract' => [['021']], + 'PHPStan\Node\Printer\Printer' => [['021']], + 'PHPStan\Broker\AnonymousClassNameHelper' => [['022']], + 'PHPStan\Php\PhpVersion' => [['023']], + 'PHPStan\Php\PhpVersionFactory' => [['024']], + 'PHPStan\Php\PhpVersionFactoryFactory' => [['025']], + 'PHPStan\PhpDocParser\Lexer\Lexer' => [['026']], + 'PHPStan\PhpDocParser\Parser\TypeParser' => [['027']], + 'PHPStan\PhpDocParser\Parser\ConstExprParser' => [['028']], + 'PHPStan\PhpDocParser\Parser\PhpDocParser' => [['029']], + 'PHPStan\PhpDoc\ConstExprParserFactory' => [['030']], + 'PHPStan\PhpDoc\PhpDocInheritanceResolver' => [['031']], + 'PHPStan\PhpDoc\PhpDocNodeResolver' => [['032']], + 'PHPStan\PhpDoc\PhpDocStringResolver' => [['033']], + 'PHPStan\PhpDoc\ConstExprNodeResolver' => [['034']], + 'PHPStan\PhpDoc\TypeNodeResolver' => [['035']], + 'PHPStan\PhpDoc\TypeNodeResolverExtensionRegistryProvider' => [['036']], + 'PHPStan\PhpDoc\TypeStringResolver' => [['037']], + 'PHPStan\PhpDoc\StubValidator' => [['038']], + 'PHPStan\PhpDoc\StubFilesExtension' => [['039', '040', '042', '043']], + 'PHPStan\PhpDoc\CountableStubFilesExtension' => [['039']], + 'PHPStan\PhpDoc\SocketSelectStubFilesExtension' => [['040']], + 'PHPStan\PhpDoc\StubFilesProvider' => [['041']], + 'PHPStan\PhpDoc\DefaultStubFilesProvider' => [['041']], + 'PHPStan\PhpDoc\JsonValidateStubFilesExtension' => [['042']], + 'PHPStan\PhpDoc\ReflectionEnumStubFilesExtension' => [['043']], + 'PHPStan\Analyser\Analyser' => [['044']], + 'PHPStan\Analyser\AnalyserResultFinalizer' => [['045']], + 'PHPStan\Analyser\FileAnalyser' => [['046']], + 'PHPStan\Analyser\LocalIgnoresProcessor' => [['047']], + 'PHPStan\Analyser\RuleErrorTransformer' => [['048']], + 'PHPStan\Analyser\Ignore\IgnoredErrorHelper' => [['049']], + 'PHPStan\Analyser\Ignore\IgnoreLexer' => [['050']], + 'PHPStan\Analyser\InternalScopeFactory' => [['051']], + 'PHPStan\Analyser\LazyInternalScopeFactory' => [['051']], + 'PHPStan\Analyser\ScopeFactory' => [['052']], + 'PHPStan\Analyser\NodeScopeResolver' => [['053']], + 'PHPStan\Analyser\ConstantResolver' => [['054']], + 'PHPStan\Analyser\ConstantResolverFactory' => [['055']], + 'PHPStan\Analyser\ResultCache\ResultCacheManagerFactory' => [['056']], + 'PHPStan\Analyser\ResultCache\ResultCacheClearer' => [['057']], + 'PHPStan\Cache\Cache' => [['058']], + 'PHPStan\Collectors\Registry' => [['059']], + 'PHPStan\Collectors\RegistryFactory' => [['060']], + 'PHPStan\Command\AnalyseApplication' => [['061']], + 'PHPStan\Command\AnalyserRunner' => [['062']], + 'PHPStan\Command\FixerApplication' => [['063']], + 'PHPStan\Dependency\DependencyResolver' => [['064']], + 'PHPStan\Dependency\ExportedNodeFetcher' => [['065']], + 'PHPStan\Dependency\ExportedNodeResolver' => [['066']], + 'PHPStan\Dependency\ExportedNodeVisitor' => [['067']], + 'PHPStan\DependencyInjection\Container' => [['068'], ['069']], + 'PHPStan\DependencyInjection\Nette\NetteContainer' => [['069']], + 'PHPStan\DependencyInjection\DerivativeContainerFactory' => [['070']], + 'PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider' => [['071']], + 'PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider' => [['072']], + 'PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider' => [['073']], + 'PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider' => [['074']], + 'PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider' => [['075']], + 'PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider' => [['076']], + 'PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider' => [['077']], + 'PHPStan\File\FileHelper' => [['078']], + 'PHPStan\File\FileExcluderFactory' => [['079']], + 'PHPStan\File\FileExcluderRawFactory' => [['080']], + 'PHPStan\File\FileExcluder' => [2 => ['fileExcluderAnalyse', 'fileExcluderScan']], + 'PHPStan\File\FileFinder' => [2 => ['fileFinderAnalyse', 'fileFinderScan']], + 'PHPStan\File\FileMonitor' => [['081']], + 'PHPStan\Parser\DeclarePositionVisitor' => [['082']], + 'PHPStan\Parallel\ParallelAnalyser' => [['083']], + 'PHPStan\Diagnose\DiagnoseExtension' => [0 => ['084'], 2 => [1 => 'phpstanDiagnoseExtension']], + 'PHPStan\Parallel\Scheduler' => [['084']], + 'PHPStan\Parser\FunctionCallStatementFinder' => [['085']], + 'PHPStan\Process\CpuCoreCounter' => [['086']], + 'PHPStan\Reflection\FunctionReflectionFactory' => [['087']], + 'PHPStan\Reflection\InitializerExprTypeResolver' => [['088']], + 'PHPStan\Reflection\MethodsClassReflectionExtension' => [['089', '099', '0101', '0103', '0105']], + 'PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension' => [['089']], + 'PHPStan\Reflection\PropertiesClassReflectionExtension' => [['090', '0100', '0102', '0103', '0107', '0258']], + 'PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension' => [['090']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor' => [['091']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher' => [['092']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker' => [['093']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory' => [['094']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository' => [['095']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory' => [['096']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory' => [['097']], + 'PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository' => [['098']], + 'PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension' => [['099']], + 'PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension' => [['0100']], + 'PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension' => [['0101']], + 'PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension' => [['0102']], + 'PHPStan\Reflection\Php\PhpClassReflectionExtension' => [['0103']], + 'PHPStan\Reflection\Php\PhpMethodReflectionFactory' => [['0104']], + 'PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension' => [['0105']], + 'PHPStan\Reflection\AllowedSubTypesClassReflectionExtension' => [['0106']], + 'PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension' => [['0106']], + 'PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension' => [['0107']], + 'PHPStan\Type\DynamicMethodReturnTypeExtension' => [ + [ + '0108', + '0109', + '0206', + '0217', + '0223', + '0224', + '0228', + '0260', + '0287', + '0313', + '0314', + '0321', + '0322', + '0323', + '0324', + '0325', + '0326', + ], + ], + 'PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension' => [['0108', '0109']], + 'PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider' => [['0110']], + 'PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider' => [['0111']], + 'PHPStan\Reflection\SignatureMap\SignatureMapParser' => [['0112']], + 'PHPStan\Reflection\SignatureMap\SignatureMapProvider' => [['0116'], ['0113', '0114']], + 'PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider' => [['0113']], + 'PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider' => [['0114']], + 'PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory' => [['0115']], + 'PHPStan\Rules\Api\ApiRuleHelper' => [['0117']], + 'PHPStan\Rules\AttributesCheck' => [['0118']], + 'PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck' => [['0119']], + 'PHPStan\Rules\ClassNameCheck' => [['0120']], + 'PHPStan\Rules\ClassCaseSensitivityCheck' => [['0121']], + 'PHPStan\Rules\ClassForbiddenNameCheck' => [['0122']], + 'PHPStan\Rules\Classes\LocalTypeAliasesCheck' => [['0123']], + 'PHPStan\Rules\Classes\MethodTagCheck' => [['0124']], + 'PHPStan\Rules\Classes\PropertyTagCheck' => [['0125']], + 'PHPStan\Rules\Comparison\ConstantConditionRuleHelper' => [['0126']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper' => [['0127']], + 'PHPStan\Rules\Exceptions\ExceptionTypeResolver' => [1 => ['0128'], [1 => 'exceptionTypeResolver']], + 'PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver' => [['0128']], + 'PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule' => [['0129']], + 'PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule' => [['0130']], + 'PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck' => [['0131']], + 'PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule' => [['0132']], + 'PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule' => [['0133']], + 'PHPStan\Rules\Exceptions\TooWideThrowTypeCheck' => [['0134']], + 'PHPStan\Rules\FunctionCallParametersCheck' => [['0135']], + 'PHPStan\Rules\FunctionDefinitionCheck' => [['0136']], + 'PHPStan\Rules\FunctionReturnTypeCheck' => [['0137']], + 'PHPStan\Rules\ParameterCastableToStringCheck' => [['0138']], + 'PHPStan\Rules\Generics\CrossCheckInterfacesHelper' => [['0139']], + 'PHPStan\Rules\Generics\GenericAncestorsCheck' => [['0140']], + 'PHPStan\Rules\Generics\GenericObjectTypeCheck' => [['0141']], + 'PHPStan\Rules\Generics\TemplateTypeCheck' => [['0142']], + 'PHPStan\Rules\Generics\VarianceCheck' => [['0143']], + 'PHPStan\Rules\IssetCheck' => [['0144']], + 'PHPStan\Rules\Methods\MethodCallCheck' => [['0145']], + 'PHPStan\Rules\Methods\StaticMethodCallCheck' => [['0146']], + 'PHPStan\Rules\Methods\MethodSignatureRule' => [['0147']], + 'PHPStan\Rules\Methods\MethodParameterComparisonHelper' => [['0148']], + 'PHPStan\Rules\MissingTypehintCheck' => [['0149']], + 'PHPStan\Rules\NullsafeCheck' => [['0150']], + 'PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtensionProvider' => [['0151']], + 'PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider' => [['0151']], + 'PHPStan\Rules\Methods\AlwaysUsedMethodExtensionProvider' => [['0152']], + 'PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider' => [['0152']], + 'PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper' => [['0153']], + 'PHPStan\Rules\PhpDoc\AssertRuleHelper' => [['0154']], + 'PHPStan\Rules\PhpDoc\UnresolvableTypeHelper' => [['0155']], + 'PHPStan\Rules\PhpDoc\GenericCallableRuleHelper' => [['0156']], + 'PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper' => [['0157']], + 'PHPStan\Rules\Playground\NeverRuleHelper' => [['0158']], + 'PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider' => [['0159']], + 'PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider' => [['0159']], + 'PHPStan\Rules\Properties\PropertyDescriptor' => [['0160']], + 'PHPStan\Rules\Properties\PropertyReflectionFinder' => [['0161']], + 'PHPStan\Rules\Pure\FunctionPurityCheck' => [['0162']], + 'PHPStan\Rules\RuleLevelHelper' => [['0163']], + 'PHPStan\Rules\UnusedFunctionParametersCheck' => [['0164']], + 'PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck' => [['0165']], + 'PHPStan\Type\FileTypeMapper' => [['0166']], + 'PHPStan\Type\TypeAliasResolver' => [['0167']], + 'PHPStan\Type\TypeAliasResolverProvider' => [['0168']], + 'PHPStan\Type\BitwiseFlagHelper' => [['0169']], + 'PHPStan\Type\DynamicFunctionReturnTypeExtension' => [ + [ + '0170', + '0171', + '0172', + '0173', + '0174', + '0175', + '0176', + '0177', + '0178', + '0179', + '0180', + '0181', + '0183', + '0184', + '0185', + '0186', + '0187', + '0188', + '0189', + '0190', + '0191', + '0192', + '0193', + '0194', + '0195', + '0196', + '0197', + '0199', + '0200', + '0203', + '0204', + '0208', + '0209', + '0211', + '0213', + '0214', + '0216', + '0218', + '0221', + '0222', + '0230', + '0231', + '0233', + '0234', + '0235', + '0236', + '0237', + '0238', + '0239', + '0240', + '0241', + '0242', + '0243', + '0245', + '0260', + '0263', + '0264', + '0265', + '0266', + '0267', + '0269', + '0270', + '0271', + '0272', + '0273', + '0274', + '0275', + '0276', + '0277', + '0278', + '0279', + '0281', + '0282', + '0283', + '0284', + '0285', + '0286', + '0288', + '0289', + '0290', + '0291', + '0292', + '0293', + '0294', + '0295', + '0298', + '0307', + '0311', + '0312', + '0315', + '0316', + '0317', + '0318', + '0319', + '0320', + ], + ], + 'PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension' => [['0170']], + 'PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension' => [['0171']], + 'PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension' => [['0172']], + 'PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension' => [['0173']], + 'PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension' => [['0174']], + 'PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension' => [['0175']], + 'PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension' => [['0176']], + 'PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension' => [['0177']], + 'PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension' => [['0178']], + 'PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension' => [['0179']], + 'PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension' => [['0180']], + 'PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension' => [['0181']], + 'PHPStan\Type\FunctionTypeSpecifyingExtension' => [ + [ + '0182', + '0198', + '0212', + '0247', + '0257', + '0261', + '0262', + '0280', + '0296', + '0297', + '0299', + '0300', + '0301', + '0302', + '0303', + '0304', + '0305', + '0306', + '0308', + '0310', + ], + ], + 'PHPStan\Analyser\TypeSpecifierAwareExtension' => [ + [ + '0182', + '0198', + '0212', + '0247', + '0257', + '0261', + '0262', + '0268', + '0280', + '0296', + '0297', + '0299', + '0300', + '0301', + '0302', + '0303', + '0304', + '0305', + '0306', + '0308', + '0310', + '0312', + ], + ], + 'PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension' => [['0182']], + 'PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension' => [['0183']], + 'PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension' => [['0184']], + 'PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension' => [['0185']], + 'PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension' => [['0186']], + 'PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension' => [['0187']], + 'PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension' => [['0188']], + 'PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension' => [['0189']], + 'PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension' => [['0190']], + 'PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension' => [['0191']], + 'PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension' => [['0192']], + 'PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension' => [['0193']], + 'PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension' => [['0194']], + 'PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension' => [['0195']], + 'PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension' => [['0196']], + 'PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension' => [['0197']], + 'PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension' => [['0198']], + 'PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension' => [['0199']], + 'PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension' => [['0200']], + 'PHPStan\Type\DynamicFunctionThrowTypeExtension' => [['0201', '0244', '0246']], + 'PHPStan\Type\Php\AssertThrowTypeExtension' => [['0201']], + 'PHPStan\Type\DynamicStaticMethodReturnTypeExtension' => [['0202', '0205', '0207', '0220', '0321', '0327']], + 'PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension' => [['0202']], + 'PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension' => [['0203']], + 'PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension' => [['0204']], + 'PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension' => [['0205']], + 'PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension' => [['0206']], + 'PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension' => [['0207']], + 'PHPStan\Type\Php\CompactFunctionReturnTypeExtension' => [['0208']], + 'PHPStan\Type\Php\ConstantFunctionReturnTypeExtension' => [['0209']], + 'PHPStan\Type\Php\ConstantHelper' => [['0210']], + 'PHPStan\Type\Php\CountFunctionReturnTypeExtension' => [['0211']], + 'PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension' => [['0212']], + 'PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension' => [['0213']], + 'PHPStan\Type\Php\CurlInitReturnTypeExtension' => [['0214']], + 'PHPStan\Type\Php\DateFunctionReturnTypeHelper' => [['0215']], + 'PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension' => [['0216']], + 'PHPStan\Type\Php\DateFormatMethodReturnTypeExtension' => [['0217']], + 'PHPStan\Type\Php\DateFunctionReturnTypeExtension' => [['0218']], + 'PHPStan\Type\DynamicStaticMethodThrowTypeExtension' => [ + ['0219', '0225', '0227', '0253', '0254', '0255', '0256', '0259'], + ], + 'PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension' => [['0219']], + 'PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension' => [['0220']], + 'PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension' => [['0221']], + 'PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension' => [['0222']], + 'PHPStan\Type\Php\DateTimeModifyReturnTypeExtension' => [['0223', '0224']], + 'PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension' => [['0225']], + 'PHPStan\Type\DynamicMethodThrowTypeExtension' => [['0226', '0229']], + 'PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension' => [['0226']], + 'PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension' => [['0227']], + 'PHPStan\Type\Php\DsMapDynamicReturnTypeExtension' => [['0228']], + 'PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension' => [['0229']], + 'PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension' => [['0230']], + 'PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension' => [['0231']], + 'PHPStan\Type\Php\FilterFunctionReturnTypeHelper' => [['0232']], + 'PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension' => [['0233']], + 'PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension' => [['0234']], + 'PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension' => [['0235']], + 'PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension' => [['0236']], + 'PHPStan\Type\Php\GetClassDynamicReturnTypeExtension' => [['0237']], + 'PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension' => [['0238']], + 'PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension' => [['0239']], + 'PHPStan\Type\Php\GettypeFunctionReturnTypeExtension' => [['0240']], + 'PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension' => [['0241']], + 'PHPStan\Type\Php\HashFunctionsReturnTypeExtension' => [['0242']], + 'PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension' => [['0243']], + 'PHPStan\Type\Php\IntdivThrowTypeExtension' => [['0244']], + 'PHPStan\Type\Php\IniGetReturnTypeExtension' => [['0245']], + 'PHPStan\Type\Php\JsonThrowTypeExtension' => [['0246']], + 'PHPStan\Type\Php\PregMatchTypeSpecifyingExtension' => [['0247']], + 'PHPStan\Type\FunctionParameterOutTypeExtension' => [['0248']], + 'PHPStan\Type\Php\PregMatchParameterOutTypeExtension' => [['0248']], + 'PHPStan\Type\FunctionParameterClosureTypeExtension' => [['0249']], + 'PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension' => [['0249']], + 'PHPStan\Type\Php\RegexArrayShapeMatcher' => [['0250']], + 'PHPStan\Type\Regex\RegexGroupParser' => [['0251']], + 'PHPStan\Type\Regex\RegexExpressionHelper' => [['0252']], + 'PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension' => [['0253']], + 'PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension' => [['0254']], + 'PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension' => [['0255']], + 'PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension' => [['0256']], + 'PHPStan\Type\Php\StrContainingTypeSpecifyingExtension' => [['0257']], + 'PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension' => [['0258']], + 'PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension' => [['0259']], + 'PHPStan\Type\Php\StatDynamicReturnTypeExtension' => [['0260']], + 'PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension' => [['0261']], + 'PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension' => [['0262']], + 'PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension' => [['0263']], + 'PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension' => [['0264']], + 'PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension' => [['0265']], + 'PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension' => [['0266']], + 'PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension' => [['0267']], + 'PHPStan\Type\MethodTypeSpecifyingExtension' => [['0268']], + 'PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension' => [['0268']], + 'PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension' => [['0269']], + 'PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension' => [['0270']], + 'PHPStan\Type\Php\LtrimFunctionReturnTypeExtension' => [['0271']], + 'PHPStan\Type\Php\MbFunctionsReturnTypeExtension' => [['0272']], + 'PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension' => [['0273']], + 'PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension' => [['0274']], + 'PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension' => [['0275']], + 'PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension' => [['0276']], + 'PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension' => [['0277']], + 'PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension' => [['0278']], + 'PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension' => [['0279']], + 'PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension' => [['0280']], + 'PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension' => [['0281']], + 'PHPStan\Type\Php\StrlenFunctionReturnTypeExtension' => [['0282']], + 'PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension' => [['0283']], + 'PHPStan\Type\Php\StrPadFunctionReturnTypeExtension' => [['0284']], + 'PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension' => [['0285']], + 'PHPStan\Type\Php\SubstrDynamicReturnTypeExtension' => [['0286']], + 'PHPStan\Type\Php\ThrowableReturnTypeExtension' => [['0287']], + 'PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension' => [['0288']], + 'PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension' => [['0289']], + 'PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension' => [['0290']], + 'PHPStan\Type\Php\PowFunctionReturnTypeExtension' => [['0291']], + 'PHPStan\Type\Php\RoundFunctionReturnTypeExtension' => [['0292']], + 'PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension' => [['0293']], + 'PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension' => [['0294']], + 'PHPStan\Type\Php\RangeFunctionReturnTypeExtension' => [['0295']], + 'PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension' => [['0296']], + 'PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension' => [['0297']], + 'PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension' => [['0298']], + 'PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension' => [['0299']], + 'PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension' => [['0300']], + 'PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension' => [['0301']], + 'PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension' => [['0302']], + 'PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension' => [['0303']], + 'PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension' => [['0304']], + 'PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension' => [['0305']], + 'PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension' => [['0306']], + 'PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension' => [['0307']], + 'PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension' => [['0308']], + 'PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper' => [['0309']], + 'PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension' => [['0310']], + 'PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension' => [['0311']], + 'PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension' => [['0312']], + 'PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension' => [['0313']], + 'PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension' => [['0314']], + 'PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension' => [['0315']], + 'PHPStan\Type\Php\StrTokFunctionReturnTypeExtension' => [['0316']], + 'PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension' => [['0317']], + 'PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension' => [['0318']], + 'PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension' => [['0319']], + 'PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension' => [['0320']], + 'PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension' => [['0321']], + 'PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension' => [['0322', '0323', '0324', '0325', '0326']], + 'PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension' => [['0327']], + 'PHPStan\Type\ClosureTypeFactory' => [['0328']], + 'PHPStan\Type\Constant\OversizedArrayBuilder' => [['0329']], + 'PHPStan\Rules\Functions\PrintfHelper' => [['0330']], + 'PHPStan\Analyser\TypeSpecifier' => [['typeSpecifier']], + 'PHPStan\Analyser\TypeSpecifierFactory' => [['typeSpecifierFactory']], + 'PHPStan\File\RelativePathHelper' => [ + 0 => ['relativePathHelper'], + 2 => [1 => 'simpleRelativePathHelper', 'parentDirectoryRelativePathHelper'], + ], + 'PHPStan\File\ParentDirectoryRelativePathHelper' => [2 => ['parentDirectoryRelativePathHelper']], + 'PHPStan\Reflection\ReflectionProvider' => [['reflectionProvider'], ['broker'], [2 => 'betterReflectionProvider']], + 'PHPStan\Broker\Broker' => [['broker']], + 'PHPStan\Broker\BrokerFactory' => [['brokerFactory']], + 'PHPStan\Cache\CacheStorage' => [2 => ['cacheStorage']], + 'PHPStan\Cache\FileCacheStorage' => [2 => ['cacheStorage']], + 'PHPStan\Parser\Parser' => [ + 2 => [ + 'currentPhpVersionRichParser', + 'currentPhpVersionSimpleParser', + 'currentPhpVersionSimpleDirectParser', + 'defaultAnalysisParser', + 'php8Parser', + 'pathRoutingParser', + ], + ], + 'PHPStan\Parser\RichParser' => [2 => ['currentPhpVersionRichParser']], + 'PHPStan\Parser\CleaningParser' => [2 => ['currentPhpVersionSimpleParser']], + 'PHPStan\Parser\SimpleParser' => [2 => ['currentPhpVersionSimpleDirectParser', 'php8Parser']], + 'PHPStan\Parser\CachedParser' => [2 => ['defaultAnalysisParser']], + 'PhpParser\Parser' => [2 => ['phpParserDecorator', 'currentPhpVersionPhpParser', 'php8PhpParser']], + 'PHPStan\Parser\PhpParserDecorator' => [2 => ['phpParserDecorator']], + 'PhpParser\Lexer' => [2 => ['currentPhpVersionLexer', 'php8Lexer']], + 'PhpParser\ParserAbstract' => [2 => ['currentPhpVersionPhpParser', 'php8PhpParser']], + 'PhpParser\Parser\Php7' => [2 => ['currentPhpVersionPhpParser', 'php8PhpParser']], + 'PHPStan\Rules\Registry' => [['registry']], + 'PHPStan\Rules\LazyRegistry' => [['registry']], + 'PHPStan\PhpDoc\StubPhpDocProvider' => [['stubPhpDocProvider']], + 'PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory' => [['reflectionProviderFactory']], + 'PHPStan\BetterReflection\SourceLocator\Type\SourceLocator' => [2 => ['betterReflectionSourceLocator']], + 'PHPStan\BetterReflection\Reflector\Reflector' => [ + 0 => ['originalBetterReflectionReflector'], + 2 => [ + 1 => 'betterReflectionReflector', + 'betterReflectionClassReflector', + 'betterReflectionFunctionReflector', + 'betterReflectionConstantReflector', + 'nodeScopeResolverReflector', + ], + ], + 'PHPStan\BetterReflection\Reflector\DefaultReflector' => [['originalBetterReflectionReflector']], + 'PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector' => [ + 2 => ['betterReflectionReflector', 'nodeScopeResolverReflector'], + ], + 'PHPStan\BetterReflection\Reflector\ClassReflector' => [2 => ['betterReflectionClassReflector']], + 'PHPStan\BetterReflection\Reflector\FunctionReflector' => [2 => ['betterReflectionFunctionReflector']], + 'PHPStan\BetterReflection\Reflector\ConstantReflector' => [2 => ['betterReflectionConstantReflector']], + 'PHPStan\Reflection\BetterReflection\BetterReflectionProvider' => [2 => ['betterReflectionProvider']], + 'PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory' => [['0331']], + 'PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory' => [['0332']], + 'PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory' => [['0333']], + 'PHPStan\BetterReflection\SourceLocator\SourceStubber\SourceStubber' => [1 => ['0334', '0335']], + 'PHPStan\BetterReflection\SourceLocator\SourceStubber\PhpStormStubsSourceStubber' => [['0334']], + 'PHPStan\BetterReflection\SourceLocator\SourceStubber\ReflectionSourceStubber' => [['0335']], + 'PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory' => [['0336']], + 'PhpParser\Lexer\Emulative' => [2 => ['php8Lexer']], + 'PHPStan\Parser\PathRoutingParser' => [2 => ['pathRoutingParser']], + 'PHPStan\Diagnose\PHPStanDiagnoseExtension' => [2 => ['phpstanDiagnoseExtension']], + 'PHPStan\Command\ErrorFormatter\ErrorFormatter' => [ + [ + 'errorFormatter.raw', + 'errorFormatter.table', + 'errorFormatter.checkstyle', + 'errorFormatter.json', + 'errorFormatter.junit', + 'errorFormatter.prettyJson', + 'errorFormatter.gitlab', + 'errorFormatter.github', + 'errorFormatter.teamcity', + ], + ['0337'], + ], + 'PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter' => [['0337']], + 'PHPStan\Command\ErrorFormatter\RawErrorFormatter' => [['errorFormatter.raw']], + 'PHPStan\Command\ErrorFormatter\TableErrorFormatter' => [['errorFormatter.table']], + 'PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter' => [['errorFormatter.checkstyle']], + 'PHPStan\Command\ErrorFormatter\JsonErrorFormatter' => [['errorFormatter.json', 'errorFormatter.prettyJson']], + 'PHPStan\Command\ErrorFormatter\JunitErrorFormatter' => [['errorFormatter.junit']], + 'PHPStan\Command\ErrorFormatter\GitlabErrorFormatter' => [['errorFormatter.gitlab']], + 'PHPStan\Command\ErrorFormatter\GithubErrorFormatter' => [['errorFormatter.github']], + 'PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter' => [['errorFormatter.teamcity']], + 'PHPStan\Rules\Api\ApiClassConstFetchRule' => [['0338']], + 'PHPStan\Rules\Api\ApiInstanceofRule' => [['0339']], + 'PHPStan\Rules\Api\ApiInstanceofTypeRule' => [['0340']], + 'PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule' => [['0341']], + 'PHPStan\Rules\Api\RuntimeReflectionFunctionRule' => [['0342']], + 'PHPStan\Rules\Api\RuntimeReflectionInstantiationRule' => [['0343']], + 'PHPStan\Rules\Classes\ExistingClassInClassExtendsRule' => [['0344']], + 'PHPStan\Rules\Classes\ExistingClassInInstanceOfRule' => [['0345']], + 'PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule' => [['0346']], + 'PHPStan\Rules\Functions\CallToNonExistentFunctionRule' => [['0347']], + 'PHPStan\Rules\Constants\OverridingConstantRule' => [['0348']], + 'PHPStan\Rules\Methods\OverridingMethodRule' => [['0349']], + 'PHPStan\Rules\Methods\ConsistentConstructorRule' => [['0350']], + 'PHPStan\Rules\Missing\MissingReturnRule' => [['0351']], + 'PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule' => [['0352']], + 'PHPStan\Rules\Namespaces\ExistingNamesInUseRule' => [['0353']], + 'PHPStan\Rules\Operators\InvalidIncDecOperationRule' => [['0354']], + 'PHPStan\Rules\Properties\AccessPropertiesRule' => [['0355']], + 'PHPStan\Rules\Properties\AccessStaticPropertiesRule' => [['0356']], + 'PHPStan\Rules\Properties\ExistingClassesInPropertiesRule' => [['0357']], + 'PHPStan\Rules\Functions\FunctionCallableRule' => [['0358']], + 'PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule' => [['0359']], + 'PHPStan\Rules\Properties\OverridingPropertyRule' => [['0360']], + 'PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule' => [['0361']], + 'PHPStan\Rules\Properties\UninitializedPropertyRule' => [['0362']], + 'PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule' => [['0363']], + 'PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule' => [['0364']], + 'PHPStan\Rules\Variables\CompactVariablesRule' => [['0365']], + 'PHPStan\Rules\Variables\DefinedVariableRule' => [['0366']], + 'PHPStan\Rules\Regexp\RegularExpressionPatternRule' => [['0367']], + 'PHPStan\Reflection\ConstructorsHelper' => [['0368']], + 'PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule' => [['0369']], + 'PHPStan\Rules\Constants\MagicConstantContextRule' => [['0370']], + 'PHPStan\Rules\Functions\UselessFunctionReturnValueRule' => [['0371']], + 'PHPStan\Rules\Functions\PrintfArrayParametersRule' => [['0372']], + 'PHPStan\Rules\Regexp\RegularExpressionQuotingRule' => [['0373']], + 'PHPStan\Rules\Classes\MixinRule' => [['0374']], + 'PHPStan\Rules\Classes\MethodTagRule' => [['0375']], + 'PHPStan\Rules\Classes\MethodTagTraitRule' => [['0376']], + 'PHPStan\Rules\Classes\PropertyTagRule' => [['0377']], + 'PHPStan\Rules\Classes\PropertyTagTraitRule' => [['0378']], + 'PHPStan\Rules\PhpDoc\RequireExtendsCheck' => [['0379']], + 'PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule' => [['0380']], + 'PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule' => [['0381']], + 'PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule' => [['0382']], + 'PHPStan\Rules\Functions\CallCallablesRule' => [['0383']], + 'PHPStan\Rules\Methods\IllegalConstructorMethodCallRule' => [['0384']], + 'PHPStan\Rules\Methods\IllegalConstructorStaticCallRule' => [['0385']], + 'PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule' => [['0386']], + 'PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule' => [['0387']], + 'PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule' => [['0388']], + 'PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule' => [['0389']], + 'PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule' => [['0390']], + 'PHPStan\Rules\Generics\PropertyVarianceRule' => [['0391']], + 'PHPStan\Rules\Pure\PureFunctionRule' => [['0392']], + 'PHPStan\Rules\Pure\PureMethodRule' => [['0393']], + 'PHPStan\Rules\Operators\InvalidBinaryOperationRule' => [['0394']], + 'PHPStan\Rules\Operators\InvalidUnaryOperationRule' => [['0395']], + 'PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule' => [['0396']], + 'PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule' => [['0397']], + 'PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule' => [['0398']], + 'PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule' => [['0399']], + 'PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule' => [['0400']], + 'PHPStan\Rules\Generators\YieldFromTypeRule' => [['0401']], + 'PHPStan\Rules\Generators\YieldInGeneratorRule' => [['0402']], + 'PHPStan\Rules\Arrays\ArrayUnpackingRule' => [['0403']], + 'PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule' => [['0404']], + 'PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule' => [['0405']], + 'PHPStan\Rules\Variables\ParameterOutAssignedTypeRule' => [['0406']], + 'PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule' => [['0407']], + 'PHPStan\Rules\Classes\ImpossibleInstanceOfRule' => [['0408']], + 'PHPStan\Rules\Comparison\BooleanAndConstantConditionRule' => [['0409']], + 'PHPStan\Rules\Comparison\BooleanOrConstantConditionRule' => [['0410']], + 'PHPStan\Rules\Comparison\BooleanNotConstantConditionRule' => [['0411']], + 'PHPStan\Rules\DeadCode\NoopRule' => [['0412']], + 'PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule' => [['0413']], + 'PHPStan\Collectors\Collector' => [['0414', '0415', '0417', '0418', '0420', '0421', '0423', '0445', '0446']], + 'PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector' => [['0414']], + 'PHPStan\Rules\DeadCode\PossiblyPureNewCollector' => [['0415']], + 'PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule' => [['0416']], + 'PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector' => [['0417']], + 'PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector' => [['0418']], + 'PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule' => [['0419']], + 'PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector' => [['0420']], + 'PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector' => [['0421']], + 'PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule' => [['0422']], + 'PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector' => [['0423']], + 'PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule' => [['0424']], + 'PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule' => [['0425']], + 'PHPStan\Rules\Comparison\ElseIfConstantConditionRule' => [['0426']], + 'PHPStan\Rules\Comparison\IfConstantConditionRule' => [['0427']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule' => [['0428']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule' => [['0429']], + 'PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule' => [['0430']], + 'PHPStan\Rules\Comparison\LogicalXorConstantConditionRule' => [['0431']], + 'PHPStan\Rules\DeadCode\BetterNoopRule' => [['0432']], + 'PHPStan\Rules\Comparison\MatchExpressionRule' => [['0433']], + 'PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule' => [['0434']], + 'PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule' => [['0435']], + 'PHPStan\Rules\Comparison\ConstantLooseComparisonRule' => [['0436']], + 'PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule' => [['0437']], + 'PHPStan\Rules\Comparison\UnreachableIfBranchesRule' => [['0438']], + 'PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule' => [['0439']], + 'PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule' => [['0440']], + 'PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule' => [['0441']], + 'PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule' => [['0442']], + 'PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule' => [['0443']], + 'PHPStan\Rules\Properties\NullsafePropertyFetchRule' => [['0444']], + 'PHPStan\Rules\Traits\TraitDeclarationCollector' => [['0445']], + 'PHPStan\Rules\Traits\TraitUseCollector' => [['0446']], + 'PHPStan\Rules\Traits\NotAnalysedTraitRule' => [['0447']], + 'PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule' => [['0448']], + 'PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule' => [['0449']], + 'PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule' => [['0450']], + 'PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule' => [['0451']], + 'PHPStan\Rules\Functions\RandomIntParametersRule' => [['0452']], + 'PHPStan\Rules\Functions\ArrayFilterRule' => [['0453']], + 'PHPStan\Rules\Functions\ArrayValuesRule' => [['0454']], + 'PHPStan\Rules\Functions\CallUserFuncRule' => [['0455']], + 'PHPStan\Rules\Functions\ImplodeFunctionRule' => [['0456']], + 'PHPStan\Rules\Functions\ParameterCastableToStringRule' => [['0457']], + 'PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule' => [['0458']], + 'PHPStan\Rules\Functions\SortParameterCastableToStringRule' => [['0459']], + 'PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule' => [['0460']], + 'PHPStan\Rules\Methods\MissingMethodParameterTypehintRule' => [['0461']], + 'PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule' => [['0462']], + ]; + + + public function __construct(array $params = []) + { + parent::__construct($params); + } + + + public function createService01(): PhpParser\BuilderFactory + { + return new PhpParser\BuilderFactory; + } + + + public function createService02(): PHPStan\Parser\LexerFactory + { + return new PHPStan\Parser\LexerFactory($this->getService('023')); + } + + + public function createService03(): PhpParser\NodeVisitor\NameResolver + { + return new PhpParser\NodeVisitor\NameResolver(options: ['preserveOriginalNames' => true]); + } + + + public function createService04(): PHPStan\Parser\AnonymousClassVisitor + { + return new PHPStan\Parser\AnonymousClassVisitor; + } + + + public function createService05(): PHPStan\Parser\ArrayFilterArgVisitor + { + return new PHPStan\Parser\ArrayFilterArgVisitor; + } + + + public function createService06(): PHPStan\Parser\ArrayMapArgVisitor + { + return new PHPStan\Parser\ArrayMapArgVisitor; + } + + + public function createService07(): PHPStan\Parser\ArrayWalkArgVisitor + { + return new PHPStan\Parser\ArrayWalkArgVisitor; + } + + + public function createService08(): PHPStan\Parser\ClosureArgVisitor + { + return new PHPStan\Parser\ClosureArgVisitor; + } + + + public function createService09(): PHPStan\Parser\ClosureBindToVarVisitor + { + return new PHPStan\Parser\ClosureBindToVarVisitor; + } + + + public function createService010(): PHPStan\Parser\ClosureBindArgVisitor + { + return new PHPStan\Parser\ClosureBindArgVisitor; + } + + + public function createService011(): PHPStan\Parser\CurlSetOptArgVisitor + { + return new PHPStan\Parser\CurlSetOptArgVisitor; + } + + + public function createService012(): PHPStan\Parser\TypeTraverserInstanceofVisitor + { + return new PHPStan\Parser\TypeTraverserInstanceofVisitor; + } + + + public function createService013(): PHPStan\Parser\ArrowFunctionArgVisitor + { + return new PHPStan\Parser\ArrowFunctionArgVisitor; + } + + + public function createService014(): PHPStan\Parser\MagicConstantParamDefaultVisitor + { + return new PHPStan\Parser\MagicConstantParamDefaultVisitor; + } + + + public function createService015(): PHPStan\Parser\NewAssignedToPropertyVisitor + { + return new PHPStan\Parser\NewAssignedToPropertyVisitor; + } + + + public function createService016(): PHPStan\Parser\ParentStmtTypesVisitor + { + return new PHPStan\Parser\ParentStmtTypesVisitor; + } + + + public function createService017(): PHPStan\Parser\TryCatchTypeVisitor + { + return new PHPStan\Parser\TryCatchTypeVisitor; + } + + + public function createService018(): PHPStan\Parser\LastConditionVisitor + { + return new PHPStan\Parser\LastConditionVisitor; + } + + + public function createService019(): PhpParser\NodeVisitor\NodeConnectingVisitor + { + return new PhpParser\NodeVisitor\NodeConnectingVisitor; + } + + + public function createService020(): PHPStan\Node\Printer\ExprPrinter + { + return new PHPStan\Node\Printer\ExprPrinter($this->getService('021')); + } + + + public function createService021(): PHPStan\Node\Printer\Printer + { + return new PHPStan\Node\Printer\Printer; + } + + + public function createService022(): PHPStan\Broker\AnonymousClassNameHelper + { + return new PHPStan\Broker\AnonymousClassNameHelper($this->getService('078'), $this->getService('simpleRelativePathHelper')); + } + + + public function createService023(): PHPStan\Php\PhpVersion + { + return $this->getService('024')->create(); + } + + + public function createService024(): PHPStan\Php\PhpVersionFactory + { + return $this->getService('025')->create(); + } + + + public function createService025(): PHPStan\Php\PhpVersionFactoryFactory + { + return new PHPStan\Php\PhpVersionFactoryFactory(null, ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo']); + } + + + public function createService026(): PHPStan\PhpDocParser\Lexer\Lexer + { + return new PHPStan\PhpDocParser\Lexer\Lexer; + } + + + public function createService027(): PHPStan\PhpDocParser\Parser\TypeParser + { + return new PHPStan\PhpDocParser\Parser\TypeParser($this->getService('028'), false); + } + + + public function createService028(): PHPStan\PhpDocParser\Parser\ConstExprParser + { + return $this->getService('030')->create(); + } + + + public function createService029(): PHPStan\PhpDocParser\Parser\PhpDocParser + { + return new PHPStan\PhpDocParser\Parser\PhpDocParser( + $this->getService('027'), + $this->getService('028'), + false, + true, + ['lines' => false] + ); + } + + + public function createService030(): PHPStan\PhpDoc\ConstExprParserFactory + { + return new PHPStan\PhpDoc\ConstExprParserFactory(false); + } + + + public function createService031(): PHPStan\PhpDoc\PhpDocInheritanceResolver + { + return new PHPStan\PhpDoc\PhpDocInheritanceResolver($this->getService('0166'), $this->getService('stubPhpDocProvider')); + } + + + public function createService032(): PHPStan\PhpDoc\PhpDocNodeResolver + { + return new PHPStan\PhpDoc\PhpDocNodeResolver($this->getService('035'), $this->getService('034'), $this->getService('0155')); + } + + + public function createService033(): PHPStan\PhpDoc\PhpDocStringResolver + { + return new PHPStan\PhpDoc\PhpDocStringResolver($this->getService('026'), $this->getService('029')); + } + + + public function createService034(): PHPStan\PhpDoc\ConstExprNodeResolver + { + return new PHPStan\PhpDoc\ConstExprNodeResolver($this->getService('0110'), $this->getService('088')); + } + + + public function createService035(): PHPStan\PhpDoc\TypeNodeResolver + { + return new PHPStan\PhpDoc\TypeNodeResolver( + $this->getService('036'), + $this->getService('0110'), + $this->getService('0168'), + $this->getService('054'), + $this->getService('088') + ); + } + + + public function createService036(): PHPStan\PhpDoc\TypeNodeResolverExtensionRegistryProvider + { + return new PHPStan\PhpDoc\LazyTypeNodeResolverExtensionRegistryProvider($this->getService('068')); + } + + + public function createService037(): PHPStan\PhpDoc\TypeStringResolver + { + return new PHPStan\PhpDoc\TypeStringResolver($this->getService('026'), $this->getService('027'), $this->getService('035')); + } + + + public function createService038(): PHPStan\PhpDoc\StubValidator + { + return new PHPStan\PhpDoc\StubValidator($this->getService('070'), false); + } + + + public function createService039(): PHPStan\PhpDoc\CountableStubFilesExtension + { + return new PHPStan\PhpDoc\CountableStubFilesExtension(false); + } + + + public function createService040(): PHPStan\PhpDoc\SocketSelectStubFilesExtension + { + return new PHPStan\PhpDoc\SocketSelectStubFilesExtension($this->getService('023')); + } + + + public function createService041(): PHPStan\PhpDoc\DefaultStubFilesProvider + { + return new PHPStan\PhpDoc\DefaultStubFilesProvider( + $this->getService('068'), + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionAttribute.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClass.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClassConstant.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionFunctionAbstract.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionMethod.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionParameter.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionProperty.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/iterable.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ArrayObject.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/WeakReference.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ext-ds.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ImagickPixel.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/PDOStatement.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/date.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ibm_db2.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/mysqli.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/zip.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/dom.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/spl.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/SplObjectStorage.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/Exception.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/arrayFunctions.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/core.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/typeCheckingFunctions.stub', + ], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'] + ); + } + + + public function createService042(): PHPStan\PhpDoc\JsonValidateStubFilesExtension + { + return new PHPStan\PhpDoc\JsonValidateStubFilesExtension($this->getService('023')); + } + + + public function createService043(): PHPStan\PhpDoc\ReflectionEnumStubFilesExtension + { + return new PHPStan\PhpDoc\ReflectionEnumStubFilesExtension($this->getService('023')); + } + + + public function createService044(): PHPStan\Analyser\Analyser + { + return new PHPStan\Analyser\Analyser( + $this->getService('046'), + $this->getService('registry'), + $this->getService('059'), + $this->getService('053'), + 50 + ); + } + + + public function createService045(): PHPStan\Analyser\AnalyserResultFinalizer + { + return new PHPStan\Analyser\AnalyserResultFinalizer( + $this->getService('registry'), + $this->getService('048'), + $this->getService('052'), + $this->getService('047'), + true + ); + } + + + public function createService046(): PHPStan\Analyser\FileAnalyser + { + return new PHPStan\Analyser\FileAnalyser( + $this->getService('052'), + $this->getService('053'), + $this->getService('defaultAnalysisParser'), + $this->getService('064'), + $this->getService('048'), + $this->getService('047') + ); + } + + + public function createService047(): PHPStan\Analyser\LocalIgnoresProcessor + { + return new PHPStan\Analyser\LocalIgnoresProcessor; + } + + + public function createService048(): PHPStan\Analyser\RuleErrorTransformer + { + return new PHPStan\Analyser\RuleErrorTransformer; + } + + + public function createService049(): PHPStan\Analyser\Ignore\IgnoredErrorHelper + { + return new PHPStan\Analyser\Ignore\IgnoredErrorHelper($this->getService('078'), [], true); + } + + + public function createService050(): PHPStan\Analyser\Ignore\IgnoreLexer + { + return new PHPStan\Analyser\Ignore\IgnoreLexer; + } + + + public function createService051(): PHPStan\Analyser\LazyInternalScopeFactory + { + return new PHPStan\Analyser\LazyInternalScopeFactory('PHPStan\Analyser\MutatingScope', $this->getService('068')); + } + + + public function createService052(): PHPStan\Analyser\ScopeFactory + { + return new PHPStan\Analyser\ScopeFactory($this->getService('051')); + } + + + public function createService053(): PHPStan\Analyser\NodeScopeResolver + { + return new PHPStan\Analyser\NodeScopeResolver( + $this->getService('reflectionProvider'), + $this->getService('088'), + $this->getService('nodeScopeResolverReflector'), + $this->getService('071'), + $this->getService('073'), + $this->getService('defaultAnalysisParser'), + $this->getService('0166'), + $this->getService('stubPhpDocProvider'), + $this->getService('023'), + $this->getService('0116'), + $this->getService('031'), + $this->getService('078'), + $this->getService('typeSpecifier'), + $this->getService('076'), + $this->getService('0159'), + $this->getService('077'), + $this->getService('052'), + true, + true, + [], + [], + ['stdClass'], + true, + true, + false, + false, + false, + false + ); + } + + + public function createService054(): PHPStan\Analyser\ConstantResolver + { + return $this->getService('055')->create(); + } + + + public function createService055(): PHPStan\Analyser\ConstantResolverFactory + { + return new PHPStan\Analyser\ConstantResolverFactory($this->getService('0110'), $this->getService('068')); + } + + + public function createService056(): PHPStan\Analyser\ResultCache\ResultCacheManagerFactory + { + return new class ($this) implements PHPStan\Analyser\ResultCache\ResultCacheManagerFactory { + private $container; + + + public function __construct(Container_9e7071f660 $container) + { + $this->container = $container; + } + + + public function create(): PHPStan\Analyser\ResultCache\ResultCacheManager + { + return new PHPStan\Analyser\ResultCache\ResultCacheManager( + $this->container->getService('065'), + $this->container->getService('fileFinderScan'), + $this->container->getService('reflectionProvider'), + $this->container->getService('041'), + $this->container->getService('078'), + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCache.php', + $this->container->getParameter('analysedPaths'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + '9', + null, + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionUnionType.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionAttribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/Attribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionIntersectionType.php', + ], + [], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php'], + false + ); + } + }; + } + + + public function createService057(): PHPStan\Analyser\ResultCache\ResultCacheClearer + { + return new PHPStan\Analyser\ResultCache\ResultCacheClearer('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCache.php'); + } + + + public function createService058(): PHPStan\Cache\Cache + { + return new PHPStan\Cache\Cache($this->getService('cacheStorage')); + } + + + public function createService059(): PHPStan\Collectors\Registry + { + return $this->getService('060')->create(); + } + + + public function createService060(): PHPStan\Collectors\RegistryFactory + { + return new PHPStan\Collectors\RegistryFactory($this->getService('068')); + } + + + public function createService061(): PHPStan\Command\AnalyseApplication + { + return new PHPStan\Command\AnalyseApplication( + $this->getService('062'), + $this->getService('045'), + $this->getService('038'), + $this->getService('056'), + $this->getService('049'), + $this->getService('041') + ); + } + + + public function createService062(): PHPStan\Command\AnalyserRunner + { + return new PHPStan\Command\AnalyserRunner( + $this->getService('084'), + $this->getService('044'), + $this->getService('083'), + $this->getService('086') + ); + } + + + public function createService063(): PHPStan\Command\FixerApplication + { + return new PHPStan\Command\FixerApplication( + $this->getService('081'), + $this->getService('049'), + $this->getService('041'), + $this->getParameter('analysedPaths'), + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + ($this->getParameter('sysGetTempDir')) . '/phpstan-fixer', + ['1.1.1.2'], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/phpstan.neon', + ], + null, + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionUnionType.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionAttribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/Attribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionIntersectionType.php', + ], + null, + '9' + ); + } + + + public function createService064(): PHPStan\Dependency\DependencyResolver + { + return new PHPStan\Dependency\DependencyResolver( + $this->getService('078'), + $this->getService('reflectionProvider'), + $this->getService('066'), + $this->getService('0166') + ); + } + + + public function createService065(): PHPStan\Dependency\ExportedNodeFetcher + { + return new PHPStan\Dependency\ExportedNodeFetcher($this->getService('defaultAnalysisParser'), $this->getService('067')); + } + + + public function createService066(): PHPStan\Dependency\ExportedNodeResolver + { + return new PHPStan\Dependency\ExportedNodeResolver($this->getService('0166'), $this->getService('020')); + } + + + public function createService067(): PHPStan\Dependency\ExportedNodeVisitor + { + return new PHPStan\Dependency\ExportedNodeVisitor($this->getService('066')); + } + + + public function createService068(): PHPStan\DependencyInjection\Container + { + return new PHPStan\DependencyInjection\MemoizingContainer($this->getService('069')); + } + + + public function createService069(): PHPStan\DependencyInjection\Nette\NetteContainer + { + return new PHPStan\DependencyInjection\Nette\NetteContainer($this); + } + + + public function createService070(): PHPStan\DependencyInjection\DerivativeContainerFactory + { + return new PHPStan\DependencyInjection\DerivativeContainerFactory( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan', + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/phpstan.neon', + ], + $this->getParameter('analysedPaths'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + $this->getParameter('analysedPathsFromConfig'), + '9', + null, + null + ); + } + + + public function createService071(): PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Reflection\LazyClassReflectionExtensionRegistryProvider($this->getService('068')); + } + + + public function createService072(): PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Type\LazyDynamicReturnTypeExtensionRegistryProvider($this->getService('068')); + } + + + public function createService073(): PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider + { + return new PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider($this->getService('068')); + } + + + public function createService074(): PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Type\LazyExpressionTypeResolverExtensionRegistryProvider($this->getService('068')); + } + + + public function createService075(): PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider + { + return new PHPStan\DependencyInjection\Type\LazyOperatorTypeSpecifyingExtensionRegistryProvider($this->getService('068')); + } + + + public function createService076(): PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider + { + return new PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider($this->getService('068')); + } + + + public function createService077(): PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider + { + return new PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider($this->getService('068')); + } + + + public function createService078(): PHPStan\File\FileHelper + { + return new PHPStan\File\FileHelper('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'); + } + + + public function createService079(): PHPStan\File\FileExcluderFactory + { + return new PHPStan\File\FileExcluderFactory($this->getService('080'), [], null); + } + + + public function createService080(): PHPStan\File\FileExcluderRawFactory + { + return new class ($this) implements PHPStan\File\FileExcluderRawFactory { + private $container; + + + public function __construct(Container_9e7071f660 $container) + { + $this->container = $container; + } + + + public function create(array $analyseExcludes): PHPStan\File\FileExcluder + { + return new PHPStan\File\FileExcluder($this->container->getService('078'), $analyseExcludes, false); + } + }; + } + + + public function createService081(): PHPStan\File\FileMonitor + { + return new PHPStan\File\FileMonitor($this->getService('fileFinderAnalyse')); + } + + + public function createService082(): PHPStan\Parser\DeclarePositionVisitor + { + return new PHPStan\Parser\DeclarePositionVisitor; + } + + + public function createService083(): PHPStan\Parallel\ParallelAnalyser + { + return new PHPStan\Parallel\ParallelAnalyser(50, 600.0, 134217728); + } + + + public function createService084(): PHPStan\Parallel\Scheduler + { + return new PHPStan\Parallel\Scheduler(20, 32, 2); + } + + + public function createService085(): PHPStan\Parser\FunctionCallStatementFinder + { + return new PHPStan\Parser\FunctionCallStatementFinder; + } + + + public function createService086(): PHPStan\Process\CpuCoreCounter + { + return new PHPStan\Process\CpuCoreCounter; + } + + + public function createService087(): PHPStan\Reflection\FunctionReflectionFactory + { + return new class ($this) implements PHPStan\Reflection\FunctionReflectionFactory { + private $container; + + + public function __construct(Container_9e7071f660 $container) + { + $this->container = $container; + } + + + public function create( + PHPStan\BetterReflection\Reflection\Adapter\ReflectionFunction $reflection, + PHPStan\Type\Generic\TemplateTypeMap $templateTypeMap, + array $phpDocParameterTypes, + ?PHPStan\Type\Type $phpDocReturnType, + ?PHPStan\Type\Type $phpDocThrowType, + ?string $deprecatedDescription, + bool $isDeprecated, + bool $isInternal, + bool $isFinal, + ?string $filename, + ?bool $isPure, + PHPStan\Reflection\Assertions $asserts, + bool $acceptsNamedArguments, + ?string $phpDocComment, + array $phpDocParameterOutTypes, + array $phpDocParameterImmediatelyInvokedCallable, + array $phpDocParameterClosureThisTypes + ): PHPStan\Reflection\Php\PhpFunctionReflection { + return new PHPStan\Reflection\Php\PhpFunctionReflection( + $this->container->getService('088'), + $reflection, + $this->container->getService('defaultAnalysisParser'), + $this->container->getService('085'), + $this->container->getService('058'), + $templateTypeMap, + $phpDocParameterTypes, + $phpDocReturnType, + $phpDocThrowType, + $deprecatedDescription, + $isDeprecated, + $isInternal, + $isFinal, + $filename, + $isPure, + $asserts, + $acceptsNamedArguments, + $phpDocComment, + $phpDocParameterOutTypes, + $phpDocParameterImmediatelyInvokedCallable, + $phpDocParameterClosureThisTypes + ); + } + }; + } + + + public function createService088(): PHPStan\Reflection\InitializerExprTypeResolver + { + return new PHPStan\Reflection\InitializerExprTypeResolver( + $this->getService('054'), + $this->getService('0110'), + $this->getService('023'), + $this->getService('075'), + $this->getService('0329'), + false + ); + } + + + public function createService089(): PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension + { + return new PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension; + } + + + public function createService090(): PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension + { + return new PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension; + } + + + public function createService091(): PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor; + } + + + public function createService092(): PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher( + $this->getService('091'), + $this->getService('defaultAnalysisParser') + ); + } + + + public function createService093(): PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker( + $this->getService('095'), + $this->getService('096'), + $this->getService('094'), + $this->getService('023') + ); + } + + + public function createService094(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory( + $this->getService('092'), + $this->getService('fileFinderScan'), + $this->getService('023'), + $this->getService('058') + ); + } + + + public function createService095(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository($this->getService('094')); + } + + + public function createService096(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory + { + return new class ($this) implements PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory { + private $container; + + + public function __construct(Container_9e7071f660 $container) + { + $this->container = $container; + } + + + public function create(PHPStan\BetterReflection\SourceLocator\Type\Composer\Psr\PsrAutoloaderMapping $mapping): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator($mapping, $this->container->getService('098')); + } + }; + } + + + public function createService097(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory + { + return new class ($this) implements PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory { + private $container; + + + public function __construct(Container_9e7071f660 $container) + { + $this->container = $container; + } + + + public function create(string $fileName): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator( + $this->container->getService('092'), + $fileName + ); + } + }; + } + + + public function createService098(): PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository + { + return new PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository($this->getService('097')); + } + + + public function createService099(): PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension + { + return new PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension; + } + + + public function createService0100(): PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension + { + return new PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension; + } + + + public function createService0101(): PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension + { + return new PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension([]); + } + + + public function createService0102(): PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension + { + return new PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension([]); + } + + + public function createService0103(): PHPStan\Reflection\Php\PhpClassReflectionExtension + { + return new PHPStan\Reflection\Php\PhpClassReflectionExtension( + $this->getService('052'), + $this->getService('053'), + $this->getService('0104'), + $this->getService('031'), + $this->getService('089'), + $this->getService('090'), + $this->getService('0116'), + $this->getService('defaultAnalysisParser'), + $this->getService('stubPhpDocProvider'), + $this->getService('0110'), + $this->getService('0166'), + false + ); + } + + + public function createService0104(): PHPStan\Reflection\Php\PhpMethodReflectionFactory + { + return new class ($this) implements PHPStan\Reflection\Php\PhpMethodReflectionFactory { + private $container; + + + public function __construct(Container_9e7071f660 $container) + { + $this->container = $container; + } + + + public function create( + PHPStan\Reflection\ClassReflection $declaringClass, + ?PHPStan\Reflection\ClassReflection $declaringTrait, + PHPStan\Reflection\Php\BuiltinMethodReflection $reflection, + PHPStan\Type\Generic\TemplateTypeMap $templateTypeMap, + array $phpDocParameterTypes, + ?PHPStan\Type\Type $phpDocReturnType, + ?PHPStan\Type\Type $phpDocThrowType, + ?string $deprecatedDescription, + bool $isDeprecated, + bool $isInternal, + bool $isFinal, + ?bool $isPure, + PHPStan\Reflection\Assertions $asserts, + ?PHPStan\Type\Type $selfOutType, + ?string $phpDocComment, + array $phpDocParameterOutTypes, + array $immediatelyInvokedCallableParameters = [], + array $phpDocClosureThisTypeParameters = [], + bool $acceptsNamedArguments = true + ): PHPStan\Reflection\Php\PhpMethodReflection { + return new PHPStan\Reflection\Php\PhpMethodReflection( + $this->container->getService('088'), + $declaringClass, + $declaringTrait, + $reflection, + $this->container->getService('reflectionProvider'), + $this->container->getService('defaultAnalysisParser'), + $this->container->getService('085'), + $this->container->getService('058'), + $templateTypeMap, + $phpDocParameterTypes, + $phpDocReturnType, + $phpDocThrowType, + $deprecatedDescription, + $isDeprecated, + $isInternal, + $isFinal, + $isPure, + $asserts, + $acceptsNamedArguments, + $selfOutType, + $phpDocComment, + $phpDocParameterOutTypes, + $immediatelyInvokedCallableParameters, + $phpDocClosureThisTypeParameters + ); + } + }; + } + + + public function createService0105(): PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension + { + return new PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension; + } + + + public function createService0106(): PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension + { + return new PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension; + } + + + public function createService0107(): PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension + { + return new PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension( + $this->getService('reflectionProvider'), + ['stdClass'], + $this->getService('090') + ); + } + + + public function createService0108(): PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension + { + return new PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension( + $this->getService('023'), + 'PHPStan\Reflection\ClassReflection', + 'getNativeReflection' + ); + } + + + public function createService0109(): PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension + { + return new PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension( + $this->getService('023'), + 'PHPStan\Reflection\Php\BuiltinMethodReflection', + 'getDeclaringClass' + ); + } + + + public function createService0110(): PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider + { + return new PHPStan\Reflection\ReflectionProvider\LazyReflectionProviderProvider($this->getService('068')); + } + + + public function createService0111(): PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider + { + return new PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider( + $this->getService('0116'), + $this->getService('betterReflectionReflector'), + $this->getService('0166'), + $this->getService('stubPhpDocProvider') + ); + } + + + public function createService0112(): PHPStan\Reflection\SignatureMap\SignatureMapParser + { + return new PHPStan\Reflection\SignatureMap\SignatureMapParser($this->getService('037')); + } + + + public function createService0113(): PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider + { + return new PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider( + $this->getService('0112'), + $this->getService('088'), + $this->getService('023'), + false + ); + } + + + public function createService0114(): PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider + { + return new PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider( + $this->getService('0113'), + $this->getService('092'), + $this->getService('0166'), + $this->getService('023'), + $this->getService('088') + ); + } + + + public function createService0115(): PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory + { + return new PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory( + $this->getService('023'), + $this->getService('0113'), + $this->getService('0114') + ); + } + + + public function createService0116(): PHPStan\Reflection\SignatureMap\SignatureMapProvider + { + return $this->getService('0115')->create(); + } + + + public function createService0117(): PHPStan\Rules\Api\ApiRuleHelper + { + return new PHPStan\Rules\Api\ApiRuleHelper; + } + + + public function createService0118(): PHPStan\Rules\AttributesCheck + { + return new PHPStan\Rules\AttributesCheck( + $this->getService('reflectionProvider'), + $this->getService('0135'), + $this->getService('0120'), + false + ); + } + + + public function createService0119(): PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck + { + return new PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck($this->getService('0163'), true, false, false, false); + } + + + public function createService0120(): PHPStan\Rules\ClassNameCheck + { + return new PHPStan\Rules\ClassNameCheck($this->getService('0121'), $this->getService('0122')); + } + + + public function createService0121(): PHPStan\Rules\ClassCaseSensitivityCheck + { + return new PHPStan\Rules\ClassCaseSensitivityCheck($this->getService('reflectionProvider'), false); + } + + + public function createService0122(): PHPStan\Rules\ClassForbiddenNameCheck + { + return new PHPStan\Rules\ClassForbiddenNameCheck($this->getService('068')); + } + + + public function createService0123(): PHPStan\Rules\Classes\LocalTypeAliasesCheck + { + return new PHPStan\Rules\Classes\LocalTypeAliasesCheck( + [], + $this->getService('reflectionProvider'), + $this->getService('035'), + $this->getService('0149'), + $this->getService('0120'), + $this->getService('0155'), + $this->getService('0141'), + true, + true, + false + ); + } + + + public function createService0124(): PHPStan\Rules\Classes\MethodTagCheck + { + return new PHPStan\Rules\Classes\MethodTagCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true + ); + } + + + public function createService0125(): PHPStan\Rules\Classes\PropertyTagCheck + { + return new PHPStan\Rules\Classes\PropertyTagCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true + ); + } + + + public function createService0126(): PHPStan\Rules\Comparison\ConstantConditionRuleHelper + { + return new PHPStan\Rules\Comparison\ConstantConditionRuleHelper($this->getService('0127'), true, false); + } + + + public function createService0127(): PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper( + $this->getService('reflectionProvider'), + $this->getService('typeSpecifier'), + ['stdClass'], + true, + false + ); + } + + + public function createService0128(): PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver + { + return new PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver($this->getService('reflectionProvider'), [], [], [], []); + } + + + public function createService0129(): PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule + { + return new PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule($this->getService('0131')); + } + + + public function createService0130(): PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule + { + return new PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule($this->getService('0131')); + } + + + public function createService0131(): PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck + { + return new PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck($this->getService('exceptionTypeResolver')); + } + + + public function createService0132(): PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule + { + return new PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule($this->getService('0134')); + } + + + public function createService0133(): PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule + { + return new PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule($this->getService('0166'), $this->getService('0134')); + } + + + public function createService0134(): PHPStan\Rules\Exceptions\TooWideThrowTypeCheck + { + return new PHPStan\Rules\Exceptions\TooWideThrowTypeCheck; + } + + + public function createService0135(): PHPStan\Rules\FunctionCallParametersCheck + { + return new PHPStan\Rules\FunctionCallParametersCheck( + $this->getService('0163'), + $this->getService('0150'), + $this->getService('023'), + $this->getService('0155'), + $this->getService('0161'), + true, + true, + true, + true, + false + ); + } + + + public function createService0136(): PHPStan\Rules\FunctionDefinitionCheck + { + return new PHPStan\Rules\FunctionDefinitionCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0155'), + $this->getService('023'), + true, + false, + false + ); + } + + + public function createService0137(): PHPStan\Rules\FunctionReturnTypeCheck + { + return new PHPStan\Rules\FunctionReturnTypeCheck($this->getService('0163')); + } + + + public function createService0138(): PHPStan\Rules\ParameterCastableToStringCheck + { + return new PHPStan\Rules\ParameterCastableToStringCheck($this->getService('0163')); + } + + + public function createService0139(): PHPStan\Rules\Generics\CrossCheckInterfacesHelper + { + return new PHPStan\Rules\Generics\CrossCheckInterfacesHelper; + } + + + public function createService0140(): PHPStan\Rules\Generics\GenericAncestorsCheck + { + return new PHPStan\Rules\Generics\GenericAncestorsCheck( + $this->getService('reflectionProvider'), + $this->getService('0141'), + $this->getService('0143'), + $this->getService('0155'), + true, + [ + 'DatePeriod', + 'CallbackFilterIterator', + 'FilterIterator', + 'RecursiveCallbackFilterIterator', + 'AppendIterator', + 'NoRewindIterator', + 'LimitIterator', + 'InfiniteIterator', + 'CachingIterator', + 'RegexIterator', + 'ReflectionEnum', + ], + false + ); + } + + + public function createService0141(): PHPStan\Rules\Generics\GenericObjectTypeCheck + { + return new PHPStan\Rules\Generics\GenericObjectTypeCheck; + } + + + public function createService0142(): PHPStan\Rules\Generics\TemplateTypeCheck + { + return new PHPStan\Rules\Generics\TemplateTypeCheck( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0167'), + true + ); + } + + + public function createService0143(): PHPStan\Rules\Generics\VarianceCheck + { + return new PHPStan\Rules\Generics\VarianceCheck(false, false); + } + + + public function createService0144(): PHPStan\Rules\IssetCheck + { + return new PHPStan\Rules\IssetCheck($this->getService('0160'), $this->getService('0161'), true, true, false); + } + + + public function createService0145(): PHPStan\Rules\Methods\MethodCallCheck + { + return new PHPStan\Rules\Methods\MethodCallCheck( + $this->getService('reflectionProvider'), + $this->getService('0163'), + false, + true + ); + } + + + public function createService0146(): PHPStan\Rules\Methods\StaticMethodCallCheck + { + return new PHPStan\Rules\Methods\StaticMethodCallCheck( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('0120'), + false, + true + ); + } + + + public function createService0147(): PHPStan\Rules\Methods\MethodSignatureRule + { + return new PHPStan\Rules\Methods\MethodSignatureRule($this->getService('0103'), false, false, false); + } + + + public function createService0148(): PHPStan\Rules\Methods\MethodParameterComparisonHelper + { + return new PHPStan\Rules\Methods\MethodParameterComparisonHelper($this->getService('023'), false); + } + + + public function createService0149(): PHPStan\Rules\MissingTypehintCheck + { + return new PHPStan\Rules\MissingTypehintCheck( + false, + true, + true, + false, + [ + 'DatePeriod', + 'CallbackFilterIterator', + 'FilterIterator', + 'RecursiveCallbackFilterIterator', + 'AppendIterator', + 'NoRewindIterator', + 'LimitIterator', + 'InfiniteIterator', + 'CachingIterator', + 'RegexIterator', + 'ReflectionEnum', + ] + ); + } + + + public function createService0150(): PHPStan\Rules\NullsafeCheck + { + return new PHPStan\Rules\NullsafeCheck; + } + + + public function createService0151(): PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider + { + return new PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider($this->getService('068')); + } + + + public function createService0152(): PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider + { + return new PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider($this->getService('068')); + } + + + public function createService0153(): PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper + { + return new PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper; + } + + + public function createService0154(): PHPStan\Rules\PhpDoc\AssertRuleHelper + { + return new PHPStan\Rules\PhpDoc\AssertRuleHelper($this->getService('088')); + } + + + public function createService0155(): PHPStan\Rules\PhpDoc\UnresolvableTypeHelper + { + return new PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; + } + + + public function createService0156(): PHPStan\Rules\PhpDoc\GenericCallableRuleHelper + { + return new PHPStan\Rules\PhpDoc\GenericCallableRuleHelper($this->getService('0142')); + } + + + public function createService0157(): PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper + { + return new PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper(false, false); + } + + + public function createService0158(): PHPStan\Rules\Playground\NeverRuleHelper + { + return new PHPStan\Rules\Playground\NeverRuleHelper; + } + + + public function createService0159(): PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider + { + return new PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider($this->getService('068')); + } + + + public function createService0160(): PHPStan\Rules\Properties\PropertyDescriptor + { + return new PHPStan\Rules\Properties\PropertyDescriptor; + } + + + public function createService0161(): PHPStan\Rules\Properties\PropertyReflectionFinder + { + return new PHPStan\Rules\Properties\PropertyReflectionFinder; + } + + + public function createService0162(): PHPStan\Rules\Pure\FunctionPurityCheck + { + return new PHPStan\Rules\Pure\FunctionPurityCheck; + } + + + public function createService0163(): PHPStan\Rules\RuleLevelHelper + { + return new PHPStan\Rules\RuleLevelHelper($this->getService('reflectionProvider'), true, false, true, true, false, false, false); + } + + + public function createService0164(): PHPStan\Rules\UnusedFunctionParametersCheck + { + return new PHPStan\Rules\UnusedFunctionParametersCheck($this->getService('reflectionProvider')); + } + + + public function createService0165(): PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck + { + return new PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck; + } + + + public function createService0166(): PHPStan\Type\FileTypeMapper + { + return new PHPStan\Type\FileTypeMapper( + $this->getService('0110'), + $this->getService('defaultAnalysisParser'), + $this->getService('033'), + $this->getService('032'), + $this->getService('022'), + $this->getService('078') + ); + } + + + public function createService0167(): PHPStan\Type\TypeAliasResolver + { + return new PHPStan\Type\UsefulTypeAliasResolver( + [], + $this->getService('037'), + $this->getService('035'), + $this->getService('reflectionProvider') + ); + } + + + public function createService0168(): PHPStan\Type\TypeAliasResolverProvider + { + return new PHPStan\Type\LazyTypeAliasResolverProvider($this->getService('068')); + } + + + public function createService0169(): PHPStan\Type\BitwiseFlagHelper + { + return new PHPStan\Type\BitwiseFlagHelper($this->getService('reflectionProvider')); + } + + + public function createService0170(): PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension; + } + + + public function createService0171(): PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension; + } + + + public function createService0172(): PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0173(): PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0174(): PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0175(): PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0176(): PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension; + } + + + public function createService0177(): PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0178(): PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0179(): PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension; + } + + + public function createService0180(): PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0181(): PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension; + } + + + public function createService0182(): PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension; + } + + + public function createService0183(): PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension; + } + + + public function createService0184(): PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension; + } + + + public function createService0185(): PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0186(): PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension; + } + + + public function createService0187(): PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension; + } + + + public function createService0188(): PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension; + } + + + public function createService0189(): PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension; + } + + + public function createService0190(): PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension; + } + + + public function createService0191(): PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension; + } + + + public function createService0192(): PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension; + } + + + public function createService0193(): PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension; + } + + + public function createService0194(): PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension; + } + + + public function createService0195(): PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension; + } + + + public function createService0196(): PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension; + } + + + public function createService0197(): PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0198(): PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension; + } + + + public function createService0199(): PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0200(): PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension; + } + + + public function createService0201(): PHPStan\Type\Php\AssertThrowTypeExtension + { + return new PHPStan\Type\Php\AssertThrowTypeExtension; + } + + + public function createService0202(): PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension; + } + + + public function createService0203(): PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension; + } + + + public function createService0204(): PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension + { + return new PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension($this->getService('023')); + } + + + public function createService0205(): PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension; + } + + + public function createService0206(): PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension; + } + + + public function createService0207(): PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension; + } + + + public function createService0208(): PHPStan\Type\Php\CompactFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\CompactFunctionReturnTypeExtension(true); + } + + + public function createService0209(): PHPStan\Type\Php\ConstantFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ConstantFunctionReturnTypeExtension($this->getService('0210')); + } + + + public function createService0210(): PHPStan\Type\Php\ConstantHelper + { + return new PHPStan\Type\Php\ConstantHelper; + } + + + public function createService0211(): PHPStan\Type\Php\CountFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\CountFunctionReturnTypeExtension; + } + + + public function createService0212(): PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension; + } + + + public function createService0213(): PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0214(): PHPStan\Type\Php\CurlInitReturnTypeExtension + { + return new PHPStan\Type\Php\CurlInitReturnTypeExtension($this->getService('023')); + } + + + public function createService0215(): PHPStan\Type\Php\DateFunctionReturnTypeHelper + { + return new PHPStan\Type\Php\DateFunctionReturnTypeHelper; + } + + + public function createService0216(): PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension($this->getService('0215')); + } + + + public function createService0217(): PHPStan\Type\Php\DateFormatMethodReturnTypeExtension + { + return new PHPStan\Type\Php\DateFormatMethodReturnTypeExtension($this->getService('0215')); + } + + + public function createService0218(): PHPStan\Type\Php\DateFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\DateFunctionReturnTypeExtension($this->getService('0215')); + } + + + public function createService0219(): PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension($this->getService('023')); + } + + + public function createService0220(): PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension; + } + + + public function createService0221(): PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension; + } + + + public function createService0222(): PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension; + } + + + public function createService0223(): PHPStan\Type\Php\DateTimeModifyReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeModifyReturnTypeExtension($this->getService('023'), 'DateTime'); + } + + + public function createService0224(): PHPStan\Type\Php\DateTimeModifyReturnTypeExtension + { + return new PHPStan\Type\Php\DateTimeModifyReturnTypeExtension($this->getService('023'), 'DateTimeImmutable'); + } + + + public function createService0225(): PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension($this->getService('023')); + } + + + public function createService0226(): PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension + { + return new PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension($this->getService('023')); + } + + + public function createService0227(): PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension($this->getService('023')); + } + + + public function createService0228(): PHPStan\Type\Php\DsMapDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\DsMapDynamicReturnTypeExtension; + } + + + public function createService0229(): PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension + { + return new PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension; + } + + + public function createService0230(): PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension; + } + + + public function createService0231(): PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0232(): PHPStan\Type\Php\FilterFunctionReturnTypeHelper + { + return new PHPStan\Type\Php\FilterFunctionReturnTypeHelper($this->getService('reflectionProvider'), $this->getService('023')); + } + + + public function createService0233(): PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension($this->getService('0232')); + } + + + public function createService0234(): PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension($this->getService('0232')); + } + + + public function createService0235(): PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension( + $this->getService('0232'), + $this->getService('reflectionProvider') + ); + } + + + public function createService0236(): PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension; + } + + + public function createService0237(): PHPStan\Type\Php\GetClassDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\GetClassDynamicReturnTypeExtension; + } + + + public function createService0238(): PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension; + } + + + public function createService0239(): PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0240(): PHPStan\Type\Php\GettypeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GettypeFunctionReturnTypeExtension; + } + + + public function createService0241(): PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension; + } + + + public function createService0242(): PHPStan\Type\Php\HashFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\HashFunctionsReturnTypeExtension($this->getService('023')); + } + + + public function createService0243(): PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0244(): PHPStan\Type\Php\IntdivThrowTypeExtension + { + return new PHPStan\Type\Php\IntdivThrowTypeExtension; + } + + + public function createService0245(): PHPStan\Type\Php\IniGetReturnTypeExtension + { + return new PHPStan\Type\Php\IniGetReturnTypeExtension; + } + + + public function createService0246(): PHPStan\Type\Php\JsonThrowTypeExtension + { + return new PHPStan\Type\Php\JsonThrowTypeExtension($this->getService('reflectionProvider'), $this->getService('0169')); + } + + + public function createService0247(): PHPStan\Type\Php\PregMatchTypeSpecifyingExtension + { + return new PHPStan\Type\Php\PregMatchTypeSpecifyingExtension($this->getService('0250')); + } + + + public function createService0248(): PHPStan\Type\Php\PregMatchParameterOutTypeExtension + { + return new PHPStan\Type\Php\PregMatchParameterOutTypeExtension($this->getService('0250')); + } + + + public function createService0249(): PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension + { + return new PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension($this->getService('0250')); + } + + + public function createService0250(): PHPStan\Type\Php\RegexArrayShapeMatcher + { + return new PHPStan\Type\Php\RegexArrayShapeMatcher( + $this->getService('0251'), + $this->getService('0252'), + $this->getService('023') + ); + } + + + public function createService0251(): PHPStan\Type\Regex\RegexGroupParser + { + return new PHPStan\Type\Regex\RegexGroupParser($this->getService('023'), $this->getService('0252')); + } + + + public function createService0252(): PHPStan\Type\Regex\RegexExpressionHelper + { + return new PHPStan\Type\Regex\RegexExpressionHelper($this->getService('088')); + } + + + public function createService0253(): PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension; + } + + + public function createService0254(): PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0255(): PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0256(): PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0257(): PHPStan\Type\Php\StrContainingTypeSpecifyingExtension + { + return new PHPStan\Type\Php\StrContainingTypeSpecifyingExtension; + } + + + public function createService0258(): PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension + { + return new PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension; + } + + + public function createService0259(): PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension + { + return new PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension; + } + + + public function createService0260(): PHPStan\Type\Php\StatDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\StatDynamicReturnTypeExtension; + } + + + public function createService0261(): PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension + { + return new PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension; + } + + + public function createService0262(): PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension + { + return new PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension($this->getService('0161')); + } + + + public function createService0263(): PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0264(): PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension; + } + + + public function createService0265(): PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension($this->getService('reflectionProvider')); + } + + + public function createService0266(): PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension; + } + + + public function createService0267(): PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension($this->getService('0169')); + } + + + public function createService0268(): PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension; + } + + + public function createService0269(): PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension; + } + + + public function createService0270(): PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension; + } + + + public function createService0271(): PHPStan\Type\Php\LtrimFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\LtrimFunctionReturnTypeExtension; + } + + + public function createService0272(): PHPStan\Type\Php\MbFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\MbFunctionsReturnTypeExtension($this->getService('023')); + } + + + public function createService0273(): PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension; + } + + + public function createService0274(): PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0275(): PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0276(): PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension; + } + + + public function createService0277(): PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension; + } + + + public function createService0278(): PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension; + } + + + public function createService0279(): PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension; + } + + + public function createService0280(): PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension; + } + + + public function createService0281(): PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension + { + return new PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension; + } + + + public function createService0282(): PHPStan\Type\Php\StrlenFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrlenFunctionReturnTypeExtension; + } + + + public function createService0283(): PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension; + } + + + public function createService0284(): PHPStan\Type\Php\StrPadFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrPadFunctionReturnTypeExtension; + } + + + public function createService0285(): PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension; + } + + + public function createService0286(): PHPStan\Type\Php\SubstrDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\SubstrDynamicReturnTypeExtension; + } + + + public function createService0287(): PHPStan\Type\Php\ThrowableReturnTypeExtension + { + return new PHPStan\Type\Php\ThrowableReturnTypeExtension; + } + + + public function createService0288(): PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension; + } + + + public function createService0289(): PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension($this->getService('023')); + } + + + public function createService0290(): PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension; + } + + + public function createService0291(): PHPStan\Type\Php\PowFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\PowFunctionReturnTypeExtension; + } + + + public function createService0292(): PHPStan\Type\Php\RoundFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\RoundFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0293(): PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension; + } + + + public function createService0294(): PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension; + } + + + public function createService0295(): PHPStan\Type\Php\RangeFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\RangeFunctionReturnTypeExtension; + } + + + public function createService0296(): PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension; + } + + + public function createService0297(): PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension; + } + + + public function createService0298(): PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension; + } + + + public function createService0299(): PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension + { + return new PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension; + } + + + public function createService0300(): PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension + { + return new PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension($this->getService('0210')); + } + + + public function createService0301(): PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension; + } + + + public function createService0302(): PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension; + } + + + public function createService0303(): PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension(false); + } + + + public function createService0304(): PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension($this->getService('0261')); + } + + + public function createService0305(): PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension; + } + + + public function createService0306(): PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension($this->getService('0309')); + } + + + public function createService0307(): PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension; + } + + + public function createService0308(): PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension($this->getService('0309')); + } + + + public function createService0309(): PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper + { + return new PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper; + } + + + public function createService0310(): PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension + { + return new PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension; + } + + + public function createService0311(): PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension( + $this->getService('reflectionProvider'), + $this->getService('0169') + ); + } + + + public function createService0312(): PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension( + $this->getService('reflectionProvider'), + true, + ['stdClass'], + false + ); + } + + + public function createService0313(): PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension + { + return new PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension; + } + + + public function createService0314(): PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension + { + return new PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension; + } + + + public function createService0315(): PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension($this->getService('023')); + } + + + public function createService0316(): PHPStan\Type\Php\StrTokFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrTokFunctionReturnTypeExtension; + } + + + public function createService0317(): PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension; + } + + + public function createService0318(): PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension; + } + + + public function createService0319(): PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension + { + return new PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension; + } + + + public function createService0320(): PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension + { + return new PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension; + } + + + public function createService0321(): PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension + { + return new PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension; + } + + + public function createService0322(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionClass'); + } + + + public function createService0323(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionClassConstant'); + } + + + public function createService0324(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionFunctionAbstract'); + } + + + public function createService0325(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionParameter'); + } + + + public function createService0326(): PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension + { + return new PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension('ReflectionProperty'); + } + + + public function createService0327(): PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension + { + return new PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension; + } + + + public function createService0328(): PHPStan\Type\ClosureTypeFactory + { + return new PHPStan\Type\ClosureTypeFactory( + $this->getService('088'), + $this->getService('0335'), + $this->getService('originalBetterReflectionReflector'), + $this->getService('currentPhpVersionPhpParser') + ); + } + + + public function createService0329(): PHPStan\Type\Constant\OversizedArrayBuilder + { + return new PHPStan\Type\Constant\OversizedArrayBuilder; + } + + + public function createService0330(): PHPStan\Rules\Functions\PrintfHelper + { + return new PHPStan\Rules\Functions\PrintfHelper($this->getService('023')); + } + + + public function createService0331(): PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory + { + return new PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory( + $this->getService('phpParserDecorator'), + $this->getService('php8PhpParser'), + $this->getService('0334'), + $this->getService('0335'), + $this->getService('098'), + $this->getService('095'), + $this->getService('093'), + $this->getService('096'), + $this->getService('092'), + [], + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php'], + $this->getParameter('analysedPaths'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + $this->getParameter('analysedPathsFromConfig'), + false + ); + } + + + public function createService0332(): PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory + { + return new class ($this) implements PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory { + private $container; + + + public function __construct(Container_9e7071f660 $container) + { + $this->container = $container; + } + + + public function create(PHPStan\BetterReflection\Reflector\Reflector $reflector): PHPStan\Reflection\BetterReflection\BetterReflectionProvider + { + return new PHPStan\Reflection\BetterReflection\BetterReflectionProvider( + $this->container->getService('0110'), + $this->container->getService('088'), + $this->container->getService('071'), + $reflector, + $this->container->getService('0166'), + $this->container->getService('031'), + $this->container->getService('023'), + $this->container->getService('0111'), + $this->container->getService('stubPhpDocProvider'), + $this->container->getService('087'), + $this->container->getService('relativePathHelper'), + $this->container->getService('022'), + $this->container->getService('078'), + $this->container->getService('0334'), + $this->container->getService('0116'), + ['stdClass'] + ); + } + }; + } + + + public function createService0333(): PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory + { + return new PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory( + $this->getService('php8PhpParser'), + $this->getService('021'), + $this->getService('023') + ); + } + + + public function createService0334(): PHPStan\BetterReflection\SourceLocator\SourceStubber\PhpStormStubsSourceStubber + { + return $this->getService('0333')->create(); + } + + + public function createService0335(): PHPStan\BetterReflection\SourceLocator\SourceStubber\ReflectionSourceStubber + { + return $this->getService('0336')->create(); + } + + + public function createService0336(): PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory + { + return new PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory( + $this->getService('021'), + $this->getService('023') + ); + } + + + public function createService0337(): PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter( + $this->getService('errorFormatter.github'), + $this->getService('errorFormatter.teamcity') + ); + } + + + public function createService0338(): PHPStan\Rules\Api\ApiClassConstFetchRule + { + return new PHPStan\Rules\Api\ApiClassConstFetchRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createService0339(): PHPStan\Rules\Api\ApiInstanceofRule + { + return new PHPStan\Rules\Api\ApiInstanceofRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createService0340(): PHPStan\Rules\Api\ApiInstanceofTypeRule + { + return new PHPStan\Rules\Api\ApiInstanceofTypeRule($this->getService('reflectionProvider'), false, false); + } + + + public function createService0341(): PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule + { + return new PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule($this->getService('068')); + } + + + public function createService0342(): PHPStan\Rules\Api\RuntimeReflectionFunctionRule + { + return new PHPStan\Rules\Api\RuntimeReflectionFunctionRule($this->getService('reflectionProvider')); + } + + + public function createService0343(): PHPStan\Rules\Api\RuntimeReflectionInstantiationRule + { + return new PHPStan\Rules\Api\RuntimeReflectionInstantiationRule($this->getService('reflectionProvider')); + } + + + public function createService0344(): PHPStan\Rules\Classes\ExistingClassInClassExtendsRule + { + return new PHPStan\Rules\Classes\ExistingClassInClassExtendsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createService0345(): PHPStan\Rules\Classes\ExistingClassInInstanceOfRule + { + return new PHPStan\Rules\Classes\ExistingClassInInstanceOfRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + true + ); + } + + + public function createService0346(): PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule + { + return new PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + true + ); + } + + + public function createService0347(): PHPStan\Rules\Functions\CallToNonExistentFunctionRule + { + return new PHPStan\Rules\Functions\CallToNonExistentFunctionRule($this->getService('reflectionProvider'), false); + } + + + public function createService0348(): PHPStan\Rules\Constants\OverridingConstantRule + { + return new PHPStan\Rules\Constants\OverridingConstantRule(true); + } + + + public function createService0349(): PHPStan\Rules\Methods\OverridingMethodRule + { + return new PHPStan\Rules\Methods\OverridingMethodRule( + $this->getService('023'), + $this->getService('0147'), + true, + $this->getService('0148'), + $this->getService('0103'), + false, + false, + false + ); + } + + + public function createService0350(): PHPStan\Rules\Methods\ConsistentConstructorRule + { + return new PHPStan\Rules\Methods\ConsistentConstructorRule($this->getService('0148')); + } + + + public function createService0351(): PHPStan\Rules\Missing\MissingReturnRule + { + return new PHPStan\Rules\Missing\MissingReturnRule(false, true); + } + + + public function createService0352(): PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule + { + return new PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + false + ); + } + + + public function createService0353(): PHPStan\Rules\Namespaces\ExistingNamesInUseRule + { + return new PHPStan\Rules\Namespaces\ExistingNamesInUseRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + false + ); + } + + + public function createService0354(): PHPStan\Rules\Operators\InvalidIncDecOperationRule + { + return new PHPStan\Rules\Operators\InvalidIncDecOperationRule($this->getService('0163'), false, false); + } + + + public function createService0355(): PHPStan\Rules\Properties\AccessPropertiesRule + { + return new PHPStan\Rules\Properties\AccessPropertiesRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + true, + false + ); + } + + + public function createService0356(): PHPStan\Rules\Properties\AccessStaticPropertiesRule + { + return new PHPStan\Rules\Properties\AccessStaticPropertiesRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('0120') + ); + } + + + public function createService0357(): PHPStan\Rules\Properties\ExistingClassesInPropertiesRule + { + return new PHPStan\Rules\Properties\ExistingClassesInPropertiesRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0155'), + $this->getService('023'), + true, + false + ); + } + + + public function createService0358(): PHPStan\Rules\Functions\FunctionCallableRule + { + return new PHPStan\Rules\Functions\FunctionCallableRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('023'), + false, + true + ); + } + + + public function createService0359(): PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule + { + return new PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule($this->getService('0368')); + } + + + public function createService0360(): PHPStan\Rules\Properties\OverridingPropertyRule + { + return new PHPStan\Rules\Properties\OverridingPropertyRule(true, false); + } + + + public function createService0361(): PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule + { + return new PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule; + } + + + public function createService0362(): PHPStan\Rules\Properties\UninitializedPropertyRule + { + return new PHPStan\Rules\Properties\UninitializedPropertyRule($this->getService('0368')); + } + + + public function createService0363(): PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule + { + return new PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule( + $this->getService('0163'), + $this->getService('0160'), + $this->getService('0161'), + false + ); + } + + + public function createService0364(): PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule + { + return new PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule( + $this->getService('0160'), + $this->getService('0161'), + $this->getService('0163'), + false + ); + } + + + public function createService0365(): PHPStan\Rules\Variables\CompactVariablesRule + { + return new PHPStan\Rules\Variables\CompactVariablesRule(true); + } + + + public function createService0366(): PHPStan\Rules\Variables\DefinedVariableRule + { + return new PHPStan\Rules\Variables\DefinedVariableRule(true, true); + } + + + public function createService0367(): PHPStan\Rules\Regexp\RegularExpressionPatternRule + { + return new PHPStan\Rules\Regexp\RegularExpressionPatternRule($this->getService('0252')); + } + + + public function createService0368(): PHPStan\Reflection\ConstructorsHelper + { + return new PHPStan\Reflection\ConstructorsHelper($this->getService('068'), []); + } + + + public function createService0369(): PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule + { + return new PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule($this->getService('023')); + } + + + public function createService0370(): PHPStan\Rules\Constants\MagicConstantContextRule + { + return new PHPStan\Rules\Constants\MagicConstantContextRule; + } + + + public function createService0371(): PHPStan\Rules\Functions\UselessFunctionReturnValueRule + { + return new PHPStan\Rules\Functions\UselessFunctionReturnValueRule($this->getService('reflectionProvider')); + } + + + public function createService0372(): PHPStan\Rules\Functions\PrintfArrayParametersRule + { + return new PHPStan\Rules\Functions\PrintfArrayParametersRule($this->getService('0330'), $this->getService('reflectionProvider')); + } + + + public function createService0373(): PHPStan\Rules\Regexp\RegularExpressionQuotingRule + { + return new PHPStan\Rules\Regexp\RegularExpressionQuotingRule($this->getService('reflectionProvider'), $this->getService('0252')); + } + + + public function createService0374(): PHPStan\Rules\Classes\MixinRule + { + return new PHPStan\Rules\Classes\MixinRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true, + false + ); + } + + + public function createService0375(): PHPStan\Rules\Classes\MethodTagRule + { + return new PHPStan\Rules\Classes\MethodTagRule($this->getService('0124')); + } + + + public function createService0376(): PHPStan\Rules\Classes\MethodTagTraitRule + { + return new PHPStan\Rules\Classes\MethodTagTraitRule($this->getService('0124'), $this->getService('reflectionProvider')); + } + + + public function createService0377(): PHPStan\Rules\Classes\PropertyTagRule + { + return new PHPStan\Rules\Classes\PropertyTagRule($this->getService('0125')); + } + + + public function createService0378(): PHPStan\Rules\Classes\PropertyTagTraitRule + { + return new PHPStan\Rules\Classes\PropertyTagTraitRule($this->getService('0125'), $this->getService('reflectionProvider')); + } + + + public function createService0379(): PHPStan\Rules\PhpDoc\RequireExtendsCheck + { + return new PHPStan\Rules\PhpDoc\RequireExtendsCheck($this->getService('0120'), true); + } + + + public function createService0380(): PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule + { + return new PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule( + $this->getService('reflectionProvider'), + $this->getService('0120'), + true + ); + } + + + public function createService0381(): PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule + { + return new PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule; + } + + + public function createService0382(): PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule + { + return new PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule; + } + + + public function createService0383(): PHPStan\Rules\Functions\CallCallablesRule + { + return new PHPStan\Rules\Functions\CallCallablesRule($this->getService('0135'), $this->getService('0163'), true); + } + + + public function createService0384(): PHPStan\Rules\Methods\IllegalConstructorMethodCallRule + { + return new PHPStan\Rules\Methods\IllegalConstructorMethodCallRule; + } + + + public function createService0385(): PHPStan\Rules\Methods\IllegalConstructorStaticCallRule + { + return new PHPStan\Rules\Methods\IllegalConstructorStaticCallRule; + } + + + public function createService0386(): PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule + { + return new PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule($this->getService('026'), $this->getService('029'), false, false); + } + + + public function createService0387(): PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule + { + return new PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule( + $this->getService('0166'), + $this->getService('reflectionProvider'), + $this->getService('0120'), + $this->getService('0141'), + $this->getService('0149'), + $this->getService('0155'), + true, + true + ); + } + + + public function createService0388(): PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule + { + return new PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule($this->getService('026'), $this->getService('029'), false); + } + + + public function createService0389(): PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule + { + return new PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule($this->getService('0157')); + } + + + public function createService0390(): PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule + { + return new PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule($this->getService('0166'), $this->getService('0157'), false); + } + + + public function createService0391(): PHPStan\Rules\Generics\PropertyVarianceRule + { + return new PHPStan\Rules\Generics\PropertyVarianceRule($this->getService('0143'), false); + } + + + public function createService0392(): PHPStan\Rules\Pure\PureFunctionRule + { + return new PHPStan\Rules\Pure\PureFunctionRule($this->getService('0162')); + } + + + public function createService0393(): PHPStan\Rules\Pure\PureMethodRule + { + return new PHPStan\Rules\Pure\PureMethodRule($this->getService('0162')); + } + + + public function createService0394(): PHPStan\Rules\Operators\InvalidBinaryOperationRule + { + return new PHPStan\Rules\Operators\InvalidBinaryOperationRule($this->getService('020'), $this->getService('0163'), false); + } + + + public function createService0395(): PHPStan\Rules\Operators\InvalidUnaryOperationRule + { + return new PHPStan\Rules\Operators\InvalidUnaryOperationRule($this->getService('0163'), false); + } + + + public function createService0396(): PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule + { + return new PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule($this->getService('0163'), true); + } + + + public function createService0397(): PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule + { + return new PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule(true); + } + + + public function createService0398(): PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule + { + return new PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule($this->getService('0163'), $this->getService('0119'), true); + } + + + public function createService0399(): PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule + { + return new PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule( + $this->getService('exceptionTypeResolver'), + false + ); + } + + + public function createService0400(): PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule + { + return new PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule( + $this->getService('exceptionTypeResolver'), + false + ); + } + + + public function createService0401(): PHPStan\Rules\Generators\YieldFromTypeRule + { + return new PHPStan\Rules\Generators\YieldFromTypeRule($this->getService('0163'), true); + } + + + public function createService0402(): PHPStan\Rules\Generators\YieldInGeneratorRule + { + return new PHPStan\Rules\Generators\YieldInGeneratorRule(true); + } + + + public function createService0403(): PHPStan\Rules\Arrays\ArrayUnpackingRule + { + return new PHPStan\Rules\Arrays\ArrayUnpackingRule($this->getService('023'), $this->getService('0163')); + } + + + public function createService0404(): PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule + { + return new PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule($this->getService('0161')); + } + + + public function createService0405(): PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule + { + return new PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule($this->getService('0161'), $this->getService('0368')); + } + + + public function createService0406(): PHPStan\Rules\Variables\ParameterOutAssignedTypeRule + { + return new PHPStan\Rules\Variables\ParameterOutAssignedTypeRule($this->getService('0163')); + } + + + public function createService0407(): PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule + { + return new PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule($this->getService('0163')); + } + + + public function createService0408(): PHPStan\Rules\Classes\ImpossibleInstanceOfRule + { + return new PHPStan\Rules\Classes\ImpossibleInstanceOfRule(false, true, false); + } + + + public function createService0409(): PHPStan\Rules\Comparison\BooleanAndConstantConditionRule + { + return new PHPStan\Rules\Comparison\BooleanAndConstantConditionRule($this->getService('0126'), true, false, false); + } + + + public function createService0410(): PHPStan\Rules\Comparison\BooleanOrConstantConditionRule + { + return new PHPStan\Rules\Comparison\BooleanOrConstantConditionRule($this->getService('0126'), true, false, false); + } + + + public function createService0411(): PHPStan\Rules\Comparison\BooleanNotConstantConditionRule + { + return new PHPStan\Rules\Comparison\BooleanNotConstantConditionRule($this->getService('0126'), true, false); + } + + + public function createService0412(): PHPStan\Rules\DeadCode\NoopRule + { + return new PHPStan\Rules\DeadCode\NoopRule($this->getService('020'), false); + } + + + public function createService0413(): PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule; + } + + + public function createService0414(): PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector + { + return new PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector; + } + + + public function createService0415(): PHPStan\Rules\DeadCode\PossiblyPureNewCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureNewCollector($this->getService('reflectionProvider')); + } + + + public function createService0416(): PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule; + } + + + public function createService0417(): PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector + { + return new PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector; + } + + + public function createService0418(): PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector($this->getService('reflectionProvider')); + } + + + public function createService0419(): PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule; + } + + + public function createService0420(): PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector + { + return new PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector; + } + + + public function createService0421(): PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector; + } + + + public function createService0422(): PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule + { + return new PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule; + } + + + public function createService0423(): PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector + { + return new PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector; + } + + + public function createService0424(): PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule + { + return new PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule($this->getService('0159'), [], [], false); + } + + + public function createService0425(): PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule + { + return new PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule($this->getService('0126'), true); + } + + + public function createService0426(): PHPStan\Rules\Comparison\ElseIfConstantConditionRule + { + return new PHPStan\Rules\Comparison\ElseIfConstantConditionRule($this->getService('0126'), true, false); + } + + + public function createService0427(): PHPStan\Rules\Comparison\IfConstantConditionRule + { + return new PHPStan\Rules\Comparison\IfConstantConditionRule($this->getService('0126'), true); + } + + + public function createService0428(): PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule($this->getService('0127'), false, true, false); + } + + + public function createService0429(): PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule($this->getService('0127'), false, true, false); + } + + + public function createService0430(): PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule + { + return new PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule($this->getService('0127'), false, true, false); + } + + + public function createService0431(): PHPStan\Rules\Comparison\LogicalXorConstantConditionRule + { + return new PHPStan\Rules\Comparison\LogicalXorConstantConditionRule($this->getService('0126'), true, false); + } + + + public function createService0432(): PHPStan\Rules\DeadCode\BetterNoopRule + { + return new PHPStan\Rules\DeadCode\BetterNoopRule($this->getService('020')); + } + + + public function createService0433(): PHPStan\Rules\Comparison\MatchExpressionRule + { + return new PHPStan\Rules\Comparison\MatchExpressionRule($this->getService('0126'), false, false, false, true); + } + + + public function createService0434(): PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule + { + return new PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule(true); + } + + + public function createService0435(): PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule + { + return new PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule(false, true, false); + } + + + public function createService0436(): PHPStan\Rules\Comparison\ConstantLooseComparisonRule + { + return new PHPStan\Rules\Comparison\ConstantLooseComparisonRule(false, true, false); + } + + + public function createService0437(): PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule + { + return new PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule($this->getService('0126'), true); + } + + + public function createService0438(): PHPStan\Rules\Comparison\UnreachableIfBranchesRule + { + return new PHPStan\Rules\Comparison\UnreachableIfBranchesRule($this->getService('0126'), true, false); + } + + + public function createService0439(): PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule + { + return new PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule($this->getService('0126'), true, false); + } + + + public function createService0440(): PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule + { + return new PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule($this->getService('0126'), true); + } + + + public function createService0441(): PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule + { + return new PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule($this->getService('0126'), true); + } + + + public function createService0442(): PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule( + $this->getService('reflectionProvider'), + false + ); + } + + + public function createService0443(): PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule(false, false); + } + + + public function createService0444(): PHPStan\Rules\Properties\NullsafePropertyFetchRule + { + return new PHPStan\Rules\Properties\NullsafePropertyFetchRule; + } + + + public function createService0445(): PHPStan\Rules\Traits\TraitDeclarationCollector + { + return new PHPStan\Rules\Traits\TraitDeclarationCollector; + } + + + public function createService0446(): PHPStan\Rules\Traits\TraitUseCollector + { + return new PHPStan\Rules\Traits\TraitUseCollector; + } + + + public function createService0447(): PHPStan\Rules\Traits\NotAnalysedTraitRule + { + return new PHPStan\Rules\Traits\NotAnalysedTraitRule; + } + + + public function createService0448(): PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule + { + return new PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule($this->getService('exceptionTypeResolver'), true); + } + + + public function createService0449(): PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule($this->getService('0165')); + } + + + public function createService0450(): PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule($this->getService('0165')); + } + + + public function createService0451(): PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule + { + return new PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule($this->getService('0159'), $this->getService('0161')); + } + + + public function createService0452(): PHPStan\Rules\Functions\RandomIntParametersRule + { + return new PHPStan\Rules\Functions\RandomIntParametersRule($this->getService('reflectionProvider'), true); + } + + + public function createService0453(): PHPStan\Rules\Functions\ArrayFilterRule + { + return new PHPStan\Rules\Functions\ArrayFilterRule($this->getService('reflectionProvider'), true); + } + + + public function createService0454(): PHPStan\Rules\Functions\ArrayValuesRule + { + return new PHPStan\Rules\Functions\ArrayValuesRule($this->getService('reflectionProvider'), true); + } + + + public function createService0455(): PHPStan\Rules\Functions\CallUserFuncRule + { + return new PHPStan\Rules\Functions\CallUserFuncRule($this->getService('reflectionProvider'), $this->getService('0135')); + } + + + public function createService0456(): PHPStan\Rules\Functions\ImplodeFunctionRule + { + return new PHPStan\Rules\Functions\ImplodeFunctionRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + false + ); + } + + + public function createService0457(): PHPStan\Rules\Functions\ParameterCastableToStringRule + { + return new PHPStan\Rules\Functions\ParameterCastableToStringRule( + $this->getService('reflectionProvider'), + $this->getService('0138') + ); + } + + + public function createService0458(): PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule + { + return new PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule( + $this->getService('reflectionProvider'), + $this->getService('0138') + ); + } + + + public function createService0459(): PHPStan\Rules\Functions\SortParameterCastableToStringRule + { + return new PHPStan\Rules\Functions\SortParameterCastableToStringRule( + $this->getService('reflectionProvider'), + $this->getService('0138') + ); + } + + + public function createService0460(): PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule + { + return new PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule($this->getService('0149'), false); + } + + + public function createService0461(): PHPStan\Rules\Methods\MissingMethodParameterTypehintRule + { + return new PHPStan\Rules\Methods\MissingMethodParameterTypehintRule($this->getService('0149'), false); + } + + + public function createService0462(): PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule + { + return new PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule($this->getService('0149')); + } + + + public function createServiceBetterReflectionClassReflector(): PHPStan\BetterReflection\Reflector\ClassReflector + { + return new PHPStan\BetterReflection\Reflector\ClassReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceBetterReflectionConstantReflector(): PHPStan\BetterReflection\Reflector\ConstantReflector + { + return new PHPStan\BetterReflection\Reflector\ConstantReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceBetterReflectionFunctionReflector(): PHPStan\BetterReflection\Reflector\FunctionReflector + { + return new PHPStan\BetterReflection\Reflector\FunctionReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceBetterReflectionProvider(): PHPStan\Reflection\BetterReflection\BetterReflectionProvider + { + return new PHPStan\Reflection\BetterReflection\BetterReflectionProvider( + $this->getService('0110'), + $this->getService('088'), + $this->getService('071'), + $this->getService('betterReflectionReflector'), + $this->getService('0166'), + $this->getService('031'), + $this->getService('023'), + $this->getService('0111'), + $this->getService('stubPhpDocProvider'), + $this->getService('087'), + $this->getService('relativePathHelper'), + $this->getService('022'), + $this->getService('078'), + $this->getService('0334'), + $this->getService('0116'), + ['stdClass'] + ); + } + + + public function createServiceBetterReflectionReflector(): PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector + { + return new PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector($this->getService('originalBetterReflectionReflector')); + } + + + public function createServiceBetterReflectionSourceLocator(): PHPStan\BetterReflection\SourceLocator\Type\SourceLocator + { + return $this->getService('0331')->create(); + } + + + public function createServiceBroker(): PHPStan\Broker\Broker + { + return $this->getService('brokerFactory')->create(); + } + + + public function createServiceBrokerFactory(): PHPStan\Broker\BrokerFactory + { + return new PHPStan\Broker\BrokerFactory($this->getService('068')); + } + + + public function createServiceCacheStorage(): PHPStan\Cache\FileCacheStorage + { + return new PHPStan\Cache\FileCacheStorage('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/cache/PHPStan'); + } + + + public function createServiceContainer(): Container_9e7071f660 + { + return $this; + } + + + public function createServiceCurrentPhpVersionLexer(): PhpParser\Lexer + { + return $this->getService('02')->create(); + } + + + public function createServiceCurrentPhpVersionPhpParser(): PhpParser\Parser\Php7 + { + return new PhpParser\Parser\Php7($this->getService('currentPhpVersionLexer')); + } + + + public function createServiceCurrentPhpVersionRichParser(): PHPStan\Parser\RichParser + { + return new PHPStan\Parser\RichParser( + $this->getService('currentPhpVersionPhpParser'), + $this->getService('currentPhpVersionLexer'), + $this->getService('03'), + $this->getService('068'), + $this->getService('050'), + false + ); + } + + + public function createServiceCurrentPhpVersionSimpleDirectParser(): PHPStan\Parser\SimpleParser + { + return new PHPStan\Parser\SimpleParser($this->getService('currentPhpVersionPhpParser'), $this->getService('03')); + } + + + public function createServiceCurrentPhpVersionSimpleParser(): PHPStan\Parser\CleaningParser + { + return new PHPStan\Parser\CleaningParser($this->getService('currentPhpVersionSimpleDirectParser'), $this->getService('023')); + } + + + public function createServiceDefaultAnalysisParser(): PHPStan\Parser\CachedParser + { + return new PHPStan\Parser\CachedParser($this->getService('pathRoutingParser'), 256); + } + + + public function createServiceErrorFormatter__checkstyle(): PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__github(): PHPStan\Command\ErrorFormatter\GithubErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\GithubErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__gitlab(): PHPStan\Command\ErrorFormatter\GitlabErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\GitlabErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__json(): PHPStan\Command\ErrorFormatter\JsonErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\JsonErrorFormatter(false); + } + + + public function createServiceErrorFormatter__junit(): PHPStan\Command\ErrorFormatter\JunitErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\JunitErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceErrorFormatter__prettyJson(): PHPStan\Command\ErrorFormatter\JsonErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\JsonErrorFormatter(true); + } + + + public function createServiceErrorFormatter__raw(): PHPStan\Command\ErrorFormatter\RawErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\RawErrorFormatter; + } + + + public function createServiceErrorFormatter__table(): PHPStan\Command\ErrorFormatter\TableErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\TableErrorFormatter( + $this->getService('relativePathHelper'), + $this->getService('simpleRelativePathHelper'), + $this->getService('0337'), + true, + null, + null + ); + } + + + public function createServiceErrorFormatter__teamcity(): PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter + { + return new PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter($this->getService('simpleRelativePathHelper')); + } + + + public function createServiceExceptionTypeResolver(): PHPStan\Rules\Exceptions\ExceptionTypeResolver + { + return $this->getService('0128'); + } + + + public function createServiceFileExcluderAnalyse(): PHPStan\File\FileExcluder + { + return $this->getService('079')->createAnalyseFileExcluder(); + } + + + public function createServiceFileExcluderScan(): PHPStan\File\FileExcluder + { + return $this->getService('079')->createScanFileExcluder(); + } + + + public function createServiceFileFinderAnalyse(): PHPStan\File\FileFinder + { + return new PHPStan\File\FileFinder($this->getService('fileExcluderAnalyse'), $this->getService('078'), ['php']); + } + + + public function createServiceFileFinderScan(): PHPStan\File\FileFinder + { + return new PHPStan\File\FileFinder($this->getService('fileExcluderScan'), $this->getService('078'), ['php']); + } + + + public function createServiceNodeScopeResolverReflector(): PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector + { + return $this->getService('betterReflectionReflector'); + } + + + public function createServiceOriginalBetterReflectionReflector(): PHPStan\BetterReflection\Reflector\DefaultReflector + { + return new PHPStan\BetterReflection\Reflector\DefaultReflector($this->getService('betterReflectionSourceLocator')); + } + + + public function createServiceParentDirectoryRelativePathHelper(): PHPStan\File\ParentDirectoryRelativePathHelper + { + return new PHPStan\File\ParentDirectoryRelativePathHelper('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'); + } + + + public function createServicePathRoutingParser(): PHPStan\Parser\PathRoutingParser + { + return new PHPStan\Parser\PathRoutingParser( + $this->getService('078'), + $this->getService('currentPhpVersionRichParser'), + $this->getService('currentPhpVersionSimpleParser'), + $this->getService('php8Parser') + ); + } + + + public function createServicePhp8Lexer(): PhpParser\Lexer\Emulative + { + return $this->getService('02')->createEmulative(); + } + + + public function createServicePhp8Parser(): PHPStan\Parser\SimpleParser + { + return new PHPStan\Parser\SimpleParser($this->getService('php8PhpParser'), $this->getService('03')); + } + + + public function createServicePhp8PhpParser(): PhpParser\Parser\Php7 + { + return new PhpParser\Parser\Php7($this->getService('php8Lexer')); + } + + + public function createServicePhpParserDecorator(): PHPStan\Parser\PhpParserDecorator + { + return new PHPStan\Parser\PhpParserDecorator($this->getService('defaultAnalysisParser')); + } + + + public function createServicePhpstanDiagnoseExtension(): PHPStan\Diagnose\PHPStanDiagnoseExtension + { + return new PHPStan\Diagnose\PHPStanDiagnoseExtension( + $this->getService('023'), + $this->getService('078'), + ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/phpstan.neon', + ] + ); + } + + + public function createServiceReflectionProvider(): PHPStan\Reflection\ReflectionProvider + { + return $this->getService('reflectionProviderFactory')->create(); + } + + + public function createServiceReflectionProviderFactory(): PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory + { + return new PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory($this->getService('betterReflectionProvider')); + } + + + public function createServiceRegistry(): PHPStan\Rules\LazyRegistry + { + return new PHPStan\Rules\LazyRegistry($this->getService('068')); + } + + + public function createServiceRelativePathHelper(): PHPStan\File\RelativePathHelper + { + return new PHPStan\File\FuzzyRelativePathHelper( + $this->getService('parentDirectoryRelativePathHelper'), + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + $this->getParameter('analysedPaths') + ); + } + + + public function createServiceRules__0(): PHPStan\Rules\Debug\DumpTypeRule + { + return new PHPStan\Rules\Debug\DumpTypeRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__1(): PHPStan\Rules\Debug\FileAssertRule + { + return new PHPStan\Rules\Debug\FileAssertRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__10(): PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule + { + return new PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule($this->getService('0117')); + } + + + public function createServiceRules__100(): PHPStan\Rules\Generics\ClassTemplateTypeRule + { + return new PHPStan\Rules\Generics\ClassTemplateTypeRule($this->getService('0142')); + } + + + public function createServiceRules__101(): PHPStan\Rules\Generics\EnumAncestorsRule + { + return new PHPStan\Rules\Generics\EnumAncestorsRule($this->getService('0140'), $this->getService('0139')); + } + + + public function createServiceRules__102(): PHPStan\Rules\Generics\EnumTemplateTypeRule + { + return new PHPStan\Rules\Generics\EnumTemplateTypeRule; + } + + + public function createServiceRules__103(): PHPStan\Rules\Generics\FunctionTemplateTypeRule + { + return new PHPStan\Rules\Generics\FunctionTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__104(): PHPStan\Rules\Generics\FunctionSignatureVarianceRule + { + return new PHPStan\Rules\Generics\FunctionSignatureVarianceRule($this->getService('0143')); + } + + + public function createServiceRules__105(): PHPStan\Rules\Generics\InterfaceAncestorsRule + { + return new PHPStan\Rules\Generics\InterfaceAncestorsRule($this->getService('0140'), $this->getService('0139')); + } + + + public function createServiceRules__106(): PHPStan\Rules\Generics\InterfaceTemplateTypeRule + { + return new PHPStan\Rules\Generics\InterfaceTemplateTypeRule($this->getService('0142')); + } + + + public function createServiceRules__107(): PHPStan\Rules\Generics\MethodTemplateTypeRule + { + return new PHPStan\Rules\Generics\MethodTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__108(): PHPStan\Rules\Generics\MethodTagTemplateTypeRule + { + return new PHPStan\Rules\Generics\MethodTagTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__109(): PHPStan\Rules\Generics\MethodSignatureVarianceRule + { + return new PHPStan\Rules\Generics\MethodSignatureVarianceRule($this->getService('0143')); + } + + + public function createServiceRules__11(): PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule + { + return new PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule($this->getService('020')); + } + + + public function createServiceRules__110(): PHPStan\Rules\Generics\TraitTemplateTypeRule + { + return new PHPStan\Rules\Generics\TraitTemplateTypeRule($this->getService('0166'), $this->getService('0142')); + } + + + public function createServiceRules__111(): PHPStan\Rules\Generics\UsedTraitsRule + { + return new PHPStan\Rules\Generics\UsedTraitsRule($this->getService('0166'), $this->getService('0140')); + } + + + public function createServiceRules__112(): PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule + { + return new PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule; + } + + + public function createServiceRules__113(): PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule + { + return new PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule; + } + + + public function createServiceRules__114(): PHPStan\Rules\Operators\InvalidComparisonOperationRule + { + return new PHPStan\Rules\Operators\InvalidComparisonOperationRule($this->getService('0163')); + } + + + public function createServiceRules__115(): PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule + { + return new PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule($this->getService('0153')); + } + + + public function createServiceRules__116(): PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule + { + return new PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule($this->getService('0153')); + } + + + public function createServiceRules__117(): PHPStan\Rules\PhpDoc\FunctionAssertRule + { + return new PHPStan\Rules\PhpDoc\FunctionAssertRule($this->getService('0154')); + } + + + public function createServiceRules__118(): PHPStan\Rules\PhpDoc\MethodAssertRule + { + return new PHPStan\Rules\PhpDoc\MethodAssertRule($this->getService('0154')); + } + + + public function createServiceRules__119(): PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule($this->getService('0155'), $this->getService('0141')); + } + + + public function createServiceRules__12(): PHPStan\Rules\Arrays\EmptyArrayItemRule + { + return new PHPStan\Rules\Arrays\EmptyArrayItemRule; + } + + + public function createServiceRules__120(): PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule($this->getService('0141'), $this->getService('0155')); + } + + + public function createServiceRules__121(): PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule( + $this->getService('0166'), + $this->getService('0141'), + $this->getService('0155'), + $this->getService('0156') + ); + } + + + public function createServiceRules__122(): PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule + { + return new PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule( + $this->getService('0141'), + $this->getService('0155'), + $this->getService('0156') + ); + } + + + public function createServiceRules__123(): PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule + { + return new PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule($this->getService('0166')); + } + + + public function createServiceRules__124(): PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule + { + return new PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule($this->getService('0166')); + } + + + public function createServiceRules__125(): PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule + { + return new PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule; + } + + + public function createServiceRules__126(): PHPStan\Rules\Classes\RequireImplementsRule + { + return new PHPStan\Rules\Classes\RequireImplementsRule; + } + + + public function createServiceRules__127(): PHPStan\Rules\Classes\RequireExtendsRule + { + return new PHPStan\Rules\Classes\RequireExtendsRule; + } + + + public function createServiceRules__128(): PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule + { + return new PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule; + } + + + public function createServiceRules__129(): PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule + { + return new PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule($this->getService('0379')); + } + + + public function createServiceRules__13(): PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule + { + return new PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule; + } + + + public function createServiceRules__130(): PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule + { + return new PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule( + $this->getService('reflectionProvider'), + $this->getService('0379') + ); + } + + + public function createServiceRules__131(): PHPStan\Rules\Arrays\ArrayDestructuringRule + { + return new PHPStan\Rules\Arrays\ArrayDestructuringRule($this->getService('0163'), $this->getService('0119')); + } + + + public function createServiceRules__132(): PHPStan\Rules\Arrays\IterableInForeachRule + { + return new PHPStan\Rules\Arrays\IterableInForeachRule($this->getService('0163')); + } + + + public function createServiceRules__133(): PHPStan\Rules\Arrays\OffsetAccessAssignmentRule + { + return new PHPStan\Rules\Arrays\OffsetAccessAssignmentRule($this->getService('0163')); + } + + + public function createServiceRules__134(): PHPStan\Rules\Arrays\OffsetAccessAssignOpRule + { + return new PHPStan\Rules\Arrays\OffsetAccessAssignOpRule($this->getService('0163')); + } + + + public function createServiceRules__135(): PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule + { + return new PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule($this->getService('0163')); + } + + + public function createServiceRules__136(): PHPStan\Rules\Arrays\UnpackIterableInArrayRule + { + return new PHPStan\Rules\Arrays\UnpackIterableInArrayRule($this->getService('0163')); + } + + + public function createServiceRules__137(): PHPStan\Rules\Exceptions\ThrowExprTypeRule + { + return new PHPStan\Rules\Exceptions\ThrowExprTypeRule($this->getService('0163')); + } + + + public function createServiceRules__138(): PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule + { + return new PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__139(): PHPStan\Rules\Functions\ClosureReturnTypeRule + { + return new PHPStan\Rules\Functions\ClosureReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__14(): PHPStan\Rules\Cast\UnsetCastRule + { + return new PHPStan\Rules\Cast\UnsetCastRule($this->getService('023')); + } + + + public function createServiceRules__140(): PHPStan\Rules\Functions\ReturnTypeRule + { + return new PHPStan\Rules\Functions\ReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__141(): PHPStan\Rules\Generators\YieldTypeRule + { + return new PHPStan\Rules\Generators\YieldTypeRule($this->getService('0163')); + } + + + public function createServiceRules__142(): PHPStan\Rules\Methods\ReturnTypeRule + { + return new PHPStan\Rules\Methods\ReturnTypeRule($this->getService('0137')); + } + + + public function createServiceRules__143(): PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule + { + return new PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule($this->getService('0163')); + } + + + public function createServiceRules__144(): PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule + { + return new PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule($this->getService('0161'), $this->getService('0368')); + } + + + public function createServiceRules__145(): PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule + { + return new PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule($this->getService('0161')); + } + + + public function createServiceRules__146(): PHPStan\Rules\Properties\TypesAssignedToPropertiesRule + { + return new PHPStan\Rules\Properties\TypesAssignedToPropertiesRule($this->getService('0163'), $this->getService('0161')); + } + + + public function createServiceRules__147(): PHPStan\Rules\Variables\ThrowTypeRule + { + return new PHPStan\Rules\Variables\ThrowTypeRule($this->getService('0163')); + } + + + public function createServiceRules__148(): PHPStan\Rules\Variables\VariableCloningRule + { + return new PHPStan\Rules\Variables\VariableCloningRule($this->getService('0163')); + } + + + public function createServiceRules__149(): PHPStan\Rules\Arrays\DeadForeachRule + { + return new PHPStan\Rules\Arrays\DeadForeachRule; + } + + + public function createServiceRules__15(): PHPStan\Rules\Classes\AllowedSubTypesRule + { + return new PHPStan\Rules\Classes\AllowedSubTypesRule; + } + + + public function createServiceRules__150(): PHPStan\Rules\DeadCode\UnreachableStatementRule + { + return new PHPStan\Rules\DeadCode\UnreachableStatementRule; + } + + + public function createServiceRules__151(): PHPStan\Rules\DeadCode\UnusedPrivateConstantRule + { + return new PHPStan\Rules\DeadCode\UnusedPrivateConstantRule($this->getService('0151')); + } + + + public function createServiceRules__152(): PHPStan\Rules\DeadCode\UnusedPrivateMethodRule + { + return new PHPStan\Rules\DeadCode\UnusedPrivateMethodRule($this->getService('0152')); + } + + + public function createServiceRules__153(): PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule + { + return new PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule; + } + + + public function createServiceRules__154(): PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__155(): PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule($this->getService('0163')); + } + + + public function createServiceRules__156(): PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule + { + return new PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule( + $this->getService('0163'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__157(): PHPStan\Rules\Methods\NullsafeMethodCallRule + { + return new PHPStan\Rules\Methods\NullsafeMethodCallRule; + } + + + public function createServiceRules__158(): PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule; + } + + + public function createServiceRules__159(): PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule; + } + + + public function createServiceRules__16(): PHPStan\Rules\Classes\ClassAttributesRule + { + return new PHPStan\Rules\Classes\ClassAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__160(): PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule + { + return new PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule; + } + + + public function createServiceRules__161(): PHPStan\Rules\DateTimeInstantiationRule + { + return new PHPStan\Rules\DateTimeInstantiationRule; + } + + + public function createServiceRules__162(): PHPStan\Rules\Constants\MissingClassConstantTypehintRule + { + return new PHPStan\Rules\Constants\MissingClassConstantTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__163(): PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule + { + return new PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__164(): PHPStan\Rules\Methods\MissingMethodReturnTypehintRule + { + return new PHPStan\Rules\Methods\MissingMethodReturnTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__165(): PHPStan\Rules\Properties\MissingPropertyTypehintRule + { + return new PHPStan\Rules\Properties\MissingPropertyTypehintRule($this->getService('0149')); + } + + + public function createServiceRules__17(): PHPStan\Rules\Classes\ClassConstantAttributesRule + { + return new PHPStan\Rules\Classes\ClassConstantAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__18(): PHPStan\Rules\Classes\ClassConstantRule + { + return new PHPStan\Rules\Classes\ClassConstantRule( + $this->getService('reflectionProvider'), + $this->getService('0163'), + $this->getService('0120'), + $this->getService('023') + ); + } + + + public function createServiceRules__19(): PHPStan\Rules\Classes\DuplicateDeclarationRule + { + return new PHPStan\Rules\Classes\DuplicateDeclarationRule; + } + + + public function createServiceRules__2(): PHPStan\Rules\Api\ApiInstantiationRule + { + return new PHPStan\Rules\Api\ApiInstantiationRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__20(): PHPStan\Rules\Classes\EnumSanityRule + { + return new PHPStan\Rules\Classes\EnumSanityRule; + } + + + public function createServiceRules__21(): PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule + { + return new PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__22(): PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule + { + return new PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__23(): PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule + { + return new PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule( + $this->getService('0120'), + $this->getService('reflectionProvider') + ); + } + + + public function createServiceRules__24(): PHPStan\Rules\Classes\ExistingClassInTraitUseRule + { + return new PHPStan\Rules\Classes\ExistingClassInTraitUseRule($this->getService('0120'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__25(): PHPStan\Rules\Classes\InstantiationRule + { + return new PHPStan\Rules\Classes\InstantiationRule( + $this->getService('reflectionProvider'), + $this->getService('0135'), + $this->getService('0120') + ); + } + + + public function createServiceRules__26(): PHPStan\Rules\Classes\InstantiationCallableRule + { + return new PHPStan\Rules\Classes\InstantiationCallableRule; + } + + + public function createServiceRules__27(): PHPStan\Rules\Classes\InvalidPromotedPropertiesRule + { + return new PHPStan\Rules\Classes\InvalidPromotedPropertiesRule($this->getService('023')); + } + + + public function createServiceRules__28(): PHPStan\Rules\Classes\LocalTypeAliasesRule + { + return new PHPStan\Rules\Classes\LocalTypeAliasesRule($this->getService('0123')); + } + + + public function createServiceRules__29(): PHPStan\Rules\Classes\LocalTypeTraitAliasesRule + { + return new PHPStan\Rules\Classes\LocalTypeTraitAliasesRule($this->getService('0123'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__3(): PHPStan\Rules\Api\ApiClassExtendsRule + { + return new PHPStan\Rules\Api\ApiClassExtendsRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__30(): PHPStan\Rules\Classes\NewStaticRule + { + return new PHPStan\Rules\Classes\NewStaticRule; + } + + + public function createServiceRules__31(): PHPStan\Rules\Classes\NonClassAttributeClassRule + { + return new PHPStan\Rules\Classes\NonClassAttributeClassRule; + } + + + public function createServiceRules__32(): PHPStan\Rules\Classes\ReadOnlyClassRule + { + return new PHPStan\Rules\Classes\ReadOnlyClassRule($this->getService('023')); + } + + + public function createServiceRules__33(): PHPStan\Rules\Classes\TraitAttributeClassRule + { + return new PHPStan\Rules\Classes\TraitAttributeClassRule; + } + + + public function createServiceRules__34(): PHPStan\Rules\Constants\DynamicClassConstantFetchRule + { + return new PHPStan\Rules\Constants\DynamicClassConstantFetchRule($this->getService('023'), $this->getService('0163')); + } + + + public function createServiceRules__35(): PHPStan\Rules\Constants\FinalConstantRule + { + return new PHPStan\Rules\Constants\FinalConstantRule($this->getService('023')); + } + + + public function createServiceRules__36(): PHPStan\Rules\Constants\NativeTypedClassConstantRule + { + return new PHPStan\Rules\Constants\NativeTypedClassConstantRule($this->getService('023')); + } + + + public function createServiceRules__37(): PHPStan\Rules\EnumCases\EnumCaseAttributesRule + { + return new PHPStan\Rules\EnumCases\EnumCaseAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__38(): PHPStan\Rules\Exceptions\NoncapturingCatchRule + { + return new PHPStan\Rules\Exceptions\NoncapturingCatchRule($this->getService('023')); + } + + + public function createServiceRules__39(): PHPStan\Rules\Exceptions\ThrowExpressionRule + { + return new PHPStan\Rules\Exceptions\ThrowExpressionRule($this->getService('023')); + } + + + public function createServiceRules__4(): PHPStan\Rules\Api\ApiClassImplementsRule + { + return new PHPStan\Rules\Api\ApiClassImplementsRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__40(): PHPStan\Rules\Functions\ArrowFunctionAttributesRule + { + return new PHPStan\Rules\Functions\ArrowFunctionAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__41(): PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule + { + return new PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule($this->getService('0150')); + } + + + public function createServiceRules__42(): PHPStan\Rules\Functions\ClosureAttributesRule + { + return new PHPStan\Rules\Functions\ClosureAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__43(): PHPStan\Rules\Functions\DefineParametersRule + { + return new PHPStan\Rules\Functions\DefineParametersRule($this->getService('023')); + } + + + public function createServiceRules__44(): PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule + { + return new PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule( + $this->getService('0136'), + $this->getService('023') + ); + } + + + public function createServiceRules__45(): PHPStan\Rules\Functions\CallToFunctionParametersRule + { + return new PHPStan\Rules\Functions\CallToFunctionParametersRule( + $this->getService('reflectionProvider'), + $this->getService('0135') + ); + } + + + public function createServiceRules__46(): PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule + { + return new PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule($this->getService('0136')); + } + + + public function createServiceRules__47(): PHPStan\Rules\Functions\ExistingClassesInTypehintsRule + { + return new PHPStan\Rules\Functions\ExistingClassesInTypehintsRule($this->getService('0136')); + } + + + public function createServiceRules__48(): PHPStan\Rules\Functions\FunctionAttributesRule + { + return new PHPStan\Rules\Functions\FunctionAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__49(): PHPStan\Rules\Functions\InnerFunctionRule + { + return new PHPStan\Rules\Functions\InnerFunctionRule; + } + + + public function createServiceRules__5(): PHPStan\Rules\Api\ApiInterfaceExtendsRule + { + return new PHPStan\Rules\Api\ApiInterfaceExtendsRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__50(): PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule + { + return new PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule; + } + + + public function createServiceRules__51(): PHPStan\Rules\Functions\ParamAttributesRule + { + return new PHPStan\Rules\Functions\ParamAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__52(): PHPStan\Rules\Functions\PrintfParametersRule + { + return new PHPStan\Rules\Functions\PrintfParametersRule($this->getService('0330'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__53(): PHPStan\Rules\Functions\RedefinedParametersRule + { + return new PHPStan\Rules\Functions\RedefinedParametersRule; + } + + + public function createServiceRules__54(): PHPStan\Rules\Functions\ReturnNullsafeByRefRule + { + return new PHPStan\Rules\Functions\ReturnNullsafeByRefRule($this->getService('0150')); + } + + + public function createServiceRules__55(): PHPStan\Rules\Ignore\IgnoreParseErrorRule + { + return new PHPStan\Rules\Ignore\IgnoreParseErrorRule; + } + + + public function createServiceRules__56(): PHPStan\Rules\Functions\VariadicParametersDeclarationRule + { + return new PHPStan\Rules\Functions\VariadicParametersDeclarationRule; + } + + + public function createServiceRules__57(): PHPStan\Rules\Keywords\ContinueBreakInLoopRule + { + return new PHPStan\Rules\Keywords\ContinueBreakInLoopRule; + } + + + public function createServiceRules__58(): PHPStan\Rules\Keywords\DeclareStrictTypesRule + { + return new PHPStan\Rules\Keywords\DeclareStrictTypesRule($this->getService('020')); + } + + + public function createServiceRules__59(): PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule + { + return new PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule; + } + + + public function createServiceRules__6(): PHPStan\Rules\Api\ApiMethodCallRule + { + return new PHPStan\Rules\Api\ApiMethodCallRule($this->getService('0117')); + } + + + public function createServiceRules__60(): PHPStan\Rules\Methods\AbstractPrivateMethodRule + { + return new PHPStan\Rules\Methods\AbstractPrivateMethodRule; + } + + + public function createServiceRules__61(): PHPStan\Rules\Methods\CallMethodsRule + { + return new PHPStan\Rules\Methods\CallMethodsRule($this->getService('0145'), $this->getService('0135')); + } + + + public function createServiceRules__62(): PHPStan\Rules\Methods\CallStaticMethodsRule + { + return new PHPStan\Rules\Methods\CallStaticMethodsRule($this->getService('0146'), $this->getService('0135')); + } + + + public function createServiceRules__63(): PHPStan\Rules\Methods\ConstructorReturnTypeRule + { + return new PHPStan\Rules\Methods\ConstructorReturnTypeRule; + } + + + public function createServiceRules__64(): PHPStan\Rules\Methods\ExistingClassesInTypehintsRule + { + return new PHPStan\Rules\Methods\ExistingClassesInTypehintsRule($this->getService('0136')); + } + + + public function createServiceRules__65(): PHPStan\Rules\Methods\FinalPrivateMethodRule + { + return new PHPStan\Rules\Methods\FinalPrivateMethodRule($this->getService('023')); + } + + + public function createServiceRules__66(): PHPStan\Rules\Methods\MethodCallableRule + { + return new PHPStan\Rules\Methods\MethodCallableRule($this->getService('0145'), $this->getService('023')); + } + + + public function createServiceRules__67(): PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule + { + return new PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule; + } + + + public function createServiceRules__68(): PHPStan\Rules\Methods\MissingMethodImplementationRule + { + return new PHPStan\Rules\Methods\MissingMethodImplementationRule; + } + + + public function createServiceRules__69(): PHPStan\Rules\Methods\MethodAttributesRule + { + return new PHPStan\Rules\Methods\MethodAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__7(): PHPStan\Rules\Api\ApiStaticCallRule + { + return new PHPStan\Rules\Api\ApiStaticCallRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__70(): PHPStan\Rules\Methods\StaticMethodCallableRule + { + return new PHPStan\Rules\Methods\StaticMethodCallableRule($this->getService('0146'), $this->getService('023')); + } + + + public function createServiceRules__71(): PHPStan\Rules\Names\UsedNamesRule + { + return new PHPStan\Rules\Names\UsedNamesRule; + } + + + public function createServiceRules__72(): PHPStan\Rules\Operators\InvalidAssignVarRule + { + return new PHPStan\Rules\Operators\InvalidAssignVarRule($this->getService('0150')); + } + + + public function createServiceRules__73(): PHPStan\Rules\Properties\AccessPropertiesInAssignRule + { + return new PHPStan\Rules\Properties\AccessPropertiesInAssignRule($this->getService('0355')); + } + + + public function createServiceRules__74(): PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule + { + return new PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule($this->getService('0356')); + } + + + public function createServiceRules__75(): PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule + { + return new PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule; + } + + + public function createServiceRules__76(): PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule + { + return new PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule($this->getService('0368')); + } + + + public function createServiceRules__77(): PHPStan\Rules\Properties\PropertiesInInterfaceRule + { + return new PHPStan\Rules\Properties\PropertiesInInterfaceRule; + } + + + public function createServiceRules__78(): PHPStan\Rules\Properties\PropertyAttributesRule + { + return new PHPStan\Rules\Properties\PropertyAttributesRule($this->getService('0118')); + } + + + public function createServiceRules__79(): PHPStan\Rules\Properties\ReadOnlyPropertyRule + { + return new PHPStan\Rules\Properties\ReadOnlyPropertyRule($this->getService('023')); + } + + + public function createServiceRules__8(): PHPStan\Rules\Api\ApiTraitUseRule + { + return new PHPStan\Rules\Api\ApiTraitUseRule($this->getService('0117'), $this->getService('reflectionProvider')); + } + + + public function createServiceRules__80(): PHPStan\Rules\Traits\ConflictingTraitConstantsRule + { + return new PHPStan\Rules\Traits\ConflictingTraitConstantsRule($this->getService('088')); + } + + + public function createServiceRules__81(): PHPStan\Rules\Traits\ConstantsInTraitsRule + { + return new PHPStan\Rules\Traits\ConstantsInTraitsRule($this->getService('023')); + } + + + public function createServiceRules__82(): PHPStan\Rules\Types\InvalidTypesInUnionRule + { + return new PHPStan\Rules\Types\InvalidTypesInUnionRule; + } + + + public function createServiceRules__83(): PHPStan\Rules\Variables\UnsetRule + { + return new PHPStan\Rules\Variables\UnsetRule; + } + + + public function createServiceRules__84(): PHPStan\Rules\Whitespace\FileWhitespaceRule + { + return new PHPStan\Rules\Whitespace\FileWhitespaceRule; + } + + + public function createServiceRules__85(): PHPStan\Rules\Classes\UnusedConstructorParametersRule + { + return new PHPStan\Rules\Classes\UnusedConstructorParametersRule($this->getService('0164')); + } + + + public function createServiceRules__86(): PHPStan\Rules\Constants\ConstantRule + { + return new PHPStan\Rules\Constants\ConstantRule; + } + + + public function createServiceRules__87(): PHPStan\Rules\Functions\UnusedClosureUsesRule + { + return new PHPStan\Rules\Functions\UnusedClosureUsesRule($this->getService('0164')); + } + + + public function createServiceRules__88(): PHPStan\Rules\Variables\EmptyRule + { + return new PHPStan\Rules\Variables\EmptyRule($this->getService('0144')); + } + + + public function createServiceRules__89(): PHPStan\Rules\Variables\IssetRule + { + return new PHPStan\Rules\Variables\IssetRule($this->getService('0144')); + } + + + public function createServiceRules__9(): PHPStan\Rules\Api\GetTemplateTypeRule + { + return new PHPStan\Rules\Api\GetTemplateTypeRule($this->getService('reflectionProvider')); + } + + + public function createServiceRules__90(): PHPStan\Rules\Variables\NullCoalesceRule + { + return new PHPStan\Rules\Variables\NullCoalesceRule($this->getService('0144')); + } + + + public function createServiceRules__91(): PHPStan\Rules\Cast\EchoRule + { + return new PHPStan\Rules\Cast\EchoRule($this->getService('0163')); + } + + + public function createServiceRules__92(): PHPStan\Rules\Cast\InvalidCastRule + { + return new PHPStan\Rules\Cast\InvalidCastRule($this->getService('reflectionProvider'), $this->getService('0163')); + } + + + public function createServiceRules__93(): PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule + { + return new PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule($this->getService('020'), $this->getService('0163')); + } + + + public function createServiceRules__94(): PHPStan\Rules\Cast\PrintRule + { + return new PHPStan\Rules\Cast\PrintRule($this->getService('0163')); + } + + + public function createServiceRules__95(): PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule + { + return new PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule; + } + + + public function createServiceRules__96(): PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule + { + return new PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule; + } + + + public function createServiceRules__97(): PHPStan\Rules\Constants\ValueAssignedToClassConstantRule + { + return new PHPStan\Rules\Constants\ValueAssignedToClassConstantRule; + } + + + public function createServiceRules__98(): PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule + { + return new PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule; + } + + + public function createServiceRules__99(): PHPStan\Rules\Generics\ClassAncestorsRule + { + return new PHPStan\Rules\Generics\ClassAncestorsRule($this->getService('0140'), $this->getService('0139')); + } + + + public function createServiceSimpleRelativePathHelper(): PHPStan\File\RelativePathHelper + { + return new PHPStan\File\SimpleRelativePathHelper('/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'); + } + + + public function createServiceStubPhpDocProvider(): PHPStan\PhpDoc\StubPhpDocProvider + { + return new PHPStan\PhpDoc\StubPhpDocProvider( + $this->getService('defaultAnalysisParser'), + $this->getService('0166'), + $this->getService('041') + ); + } + + + public function createServiceTypeSpecifier(): PHPStan\Analyser\TypeSpecifier + { + return $this->getService('typeSpecifierFactory')->create(); + } + + + public function createServiceTypeSpecifierFactory(): PHPStan\Analyser\TypeSpecifierFactory + { + return new PHPStan\Analyser\TypeSpecifierFactory($this->getService('068')); + } + + + public function initialize(): void + { + } + + + protected function getStaticParameters(): array + { + return [ + 'bootstrapFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionUnionType.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionAttribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/Attribute.php', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionIntersectionType.php', + ], + 'excludes_analyse' => [], + 'excludePaths' => null, + 'level' => 9, + 'paths' => ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php'], + 'exceptions' => [ + 'implicitThrows' => true, + 'reportUncheckedExceptionDeadCatch' => true, + 'uncheckedExceptionRegexes' => [], + 'uncheckedExceptionClasses' => [], + 'checkedExceptionRegexes' => [], + 'checkedExceptionClasses' => [], + 'check' => ['missingCheckedExceptionInThrows' => false, 'tooWideThrowType' => false], + ], + 'featureToggles' => [ + 'bleedingEdge' => false, + 'disableRuntimeReflectionProvider' => true, + 'skipCheckGenericClasses' => [ + 'DatePeriod', + 'CallbackFilterIterator', + 'FilterIterator', + 'RecursiveCallbackFilterIterator', + 'AppendIterator', + 'NoRewindIterator', + 'LimitIterator', + 'InfiniteIterator', + 'CachingIterator', + 'RegexIterator', + 'ReflectionEnum', + ], + 'explicitMixedInUnknownGenericNew' => false, + 'explicitMixedForGlobalVariables' => false, + 'explicitMixedViaIsArray' => false, + 'arrayFilter' => false, + 'arrayUnpacking' => false, + 'arrayValues' => false, + 'nodeConnectingVisitorCompatibility' => true, + 'nodeConnectingVisitorRule' => false, + 'illegalConstructorMethodCall' => false, + 'disableCheckMissingIterableValueType' => false, + 'strictUnnecessaryNullsafePropertyFetch' => false, + 'looseComparison' => false, + 'consistentConstructor' => false, + 'checkUnresolvableParameterTypes' => false, + 'readOnlyByPhpDoc' => false, + 'phpDocParserRequireWhitespaceBeforeDescription' => false, + 'phpDocParserIncludeLines' => false, + 'enableIgnoreErrorsWithinPhpDocs' => false, + 'runtimeReflectionRules' => false, + 'notAnalysedTrait' => false, + 'curlSetOptTypes' => false, + 'listType' => false, + 'abstractTraitMethod' => false, + 'missingMagicSerializationRule' => false, + 'nullContextForVoidReturningFunctions' => false, + 'unescapeStrings' => false, + 'alwaysCheckTooWideReturnTypeFinalMethods' => false, + 'duplicateStubs' => false, + 'logicalXor' => false, + 'betterNoop' => false, + 'invarianceComposition' => false, + 'alwaysTrueAlwaysReported' => false, + 'disableUnreachableBranchesRules' => false, + 'varTagType' => false, + 'closureDefaultParameterTypeRule' => false, + 'newRuleLevelHelper' => false, + 'instanceofType' => false, + 'paramOutVariance' => false, + 'allInvalidPhpDocs' => false, + 'strictStaticMethodTemplateTypeVariance' => false, + 'propertyVariance' => false, + 'genericPrototypeMessage' => false, + 'stricterFunctionMap' => false, + 'invalidPhpDocTagLine' => false, + 'detectDeadTypeInMultiCatch' => false, + 'zeroFiles' => false, + 'projectServicesNotInAnalysedPaths' => false, + 'callUserFunc' => false, + 'finalByPhpDoc' => false, + 'magicConstantOutOfContext' => false, + 'paramOutType' => false, + 'pure' => false, + 'checkParameterCastableToStringFunctions' => false, + 'uselessReturnValue' => false, + 'printfArrayParameters' => false, + 'preciseMissingReturn' => false, + 'validatePregQuote' => false, + 'noImplicitWildcard' => false, + 'narrowPregMatches' => true, + 'tooWidePropertyType' => false, + 'explicitThrow' => false, + 'absentTypeChecks' => false, + ], + 'fileExtensions' => ['php'], + 'checkAdvancedIsset' => true, + 'checkAlwaysTrueCheckTypeFunctionCall' => false, + 'checkAlwaysTrueInstanceof' => false, + 'checkAlwaysTrueStrictComparison' => false, + 'checkAlwaysTrueLooseComparison' => false, + 'reportAlwaysTrueInLastCondition' => false, + 'checkClassCaseSensitivity' => true, + 'checkExplicitMixed' => true, + 'checkImplicitMixed' => false, + 'checkFunctionArgumentTypes' => true, + 'checkFunctionNameCase' => false, + 'checkGenericClassInNonGenericObjectType' => true, + 'checkInternalClassCaseSensitivity' => false, + 'checkMissingIterableValueType' => true, + 'checkMissingCallableSignature' => false, + 'checkMissingVarTagTypehint' => true, + 'checkArgumentsPassedByReference' => true, + 'checkMaybeUndefinedVariables' => true, + 'checkNullables' => true, + 'checkThisOnly' => false, + 'checkUnionTypes' => true, + 'checkBenevolentUnionTypes' => false, + 'checkExplicitMixedMissingReturn' => false, + 'checkPhpDocMissingReturn' => true, + 'checkPhpDocMethodSignatures' => true, + 'checkExtraArguments' => true, + 'checkMissingTypehints' => true, + 'checkTooWideReturnTypesInProtectedAndPublicMethods' => false, + 'checkUninitializedProperties' => false, + 'checkDynamicProperties' => false, + 'deprecationRulesInstalled' => false, + 'inferPrivatePropertyTypeFromConstructor' => false, + 'reportMaybes' => true, + 'reportMaybesInMethodSignatures' => false, + 'reportMaybesInPropertyPhpDocTypes' => false, + 'reportStaticMethodSignatures' => false, + 'reportWrongPhpDocTypeInVarTag' => false, + 'reportAnyTypeWideningInVarTag' => false, + 'reportPossiblyNonexistentGeneralArrayOffset' => false, + 'reportPossiblyNonexistentConstantArrayOffset' => false, + 'checkMissingOverrideMethodAttribute' => false, + 'mixinExcludeClasses' => [], + 'scanFiles' => [], + 'scanDirectories' => ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php'], + 'parallel' => [ + 'jobSize' => 20, + 'processTimeout' => 600.0, + 'maximumNumberOfProcesses' => 32, + 'minimumNumberOfJobsPerProcess' => 2, + 'buffer' => 134217728, + ], + 'phpVersion' => null, + 'polluteScopeWithLoopInitialAssignments' => true, + 'polluteScopeWithAlwaysIterableForeach' => true, + 'propertyAlwaysWrittenTags' => [], + 'propertyAlwaysReadTags' => [], + 'additionalConstructors' => [], + 'treatPhpDocTypesAsCertain' => true, + 'usePathConstantsAsConstantString' => false, + 'rememberPossiblyImpureFunctionValues' => true, + 'tipsOfTheDay' => true, + 'reportMagicMethods' => true, + 'reportMagicProperties' => true, + 'ignoreErrors' => [], + 'internalErrorsCountLimit' => 50, + 'cache' => ['nodesByFileCountMax' => 1024, 'nodesByStringCountMax' => 256], + 'reportUnmatchedIgnoredErrors' => true, + 'scopeClass' => 'PHPStan\Analyser\MutatingScope', + 'typeAliases' => [], + 'universalObjectCratesClasses' => ['stdClass'], + 'stubFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionAttribute.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClass.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionClassConstant.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionFunctionAbstract.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionMethod.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionParameter.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ReflectionProperty.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/iterable.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ArrayObject.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/WeakReference.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ext-ds.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ImagickPixel.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/PDOStatement.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/date.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/ibm_db2.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/mysqli.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/zip.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/dom.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/spl.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/SplObjectStorage.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/Exception.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/arrayFunctions.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/core.stub', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/typeCheckingFunctions.stub', + ], + 'earlyTerminatingMethodCalls' => [], + 'earlyTerminatingFunctionCalls' => [], + 'memoryLimitFile' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/.memory_limit', + 'tempResultCachePath' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCaches', + 'resultCachePath' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan/resultCache.php', + 'resultCacheChecksProjectExtensionFilesDependencies' => false, + 'staticReflectionClassNamePatterns' => [], + 'dynamicConstantNames' => [ + 'ICONV_IMPL', + 'LIBXML_VERSION', + 'LIBXML_DOTTED_VERSION', + 'Memcached::HAVE_ENCODING', + 'Memcached::HAVE_IGBINARY', + 'Memcached::HAVE_JSON', + 'Memcached::HAVE_MSGPACK', + 'Memcached::HAVE_SASL', + 'Memcached::HAVE_SESSION', + 'PHP_VERSION', + 'PHP_MAJOR_VERSION', + 'PHP_MINOR_VERSION', + 'PHP_RELEASE_VERSION', + 'PHP_VERSION_ID', + 'PHP_EXTRA_VERSION', + 'PHP_WINDOWS_VERSION_MAJOR', + 'PHP_WINDOWS_VERSION_MINOR', + 'PHP_WINDOWS_VERSION_BUILD', + 'PHP_ZTS', + 'PHP_DEBUG', + 'PHP_MAXPATHLEN', + 'PHP_OS', + 'PHP_OS_FAMILY', + 'PHP_SAPI', + 'PHP_EOL', + 'PHP_INT_MAX', + 'PHP_INT_MIN', + 'PHP_INT_SIZE', + 'PHP_FLOAT_DIG', + 'PHP_FLOAT_EPSILON', + 'PHP_FLOAT_MIN', + 'PHP_FLOAT_MAX', + 'DEFAULT_INCLUDE_PATH', + 'PEAR_INSTALL_DIR', + 'PEAR_EXTENSION_DIR', + 'PHP_EXTENSION_DIR', + 'PHP_PREFIX', + 'PHP_BINDIR', + 'PHP_BINARY', + 'PHP_MANDIR', + 'PHP_LIBDIR', + 'PHP_DATADIR', + 'PHP_SYSCONFDIR', + 'PHP_LOCALSTATEDIR', + 'PHP_CONFIG_FILE_PATH', + 'PHP_CONFIG_FILE_SCAN_DIR', + 'PHP_SHLIB_SUFFIX', + 'PHP_FD_SETSIZE', + 'OPENSSL_VERSION_NUMBER', + 'ZEND_DEBUG_BUILD', + 'ZEND_THREAD_SAFE', + ], + 'customRulesetUsed' => false, + 'editorUrl' => null, + 'editorUrlTitle' => null, + 'errorFormat' => null, + 'sourceLocatorPlaygroundMode' => false, + '__validate' => true, + 'tmpDir' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan', + 'debugMode' => true, + 'productionMode' => false, + 'tempDir' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/../cache/phpstan', + 'rootDir' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan', + 'currentWorkingDirectory' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo', + 'cliArgumentsVariablesRegistered' => true, + 'additionalConfigFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/phpstan.neon', + ], + 'allConfigFiles' => [ + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon', + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/phpstan.neon', + ], + 'composerAutoloaderProjectPaths' => ['/home/sanderronde/git/phpstan-vscode/test/multi-config-demo'], + 'generateBaselineFile' => null, + 'usedLevel' => '9', + 'cliAutoloadFile' => null, + ]; + } + + + protected function getDynamicParameter($key) + { + switch (true) { + case $key === 'analysedPaths': return null; + case $key === 'analysedPathsFromConfig': return null; + case $key === 'env': return null; + case $key === 'fixerTmpDir': return ($this->getParameter('sysGetTempDir')) . '/phpstan-fixer'; + case $key === 'sysGetTempDir': return sys_get_temp_dir(); + case $key === 'pro': return [ + 'dnsServers' => ['1.1.1.2'], + 'tmpDir' => ($this->getParameter('sysGetTempDir')) . '/phpstan-fixer', + ]; + default: return parent::getDynamicParameter($key); + }; + } + + + public function getParameters(): array + { + array_map(function ($key) { $this->getParameter($key); }, [ + 'analysedPaths', + 'analysedPathsFromConfig', + 'env', + 'fixerTmpDir', + 'sysGetTempDir', + 'pro', + ]); + return parent::getParameters(); + } +} diff --git a/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php.lock b/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php.lock new file mode 100644 index 0000000..e69de29 diff --git a/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php.meta b/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php.meta new file mode 100644 index 0000000..250bef8 --- /dev/null +++ b/test/cache/phpstan/cache/nette.configurator/Container_9e7071f660.php.meta @@ -0,0 +1 @@ +a:6:{i:0;i:1;i:1;a:22:{s:119:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.neon";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/parametersSchema.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level9.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level8.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level7.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level6.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level5.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level4.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level3.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level2.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level1.neon";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/conf/config.level0.neon";i:1724750225;s:76:"/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/phpstan.neon";i:1726410431;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Extensions/ServicesExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Extensions/ParametersExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/bootstrap/src/Bootstrap/Extensions/PhpExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Extensions/ExtensionsExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/RulesExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ConditionalTagsExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ParametersSchemaExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ValidateIgnoredErrorsExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/ValidateExcludePathsExtension.php";i:1724750225;}i:2;a:722:{s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Debug/DumpTypeRule.php";i:1724750225;s:121:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Rule.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Debug/FileAssertRule.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInstantiationRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiClassExtendsRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiClassImplementsRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInterfaceExtendsRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiMethodCallRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiStaticCallRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiTraitUseRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/GetTemplateTypeRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/PhpStanNamespaceIn3rdPartyPackageRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/DuplicateKeysInLiteralArraysRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/EmptyArrayItemRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessWithoutDimForReadingRule.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/UnsetCastRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/AllowedSubTypesRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ClassAttributesRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ClassConstantAttributesRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ClassConstantRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/DuplicateDeclarationRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/EnumSanityRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassesInClassImplementsRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassesInEnumImplementsRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassesInInterfaceExtendsRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassInTraitUseRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/InstantiationRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/InstantiationCallableRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/InvalidPromotedPropertiesRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/LocalTypeAliasesRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/LocalTypeTraitAliasesRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/NewStaticRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/NonClassAttributeClassRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ReadOnlyClassRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/TraitAttributeClassRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/DynamicClassConstantFetchRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/FinalConstantRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/NativeTypedClassConstantRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/EnumCases/EnumCaseAttributesRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/NoncapturingCatchRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowExpressionRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrowFunctionAttributesRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrowFunctionReturnNullsafeByRefRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ClosureAttributesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/DefineParametersRule.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallToFunctionParametersRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ExistingClassesInClosureTypehintsRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ExistingClassesInTypehintsRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/FunctionAttributesRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/InnerFunctionRule.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/InvalidLexicalVariablesInClosureUseRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ParamAttributesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/PrintfParametersRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/RedefinedParametersRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ReturnNullsafeByRefRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Ignore/IgnoreParseErrorRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/VariadicParametersDeclarationRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Keywords/ContinueBreakInLoopRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Keywords/DeclareStrictTypesRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/AbstractMethodInNonAbstractClassRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/AbstractPrivateMethodRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallMethodsRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallStaticMethodsRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ConstructorReturnTypeRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ExistingClassesInTypehintsRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/FinalPrivateMethodRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodCallableRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodVisibilityInInterfaceRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodImplementationRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodAttributesRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/StaticMethodCallableRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Names/UsedNamesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidAssignVarRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessPropertiesInAssignRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessStaticPropertiesInAssignRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/InvalidCallablePropertyTypeRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/MissingReadOnlyPropertyAssignRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertiesInInterfaceRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertyAttributesRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyPropertyRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/ConflictingTraitConstantsRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/ConstantsInTraitsRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Types/InvalidTypesInUnionRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/UnsetRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Whitespace/FileWhitespaceRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/UnusedConstructorParametersRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/ConstantRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/UnusedClosureUsesRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/EmptyRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/IssetRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/NullCoalesceRule.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/EchoRule.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/InvalidCastRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/InvalidPartOfEncapsedStringRule.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Cast/PrintRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/AccessPrivateConstantThroughStaticRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/UsageOfVoidMatchExpressionRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/ValueAssignedToClassConstantRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/IncompatibleDefaultParameterTypeRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/ClassAncestorsRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/ClassTemplateTypeRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/EnumAncestorsRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/EnumTemplateTypeRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/FunctionTemplateTypeRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/FunctionSignatureVarianceRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/InterfaceAncestorsRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/InterfaceTemplateTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/MethodTemplateTypeRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/MethodTagTemplateTypeRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/MethodSignatureVarianceRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/TraitTemplateTypeRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/UsedTraitsRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallPrivateMethodThroughStaticRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/IncompatibleDefaultParameterTypeRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidComparisonOperationRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/FunctionConditionalReturnTypeRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/MethodConditionalReturnTypeRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/FunctionAssertRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/MethodAssertRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatibleSelfOutTypeRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatibleClassConstantPhpDocTypeRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidThrowsPhpDocValueRule.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/IncompatibleParamImmediatelyInvokedCallableRule.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessPrivatePropertyThroughStaticRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/RequireImplementsRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/RequireExtendsRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireImplementsDefinitionClassRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireExtendsDefinitionClassRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireExtendsDefinitionTraitRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/ArrayDestructuringRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/IterableInForeachRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessAssignmentRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessAssignOpRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/OffsetAccessValueAssignmentRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/UnpackIterableInArrayRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowExprTypeRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrowFunctionReturnTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ClosureReturnTypeRule.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ReturnTypeRule.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generators/YieldTypeRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ReturnTypeRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/DefaultValueTypesAssignedToPropertiesRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyPropertyAssignRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyPropertyAssignRefRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/TypesAssignedToPropertiesRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/ThrowTypeRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/VariableCloningRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/DeadForeachRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnreachableStatementRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnusedPrivateConstantRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnusedPrivateMethodRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/OverwrittenExitPointByFinallyRule.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallToFunctionStatementWithoutSideEffectsRule.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallToMethodStatementWithoutSideEffectsRule.php";i:1724750225;s:174:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallToStaticMethodStatementWithoutSideEffectsRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/NullsafeMethodCallRule.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideArrowFunctionReturnTypehintRule.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideClosureReturnTypehintRule.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DateTimeInstantiationRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/MissingClassConstantTypehintRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/MissingFunctionReturnTypehintRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodReturnTypehintRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/MissingPropertyTypehintRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/LexerFactory.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NameResolver.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitorAbstract.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/AnonymousClassVisitor.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrayFilterArgVisitor.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrayMapArgVisitor.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrayWalkArgVisitor.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ClosureArgVisitor.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ClosureBindToVarVisitor.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ClosureBindArgVisitor.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/CurlSetOptArgVisitor.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/TypeTraverserInstanceofVisitor.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ArrowFunctionArgVisitor.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/MagicConstantParamDefaultVisitor.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/NewAssignedToPropertyVisitor.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/ParentStmtTypesVisitor.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/TryCatchTypeVisitor.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/LastConditionVisitor.php";i:1724750225;s:178:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NodeConnectingVisitor.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Node/Printer/ExprPrinter.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Node/Printer/Printer.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinter/Standard.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Broker/AnonymousClassNameHelper.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Php/PhpVersionFactoryFactory.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Lexer/Lexer.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Parser/TypeParser.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Parser/PhpDocParser.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/ConstExprParserFactory.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/PhpDocInheritanceResolver.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/PhpDocNodeResolver.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/PhpDocStringResolver.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/ConstExprNodeResolver.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/TypeNodeResolver.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/TypeStringResolver.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubValidator.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/CountableStubFilesExtension.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubFilesExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/SocketSelectStubFilesExtension.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/DefaultStubFilesProvider.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubFilesProvider.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/JsonValidateStubFilesExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/ReflectionEnumStubFilesExtension.php";i:1724750225;s:128:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/Analyser.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/AnalyserResultFinalizer.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/FileAnalyser.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/LocalIgnoresProcessor.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/RuleErrorTransformer.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/Ignore/IgnoredErrorHelper.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/Ignore/IgnoreLexer.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/LazyInternalScopeFactory.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/InternalScopeFactory.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ScopeFactory.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/NodeScopeResolver.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ConstantResolverFactory.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ResultCache/ResultCacheClearer.php";i:1724750225;s:122:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Cache/Cache.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Collectors/RegistryFactory.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/AnalyseApplication.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/AnalyserRunner.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/FixerApplication.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/DependencyResolver.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/ExportedNodeFetcher.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/ExportedNodeResolver.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Dependency/ExportedNodeVisitor.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Nette/NetteContainer.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Container.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/DerivativeContainerFactory.php";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileHelper.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileExcluderFactory.php";i:1724750225;s:126:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileFinder.php";i:1724750225;s:127:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileMonitor.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/DeclarePositionVisitor.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parallel/ParallelAnalyser.php";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parallel/Scheduler.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Diagnose/DiagnoseExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/FunctionCallStatementFinder.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Process/CpuCoreCounter.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/InitializerExprTypeResolver.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Annotations/AnnotationsMethodsClassReflectionExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/MethodsClassReflectionExtension.php";i:1724750225;s:179:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Annotations/AnnotationsPropertiesClassReflectionExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/PropertiesClassReflectionExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/FileNodesFetcher.php";i:1724750225;s:199:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/ComposerJsonAndInstalledJsonSourceLocatorMaker.php";i:1724750225;s:191:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedDirectorySourceLocatorFactory.php";i:1724750225;s:194:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedDirectorySourceLocatorRepository.php";i:1724750225;s:195:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedSingleFileSourceLocatorRepository.php";i:1724750225;s:184:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/RequireExtension/RequireExtendsMethodsClassReflectionExtension.php";i:1724750225;s:187:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/RequireExtension/RequireExtendsPropertiesClassReflectionExtension.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Mixin/MixinMethodsClassReflectionExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Mixin/MixinPropertiesClassReflectionExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpClassReflectionExtension.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/Soap/SoapClientMethodsClassReflectionExtension.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/EnumAllowedSubTypesClassReflectionExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/AllowedSubTypesClassReflectionExtension.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/UniversalObjectCratesClassReflectionExtension.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/PHPStan/NativeReflectionEnumReturnDynamicReturnTypeExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicMethodReturnTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/NativeFunctionReflectionProvider.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/SignatureMapParser.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/FunctionSignatureMapProvider.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/SignatureMapProvider.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/Php8SignatureMapProvider.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/SignatureMap/SignatureMapProviderFactory.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiRuleHelper.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/AttributesCheck.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchCheck.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ClassNameCheck.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ClassCaseSensitivityCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ClassForbiddenNameCheck.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/LocalTypeAliasesCheck.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MethodTagCheck.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/PropertyTagCheck.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ConstantConditionRuleHelper.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeHelper.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/DefaultExceptionTypeResolver.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ExceptionTypeResolver.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/MissingCheckedExceptionInFunctionThrowsRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/MissingCheckedExceptionInMethodThrowsRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/MissingCheckedExceptionInThrowsCheck.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/TooWideFunctionThrowTypeRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/TooWideMethodThrowTypeRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/TooWideThrowTypeCheck.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/FunctionCallParametersCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/FunctionDefinitionCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/FunctionReturnTypeCheck.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/ParameterCastableToStringCheck.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/CrossCheckInterfacesHelper.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/GenericAncestorsCheck.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/GenericObjectTypeCheck.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/TemplateTypeCheck.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/VarianceCheck.php";i:1724750225;s:127:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/IssetCheck.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodCallCheck.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/StaticMethodCallCheck.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodSignatureRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MethodParameterComparisonHelper.php";i:1724750225;s:137:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/MissingTypehintCheck.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/NullsafeCheck.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/LazyAlwaysUsedClassConstantsExtensionProvider.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/ConditionalReturnTypeRuleHelper.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/AssertRuleHelper.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/UnresolvableTypeHelper.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/GenericCallableRuleHelper.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/VarTagTypeRuleHelper.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Playground/NeverRuleHelper.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertyDescriptor.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/PropertyReflectionFinder.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Pure/FunctionPurityCheck.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/RuleLevelHelper.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/UnusedFunctionParametersCheck.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideParameterOutTypeCheck.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FileTypeMapper.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/BitwiseFlagHelper.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/AbsFunctionDynamicReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicFunctionReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArgumentBasedFunctionReturnTypeExtension.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayIntersectKeyFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayChunkFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayColumnFunctionReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayCombineFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayCurrentDynamicReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFillFunctionReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFillKeysFunctionReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFilterFunctionReturnTypeReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayFlipFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyDynamicReturnTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyExistsFunctionTypeSpecifyingExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FunctionTypeSpecifyingExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/TypeSpecifierAwareExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyFirstDynamicReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeyLastDynamicReturnTypeExtension.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayKeysFunctionDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayMapFunctionReturnTypeExtension.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayMergeFunctionDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayNextDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayPopFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayRandFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayReduceFunctionReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayReplaceFunctionReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayReverseFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayShiftFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySliceFunctionReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySpliceFunctionReturnTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySearchFunctionDynamicReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySearchFunctionTypeSpecifyingExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayValuesFunctionDynamicReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArraySumFunctionDynamicReturnTypeExtension.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/AssertThrowTypeExtension.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicFunctionThrowTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/BackedEnumFromMethodDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicStaticMethodReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/Base64DecodeDynamicFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/BcMathStringOrNullReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClosureBindDynamicReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClosureBindToDynamicReturnTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClosureFromCallableDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CompactFunctionReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ConstantFunctionReturnTypeExtension.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ConstantHelper.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CountFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CountFunctionTypeSpecifyingExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CurlGetinfoFunctionDynamicReturnTypeExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CurlInitReturnTypeExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFunctionReturnTypeHelper.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFormatFunctionReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFormatMethodReturnTypeExtension.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateFunctionReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateIntervalConstructorThrowTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicStaticMethodThrowTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateIntervalDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeCreateDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeDynamicReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeModifyReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeConstructorThrowTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeModifyMethodThrowTypeExtension.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/DynamicMethodThrowTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DateTimeZoneConstructorThrowTypeExtension.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DsMapDynamicReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DsMapDynamicMethodThrowTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DioStatDynamicFunctionReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ExplodeFunctionDynamicReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterFunctionReturnTypeHelper.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterInputDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterVarDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FilterVarArrayDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetCalledClassDynamicReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetClassDynamicReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetDebugTypeFunctionReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GetParentClassDynamicFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GettypeFunctionReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/GettimeofdayDynamicFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/HashFunctionsReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/HighlightStringDynamicReturnTypeExtension.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IntdivThrowTypeExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IniGetReturnTypeExtension.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/JsonThrowTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregMatchTypeSpecifyingExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregMatchParameterOutTypeExtension.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FunctionParameterOutTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregReplaceCallbackClosureTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/FunctionParameterClosureTypeExtension.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RegexArrayShapeMatcher.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Regex/RegexGroupParser.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Regex/RegexExpressionHelper.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionClassConstructorThrowTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionFunctionConstructorThrowTypeExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionMethodConstructorThrowTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionPropertyConstructorThrowTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrContainingTypeSpecifyingExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementClassPropertyReflectionExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementConstructorThrowTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StatDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MethodExistsTypeSpecifyingExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PropertyExistsTypeSpecifyingExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MinMaxFunctionReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/NumberFormatFunctionDynamicReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PathinfoFunctionDynamicReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregFilterFunctionReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PregSplitDynamicReturnTypeExtension.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionClassIsSubclassOfTypeSpecifyingExtension.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/MethodTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReplaceFunctionsDynamicReturnTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ArrayPointerFunctionsDynamicReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/LtrimFunctionReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbFunctionsReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbFunctionsReturnTypeExtensionTrait.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbConvertEncodingFunctionReturnTypeExtension.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbSubstituteCharacterDynamicReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MbStrlenFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/MicrotimeFunctionReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/HrtimeFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ImplodeFunctionReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/NonEmptyStringFunctionsReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SetTypeFunctionTypeSpecifyingExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrCaseFunctionsReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrlenFunctionReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrIncrementDecrementFunctionReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrPadFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrRepeatFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SubstrDynamicReturnTypeExtension.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ThrowableReturnTypeExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ParseUrlFunctionDynamicReturnTypeExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/TriggerErrorDynamicReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/VersionCompareFunctionDynamicReturnTypeExtension.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/PowFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RoundFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrtotimeFunctionReturnTypeExtension.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RandomIntFunctionReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/RangeFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/AssertFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClassExistsFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ClassImplementsFunctionReturnTypeExtension.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DefineConstantTypeSpecifyingExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DefinedConstantTypeSpecifyingExtension.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/FunctionExistsFunctionTypeSpecifyingExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/InArrayFunctionTypeSpecifyingExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsArrayFunctionTypeSpecifyingExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsCallableFunctionTypeSpecifyingExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsIterableFunctionTypeSpecifyingExtension.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsSubclassOfFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IteratorToArrayFunctionReturnTypeExtension.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsAFunctionTypeSpecifyingExtension.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/IsAFunctionTypeSpecifyingHelper.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/CtypeDigitFunctionTypeSpecifyingExtension.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/JsonThrowOnErrorDynamicReturnTypeExtension.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/TypeSpecifyingFunctionsDynamicReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementAsXMLMethodReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SimpleXMLElementXpathMethodReturnTypeExtension.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrSplitFunctionReturnTypeExtension.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrTokFunctionReturnTypeExtension.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SprintfFunctionDynamicReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/SscanfFunctionDynamicReturnTypeExtension.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrvalFamilyFunctionReturnTypeExtension.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/StrWordCountFunctionDynamicReturnTypeExtension.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/XMLReaderOpenReturnTypeExtension.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/ReflectionGetAttributesMethodReturnTypeExtension.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Php/DatePeriodConstructorReturnTypeExtension.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/ClosureTypeFactory.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/Constant/OversizedArrayBuilder.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/PrintfHelper.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/TypeSpecifierFactory.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/ParentDirectoryRelativePathHelper.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/RelativePathHelper.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Broker/BrokerFactory.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Cache/FileCacheStorage.php";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Cache/CacheStorage.php";i:1724750225;s:128:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/RichParser.php";i:1724750225;s:124:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/Parser.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/CleaningParser.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/SimpleParser.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/CachedParser.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/PhpParserDecorator.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Parser.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Parser/Php7.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php";i:1724750225;s:129:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/LazyRegistry.php";i:1724750225;s:125:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Registry.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/StubPhpDocProvider.php";i:1724750225;s:166:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider/ReflectionProviderFactory.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider.php";i:1724750225;s:175:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/DefaultReflector.php";i:1724750225;s:168:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/Reflector.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/Reflector/MemoizingReflector.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/ClassReflector.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/FunctionReflector.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/Reflector/ConstantReflector.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/BetterReflectionProvider.php";i:1724750225;s:175:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/BetterReflectionSourceLocatorFactory.php";i:1724750225;s:186:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceStubber/PhpStormStubsSourceStubberFactory.php";i:1724750225;s:203:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/SourceStubber/PhpStormStubsSourceStubber.php";i:1724750225;s:190:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/SourceStubber/SourceStubber.php";i:1724750225;s:183:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceStubber/ReflectionSourceStubberFactory.php";i:1724750225;s:200:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/SourceStubber/ReflectionSourceStubber.php";i:1724750225;s:135:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Parser/PathRoutingParser.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Diagnose/PHPStanDiagnoseExtension.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/CiDetectedErrorFormatter.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/ErrorFormatter.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/RawErrorFormatter.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/TableErrorFormatter.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/CheckstyleErrorFormatter.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/JsonErrorFormatter.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/JunitErrorFormatter.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/GitlabErrorFormatter.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/GithubErrorFormatter.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Command/ErrorFormatter/TeamcityErrorFormatter.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiClassConstFetchRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInstanceofRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/ApiInstanceofTypeRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/NodeConnectingVisitorAttributesRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/RuntimeReflectionFunctionRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Api/RuntimeReflectionInstantiationRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassInClassExtendsRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ExistingClassInInstanceOfRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/CaughtExceptionExistenceRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallToNonExistentFunctionRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/OverridingConstantRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/OverridingMethodRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/ConsistentConstructorRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Missing/MissingReturnRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Namespaces/ExistingNamesInGroupUseRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Namespaces/ExistingNamesInUseRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidIncDecOperationRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessPropertiesRule.php";i:1724750225;s:154:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/AccessStaticPropertiesRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ExistingClassesInPropertiesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/FunctionCallableRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/OverridingPropertyRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyByPhpDocPropertyRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/UninitializedPropertyRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/WritingToReadOnlyPropertiesRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadingWriteOnlyPropertiesRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/CompactVariablesRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/DefinedVariableRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Regexp/RegularExpressionPatternRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ConstructorsHelper.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMagicSerializationMethodsRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Constants/MagicConstantContextRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/UselessFunctionReturnValueRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/PrintfArrayParametersRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Regexp/RegularExpressionQuotingRule.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MixinRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MethodTagRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/MethodTagTraitRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/PropertyTagRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/PropertyTagTraitRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireExtendsCheck.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/RequireImplementsDefinitionTraitRule.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/IncompatibleArrowFunctionDefaultParameterTypeRule.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/IncompatibleClosureDefaultParameterTypeRule.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallCallablesRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/IllegalConstructorMethodCallRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/IllegalConstructorStaticCallRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidPhpDocTagValueRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/InvalidPHPStanDocTagRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/VarTagChangedExpressionTypeRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/PhpDoc/WrongVariableNameInVarTagRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generics/PropertyVarianceRule.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Pure/PureFunctionRule.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Pure/PureMethodRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidBinaryOperationRule.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Operators/InvalidUnaryOperationRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/InvalidKeyInArrayDimFetchRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/InvalidKeyInArrayItemRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchRule.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowsVoidFunctionWithExplicitThrowPointRule.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/ThrowsVoidMethodWithExplicitThrowPointRule.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generators/YieldFromTypeRule.php";i:1724750225;s:148:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Generators/YieldInGeneratorRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Arrays/ArrayUnpackingRule.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRefRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/ParameterOutAssignedTypeRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Variables/ParameterOutExecutionEndTypeRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Classes/ImpossibleInstanceOfRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/BooleanAndConstantConditionRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/BooleanOrConstantConditionRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/BooleanNotConstantConditionRule.php";i:1724750225;s:134:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/NoopRule.php";i:1724750225;s:175:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToConstructorStatementWithoutImpurePointsRule.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/ConstructorWithoutImpurePointsCollector.php";i:1724750225;s:131:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Collectors/Collector.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureNewCollector.php";i:1724750225;s:172:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToFunctionStatementWithoutImpurePointsRule.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/FunctionWithoutImpurePointsCollector.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureFuncCallCollector.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToMethodStatementWithoutImpurePointsRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/MethodWithoutImpurePointsCollector.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureMethodCallCollector.php";i:1724750225;s:176:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/CallToStaticMethodStatementWithoutImpurePointsRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/PossiblyPureStaticCallCollector.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/UnusedPrivatePropertyRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/DoWhileLoopConstantConditionRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ElseIfConstantConditionRule.php";i:1724750225;s:151:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/IfConstantConditionRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/LogicalXorConstantConditionRule.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/DeadCode/BetterNoopRule.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/MatchExpressionRule.php";i:1724750225;s:174:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php";i:1724750225;s:155:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/ConstantLooseComparisonRule.php";i:1724750225;s:164:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/TernaryOperatorConstantConditionRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/UnreachableIfBranchesRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/UnreachableTernaryElseBranchRule.php";i:1724750225;s:161:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/WhileLoopAlwaysFalseConditionRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Comparison/WhileLoopAlwaysTrueConditionRule.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/CallToConstructorStatementWithoutSideEffectsRule.php";i:1724750225;s:165:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Properties/NullsafePropertyFetchRule.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/TraitDeclarationCollector.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/TraitUseCollector.php";i:1724750225;s:144:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Traits/NotAnalysedTraitRule.php";i:1724750225;s:158:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Exceptions/CatchWithUnthrownExceptionRule.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideFunctionParameterOutTypeRule.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWideMethodParameterOutTypeRule.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/RandomIntParametersRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrayFilterRule.php";i:1724750225;s:142:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ArrayValuesRule.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/CallUserFuncRule.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ImplodeFunctionRule.php";i:1724750225;s:156:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ParameterCastableToStringRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/ImplodeParameterCastableToStringRule.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/SortParameterCastableToStringRule.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Functions/MissingFunctionParameterTypehintRule.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodParameterTypehintRule.php";i:1724750225;s:153:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Rules/Methods/MissingMethodSelfOutTypeRule.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/di/src/DI/Container.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nette/utils/src/SmartObject.php";i:1724750225;s:132:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Php/PhpVersionFactory.php";i:1724750225;s:125:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Php/PhpVersion.php";i:1724750225;s:162:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/phpstan/phpdoc-parser/src/Parser/ConstExprParser.php";i:1724750225;s:163:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php";i:1724750225;s:159:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/PhpDoc/TypeNodeResolverExtensionRegistryProvider.php";i:1724750225;s:136:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ConstantResolver.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ResultCache/ResultCacheManager.php";i:1724750225;s:157:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/ResultCache/ResultCacheManagerFactory.php";i:1724750225;s:130:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Collectors/Registry.php";i:1724750225;s:149:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/MemoizingContainer.php";i:1724750225;s:186:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Reflection/ClassReflectionExtensionRegistryProvider.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyDynamicReturnTypeExtensionRegistryProvider.php";i:1724750225;s:178:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyParameterOutTypeExtensionProvider.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/ParameterOutTypeExtensionProvider.php";i:1724750225;s:187:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyExpressionTypeResolverExtensionRegistryProvider.php";i:1724750225;s:183:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/ExpressionTypeResolverExtensionRegistryProvider.php";i:1724750225;s:187:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyOperatorTypeSpecifyingExtensionRegistryProvider.php";i:1724750225;s:183:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyDynamicThrowTypeExtensionProvider.php";i:1724750225;s:169:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/DynamicThrowTypeExtensionProvider.php";i:1724750225;s:177:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/LazyParameterClosureTypeExtensionProvider.php";i:1724750225;s:173:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/DependencyInjection/Type/ParameterClosureTypeExtensionProvider.php";i:1724750225;s:128:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileExcluder.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FileExcluderRawFactory.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpFunctionReflection.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/FunctionReflection.php";i:1724750225;s:147:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/FunctionReflectionFactory.php";i:1724750225;s:182:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedPsrAutoloaderLocator.php";i:1724750225;s:181:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/ondrejmirtes/better-reflection/src/SourceLocator/Type/SourceLocator.php";i:1724750225;s:189:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedPsrAutoloaderLocatorFactory.php";i:1724750225;s:185:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedSingleFileSourceLocator.php";i:1724750225;s:192:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/SourceLocator/OptimizedSingleFileSourceLocatorFactory.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpMethodReflection.php";i:1724750225;s:146:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ExtendedMethodReflection.php";i:1724750225;s:143:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ClassMemberReflection.php";i:1724750225;s:138:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/MethodReflection.php";i:1724750225;s:152:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/Php/PhpMethodReflectionFactory.php";i:1724750225;s:171:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider/LazyReflectionProviderProvider.php";i:1724750225;s:167:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/ReflectionProvider/ReflectionProviderProvider.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/UsefulTypeAliasResolver.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/TypeAliasResolver.php";i:1724750225;s:145:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/LazyTypeAliasResolverProvider.php";i:1724750225;s:141:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Type/TypeAliasResolverProvider.php";i:1724750225;s:133:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Analyser/TypeSpecifier.php";i:1724750225;s:139:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/FuzzyRelativePathHelper.php";i:1724750225;s:140:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/File/SimpleRelativePathHelper.php";i:1724750225;s:124:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Broker/Broker.php";i:1724750225;s:150:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Lexer.php";i:1724750225;s:170:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/src/Reflection/BetterReflection/BetterReflectionProviderFactory.php";i:1724750225;s:160:"phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/vendor/nikic/php-parser/lib/PhpParser/Lexer/Emulative.php";i:1724750225;}i:3;a:708:{i:0;s:32:"PHPStan\Rules\Debug\DumpTypeRule";i:1;s:18:"PHPStan\Rules\Rule";i:2;s:34:"PHPStan\Rules\Debug\FileAssertRule";i:3;s:38:"PHPStan\Rules\Api\ApiInstantiationRule";i:4;s:37:"PHPStan\Rules\Api\ApiClassExtendsRule";i:5;s:40:"PHPStan\Rules\Api\ApiClassImplementsRule";i:6;s:41:"PHPStan\Rules\Api\ApiInterfaceExtendsRule";i:7;s:35:"PHPStan\Rules\Api\ApiMethodCallRule";i:8;s:35:"PHPStan\Rules\Api\ApiStaticCallRule";i:9;s:33:"PHPStan\Rules\Api\ApiTraitUseRule";i:10;s:37:"PHPStan\Rules\Api\GetTemplateTypeRule";i:11;s:55:"PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule";i:12;s:53:"PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule";i:13;s:39:"PHPStan\Rules\Arrays\EmptyArrayItemRule";i:14;s:57:"PHPStan\Rules\Arrays\OffsetAccessWithoutDimForReadingRule";i:15;s:32:"PHPStan\Rules\Cast\UnsetCastRule";i:16;s:41:"PHPStan\Rules\Classes\AllowedSubTypesRule";i:17;s:41:"PHPStan\Rules\Classes\ClassAttributesRule";i:18;s:49:"PHPStan\Rules\Classes\ClassConstantAttributesRule";i:19;s:39:"PHPStan\Rules\Classes\ClassConstantRule";i:20;s:46:"PHPStan\Rules\Classes\DuplicateDeclarationRule";i:21;s:36:"PHPStan\Rules\Classes\EnumSanityRule";i:22;s:58:"PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule";i:23;s:57:"PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule";i:24;s:59:"PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule";i:25;s:49:"PHPStan\Rules\Classes\ExistingClassInTraitUseRule";i:26;s:39:"PHPStan\Rules\Classes\InstantiationRule";i:27;s:47:"PHPStan\Rules\Classes\InstantiationCallableRule";i:28;s:51:"PHPStan\Rules\Classes\InvalidPromotedPropertiesRule";i:29;s:42:"PHPStan\Rules\Classes\LocalTypeAliasesRule";i:30;s:47:"PHPStan\Rules\Classes\LocalTypeTraitAliasesRule";i:31;s:35:"PHPStan\Rules\Classes\NewStaticRule";i:32;s:48:"PHPStan\Rules\Classes\NonClassAttributeClassRule";i:33;s:39:"PHPStan\Rules\Classes\ReadOnlyClassRule";i:34;s:45:"PHPStan\Rules\Classes\TraitAttributeClassRule";i:35;s:53:"PHPStan\Rules\Constants\DynamicClassConstantFetchRule";i:36;s:41:"PHPStan\Rules\Constants\FinalConstantRule";i:37;s:52:"PHPStan\Rules\Constants\NativeTypedClassConstantRule";i:38;s:46:"PHPStan\Rules\EnumCases\EnumCaseAttributesRule";i:39;s:46:"PHPStan\Rules\Exceptions\NoncapturingCatchRule";i:40;s:44:"PHPStan\Rules\Exceptions\ThrowExpressionRule";i:41;s:51:"PHPStan\Rules\Functions\ArrowFunctionAttributesRule";i:42;s:60:"PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule";i:43;s:45:"PHPStan\Rules\Functions\ClosureAttributesRule";i:44;s:44:"PHPStan\Rules\Functions\DefineParametersRule";i:45;s:67:"PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule";i:46;s:52:"PHPStan\Rules\Functions\CallToFunctionParametersRule";i:47;s:61:"PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule";i:48;s:54:"PHPStan\Rules\Functions\ExistingClassesInTypehintsRule";i:49;s:46:"PHPStan\Rules\Functions\FunctionAttributesRule";i:50;s:41:"PHPStan\Rules\Functions\InnerFunctionRule";i:51;s:63:"PHPStan\Rules\Functions\InvalidLexicalVariablesInClosureUseRule";i:52;s:43:"PHPStan\Rules\Functions\ParamAttributesRule";i:53;s:44:"PHPStan\Rules\Functions\PrintfParametersRule";i:54;s:47:"PHPStan\Rules\Functions\RedefinedParametersRule";i:55;s:47:"PHPStan\Rules\Functions\ReturnNullsafeByRefRule";i:56;s:41:"PHPStan\Rules\Ignore\IgnoreParseErrorRule";i:57;s:57:"PHPStan\Rules\Functions\VariadicParametersDeclarationRule";i:58;s:46:"PHPStan\Rules\Keywords\ContinueBreakInLoopRule";i:59;s:45:"PHPStan\Rules\Keywords\DeclareStrictTypesRule";i:60;s:58:"PHPStan\Rules\Methods\AbstractMethodInNonAbstractClassRule";i:61;s:47:"PHPStan\Rules\Methods\AbstractPrivateMethodRule";i:62;s:37:"PHPStan\Rules\Methods\CallMethodsRule";i:63;s:43:"PHPStan\Rules\Methods\CallStaticMethodsRule";i:64;s:47:"PHPStan\Rules\Methods\ConstructorReturnTypeRule";i:65;s:52:"PHPStan\Rules\Methods\ExistingClassesInTypehintsRule";i:66;s:44:"PHPStan\Rules\Methods\FinalPrivateMethodRule";i:67;s:40:"PHPStan\Rules\Methods\MethodCallableRule";i:68;s:53:"PHPStan\Rules\Methods\MethodVisibilityInInterfaceRule";i:69;s:53:"PHPStan\Rules\Methods\MissingMethodImplementationRule";i:70;s:42:"PHPStan\Rules\Methods\MethodAttributesRule";i:71;s:46:"PHPStan\Rules\Methods\StaticMethodCallableRule";i:72;s:33:"PHPStan\Rules\Names\UsedNamesRule";i:73;s:44:"PHPStan\Rules\Operators\InvalidAssignVarRule";i:74;s:53:"PHPStan\Rules\Properties\AccessPropertiesInAssignRule";i:75;s:59:"PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule";i:76;s:56:"PHPStan\Rules\Properties\InvalidCallablePropertyTypeRule";i:77;s:58:"PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule";i:78;s:50:"PHPStan\Rules\Properties\PropertiesInInterfaceRule";i:79;s:47:"PHPStan\Rules\Properties\PropertyAttributesRule";i:80;s:45:"PHPStan\Rules\Properties\ReadOnlyPropertyRule";i:81;s:50:"PHPStan\Rules\Traits\ConflictingTraitConstantsRule";i:82;s:42:"PHPStan\Rules\Traits\ConstantsInTraitsRule";i:83;s:43:"PHPStan\Rules\Types\InvalidTypesInUnionRule";i:84;s:33:"PHPStan\Rules\Variables\UnsetRule";i:85;s:43:"PHPStan\Rules\Whitespace\FileWhitespaceRule";i:86;s:53:"PHPStan\Rules\Classes\UnusedConstructorParametersRule";i:87;s:36:"PHPStan\Rules\Constants\ConstantRule";i:88;s:45:"PHPStan\Rules\Functions\UnusedClosureUsesRule";i:89;s:33:"PHPStan\Rules\Variables\EmptyRule";i:90;s:33:"PHPStan\Rules\Variables\IssetRule";i:91;s:40:"PHPStan\Rules\Variables\NullCoalesceRule";i:92;s:27:"PHPStan\Rules\Cast\EchoRule";i:93;s:34:"PHPStan\Rules\Cast\InvalidCastRule";i:94;s:50:"PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule";i:95;s:28:"PHPStan\Rules\Cast\PrintRule";i:96;s:60:"PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule";i:97;s:55:"PHPStan\Rules\Comparison\UsageOfVoidMatchExpressionRule";i:98;s:56:"PHPStan\Rules\Constants\ValueAssignedToClassConstantRule";i:99;s:60:"PHPStan\Rules\Functions\IncompatibleDefaultParameterTypeRule";i:100;s:41:"PHPStan\Rules\Generics\ClassAncestorsRule";i:101;s:44:"PHPStan\Rules\Generics\ClassTemplateTypeRule";i:102;s:40:"PHPStan\Rules\Generics\EnumAncestorsRule";i:103;s:43:"PHPStan\Rules\Generics\EnumTemplateTypeRule";i:104;s:47:"PHPStan\Rules\Generics\FunctionTemplateTypeRule";i:105;s:52:"PHPStan\Rules\Generics\FunctionSignatureVarianceRule";i:106;s:45:"PHPStan\Rules\Generics\InterfaceAncestorsRule";i:107;s:48:"PHPStan\Rules\Generics\InterfaceTemplateTypeRule";i:108;s:45:"PHPStan\Rules\Generics\MethodTemplateTypeRule";i:109;s:48:"PHPStan\Rules\Generics\MethodTagTemplateTypeRule";i:110;s:50:"PHPStan\Rules\Generics\MethodSignatureVarianceRule";i:111;s:44:"PHPStan\Rules\Generics\TraitTemplateTypeRule";i:112;s:37:"PHPStan\Rules\Generics\UsedTraitsRule";i:113;s:56:"PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule";i:114;s:58:"PHPStan\Rules\Methods\IncompatibleDefaultParameterTypeRule";i:115;s:54:"PHPStan\Rules\Operators\InvalidComparisonOperationRule";i:116;s:54:"PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule";i:117;s:52:"PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule";i:118;s:39:"PHPStan\Rules\PhpDoc\FunctionAssertRule";i:119;s:37:"PHPStan\Rules\PhpDoc\MethodAssertRule";i:120;s:48:"PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule";i:121;s:60:"PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule";i:122;s:47:"PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule";i:123;s:55:"PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule";i:124;s:49:"PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule";i:125;s:68:"PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule";i:126;s:63:"PHPStan\Rules\Properties\AccessPrivatePropertyThroughStaticRule";i:127;s:43:"PHPStan\Rules\Classes\RequireImplementsRule";i:128;s:40:"PHPStan\Rules\Classes\RequireExtendsRule";i:129;s:57:"PHPStan\Rules\PhpDoc\RequireImplementsDefinitionClassRule";i:130;s:54:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule";i:131;s:54:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule";i:132;s:43:"PHPStan\Rules\Arrays\ArrayDestructuringRule";i:133;s:42:"PHPStan\Rules\Arrays\IterableInForeachRule";i:134;s:47:"PHPStan\Rules\Arrays\OffsetAccessAssignmentRule";i:135;s:45:"PHPStan\Rules\Arrays\OffsetAccessAssignOpRule";i:136;s:52:"PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule";i:137;s:46:"PHPStan\Rules\Arrays\UnpackIterableInArrayRule";i:138;s:42:"PHPStan\Rules\Exceptions\ThrowExprTypeRule";i:139;s:51:"PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule";i:140;s:45:"PHPStan\Rules\Functions\ClosureReturnTypeRule";i:141;s:38:"PHPStan\Rules\Functions\ReturnTypeRule";i:142;s:38:"PHPStan\Rules\Generators\YieldTypeRule";i:143;s:36:"PHPStan\Rules\Methods\ReturnTypeRule";i:144;s:66:"PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule";i:145;s:51:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule";i:146;s:54:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule";i:147;s:54:"PHPStan\Rules\Properties\TypesAssignedToPropertiesRule";i:148;s:37:"PHPStan\Rules\Variables\ThrowTypeRule";i:149;s:43:"PHPStan\Rules\Variables\VariableCloningRule";i:150;s:36:"PHPStan\Rules\Arrays\DeadForeachRule";i:151;s:47:"PHPStan\Rules\DeadCode\UnreachableStatementRule";i:152;s:48:"PHPStan\Rules\DeadCode\UnusedPrivateConstantRule";i:153;s:46:"PHPStan\Rules\DeadCode\UnusedPrivateMethodRule";i:154;s:58:"PHPStan\Rules\Exceptions\OverwrittenExitPointByFinallyRule";i:155;s:69:"PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule";i:156;s:65:"PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule";i:157;s:71:"PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule";i:158;s:44:"PHPStan\Rules\Methods\NullsafeMethodCallRule";i:159;s:69:"PHPStan\Rules\TooWideTypehints\TooWideArrowFunctionReturnTypehintRule";i:160;s:63:"PHPStan\Rules\TooWideTypehints\TooWideClosureReturnTypehintRule";i:161;s:64:"PHPStan\Rules\TooWideTypehints\TooWideFunctionReturnTypehintRule";i:162;s:39:"PHPStan\Rules\DateTimeInstantiationRule";i:163;s:56:"PHPStan\Rules\Constants\MissingClassConstantTypehintRule";i:164;s:57:"PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule";i:165;s:53:"PHPStan\Rules\Methods\MissingMethodReturnTypehintRule";i:166;s:52:"PHPStan\Rules\Properties\MissingPropertyTypehintRule";i:167;s:24:"PhpParser\BuilderFactory";i:168;s:27:"PHPStan\Parser\LexerFactory";i:169;s:34:"PhpParser\NodeVisitor\NameResolver";i:170;s:29:"PhpParser\NodeVisitorAbstract";i:171;s:21:"PhpParser\NodeVisitor";i:172;s:36:"PHPStan\Parser\AnonymousClassVisitor";i:173;s:36:"PHPStan\Parser\ArrayFilterArgVisitor";i:174;s:33:"PHPStan\Parser\ArrayMapArgVisitor";i:175;s:34:"PHPStan\Parser\ArrayWalkArgVisitor";i:176;s:32:"PHPStan\Parser\ClosureArgVisitor";i:177;s:38:"PHPStan\Parser\ClosureBindToVarVisitor";i:178;s:36:"PHPStan\Parser\ClosureBindArgVisitor";i:179;s:35:"PHPStan\Parser\CurlSetOptArgVisitor";i:180;s:45:"PHPStan\Parser\TypeTraverserInstanceofVisitor";i:181;s:38:"PHPStan\Parser\ArrowFunctionArgVisitor";i:182;s:47:"PHPStan\Parser\MagicConstantParamDefaultVisitor";i:183;s:43:"PHPStan\Parser\NewAssignedToPropertyVisitor";i:184;s:37:"PHPStan\Parser\ParentStmtTypesVisitor";i:185;s:34:"PHPStan\Parser\TryCatchTypeVisitor";i:186;s:35:"PHPStan\Parser\LastConditionVisitor";i:187;s:43:"PhpParser\NodeVisitor\NodeConnectingVisitor";i:188;s:32:"PHPStan\Node\Printer\ExprPrinter";i:189;s:28:"PHPStan\Node\Printer\Printer";i:190;s:32:"PhpParser\PrettyPrinter\Standard";i:191;s:31:"PhpParser\PrettyPrinterAbstract";i:192;s:39:"PHPStan\Broker\AnonymousClassNameHelper";i:193;s:36:"PHPStan\Php\PhpVersionFactoryFactory";i:194;s:32:"PHPStan\PhpDocParser\Lexer\Lexer";i:195;s:38:"PHPStan\PhpDocParser\Parser\TypeParser";i:196;s:40:"PHPStan\PhpDocParser\Parser\PhpDocParser";i:197;s:37:"PHPStan\PhpDoc\ConstExprParserFactory";i:198;s:40:"PHPStan\PhpDoc\PhpDocInheritanceResolver";i:199;s:33:"PHPStan\PhpDoc\PhpDocNodeResolver";i:200;s:35:"PHPStan\PhpDoc\PhpDocStringResolver";i:201;s:36:"PHPStan\PhpDoc\ConstExprNodeResolver";i:202;s:31:"PHPStan\PhpDoc\TypeNodeResolver";i:203;s:33:"PHPStan\PhpDoc\TypeStringResolver";i:204;s:28:"PHPStan\PhpDoc\StubValidator";i:205;s:42:"PHPStan\PhpDoc\CountableStubFilesExtension";i:206;s:33:"PHPStan\PhpDoc\StubFilesExtension";i:207;s:45:"PHPStan\PhpDoc\SocketSelectStubFilesExtension";i:208;s:39:"PHPStan\PhpDoc\DefaultStubFilesProvider";i:209;s:32:"PHPStan\PhpDoc\StubFilesProvider";i:210;s:45:"PHPStan\PhpDoc\JsonValidateStubFilesExtension";i:211;s:47:"PHPStan\PhpDoc\ReflectionEnumStubFilesExtension";i:212;s:25:"PHPStan\Analyser\Analyser";i:213;s:40:"PHPStan\Analyser\AnalyserResultFinalizer";i:214;s:29:"PHPStan\Analyser\FileAnalyser";i:215;s:38:"PHPStan\Analyser\LocalIgnoresProcessor";i:216;s:37:"PHPStan\Analyser\RuleErrorTransformer";i:217;s:42:"PHPStan\Analyser\Ignore\IgnoredErrorHelper";i:218;s:35:"PHPStan\Analyser\Ignore\IgnoreLexer";i:219;s:41:"PHPStan\Analyser\LazyInternalScopeFactory";i:220;s:37:"PHPStan\Analyser\InternalScopeFactory";i:221;s:29:"PHPStan\Analyser\ScopeFactory";i:222;s:34:"PHPStan\Analyser\NodeScopeResolver";i:223;s:40:"PHPStan\Analyser\ConstantResolverFactory";i:224;s:47:"PHPStan\Analyser\ResultCache\ResultCacheClearer";i:225;s:19:"PHPStan\Cache\Cache";i:226;s:34:"PHPStan\Collectors\RegistryFactory";i:227;s:34:"PHPStan\Command\AnalyseApplication";i:228;s:30:"PHPStan\Command\AnalyserRunner";i:229;s:32:"PHPStan\Command\FixerApplication";i:230;s:37:"PHPStan\Dependency\DependencyResolver";i:231;s:38:"PHPStan\Dependency\ExportedNodeFetcher";i:232;s:39:"PHPStan\Dependency\ExportedNodeResolver";i:233;s:38:"PHPStan\Dependency\ExportedNodeVisitor";i:234;s:48:"PHPStan\DependencyInjection\Nette\NetteContainer";i:235;s:37:"PHPStan\DependencyInjection\Container";i:236;s:54:"PHPStan\DependencyInjection\DerivativeContainerFactory";i:237;s:23:"PHPStan\File\FileHelper";i:238;s:32:"PHPStan\File\FileExcluderFactory";i:239;s:23:"PHPStan\File\FileFinder";i:240;s:24:"PHPStan\File\FileMonitor";i:241;s:37:"PHPStan\Parser\DeclarePositionVisitor";i:242;s:33:"PHPStan\Parallel\ParallelAnalyser";i:243;s:26:"PHPStan\Parallel\Scheduler";i:244;s:34:"PHPStan\Diagnose\DiagnoseExtension";i:245;s:42:"PHPStan\Parser\FunctionCallStatementFinder";i:246;s:30:"PHPStan\Process\CpuCoreCounter";i:247;s:46:"PHPStan\Reflection\InitializerExprTypeResolver";i:248;s:73:"PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension";i:249;s:50:"PHPStan\Reflection\MethodsClassReflectionExtension";i:250;s:76:"PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension";i:251;s:53:"PHPStan\Reflection\PropertiesClassReflectionExtension";i:252;s:64:"PHPStan\Reflection\BetterReflection\SourceLocator\CachingVisitor";i:253;s:66:"PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher";i:254;s:96:"PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker";i:255;s:88:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory";i:256;s:91:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository";i:257;s:92:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository";i:258;s:81:"PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension";i:259;s:84:"PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension";i:260;s:61:"PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension";i:261;s:64:"PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension";i:262;s:50:"PHPStan\Reflection\Php\PhpClassReflectionExtension";i:263;s:69:"PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension";i:264;s:66:"PHPStan\Reflection\Php\EnumAllowedSubTypesClassReflectionExtension";i:265;s:58:"PHPStan\Reflection\AllowedSubTypesClassReflectionExtension";i:266;s:68:"PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension";i:267;s:79:"PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension";i:268;s:45:"PHPStan\Type\DynamicMethodReturnTypeExtension";i:269;s:64:"PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider";i:270;s:50:"PHPStan\Reflection\SignatureMap\SignatureMapParser";i:271;s:60:"PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider";i:272;s:52:"PHPStan\Reflection\SignatureMap\SignatureMapProvider";i:273;s:56:"PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider";i:274;s:59:"PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory";i:275;s:31:"PHPStan\Rules\Api\ApiRuleHelper";i:276;s:29:"PHPStan\Rules\AttributesCheck";i:277;s:58:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck";i:278;s:28:"PHPStan\Rules\ClassNameCheck";i:279;s:39:"PHPStan\Rules\ClassCaseSensitivityCheck";i:280;s:37:"PHPStan\Rules\ClassForbiddenNameCheck";i:281;s:43:"PHPStan\Rules\Classes\LocalTypeAliasesCheck";i:282;s:36:"PHPStan\Rules\Classes\MethodTagCheck";i:283;s:38:"PHPStan\Rules\Classes\PropertyTagCheck";i:284;s:52:"PHPStan\Rules\Comparison\ConstantConditionRuleHelper";i:285;s:50:"PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper";i:286;s:53:"PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver";i:287;s:46:"PHPStan\Rules\Exceptions\ExceptionTypeResolver";i:288;s:68:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule";i:289;s:66:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule";i:290;s:61:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck";i:291;s:53:"PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule";i:292;s:51:"PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule";i:293;s:46:"PHPStan\Rules\Exceptions\TooWideThrowTypeCheck";i:294;s:41:"PHPStan\Rules\FunctionCallParametersCheck";i:295;s:37:"PHPStan\Rules\FunctionDefinitionCheck";i:296;s:37:"PHPStan\Rules\FunctionReturnTypeCheck";i:297;s:44:"PHPStan\Rules\ParameterCastableToStringCheck";i:298;s:49:"PHPStan\Rules\Generics\CrossCheckInterfacesHelper";i:299;s:44:"PHPStan\Rules\Generics\GenericAncestorsCheck";i:300;s:45:"PHPStan\Rules\Generics\GenericObjectTypeCheck";i:301;s:40:"PHPStan\Rules\Generics\TemplateTypeCheck";i:302;s:36:"PHPStan\Rules\Generics\VarianceCheck";i:303;s:24:"PHPStan\Rules\IssetCheck";i:304;s:37:"PHPStan\Rules\Methods\MethodCallCheck";i:305;s:43:"PHPStan\Rules\Methods\StaticMethodCallCheck";i:306;s:41:"PHPStan\Rules\Methods\MethodSignatureRule";i:307;s:53:"PHPStan\Rules\Methods\MethodParameterComparisonHelper";i:308;s:34:"PHPStan\Rules\MissingTypehintCheck";i:309;s:27:"PHPStan\Rules\NullsafeCheck";i:310;s:69:"PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider";i:311;s:65:"PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtensionProvider";i:312;s:59:"PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider";i:313;s:55:"PHPStan\Rules\Methods\AlwaysUsedMethodExtensionProvider";i:314;s:52:"PHPStan\Rules\PhpDoc\ConditionalReturnTypeRuleHelper";i:315;s:37:"PHPStan\Rules\PhpDoc\AssertRuleHelper";i:316;s:43:"PHPStan\Rules\PhpDoc\UnresolvableTypeHelper";i:317;s:46:"PHPStan\Rules\PhpDoc\GenericCallableRuleHelper";i:318;s:41:"PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper";i:319;s:40:"PHPStan\Rules\Playground\NeverRuleHelper";i:320;s:65:"PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider";i:321;s:61:"PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider";i:322;s:43:"PHPStan\Rules\Properties\PropertyDescriptor";i:323;s:49:"PHPStan\Rules\Properties\PropertyReflectionFinder";i:324;s:38:"PHPStan\Rules\Pure\FunctionPurityCheck";i:325;s:29:"PHPStan\Rules\RuleLevelHelper";i:326;s:43:"PHPStan\Rules\UnusedFunctionParametersCheck";i:327;s:59:"PHPStan\Rules\TooWideTypehints\TooWideParameterOutTypeCheck";i:328;s:27:"PHPStan\Type\FileTypeMapper";i:329;s:30:"PHPStan\Type\BitwiseFlagHelper";i:330;s:54:"PHPStan\Type\Php\AbsFunctionDynamicReturnTypeExtension";i:331;s:47:"PHPStan\Type\DynamicFunctionReturnTypeExtension";i:332;s:57:"PHPStan\Type\Php\ArgumentBasedFunctionReturnTypeExtension";i:333;s:61:"PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension";i:334;s:54:"PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension";i:335;s:55:"PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension";i:336;s:56:"PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension";i:337;s:55:"PHPStan\Type\Php\ArrayCurrentDynamicReturnTypeExtension";i:338;s:53:"PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension";i:339;s:57:"PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension";i:340;s:65:"PHPStan\Type\Php\ArrayFilterFunctionReturnTypeReturnTypeExtension";i:341;s:53:"PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension";i:342;s:51:"PHPStan\Type\Php\ArrayKeyDynamicReturnTypeExtension";i:343;s:62:"PHPStan\Type\Php\ArrayKeyExistsFunctionTypeSpecifyingExtension";i:344;s:44:"PHPStan\Type\FunctionTypeSpecifyingExtension";i:345;s:44:"PHPStan\Analyser\TypeSpecifierAwareExtension";i:346;s:56:"PHPStan\Type\Php\ArrayKeyFirstDynamicReturnTypeExtension";i:347;s:55:"PHPStan\Type\Php\ArrayKeyLastDynamicReturnTypeExtension";i:348;s:60:"PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension";i:349;s:52:"PHPStan\Type\Php\ArrayMapFunctionReturnTypeExtension";i:350;s:61:"PHPStan\Type\Php\ArrayMergeFunctionDynamicReturnTypeExtension";i:351;s:52:"PHPStan\Type\Php\ArrayNextDynamicReturnTypeExtension";i:352;s:52:"PHPStan\Type\Php\ArrayPopFunctionReturnTypeExtension";i:353;s:53:"PHPStan\Type\Php\ArrayRandFunctionReturnTypeExtension";i:354;s:55:"PHPStan\Type\Php\ArrayReduceFunctionReturnTypeExtension";i:355;s:56:"PHPStan\Type\Php\ArrayReplaceFunctionReturnTypeExtension";i:356;s:56:"PHPStan\Type\Php\ArrayReverseFunctionReturnTypeExtension";i:357;s:54:"PHPStan\Type\Php\ArrayShiftFunctionReturnTypeExtension";i:358;s:54:"PHPStan\Type\Php\ArraySliceFunctionReturnTypeExtension";i:359;s:55:"PHPStan\Type\Php\ArraySpliceFunctionReturnTypeExtension";i:360;s:62:"PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension";i:361;s:59:"PHPStan\Type\Php\ArraySearchFunctionTypeSpecifyingExtension";i:362;s:62:"PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension";i:363;s:59:"PHPStan\Type\Php\ArraySumFunctionDynamicReturnTypeExtension";i:364;s:41:"PHPStan\Type\Php\AssertThrowTypeExtension";i:365;s:46:"PHPStan\Type\DynamicFunctionThrowTypeExtension";i:366;s:63:"PHPStan\Type\Php\BackedEnumFromMethodDynamicReturnTypeExtension";i:367;s:51:"PHPStan\Type\DynamicStaticMethodReturnTypeExtension";i:368;s:63:"PHPStan\Type\Php\Base64DecodeDynamicFunctionReturnTypeExtension";i:369;s:54:"PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension";i:370;s:54:"PHPStan\Type\Php\ClosureBindDynamicReturnTypeExtension";i:371;s:56:"PHPStan\Type\Php\ClosureBindToDynamicReturnTypeExtension";i:372;s:62:"PHPStan\Type\Php\ClosureFromCallableDynamicReturnTypeExtension";i:373;s:51:"PHPStan\Type\Php\CompactFunctionReturnTypeExtension";i:374;s:52:"PHPStan\Type\Php\ConstantFunctionReturnTypeExtension";i:375;s:31:"PHPStan\Type\Php\ConstantHelper";i:376;s:49:"PHPStan\Type\Php\CountFunctionReturnTypeExtension";i:377;s:53:"PHPStan\Type\Php\CountFunctionTypeSpecifyingExtension";i:378;s:62:"PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension";i:379;s:44:"PHPStan\Type\Php\CurlInitReturnTypeExtension";i:380;s:45:"PHPStan\Type\Php\DateFunctionReturnTypeHelper";i:381;s:54:"PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension";i:382;s:52:"PHPStan\Type\Php\DateFormatMethodReturnTypeExtension";i:383;s:48:"PHPStan\Type\Php\DateFunctionReturnTypeExtension";i:384;s:58:"PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension";i:385;s:50:"PHPStan\Type\DynamicStaticMethodThrowTypeExtension";i:386;s:55:"PHPStan\Type\Php\DateIntervalDynamicReturnTypeExtension";i:387;s:57:"PHPStan\Type\Php\DateTimeCreateDynamicReturnTypeExtension";i:388;s:51:"PHPStan\Type\Php\DateTimeDynamicReturnTypeExtension";i:389;s:50:"PHPStan\Type\Php\DateTimeModifyReturnTypeExtension";i:390;s:54:"PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension";i:391;s:55:"PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension";i:392;s:44:"PHPStan\Type\DynamicMethodThrowTypeExtension";i:393;s:58:"PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension";i:394;s:48:"PHPStan\Type\Php\DsMapDynamicReturnTypeExtension";i:395;s:53:"PHPStan\Type\Php\DsMapDynamicMethodThrowTypeExtension";i:396;s:58:"PHPStan\Type\Php\DioStatDynamicFunctionReturnTypeExtension";i:397;s:58:"PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension";i:398;s:47:"PHPStan\Type\Php\FilterFunctionReturnTypeHelper";i:399;s:54:"PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension";i:400;s:52:"PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension";i:401;s:57:"PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension";i:402;s:57:"PHPStan\Type\Php\GetCalledClassDynamicReturnTypeExtension";i:403;s:51:"PHPStan\Type\Php\GetClassDynamicReturnTypeExtension";i:404;s:56:"PHPStan\Type\Php\GetDebugTypeFunctionReturnTypeExtension";i:405;s:65:"PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension";i:406;s:51:"PHPStan\Type\Php\GettypeFunctionReturnTypeExtension";i:407;s:63:"PHPStan\Type\Php\GettimeofdayDynamicFunctionReturnTypeExtension";i:408;s:49:"PHPStan\Type\Php\HashFunctionsReturnTypeExtension";i:409;s:58:"PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension";i:410;s:41:"PHPStan\Type\Php\IntdivThrowTypeExtension";i:411;s:42:"PHPStan\Type\Php\IniGetReturnTypeExtension";i:412;s:39:"PHPStan\Type\Php\JsonThrowTypeExtension";i:413;s:49:"PHPStan\Type\Php\PregMatchTypeSpecifyingExtension";i:414;s:51:"PHPStan\Type\Php\PregMatchParameterOutTypeExtension";i:415;s:46:"PHPStan\Type\FunctionParameterOutTypeExtension";i:416;s:56:"PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension";i:417;s:50:"PHPStan\Type\FunctionParameterClosureTypeExtension";i:418;s:39:"PHPStan\Type\Php\RegexArrayShapeMatcher";i:419;s:35:"PHPStan\Type\Regex\RegexGroupParser";i:420;s:40:"PHPStan\Type\Regex\RegexExpressionHelper";i:421;s:61:"PHPStan\Type\Php\ReflectionClassConstructorThrowTypeExtension";i:422;s:64:"PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension";i:423;s:62:"PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension";i:424;s:64:"PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension";i:425;s:53:"PHPStan\Type\Php\StrContainingTypeSpecifyingExtension";i:426;s:65:"PHPStan\Type\Php\SimpleXMLElementClassPropertyReflectionExtension";i:427;s:62:"PHPStan\Type\Php\SimpleXMLElementConstructorThrowTypeExtension";i:428;s:47:"PHPStan\Type\Php\StatDynamicReturnTypeExtension";i:429;s:52:"PHPStan\Type\Php\MethodExistsTypeSpecifyingExtension";i:430;s:54:"PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension";i:431;s:50:"PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension";i:432;s:63:"PHPStan\Type\Php\NumberFormatFunctionDynamicReturnTypeExtension";i:433;s:59:"PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension";i:434;s:54:"PHPStan\Type\Php\PregFilterFunctionReturnTypeExtension";i:435;s:52:"PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension";i:436;s:67:"PHPStan\Type\Php\ReflectionClassIsSubclassOfTypeSpecifyingExtension";i:437;s:42:"PHPStan\Type\MethodTypeSpecifyingExtension";i:438;s:59:"PHPStan\Type\Php\ReplaceFunctionsDynamicReturnTypeExtension";i:439;s:64:"PHPStan\Type\Php\ArrayPointerFunctionsDynamicReturnTypeExtension";i:440;s:49:"PHPStan\Type\Php\LtrimFunctionReturnTypeExtension";i:441;s:47:"PHPStan\Type\Php\MbFunctionsReturnTypeExtension";i:442;s:52:"PHPStan\Type\Php\MbFunctionsReturnTypeExtensionTrait";i:443;s:61:"PHPStan\Type\Php\MbConvertEncodingFunctionReturnTypeExtension";i:444;s:64:"PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension";i:445;s:52:"PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension";i:446;s:53:"PHPStan\Type\Php\MicrotimeFunctionReturnTypeExtension";i:447;s:50:"PHPStan\Type\Php\HrtimeFunctionReturnTypeExtension";i:448;s:51:"PHPStan\Type\Php\ImplodeFunctionReturnTypeExtension";i:449;s:59:"PHPStan\Type\Php\NonEmptyStringFunctionsReturnTypeExtension";i:450;s:55:"PHPStan\Type\Php\SetTypeFunctionTypeSpecifyingExtension";i:451;s:52:"PHPStan\Type\Php\StrCaseFunctionsReturnTypeExtension";i:452;s:50:"PHPStan\Type\Php\StrlenFunctionReturnTypeExtension";i:453;s:65:"PHPStan\Type\Php\StrIncrementDecrementFunctionReturnTypeExtension";i:454;s:50:"PHPStan\Type\Php\StrPadFunctionReturnTypeExtension";i:455;s:53:"PHPStan\Type\Php\StrRepeatFunctionReturnTypeExtension";i:456;s:49:"PHPStan\Type\Php\SubstrDynamicReturnTypeExtension";i:457;s:45:"PHPStan\Type\Php\ThrowableReturnTypeExtension";i:458;s:59:"PHPStan\Type\Php\ParseUrlFunctionDynamicReturnTypeExtension";i:459;s:55:"PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension";i:460;s:65:"PHPStan\Type\Php\VersionCompareFunctionDynamicReturnTypeExtension";i:461;s:47:"PHPStan\Type\Php\PowFunctionReturnTypeExtension";i:462;s:49:"PHPStan\Type\Php\RoundFunctionReturnTypeExtension";i:463;s:53:"PHPStan\Type\Php\StrtotimeFunctionReturnTypeExtension";i:464;s:53:"PHPStan\Type\Php\RandomIntFunctionReturnTypeExtension";i:465;s:49:"PHPStan\Type\Php\RangeFunctionReturnTypeExtension";i:466;s:54:"PHPStan\Type\Php\AssertFunctionTypeSpecifyingExtension";i:467;s:59:"PHPStan\Type\Php\ClassExistsFunctionTypeSpecifyingExtension";i:468;s:59:"PHPStan\Type\Php\ClassImplementsFunctionReturnTypeExtension";i:469;s:54:"PHPStan\Type\Php\DefineConstantTypeSpecifyingExtension";i:470;s:55:"PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension";i:471;s:62:"PHPStan\Type\Php\FunctionExistsFunctionTypeSpecifyingExtension";i:472;s:55:"PHPStan\Type\Php\InArrayFunctionTypeSpecifyingExtension";i:473;s:55:"PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension";i:474;s:58:"PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension";i:475;s:58:"PHPStan\Type\Php\IsIterableFunctionTypeSpecifyingExtension";i:476;s:60:"PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension";i:477;s:59:"PHPStan\Type\Php\IteratorToArrayFunctionReturnTypeExtension";i:478;s:51:"PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension";i:479;s:48:"PHPStan\Type\Php\IsAFunctionTypeSpecifyingHelper";i:480;s:58:"PHPStan\Type\Php\CtypeDigitFunctionTypeSpecifyingExtension";i:481;s:59:"PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension";i:482;s:66:"PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension";i:483;s:63:"PHPStan\Type\Php\SimpleXMLElementAsXMLMethodReturnTypeExtension";i:484;s:63:"PHPStan\Type\Php\SimpleXMLElementXpathMethodReturnTypeExtension";i:485;s:52:"PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension";i:486;s:50:"PHPStan\Type\Php\StrTokFunctionReturnTypeExtension";i:487;s:58:"PHPStan\Type\Php\SprintfFunctionDynamicReturnTypeExtension";i:488;s:57:"PHPStan\Type\Php\SscanfFunctionDynamicReturnTypeExtension";i:489;s:56:"PHPStan\Type\Php\StrvalFamilyFunctionReturnTypeExtension";i:490;s:63:"PHPStan\Type\Php\StrWordCountFunctionDynamicReturnTypeExtension";i:491;s:49:"PHPStan\Type\Php\XMLReaderOpenReturnTypeExtension";i:492;s:65:"PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension";i:493;s:57:"PHPStan\Type\Php\DatePeriodConstructorReturnTypeExtension";i:494;s:31:"PHPStan\Type\ClosureTypeFactory";i:495;s:43:"PHPStan\Type\Constant\OversizedArrayBuilder";i:496;s:36:"PHPStan\Rules\Functions\PrintfHelper";i:497;s:37:"PHPStan\Analyser\TypeSpecifierFactory";i:498;s:46:"PHPStan\File\ParentDirectoryRelativePathHelper";i:499;s:31:"PHPStan\File\RelativePathHelper";i:500;s:28:"PHPStan\Broker\BrokerFactory";i:501;s:30:"PHPStan\Cache\FileCacheStorage";i:502;s:26:"PHPStan\Cache\CacheStorage";i:503;s:25:"PHPStan\Parser\RichParser";i:504;s:21:"PHPStan\Parser\Parser";i:505;s:29:"PHPStan\Parser\CleaningParser";i:506;s:27:"PHPStan\Parser\SimpleParser";i:507;s:27:"PHPStan\Parser\CachedParser";i:508;s:33:"PHPStan\Parser\PhpParserDecorator";i:509;s:16:"PhpParser\Parser";i:510;s:21:"PhpParser\Parser\Php7";i:511;s:24:"PhpParser\ParserAbstract";i:512;s:26:"PHPStan\Rules\LazyRegistry";i:513;s:22:"PHPStan\Rules\Registry";i:514;s:33:"PHPStan\PhpDoc\StubPhpDocProvider";i:515;s:63:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory";i:516;s:37:"PHPStan\Reflection\ReflectionProvider";i:517;s:51:"PHPStan\BetterReflection\Reflector\DefaultReflector";i:518;s:44:"PHPStan\BetterReflection\Reflector\Reflector";i:519;s:64:"PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector";i:520;s:49:"PHPStan\BetterReflection\Reflector\ClassReflector";i:521;s:52:"PHPStan\BetterReflection\Reflector\FunctionReflector";i:522;s:52:"PHPStan\BetterReflection\Reflector\ConstantReflector";i:523;s:60:"PHPStan\Reflection\BetterReflection\BetterReflectionProvider";i:524;s:72:"PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory";i:525;s:83:"PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory";i:526;s:79:"PHPStan\BetterReflection\SourceLocator\SourceStubber\PhpStormStubsSourceStubber";i:527;s:66:"PHPStan\BetterReflection\SourceLocator\SourceStubber\SourceStubber";i:528;s:76:"PHPStan\BetterReflection\SourceLocator\SourceStubber\ReflectionSourceStubber";i:529;s:80:"PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory";i:530;s:32:"PHPStan\Parser\PathRoutingParser";i:531;s:41:"PHPStan\Diagnose\PHPStanDiagnoseExtension";i:532;s:55:"PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter";i:533;s:45:"PHPStan\Command\ErrorFormatter\ErrorFormatter";i:534;s:48:"PHPStan\Command\ErrorFormatter\RawErrorFormatter";i:535;s:50:"PHPStan\Command\ErrorFormatter\TableErrorFormatter";i:536;s:55:"PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter";i:537;s:49:"PHPStan\Command\ErrorFormatter\JsonErrorFormatter";i:538;s:50:"PHPStan\Command\ErrorFormatter\JunitErrorFormatter";i:539;s:51:"PHPStan\Command\ErrorFormatter\GitlabErrorFormatter";i:540;s:51:"PHPStan\Command\ErrorFormatter\GithubErrorFormatter";i:541;s:53:"PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter";i:542;s:40:"PHPStan\Rules\Api\ApiClassConstFetchRule";i:543;s:35:"PHPStan\Rules\Api\ApiInstanceofRule";i:544;s:39:"PHPStan\Rules\Api\ApiInstanceofTypeRule";i:545;s:53:"PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule";i:546;s:47:"PHPStan\Rules\Api\RuntimeReflectionFunctionRule";i:547;s:52:"PHPStan\Rules\Api\RuntimeReflectionInstantiationRule";i:548;s:53:"PHPStan\Rules\Classes\ExistingClassInClassExtendsRule";i:549;s:51:"PHPStan\Rules\Classes\ExistingClassInInstanceOfRule";i:550;s:53:"PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule";i:551;s:53:"PHPStan\Rules\Functions\CallToNonExistentFunctionRule";i:552;s:46:"PHPStan\Rules\Constants\OverridingConstantRule";i:553;s:42:"PHPStan\Rules\Methods\OverridingMethodRule";i:554;s:47:"PHPStan\Rules\Methods\ConsistentConstructorRule";i:555;s:39:"PHPStan\Rules\Missing\MissingReturnRule";i:556;s:52:"PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule";i:557;s:47:"PHPStan\Rules\Namespaces\ExistingNamesInUseRule";i:558;s:50:"PHPStan\Rules\Operators\InvalidIncDecOperationRule";i:559;s:45:"PHPStan\Rules\Properties\AccessPropertiesRule";i:560;s:51:"PHPStan\Rules\Properties\AccessStaticPropertiesRule";i:561;s:56:"PHPStan\Rules\Properties\ExistingClassesInPropertiesRule";i:562;s:44:"PHPStan\Rules\Functions\FunctionCallableRule";i:563;s:66:"PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule";i:564;s:47:"PHPStan\Rules\Properties\OverridingPropertyRule";i:565;s:53:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyRule";i:566;s:50:"PHPStan\Rules\Properties\UninitializedPropertyRule";i:567;s:56:"PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule";i:568;s:55:"PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule";i:569;s:44:"PHPStan\Rules\Variables\CompactVariablesRule";i:570;s:43:"PHPStan\Rules\Variables\DefinedVariableRule";i:571;s:49:"PHPStan\Rules\Regexp\RegularExpressionPatternRule";i:572;s:37:"PHPStan\Reflection\ConstructorsHelper";i:573;s:58:"PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule";i:574;s:48:"PHPStan\Rules\Constants\MagicConstantContextRule";i:575;s:54:"PHPStan\Rules\Functions\UselessFunctionReturnValueRule";i:576;s:49:"PHPStan\Rules\Functions\PrintfArrayParametersRule";i:577;s:49:"PHPStan\Rules\Regexp\RegularExpressionQuotingRule";i:578;s:31:"PHPStan\Rules\Classes\MixinRule";i:579;s:35:"PHPStan\Rules\Classes\MethodTagRule";i:580;s:40:"PHPStan\Rules\Classes\MethodTagTraitRule";i:581;s:37:"PHPStan\Rules\Classes\PropertyTagRule";i:582;s:42:"PHPStan\Rules\Classes\PropertyTagTraitRule";i:583;s:40:"PHPStan\Rules\PhpDoc\RequireExtendsCheck";i:584;s:57:"PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule";i:585;s:73:"PHPStan\Rules\Functions\IncompatibleArrowFunctionDefaultParameterTypeRule";i:586;s:67:"PHPStan\Rules\Functions\IncompatibleClosureDefaultParameterTypeRule";i:587;s:41:"PHPStan\Rules\Functions\CallCallablesRule";i:588;s:54:"PHPStan\Rules\Methods\IllegalConstructorMethodCallRule";i:589;s:54:"PHPStan\Rules\Methods\IllegalConstructorStaticCallRule";i:590;s:46:"PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule";i:591;s:48:"PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule";i:592;s:45:"PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule";i:593;s:52:"PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule";i:594;s:50:"PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule";i:595;s:43:"PHPStan\Rules\Generics\PropertyVarianceRule";i:596;s:35:"PHPStan\Rules\Pure\PureFunctionRule";i:597;s:33:"PHPStan\Rules\Pure\PureMethodRule";i:598;s:50:"PHPStan\Rules\Operators\InvalidBinaryOperationRule";i:599;s:49:"PHPStan\Rules\Operators\InvalidUnaryOperationRule";i:600;s:50:"PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule";i:601;s:46:"PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule";i:602;s:57:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule";i:603;s:69:"PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule";i:604;s:67:"PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule";i:605;s:42:"PHPStan\Rules\Generators\YieldFromTypeRule";i:606;s:45:"PHPStan\Rules\Generators\YieldInGeneratorRule";i:607;s:39:"PHPStan\Rules\Arrays\ArrayUnpackingRule";i:608;s:62:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule";i:609;s:59:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule";i:610;s:52:"PHPStan\Rules\Variables\ParameterOutAssignedTypeRule";i:611;s:56:"PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule";i:612;s:46:"PHPStan\Rules\Classes\ImpossibleInstanceOfRule";i:613;s:56:"PHPStan\Rules\Comparison\BooleanAndConstantConditionRule";i:614;s:55:"PHPStan\Rules\Comparison\BooleanOrConstantConditionRule";i:615;s:56:"PHPStan\Rules\Comparison\BooleanNotConstantConditionRule";i:616;s:31:"PHPStan\Rules\DeadCode\NoopRule";i:617;s:72:"PHPStan\Rules\DeadCode\CallToConstructorStatementWithoutImpurePointsRule";i:618;s:62:"PHPStan\Rules\DeadCode\ConstructorWithoutImpurePointsCollector";i:619;s:28:"PHPStan\Collectors\Collector";i:620;s:47:"PHPStan\Rules\DeadCode\PossiblyPureNewCollector";i:621;s:69:"PHPStan\Rules\DeadCode\CallToFunctionStatementWithoutImpurePointsRule";i:622;s:59:"PHPStan\Rules\DeadCode\FunctionWithoutImpurePointsCollector";i:623;s:52:"PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector";i:624;s:67:"PHPStan\Rules\DeadCode\CallToMethodStatementWithoutImpurePointsRule";i:625;s:57:"PHPStan\Rules\DeadCode\MethodWithoutImpurePointsCollector";i:626;s:54:"PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector";i:627;s:73:"PHPStan\Rules\DeadCode\CallToStaticMethodStatementWithoutImpurePointsRule";i:628;s:54:"PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector";i:629;s:48:"PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule";i:630;s:57:"PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule";i:631;s:52:"PHPStan\Rules\Comparison\ElseIfConstantConditionRule";i:632;s:48:"PHPStan\Rules\Comparison\IfConstantConditionRule";i:633;s:60:"PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule";i:634;s:58:"PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule";i:635;s:64:"PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule";i:636;s:56:"PHPStan\Rules\Comparison\LogicalXorConstantConditionRule";i:637;s:37:"PHPStan\Rules\DeadCode\BetterNoopRule";i:638;s:44:"PHPStan\Rules\Comparison\MatchExpressionRule";i:639;s:71:"PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule";i:640;s:61:"PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule";i:641;s:52:"PHPStan\Rules\Comparison\ConstantLooseComparisonRule";i:642;s:61:"PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule";i:643;s:50:"PHPStan\Rules\Comparison\UnreachableIfBranchesRule";i:644;s:57:"PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule";i:645;s:58:"PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule";i:646;s:57:"PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule";i:647;s:70:"PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule";i:648;s:62:"PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule";i:649;s:50:"PHPStan\Rules\Properties\NullsafePropertyFetchRule";i:650;s:46:"PHPStan\Rules\Traits\TraitDeclarationCollector";i:651;s:38:"PHPStan\Rules\Traits\TraitUseCollector";i:652;s:41:"PHPStan\Rules\Traits\NotAnalysedTraitRule";i:653;s:55:"PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule";i:654;s:66:"PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule";i:655;s:64:"PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule";i:656;s:54:"PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule";i:657;s:47:"PHPStan\Rules\Functions\RandomIntParametersRule";i:658;s:39:"PHPStan\Rules\Functions\ArrayFilterRule";i:659;s:39:"PHPStan\Rules\Functions\ArrayValuesRule";i:660;s:40:"PHPStan\Rules\Functions\CallUserFuncRule";i:661;s:43:"PHPStan\Rules\Functions\ImplodeFunctionRule";i:662;s:53:"PHPStan\Rules\Functions\ParameterCastableToStringRule";i:663;s:60:"PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule";i:664;s:57:"PHPStan\Rules\Functions\SortParameterCastableToStringRule";i:665;s:60:"PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule";i:666;s:56:"PHPStan\Rules\Methods\MissingMethodParameterTypehintRule";i:667;s:50:"PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule";i:668;s:37:"_PHPStan_4f7beffdf\Nette\DI\Container";i:669;s:36:"_PHPStan_4f7beffdf\Nette\SmartObject";i:670;s:22:"PHPStan\Php\PhpVersion";i:671;s:29:"PHPStan\Php\PhpVersionFactory";i:672;s:43:"PHPStan\PhpDocParser\Parser\ConstExprParser";i:673;s:56:"PHPStan\PhpDoc\TypeNodeResolverExtensionRegistryProvider";i:674;s:33:"PHPStan\Analyser\ConstantResolver";i:675;s:47:"PHPStan\Analyser\ResultCache\ResultCacheManager";i:676;s:54:"PHPStan\Analyser\ResultCache\ResultCacheManagerFactory";i:677;s:27:"PHPStan\Collectors\Registry";i:678;s:79:"PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider";i:679;s:75:"PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider";i:680;s:66:"PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider";i:681;s:80:"PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider";i:682;s:80:"PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider";i:683;s:66:"PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider";i:684;s:70:"PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider";i:685;s:25:"PHPStan\File\FileExcluder";i:686;s:35:"PHPStan\File\FileExcluderRawFactory";i:687;s:44:"PHPStan\Reflection\Php\PhpFunctionReflection";i:688;s:37:"PHPStan\Reflection\FunctionReflection";i:689;s:44:"PHPStan\Reflection\FunctionReflectionFactory";i:690;s:79:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator";i:691;s:57:"PHPStan\BetterReflection\SourceLocator\Type\SourceLocator";i:692;s:86:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocatorFactory";i:693;s:82:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator";i:694;s:89:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorFactory";i:695;s:42:"PHPStan\Reflection\Php\PhpMethodReflection";i:696;s:43:"PHPStan\Reflection\ExtendedMethodReflection";i:697;s:40:"PHPStan\Reflection\ClassMemberReflection";i:698;s:35:"PHPStan\Reflection\MethodReflection";i:699;s:49:"PHPStan\Reflection\Php\PhpMethodReflectionFactory";i:700;s:64:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider";i:701;s:30:"PHPStan\Type\TypeAliasResolver";i:702;s:38:"PHPStan\Type\TypeAliasResolverProvider";i:703;s:30:"PHPStan\Analyser\TypeSpecifier";i:704;s:21:"PHPStan\Broker\Broker";i:705;s:15:"PhpParser\Lexer";i:706;s:67:"PHPStan\Reflection\BetterReflection\BetterReflectionProviderFactory";i:707;s:25:"PhpParser\Lexer\Emulative";}i:4;a:462:{i:0;s:71:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory::create";i:1;s:91:"PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory::create";i:2;s:88:"PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory::create";i:3;s:45:"PHPStan\Rules\Debug\DumpTypeRule::__construct";i:4;s:47:"PHPStan\Rules\Debug\FileAssertRule::__construct";i:5;s:51:"PHPStan\Rules\Api\ApiInstantiationRule::__construct";i:6;s:50:"PHPStan\Rules\Api\ApiClassExtendsRule::__construct";i:7;s:53:"PHPStan\Rules\Api\ApiClassImplementsRule::__construct";i:8;s:54:"PHPStan\Rules\Api\ApiInterfaceExtendsRule::__construct";i:9;s:48:"PHPStan\Rules\Api\ApiMethodCallRule::__construct";i:10;s:48:"PHPStan\Rules\Api\ApiStaticCallRule::__construct";i:11;s:46:"PHPStan\Rules\Api\ApiTraitUseRule::__construct";i:12;s:50:"PHPStan\Rules\Api\GetTemplateTypeRule::__construct";i:13;s:68:"PHPStan\Rules\Api\PhpStanNamespaceIn3rdPartyPackageRule::__construct";i:14;s:66:"PHPStan\Rules\Arrays\DuplicateKeysInLiteralArraysRule::__construct";i:15;s:45:"PHPStan\Rules\Cast\UnsetCastRule::__construct";i:16;s:54:"PHPStan\Rules\Classes\ClassAttributesRule::__construct";i:17;s:62:"PHPStan\Rules\Classes\ClassConstantAttributesRule::__construct";i:18;s:52:"PHPStan\Rules\Classes\ClassConstantRule::__construct";i:19;s:71:"PHPStan\Rules\Classes\ExistingClassesInClassImplementsRule::__construct";i:20;s:70:"PHPStan\Rules\Classes\ExistingClassesInEnumImplementsRule::__construct";i:21;s:72:"PHPStan\Rules\Classes\ExistingClassesInInterfaceExtendsRule::__construct";i:22;s:62:"PHPStan\Rules\Classes\ExistingClassInTraitUseRule::__construct";i:23;s:52:"PHPStan\Rules\Classes\InstantiationRule::__construct";i:24;s:64:"PHPStan\Rules\Classes\InvalidPromotedPropertiesRule::__construct";i:25;s:55:"PHPStan\Rules\Classes\LocalTypeAliasesRule::__construct";i:26;s:60:"PHPStan\Rules\Classes\LocalTypeTraitAliasesRule::__construct";i:27;s:52:"PHPStan\Rules\Classes\ReadOnlyClassRule::__construct";i:28;s:66:"PHPStan\Rules\Constants\DynamicClassConstantFetchRule::__construct";i:29;s:54:"PHPStan\Rules\Constants\FinalConstantRule::__construct";i:30;s:65:"PHPStan\Rules\Constants\NativeTypedClassConstantRule::__construct";i:31;s:59:"PHPStan\Rules\EnumCases\EnumCaseAttributesRule::__construct";i:32;s:59:"PHPStan\Rules\Exceptions\NoncapturingCatchRule::__construct";i:33;s:57:"PHPStan\Rules\Exceptions\ThrowExpressionRule::__construct";i:34;s:64:"PHPStan\Rules\Functions\ArrowFunctionAttributesRule::__construct";i:35;s:73:"PHPStan\Rules\Functions\ArrowFunctionReturnNullsafeByRefRule::__construct";i:36;s:58:"PHPStan\Rules\Functions\ClosureAttributesRule::__construct";i:37;s:57:"PHPStan\Rules\Functions\DefineParametersRule::__construct";i:38;s:80:"PHPStan\Rules\Functions\ExistingClassesInArrowFunctionTypehintsRule::__construct";i:39;s:65:"PHPStan\Rules\Functions\CallToFunctionParametersRule::__construct";i:40;s:74:"PHPStan\Rules\Functions\ExistingClassesInClosureTypehintsRule::__construct";i:41;s:67:"PHPStan\Rules\Functions\ExistingClassesInTypehintsRule::__construct";i:42;s:59:"PHPStan\Rules\Functions\FunctionAttributesRule::__construct";i:43;s:56:"PHPStan\Rules\Functions\ParamAttributesRule::__construct";i:44;s:57:"PHPStan\Rules\Functions\PrintfParametersRule::__construct";i:45;s:60:"PHPStan\Rules\Functions\ReturnNullsafeByRefRule::__construct";i:46;s:58:"PHPStan\Rules\Keywords\DeclareStrictTypesRule::__construct";i:47;s:50:"PHPStan\Rules\Methods\CallMethodsRule::__construct";i:48;s:56:"PHPStan\Rules\Methods\CallStaticMethodsRule::__construct";i:49;s:65:"PHPStan\Rules\Methods\ExistingClassesInTypehintsRule::__construct";i:50;s:57:"PHPStan\Rules\Methods\FinalPrivateMethodRule::__construct";i:51;s:53:"PHPStan\Rules\Methods\MethodCallableRule::__construct";i:52;s:55:"PHPStan\Rules\Methods\MethodAttributesRule::__construct";i:53;s:59:"PHPStan\Rules\Methods\StaticMethodCallableRule::__construct";i:54;s:57:"PHPStan\Rules\Operators\InvalidAssignVarRule::__construct";i:55;s:66:"PHPStan\Rules\Properties\AccessPropertiesInAssignRule::__construct";i:56;s:72:"PHPStan\Rules\Properties\AccessStaticPropertiesInAssignRule::__construct";i:57;s:71:"PHPStan\Rules\Properties\MissingReadOnlyPropertyAssignRule::__construct";i:58;s:60:"PHPStan\Rules\Properties\PropertyAttributesRule::__construct";i:59;s:58:"PHPStan\Rules\Properties\ReadOnlyPropertyRule::__construct";i:60;s:63:"PHPStan\Rules\Traits\ConflictingTraitConstantsRule::__construct";i:61;s:55:"PHPStan\Rules\Traits\ConstantsInTraitsRule::__construct";i:62;s:66:"PHPStan\Rules\Classes\UnusedConstructorParametersRule::__construct";i:63;s:58:"PHPStan\Rules\Functions\UnusedClosureUsesRule::__construct";i:64;s:46:"PHPStan\Rules\Variables\EmptyRule::__construct";i:65;s:46:"PHPStan\Rules\Variables\IssetRule::__construct";i:66;s:53:"PHPStan\Rules\Variables\NullCoalesceRule::__construct";i:67;s:40:"PHPStan\Rules\Cast\EchoRule::__construct";i:68;s:47:"PHPStan\Rules\Cast\InvalidCastRule::__construct";i:69;s:63:"PHPStan\Rules\Cast\InvalidPartOfEncapsedStringRule::__construct";i:70;s:41:"PHPStan\Rules\Cast\PrintRule::__construct";i:71;s:54:"PHPStan\Rules\Generics\ClassAncestorsRule::__construct";i:72;s:57:"PHPStan\Rules\Generics\ClassTemplateTypeRule::__construct";i:73;s:53:"PHPStan\Rules\Generics\EnumAncestorsRule::__construct";i:74;s:60:"PHPStan\Rules\Generics\FunctionTemplateTypeRule::__construct";i:75;s:65:"PHPStan\Rules\Generics\FunctionSignatureVarianceRule::__construct";i:76;s:58:"PHPStan\Rules\Generics\InterfaceAncestorsRule::__construct";i:77;s:61:"PHPStan\Rules\Generics\InterfaceTemplateTypeRule::__construct";i:78;s:58:"PHPStan\Rules\Generics\MethodTemplateTypeRule::__construct";i:79;s:61:"PHPStan\Rules\Generics\MethodTagTemplateTypeRule::__construct";i:80;s:63:"PHPStan\Rules\Generics\MethodSignatureVarianceRule::__construct";i:81;s:57:"PHPStan\Rules\Generics\TraitTemplateTypeRule::__construct";i:82;s:50:"PHPStan\Rules\Generics\UsedTraitsRule::__construct";i:83;s:67:"PHPStan\Rules\Operators\InvalidComparisonOperationRule::__construct";i:84;s:67:"PHPStan\Rules\PhpDoc\FunctionConditionalReturnTypeRule::__construct";i:85;s:65:"PHPStan\Rules\PhpDoc\MethodConditionalReturnTypeRule::__construct";i:86;s:52:"PHPStan\Rules\PhpDoc\FunctionAssertRule::__construct";i:87;s:50:"PHPStan\Rules\PhpDoc\MethodAssertRule::__construct";i:88;s:61:"PHPStan\Rules\PhpDoc\IncompatibleSelfOutTypeRule::__construct";i:89;s:73:"PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule::__construct";i:90;s:60:"PHPStan\Rules\PhpDoc\IncompatiblePhpDocTypeRule::__construct";i:91;s:68:"PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule::__construct";i:92;s:62:"PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule::__construct";i:93;s:81:"PHPStan\Rules\PhpDoc\IncompatibleParamImmediatelyInvokedCallableRule::__construct";i:94;s:67:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionClassRule::__construct";i:95;s:67:"PHPStan\Rules\PhpDoc\RequireExtendsDefinitionTraitRule::__construct";i:96;s:56:"PHPStan\Rules\Arrays\ArrayDestructuringRule::__construct";i:97;s:55:"PHPStan\Rules\Arrays\IterableInForeachRule::__construct";i:98;s:60:"PHPStan\Rules\Arrays\OffsetAccessAssignmentRule::__construct";i:99;s:58:"PHPStan\Rules\Arrays\OffsetAccessAssignOpRule::__construct";i:100;s:65:"PHPStan\Rules\Arrays\OffsetAccessValueAssignmentRule::__construct";i:101;s:59:"PHPStan\Rules\Arrays\UnpackIterableInArrayRule::__construct";i:102;s:55:"PHPStan\Rules\Exceptions\ThrowExprTypeRule::__construct";i:103;s:64:"PHPStan\Rules\Functions\ArrowFunctionReturnTypeRule::__construct";i:104;s:58:"PHPStan\Rules\Functions\ClosureReturnTypeRule::__construct";i:105;s:51:"PHPStan\Rules\Functions\ReturnTypeRule::__construct";i:106;s:51:"PHPStan\Rules\Generators\YieldTypeRule::__construct";i:107;s:49:"PHPStan\Rules\Methods\ReturnTypeRule::__construct";i:108;s:79:"PHPStan\Rules\Properties\DefaultValueTypesAssignedToPropertiesRule::__construct";i:109;s:64:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRule::__construct";i:110;s:67:"PHPStan\Rules\Properties\ReadOnlyPropertyAssignRefRule::__construct";i:111;s:67:"PHPStan\Rules\Properties\TypesAssignedToPropertiesRule::__construct";i:112;s:50:"PHPStan\Rules\Variables\ThrowTypeRule::__construct";i:113;s:56:"PHPStan\Rules\Variables\VariableCloningRule::__construct";i:114;s:61:"PHPStan\Rules\DeadCode\UnusedPrivateConstantRule::__construct";i:115;s:59:"PHPStan\Rules\DeadCode\UnusedPrivateMethodRule::__construct";i:116;s:82:"PHPStan\Rules\Functions\CallToFunctionStatementWithoutSideEffectsRule::__construct";i:117;s:78:"PHPStan\Rules\Methods\CallToMethodStatementWithoutSideEffectsRule::__construct";i:118;s:84:"PHPStan\Rules\Methods\CallToStaticMethodStatementWithoutSideEffectsRule::__construct";i:119;s:69:"PHPStan\Rules\Constants\MissingClassConstantTypehintRule::__construct";i:120;s:70:"PHPStan\Rules\Functions\MissingFunctionReturnTypehintRule::__construct";i:121;s:66:"PHPStan\Rules\Methods\MissingMethodReturnTypehintRule::__construct";i:122;s:65:"PHPStan\Rules\Properties\MissingPropertyTypehintRule::__construct";i:123;s:40:"PHPStan\Parser\LexerFactory::__construct";i:124;s:47:"PhpParser\NodeVisitor\NameResolver::__construct";i:125;s:45:"PHPStan\Node\Printer\ExprPrinter::__construct";i:126;s:41:"PHPStan\Node\Printer\Printer::__construct";i:127;s:52:"PHPStan\Broker\AnonymousClassNameHelper::__construct";i:128;s:37:"PHPStan\Php\PhpVersionFactory::create";i:129;s:44:"PHPStan\Php\PhpVersionFactoryFactory::create";i:130;s:49:"PHPStan\Php\PhpVersionFactoryFactory::__construct";i:131;s:45:"PHPStan\PhpDocParser\Lexer\Lexer::__construct";i:132;s:51:"PHPStan\PhpDocParser\Parser\TypeParser::__construct";i:133;s:45:"PHPStan\PhpDoc\ConstExprParserFactory::create";i:134;s:53:"PHPStan\PhpDocParser\Parser\PhpDocParser::__construct";i:135;s:50:"PHPStan\PhpDoc\ConstExprParserFactory::__construct";i:136;s:53:"PHPStan\PhpDoc\PhpDocInheritanceResolver::__construct";i:137;s:46:"PHPStan\PhpDoc\PhpDocNodeResolver::__construct";i:138;s:48:"PHPStan\PhpDoc\PhpDocStringResolver::__construct";i:139;s:49:"PHPStan\PhpDoc\ConstExprNodeResolver::__construct";i:140;s:44:"PHPStan\PhpDoc\TypeNodeResolver::__construct";i:141;s:73:"PHPStan\PhpDoc\LazyTypeNodeResolverExtensionRegistryProvider::__construct";i:142;s:46:"PHPStan\PhpDoc\TypeStringResolver::__construct";i:143;s:41:"PHPStan\PhpDoc\StubValidator::__construct";i:144;s:55:"PHPStan\PhpDoc\CountableStubFilesExtension::__construct";i:145;s:58:"PHPStan\PhpDoc\SocketSelectStubFilesExtension::__construct";i:146;s:52:"PHPStan\PhpDoc\DefaultStubFilesProvider::__construct";i:147;s:58:"PHPStan\PhpDoc\JsonValidateStubFilesExtension::__construct";i:148;s:60:"PHPStan\PhpDoc\ReflectionEnumStubFilesExtension::__construct";i:149;s:38:"PHPStan\Analyser\Analyser::__construct";i:150;s:53:"PHPStan\Analyser\AnalyserResultFinalizer::__construct";i:151;s:42:"PHPStan\Analyser\FileAnalyser::__construct";i:152;s:55:"PHPStan\Analyser\Ignore\IgnoredErrorHelper::__construct";i:153;s:54:"PHPStan\Analyser\LazyInternalScopeFactory::__construct";i:154;s:42:"PHPStan\Analyser\ScopeFactory::__construct";i:155;s:47:"PHPStan\Analyser\NodeScopeResolver::__construct";i:156;s:48:"PHPStan\Analyser\ConstantResolverFactory::create";i:157;s:53:"PHPStan\Analyser\ConstantResolverFactory::__construct";i:158;s:60:"PHPStan\Analyser\ResultCache\ResultCacheManager::__construct";i:159;s:60:"PHPStan\Analyser\ResultCache\ResultCacheClearer::__construct";i:160;s:32:"PHPStan\Cache\Cache::__construct";i:161;s:42:"PHPStan\Collectors\RegistryFactory::create";i:162;s:47:"PHPStan\Collectors\RegistryFactory::__construct";i:163;s:47:"PHPStan\Command\AnalyseApplication::__construct";i:164;s:43:"PHPStan\Command\AnalyserRunner::__construct";i:165;s:45:"PHPStan\Command\FixerApplication::__construct";i:166;s:50:"PHPStan\Dependency\DependencyResolver::__construct";i:167;s:51:"PHPStan\Dependency\ExportedNodeFetcher::__construct";i:168;s:52:"PHPStan\Dependency\ExportedNodeResolver::__construct";i:169;s:51:"PHPStan\Dependency\ExportedNodeVisitor::__construct";i:170;s:59:"PHPStan\DependencyInjection\MemoizingContainer::__construct";i:171;s:61:"PHPStan\DependencyInjection\Nette\NetteContainer::__construct";i:172;s:67:"PHPStan\DependencyInjection\DerivativeContainerFactory::__construct";i:173;s:96:"PHPStan\DependencyInjection\Reflection\LazyClassReflectionExtensionRegistryProvider::__construct";i:174;s:92:"PHPStan\DependencyInjection\Type\LazyDynamicReturnTypeExtensionRegistryProvider::__construct";i:175;s:83:"PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider::__construct";i:176;s:97:"PHPStan\DependencyInjection\Type\LazyExpressionTypeResolverExtensionRegistryProvider::__construct";i:177;s:97:"PHPStan\DependencyInjection\Type\LazyOperatorTypeSpecifyingExtensionRegistryProvider::__construct";i:178;s:83:"PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider::__construct";i:179;s:87:"PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider::__construct";i:180;s:36:"PHPStan\File\FileHelper::__construct";i:181;s:45:"PHPStan\File\FileExcluderFactory::__construct";i:182;s:38:"PHPStan\File\FileExcluder::__construct";i:183;s:59:"PHPStan\File\FileExcluderFactory::createAnalyseFileExcluder";i:184;s:56:"PHPStan\File\FileExcluderFactory::createScanFileExcluder";i:185;s:36:"PHPStan\File\FileFinder::__construct";i:187;s:37:"PHPStan\File\FileMonitor::__construct";i:188;s:46:"PHPStan\Parallel\ParallelAnalyser::__construct";i:189;s:39:"PHPStan\Parallel\Scheduler::__construct";i:190;s:57:"PHPStan\Reflection\Php\PhpFunctionReflection::__construct";i:191;s:59:"PHPStan\Reflection\InitializerExprTypeResolver::__construct";i:192;s:79:"PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher::__construct";i:193;s:109:"PHPStan\Reflection\BetterReflection\SourceLocator\ComposerJsonAndInstalledJsonSourceLocatorMaker::__construct";i:194;s:101:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory::__construct";i:195;s:104:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorRepository::__construct";i:196;s:92:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedPsrAutoloaderLocator::__construct";i:197;s:95:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator::__construct";i:198;s:105:"PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocatorRepository::__construct";i:199;s:74:"PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension::__construct";i:200;s:77:"PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension::__construct";i:201;s:63:"PHPStan\Reflection\Php\PhpClassReflectionExtension::__construct";i:202;s:55:"PHPStan\Reflection\Php\PhpMethodReflection::__construct";i:203;s:81:"PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension::__construct";i:204;s:92:"PHPStan\Reflection\PHPStan\NativeReflectionEnumReturnDynamicReturnTypeExtension::__construct";i:206;s:81:"PHPStan\Reflection\ReflectionProvider\LazyReflectionProviderProvider::__construct";i:207;s:77:"PHPStan\Reflection\SignatureMap\NativeFunctionReflectionProvider::__construct";i:208;s:63:"PHPStan\Reflection\SignatureMap\SignatureMapParser::__construct";i:209;s:73:"PHPStan\Reflection\SignatureMap\FunctionSignatureMapProvider::__construct";i:210;s:69:"PHPStan\Reflection\SignatureMap\Php8SignatureMapProvider::__construct";i:211;s:72:"PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory::__construct";i:212;s:67:"PHPStan\Reflection\SignatureMap\SignatureMapProviderFactory::create";i:213;s:42:"PHPStan\Rules\AttributesCheck::__construct";i:214;s:71:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchCheck::__construct";i:215;s:41:"PHPStan\Rules\ClassNameCheck::__construct";i:216;s:52:"PHPStan\Rules\ClassCaseSensitivityCheck::__construct";i:217;s:50:"PHPStan\Rules\ClassForbiddenNameCheck::__construct";i:218;s:56:"PHPStan\Rules\Classes\LocalTypeAliasesCheck::__construct";i:219;s:49:"PHPStan\Rules\Classes\MethodTagCheck::__construct";i:220;s:51:"PHPStan\Rules\Classes\PropertyTagCheck::__construct";i:221;s:65:"PHPStan\Rules\Comparison\ConstantConditionRuleHelper::__construct";i:222;s:63:"PHPStan\Rules\Comparison\ImpossibleCheckTypeHelper::__construct";i:223;s:66:"PHPStan\Rules\Exceptions\DefaultExceptionTypeResolver::__construct";i:224;s:81:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule::__construct";i:225;s:79:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInMethodThrowsRule::__construct";i:226;s:74:"PHPStan\Rules\Exceptions\MissingCheckedExceptionInThrowsCheck::__construct";i:227;s:66:"PHPStan\Rules\Exceptions\TooWideFunctionThrowTypeRule::__construct";i:228;s:64:"PHPStan\Rules\Exceptions\TooWideMethodThrowTypeRule::__construct";i:229;s:54:"PHPStan\Rules\FunctionCallParametersCheck::__construct";i:230;s:50:"PHPStan\Rules\FunctionDefinitionCheck::__construct";i:231;s:50:"PHPStan\Rules\FunctionReturnTypeCheck::__construct";i:232;s:57:"PHPStan\Rules\ParameterCastableToStringCheck::__construct";i:233;s:57:"PHPStan\Rules\Generics\GenericAncestorsCheck::__construct";i:234;s:53:"PHPStan\Rules\Generics\TemplateTypeCheck::__construct";i:235;s:49:"PHPStan\Rules\Generics\VarianceCheck::__construct";i:236;s:37:"PHPStan\Rules\IssetCheck::__construct";i:237;s:50:"PHPStan\Rules\Methods\MethodCallCheck::__construct";i:238;s:56:"PHPStan\Rules\Methods\StaticMethodCallCheck::__construct";i:239;s:54:"PHPStan\Rules\Methods\MethodSignatureRule::__construct";i:240;s:66:"PHPStan\Rules\Methods\MethodParameterComparisonHelper::__construct";i:241;s:47:"PHPStan\Rules\MissingTypehintCheck::__construct";i:242;s:82:"PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider::__construct";i:243;s:72:"PHPStan\Rules\Methods\LazyAlwaysUsedMethodExtensionProvider::__construct";i:244;s:50:"PHPStan\Rules\PhpDoc\AssertRuleHelper::__construct";i:245;s:59:"PHPStan\Rules\PhpDoc\GenericCallableRuleHelper::__construct";i:246;s:54:"PHPStan\Rules\PhpDoc\VarTagTypeRuleHelper::__construct";i:247;s:78:"PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider::__construct";i:248;s:42:"PHPStan\Rules\RuleLevelHelper::__construct";i:249;s:56:"PHPStan\Rules\UnusedFunctionParametersCheck::__construct";i:250;s:40:"PHPStan\Type\FileTypeMapper::__construct";i:251;s:49:"PHPStan\Type\UsefulTypeAliasResolver::__construct";i:252;s:55:"PHPStan\Type\LazyTypeAliasResolverProvider::__construct";i:253;s:43:"PHPStan\Type\BitwiseFlagHelper::__construct";i:254;s:74:"PHPStan\Type\Php\ArrayIntersectKeyFunctionReturnTypeExtension::__construct";i:255;s:67:"PHPStan\Type\Php\ArrayChunkFunctionReturnTypeExtension::__construct";i:256;s:68:"PHPStan\Type\Php\ArrayColumnFunctionReturnTypeExtension::__construct";i:257;s:69:"PHPStan\Type\Php\ArrayCombineFunctionReturnTypeExtension::__construct";i:258;s:66:"PHPStan\Type\Php\ArrayFillFunctionReturnTypeExtension::__construct";i:259;s:70:"PHPStan\Type\Php\ArrayFillKeysFunctionReturnTypeExtension::__construct";i:260;s:66:"PHPStan\Type\Php\ArrayFlipFunctionReturnTypeExtension::__construct";i:261;s:73:"PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension::__construct";i:262;s:75:"PHPStan\Type\Php\ArraySearchFunctionDynamicReturnTypeExtension::__construct";i:263;s:75:"PHPStan\Type\Php\ArrayValuesFunctionDynamicReturnTypeExtension::__construct";i:264;s:67:"PHPStan\Type\Php\BcMathStringOrNullReturnTypeExtension::__construct";i:265;s:64:"PHPStan\Type\Php\CompactFunctionReturnTypeExtension::__construct";i:266;s:65:"PHPStan\Type\Php\ConstantFunctionReturnTypeExtension::__construct";i:267;s:75:"PHPStan\Type\Php\CurlGetinfoFunctionDynamicReturnTypeExtension::__construct";i:268;s:57:"PHPStan\Type\Php\CurlInitReturnTypeExtension::__construct";i:269;s:67:"PHPStan\Type\Php\DateFormatFunctionReturnTypeExtension::__construct";i:270;s:65:"PHPStan\Type\Php\DateFormatMethodReturnTypeExtension::__construct";i:271;s:61:"PHPStan\Type\Php\DateFunctionReturnTypeExtension::__construct";i:272;s:71:"PHPStan\Type\Php\DateIntervalConstructorThrowTypeExtension::__construct";i:273;s:63:"PHPStan\Type\Php\DateTimeModifyReturnTypeExtension::__construct";i:275;s:67:"PHPStan\Type\Php\DateTimeConstructorThrowTypeExtension::__construct";i:276;s:68:"PHPStan\Type\Php\DateTimeModifyMethodThrowTypeExtension::__construct";i:277;s:71:"PHPStan\Type\Php\DateTimeZoneConstructorThrowTypeExtension::__construct";i:278;s:71:"PHPStan\Type\Php\ExplodeFunctionDynamicReturnTypeExtension::__construct";i:279;s:60:"PHPStan\Type\Php\FilterFunctionReturnTypeHelper::__construct";i:280;s:67:"PHPStan\Type\Php\FilterInputDynamicReturnTypeExtension::__construct";i:281;s:65:"PHPStan\Type\Php\FilterVarDynamicReturnTypeExtension::__construct";i:282;s:70:"PHPStan\Type\Php\FilterVarArrayDynamicReturnTypeExtension::__construct";i:283;s:78:"PHPStan\Type\Php\GetParentClassDynamicFunctionReturnTypeExtension::__construct";i:284;s:62:"PHPStan\Type\Php\HashFunctionsReturnTypeExtension::__construct";i:285;s:71:"PHPStan\Type\Php\HighlightStringDynamicReturnTypeExtension::__construct";i:286;s:52:"PHPStan\Type\Php\JsonThrowTypeExtension::__construct";i:287;s:62:"PHPStan\Type\Php\PregMatchTypeSpecifyingExtension::__construct";i:288;s:64:"PHPStan\Type\Php\PregMatchParameterOutTypeExtension::__construct";i:289;s:69:"PHPStan\Type\Php\PregReplaceCallbackClosureTypeExtension::__construct";i:290;s:52:"PHPStan\Type\Php\RegexArrayShapeMatcher::__construct";i:291;s:48:"PHPStan\Type\Regex\RegexGroupParser::__construct";i:292;s:53:"PHPStan\Type\Regex\RegexExpressionHelper::__construct";i:293;s:77:"PHPStan\Type\Php\ReflectionFunctionConstructorThrowTypeExtension::__construct";i:294;s:75:"PHPStan\Type\Php\ReflectionMethodConstructorThrowTypeExtension::__construct";i:295;s:77:"PHPStan\Type\Php\ReflectionPropertyConstructorThrowTypeExtension::__construct";i:296;s:67:"PHPStan\Type\Php\PropertyExistsTypeSpecifyingExtension::__construct";i:297;s:63:"PHPStan\Type\Php\MinMaxFunctionReturnTypeExtension::__construct";i:298;s:72:"PHPStan\Type\Php\PathinfoFunctionDynamicReturnTypeExtension::__construct";i:299;s:65:"PHPStan\Type\Php\PregSplitDynamicReturnTypeExtension::__construct";i:300;s:60:"PHPStan\Type\Php\MbFunctionsReturnTypeExtension::__construct";i:301;s:77:"PHPStan\Type\Php\MbSubstituteCharacterDynamicReturnTypeExtension::__construct";i:302;s:65:"PHPStan\Type\Php\MbStrlenFunctionReturnTypeExtension::__construct";i:303;s:68:"PHPStan\Type\Php\TriggerErrorDynamicReturnTypeExtension::__construct";i:304;s:62:"PHPStan\Type\Php\RoundFunctionReturnTypeExtension::__construct";i:305;s:68:"PHPStan\Type\Php\DefinedConstantTypeSpecifyingExtension::__construct";i:306;s:68:"PHPStan\Type\Php\IsArrayFunctionTypeSpecifyingExtension::__construct";i:307;s:71:"PHPStan\Type\Php\IsCallableFunctionTypeSpecifyingExtension::__construct";i:308;s:73:"PHPStan\Type\Php\IsSubclassOfFunctionTypeSpecifyingExtension::__construct";i:309;s:64:"PHPStan\Type\Php\IsAFunctionTypeSpecifyingExtension::__construct";i:310;s:72:"PHPStan\Type\Php\JsonThrowOnErrorDynamicReturnTypeExtension::__construct";i:311;s:79:"PHPStan\Type\Php\TypeSpecifyingFunctionsDynamicReturnTypeExtension::__construct";i:312;s:65:"PHPStan\Type\Php\StrSplitFunctionReturnTypeExtension::__construct";i:313;s:78:"PHPStan\Type\Php\ReflectionGetAttributesMethodReturnTypeExtension::__construct";i:318;s:44:"PHPStan\Type\ClosureTypeFactory::__construct";i:319;s:49:"PHPStan\Rules\Functions\PrintfHelper::__construct";i:320;s:49:"_PHPStan_4f7beffdf\Nette\DI\Container::getService";i:321;s:45:"PHPStan\Analyser\TypeSpecifierFactory::create";i:322;s:50:"PHPStan\Analyser\TypeSpecifierFactory::__construct";i:323;s:49:"PHPStan\File\FuzzyRelativePathHelper::__construct";i:324;s:50:"PHPStan\File\SimpleRelativePathHelper::__construct";i:325;s:59:"PHPStan\File\ParentDirectoryRelativePathHelper::__construct";i:326;s:36:"PHPStan\Broker\BrokerFactory::create";i:327;s:41:"PHPStan\Broker\BrokerFactory::__construct";i:328;s:43:"PHPStan\Cache\FileCacheStorage::__construct";i:329;s:38:"PHPStan\Parser\RichParser::__construct";i:330;s:42:"PHPStan\Parser\CleaningParser::__construct";i:331;s:40:"PHPStan\Parser\SimpleParser::__construct";i:332;s:40:"PHPStan\Parser\CachedParser::__construct";i:333;s:46:"PHPStan\Parser\PhpParserDecorator::__construct";i:334;s:35:"PHPStan\Parser\LexerFactory::create";i:335;s:37:"PhpParser\ParserAbstract::__construct";i:336;s:39:"PHPStan\Rules\LazyRegistry::__construct";i:337;s:46:"PHPStan\PhpDoc\StubPhpDocProvider::__construct";i:338;s:76:"PHPStan\Reflection\ReflectionProvider\ReflectionProviderFactory::__construct";i:340;s:80:"PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory::create";i:341;s:64:"PHPStan\BetterReflection\Reflector\DefaultReflector::__construct";i:342;s:77:"PHPStan\Reflection\BetterReflection\Reflector\MemoizingReflector::__construct";i:343;s:62:"PHPStan\BetterReflection\Reflector\ClassReflector::__construct";i:344;s:65:"PHPStan\BetterReflection\Reflector\FunctionReflector::__construct";i:345;s:65:"PHPStan\BetterReflection\Reflector\ConstantReflector::__construct";i:347;s:73:"PHPStan\Reflection\BetterReflection\BetterReflectionProvider::__construct";i:348;s:85:"PHPStan\Reflection\BetterReflection\BetterReflectionSourceLocatorFactory::__construct";i:350;s:96:"PHPStan\Reflection\BetterReflection\SourceStubber\PhpStormStubsSourceStubberFactory::__construct";i:353;s:93:"PHPStan\Reflection\BetterReflection\SourceStubber\ReflectionSourceStubberFactory::__construct";i:354;s:44:"PHPStan\Parser\LexerFactory::createEmulative";i:357;s:45:"PHPStan\Parser\PathRoutingParser::__construct";i:358;s:54:"PHPStan\Diagnose\PHPStanDiagnoseExtension::__construct";i:359;s:68:"PHPStan\Command\ErrorFormatter\CiDetectedErrorFormatter::__construct";i:360;s:63:"PHPStan\Command\ErrorFormatter\TableErrorFormatter::__construct";i:361;s:68:"PHPStan\Command\ErrorFormatter\CheckstyleErrorFormatter::__construct";i:362;s:62:"PHPStan\Command\ErrorFormatter\JsonErrorFormatter::__construct";i:363;s:63:"PHPStan\Command\ErrorFormatter\JunitErrorFormatter::__construct";i:365;s:64:"PHPStan\Command\ErrorFormatter\GitlabErrorFormatter::__construct";i:366;s:64:"PHPStan\Command\ErrorFormatter\GithubErrorFormatter::__construct";i:367;s:66:"PHPStan\Command\ErrorFormatter\TeamcityErrorFormatter::__construct";i:368;s:53:"PHPStan\Rules\Api\ApiClassConstFetchRule::__construct";i:369;s:48:"PHPStan\Rules\Api\ApiInstanceofRule::__construct";i:370;s:52:"PHPStan\Rules\Api\ApiInstanceofTypeRule::__construct";i:371;s:66:"PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule::__construct";i:372;s:60:"PHPStan\Rules\Api\RuntimeReflectionFunctionRule::__construct";i:373;s:65:"PHPStan\Rules\Api\RuntimeReflectionInstantiationRule::__construct";i:374;s:66:"PHPStan\Rules\Classes\ExistingClassInClassExtendsRule::__construct";i:375;s:64:"PHPStan\Rules\Classes\ExistingClassInInstanceOfRule::__construct";i:376;s:66:"PHPStan\Rules\Exceptions\CaughtExceptionExistenceRule::__construct";i:377;s:66:"PHPStan\Rules\Functions\CallToNonExistentFunctionRule::__construct";i:378;s:59:"PHPStan\Rules\Constants\OverridingConstantRule::__construct";i:379;s:55:"PHPStan\Rules\Methods\OverridingMethodRule::__construct";i:380;s:60:"PHPStan\Rules\Methods\ConsistentConstructorRule::__construct";i:381;s:52:"PHPStan\Rules\Missing\MissingReturnRule::__construct";i:382;s:65:"PHPStan\Rules\Namespaces\ExistingNamesInGroupUseRule::__construct";i:383;s:60:"PHPStan\Rules\Namespaces\ExistingNamesInUseRule::__construct";i:384;s:63:"PHPStan\Rules\Operators\InvalidIncDecOperationRule::__construct";i:385;s:58:"PHPStan\Rules\Properties\AccessPropertiesRule::__construct";i:386;s:64:"PHPStan\Rules\Properties\AccessStaticPropertiesRule::__construct";i:387;s:69:"PHPStan\Rules\Properties\ExistingClassesInPropertiesRule::__construct";i:388;s:57:"PHPStan\Rules\Functions\FunctionCallableRule::__construct";i:389;s:79:"PHPStan\Rules\Properties\MissingReadOnlyByPhpDocPropertyAssignRule::__construct";i:390;s:60:"PHPStan\Rules\Properties\OverridingPropertyRule::__construct";i:391;s:63:"PHPStan\Rules\Properties\UninitializedPropertyRule::__construct";i:392;s:69:"PHPStan\Rules\Properties\WritingToReadOnlyPropertiesRule::__construct";i:393;s:68:"PHPStan\Rules\Properties\ReadingWriteOnlyPropertiesRule::__construct";i:394;s:57:"PHPStan\Rules\Variables\CompactVariablesRule::__construct";i:395;s:56:"PHPStan\Rules\Variables\DefinedVariableRule::__construct";i:396;s:62:"PHPStan\Rules\Regexp\RegularExpressionPatternRule::__construct";i:397;s:50:"PHPStan\Reflection\ConstructorsHelper::__construct";i:398;s:71:"PHPStan\Rules\Methods\MissingMagicSerializationMethodsRule::__construct";i:399;s:67:"PHPStan\Rules\Functions\UselessFunctionReturnValueRule::__construct";i:400;s:62:"PHPStan\Rules\Functions\PrintfArrayParametersRule::__construct";i:401;s:62:"PHPStan\Rules\Regexp\RegularExpressionQuotingRule::__construct";i:402;s:44:"PHPStan\Rules\Classes\MixinRule::__construct";i:403;s:48:"PHPStan\Rules\Classes\MethodTagRule::__construct";i:404;s:53:"PHPStan\Rules\Classes\MethodTagTraitRule::__construct";i:405;s:50:"PHPStan\Rules\Classes\PropertyTagRule::__construct";i:406;s:55:"PHPStan\Rules\Classes\PropertyTagTraitRule::__construct";i:407;s:53:"PHPStan\Rules\PhpDoc\RequireExtendsCheck::__construct";i:408;s:70:"PHPStan\Rules\PhpDoc\RequireImplementsDefinitionTraitRule::__construct";i:409;s:54:"PHPStan\Rules\Functions\CallCallablesRule::__construct";i:410;s:59:"PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule::__construct";i:411;s:61:"PHPStan\Rules\PhpDoc\InvalidPhpDocVarTagTypeRule::__construct";i:412;s:58:"PHPStan\Rules\PhpDoc\InvalidPHPStanDocTagRule::__construct";i:413;s:65:"PHPStan\Rules\PhpDoc\VarTagChangedExpressionTypeRule::__construct";i:414;s:63:"PHPStan\Rules\PhpDoc\WrongVariableNameInVarTagRule::__construct";i:415;s:56:"PHPStan\Rules\Generics\PropertyVarianceRule::__construct";i:416;s:48:"PHPStan\Rules\Pure\PureFunctionRule::__construct";i:417;s:46:"PHPStan\Rules\Pure\PureMethodRule::__construct";i:418;s:63:"PHPStan\Rules\Operators\InvalidBinaryOperationRule::__construct";i:419;s:62:"PHPStan\Rules\Operators\InvalidUnaryOperationRule::__construct";i:420;s:63:"PHPStan\Rules\Arrays\InvalidKeyInArrayDimFetchRule::__construct";i:421;s:59:"PHPStan\Rules\Arrays\InvalidKeyInArrayItemRule::__construct";i:422;s:70:"PHPStan\Rules\Arrays\NonexistentOffsetInArrayDimFetchRule::__construct";i:423;s:82:"PHPStan\Rules\Exceptions\ThrowsVoidFunctionWithExplicitThrowPointRule::__construct";i:424;s:80:"PHPStan\Rules\Exceptions\ThrowsVoidMethodWithExplicitThrowPointRule::__construct";i:425;s:55:"PHPStan\Rules\Generators\YieldFromTypeRule::__construct";i:426;s:58:"PHPStan\Rules\Generators\YieldInGeneratorRule::__construct";i:427;s:52:"PHPStan\Rules\Arrays\ArrayUnpackingRule::__construct";i:428;s:75:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRefRule::__construct";i:429;s:72:"PHPStan\Rules\Properties\ReadOnlyByPhpDocPropertyAssignRule::__construct";i:430;s:65:"PHPStan\Rules\Variables\ParameterOutAssignedTypeRule::__construct";i:431;s:69:"PHPStan\Rules\Variables\ParameterOutExecutionEndTypeRule::__construct";i:432;s:59:"PHPStan\Rules\Classes\ImpossibleInstanceOfRule::__construct";i:433;s:69:"PHPStan\Rules\Comparison\BooleanAndConstantConditionRule::__construct";i:434;s:68:"PHPStan\Rules\Comparison\BooleanOrConstantConditionRule::__construct";i:435;s:69:"PHPStan\Rules\Comparison\BooleanNotConstantConditionRule::__construct";i:436;s:44:"PHPStan\Rules\DeadCode\NoopRule::__construct";i:437;s:60:"PHPStan\Rules\DeadCode\PossiblyPureNewCollector::__construct";i:438;s:65:"PHPStan\Rules\DeadCode\PossiblyPureFuncCallCollector::__construct";i:439;s:67:"PHPStan\Rules\DeadCode\PossiblyPureMethodCallCollector::__construct";i:440;s:67:"PHPStan\Rules\DeadCode\PossiblyPureStaticCallCollector::__construct";i:441;s:61:"PHPStan\Rules\DeadCode\UnusedPrivatePropertyRule::__construct";i:442;s:70:"PHPStan\Rules\Comparison\DoWhileLoopConstantConditionRule::__construct";i:443;s:65:"PHPStan\Rules\Comparison\ElseIfConstantConditionRule::__construct";i:444;s:61:"PHPStan\Rules\Comparison\IfConstantConditionRule::__construct";i:445;s:73:"PHPStan\Rules\Comparison\ImpossibleCheckTypeFunctionCallRule::__construct";i:446;s:71:"PHPStan\Rules\Comparison\ImpossibleCheckTypeMethodCallRule::__construct";i:447;s:77:"PHPStan\Rules\Comparison\ImpossibleCheckTypeStaticMethodCallRule::__construct";i:448;s:69:"PHPStan\Rules\Comparison\LogicalXorConstantConditionRule::__construct";i:449;s:50:"PHPStan\Rules\DeadCode\BetterNoopRule::__construct";i:450;s:57:"PHPStan\Rules\Comparison\MatchExpressionRule::__construct";i:451;s:84:"PHPStan\Rules\Comparison\NumberComparisonOperatorsConstantConditionRule::__construct";i:452;s:74:"PHPStan\Rules\Comparison\StrictComparisonOfDifferentTypesRule::__construct";i:453;s:65:"PHPStan\Rules\Comparison\ConstantLooseComparisonRule::__construct";i:454;s:74:"PHPStan\Rules\Comparison\TernaryOperatorConstantConditionRule::__construct";i:455;s:63:"PHPStan\Rules\Comparison\UnreachableIfBranchesRule::__construct";i:456;s:70:"PHPStan\Rules\Comparison\UnreachableTernaryElseBranchRule::__construct";i:457;s:71:"PHPStan\Rules\Comparison\WhileLoopAlwaysFalseConditionRule::__construct";i:458;s:70:"PHPStan\Rules\Comparison\WhileLoopAlwaysTrueConditionRule::__construct";i:459;s:83:"PHPStan\Rules\Methods\CallToConstructorStatementWithoutSideEffectsRule::__construct";i:460;s:75:"PHPStan\Rules\TooWideTypehints\TooWideMethodReturnTypehintRule::__construct";i:461;s:63:"PHPStan\Rules\Properties\NullsafePropertyFetchRule::__construct";i:462;s:68:"PHPStan\Rules\Exceptions\CatchWithUnthrownExceptionRule::__construct";i:463;s:79:"PHPStan\Rules\TooWideTypehints\TooWideFunctionParameterOutTypeRule::__construct";i:464;s:77:"PHPStan\Rules\TooWideTypehints\TooWideMethodParameterOutTypeRule::__construct";i:465;s:67:"PHPStan\Rules\TooWideTypehints\TooWidePropertyTypeRule::__construct";i:466;s:60:"PHPStan\Rules\Functions\RandomIntParametersRule::__construct";i:467;s:52:"PHPStan\Rules\Functions\ArrayFilterRule::__construct";i:468;s:52:"PHPStan\Rules\Functions\ArrayValuesRule::__construct";i:469;s:53:"PHPStan\Rules\Functions\CallUserFuncRule::__construct";i:470;s:56:"PHPStan\Rules\Functions\ImplodeFunctionRule::__construct";i:471;s:66:"PHPStan\Rules\Functions\ParameterCastableToStringRule::__construct";i:472;s:73:"PHPStan\Rules\Functions\ImplodeParameterCastableToStringRule::__construct";i:473;s:70:"PHPStan\Rules\Functions\SortParameterCastableToStringRule::__construct";i:474;s:73:"PHPStan\Rules\Functions\MissingFunctionParameterTypehintRule::__construct";i:475;s:69:"PHPStan\Rules\Methods\MissingMethodParameterTypehintRule::__construct";i:476;s:63:"PHPStan\Rules\Methods\MissingMethodSelfOutTypeRule::__construct";}i:5;s:32:"7b908ae75db9443012d417f414ac6f03";} \ No newline at end of file diff --git a/test/cache/phpstan/resultCache.php b/test/cache/phpstan/resultCache.php new file mode 100644 index 0000000..4bb5418 --- /dev/null +++ b/test/cache/phpstan/resultCache.php @@ -0,0 +1,241 @@ + 1726411440, + 'meta' => array ( + 'cacheVersion' => 'v12-linesToIgnore', + 'phpstanVersion' => '1.12.0', + 'phpVersion' => 80303, + 'projectConfig' => '{parameters: {level: 9, scanDirectories: [/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php], paths: [/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php], tmpDir: %currentWorkingDirectory%/../cache/phpstan}}', + 'analysedPaths' => + array ( + 0 => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php', + ), + 'scannedFiles' => + array ( + ), + 'composerLocks' => + array ( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/composer.lock' => '259e05ff868f12b8c3ccefd6aeb8a3d8b200bd72', + ), + 'composerInstalled' => + array ( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/composer/installed.php' => + array ( + 'versions' => + array ( + 'phpstan/phpstan' => + array ( + 'pretty_version' => '1.12.0', + 'version' => '1.12.0.0', + 'reference' => '384af967d35b2162f69526c7276acadce534d0e1', + 'type' => 'library', + 'install_path' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/composer/../phpstan/phpstan', + 'aliases' => + array ( + ), + 'dev_requirement' => false, + ), + ), + ), + ), + 'executedFilesHashes' => + array ( + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/Attribute.php' => 'eaf9127f074e9c7ebc65043ec4050f9fed60c2bb', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionAttribute.php' => '0b4b78277eb6545955d2ce5e09bff28f1f8052c8', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionIntersectionType.php' => 'a3e6299b87ee5d407dae7651758edfa11a74cb11', + 'phar:///home/sanderronde/git/phpstan-vscode/test/multi-config-demo/vendor/phpstan/phpstan/phpstan.phar/stubs/runtime/ReflectionUnionType.php' => '1b349aa997a834faeafe05fa21bc31cae22bf2e2', + ), + 'phpExtensions' => + array ( + 0 => 'Core', + 1 => 'Phar', + 2 => 'Reflection', + 3 => 'SPL', + 4 => 'SimpleXML', + 5 => 'Zend OPcache', + 6 => 'apcu', + 7 => 'ctype', + 8 => 'curl', + 9 => 'date', + 10 => 'dom', + 11 => 'filter', + 12 => 'gd', + 13 => 'hash', + 14 => 'iconv', + 15 => 'igbinary', + 16 => 'json', + 17 => 'libxml', + 18 => 'mbstring', + 19 => 'openssl', + 20 => 'pcntl', + 21 => 'pcre', + 22 => 'pgsql', + 23 => 'posix', + 24 => 'random', + 25 => 'readline', + 26 => 'redis', + 27 => 'session', + 28 => 'sockets', + 29 => 'sodium', + 30 => 'standard', + 31 => 'tideways', + 32 => 'tokenizer', + 33 => 'xml', + 34 => 'xmlwriter', + 35 => 'zlib', + ), + 'stubFiles' => + array ( + ), + 'level' => '9', +), + 'projectExtensionFiles' => array ( +), + 'errorsCallback' => static function (): array { return array ( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php/DemoClass.php' => + array ( + 0 => + \PHPStan\Analyser\Error::__set_state(array( + 'message' => 'Method DemoClass::strUnion() has no return type specified.', + 'file' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php/DemoClass.php', + 'line' => 11, + 'canBeIgnored' => true, + 'filePath' => '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php/DemoClass.php', + 'traitFilePath' => NULL, + 'tip' => NULL, + 'nodeLine' => 11, + 'nodeType' => 'PHPStan\\Node\\InClassMethodNode', + 'identifier' => 'missingType.return', + 'metadata' => + array ( + ), + )), + ), +); }, + 'locallyIgnoredErrorsCallback' => static function (): array { return array ( +); }, + 'linesToIgnore' => array ( +), + 'unmatchedLineIgnores' => array ( +), + 'collectedDataCallback' => static function (): array { return array ( +); }, + 'dependencies' => array ( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php/DemoClass.php' => + array ( + 'fileHash' => 'b8afe744d312c0f350468bc372aa3e12b22de586', + 'dependentFiles' => + array ( + ), + ), +), + 'exportedNodesCallback' => static function (): array { return array ( + '/home/sanderronde/git/phpstan-vscode/test/multi-config-demo/src/php/DemoClass.php' => + array ( + 0 => + \PHPStan\Dependency\ExportedNode\ExportedClassNode::__set_state(array( + 'name' => 'X', + 'phpDoc' => NULL, + 'abstract' => false, + 'final' => false, + 'extends' => NULL, + 'implements' => + array ( + ), + 'usedTraits' => + array ( + ), + 'traitUseAdaptations' => + array ( + ), + 'statements' => + array ( + 0 => + \PHPStan\Dependency\ExportedNode\ExportedPropertiesNode::__set_state(array( + 'names' => + array ( + 0 => 'y', + ), + 'phpDoc' => NULL, + 'type' => 'string', + 'public' => true, + 'private' => false, + 'static' => false, + 'readonly' => false, + 'attributes' => + array ( + ), + )), + ), + 'attributes' => + array ( + ), + )), + 1 => + \PHPStan\Dependency\ExportedNode\ExportedClassNode::__set_state(array( + 'name' => 'DemoClass', + 'phpDoc' => NULL, + 'abstract' => false, + 'final' => false, + 'extends' => NULL, + 'implements' => + array ( + ), + 'usedTraits' => + array ( + ), + 'traitUseAdaptations' => + array ( + ), + 'statements' => + array ( + 0 => + \PHPStan\Dependency\ExportedNode\ExportedMethodNode::__set_state(array( + 'name' => 'strUnion', + 'phpDoc' => + \PHPStan\Dependency\ExportedNode\ExportedPhpDocNode::__set_state(array( + 'phpDocString' => '/** + * @param \'a\'|\'b\'|\'c\'|\'d\'|\'e\'|\'f\' $initialStr + */', + 'namespace' => NULL, + 'uses' => + array ( + ), + 'constUses' => + array ( + ), + )), + 'byRef' => false, + 'public' => true, + 'private' => false, + 'abstract' => false, + 'final' => false, + 'static' => false, + 'returnType' => NULL, + 'parameters' => + array ( + 0 => + \PHPStan\Dependency\ExportedNode\ExportedParameterNode::__set_state(array( + 'name' => 'initialStr', + 'type' => 'string', + 'byRef' => false, + 'variadic' => false, + 'hasDefault' => false, + 'attributes' => + array ( + ), + )), + ), + 'attributes' => + array ( + ), + )), + ), + 'attributes' => + array ( + ), + )), + ), +); }, +]; diff --git a/test/multi-config-demo/.vscode/settings.json b/test/multi-config-demo/.vscode/settings.json new file mode 100644 index 0000000..b71f8d7 --- /dev/null +++ b/test/multi-config-demo/.vscode/settings.json @@ -0,0 +1,4 @@ +{ + "phpstan.rootDir": "./", + "phpstan.configFiles": ["src/phpstan.neon", "test/phpstan.neon"] +} diff --git a/test/multi-config-demo/autoloader.php b/test/multi-config-demo/autoloader.php new file mode 100644 index 0000000..36f411b --- /dev/null +++ b/test/multi-config-demo/autoloader.php @@ -0,0 +1,4 @@ + void): void; + public isList(): boolean; + public values(): Neon[]; + public keys(): string[]; + public items(): { key: string; value: Neon }[]; + public toObject(): Record; + } + + type Neon = string | number | boolean | Map; + + export function decode(content: string): Neon; + export function encode(content: Neon): string; +}