1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-12 17:27:28 +01:00
psalm/src/Psalm/Internal/Analyzer/NamespaceAnalyzer.php
LeSuisse f29826b958 Fully qualify constants and function calls (#1849)
This should give a small performance boost.
Part of #1837.

The change is enforced via phpcs and can be autofixed
with phpcbf.
2019-06-26 16:52:29 -04:00

215 lines
6.5 KiB
PHP

<?php
namespace Psalm\Internal\Analyzer;
use PhpParser;
use PhpParser\Node\Stmt\Namespace_;
use Psalm\Context;
use Psalm\StatementsSource;
use Psalm\Type;
use function implode;
use function array_merge;
use function strtolower;
use function trim;
use function strpos;
use function preg_replace;
/**
* @internal
*/
class NamespaceAnalyzer extends SourceAnalyzer implements StatementsSource
{
use CanAlias;
/**
* @var FileAnalyzer
*/
protected $source;
/**
* @var Namespace_
*/
private $namespace;
/**
* @var string
*/
private $namespace_name;
/**
* A lookup table for public namespace constants
*
* @var array<string, array<string, Type\Union>>
*/
protected static $public_namespace_constants = [];
/**
* @param Namespace_ $namespace
* @param FileAnalyzer $source
*/
public function __construct(Namespace_ $namespace, FileAnalyzer $source)
{
$this->source = $source;
$this->namespace = $namespace;
$this->namespace_name = $this->namespace->name ? implode('\\', $this->namespace->name->parts) : '';
}
/**
* @return void
*/
public function collectAnalyzableInformation()
{
$leftover_stmts = [];
if (!isset(self::$public_namespace_constants[$this->namespace_name])) {
self::$public_namespace_constants[$this->namespace_name] = [];
}
$codebase = $this->getCodebase();
$namespace_context = new Context();
$namespace_context->collect_references = $codebase->collect_references;
foreach ($this->namespace->stmts as $stmt) {
if ($stmt instanceof PhpParser\Node\Stmt\ClassLike) {
$this->collectAnalyzableClassLike($stmt);
} elseif ($stmt instanceof PhpParser\Node\Stmt\Use_) {
$this->visitUse($stmt);
} elseif ($stmt instanceof PhpParser\Node\Stmt\GroupUse) {
$this->visitGroupUse($stmt);
} elseif ($stmt instanceof PhpParser\Node\Stmt\Const_) {
foreach ($stmt->consts as $const) {
self::$public_namespace_constants[$this->namespace_name][$const->name->name] = Type::getMixed();
}
$leftover_stmts[] = $stmt;
} else {
$leftover_stmts[] = $stmt;
}
}
$codebase->analyzer->addNodeAliases(
$this->getFilePath(),
$this->namespace,
array_merge(
[$this->namespace_name => $this->namespace_name],
$this->getAliasedClassesFlipped()
)
);
if ($leftover_stmts) {
$statements_analyzer = new StatementsAnalyzer($this);
$context = new Context();
$context->collect_references = $codebase->collect_references;
$context->is_global = true;
$context->defineGlobals();
$context->collect_exceptions = $codebase->config->check_for_throws_in_global_scope;
$statements_analyzer->analyze($leftover_stmts, $context);
$file_context = $this->source->context;
if ($file_context) {
$file_context->mergeExceptions($context);
}
}
}
/**
* @param PhpParser\Node\Stmt\ClassLike $stmt
*
* @return void
*/
public function collectAnalyzableClassLike(PhpParser\Node\Stmt\ClassLike $stmt)
{
if (!$stmt->name) {
throw new \UnexpectedValueException('Did not expect anonymous class here');
}
$fq_class_name = Type::getFQCLNFromString($stmt->name->name, $this->getAliases());
if ($stmt instanceof PhpParser\Node\Stmt\Class_) {
$this->source->addNamespacedClassAnalyzer(
$fq_class_name,
new ClassAnalyzer($stmt, $this, $fq_class_name)
);
} elseif ($stmt instanceof PhpParser\Node\Stmt\Interface_) {
$this->source->addNamespacedInterfaceAnalyzer(
$fq_class_name,
new InterfaceAnalyzer($stmt, $this, $fq_class_name)
);
}
}
/**
* @return string
*/
public function getNamespace()
{
return $this->namespace_name;
}
/**
* @param string $const_name
* @param Type\Union $const_type
*
* @return void
*/
public function setConstType($const_name, Type\Union $const_type)
{
self::$public_namespace_constants[$this->namespace_name][$const_name] = $const_type;
}
/**
* @param string $namespace_name
* @param mixed $visibility
*
* @return array<string,Type\Union>
*/
public static function getConstantsForNamespace($namespace_name, $visibility)
{
// @todo this does not allow for loading in namespace constants not already defined in the current sweep
if (!isset(self::$public_namespace_constants[$namespace_name])) {
self::$public_namespace_constants[$namespace_name] = [];
}
if ($visibility === \ReflectionProperty::IS_PUBLIC) {
return self::$public_namespace_constants[$namespace_name];
}
throw new \InvalidArgumentException('Given $visibility not supported');
}
public function getFileAnalyzer() : FileAnalyzer
{
return $this->source;
}
/**
* @param string $namespace Generally a namespace, but may also be a fully qualified class name (FQCN)_.
* @param string $className Generally a FQCN, but may be a FQCN
*
* Returns true if $className is the same as, or starts with $namespace, in a case-insensitive comparision.
*
* @return bool
*/
public static function isWithin(string $className, string $namespace): bool
{
$className = strtolower(trim($className, '\\') . '\\');
$namespace = strtolower(trim($namespace, '\\') . '\\');
return $className === $namespace || strpos($className, $namespace) === 0;
}
public static function nameSpaceRootsMatch(string $fqcnA, string $fqcnB): bool
{
return strtolower(self::getNameSpaceRoot($fqcnA)) === strtolower(self::getNameSpaceRoot($fqcnB));
}
/**
* @param string $fullyQualifiedClassName, e.g. '\Psalm\Internal\Analyzer\NamespaceAnalyzer'
* @return string , e.g. 'Psalm'
*/
private static function getNameSpaceRoot(string $fullyQualifiedClassName): string
{
return preg_replace('/^([^\\\]+).*/', '$1', $fullyQualifiedClassName);
}
}