1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-11 08:49:52 +01:00
psalm/src/Psalm/Codebase.php

1243 lines
34 KiB
PHP
Raw Normal View History

<?php
namespace Psalm;
use LanguageServerProtocol\{Position, Range};
use PhpParser;
use Psalm\Internal\Analyzer\Statements\Block\ForeachAnalyzer;
2018-11-06 03:57:36 +01:00
use Psalm\Internal\Analyzer\ProjectAnalyzer;
use Psalm\Internal\Analyzer\TypeAnalyzer;
2018-11-06 03:57:36 +01:00
use Psalm\Internal\Provider\ClassLikeStorageProvider;
use Psalm\Internal\Provider\FileProvider;
use Psalm\Internal\Provider\FileReferenceProvider;
use Psalm\Internal\Provider\FileStorageProvider;
use Psalm\Internal\Provider\Providers;
use Psalm\Internal\Provider\StatementsProvider;
use Psalm\Storage\ClassLikeStorage;
use Psalm\Storage\FileStorage;
use Psalm\Storage\FunctionLikeStorage;
class Codebase
{
/**
2018-04-05 20:40:41 +02:00
* @var Config
*/
public $config;
/**
* A map of fully-qualified use declarations to the files
* that reference them (keyed by filename)
*
* @var array<string, array<string, array<int, \Psalm\CodeLocation>>>
*/
public $use_referencing_locations = [];
/**
* A map of file names to the classes that they contain explicit references to
* used in collaboration with use_referencing_locations
*
* @var array<string, array<string, bool>>
*/
public $use_referencing_files = [];
/**
* @var FileStorageProvider
*/
public $file_storage_provider;
/**
* @var ClassLikeStorageProvider
*/
public $classlike_storage_provider;
/**
* @var bool
*/
public $collect_references = false;
/**
* @var FileProvider
*/
public $file_provider;
/**
* @var FileReferenceProvider
*/
public $file_reference_provider;
/**
* @var StatementsProvider
*/
public $statements_provider;
/**
2018-02-04 00:52:35 +01:00
* @var bool
*/
2018-02-04 00:52:35 +01:00
private $debug_output = false;
/**
2018-02-04 00:52:35 +01:00
* @var array<string, Type\Union>
*/
2018-02-04 00:52:35 +01:00
private static $stubbed_constants = [];
/**
* Whether to register autoloaded information
*
* @var bool
*/
public $register_autoload_files = false;
/**
2018-02-04 00:52:35 +01:00
* Whether to log functions just at the file level or globally (for stubs)
*
* @var bool
*/
public $register_stub_files = false;
/**
* @var bool
*/
public $find_unused_code = false;
/**
* @var bool
*/
public $find_unused_variables = false;
/**
* @var Internal\Codebase\Reflection
*/
2018-02-04 00:52:35 +01:00
private $reflection;
/**
* @var Internal\Codebase\Scanner
*/
2018-02-04 00:52:35 +01:00
public $scanner;
/**
* @var Internal\Codebase\Analyzer
*/
2018-02-04 00:52:35 +01:00
public $analyzer;
/**
* @var Internal\Codebase\Functions
*/
2018-02-04 00:52:35 +01:00
public $functions;
/**
* @var Internal\Codebase\ClassLikes
*/
2018-02-04 00:52:35 +01:00
public $classlikes;
/**
* @var Internal\Codebase\Methods
*/
2018-02-04 00:52:35 +01:00
public $methods;
/**
* @var Internal\Codebase\Properties
*/
public $properties;
/**
* @var Internal\Codebase\Populator
*/
2018-02-04 00:52:35 +01:00
public $populator;
/**
* @var bool
*/
public $server_mode = false;
2019-02-24 07:33:25 +01:00
/**
* @var bool
*/
public $store_node_types = false;
2018-11-06 03:57:36 +01:00
/**
* Whether or not to infer types from usage. Computationally expensive, so turned off by default
*
* @var bool
*/
public $infer_types_from_usage = false;
/**
* @var bool
*/
public $alter_code = false;
/**
* @var bool
*/
public $diff_methods = false;
/**
* @var int
*/
public $php_major_version = PHP_MAJOR_VERSION;
/**
* @var int
*/
public $php_minor_version = PHP_MINOR_VERSION;
/**
* @param bool $debug_output
*/
public function __construct(
Config $config,
Providers $providers,
$debug_output = false
) {
$this->config = $config;
$this->file_storage_provider = $providers->file_storage_provider;
$this->classlike_storage_provider = $providers->classlike_storage_provider;
$this->debug_output = $debug_output;
$this->file_provider = $providers->file_provider;
$this->file_reference_provider = $providers->file_reference_provider;
$this->statements_provider = $providers->statements_provider;
$this->debug_output = $debug_output;
self::$stubbed_constants = [];
$this->reflection = new Internal\Codebase\Reflection($providers->classlike_storage_provider, $this);
$this->scanner = new Internal\Codebase\Scanner(
2018-02-04 00:52:35 +01:00
$this,
$config,
$providers->file_storage_provider,
$providers->file_provider,
2018-02-04 00:52:35 +01:00
$this->reflection,
$providers->file_reference_provider,
2018-02-04 00:52:35 +01:00
$debug_output
);
$this->loadAnalyzer();
$this->functions = new Internal\Codebase\Functions($providers->file_storage_provider, $this->reflection);
$this->properties = new Internal\Codebase\Properties(
$providers->classlike_storage_provider,
$providers->file_reference_provider
);
2018-10-07 02:11:19 +02:00
$this->classlikes = new Internal\Codebase\ClassLikes(
2018-10-07 02:11:19 +02:00
$this->config,
$providers->classlike_storage_provider,
$this->scanner
2018-02-04 00:52:35 +01:00
);
$this->methods = new Internal\Codebase\Methods(
$config,
$providers->classlike_storage_provider,
$providers->file_reference_provider,
$this->classlikes
);
$this->populator = new Internal\Codebase\Populator(
2018-02-04 00:52:35 +01:00
$config,
$providers->classlike_storage_provider,
$providers->file_storage_provider,
2018-02-04 00:52:35 +01:00
$this->classlikes,
$providers->file_reference_provider,
2018-02-04 00:52:35 +01:00
$debug_output
);
2018-10-07 02:11:19 +02:00
$this->loadAnalyzer();
}
/**
* @return void
*/
private function loadAnalyzer()
{
$this->analyzer = new Internal\Codebase\Analyzer(
$this->config,
$this->file_provider,
$this->file_storage_provider,
$this->debug_output
);
}
/**
* @param array<string> $candidate_files
*
* @return void
*/
2018-11-11 18:01:14 +01:00
public function reloadFiles(ProjectAnalyzer $project_analyzer, array $candidate_files)
{
$this->loadAnalyzer();
$this->file_reference_provider->loadReferenceCache();
if (!$this->statements_provider->parser_cache_provider) {
$diff_files = $candidate_files;
} else {
$diff_files = [];
$parser_cache_provider = $this->statements_provider->parser_cache_provider;
foreach ($candidate_files as $candidate_file_path) {
if ($parser_cache_provider->loadExistingFileContentsFromCache($candidate_file_path)
!== $this->file_provider->getContents($candidate_file_path)
) {
$diff_files[] = $candidate_file_path;
}
}
}
2018-11-11 18:01:14 +01:00
$referenced_files = $project_analyzer->getReferencedFilesFromDiff($diff_files, false);
foreach ($diff_files as $diff_file_path) {
$this->invalidateInformationForFile($diff_file_path);
}
foreach ($referenced_files as $referenced_file_path) {
if (in_array($referenced_file_path, $diff_files)) {
continue;
}
$file_storage = $this->file_storage_provider->get($referenced_file_path);
foreach ($file_storage->classlikes_in_file as $fq_classlike_name) {
$this->classlike_storage_provider->remove($fq_classlike_name);
$this->classlikes->removeClassLike($fq_classlike_name);
}
$this->file_storage_provider->remove($referenced_file_path);
$this->scanner->removeFile($referenced_file_path);
}
$referenced_files = array_combine($referenced_files, $referenced_files);
$this->scanner->addFilesToDeepScan($referenced_files);
2019-01-02 18:10:52 +01:00
$this->addFilesToAnalyze(array_combine($candidate_files, $candidate_files));
$this->scanner->scanFiles($this->classlikes);
$this->file_reference_provider->updateReferenceCache($this, $referenced_files);
$this->populator->populateCodebase($this);
}
/** @return void */
public function enterServerMode()
{
$this->server_mode = true;
2019-02-24 07:33:25 +01:00
$this->store_node_types = true;
}
/**
* @return void
*/
2018-02-04 00:52:35 +01:00
public function collectReferences()
{
2018-02-04 00:52:35 +01:00
$this->collect_references = true;
$this->classlikes->collect_references = true;
$this->methods->collect_references = true;
$this->properties->collect_references = true;
}
/**
* @return void
*/
public function reportUnusedCode()
{
$this->collectReferences();
$this->find_unused_code = true;
$this->find_unused_variables = true;
}
/**
* @return void
*/
public function reportUnusedVariables()
{
$this->collect_references = true;
$this->find_unused_variables = true;
}
/**
2018-02-04 00:52:35 +01:00
* @param array<string, string> $files_to_analyze
*
* @return void
*/
2018-02-04 00:52:35 +01:00
public function addFilesToAnalyze(array $files_to_analyze)
{
2018-02-04 00:52:35 +01:00
$this->scanner->addFilesToDeepScan($files_to_analyze);
$this->analyzer->addFiles($files_to_analyze);
}
/**
2018-02-04 00:52:35 +01:00
* Scans all files their related files
*
* @return void
*/
public function scanFiles(int $threads = 1)
{
$has_changes = $this->scanner->scanFiles($this->classlikes, $threads);
2018-02-04 00:52:35 +01:00
if ($has_changes) {
2018-06-28 03:53:25 +02:00
$this->populator->populateCodebase($this);
}
}
/**
2018-02-04 00:52:35 +01:00
* @param string $file_path
*
2018-02-04 00:52:35 +01:00
* @return string
*/
2018-02-04 00:52:35 +01:00
public function getFileContents($file_path)
{
2018-02-04 00:52:35 +01:00
return $this->file_provider->getContents($file_path);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $file_path
*
2018-02-04 00:52:35 +01:00
* @return array<int, PhpParser\Node\Stmt>
*/
2018-02-04 00:52:35 +01:00
public function getStatementsForFile($file_path)
{
2018-02-04 00:52:35 +01:00
return $this->statements_provider->getStatementsForFile(
$file_path,
$this->debug_output
);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $fq_classlike_name
*
2018-02-04 00:52:35 +01:00
* @return ClassLikeStorage
*/
2018-02-04 00:52:35 +01:00
public function createClassLikeStorage($fq_classlike_name)
{
2018-02-04 00:52:35 +01:00
return $this->classlike_storage_provider->create($fq_classlike_name);
}
2018-02-19 06:27:39 +01:00
/**
* @param string $file_path
*
* @return void
*/
public function cacheClassLikeStorage(ClassLikeStorage $classlike_storage, $file_path)
{
$file_contents = $this->file_provider->getContents($file_path);
if ($this->classlike_storage_provider->cache) {
$this->classlike_storage_provider->cache->writeToCache($classlike_storage, $file_path, $file_contents);
}
2018-02-19 06:27:39 +01:00
}
/**
* @param string $fq_classlike_name
* @param string $file_path
*
* @return void
*/
public function exhumeClassLikeStorage($fq_classlike_name, $file_path)
{
$file_contents = $this->file_provider->getContents($file_path);
$storage = $this->classlike_storage_provider->exhume($fq_classlike_name, $file_path, $file_contents);
if ($storage->is_trait) {
$this->classlikes->addFullyQualifiedTraitName($fq_classlike_name, $file_path);
} elseif ($storage->is_interface) {
$this->classlikes->addFullyQualifiedInterfaceName($fq_classlike_name, $file_path);
} else {
$this->classlikes->addFullyQualifiedClassName($fq_classlike_name, $file_path);
}
}
2019-01-28 00:31:40 +01:00
/**
* @param ?\ReflectionType $type
*/
public static function getPsalmTypeFromReflection($type) : Type\Union
{
return \Psalm\Internal\Codebase\Reflection::getPsalmTypeFromReflectionType($type);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $file_path
*
2018-02-04 00:52:35 +01:00
* @return FileStorage
*/
2018-02-04 00:52:35 +01:00
public function createFileStorageForPath($file_path)
{
2018-02-04 00:52:35 +01:00
return $this->file_storage_provider->create($file_path);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $symbol
*
2018-02-04 00:52:35 +01:00
* @return array<string, \Psalm\CodeLocation[]>
*/
2018-02-04 00:52:35 +01:00
public function findReferencesToSymbol($symbol)
{
2018-02-04 00:52:35 +01:00
if (!$this->collect_references) {
throw new \UnexpectedValueException('Should not be checking references');
}
2019-01-22 17:10:37 +01:00
if (strpos($symbol, '::$') !== false) {
return $this->findReferencesToProperty($symbol);
}
2018-02-04 00:52:35 +01:00
if (strpos($symbol, '::') !== false) {
return $this->findReferencesToMethod($symbol);
}
return $this->findReferencesToClassLike($symbol);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $method_id
*
2018-02-04 00:52:35 +01:00
* @return array<string, \Psalm\CodeLocation[]>
*/
2018-02-04 00:52:35 +01:00
public function findReferencesToMethod($method_id)
{
2018-02-04 00:52:35 +01:00
list($fq_class_name, $method_name) = explode('::', $method_id);
2018-02-04 00:52:35 +01:00
try {
$class_storage = $this->classlike_storage_provider->get($fq_class_name);
} catch (\InvalidArgumentException $e) {
die('Class ' . $fq_class_name . ' cannot be found' . PHP_EOL);
}
2018-02-04 00:52:35 +01:00
$method_name_lc = strtolower($method_name);
2018-02-04 00:52:35 +01:00
if (!isset($class_storage->methods[$method_name_lc])) {
die('Method ' . $method_id . ' cannot be found' . PHP_EOL);
}
2018-02-04 00:52:35 +01:00
$method_storage = $class_storage->methods[$method_name_lc];
2018-02-04 00:52:35 +01:00
if ($method_storage->referencing_locations === null) {
die('No references found for ' . $method_id . PHP_EOL);
}
2018-02-04 00:52:35 +01:00
return $method_storage->referencing_locations;
}
2019-01-22 17:10:37 +01:00
/**
* @param string $property_id
*
* @return array<string, \Psalm\CodeLocation[]>
*/
public function findReferencesToProperty($property_id)
{
list($fq_class_name, $property_name) = explode('::$', $property_id);
try {
$class_storage = $this->classlike_storage_provider->get($fq_class_name);
} catch (\InvalidArgumentException $e) {
die('Class ' . $fq_class_name . ' cannot be found' . PHP_EOL);
}
if (!isset($class_storage->properties[$property_name])) {
die('Property ' . $property_id . ' cannot be found' . PHP_EOL);
}
$property_storage = $class_storage->properties[$property_name];
if ($property_storage->referencing_locations === null) {
die('No references found for ' . $property_id . PHP_EOL);
}
return $property_storage->referencing_locations;
}
/**
2018-02-04 00:52:35 +01:00
* @param string $fq_class_name
*
2018-02-04 00:52:35 +01:00
* @return array<string, \Psalm\CodeLocation[]>
*/
2018-02-04 00:52:35 +01:00
public function findReferencesToClassLike($fq_class_name)
{
2018-02-04 00:52:35 +01:00
try {
$class_storage = $this->classlike_storage_provider->get($fq_class_name);
} catch (\InvalidArgumentException $e) {
die('Class ' . $fq_class_name . ' cannot be found' . PHP_EOL);
}
2018-02-04 00:52:35 +01:00
if ($class_storage->referencing_locations === null) {
die('No references found for ' . $fq_class_name . PHP_EOL);
}
2018-02-04 00:52:35 +01:00
$classlike_references_by_file = $class_storage->referencing_locations;
2018-02-04 00:52:35 +01:00
$fq_class_name_lc = strtolower($fq_class_name);
2018-02-04 00:52:35 +01:00
if (isset($this->use_referencing_locations[$fq_class_name_lc])) {
foreach ($this->use_referencing_locations[$fq_class_name_lc] as $file_path => $locations) {
if (!isset($classlike_references_by_file[$file_path])) {
$classlike_references_by_file[$file_path] = $locations;
} else {
$classlike_references_by_file[$file_path] = array_merge(
$locations,
$classlike_references_by_file[$file_path]
);
}
}
}
2018-02-04 00:52:35 +01:00
return $classlike_references_by_file;
}
2018-01-31 23:09:09 +01:00
/**
* @param string $file_path
* @param string $closure_id
*
* @return FunctionLikeStorage
*/
public function getClosureStorage($file_path, $closure_id)
{
$file_storage = $this->file_storage_provider->get($file_path);
// closures can be returned here
if (isset($file_storage->functions[$closure_id])) {
return $file_storage->functions[$closure_id];
}
throw new \UnexpectedValueException(
'Expecting ' . $closure_id . ' to have storage in ' . $file_path
);
}
/**
* @param string $const_id
* @param Type\Union $type
*
* @return void
*/
public function addGlobalConstantType($const_id, Type\Union $type)
{
self::$stubbed_constants[$const_id] = $type;
}
/**
* @param string $const_id
*
* @return Type\Union|null
*/
public function getStubbedConstantType($const_id)
{
return isset(self::$stubbed_constants[$const_id]) ? self::$stubbed_constants[$const_id] : null;
}
/**
2018-02-04 00:52:35 +01:00
* @param string $file_path
*
2018-02-04 00:52:35 +01:00
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function fileExists($file_path)
{
2018-02-04 00:52:35 +01:00
return $this->file_provider->fileExists($file_path);
}
/**
2018-02-04 00:52:35 +01:00
* Check whether a class/interface exists
*
2018-02-04 00:52:35 +01:00
* @param string $fq_class_name
* @param CodeLocation $code_location
*
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function classOrInterfaceExists($fq_class_name, CodeLocation $code_location = null)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->classOrInterfaceExists($fq_class_name, $code_location);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $fq_class_name
* @param string $possible_parent
*
2018-02-04 00:52:35 +01:00
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function classExtendsOrImplements($fq_class_name, $possible_parent)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->classExtends($fq_class_name, $possible_parent)
|| $this->classlikes->classImplements($fq_class_name, $possible_parent);
}
/**
2018-02-04 00:52:35 +01:00
* Determine whether or not a given class exists
*
* @param string $fq_class_name
*
2018-02-04 00:52:35 +01:00
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function classExists($fq_class_name)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->classExists($fq_class_name);
}
/**
2018-02-04 00:52:35 +01:00
* Determine whether or not a class extends a parent
*
2018-02-04 00:52:35 +01:00
* @param string $fq_class_name
* @param string $possible_parent
*
* @return bool
* @throws \Psalm\Exception\UnpopulatedClasslikeException when called on unpopulated class
* @throws \InvalidArgumentException when class does not exist
*/
2018-02-04 00:52:35 +01:00
public function classExtends($fq_class_name, $possible_parent)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->classExtends($fq_class_name, $possible_parent);
}
/**
2018-02-04 00:52:35 +01:00
* Check whether a class implements an interface
*
* @param string $fq_class_name
* @param string $interface
*
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function classImplements($fq_class_name, $interface)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->classImplements($fq_class_name, $interface);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $fq_interface_name
*
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function interfaceExists($fq_interface_name)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->interfaceExists($fq_interface_name);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $interface_name
* @param string $possible_parent
*
2018-02-04 00:52:35 +01:00
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function interfaceExtends($interface_name, $possible_parent)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->interfaceExtends($interface_name, $possible_parent);
}
2018-02-04 00:52:35 +01:00
/**
* @param string $fq_interface_name
*
* @return array<string> all interfaces extended by $interface_name
*/
public function getParentInterfaces($fq_interface_name)
{
return $this->classlikes->getParentInterfaces($fq_interface_name);
}
2018-02-04 00:52:35 +01:00
/**
* Determine whether or not a class has the correct casing
*
* @param string $fq_class_name
*
* @return bool
*/
public function classHasCorrectCasing($fq_class_name)
{
return $this->classlikes->classHasCorrectCasing($fq_class_name);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $fq_interface_name
*
2018-02-04 00:52:35 +01:00
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function interfaceHasCorrectCasing($fq_interface_name)
{
2018-02-04 00:52:35 +01:00
return $this->classlikes->interfaceHasCorrectCasing($fq_interface_name);
}
2018-02-04 00:52:35 +01:00
/**
* @param string $fq_trait_name
*
* @return bool
*/
public function traitHasCorrectCase($fq_trait_name)
{
return $this->classlikes->traitHasCorrectCase($fq_trait_name);
}
2018-02-04 00:52:35 +01:00
/**
* Whether or not a given method exists
*
* @param string $method_id
* @param CodeLocation|null $code_location
2018-09-27 19:32:08 +02:00
* @param string $calling_method_id
2018-02-04 00:52:35 +01:00
*
* @return bool
*/
2018-09-27 19:32:08 +02:00
public function methodExists($method_id, CodeLocation $code_location = null, $calling_method_id = null)
2018-02-04 00:52:35 +01:00
{
return $this->methods->methodExists($method_id, $calling_method_id, $code_location);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $method_id
*
* @return array<int, \Psalm\Storage\FunctionLikeParameter>
*/
2018-02-04 00:52:35 +01:00
public function getMethodParams($method_id)
{
2018-02-04 00:52:35 +01:00
return $this->methods->getMethodParams($method_id);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $method_id
*
* @return bool
*/
2018-02-04 00:52:35 +01:00
public function isVariadic($method_id)
{
2018-02-04 00:52:35 +01:00
return $this->methods->isVariadic($method_id);
}
2018-02-04 00:52:35 +01:00
/**
* @param string $method_id
* @param string $self_class
2019-03-04 04:57:40 +01:00
* @param array<int, PhpParser\Node\Arg> $call_args
2018-02-04 00:52:35 +01:00
*
* @return Type\Union|null
*/
2019-03-04 04:57:40 +01:00
public function getMethodReturnType($method_id, &$self_class, array $call_args = [])
2018-02-04 00:52:35 +01:00
{
return $this->methods->getMethodReturnType($method_id, $self_class);
}
2018-02-04 00:52:35 +01:00
/**
* @param string $method_id
*
* @return bool
*/
public function getMethodReturnsByRef($method_id)
{
return $this->methods->getMethodReturnsByRef($method_id);
}
2018-02-04 00:52:35 +01:00
/**
* @param string $method_id
* @param CodeLocation|null $defined_location
*
* @return CodeLocation|null
*/
public function getMethodReturnTypeLocation(
$method_id,
CodeLocation &$defined_location = null
) {
return $this->methods->getMethodReturnTypeLocation($method_id, $defined_location);
}
2018-01-31 23:09:09 +01:00
/**
2018-02-04 00:52:35 +01:00
* @param string $method_id
*
* @return string|null
2018-01-31 23:09:09 +01:00
*/
2018-02-04 00:52:35 +01:00
public function getDeclaringMethodId($method_id)
2018-01-31 23:09:09 +01:00
{
2018-02-04 00:52:35 +01:00
return $this->methods->getDeclaringMethodId($method_id);
}
2018-01-31 23:09:09 +01:00
2018-02-04 00:52:35 +01:00
/**
* Get the class this method appears in (vs is declared in, which could give a trait)
*
* @param string $method_id
*
* @return string|null
*/
public function getAppearingMethodId($method_id)
{
return $this->methods->getAppearingMethodId($method_id);
2018-01-31 23:09:09 +01:00
}
/**
2018-02-04 00:52:35 +01:00
* @param string $method_id
*
* @return array<string>
*/
2018-02-04 00:52:35 +01:00
public function getOverriddenMethodIds($method_id)
{
2018-02-04 00:52:35 +01:00
return $this->methods->getOverriddenMethodIds($method_id);
}
/**
2018-02-04 00:52:35 +01:00
* @param string $method_id
*
* @return string
*/
2018-02-04 00:52:35 +01:00
public function getCasedMethodId($method_id)
{
2018-02-04 00:52:35 +01:00
return $this->methods->getCasedMethodId($method_id);
}
/**
* @param string $file_path
*
* @return void
*/
public function invalidateInformationForFile(string $file_path)
{
$this->scanner->removeFile($file_path);
try {
$file_storage = $this->file_storage_provider->get($file_path);
} catch (\InvalidArgumentException $e) {
return;
}
foreach ($file_storage->classlikes_in_file as $fq_classlike_name) {
$this->classlike_storage_provider->remove($fq_classlike_name);
$this->classlikes->removeClassLike($fq_classlike_name);
}
$this->file_storage_provider->remove($file_path);
}
/**
* @return ?string
*/
public function getSymbolInformation(string $file_path, string $symbol)
{
if (substr($symbol, 0, 6) === 'type: ') {
return substr($symbol, 6);
}
try {
if (strpos($symbol, '::')) {
if (strpos($symbol, '()')) {
$symbol = substr($symbol, 0, -2);
$declaring_method_id = $this->methods->getDeclaringMethodId($symbol);
if (!$declaring_method_id) {
return null;
}
$storage = $this->methods->getStorage($declaring_method_id);
return '<?php ' . $storage;
}
list(, $symbol_name) = explode('::', $symbol);
if (strpos($symbol, '$') !== false) {
$storage = $this->properties->getStorage($symbol);
return '<?php ' . $storage->getInfo() . ' ' . $symbol_name;
}
list($fq_classlike_name, $const_name) = explode('::', $symbol);
$class_constants = $this->classlikes->getConstantsForClass(
$fq_classlike_name,
\ReflectionProperty::IS_PRIVATE
);
if (!isset($class_constants[$const_name])) {
return null;
}
return '<?php ' . $const_name;
}
if (strpos($symbol, '()')) {
$file_storage = $this->file_storage_provider->get($file_path);
$function_id = strtolower(substr($symbol, 0, -2));
if (isset($file_storage->functions[$function_id])) {
$function_storage = $file_storage->functions[$function_id];
return '<?php ' . $function_storage;
}
return null;
}
$storage = $this->classlike_storage_provider->get($symbol);
return '<?php ' . ($storage->abstract ? 'abstract ' : '') . 'class ' . $storage->name;
} catch (\Exception $e) {
error_log($e->getMessage());
return null;
}
}
/**
* @return ?CodeLocation
*/
public function getSymbolLocation(string $file_path, string $symbol)
{
try {
if (strpos($symbol, '::')) {
if (strpos($symbol, '()')) {
$symbol = substr($symbol, 0, -2);
$declaring_method_id = $this->methods->getDeclaringMethodId($symbol);
if (!$declaring_method_id) {
return null;
}
$storage = $this->methods->getStorage($declaring_method_id);
return $storage->location;
}
if (strpos($symbol, '$') !== false) {
$storage = $this->properties->getStorage($symbol);
return $storage->location;
}
list($fq_classlike_name, $const_name) = explode('::', $symbol);
$class_constants = $this->classlikes->getConstantsForClass(
$fq_classlike_name,
\ReflectionProperty::IS_PRIVATE
);
if (!isset($class_constants[$const_name])) {
return null;
}
$class_const_storage = $this->classlike_storage_provider->get($fq_classlike_name);
return $class_const_storage->class_constant_locations[$const_name];
}
if (strpos($symbol, '()')) {
$file_storage = $this->file_storage_provider->get($file_path);
$function_id = strtolower(substr($symbol, 0, -2));
if (isset($file_storage->functions[$function_id])) {
return $file_storage->functions[$function_id]->location;
}
return null;
}
$storage = $this->classlike_storage_provider->get($symbol);
return $storage->location;
} catch (\UnexpectedValueException $e) {
error_log($e->getMessage());
return null;
}
}
/**
* @return array{0: string, 1: Range}|null
*/
public function getReferenceAtPosition(string $file_path, Position $position)
{
$is_open = $this->file_provider->isOpen($file_path);
if (!$is_open) {
throw new \Psalm\Exception\UnanalyzedFileException($file_path . ' is not open');
}
$file_contents = $this->getFileContents($file_path);
$offset = $position->toOffset($file_contents);
list($reference_map, $type_map) = $this->analyzer->getMapsForFile($file_path);
$reference = null;
if (!$reference_map && !$type_map) {
return null;
}
$start_pos = null;
$end_pos = null;
ksort($reference_map);
foreach ($reference_map as $start_pos => list($end_pos, $possible_reference)) {
if ($offset < $start_pos) {
break;
}
2019-02-24 07:33:25 +01:00
if ($offset > $end_pos) {
continue;
}
$reference = $possible_reference;
}
if ($reference === null || $start_pos === null || $end_pos === null) {
ksort($type_map);
foreach ($type_map as $start_pos => list($end_pos, $possible_type)) {
if ($offset < $start_pos) {
break;
}
2019-02-24 07:33:25 +01:00
if ($offset > $end_pos) {
continue;
}
$reference = 'type: ' . $possible_type;
}
if ($reference === null || $start_pos === null || $end_pos === null) {
return null;
}
}
$range = new Range(
self::getPositionFromOffset($start_pos, $file_contents),
self::getPositionFromOffset($end_pos, $file_contents)
);
return [$reference, $range];
}
/**
* @return array{0: string, 1: string}|null
*/
public function getCompletionDataAtPosition(string $file_path, Position $position)
{
$is_open = $this->file_provider->isOpen($file_path);
if (!$is_open) {
throw new \Psalm\Exception\UnanalyzedFileException($file_path . ' is not open');
}
$file_contents = $this->getFileContents($file_path);
$offset = $position->toOffset($file_contents);
list(, $type_map) = $this->analyzer->getMapsForFile($file_path);
if (!$type_map) {
return null;
}
$recent_type = null;
krsort($type_map);
foreach ($type_map as $start_pos => list($end_pos, $possible_type)) {
if ($offset < $start_pos) {
continue;
}
2019-02-24 07:33:25 +01:00
if ($offset - $end_pos === 2 || $offset - $end_pos === 3) {
$recent_type = $possible_type;
break;
}
2019-02-24 07:33:25 +01:00
if ($offset - $end_pos > 3) {
break;
}
}
if (!$recent_type
|| $recent_type === 'mixed'
) {
return null;
}
2019-02-24 07:33:25 +01:00
$gap = substr($file_contents, $end_pos, $offset - $end_pos);
return [$recent_type, $gap];
}
private static function getPositionFromOffset(int $offset, string $file_contents) : Position
{
$file_contents = substr($file_contents, 0, $offset);
return new Position(
substr_count($file_contents, "\n"),
$offset - (int)strrpos($file_contents, "\n", strlen($file_contents))
);
}
/**
* @return void
*/
public function addTemporaryFileChanges(string $file_path, string $new_content)
{
$this->file_provider->addTemporaryFileChanges($file_path, $new_content);
}
2018-11-02 02:52:39 +01:00
/**
* @return void
*/
public function removeTemporaryFileChanges(string $file_path)
{
$this->file_provider->removeTemporaryFileChanges($file_path);
}
2019-02-18 21:54:23 +01:00
/**
* Checks if type is a subtype of other
*
* Given two types, checks if `$input_type` is a subtype of `$container_type`.
* If you consider `Type\Union` as a set of types, this will tell you
* if `$input_type` is fully contained in `$container_type`,
*
* $input_type $container_type
*
* Useful for emitting issues like InvalidArgument, where argument at the call site
* should be a subset of the function parameter type.
2019-02-18 21:54:23 +01:00
*/
public function isTypeContainedByType(
Type\Union $input_type,
Type\Union $container_type
): bool {
return TypeAnalyzer::isContainedBy($this, $input_type, $container_type);
}
/**
* Checks if type has any part that is a subtype of other
*
* Given two types, checks if *any part* of `$input_type` is a subtype of `$container_type`.
* If you consider `Type\Union` as a set of types, this will tell you if intersection
* of `$input_type` with `$container_type` is not empty.
*
2019-02-20 17:06:51 +01:00
* $input_type $container_type , e.g. they are not disjoint.
*
* Useful for emitting issues like PossiblyInvalidArgument, where argument at the call
* site should be a subtype of the function parameter type, but it's has some types that are
* not a subtype of the required type.
*/
public function canTypeBeContainedByType(
Type\Union $input_type,
Type\Union $container_type
): bool {
return TypeAnalyzer::canBeContainedBy($this, $input_type, $container_type);
}
/**
* Extracts key and value types from a traversable object (or iterable)
*
* Given an iterable type (*but not TArray*) returns a tuple of it's key/value types.
* First element of the tuple holds key type, second has the value type.
*
* Example:
* ```php
* $codebase->getKeyValueParamsForTraversableObject(Type::parseString('iterable<int,string>'))
* // returns [Union(TInt), Union(TString)]
* ```
*
* @return array{Type\Union,Type\Union}
*/
public function getKeyValueParamsForTraversableObject(Type\Atomic $type): array
{
$key_type = null;
$value_type = null;
ForeachAnalyzer::getKeyValueParamsForTraversableObject($type, $this, $key_type, $value_type);
return [
$key_type ?? Type::getMixed(),
$value_type ?? Type::getMixed(),
];
}
}