1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-14 02:07:37 +01:00
psalm/src/Psalm/Checker/ClassChecker.php

188 lines
5.2 KiB
PHP
Raw Normal View History

<?php
namespace Psalm\Checker;
use PhpParser;
use Psalm\StatementsSource;
class ClassChecker extends ClassLikeChecker
{
2016-10-10 07:35:12 +02:00
/**
* @var PhpParser\Node\Stmt\Class_
*/
protected $class;
2016-10-31 20:42:20 +01:00
/**
* @var integer
*/
2016-10-21 02:54:17 +02:00
protected static $anonymous_class_count = 0;
2016-09-09 15:13:41 +02:00
/**
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Stmt\ClassLike $class
* @param StatementsSource $source
* @param string|null $fq_class_name
2016-09-09 15:13:41 +02:00
*/
public function __construct(PhpParser\Node\Stmt\ClassLike $class, StatementsSource $source, $fq_class_name)
{
2016-10-23 07:57:11 +02:00
if (!$class instanceof PhpParser\Node\Stmt\Class_) {
throw new \InvalidArgumentException('Bad');
}
if ($fq_class_name === null) {
$fq_class_name = 'PsalmAnonymousClass' . (self::$anonymous_class_count++);
2016-10-21 02:54:17 +02:00
}
parent::__construct($class, $source, $fq_class_name);
$storage = self::$storage[$fq_class_name];
self::$existing_classes[$fq_class_name] = true;
self::$existing_classes_ci[strtolower($fq_class_name)] = true;
self::$class_extends[$this->fq_class_name] = [];
if ($this->class->extends) {
2016-11-08 01:16:51 +01:00
$this->parent_class = self::getFQCLNFromNameObject(
2016-11-02 07:29:00 +01:00
$this->class->extends,
$this->namespace,
$this->aliased_classes
);
}
foreach ($class->implements as $interface_name) {
2016-11-08 01:16:51 +01:00
$fq_interface_name = self::getFQCLNFromNameObject(
2016-11-02 07:29:00 +01:00
$interface_name,
$this->namespace,
$this->aliased_classes
);
$storage->class_implements[strtolower($fq_interface_name)] = $fq_interface_name;
}
}
2016-09-09 15:13:41 +02:00
/**
* Determine whether or not a given class exists
*
* @param string $fq_class_name
2016-09-09 15:13:41 +02:00
* @return bool
*/
public static function classExists($fq_class_name)
{
if (isset(self::$existing_classes_ci[strtolower($fq_class_name)])) {
return self::$existing_classes_ci[strtolower($fq_class_name)];
}
if (in_array($fq_class_name, self::$SPECIAL_TYPES)) {
return false;
}
if (parent::registerClassLike($fq_class_name) === false) {
self::$existing_classes[$fq_class_name] = false;
return false;
}
if (!isset(self::$existing_classes_ci[strtolower($fq_class_name)])) {
// it exists, but it's not a class
self::$existing_classes_ci[strtolower($fq_class_name)] = false;
return false;
}
return true;
}
2016-09-09 15:13:41 +02:00
/**
* Determine whether or not a class has the correct casing
*
* @param string $fq_class_name
2016-09-09 15:13:41 +02:00
* @return bool
*/
public static function hasCorrectCasing($fq_class_name)
{
if (!self::classExists($fq_class_name)) {
throw new \InvalidArgumentException('Cannot check casing on nonexistent class ' . $fq_class_name);
}
return isset(self::$existing_classes[$fq_class_name]);
}
/**
2016-09-09 15:13:41 +02:00
* Determine whether or not a class extends a parent
*
* @param string $fq_class_name
* @param string $possible_parent
* @return bool
*/
public static function classExtends($fq_class_name, $possible_parent)
{
if (isset(self::$class_extends[$fq_class_name][$possible_parent])) {
return self::$class_extends[$fq_class_name][$possible_parent];
}
if (!self::classExists($fq_class_name) || !self::classExists($possible_parent)) {
return false;
}
if (!isset(self::$class_extends[$fq_class_name])) {
self::$class_extends[$fq_class_name] = [];
}
2016-12-31 02:05:32 +01:00
$old_level = error_reporting();
error_reporting(0);
self::$class_extends[$fq_class_name][$possible_parent] = is_subclass_of($fq_class_name, $possible_parent);
2016-12-31 02:05:32 +01:00
error_reporting($old_level);
return self::$class_extends[$fq_class_name][$possible_parent];
}
2016-09-09 15:13:41 +02:00
/**
* Get all the interfaces a given class implements
*
* @param string $fq_class_name
2016-09-09 15:13:41 +02:00
* @return array<string>
*/
public static function getInterfacesForClass($fq_class_name)
{
self::registerClassLike($fq_class_name);
return self::$storage[$fq_class_name]->class_implements;
}
/**
2016-09-09 15:13:41 +02:00
* Check whether a class implements an interface
*
* @param string $fq_class_name
2016-09-09 15:13:41 +02:00
* @param string $interface
* @return bool
*/
public static function classImplements($fq_class_name, $interface)
{
$interface_id = strtolower($interface);
if ($interface_id === 'callable' && $fq_class_name === 'Closure') {
2016-10-21 00:05:28 +02:00
return true;
}
if (in_array($interface_id, self::$SPECIAL_TYPES) || in_array($fq_class_name, self::$SPECIAL_TYPES)) {
return false;
}
if (self::registerClassLike($fq_class_name) === false) {
return false;
}
$storage = self::$storage[$fq_class_name];
return isset($storage->class_implements[$interface_id]);
}
2016-08-15 17:01:50 +02:00
2016-11-02 07:29:00 +01:00
/**
* @return void
*/
2016-08-15 17:01:50 +02:00
public static function clearCache()
{
2016-10-21 02:54:17 +02:00
self::$anonymous_class_count = 0;
MethodChecker::clearCache();
2016-08-15 17:01:50 +02:00
}
}