2018-02-04 00:52:35 +01:00
|
|
|
<?php
|
2018-11-12 16:46:55 +01:00
|
|
|
namespace Psalm\Internal\Codebase;
|
2018-02-04 00:52:35 +01:00
|
|
|
|
|
|
|
use PhpParser;
|
|
|
|
use Psalm\Aliases;
|
2019-03-16 23:03:37 +01:00
|
|
|
use Psalm\Exception\UnpopulatedClasslikeException;
|
2018-11-06 03:57:36 +01:00
|
|
|
use Psalm\Internal\Analyzer\ClassLikeAnalyzer;
|
2018-02-04 00:52:35 +01:00
|
|
|
use Psalm\CodeLocation;
|
|
|
|
use Psalm\Config;
|
2019-04-17 17:12:18 +02:00
|
|
|
use Psalm\Internal\FileManipulation\FileManipulationBuffer;
|
2018-02-04 00:52:35 +01:00
|
|
|
use Psalm\Issue\PossiblyUnusedMethod;
|
|
|
|
use Psalm\Issue\PossiblyUnusedParam;
|
|
|
|
use Psalm\Issue\PossiblyUnusedProperty;
|
|
|
|
use Psalm\Issue\UnusedClass;
|
|
|
|
use Psalm\Issue\UnusedMethod;
|
|
|
|
use Psalm\Issue\UnusedProperty;
|
|
|
|
use Psalm\IssueBuffer;
|
2018-11-06 03:57:36 +01:00
|
|
|
use Psalm\Internal\Provider\ClassLikeStorageProvider;
|
2019-04-13 00:28:07 +02:00
|
|
|
use Psalm\Internal\Provider\FileReferenceProvider;
|
2019-05-30 16:30:41 +02:00
|
|
|
use Psalm\Progress\Progress;
|
|
|
|
use Psalm\Progress\VoidProgress;
|
2018-02-04 00:52:35 +01:00
|
|
|
use Psalm\Storage\ClassLikeStorage;
|
2018-02-09 00:14:28 +01:00
|
|
|
use Psalm\Type;
|
|
|
|
use ReflectionProperty;
|
2018-02-04 00:52:35 +01:00
|
|
|
|
2018-02-09 23:51:49 +01:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Handles information about classes, interfaces and traits
|
|
|
|
*/
|
2018-02-04 00:52:35 +01:00
|
|
|
class ClassLikes
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* @var ClassLikeStorageProvider
|
|
|
|
*/
|
|
|
|
private $classlike_storage_provider;
|
|
|
|
|
2019-04-13 00:28:07 +02:00
|
|
|
/**
|
|
|
|
* @var FileReferenceProvider
|
|
|
|
*/
|
|
|
|
public $file_reference_provider;
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $existing_classlikes_lc = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $existing_classes_lc = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $existing_classes = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $existing_interfaces_lc = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $existing_interfaces = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $existing_traits_lc = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $existing_traits = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, PhpParser\Node\Stmt\Trait_>
|
|
|
|
*/
|
|
|
|
private $trait_nodes = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, Aliases>
|
|
|
|
*/
|
|
|
|
private $trait_aliases = [];
|
|
|
|
|
2018-11-29 06:05:56 +01:00
|
|
|
/**
|
|
|
|
* @var array<string, string>
|
|
|
|
*/
|
|
|
|
private $classlike_aliases = [];
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
/**
|
|
|
|
* @var bool
|
|
|
|
*/
|
|
|
|
public $collect_references = false;
|
|
|
|
|
2019-04-13 00:28:07 +02:00
|
|
|
/**
|
|
|
|
* @var bool
|
|
|
|
*/
|
|
|
|
public $collect_locations = false;
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
/**
|
|
|
|
* @var Config
|
|
|
|
*/
|
|
|
|
private $config;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var Scanner
|
|
|
|
*/
|
|
|
|
private $scanner;
|
|
|
|
|
|
|
|
public function __construct(
|
|
|
|
Config $config,
|
|
|
|
ClassLikeStorageProvider $storage_provider,
|
2019-04-13 00:28:07 +02:00
|
|
|
FileReferenceProvider $file_reference_provider,
|
2018-12-21 17:32:44 +01:00
|
|
|
Scanner $scanner
|
2018-02-04 00:52:35 +01:00
|
|
|
) {
|
|
|
|
$this->config = $config;
|
|
|
|
$this->classlike_storage_provider = $storage_provider;
|
2019-04-13 00:28:07 +02:00
|
|
|
$this->file_reference_provider = $file_reference_provider;
|
2018-02-04 00:52:35 +01:00
|
|
|
$this->scanner = $scanner;
|
|
|
|
|
|
|
|
$this->collectPredefinedClassLikes();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
private function collectPredefinedClassLikes()
|
|
|
|
{
|
|
|
|
/** @var array<int, string> */
|
|
|
|
$predefined_classes = get_declared_classes();
|
|
|
|
|
|
|
|
foreach ($predefined_classes as $predefined_class) {
|
2018-11-09 18:59:17 +01:00
|
|
|
$predefined_class = preg_replace('/^\\\/', '', $predefined_class);
|
2019-02-11 03:13:06 +01:00
|
|
|
/** @psalm-suppress TypeCoercion */
|
2018-02-04 00:52:35 +01:00
|
|
|
$reflection_class = new \ReflectionClass($predefined_class);
|
|
|
|
|
|
|
|
if (!$reflection_class->isUserDefined()) {
|
|
|
|
$predefined_class_lc = strtolower($predefined_class);
|
|
|
|
$this->existing_classlikes_lc[$predefined_class_lc] = true;
|
|
|
|
$this->existing_classes_lc[$predefined_class_lc] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @var array<int, string> */
|
|
|
|
$predefined_interfaces = get_declared_interfaces();
|
|
|
|
|
|
|
|
foreach ($predefined_interfaces as $predefined_interface) {
|
2018-11-09 18:59:17 +01:00
|
|
|
$predefined_interface = preg_replace('/^\\\/', '', $predefined_interface);
|
2019-02-11 03:13:06 +01:00
|
|
|
/** @psalm-suppress TypeCoercion */
|
2018-02-04 00:52:35 +01:00
|
|
|
$reflection_class = new \ReflectionClass($predefined_interface);
|
|
|
|
|
|
|
|
if (!$reflection_class->isUserDefined()) {
|
|
|
|
$predefined_interface_lc = strtolower($predefined_interface);
|
|
|
|
$this->existing_classlikes_lc[$predefined_interface_lc] = true;
|
|
|
|
$this->existing_interfaces_lc[$predefined_interface_lc] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param string|null $file_path
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addFullyQualifiedClassName($fq_class_name, $file_path = null)
|
|
|
|
{
|
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
|
|
|
$this->existing_classlikes_lc[$fq_class_name_lc] = true;
|
|
|
|
$this->existing_classes_lc[$fq_class_name_lc] = true;
|
|
|
|
$this->existing_traits_lc[$fq_class_name_lc] = false;
|
|
|
|
$this->existing_interfaces_lc[$fq_class_name_lc] = false;
|
|
|
|
$this->existing_classes[$fq_class_name] = true;
|
|
|
|
|
|
|
|
if ($file_path) {
|
|
|
|
$this->scanner->setClassLikeFilePath($fq_class_name_lc, $file_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param string|null $file_path
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addFullyQualifiedInterfaceName($fq_class_name, $file_path = null)
|
|
|
|
{
|
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
|
|
|
$this->existing_classlikes_lc[$fq_class_name_lc] = true;
|
|
|
|
$this->existing_interfaces_lc[$fq_class_name_lc] = true;
|
|
|
|
$this->existing_classes_lc[$fq_class_name_lc] = false;
|
|
|
|
$this->existing_traits_lc[$fq_class_name_lc] = false;
|
|
|
|
$this->existing_interfaces[$fq_class_name] = true;
|
|
|
|
|
|
|
|
if ($file_path) {
|
|
|
|
$this->scanner->setClassLikeFilePath($fq_class_name_lc, $file_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param string|null $file_path
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addFullyQualifiedTraitName($fq_class_name, $file_path = null)
|
|
|
|
{
|
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
|
|
|
$this->existing_classlikes_lc[$fq_class_name_lc] = true;
|
|
|
|
$this->existing_traits_lc[$fq_class_name_lc] = true;
|
|
|
|
$this->existing_classes_lc[$fq_class_name_lc] = false;
|
|
|
|
$this->existing_interfaces_lc[$fq_class_name_lc] = false;
|
|
|
|
$this->existing_traits[$fq_class_name] = true;
|
|
|
|
|
|
|
|
if ($file_path) {
|
|
|
|
$this->scanner->setClassLikeFilePath($fq_class_name_lc, $file_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name_lc
|
|
|
|
* @param string|null $file_path
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addFullyQualifiedClassLikeName($fq_class_name_lc, $file_path = null)
|
|
|
|
{
|
|
|
|
$this->existing_classlikes_lc[$fq_class_name_lc] = true;
|
|
|
|
|
|
|
|
if ($file_path) {
|
|
|
|
$this->scanner->setClassLikeFilePath($fq_class_name_lc, $file_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-18 15:51:28 +02:00
|
|
|
/**
|
|
|
|
* @param string $fq_class_name_lc
|
|
|
|
*
|
2018-10-18 15:57:13 +02:00
|
|
|
* @return bool
|
2018-10-18 15:51:28 +02:00
|
|
|
*/
|
|
|
|
public function hasFullyQualifiedClassLikeName($fq_class_name_lc)
|
|
|
|
{
|
|
|
|
return isset($this->existing_classlikes_lc[$fq_class_name_lc]);
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
2019-04-13 21:38:09 +02:00
|
|
|
public function hasFullyQualifiedClassName($fq_class_name, CodeLocation $code_location = null)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
|
|
|
|
2018-11-29 06:05:56 +01:00
|
|
|
if (isset($this->classlike_aliases[$fq_class_name_lc])) {
|
|
|
|
$fq_class_name_lc = strtolower($this->classlike_aliases[$fq_class_name_lc]);
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
if (!isset($this->existing_classes_lc[$fq_class_name_lc])
|
|
|
|
|| !$this->existing_classes_lc[$fq_class_name_lc]
|
|
|
|
|| !$this->classlike_storage_provider->has($fq_class_name_lc)
|
|
|
|
) {
|
|
|
|
if ((
|
|
|
|
!isset($this->existing_classes_lc[$fq_class_name_lc])
|
|
|
|
|| $this->existing_classes_lc[$fq_class_name_lc] === true
|
|
|
|
)
|
|
|
|
&& !$this->classlike_storage_provider->has($fq_class_name_lc)
|
|
|
|
) {
|
|
|
|
if (!isset($this->existing_classes_lc[$fq_class_name_lc])) {
|
|
|
|
$this->existing_classes_lc[$fq_class_name_lc] = false;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this->existing_classes_lc[$fq_class_name_lc];
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-04-13 21:38:09 +02:00
|
|
|
if ($this->collect_references && $code_location) {
|
|
|
|
$this->file_reference_provider->addFileReferenceToClass(
|
|
|
|
$code_location->file_path,
|
|
|
|
$fq_class_name_lc
|
|
|
|
);
|
|
|
|
}
|
2018-02-04 00:52:35 +01:00
|
|
|
|
2019-04-13 21:38:09 +02:00
|
|
|
if ($this->collect_locations && $code_location) {
|
|
|
|
$this->file_reference_provider->addCallingLocationForClass(
|
|
|
|
$code_location,
|
|
|
|
strtolower($fq_class_name)
|
|
|
|
);
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
2019-04-13 21:38:09 +02:00
|
|
|
public function hasFullyQualifiedInterfaceName($fq_class_name, CodeLocation $code_location = null)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
|
|
|
|
2018-11-29 06:05:56 +01:00
|
|
|
if (isset($this->classlike_aliases[$fq_class_name_lc])) {
|
2018-12-21 15:29:23 +01:00
|
|
|
$fq_class_name_lc = strtolower($this->classlike_aliases[$fq_class_name_lc]);
|
2018-11-29 06:05:56 +01:00
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
if (!isset($this->existing_interfaces_lc[$fq_class_name_lc])
|
|
|
|
|| !$this->existing_interfaces_lc[$fq_class_name_lc]
|
|
|
|
|| !$this->classlike_storage_provider->has($fq_class_name_lc)
|
|
|
|
) {
|
|
|
|
if ((
|
|
|
|
!isset($this->existing_classes_lc[$fq_class_name_lc])
|
|
|
|
|| $this->existing_classes_lc[$fq_class_name_lc] === true
|
|
|
|
)
|
|
|
|
&& !$this->classlike_storage_provider->has($fq_class_name_lc)
|
|
|
|
) {
|
|
|
|
if (!isset($this->existing_interfaces_lc[$fq_class_name_lc])) {
|
|
|
|
$this->existing_interfaces_lc[$fq_class_name_lc] = false;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this->existing_interfaces_lc[$fq_class_name_lc];
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-04-13 21:38:09 +02:00
|
|
|
if ($this->collect_references && $code_location) {
|
|
|
|
$this->file_reference_provider->addFileReferenceToClass(
|
|
|
|
$code_location->file_path,
|
|
|
|
$fq_class_name_lc
|
|
|
|
);
|
|
|
|
}
|
2018-02-04 00:52:35 +01:00
|
|
|
|
2019-04-13 21:38:09 +02:00
|
|
|
if ($this->collect_locations && $code_location) {
|
|
|
|
$this->file_reference_provider->addCallingLocationForClass(
|
|
|
|
$code_location,
|
|
|
|
strtolower($fq_class_name)
|
|
|
|
);
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
2019-04-13 21:38:09 +02:00
|
|
|
public function hasFullyQualifiedTraitName($fq_class_name, CodeLocation $code_location = null)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
|
|
|
|
2018-11-29 06:05:56 +01:00
|
|
|
if (isset($this->classlike_aliases[$fq_class_name_lc])) {
|
2018-12-21 15:29:23 +01:00
|
|
|
$fq_class_name_lc = strtolower($this->classlike_aliases[$fq_class_name_lc]);
|
2018-11-29 06:05:56 +01:00
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
if (!isset($this->existing_traits_lc[$fq_class_name_lc]) ||
|
|
|
|
!$this->existing_traits_lc[$fq_class_name_lc]
|
|
|
|
) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-04-13 21:38:09 +02:00
|
|
|
if ($this->collect_references && $code_location) {
|
|
|
|
$this->file_reference_provider->addFileReferenceToClass(
|
|
|
|
$code_location->file_path,
|
|
|
|
$fq_class_name_lc
|
|
|
|
);
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check whether a class/interface exists
|
|
|
|
*
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param CodeLocation $code_location
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function classOrInterfaceExists(
|
|
|
|
$fq_class_name,
|
|
|
|
CodeLocation $code_location = null
|
|
|
|
) {
|
2019-04-13 21:38:09 +02:00
|
|
|
if (!$this->classExists($fq_class_name, $code_location)
|
|
|
|
&& !$this->interfaceExists($fq_class_name, $code_location)
|
|
|
|
) {
|
2018-02-04 00:52:35 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine whether or not a given class exists
|
|
|
|
*
|
|
|
|
* @param string $fq_class_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
2019-04-13 21:38:09 +02:00
|
|
|
public function classExists($fq_class_name, CodeLocation $code_location = null)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
2019-01-05 22:23:18 +01:00
|
|
|
if (isset(ClassLikeAnalyzer::SPECIAL_TYPES[$fq_class_name])) {
|
2018-02-04 00:52:35 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($fq_class_name === 'Generator') {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-04-13 21:38:09 +02:00
|
|
|
return $this->hasFullyQualifiedClassName($fq_class_name, $code_location);
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine whether or not a class extends a parent
|
|
|
|
*
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param string $possible_parent
|
|
|
|
*
|
|
|
|
* @return bool
|
2019-03-16 23:03:37 +01:00
|
|
|
* @throws UnpopulatedClasslikeException when called on unpopulated class
|
|
|
|
* @throws \InvalidArgumentException when class does not exist
|
2018-02-04 00:52:35 +01:00
|
|
|
*/
|
2019-03-17 22:11:04 +01:00
|
|
|
public function classExtends($fq_class_name, $possible_parent, bool $from_api = false)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
2019-03-16 23:03:37 +01:00
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
2018-02-04 00:52:35 +01:00
|
|
|
|
2019-03-16 23:03:37 +01:00
|
|
|
if ($fq_class_name_lc === 'generator') {
|
2018-02-04 00:52:35 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-03-16 23:03:37 +01:00
|
|
|
$fq_class_name_lc = $this->classlike_aliases[$fq_class_name_lc] ?? $fq_class_name_lc;
|
|
|
|
|
|
|
|
$class_storage = $this->classlike_storage_provider->get($fq_class_name_lc);
|
2018-11-29 06:05:56 +01:00
|
|
|
|
2019-03-17 22:11:04 +01:00
|
|
|
if ($from_api && !$class_storage->populated) {
|
2019-03-16 23:03:37 +01:00
|
|
|
throw new UnpopulatedClasslikeException($fq_class_name);
|
|
|
|
}
|
2018-02-04 00:52:35 +01:00
|
|
|
|
|
|
|
return isset($class_storage->parent_classes[strtolower($possible_parent)]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check whether a class implements an interface
|
|
|
|
*
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param string $interface
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function classImplements($fq_class_name, $interface)
|
|
|
|
{
|
|
|
|
$interface_id = strtolower($interface);
|
|
|
|
|
|
|
|
$fq_class_name = strtolower($fq_class_name);
|
|
|
|
|
|
|
|
if ($interface_id === 'callable' && $fq_class_name === 'closure') {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($interface_id === 'traversable' && $fq_class_name === 'generator') {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-01-26 22:58:49 +01:00
|
|
|
if ($interface_id === 'traversable' && $fq_class_name === 'iterator') {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-01-05 22:23:18 +01:00
|
|
|
if (isset(ClassLikeAnalyzer::SPECIAL_TYPES[$interface_id])
|
|
|
|
|| isset(ClassLikeAnalyzer::SPECIAL_TYPES[$fq_class_name])
|
2018-02-04 00:52:35 +01:00
|
|
|
) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-11-29 06:05:56 +01:00
|
|
|
if (isset($this->classlike_aliases[$fq_class_name])) {
|
|
|
|
$fq_class_name = $this->classlike_aliases[$fq_class_name];
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
$class_storage = $this->classlike_storage_provider->get($fq_class_name);
|
|
|
|
|
|
|
|
return isset($class_storage->class_implements[$interface_id]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_interface_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
2019-04-13 21:38:09 +02:00
|
|
|
public function interfaceExists($fq_interface_name, CodeLocation $code_location = null)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
2019-01-05 22:23:18 +01:00
|
|
|
if (isset(ClassLikeAnalyzer::SPECIAL_TYPES[strtolower($fq_interface_name)])) {
|
2018-02-04 00:52:35 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-04-13 21:38:09 +02:00
|
|
|
return $this->hasFullyQualifiedInterfaceName($fq_interface_name, $code_location);
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $interface_name
|
|
|
|
* @param string $possible_parent
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function interfaceExtends($interface_name, $possible_parent)
|
|
|
|
{
|
2018-07-22 02:38:55 +02:00
|
|
|
return isset($this->getParentInterfaces($interface_name)[strtolower($possible_parent)]);
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_interface_name
|
|
|
|
*
|
2018-07-22 02:38:55 +02:00
|
|
|
* @return array<string, string> all interfaces extended by $interface_name
|
2018-02-04 00:52:35 +01:00
|
|
|
*/
|
|
|
|
public function getParentInterfaces($fq_interface_name)
|
|
|
|
{
|
|
|
|
$fq_interface_name = strtolower($fq_interface_name);
|
|
|
|
|
|
|
|
$storage = $this->classlike_storage_provider->get($fq_interface_name);
|
|
|
|
|
|
|
|
return $storage->parent_interfaces;
|
|
|
|
}
|
|
|
|
|
2018-05-09 04:32:57 +02:00
|
|
|
/**
|
|
|
|
* @param string $fq_trait_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
2019-04-13 21:38:09 +02:00
|
|
|
public function traitExists($fq_trait_name, CodeLocation $code_location = null)
|
2018-05-09 04:32:57 +02:00
|
|
|
{
|
2019-04-13 21:38:09 +02:00
|
|
|
return $this->hasFullyQualifiedTraitName($fq_trait_name, $code_location);
|
2018-05-09 04:32:57 +02:00
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
if ($fq_class_name === 'Generator') {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-11-29 06:05:56 +01:00
|
|
|
if (isset($this->classlike_aliases[strtolower($fq_class_name)])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
return isset($this->existing_classes[$fq_class_name]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_interface_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function interfaceHasCorrectCasing($fq_interface_name)
|
|
|
|
{
|
2018-11-29 06:05:56 +01:00
|
|
|
if (isset($this->classlike_aliases[strtolower($fq_interface_name)])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-12-21 15:29:23 +01:00
|
|
|
if (isset($this->classlike_aliases[strtolower($fq_interface_name)])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
return isset($this->existing_interfaces[$fq_interface_name]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_trait_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function traitHasCorrectCase($fq_trait_name)
|
|
|
|
{
|
2018-11-29 06:05:56 +01:00
|
|
|
if (isset($this->classlike_aliases[strtolower($fq_trait_name)])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
return isset($this->existing_traits[$fq_trait_name]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function isUserDefined($fq_class_name)
|
|
|
|
{
|
|
|
|
return $this->classlike_storage_provider->get($fq_class_name)->user_defined;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_trait_name
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addTraitNode($fq_trait_name, PhpParser\Node\Stmt\Trait_ $node, Aliases $aliases)
|
|
|
|
{
|
|
|
|
$fq_trait_name_lc = strtolower($fq_trait_name);
|
|
|
|
$this->trait_nodes[$fq_trait_name_lc] = $node;
|
|
|
|
$this->trait_aliases[$fq_trait_name_lc] = $aliases;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_trait_name
|
|
|
|
*
|
|
|
|
* @return PhpParser\Node\Stmt\Trait_
|
|
|
|
*/
|
|
|
|
public function getTraitNode($fq_trait_name)
|
|
|
|
{
|
|
|
|
$fq_trait_name_lc = strtolower($fq_trait_name);
|
|
|
|
|
|
|
|
if (isset($this->trait_nodes[$fq_trait_name_lc])) {
|
|
|
|
return $this->trait_nodes[$fq_trait_name_lc];
|
|
|
|
}
|
|
|
|
|
|
|
|
throw new \UnexpectedValueException(
|
|
|
|
'Expecting trait statements to exist for ' . $fq_trait_name
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_trait_name
|
|
|
|
*
|
|
|
|
* @return Aliases
|
|
|
|
*/
|
|
|
|
public function getTraitAliases($fq_trait_name)
|
|
|
|
{
|
|
|
|
$fq_trait_name_lc = strtolower($fq_trait_name);
|
|
|
|
|
|
|
|
if (isset($this->trait_aliases[$fq_trait_name_lc])) {
|
|
|
|
return $this->trait_aliases[$fq_trait_name_lc];
|
|
|
|
}
|
|
|
|
|
|
|
|
throw new \UnexpectedValueException(
|
|
|
|
'Expecting trait aliases to exist for ' . $fq_trait_name
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2018-11-29 06:05:56 +01:00
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addClassAlias(string $fq_class_name, string $alias_name)
|
|
|
|
{
|
|
|
|
$this->classlike_aliases[strtolower($alias_name)] = $fq_class_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getUnAliasedName(string $alias_name)
|
|
|
|
{
|
|
|
|
return $this->classlike_aliases[strtolower($alias_name)] ?? $alias_name;
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
2019-05-30 16:30:41 +02:00
|
|
|
public function checkClassReferences(Methods $methods, Progress $progress = null)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
2019-05-30 16:30:41 +02:00
|
|
|
if ($progress === null) {
|
|
|
|
$progress = new VoidProgress();
|
2019-04-17 19:15:06 +02:00
|
|
|
}
|
|
|
|
|
2019-05-30 16:30:41 +02:00
|
|
|
$progress->debug('Checking class references' . PHP_EOL);
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
foreach ($this->existing_classlikes_lc as $fq_class_name_lc => $_) {
|
|
|
|
try {
|
|
|
|
$classlike_storage = $this->classlike_storage_provider->get($fq_class_name_lc);
|
|
|
|
} catch (\InvalidArgumentException $e) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-06-10 05:10:42 +02:00
|
|
|
if ($classlike_storage->location
|
|
|
|
&& $this->config->isInProjectDirs($classlike_storage->location->file_path)
|
|
|
|
&& !$classlike_storage->is_trait
|
2018-02-04 00:52:35 +01:00
|
|
|
) {
|
2019-04-13 21:38:09 +02:00
|
|
|
if (!$this->file_reference_provider->isClassReferenced($fq_class_name_lc)) {
|
2018-02-04 00:52:35 +01:00
|
|
|
if (IssueBuffer::accepts(
|
|
|
|
new UnusedClass(
|
|
|
|
'Class ' . $classlike_storage->name . ' is never used',
|
2019-02-18 15:07:38 +01:00
|
|
|
$classlike_storage->location,
|
|
|
|
$classlike_storage->name
|
|
|
|
),
|
|
|
|
$classlike_storage->suppressed_issues
|
2018-02-04 00:52:35 +01:00
|
|
|
)) {
|
|
|
|
// fall through
|
|
|
|
}
|
|
|
|
} else {
|
2018-12-21 17:32:44 +01:00
|
|
|
$this->checkMethodReferences($classlike_storage, $methods);
|
2019-04-17 22:41:35 +02:00
|
|
|
$this->checkPropertyReferences($classlike_storage);
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-01 06:56:54 +02:00
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function refactorMethods(Methods $methods, Progress $progress = null)
|
|
|
|
{
|
|
|
|
if ($progress === null) {
|
|
|
|
$progress = new VoidProgress();
|
|
|
|
}
|
|
|
|
|
|
|
|
$project_analyzer = \Psalm\Internal\Analyzer\ProjectAnalyzer::getInstance();
|
|
|
|
$codebase = $project_analyzer->getCodebase();
|
|
|
|
|
|
|
|
if (!$codebase->method_migrations) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
$progress->debug('Refacting methods ' . PHP_EOL);
|
|
|
|
|
|
|
|
$code_migrations = [];
|
|
|
|
|
|
|
|
foreach ($codebase->method_migrations as $original => $eventual) {
|
|
|
|
try {
|
|
|
|
$original_method_storage = $methods->getStorage($original);
|
|
|
|
} catch (\InvalidArgumentException $e) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
list($eventual_fq_class_name, $eventual_name) = explode('::', $eventual);
|
|
|
|
|
|
|
|
try {
|
|
|
|
$classlike_storage = $this->classlike_storage_provider->get($eventual_fq_class_name);
|
|
|
|
} catch (\InvalidArgumentException $e) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($classlike_storage->stmt_location
|
|
|
|
&& $this->config->isInProjectDirs($classlike_storage->stmt_location->file_path)
|
|
|
|
&& $original_method_storage->stmt_location
|
|
|
|
&& $original_method_storage->stmt_location->file_path
|
|
|
|
&& $original_method_storage->location
|
|
|
|
) {
|
|
|
|
$new_class_bounds = $classlike_storage->stmt_location->getSnippetBounds();
|
|
|
|
$old_method_bounds = $original_method_storage->stmt_location->getSnippetBounds();
|
|
|
|
|
|
|
|
$old_method_name_bounds = $original_method_storage->location->getSelectionBounds();
|
|
|
|
|
|
|
|
FileManipulationBuffer::add(
|
|
|
|
$original_method_storage->stmt_location->file_path,
|
|
|
|
[
|
|
|
|
new \Psalm\FileManipulation(
|
|
|
|
$old_method_name_bounds[0],
|
|
|
|
$old_method_name_bounds[1],
|
|
|
|
$eventual_name
|
|
|
|
)
|
|
|
|
]
|
|
|
|
);
|
|
|
|
|
|
|
|
$selection = $classlike_storage->stmt_location->getSnippet();
|
|
|
|
|
|
|
|
$insert_pos = strrpos($selection, "\n", -1);
|
|
|
|
|
|
|
|
if (!$insert_pos) {
|
|
|
|
$insert_pos = strlen($selection) - 1;
|
|
|
|
} else {
|
|
|
|
$insert_pos++;
|
|
|
|
}
|
|
|
|
|
|
|
|
$code_migrations[] = new \Psalm\Internal\FileManipulation\CodeMigration(
|
|
|
|
$original_method_storage->stmt_location->file_path,
|
|
|
|
$old_method_bounds[0],
|
|
|
|
$old_method_bounds[1],
|
|
|
|
$classlike_storage->stmt_location->file_path,
|
|
|
|
$new_class_bounds[0] + $insert_pos
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
FileManipulationBuffer::addCodeMigrations($code_migrations);
|
|
|
|
}
|
|
|
|
|
2018-02-09 00:18:34 +01:00
|
|
|
/**
|
|
|
|
* @param string $class_name
|
|
|
|
* @param mixed $visibility
|
|
|
|
*
|
|
|
|
* @return array<string,Type\Union>
|
|
|
|
*/
|
|
|
|
public function getConstantsForClass($class_name, $visibility)
|
|
|
|
{
|
|
|
|
$class_name = strtolower($class_name);
|
|
|
|
|
|
|
|
$storage = $this->classlike_storage_provider->get($class_name);
|
|
|
|
|
|
|
|
if ($visibility === ReflectionProperty::IS_PUBLIC) {
|
|
|
|
return $storage->public_class_constants;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($visibility === ReflectionProperty::IS_PROTECTED) {
|
|
|
|
return array_merge(
|
|
|
|
$storage->public_class_constants,
|
|
|
|
$storage->protected_class_constants
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($visibility === ReflectionProperty::IS_PRIVATE) {
|
|
|
|
return array_merge(
|
|
|
|
$storage->public_class_constants,
|
|
|
|
$storage->protected_class_constants,
|
|
|
|
$storage->private_class_constants
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
throw new \InvalidArgumentException('Must specify $visibility');
|
|
|
|
}
|
|
|
|
|
2018-02-09 00:14:28 +01:00
|
|
|
/**
|
|
|
|
* @param string $class_name
|
|
|
|
* @param string $const_name
|
|
|
|
* @param Type\Union $type
|
|
|
|
* @param int $visibility
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function setConstantType(
|
|
|
|
$class_name,
|
|
|
|
$const_name,
|
|
|
|
Type\Union $type,
|
|
|
|
$visibility
|
|
|
|
) {
|
|
|
|
$storage = $this->classlike_storage_provider->get($class_name);
|
|
|
|
|
|
|
|
if ($visibility === ReflectionProperty::IS_PUBLIC) {
|
|
|
|
$storage->public_class_constants[$const_name] = $type;
|
|
|
|
} elseif ($visibility === ReflectionProperty::IS_PROTECTED) {
|
|
|
|
$storage->protected_class_constants[$const_name] = $type;
|
|
|
|
} elseif ($visibility === ReflectionProperty::IS_PRIVATE) {
|
|
|
|
$storage->private_class_constants[$const_name] = $type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
2018-12-21 17:32:44 +01:00
|
|
|
private function checkMethodReferences(ClassLikeStorage $classlike_storage, Methods $methods)
|
2018-02-04 00:52:35 +01:00
|
|
|
{
|
2019-04-17 17:12:18 +02:00
|
|
|
$project_analyzer = \Psalm\Internal\Analyzer\ProjectAnalyzer::getInstance();
|
|
|
|
$codebase = $project_analyzer->getCodebase();
|
|
|
|
|
2018-06-10 05:10:42 +02:00
|
|
|
foreach ($classlike_storage->appearing_method_ids as $method_name => $appearing_method_id) {
|
|
|
|
list($appearing_fq_classlike_name) = explode('::', $appearing_method_id);
|
|
|
|
|
|
|
|
if ($appearing_fq_classlike_name !== $classlike_storage->name) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-04-13 00:28:07 +02:00
|
|
|
$method_id = $appearing_method_id;
|
|
|
|
|
2019-04-17 21:12:52 +02:00
|
|
|
$declaring_classlike_storage = $classlike_storage;
|
|
|
|
|
2018-06-10 05:10:42 +02:00
|
|
|
if (isset($classlike_storage->methods[$method_name])) {
|
|
|
|
$method_storage = $classlike_storage->methods[$method_name];
|
|
|
|
} else {
|
|
|
|
$declaring_method_id = $classlike_storage->declaring_method_ids[$method_name];
|
|
|
|
|
2019-03-01 19:33:23 +01:00
|
|
|
list($declaring_fq_classlike_name, $declaring_method_name) = explode('::', $declaring_method_id);
|
2018-06-10 05:10:42 +02:00
|
|
|
|
|
|
|
try {
|
|
|
|
$declaring_classlike_storage = $this->classlike_storage_provider->get($declaring_fq_classlike_name);
|
|
|
|
} catch (\InvalidArgumentException $e) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-03-01 19:33:23 +01:00
|
|
|
$method_storage = $declaring_classlike_storage->methods[$declaring_method_name];
|
2019-04-13 00:28:07 +02:00
|
|
|
$method_id = $declaring_method_id;
|
2018-06-10 05:10:42 +02:00
|
|
|
}
|
|
|
|
|
2019-04-13 00:28:07 +02:00
|
|
|
$method_referenced = $this->file_reference_provider->isClassMethodReferenced(strtolower($method_id));
|
|
|
|
|
|
|
|
if (!$method_referenced
|
2018-02-04 00:52:35 +01:00
|
|
|
&& (substr($method_name, 0, 2) !== '__' || $method_name === '__construct')
|
|
|
|
&& $method_storage->location
|
|
|
|
) {
|
2018-04-07 00:28:22 +02:00
|
|
|
$method_location = $method_storage->location;
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
$method_id = $classlike_storage->name . '::' . $method_storage->cased_name;
|
|
|
|
|
2018-12-13 23:20:29 +01:00
|
|
|
if ($method_storage->visibility !== ClassLikeAnalyzer::VISIBILITY_PRIVATE) {
|
2018-02-04 00:52:35 +01:00
|
|
|
$method_name_lc = strtolower($method_name);
|
|
|
|
|
|
|
|
$has_parent_references = false;
|
|
|
|
|
2019-04-22 19:18:19 +02:00
|
|
|
$has_variable_calls = $codebase->analyzer->hasMixedMemberName(strtolower($method_name))
|
|
|
|
|| $codebase->analyzer->hasMixedMemberName(strtolower($classlike_storage->name . '::'));
|
|
|
|
|
2018-06-10 05:10:42 +02:00
|
|
|
if (isset($classlike_storage->overridden_method_ids[$method_name_lc])) {
|
|
|
|
foreach ($classlike_storage->overridden_method_ids[$method_name_lc] as $parent_method_id) {
|
2018-12-21 17:32:44 +01:00
|
|
|
$parent_method_storage = $methods->getStorage($parent_method_id);
|
2018-02-04 00:52:35 +01:00
|
|
|
|
2019-04-13 00:28:07 +02:00
|
|
|
$parent_method_referenced = $this->file_reference_provider->isClassMethodReferenced(
|
|
|
|
strtolower($parent_method_id)
|
|
|
|
);
|
|
|
|
|
|
|
|
if (!$parent_method_storage->abstract || $parent_method_referenced) {
|
2018-06-10 05:10:42 +02:00
|
|
|
$has_parent_references = true;
|
|
|
|
}
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-22 19:18:19 +02:00
|
|
|
foreach ($classlike_storage->parent_classes as $parent_method_fqcln) {
|
|
|
|
if ($codebase->analyzer->hasMixedMemberName(
|
|
|
|
strtolower($parent_method_fqcln) . '::'
|
|
|
|
)) {
|
|
|
|
$has_variable_calls = true;
|
|
|
|
}
|
|
|
|
}
|
2019-04-19 17:45:08 +02:00
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
foreach ($classlike_storage->class_implements as $fq_interface_name) {
|
2019-05-11 00:07:13 +02:00
|
|
|
try {
|
|
|
|
$interface_storage = $this->classlike_storage_provider->get($fq_interface_name);
|
|
|
|
} catch (\InvalidArgumentException $e) {
|
|
|
|
continue;
|
|
|
|
}
|
2019-04-19 17:45:08 +02:00
|
|
|
|
2019-04-22 19:18:19 +02:00
|
|
|
if ($codebase->analyzer->hasMixedMemberName(
|
2019-04-19 17:45:08 +02:00
|
|
|
strtolower($fq_interface_name) . '::'
|
|
|
|
)) {
|
|
|
|
$has_variable_calls = true;
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
if (isset($interface_storage->methods[$method_name])) {
|
2019-04-13 00:28:07 +02:00
|
|
|
$interface_method_referenced = $this->file_reference_provider->isClassMethodReferenced(
|
|
|
|
strtolower($fq_interface_name . '::' . $method_name)
|
|
|
|
);
|
2018-02-04 00:52:35 +01:00
|
|
|
|
2019-04-13 00:28:07 +02:00
|
|
|
if ($interface_method_referenced) {
|
2018-02-04 00:52:35 +01:00
|
|
|
$has_parent_references = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$has_parent_references) {
|
2019-04-17 17:12:18 +02:00
|
|
|
$issue = new PossiblyUnusedMethod(
|
2019-04-19 17:45:08 +02:00
|
|
|
'Cannot find ' . ($has_variable_calls ? 'explicit' : 'any')
|
|
|
|
. ' calls to method ' . $method_id
|
|
|
|
. ($has_variable_calls ? ' (but did find some potential callers)' : ''),
|
2019-04-17 17:12:18 +02:00
|
|
|
$method_storage->location,
|
|
|
|
$method_id
|
|
|
|
);
|
|
|
|
|
|
|
|
if ($codebase->alter_code) {
|
|
|
|
if ($method_storage->stmt_location
|
2019-04-17 21:12:52 +02:00
|
|
|
&& !$declaring_classlike_storage->is_trait
|
2019-04-17 17:12:18 +02:00
|
|
|
&& isset($project_analyzer->getIssuesToFix()['PossiblyUnusedMethod'])
|
2019-04-19 17:45:08 +02:00
|
|
|
&& !$has_variable_calls
|
2019-04-17 17:12:18 +02:00
|
|
|
&& !IssueBuffer::isSuppressed($issue, $method_storage->suppressed_issues)
|
|
|
|
) {
|
|
|
|
FileManipulationBuffer::addForCodeLocation(
|
|
|
|
$method_storage->stmt_location,
|
2019-04-17 19:56:47 +02:00
|
|
|
'',
|
|
|
|
true
|
2019-04-17 17:12:18 +02:00
|
|
|
);
|
|
|
|
}
|
|
|
|
} elseif (IssueBuffer::accepts(
|
|
|
|
$issue,
|
2018-02-04 00:52:35 +01:00
|
|
|
$method_storage->suppressed_issues
|
|
|
|
)) {
|
|
|
|
// fall through
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} elseif (!isset($classlike_storage->declaring_method_ids['__call'])) {
|
2019-04-19 18:03:52 +02:00
|
|
|
$has_variable_calls = $codebase->analyzer->hasMixedMemberName(
|
|
|
|
strtolower($classlike_storage->name . '::')
|
2019-04-22 19:18:19 +02:00
|
|
|
) || $codebase->analyzer->hasMixedMemberName(strtolower($method_name));
|
2019-04-19 17:45:08 +02:00
|
|
|
|
2019-04-17 17:12:18 +02:00
|
|
|
$issue = new UnusedMethod(
|
2019-04-19 17:45:08 +02:00
|
|
|
'Cannot find ' . ($has_variable_calls ? 'explicit' : 'any')
|
|
|
|
. ' calls to private method ' . $method_id
|
|
|
|
. ($has_variable_calls ? ' (but did find some potential callers)' : ''),
|
2019-04-17 17:12:18 +02:00
|
|
|
$method_location,
|
|
|
|
$method_id
|
|
|
|
);
|
|
|
|
|
|
|
|
if ($codebase->alter_code) {
|
|
|
|
if ($method_storage->stmt_location
|
2019-04-17 21:12:52 +02:00
|
|
|
&& !$declaring_classlike_storage->is_trait
|
2019-04-17 17:12:18 +02:00
|
|
|
&& isset($project_analyzer->getIssuesToFix()['UnusedMethod'])
|
2019-04-22 19:18:19 +02:00
|
|
|
&& !$has_variable_calls
|
2019-04-17 17:12:18 +02:00
|
|
|
&& !IssueBuffer::isSuppressed($issue, $method_storage->suppressed_issues)
|
|
|
|
) {
|
|
|
|
FileManipulationBuffer::addForCodeLocation(
|
|
|
|
$method_storage->stmt_location,
|
2019-04-17 19:56:47 +02:00
|
|
|
'',
|
|
|
|
true
|
2019-04-17 17:12:18 +02:00
|
|
|
);
|
|
|
|
}
|
|
|
|
} elseif (IssueBuffer::accepts(
|
|
|
|
$issue,
|
2018-07-12 18:12:28 +02:00
|
|
|
$method_storage->suppressed_issues
|
2018-02-04 00:52:35 +01:00
|
|
|
)) {
|
|
|
|
// fall through
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2019-05-31 07:47:35 +02:00
|
|
|
if ($codebase->alter_code
|
|
|
|
&& isset($project_analyzer->getIssuesToFix()['MissingParamType'])
|
2019-05-31 17:55:24 +02:00
|
|
|
&& isset($codebase->analyzer->possible_method_param_types[strtolower($method_id)])
|
2019-05-31 07:47:35 +02:00
|
|
|
) {
|
2019-05-31 17:55:24 +02:00
|
|
|
if ($method_storage->location) {
|
2019-05-31 07:49:54 +02:00
|
|
|
$function_analyzer = $project_analyzer->getFunctionLikeAnalyzer(
|
|
|
|
$method_id,
|
|
|
|
$method_storage->location->file_path
|
|
|
|
);
|
|
|
|
|
2019-05-31 17:55:24 +02:00
|
|
|
$possible_param_types
|
|
|
|
= $codebase->analyzer->possible_method_param_types[strtolower($method_id)];
|
2019-05-31 07:47:35 +02:00
|
|
|
|
2019-05-31 17:55:24 +02:00
|
|
|
if ($function_analyzer && $possible_param_types) {
|
|
|
|
foreach ($possible_param_types as $offset => $possible_type) {
|
|
|
|
if (!isset($method_storage->params[$offset])) {
|
|
|
|
continue;
|
|
|
|
}
|
2019-05-31 07:47:35 +02:00
|
|
|
|
2019-05-31 17:55:24 +02:00
|
|
|
$param_name = $method_storage->params[$offset]->name;
|
2019-05-31 07:47:35 +02:00
|
|
|
|
2019-05-31 17:55:24 +02:00
|
|
|
if ($possible_type->hasMixed() || $possible_type->isNull()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($method_storage->params[$offset]->default_type) {
|
|
|
|
$possible_type = \Psalm\Type::combineUnionTypes(
|
|
|
|
$possible_type,
|
|
|
|
$method_storage->params[$offset]->default_type
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
$function_analyzer->addOrUpdateParamType(
|
|
|
|
$project_analyzer,
|
|
|
|
$param_name,
|
|
|
|
$possible_type,
|
|
|
|
true
|
|
|
|
);
|
|
|
|
}
|
2019-05-31 07:47:35 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-04 00:52:35 +01:00
|
|
|
foreach ($method_storage->unused_params as $offset => $code_location) {
|
|
|
|
$has_parent_references = false;
|
|
|
|
|
|
|
|
$method_name_lc = strtolower($method_name);
|
|
|
|
|
2018-06-10 05:10:42 +02:00
|
|
|
if (isset($classlike_storage->overridden_method_ids[$method_name_lc])) {
|
|
|
|
foreach ($classlike_storage->overridden_method_ids[$method_name_lc] as $parent_method_id) {
|
2018-12-21 17:32:44 +01:00
|
|
|
$parent_method_storage = $methods->getStorage($parent_method_id);
|
2018-02-04 00:52:35 +01:00
|
|
|
|
2018-06-10 05:10:42 +02:00
|
|
|
if (!$parent_method_storage->abstract
|
|
|
|
&& isset($parent_method_storage->used_params[$offset])
|
|
|
|
) {
|
|
|
|
$has_parent_references = true;
|
|
|
|
break;
|
|
|
|
}
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-29 23:29:38 +02:00
|
|
|
if (!$has_parent_references
|
|
|
|
&& !$this->file_reference_provider->isMethodParamUsed(strtolower($method_id), $offset)
|
|
|
|
) {
|
2018-02-04 00:52:35 +01:00
|
|
|
if (IssueBuffer::accepts(
|
|
|
|
new PossiblyUnusedParam(
|
2019-05-13 22:01:41 +02:00
|
|
|
'Param #' . ($offset + 1) . ' is never referenced in this method',
|
2018-02-04 00:52:35 +01:00
|
|
|
$code_location
|
|
|
|
),
|
|
|
|
$method_storage->suppressed_issues
|
|
|
|
)) {
|
|
|
|
// fall through
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-04-17 22:41:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
private function checkPropertyReferences(ClassLikeStorage $classlike_storage)
|
|
|
|
{
|
|
|
|
$project_analyzer = \Psalm\Internal\Analyzer\ProjectAnalyzer::getInstance();
|
|
|
|
$codebase = $project_analyzer->getCodebase();
|
2018-02-04 00:52:35 +01:00
|
|
|
|
|
|
|
foreach ($classlike_storage->properties as $property_name => $property_storage) {
|
2019-04-13 00:28:07 +02:00
|
|
|
$property_referenced = $this->file_reference_provider->isClassPropertyReferenced(
|
|
|
|
strtolower($classlike_storage->name) . '::$' . $property_name
|
|
|
|
);
|
2019-04-16 22:07:48 +02:00
|
|
|
|
2019-04-13 00:28:07 +02:00
|
|
|
if (!$property_referenced
|
2018-02-04 00:52:35 +01:00
|
|
|
&& (substr($property_name, 0, 2) !== '__' || $property_name === '__construct')
|
|
|
|
&& $property_storage->location
|
|
|
|
) {
|
|
|
|
$property_id = $classlike_storage->name . '::$' . $property_name;
|
|
|
|
|
2019-04-19 17:45:08 +02:00
|
|
|
if ($property_storage->visibility === ClassLikeAnalyzer::VISIBILITY_PUBLIC
|
|
|
|
|| $property_storage->visibility === ClassLikeAnalyzer::VISIBILITY_PROTECTED
|
|
|
|
) {
|
2019-04-17 22:41:35 +02:00
|
|
|
$has_parent_references = isset($classlike_storage->overridden_property_ids[$property_name]);
|
2019-04-17 17:12:18 +02:00
|
|
|
|
2019-04-19 17:45:08 +02:00
|
|
|
$has_variable_calls = $codebase->analyzer->hasMixedMemberName('$' . $property_name)
|
|
|
|
|| $codebase->analyzer->hasMixedMemberName(strtolower($classlike_storage->name) . '::$');
|
|
|
|
|
2019-04-22 19:18:19 +02:00
|
|
|
foreach ($classlike_storage->parent_classes as $parent_method_fqcln) {
|
|
|
|
if ($codebase->analyzer->hasMixedMemberName(
|
|
|
|
strtolower($parent_method_fqcln) . '::$'
|
|
|
|
)) {
|
|
|
|
$has_variable_calls = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-19 17:45:08 +02:00
|
|
|
foreach ($classlike_storage->class_implements as $fq_interface_name) {
|
2019-04-22 19:18:19 +02:00
|
|
|
if ($codebase->analyzer->hasMixedMemberName(
|
2019-04-19 17:45:08 +02:00
|
|
|
strtolower($fq_interface_name) . '::$'
|
|
|
|
)) {
|
|
|
|
$has_variable_calls = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$has_parent_references
|
|
|
|
&& ($property_storage->visibility === ClassLikeAnalyzer::VISIBILITY_PUBLIC
|
|
|
|
|| !isset($classlike_storage->declaring_method_ids['__get']))
|
|
|
|
) {
|
2019-04-17 22:41:35 +02:00
|
|
|
$issue = new PossiblyUnusedProperty(
|
2019-04-19 17:45:08 +02:00
|
|
|
'Cannot find ' . ($has_variable_calls ? 'explicit' : 'any')
|
|
|
|
. ' references to property ' . $property_id
|
|
|
|
. ($has_variable_calls ? ' (but did find some potential references)' : ''),
|
2019-04-17 22:41:35 +02:00
|
|
|
$property_storage->location
|
|
|
|
);
|
|
|
|
|
|
|
|
if ($codebase->alter_code) {
|
|
|
|
if ($property_storage->stmt_location
|
|
|
|
&& isset($project_analyzer->getIssuesToFix()['PossiblyUnusedProperty'])
|
2019-04-19 17:45:08 +02:00
|
|
|
&& !$has_variable_calls
|
2019-04-17 22:41:35 +02:00
|
|
|
&& !IssueBuffer::isSuppressed($issue, $classlike_storage->suppressed_issues)
|
|
|
|
) {
|
|
|
|
FileManipulationBuffer::addForCodeLocation(
|
|
|
|
$property_storage->stmt_location,
|
|
|
|
'',
|
|
|
|
true
|
|
|
|
);
|
|
|
|
}
|
|
|
|
} elseif (IssueBuffer::accepts(
|
|
|
|
$issue,
|
|
|
|
$classlike_storage->suppressed_issues
|
|
|
|
)) {
|
|
|
|
// fall through
|
2019-04-17 17:12:18 +02:00
|
|
|
}
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|
2019-04-19 17:45:08 +02:00
|
|
|
} elseif (!isset($classlike_storage->declaring_method_ids['__get'])) {
|
|
|
|
$has_variable_calls = $codebase->analyzer->hasMixedMemberName('$' . $property_name);
|
|
|
|
|
2019-04-17 17:12:18 +02:00
|
|
|
$issue = new UnusedProperty(
|
2019-04-19 17:45:08 +02:00
|
|
|
'Cannot find ' . ($has_variable_calls ? 'explicit' : 'any')
|
|
|
|
. ' references to private property ' . $property_id
|
|
|
|
. ($has_variable_calls ? ' (but did find some potential references)' : ''),
|
2019-04-17 17:12:18 +02:00
|
|
|
$property_storage->location
|
|
|
|
);
|
|
|
|
|
|
|
|
if ($codebase->alter_code) {
|
|
|
|
if ($property_storage->stmt_location
|
|
|
|
&& isset($project_analyzer->getIssuesToFix()['UnusedProperty'])
|
2019-04-19 17:45:08 +02:00
|
|
|
&& !$has_variable_calls
|
2019-04-17 17:12:18 +02:00
|
|
|
&& !IssueBuffer::isSuppressed($issue, $classlike_storage->suppressed_issues)
|
|
|
|
) {
|
|
|
|
FileManipulationBuffer::addForCodeLocation(
|
|
|
|
$property_storage->stmt_location,
|
2019-04-17 19:56:47 +02:00
|
|
|
'',
|
|
|
|
true
|
2019-04-17 17:12:18 +02:00
|
|
|
);
|
|
|
|
}
|
|
|
|
} elseif (IssueBuffer::accepts(
|
|
|
|
$issue,
|
|
|
|
$classlike_storage->suppressed_issues
|
2018-02-04 00:52:35 +01:00
|
|
|
)) {
|
|
|
|
// fall through
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_classlike_name_lc
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function registerMissingClassLike($fq_classlike_name_lc)
|
|
|
|
{
|
|
|
|
$this->existing_classlikes_lc[$fq_classlike_name_lc] = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_classlike_name_lc
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function isMissingClassLike($fq_classlike_name_lc)
|
|
|
|
{
|
|
|
|
return isset($this->existing_classlikes_lc[$fq_classlike_name_lc])
|
|
|
|
&& $this->existing_classlikes_lc[$fq_classlike_name_lc] === false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_classlike_name_lc
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function doesClassLikeExist($fq_classlike_name_lc)
|
|
|
|
{
|
|
|
|
return isset($this->existing_classlikes_lc[$fq_classlike_name_lc])
|
|
|
|
&& $this->existing_classlikes_lc[$fq_classlike_name_lc];
|
|
|
|
}
|
2018-09-28 22:18:45 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function removeClassLike($fq_class_name)
|
|
|
|
{
|
|
|
|
$fq_class_name_lc = strtolower($fq_class_name);
|
|
|
|
unset(
|
|
|
|
$this->existing_classlikes_lc[$fq_class_name_lc],
|
|
|
|
$this->existing_classes_lc[$fq_class_name_lc],
|
|
|
|
$this->existing_traits_lc[$fq_class_name_lc],
|
2018-10-12 05:00:32 +02:00
|
|
|
$this->existing_traits[$fq_class_name],
|
2018-09-28 22:18:45 +02:00
|
|
|
$this->existing_interfaces_lc[$fq_class_name_lc],
|
2018-10-12 05:00:32 +02:00
|
|
|
$this->existing_interfaces[$fq_class_name],
|
2018-09-28 22:18:45 +02:00
|
|
|
$this->existing_classes[$fq_class_name],
|
|
|
|
$this->trait_nodes[$fq_class_name_lc],
|
2019-04-13 21:38:09 +02:00
|
|
|
$this->trait_aliases[$fq_class_name_lc]
|
2018-09-28 22:18:45 +02:00
|
|
|
);
|
2018-10-12 05:00:32 +02:00
|
|
|
|
|
|
|
$this->scanner->removeClassLike($fq_class_name_lc);
|
2018-09-28 22:18:45 +02:00
|
|
|
}
|
2018-10-11 19:58:39 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return array{
|
|
|
|
* 0: array<string, bool>,
|
|
|
|
* 1: array<string, bool>,
|
|
|
|
* 2: array<string, bool>,
|
|
|
|
* 3: array<string, bool>,
|
|
|
|
* 4: array<string, bool>,
|
|
|
|
* 5: array<string, bool>,
|
|
|
|
* 6: array<string, bool>,
|
|
|
|
* 7: array<string, \PhpParser\Node\Stmt\Trait_>,
|
2019-04-13 21:38:09 +02:00
|
|
|
* 8: array<string, \Psalm\Aliases>
|
2018-10-11 19:58:39 +02:00
|
|
|
* }
|
|
|
|
*/
|
|
|
|
public function getThreadData()
|
|
|
|
{
|
|
|
|
return [
|
|
|
|
$this->existing_classlikes_lc,
|
|
|
|
$this->existing_classes_lc,
|
|
|
|
$this->existing_traits_lc,
|
|
|
|
$this->existing_traits,
|
|
|
|
$this->existing_interfaces_lc,
|
|
|
|
$this->existing_interfaces,
|
|
|
|
$this->existing_classes,
|
|
|
|
$this->trait_nodes,
|
|
|
|
$this->trait_aliases,
|
|
|
|
];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param array{
|
|
|
|
* 0: array<string, bool>,
|
|
|
|
* 1: array<string, bool>,
|
|
|
|
* 2: array<string, bool>,
|
|
|
|
* 3: array<string, bool>,
|
|
|
|
* 4: array<string, bool>,
|
|
|
|
* 5: array<string, bool>,
|
|
|
|
* 6: array<string, bool>,
|
|
|
|
* 7: array<string, \PhpParser\Node\Stmt\Trait_>,
|
2019-04-13 21:38:09 +02:00
|
|
|
* 8: array<string, \Psalm\Aliases>
|
2018-10-11 19:58:39 +02:00
|
|
|
* } $thread_data
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addThreadData(array $thread_data)
|
|
|
|
{
|
|
|
|
list (
|
|
|
|
$existing_classlikes_lc,
|
|
|
|
$existing_classes_lc,
|
|
|
|
$existing_traits_lc,
|
|
|
|
$existing_traits,
|
|
|
|
$existing_interfaces_lc,
|
|
|
|
$existing_interfaces,
|
|
|
|
$existing_classes,
|
|
|
|
$trait_nodes,
|
|
|
|
$trait_aliases,
|
|
|
|
) = $thread_data;
|
|
|
|
|
|
|
|
$this->existing_classlikes_lc = array_merge($existing_classlikes_lc, $this->existing_classlikes_lc);
|
|
|
|
$this->existing_classes_lc = array_merge($existing_classes_lc, $this->existing_classes_lc);
|
|
|
|
$this->existing_traits_lc = array_merge($existing_traits_lc, $this->existing_traits_lc);
|
|
|
|
$this->existing_traits = array_merge($existing_traits, $this->existing_traits);
|
|
|
|
$this->existing_interfaces_lc = array_merge($existing_interfaces_lc, $this->existing_interfaces_lc);
|
|
|
|
$this->existing_interfaces = array_merge($existing_interfaces, $this->existing_interfaces);
|
|
|
|
$this->existing_classes = array_merge($existing_classes, $this->existing_classes);
|
|
|
|
$this->trait_nodes = array_merge($trait_nodes, $this->trait_nodes);
|
|
|
|
$this->trait_aliases = array_merge($trait_aliases, $this->trait_aliases);
|
|
|
|
}
|
2018-02-04 00:52:35 +01:00
|
|
|
}
|