mirror of
https://github.com/danog/psalm.git
synced 2024-12-11 00:39:38 +01:00
346 lines
11 KiB
PHP
346 lines
11 KiB
PHP
<?php
|
|
|
|
namespace Psalm\Internal\Analyzer;
|
|
|
|
use LogicException;
|
|
use PhpParser;
|
|
use Psalm\CodeLocation;
|
|
use Psalm\Codebase;
|
|
use Psalm\Context;
|
|
use Psalm\Internal\Codebase\InternalCallMapHandler;
|
|
use Psalm\Internal\MethodIdentifier;
|
|
use Psalm\Issue\InvalidEnumMethod;
|
|
use Psalm\Issue\InvalidStaticInvocation;
|
|
use Psalm\Issue\MethodSignatureMustOmitReturnType;
|
|
use Psalm\Issue\NonStaticSelfCall;
|
|
use Psalm\Issue\UndefinedMethod;
|
|
use Psalm\IssueBuffer;
|
|
use Psalm\StatementsSource;
|
|
use Psalm\Storage\ClassLikeStorage;
|
|
use Psalm\Storage\MethodStorage;
|
|
use UnexpectedValueException;
|
|
|
|
use function in_array;
|
|
use function strtolower;
|
|
|
|
/**
|
|
* @internal
|
|
* @extends FunctionLikeAnalyzer<PhpParser\Node\Stmt\ClassMethod>
|
|
*/
|
|
final class MethodAnalyzer extends FunctionLikeAnalyzer
|
|
{
|
|
// https://github.com/php/php-src/blob/a83923044c48982c80804ae1b45e761c271966d3/Zend/zend_enum.c#L77-L95
|
|
private const FORBIDDEN_ENUM_METHODS = [
|
|
'__construct',
|
|
'__destruct',
|
|
'__clone',
|
|
'__get',
|
|
'__set',
|
|
'__unset',
|
|
'__isset',
|
|
'__tostring',
|
|
'__debuginfo',
|
|
'__serialize',
|
|
'__unserialize',
|
|
'__sleep',
|
|
'__wakeup',
|
|
'__set_state',
|
|
];
|
|
|
|
/** @psalm-external-mutation-free */
|
|
public function __construct(
|
|
PhpParser\Node\Stmt\ClassMethod $function,
|
|
SourceAnalyzer $source,
|
|
?MethodStorage $storage = null
|
|
) {
|
|
$codebase = $source->getCodebase();
|
|
|
|
$method_name_lc = strtolower((string) $function->name);
|
|
|
|
$source_fqcln = (string) $source->getFQCLN();
|
|
|
|
$source_fqcln_lc = strtolower($source_fqcln);
|
|
|
|
$method_id = new MethodIdentifier($source_fqcln, $method_name_lc);
|
|
|
|
if (!$storage) {
|
|
try {
|
|
$storage = $codebase->methods->getStorage($method_id);
|
|
} catch (UnexpectedValueException $e) {
|
|
$class_storage = $codebase->classlike_storage_provider->get($source_fqcln_lc);
|
|
|
|
if (!$class_storage->parent_classes) {
|
|
throw $e;
|
|
}
|
|
|
|
$declaring_method_id = $codebase->methods->getDeclaringMethodId($method_id);
|
|
|
|
if (!$declaring_method_id) {
|
|
throw $e;
|
|
}
|
|
|
|
// happens for fake constructors
|
|
$storage = $codebase->methods->getStorage($declaring_method_id);
|
|
}
|
|
}
|
|
|
|
parent::__construct($function, $source, $storage);
|
|
}
|
|
|
|
/**
|
|
* Determines whether a given method is static or not
|
|
*
|
|
* @param array<string> $suppressed_issues
|
|
*/
|
|
public static function checkStatic(
|
|
MethodIdentifier $method_id,
|
|
bool $self_call,
|
|
bool $is_context_dynamic,
|
|
Codebase $codebase,
|
|
CodeLocation $code_location,
|
|
array $suppressed_issues,
|
|
?bool &$is_dynamic_this_method = false
|
|
): void {
|
|
$codebase_methods = $codebase->methods;
|
|
|
|
if ($method_id->fq_class_name === 'Closure'
|
|
&& $method_id->method_name === 'fromcallable'
|
|
) {
|
|
return;
|
|
}
|
|
|
|
$original_method_id = $method_id;
|
|
|
|
$method_id = $codebase_methods->getDeclaringMethodId($method_id);
|
|
|
|
if (!$method_id) {
|
|
if (InternalCallMapHandler::inCallMap((string) $original_method_id)) {
|
|
return;
|
|
}
|
|
|
|
throw new LogicException('Declaring method for ' . $original_method_id . ' should not be null');
|
|
}
|
|
|
|
$storage = $codebase_methods->getStorage($method_id);
|
|
|
|
if (!$storage->is_static) {
|
|
if ($self_call) {
|
|
if (!$is_context_dynamic) {
|
|
if (IssueBuffer::accepts(
|
|
new NonStaticSelfCall(
|
|
'Method ' . $codebase_methods->getCasedMethodId($method_id) .
|
|
' is not static, but is called ' .
|
|
'using self::',
|
|
$code_location,
|
|
),
|
|
$suppressed_issues,
|
|
)) {
|
|
return;
|
|
}
|
|
} else {
|
|
$is_dynamic_this_method = true;
|
|
}
|
|
} else {
|
|
if (IssueBuffer::accepts(
|
|
new InvalidStaticInvocation(
|
|
'Method ' . $codebase_methods->getCasedMethodId($method_id) .
|
|
' is not static, but is called ' .
|
|
'statically',
|
|
$code_location,
|
|
),
|
|
$suppressed_issues,
|
|
)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param string[] $suppressed_issues
|
|
* @param lowercase-string|null $calling_method_id
|
|
*/
|
|
public static function checkMethodExists(
|
|
Codebase $codebase,
|
|
MethodIdentifier $method_id,
|
|
CodeLocation $code_location,
|
|
array $suppressed_issues,
|
|
?string $calling_method_id = null
|
|
): ?bool {
|
|
if ($codebase->methods->methodExists(
|
|
$method_id,
|
|
$calling_method_id,
|
|
!$calling_method_id
|
|
|| $calling_method_id !== strtolower((string) $method_id)
|
|
? $code_location
|
|
: null,
|
|
null,
|
|
$code_location->file_path,
|
|
)) {
|
|
return true;
|
|
}
|
|
|
|
if (IssueBuffer::accepts(
|
|
new UndefinedMethod('Method ' . $method_id . ' does not exist', $code_location, (string) $method_id),
|
|
$suppressed_issues,
|
|
)) {
|
|
return false;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static function isMethodVisible(
|
|
MethodIdentifier $method_id,
|
|
Context $context,
|
|
StatementsSource $source
|
|
): bool {
|
|
$codebase = $source->getCodebase();
|
|
|
|
$fq_classlike_name = $method_id->fq_class_name;
|
|
$method_name = $method_id->method_name;
|
|
|
|
if ($codebase->methods->visibility_provider->has($fq_classlike_name)) {
|
|
$method_visible = $codebase->methods->visibility_provider->isMethodVisible(
|
|
$source,
|
|
$fq_classlike_name,
|
|
$method_name,
|
|
$context,
|
|
null,
|
|
);
|
|
|
|
if ($method_visible !== null) {
|
|
return $method_visible;
|
|
}
|
|
}
|
|
|
|
$declaring_method_id = $codebase->methods->getDeclaringMethodId($method_id);
|
|
|
|
if (!$declaring_method_id) {
|
|
// this can happen for methods in the callmap that were not reflected
|
|
return true;
|
|
}
|
|
|
|
$appearing_method_id = $codebase->methods->getAppearingMethodId($method_id);
|
|
|
|
$appearing_method_class = null;
|
|
|
|
if ($appearing_method_id) {
|
|
$appearing_method_class = $appearing_method_id->fq_class_name;
|
|
|
|
// if the calling class is the same, we know the method exists, so it must be visible
|
|
if ($appearing_method_class === $context->self) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
$declaring_method_class = $declaring_method_id->fq_class_name;
|
|
|
|
if ($source->getSource() instanceof TraitAnalyzer
|
|
&& strtolower($declaring_method_class) === strtolower((string) $source->getFQCLN())
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
$storage = $codebase->methods->getStorage($declaring_method_id);
|
|
|
|
switch ($storage->visibility) {
|
|
case ClassLikeAnalyzer::VISIBILITY_PUBLIC:
|
|
return true;
|
|
|
|
case ClassLikeAnalyzer::VISIBILITY_PRIVATE:
|
|
return $context->self && $appearing_method_class === $context->self;
|
|
|
|
case ClassLikeAnalyzer::VISIBILITY_PROTECTED:
|
|
if (!$context->self) {
|
|
return false;
|
|
}
|
|
|
|
if ($appearing_method_class
|
|
&& $codebase->classExtends($appearing_method_class, $context->self)
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
if ($appearing_method_class
|
|
&& !$codebase->classExtends($context->self, $appearing_method_class)
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check that __clone, __construct, and __destruct do not have a return type
|
|
* hint in their signature.
|
|
*/
|
|
public static function checkMethodSignatureMustOmitReturnType(
|
|
MethodStorage $method_storage,
|
|
CodeLocation $code_location
|
|
): void {
|
|
if ($method_storage->signature_return_type === null) {
|
|
return;
|
|
}
|
|
|
|
if ($method_storage->cased_name === null) {
|
|
return;
|
|
}
|
|
|
|
$method_name_lc = strtolower($method_storage->cased_name);
|
|
$methodsOfInterest = ['__clone', '__construct', '__destruct'];
|
|
|
|
if (in_array($method_name_lc, $methodsOfInterest, true)) {
|
|
IssueBuffer::maybeAdd(
|
|
new MethodSignatureMustOmitReturnType(
|
|
'Method ' . $method_storage->cased_name . ' must not declare a return type',
|
|
$code_location,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
public function getMethodId(?string $context_self = null): MethodIdentifier
|
|
{
|
|
$function_name = (string)$this->function->name;
|
|
|
|
return new MethodIdentifier(
|
|
$context_self ?: (string) $this->source->getFQCLN(),
|
|
strtolower($function_name),
|
|
);
|
|
}
|
|
|
|
public static function checkForbiddenEnumMethod(MethodStorage $method_storage, ClassLikeStorage $enum_storage): void
|
|
{
|
|
if ($method_storage->cased_name === null || $method_storage->location === null) {
|
|
return;
|
|
}
|
|
|
|
$method_name_lc = strtolower($method_storage->cased_name);
|
|
if (in_array($method_name_lc, self::FORBIDDEN_ENUM_METHODS, true)) {
|
|
IssueBuffer::maybeAdd(new InvalidEnumMethod(
|
|
'Enums cannot define ' . $method_storage->cased_name,
|
|
$method_storage->location,
|
|
$method_storage->defining_fqcln . '::' . $method_storage->cased_name,
|
|
));
|
|
}
|
|
|
|
if ($method_name_lc === 'cases') {
|
|
IssueBuffer::maybeAdd(new InvalidEnumMethod(
|
|
'Enums cannot define ' . $method_storage->cased_name,
|
|
$method_storage->location,
|
|
$method_storage->defining_fqcln . '::' . $method_storage->cased_name,
|
|
));
|
|
}
|
|
|
|
if ($enum_storage->enum_type && ($method_name_lc === 'from' || $method_name_lc === 'tryfrom')) {
|
|
IssueBuffer::maybeAdd(new InvalidEnumMethod(
|
|
'Enums cannot define ' . $method_storage->cased_name,
|
|
$method_storage->location,
|
|
$method_storage->defining_fqcln . '::' . $method_storage->cased_name,
|
|
));
|
|
}
|
|
}
|
|
}
|