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

1522 lines
52 KiB
PHP
Raw Normal View History

2016-08-14 05:26:45 +02:00
<?php
2018-11-06 03:57:36 +01:00
namespace Psalm\Internal\Analyzer;
2016-08-14 05:26:45 +02:00
use PhpParser;
2016-10-15 06:12:57 +02:00
use PhpParser\Node\Expr\Closure;
use PhpParser\Node\Stmt\ClassMethod;
2016-11-02 07:29:00 +01:00
use PhpParser\Node\Stmt\Function_;
2018-11-06 03:57:36 +01:00
use Psalm\Codebase;
use Psalm\Internal\Analyzer\FunctionLike\ReturnTypeAnalyzer;
use Psalm\Internal\Analyzer\FunctionLike\ReturnTypeCollector;
use Psalm\Internal\Analyzer\Statements\ExpressionAnalyzer;
use Psalm\CodeLocation;
2016-11-02 07:29:00 +01:00
use Psalm\Context;
use Psalm\Internal\FileManipulation\FunctionDocblockManipulator;
2019-02-27 22:00:44 +01:00
use Psalm\Issue\InvalidDocblockParamName;
use Psalm\Issue\InvalidParamDefault;
use Psalm\Issue\MismatchingDocblockParamType;
use Psalm\Issue\MissingClosureParamType;
use Psalm\Issue\MissingParamType;
use Psalm\Issue\MissingThrowsDocblock;
use Psalm\Issue\ReferenceConstraintViolation;
use Psalm\Issue\ReservedWord;
use Psalm\Issue\UnusedClosureParam;
use Psalm\Issue\UnusedParam;
2016-11-02 07:29:00 +01:00
use Psalm\IssueBuffer;
2016-08-14 05:26:45 +02:00
use Psalm\StatementsSource;
use Psalm\Storage\FunctionLikeParameter;
2017-09-04 02:52:54 +02:00
use Psalm\Storage\FunctionLikeStorage;
use Psalm\Storage\MethodStorage;
2016-08-14 05:26:45 +02:00
use Psalm\Type;
use Psalm\Type\Atomic\TNamedObject;
use function md5;
use function explode;
use function strtolower;
use function array_merge;
use function array_filter;
use function is_string;
use function array_key_exists;
use function substr;
use function strpos;
use function array_search;
use function array_keys;
use function end;
use function array_diff;
2019-08-14 06:47:57 +02:00
use Psalm\Internal\Taint\Source;
2016-08-14 05:26:45 +02:00
/**
* @internal
*/
2018-11-06 03:57:36 +01:00
abstract class FunctionLikeAnalyzer extends SourceAnalyzer implements StatementsSource
2016-08-14 05:26:45 +02:00
{
2016-10-14 06:53:43 +02:00
/**
2016-10-15 06:12:57 +02:00
* @var Closure|Function_|ClassMethod
2016-10-14 06:53:43 +02:00
*/
2016-08-14 05:26:45 +02:00
protected $function;
2016-10-14 06:53:43 +02:00
2018-11-06 03:57:36 +01:00
/**
* @var Codebase
*/
protected $codebase;
2016-10-14 06:53:43 +02:00
/**
2017-01-07 20:35:07 +01:00
* @var array<string>
2016-10-14 06:53:43 +02:00
*/
2017-01-07 20:35:07 +01:00
protected $suppressed_issues;
2016-10-14 06:53:43 +02:00
/**
* @var bool
*/
2016-08-14 05:26:45 +02:00
protected $is_static = false;
2016-10-14 06:53:43 +02:00
/**
* @var StatementsSource
*/
2016-08-14 05:26:45 +02:00
protected $source;
2016-10-14 06:53:43 +02:00
2016-10-15 06:12:57 +02:00
/**
* @var ?array<string, Type\Union>
2016-10-15 06:12:57 +02:00
*/
2016-08-14 05:26:45 +02:00
protected $return_vars_in_scope = [];
2016-10-15 06:12:57 +02:00
/**
* @var ?array<string, bool>
2016-10-15 06:12:57 +02:00
*/
2016-08-14 05:26:45 +02:00
protected $return_vars_possibly_in_scope = [];
2016-11-01 05:39:41 +01:00
2018-01-14 18:09:40 +01:00
/**
* @var Type\Union|null
*/
private $local_return_type;
2016-11-01 05:39:41 +01:00
/**
* @var array<string, bool>
2016-11-01 05:39:41 +01:00
*/
2016-08-14 05:26:45 +02:00
protected static $no_effects_hashes = [];
/**
* @var FunctionLikeStorage
*/
protected $storage;
2016-10-15 06:12:57 +02:00
/**
* @param Closure|Function_|ClassMethod $function
2018-11-06 03:57:36 +01:00
* @param SourceAnalyzer $source
2016-10-15 06:12:57 +02:00
*/
protected function __construct($function, SourceAnalyzer $source, FunctionLikeStorage $storage)
2016-08-14 05:26:45 +02:00
{
$this->function = $function;
$this->source = $source;
$this->suppressed_issues = $source->getSuppressedIssues();
2018-11-06 03:57:36 +01:00
$this->codebase = $source->getCodebase();
$this->storage = $storage;
2016-08-14 05:26:45 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @param Context $context
* @param Context|null $global_context
2017-01-12 03:37:53 +01:00
* @param bool $add_mutations whether or not to add mutations to this method
* @param ?array<string, bool> $byref_uses
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return false|null
*/
public function analyze(
Context $context,
Context $global_context = null,
$add_mutations = false,
array $byref_uses = null
) {
$storage = $this->storage;
2016-12-07 20:13:39 +01:00
$function_stmts = $this->function->getStmts() ?: [];
2016-09-02 00:02:09 +02:00
2016-12-07 20:13:39 +01:00
$hash = null;
2018-04-25 20:45:51 +02:00
$real_method_id = null;
2016-08-14 05:26:45 +02:00
$cased_method_id = null;
2016-11-02 07:29:00 +01:00
2017-02-10 02:35:17 +01:00
$class_storage = null;
if ($global_context) {
foreach ($global_context->constants as $const_name => $var_type) {
if (!$context->hasVariable($const_name)) {
$context->vars_in_scope[$const_name] = clone $var_type;
}
}
}
2018-11-06 03:57:36 +01:00
$codebase = $this->codebase;
2018-11-11 18:01:14 +01:00
$project_analyzer = $this->getProjectAnalyzer();
$implemented_docblock_param_types = [];
2018-11-06 03:57:36 +01:00
$classlike_storage_provider = $codebase->classlike_storage_provider;
if ($codebase->track_unused_suppressions) {
foreach ($storage->suppressed_issues as $offset => $issue_name) {
IssueBuffer::addUnusedSuppression($this->getFilePath(), $offset, $issue_name);
}
}
$overridden_method_ids = [];
if ($this->function instanceof ClassMethod) {
if (!$storage instanceof MethodStorage) {
throw new \UnexpectedValueException('$storage must be MethodStorage');
}
2017-01-12 06:54:41 +01:00
$real_method_id = (string)$this->getMethodId();
$method_id = (string)$this->getMethodId($context->self);
2017-01-12 03:37:53 +01:00
if ($add_mutations) {
$hash = md5($real_method_id . '::' . $context->getScopeSummary());
2016-08-14 05:26:45 +02:00
2016-12-07 20:13:39 +01:00
// if we know that the function has no effects on vars, we don't bother rechecking
if (isset(self::$no_effects_hashes[$hash])) {
return null;
2016-11-07 05:29:54 +01:00
}
2016-12-07 20:13:39 +01:00
} elseif ($context->self) {
$context->vars_in_scope['$this'] = new Type\Union([new TNamedObject($context->self)]);
2017-02-08 08:23:17 +01:00
$context->vars_possibly_in_scope['$this'] = true;
2016-12-07 20:13:39 +01:00
}
2016-11-07 05:29:54 +01:00
$fq_class_name = (string)$context->self;
2016-11-05 03:04:55 +01:00
$class_storage = $classlike_storage_provider->get($fq_class_name);
if ($class_storage->has_visitor_issues) {
return null;
}
$cased_method_id = $fq_class_name . '::' . $storage->cased_name;
2018-02-04 00:52:35 +01:00
$overridden_method_ids = $codebase->methods->getOverriddenMethodIds($method_id);
if ($this->function->name->name === '__construct') {
$context->inside_constructor = true;
}
$codeLocation = new CodeLocation(
$this,
$this->function,
null,
true
);
if ($overridden_method_ids
&& $this->function->name->name !== '__construct'
&& !$context->collect_initializations
&& !$context->collect_mutations
) {
foreach ($overridden_method_ids as $overridden_method_id) {
2018-02-04 00:52:35 +01:00
$parent_method_storage = $codebase->methods->getStorage($overridden_method_id);
list($overridden_fq_class_name) = explode('::', $overridden_method_id);
2016-12-07 20:13:39 +01:00
$parent_storage = $classlike_storage_provider->get($overridden_fq_class_name);
2016-12-07 20:13:39 +01:00
$implementer_visibility = $storage->visibility;
$implementer_appearing_method_id = $codebase->methods->getAppearingMethodId($cased_method_id);
$implementer_declaring_method_id = $real_method_id;
if ($implementer_appearing_method_id
&& $implementer_appearing_method_id !== $implementer_declaring_method_id
) {
list($appearing_fq_class_name, $appearing_method_name) = explode(
'::',
$implementer_appearing_method_id
);
$appearing_class_storage = $classlike_storage_provider->get(
$appearing_fq_class_name
);
if (isset($appearing_class_storage->trait_visibility_map[$appearing_method_name])) {
$implementer_visibility
= $appearing_class_storage->trait_visibility_map[$appearing_method_name];
}
}
// we've already checked this in the class checker
if (!isset($class_storage->class_implements[strtolower($overridden_fq_class_name)])) {
MethodAnalyzer::compareMethods(
$codebase,
$class_storage,
$parent_storage,
$storage,
$parent_method_storage,
$fq_class_name,
$implementer_visibility,
$codeLocation,
$storage->suppressed_issues
);
}
foreach ($parent_method_storage->params as $i => $guide_param) {
2018-12-21 17:01:24 +01:00
if ($guide_param->type
&& (!$guide_param->signature_type
|| ($guide_param->signature_type !== $guide_param->type
&& $storage->inheritdoc)
|| !$parent_storage->user_defined
)
) {
if (!isset($implemented_docblock_param_types[$i])) {
$implemented_docblock_param_types[$i] = $guide_param->type;
}
}
}
}
2016-12-07 20:13:39 +01:00
}
2018-11-06 03:57:36 +01:00
MethodAnalyzer::checkMethodSignatureMustOmitReturnType($storage, $codeLocation);
$context->calling_method_id = strtolower($method_id);
} elseif ($this->function instanceof Function_) {
$cased_method_id = $this->function->name->name;
} else { // Closure
if ($storage->return_type) {
2018-11-06 03:57:36 +01:00
$closure_return_type = ExpressionAnalyzer::fleshOutType(
$codebase,
$storage->return_type,
$context->self,
$context->self,
$this->getParentFQCLN()
);
} else {
$closure_return_type = Type::getMixed();
}
2016-12-15 01:19:25 +01:00
/** @var PhpParser\Node\Expr\Closure $this->function */
2016-12-07 20:13:39 +01:00
$this->function->inferredType = new Type\Union([
new Type\Atomic\TFn(
2016-12-07 20:13:39 +01:00
'Closure',
$storage->params,
$closure_return_type
2017-05-27 02:05:57 +02:00
),
2016-12-07 20:13:39 +01:00
]);
}
2016-09-02 00:02:09 +02:00
$this->suppressed_issues = $this->getSource()->getSuppressedIssues() + $storage->suppressed_issues;
if ($storage instanceof MethodStorage && $storage->is_static) {
$this->is_static = true;
}
2018-11-11 18:01:14 +01:00
$statements_analyzer = new StatementsAnalyzer($this);
if ($byref_uses) {
$statements_analyzer->setByRefUses($byref_uses);
}
if ($storage->template_types) {
foreach ($storage->template_types as $param_name => $_) {
$fq_classlike_name = Type::getFQCLNFromString(
$param_name,
$this->getAliases()
);
if ($codebase->classOrInterfaceExists($fq_classlike_name)) {
if (IssueBuffer::accepts(
new ReservedWord(
'Cannot use ' . $param_name . ' as template name since the class already exists',
new CodeLocation($this, $this->function),
'resource'
),
$this->getSuppressedIssues()
)) {
// fall through
}
}
}
}
2017-02-10 02:35:17 +01:00
$template_types = $storage->template_types;
if ($class_storage && $class_storage->template_types) {
$template_types = array_merge($template_types ?: [], $class_storage->template_types);
}
$params = $storage->params;
if ($storage instanceof MethodStorage) {
2019-01-31 23:48:48 +01:00
$non_null_param_types = array_filter(
$storage->params,
/** @return bool */
function (FunctionLikeParameter $p) {
return $p->type !== null && $p->has_docblock_type;
}
);
} else {
$non_null_param_types = array_filter(
$storage->params,
/** @return bool */
function (FunctionLikeParameter $p) {
return $p->type !== null;
}
);
}
if ($storage instanceof MethodStorage
&& is_string($cased_method_id)
&& $overridden_method_ids
) {
$types_without_docblocks = array_filter(
$storage->params,
/** @return bool */
function (FunctionLikeParameter $p) {
return !$p->type || !$p->has_docblock_type;
}
);
if ($types_without_docblocks) {
$params = $codebase->methods->getMethodParams($cased_method_id, $this);
}
}
$check_stmts = true;
2019-06-04 22:36:32 +02:00
if ($codebase->alter_code) {
2019-06-01 16:32:49 +02:00
foreach ($this->function->params as $param) {
$param_name_node = null;
if ($param->type instanceof PhpParser\Node\Name) {
$param_name_node = $param->type;
} elseif ($param->type instanceof PhpParser\Node\NullableType
&& $param->type->type instanceof PhpParser\Node\Name
) {
$param_name_node = $param->type->type;
}
if ($param_name_node) {
2019-06-04 22:36:32 +02:00
$resolved_name = ClassLikeAnalyzer::getFQCLNFromNameObject($param_name_node, $this->getAliases());
2019-06-01 16:32:49 +02:00
$parent_fqcln = $this->getParentFQCLN();
if ($resolved_name === 'self' && $context->self) {
$resolved_name = (string) $context->self;
} elseif ($resolved_name === 'parent' && $parent_fqcln) {
$resolved_name = $parent_fqcln;
}
2019-06-04 22:36:32 +02:00
$codebase->classlikes->handleClassLikeReferenceInMigration(
$codebase,
$this,
$param_name_node,
2019-06-01 16:32:49 +02:00
$resolved_name,
2019-06-04 22:36:32 +02:00
$context->calling_method_id
2019-06-01 16:32:49 +02:00
);
}
}
if ($this->function->returnType) {
$return_name_node = null;
if ($this->function->returnType instanceof PhpParser\Node\Name) {
$return_name_node = $this->function->returnType;
} elseif ($this->function->returnType instanceof PhpParser\Node\NullableType
&& $this->function->returnType->type instanceof PhpParser\Node\Name
) {
$return_name_node = $this->function->returnType->type;
}
if ($return_name_node) {
2019-06-04 22:36:32 +02:00
$resolved_name = ClassLikeAnalyzer::getFQCLNFromNameObject($return_name_node, $this->getAliases());
$parent_fqcln = $this->getParentFQCLN();
if ($resolved_name === 'self' && $context->self) {
$resolved_name = (string) $context->self;
} elseif ($resolved_name === 'parent' && $parent_fqcln) {
$resolved_name = $parent_fqcln;
}
2019-06-04 22:36:32 +02:00
$codebase->classlikes->handleClassLikeReferenceInMigration(
$codebase,
$this,
$return_name_node,
$resolved_name,
2019-06-04 22:36:32 +02:00
$context->calling_method_id
);
}
}
if ($storage->return_type
&& $storage->return_type_location
&& $storage->return_type_location !== $storage->signature_return_type_location
) {
$replace_type = ExpressionAnalyzer::fleshOutType(
$codebase,
$storage->return_type,
$context->self,
$context->self,
2019-06-07 00:46:40 +02:00
$this->getParentFQCLN(),
false
);
2019-06-04 22:36:32 +02:00
$codebase->classlikes->handleDocblockTypeInMigration(
$codebase,
$this,
$replace_type,
2019-06-04 22:36:32 +02:00
$storage->return_type_location,
$context->calling_method_id
);
}
2019-06-01 22:57:33 +02:00
foreach ($params as $function_param) {
if ($function_param->type
&& $function_param->type_location
&& $function_param->type_location !== $function_param->signature_type_location
&& $function_param->type_location->file_path === $this->getFilePath()
2019-06-01 22:57:33 +02:00
) {
$replace_type = ExpressionAnalyzer::fleshOutType(
$codebase,
$function_param->type,
$context->self,
$context->self,
2019-06-07 00:46:40 +02:00
$this->getParentFQCLN(),
false
2019-06-01 22:57:33 +02:00
);
2019-06-04 22:36:32 +02:00
$codebase->classlikes->handleDocblockTypeInMigration(
$codebase,
$this,
2019-06-01 22:57:33 +02:00
$replace_type,
2019-06-04 22:36:32 +02:00
$function_param->type_location,
$context->calling_method_id
2019-06-01 22:57:33 +02:00
);
}
}
2019-06-01 16:32:49 +02:00
}
2019-06-02 18:02:32 +02:00
foreach ($codebase->methods_to_rename as $original_method_id => $new_method_name) {
if ($this->function instanceof ClassMethod
&& strtolower($this->getMethodId()) === $original_method_id
) {
$file_manipulations = [
new \Psalm\FileManipulation(
(int) $this->function->name->getAttribute('startFilePos'),
(int) $this->function->name->getAttribute('endFilePos') + 1,
$new_method_name
)
];
\Psalm\Internal\FileManipulation\FileManipulationBuffer::add(
$this->getFilePath(),
$file_manipulations
);
}
}
foreach ($params as $offset => $function_param) {
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
$signature_type = $function_param->signature_type;
$signature_type_location = $function_param->signature_type_location;
2019-02-24 07:33:25 +01:00
if ($signature_type && $signature_type_location && $signature_type->hasObjectType()) {
list($start, $end) = $signature_type_location->getSelectionBounds();
$codebase->analyzer->addOffsetReference(
$this->getFilePath(),
$start,
$end,
(string) $signature_type
);
}
2018-02-01 05:27:25 +01:00
if ($signature_type) {
$signature_type = ExpressionAnalyzer::fleshOutType(
$codebase,
$signature_type,
$context->self,
$context->self,
$this->getParentFQCLN()
);
}
if ($function_param->type) {
2018-12-21 17:01:24 +01:00
$is_signature_type = $function_param->type === $function_param->signature_type;
if ($is_signature_type
&& $storage instanceof MethodStorage
&& $storage->inheritdoc
&& isset($implemented_docblock_param_types[$offset])
) {
$param_type = clone $implemented_docblock_param_types[$offset];
} else {
$param_type = clone $function_param->type;
}
2018-11-06 03:57:36 +01:00
$param_type = ExpressionAnalyzer::fleshOutType(
$codebase,
$param_type,
$context->self,
$context->self,
$this->getParentFQCLN()
);
if ($function_param->type_location) {
if ($param_type->check(
$this,
$function_param->type_location,
$storage->suppressed_issues,
[],
false,
$this->function instanceof ClassMethod
&& strtolower($this->function->name->name) !== '__construct'
) === false) {
$check_stmts = false;
}
}
} else {
if (!$non_null_param_types && isset($implemented_docblock_param_types[$offset])) {
$param_type = clone $implemented_docblock_param_types[$offset];
2018-11-06 03:57:36 +01:00
$param_type = ExpressionAnalyzer::fleshOutType(
$codebase,
$param_type,
$context->self,
$context->self,
$this->getParentFQCLN()
);
} else {
$param_type = Type::getMixed();
}
}
$var_type = $param_type;
if ($function_param->is_variadic) {
$var_type = new Type\Union([
new Type\Atomic\TArray([
Type::getInt(),
$param_type,
]),
]);
}
if ($cased_method_id && $codebase->taint) {
2019-08-14 06:47:57 +02:00
$type_source = Source::getForMethodArgument(
$cased_method_id,
$offset,
$function_param->location,
null
);
$var_type->sources = [$type_source];
if ($tainted_source = $codebase->taint->hasExistingSource($type_source)) {
$var_type->tainted = $tainted_source->taint;
$type_source->taint = $tainted_source->taint;
}
}
$context->vars_in_scope['$' . $function_param->name] = $var_type;
2017-07-09 03:19:16 +02:00
$context->vars_possibly_in_scope['$' . $function_param->name] = true;
if ($context->collect_references && $function_param->location) {
2018-06-17 02:01:33 +02:00
$context->unreferenced_vars['$' . $function_param->name] = [
$function_param->location->getHash() => $function_param->location
];
}
/**
* @var PhpParser\Node\Param
*/
$parser_param = $this->function->getParams()[$offset];
if (!$function_param->type_location || !$function_param->location) {
if ($parser_param->default) {
ExpressionAnalyzer::analyze($statements_analyzer, $parser_param->default, $context);
}
continue;
}
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
if ($signature_type) {
2019-07-10 07:35:57 +02:00
$union_comparison_result = new TypeComparisonResult();
2018-11-06 03:57:36 +01:00
if (!TypeAnalyzer::isContainedBy(
2018-06-09 05:54:07 +02:00
$codebase,
$param_type,
$signature_type,
false,
false,
2019-07-10 07:35:57 +02:00
$union_comparison_result
) && !$union_comparison_result->type_coerced_from_mixed
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
) {
2018-11-06 03:57:36 +01:00
if ($codebase->alter_code
2018-11-11 18:01:14 +01:00
&& isset($project_analyzer->getIssuesToFix()['MismatchingDocblockParamType'])
2018-01-07 16:23:02 +01:00
) {
2018-11-11 18:01:14 +01:00
$this->addOrUpdateParamType($project_analyzer, $function_param->name, $signature_type, true);
2018-01-07 16:23:02 +01:00
2018-01-07 18:53:25 +01:00
continue;
2018-01-07 16:23:02 +01:00
}
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
if (IssueBuffer::accepts(
new MismatchingDocblockParamType(
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
'Parameter $' . $function_param->name . ' has wrong type \'' . $param_type .
'\', should be \'' . $signature_type . '\'',
$function_param->type_location
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
),
$storage->suppressed_issues
)) {
return false;
}
if ($signature_type->check(
2018-01-10 04:46:55 +01:00
$this,
$function_param->type_location,
$storage->suppressed_issues,
[],
false
) === false) {
$check_stmts = false;
}
2018-01-10 04:46:55 +01:00
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
continue;
}
}
if ($parser_param->default) {
2018-11-11 18:01:14 +01:00
ExpressionAnalyzer::analyze($statements_analyzer, $parser_param->default, $context);
$default_type = isset($parser_param->default->inferredType)
? $parser_param->default->inferredType
: null;
2018-03-21 04:55:26 +01:00
if ($default_type
&& !$default_type->hasMixed()
2018-11-06 03:57:36 +01:00
&& !TypeAnalyzer::isContainedBy(
2018-02-01 06:50:01 +01:00
$codebase,
$default_type,
2019-06-25 15:06:23 +02:00
$param_type,
false,
false,
2019-07-10 07:35:57 +02:00
null,
2019-06-25 15:06:23 +02:00
true
)
) {
if (IssueBuffer::accepts(
new InvalidParamDefault(
2018-03-21 04:55:26 +01:00
'Default value type ' . $default_type . ' for argument ' . ($offset + 1)
. ' of method ' . $cased_method_id
. ' does not match the given type ' . $param_type,
2017-12-30 03:28:21 +01:00
$function_param->type_location
)
)) {
2016-12-31 06:14:00 +01:00
// fall through
}
}
}
2017-02-10 02:35:17 +01:00
if ($template_types) {
2017-02-10 06:14:44 +01:00
$substituted_type = clone $param_type;
if ($substituted_type->check(
2017-12-30 03:28:21 +01:00
$this->source,
$function_param->type_location,
$this->suppressed_issues,
[],
false
) === false) {
$check_stmts = false;
}
2017-02-10 02:35:17 +01:00
} else {
if ($param_type->isVoid()) {
if (IssueBuffer::accepts(
new ReservedWord(
'Parameter cannot be void',
$function_param->type_location,
'void'
),
$this->suppressed_issues
)) {
// fall through
}
}
if ($param_type->check(
$this->source,
$function_param->type_location,
$this->suppressed_issues,
[],
false
) === false) {
$check_stmts = false;
}
2017-03-02 00:36:04 +01:00
}
if ($codebase->collect_references) {
2017-12-30 03:28:21 +01:00
if ($function_param->type_location !== $function_param->signature_type_location &&
$function_param->signature_type_location &&
2017-03-02 00:36:04 +01:00
$function_param->signature_type
) {
if ($function_param->signature_type->check(
2017-03-02 00:36:04 +01:00
$this->source,
2017-12-30 03:28:21 +01:00
$function_param->signature_type_location,
$this->suppressed_issues,
[],
false
) === false) {
$check_stmts = false;
}
2017-03-02 00:36:04 +01:00
}
2017-02-10 02:35:17 +01:00
}
2016-09-02 00:02:09 +02:00
2017-02-08 08:23:17 +01:00
if ($function_param->by_ref) {
// register by ref params as having been used, to avoid false positives
// @todo change the assignment analysis *just* for byref params
// so that we don't have to do this
$context->hasVariable('$' . $function_param->name);
}
2016-09-02 00:02:09 +02:00
2018-11-11 18:01:14 +01:00
$statements_analyzer->registerVariable(
2017-02-08 08:23:17 +01:00
'$' . $function_param->name,
$function_param->location,
null
2016-12-07 20:13:39 +01:00
);
}
2016-08-14 05:26:45 +02:00
if ($storage->pure) {
$context->pure = true;
}
2019-02-27 22:00:44 +01:00
if ($storage->unused_docblock_params) {
foreach ($storage->unused_docblock_params as $param_name => $param_location) {
if (IssueBuffer::accepts(
new InvalidDocblockParamName(
'Incorrect param name $' . $param_name . ' in docblock for ' . $cased_method_id,
$param_location
)
)) {
}
}
}
if (ReturnTypeAnalyzer::checkReturnType(
2018-02-22 00:59:31 +01:00
$this->function,
2018-11-11 18:01:14 +01:00
$project_analyzer,
2018-02-22 00:59:31 +01:00
$this,
$storage,
$context
) === false) {
$check_stmts = false;
}
if (!$check_stmts) {
2018-02-22 00:59:31 +01:00
return false;
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
}
if ($context->collect_initializations || $context->collect_mutations) {
$statements_analyzer->addSuppressedIssues([
'DocblockTypeContradiction',
2019-02-19 03:31:08 +01:00
'InvalidReturnStatement',
'RedundantCondition',
'RedundantConditionGivenDocblockType',
2019-02-19 03:31:08 +01:00
'TypeDoesNotContainNull',
'TypeDoesNotContainType',
'LoopInvalidation',
]);
if ($context->collect_initializations) {
$statements_analyzer->addSuppressedIssues([
'UndefinedInterfaceMethod',
'UndefinedMethod',
'PossiblyUndefinedMethod',
]);
}
}
2018-11-11 18:01:14 +01:00
$statements_analyzer->analyze($function_stmts, $context, $global_context, true);
2016-08-14 05:26:45 +02:00
$this->examineParamTypes($statements_analyzer, $context, $codebase);
foreach ($storage->params as $offset => $function_param) {
// only complain if there's no type defined by a parent type
if (!$function_param->type
&& $function_param->location
&& !isset($implemented_docblock_param_types[$offset])
) {
if ($this->function instanceof Closure) {
IssueBuffer::accepts(
new MissingClosureParamType(
'Parameter $' . $function_param->name . ' has no provided type',
$function_param->location
),
$storage->suppressed_issues + $this->getSuppressedIssues()
);
} else {
IssueBuffer::accepts(
new MissingParamType(
'Parameter $' . $function_param->name . ' has no provided type',
$function_param->location
),
$storage->suppressed_issues + $this->getSuppressedIssues()
);
}
}
}
if ($storage->signature_return_type && $storage->signature_return_type_location) {
list($start, $end) = $storage->signature_return_type_location->getSelectionBounds();
$codebase->analyzer->addOffsetReference(
$this->getFilePath(),
$start,
$end,
(string) $storage->signature_return_type
);
}
2016-12-07 20:13:39 +01:00
if ($this->function instanceof Closure) {
$this->verifyReturnType(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
$storage->return_type,
2017-01-07 20:35:07 +01:00
$this->source->getFQCLN(),
$storage->return_type_location,
$global_context && $global_context->inside_call
2016-12-07 20:13:39 +01:00
);
$closure_yield_types = [];
$ignore_nullable_issues = false;
$ignore_falsable_issues = false;
$closure_return_types = ReturnTypeCollector::getReturnTypes(
$this->function->stmts,
$closure_yield_types,
$ignore_nullable_issues,
$ignore_falsable_issues,
true
);
if ($closure_return_types) {
$closure_return_type = new Type\Union($closure_return_types);
if (!$storage->return_type
|| $storage->return_type->hasMixed()
2018-11-06 03:57:36 +01:00
|| TypeAnalyzer::isContainedBy(
$codebase,
$closure_return_type,
2018-04-10 04:00:36 +02:00
$storage->return_type
)
) {
if ($this->function->inferredType) {
/** @var Type\Atomic\TFn */
$closure_atomic = $this->function->inferredType->getTypes()['Closure'];
$closure_atomic->return_type = $closure_return_type;
}
2016-08-14 05:26:45 +02:00
}
}
2016-12-07 20:13:39 +01:00
}
2016-08-14 05:26:45 +02:00
$unused_params = [];
if ($context->collect_references
&& !$context->collect_initializations
&& $codebase->find_unused_variables
&& $context->check_variables
) {
2018-11-11 18:01:14 +01:00
foreach ($statements_analyzer->getUnusedVarLocations() as list($var_name, $original_location)) {
if (!array_key_exists(substr($var_name, 1), $storage->param_types)) {
continue;
}
if (strpos($var_name, '$_') === 0 || (strpos($var_name, '$unused') === 0 && $var_name !== '$unused')) {
continue;
}
$position = array_search(substr($var_name, 1), array_keys($storage->param_types), true);
if ($position === false) {
throw new \UnexpectedValueException('$position should not be false here');
}
if ($storage->params[$position]->by_ref) {
continue;
}
if (!($storage instanceof MethodStorage)
2018-11-06 03:57:36 +01:00
|| $storage->visibility === ClassLikeAnalyzer::VISIBILITY_PRIVATE
) {
if ($this->function instanceof Closure) {
if (IssueBuffer::accepts(
new UnusedClosureParam(
'Param ' . $var_name . ' is never referenced in this method',
$original_location
),
$this->getSuppressedIssues()
)) {
// fall through
}
} else {
if (IssueBuffer::accepts(
new UnusedParam(
'Param ' . $var_name . ' is never referenced in this method',
$original_location
),
$this->getSuppressedIssues()
)) {
// fall through
}
}
} else {
$fq_class_name = (string)$context->self;
$class_storage = $codebase->classlike_storage_provider->get($fq_class_name);
$method_name_lc = strtolower($storage->cased_name);
if ($storage->abstract || !isset($class_storage->overridden_method_ids[$method_name_lc])) {
continue;
}
$parent_method_id = end($class_storage->overridden_method_ids[$method_name_lc]);
if ($parent_method_id) {
2018-02-04 00:52:35 +01:00
$parent_method_storage = $codebase->methods->getStorage($parent_method_id);
// if the parent method has a param at that position and isn't abstract
if (!$parent_method_storage->abstract
&& isset($parent_method_storage->params[$position])
) {
continue;
}
}
$unused_params[$position] = $original_location;
}
}
if ($storage instanceof MethodStorage
&& $class_storage
&& $storage->visibility !== ClassLikeAnalyzer::VISIBILITY_PRIVATE
) {
$method_id_lc = strtolower($this->getMethodId());
foreach ($storage->params as $i => $_) {
if (!isset($unused_params[$i])) {
$codebase->file_reference_provider->addMethodParamUse(
$method_id_lc,
$i,
$method_id_lc
);
/** @var ClassMethod $this->function */
$method_name_lc = strtolower($storage->cased_name);
if (!isset($class_storage->overridden_method_ids[$method_name_lc])) {
continue;
}
foreach ($class_storage->overridden_method_ids[$method_name_lc] as $parent_method_id) {
$codebase->file_reference_provider->addMethodParamUse(
strtolower($parent_method_id),
$i,
$method_id_lc
);
2017-02-08 00:18:33 +01:00
}
}
}
}
}
foreach ($storage->throws as $expected_exception => $_) {
2019-08-13 21:44:18 +02:00
if (isset($storage->throw_locations[$expected_exception])) {
if (ClassLikeAnalyzer::checkFullyQualifiedClassLikeName(
$statements_analyzer,
$expected_exception,
2019-08-13 21:44:18 +02:00
$storage->throw_locations[$expected_exception],
$statements_analyzer->getSuppressedIssues(),
false,
false,
true,
true
2019-08-13 21:44:18 +02:00
)) {
$input_type = new Type\Union([new TNamedObject($expected_exception)]);
$container_type = new Type\Union([new TNamedObject('Exception'), new TNamedObject('Throwable')]);
2019-08-13 21:44:18 +02:00
if (!TypeAnalyzer::isContainedBy($codebase, $input_type, $container_type)) {
if (IssueBuffer::accepts(
new \Psalm\Issue\InvalidThrow(
'Class supplied for @throws ' . $expected_exception
. ' does not implement Throwable',
$storage->throw_locations[$expected_exception],
$expected_exception
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
}
}
}
}
foreach ($statements_analyzer->getUncaughtThrows($context) as $possibly_thrown_exception => $codelocations) {
$is_expected = false;
foreach ($storage->throws as $expected_exception => $_) {
if ($expected_exception === $possibly_thrown_exception
|| $codebase->classExtends($possibly_thrown_exception, $expected_exception)
) {
$is_expected = true;
break;
}
}
if (!$is_expected) {
foreach ($codelocations as $codelocation) {
// issues are suppressed in ThrowAnalyzer, CallAnalyzer, etc.
if (IssueBuffer::accepts(
new MissingThrowsDocblock(
$possibly_thrown_exception . ' is thrown but not caught - please either catch'
. ' or add a @throws annotation',
$codelocation
)
)) {
// fall through
}
}
}
}
2017-01-12 03:37:53 +01:00
if ($add_mutations) {
if ($this->return_vars_in_scope !== null) {
2018-11-06 03:57:36 +01:00
$context->vars_in_scope = TypeAnalyzer::combineKeyedTypes(
2017-01-12 03:37:53 +01:00
$context->vars_in_scope,
$this->return_vars_in_scope
2017-01-12 03:37:53 +01:00
);
}
2016-12-07 20:13:39 +01:00
if ($this->return_vars_possibly_in_scope !== null) {
2017-01-12 03:37:53 +01:00
$context->vars_possibly_in_scope = array_merge(
$context->vars_possibly_in_scope,
$this->return_vars_possibly_in_scope
2017-01-12 03:37:53 +01:00
);
}
2016-12-07 20:13:39 +01:00
2017-02-11 01:10:13 +01:00
foreach ($context->vars_in_scope as $var => $_) {
if (strpos($var, '$this->') !== 0 && $var !== '$this') {
2017-01-12 03:37:53 +01:00
unset($context->vars_in_scope[$var]);
}
2016-08-14 05:26:45 +02:00
}
2017-02-11 01:10:13 +01:00
foreach ($context->vars_possibly_in_scope as $var => $_) {
if (strpos($var, '$this->') !== 0 && $var !== '$this') {
2017-01-12 03:37:53 +01:00
unset($context->vars_possibly_in_scope[$var]);
}
2016-08-14 05:26:45 +02:00
}
2016-11-02 07:29:00 +01:00
2018-11-06 03:57:36 +01:00
if ($hash && $real_method_id && $this instanceof MethodAnalyzer) {
$new_hash = md5($real_method_id . '::' . $context->getScopeSummary());
if ($new_hash === $hash) {
self::$no_effects_hashes[$hash] = true;
}
2017-01-12 03:37:53 +01:00
}
2016-12-07 20:13:39 +01:00
}
2016-11-02 07:29:00 +01:00
return null;
2016-08-14 05:26:45 +02:00
}
/**
2018-02-22 00:59:31 +01:00
* @param Type\Union|null $return_type
* @param string $fq_class_name
* @param CodeLocation|null $return_type_location
*
2018-02-22 00:59:31 +01:00
* @return false|null
*/
2018-02-22 00:59:31 +01:00
public function verifyReturnType(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2018-02-22 00:59:31 +01:00
Type\Union $return_type = null,
$fq_class_name = null,
CodeLocation $return_type_location = null,
bool $closure_inside_call = false
) {
2018-11-06 03:57:36 +01:00
ReturnTypeAnalyzer::verifyReturnType(
2018-02-22 00:59:31 +01:00
$this->function,
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2018-02-22 00:59:31 +01:00
$this,
$return_type,
$fq_class_name,
$return_type_location,
[],
$closure_inside_call
2018-02-22 00:59:31 +01:00
);
}
2018-02-22 00:59:31 +01:00
/**
* @param string $param_name
* @param bool $docblock_only
*
* @return void
*/
public function addOrUpdateParamType(
2018-11-11 18:01:14 +01:00
ProjectAnalyzer $project_analyzer,
2018-02-22 00:59:31 +01:00
$param_name,
Type\Union $inferred_return_type,
$docblock_only = false
) {
$manipulator = FunctionDocblockManipulator::getForFunction(
2018-11-11 18:01:14 +01:00
$project_analyzer,
2018-02-22 00:59:31 +01:00
$this->source->getFilePath(),
$this->getMethodId(),
$this->function
);
$manipulator->setParamType(
$param_name,
!$docblock_only && $project_analyzer->getCodebase()->php_major_version >= 7
2018-02-22 00:59:31 +01:00
? $inferred_return_type->toPhpString(
$this->source->getNamespace(),
$this->source->getAliasedClassesFlipped(),
$this->source->getFQCLN(),
$project_analyzer->getCodebase()->php_major_version,
$project_analyzer->getCodebase()->php_minor_version
2018-02-22 00:59:31 +01:00
) : null,
$inferred_return_type->toNamespacedString(
$this->source->getNamespace(),
$this->source->getAliasedClassesFlipped(),
$this->source->getFQCLN(),
false
),
$inferred_return_type->toNamespacedString(
$this->source->getNamespace(),
$this->source->getAliasedClassesFlipped(),
$this->source->getFQCLN(),
true
),
$inferred_return_type->canBeFullyExpressedInPhp()
);
}
2016-08-14 05:26:45 +02:00
/**
* Adds return types for the given function
2016-11-02 07:29:00 +01:00
*
* @param string $return_type
* @param Context $context
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return void
2016-08-14 05:26:45 +02:00
*/
public function addReturnTypes(Context $context)
2016-08-14 05:26:45 +02:00
{
if ($this->return_vars_in_scope !== null) {
$this->return_vars_in_scope = TypeAnalyzer::combineKeyedTypes(
2016-11-02 07:29:00 +01:00
$context->vars_in_scope,
$this->return_vars_in_scope
2016-11-02 07:29:00 +01:00
);
} else {
$this->return_vars_in_scope = $context->vars_in_scope;
2016-08-14 05:26:45 +02:00
}
if ($this->return_vars_possibly_in_scope !== null) {
$this->return_vars_possibly_in_scope = array_merge(
2016-11-02 07:29:00 +01:00
$context->vars_possibly_in_scope,
$this->return_vars_possibly_in_scope
2016-11-02 07:29:00 +01:00
);
} else {
$this->return_vars_possibly_in_scope = $context->vars_possibly_in_scope;
2016-08-14 05:26:45 +02:00
}
}
/**
* @return void
*/
public function examineParamTypes(
StatementsAnalyzer $statements_analyzer,
Context $context,
Codebase $codebase,
PhpParser\Node $stmt = null
) {
$storage = $this->getFunctionLikeStorage($statements_analyzer);
foreach ($storage->params as $i => $param) {
if ($param->by_ref && isset($context->vars_in_scope['$' . $param->name]) && !$param->is_variadic) {
$actual_type = $context->vars_in_scope['$' . $param->name];
$param_out_type = $param->type;
if (isset($storage->param_out_types[$i])) {
$param_out_type = $storage->param_out_types[$i];
}
if ($param_out_type && !$actual_type->hasMixed() && $param->location) {
if (!TypeAnalyzer::isContainedBy(
$codebase,
$actual_type,
$param_out_type,
$actual_type->ignore_nullable_issues,
$actual_type->ignore_falsable_issues
)
) {
if (IssueBuffer::accepts(
new ReferenceConstraintViolation(
'Variable ' . '$' . $param->name . ' is limited to values of type '
. $param_out_type->getId()
. ' because it is passed by reference, '
. $actual_type->getId() . ' type found. Use @param-out to specify '
. 'a different output type',
$stmt
? new CodeLocation($this, $stmt)
: $param->location
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
}
}
}
}
}
/**
* @return null|string
*/
public function getMethodName()
{
if ($this->function instanceof ClassMethod) {
return (string)$this->function->name;
}
}
2016-08-14 05:26:45 +02:00
/**
* @param string|null $context_self
2017-05-27 02:16:18 +02:00
*
* @return string
2016-08-14 05:26:45 +02:00
*/
public function getMethodId($context_self = null)
2016-08-14 05:26:45 +02:00
{
2016-11-21 03:49:06 +01:00
if ($this->function instanceof ClassMethod) {
$function_name = (string)$this->function->name;
2016-11-21 20:36:06 +01:00
2017-01-07 20:35:07 +01:00
return ($context_self ?: $this->source->getFQCLN()) . '::' . strtolower($function_name);
2016-11-21 03:49:06 +01:00
}
if ($this->function instanceof Function_) {
$namespace = $this->source->getNamespace();
return ($namespace ? strtolower($namespace) . '\\' : '') . strtolower($this->function->name->name);
2016-08-14 05:26:45 +02:00
}
2016-11-02 07:29:00 +01:00
return $this->getFilePath()
. ':' . $this->function->getLine()
. ':' . (int)$this->function->getAttribute('startFilePos')
. ':-:closure';
2016-08-14 05:26:45 +02:00
}
/**
* @param string|null $context_self
*
* @return string
*/
public function getCorrectlyCasedMethodId($context_self = null)
{
if ($this->function instanceof ClassMethod) {
$function_name = (string)$this->function->name;
return ($context_self ?: $this->source->getFQCLN()) . '::' . $function_name;
}
if ($this->function instanceof Function_) {
$namespace = $this->source->getNamespace();
return ($namespace ? $namespace . '\\' : '') . $this->function->name;
}
return $this->getMethodId();
}
2017-09-04 02:52:54 +02:00
/**
* @return FunctionLikeStorage
*/
2018-11-11 18:01:14 +01:00
public function getFunctionLikeStorage(StatementsAnalyzer $statements_analyzer = null)
2017-09-04 02:52:54 +02:00
{
2018-11-06 03:57:36 +01:00
$codebase = $this->codebase;
2017-09-04 02:52:54 +02:00
if ($this->function instanceof ClassMethod) {
$method_id = (string) $this->getMethodId();
2018-02-04 00:52:35 +01:00
$codebase_methods = $codebase->methods;
try {
2018-02-04 00:52:35 +01:00
return $codebase_methods->getStorage($method_id);
} catch (\UnexpectedValueException $e) {
$declaring_method_id = $codebase_methods->getDeclaringMethodId($method_id);
if (!$declaring_method_id) {
throw new \UnexpectedValueException('Cannot get storage for function that doesnt exist');
}
2017-09-04 02:52:54 +02:00
// happens for fake constructors
2018-02-04 00:52:35 +01:00
return $codebase_methods->getStorage($declaring_method_id);
2017-09-04 02:52:54 +02:00
}
}
2018-11-11 18:01:14 +01:00
return $codebase->functions->getStorage($statements_analyzer, (string) $this->getMethodId());
2017-09-04 02:52:54 +02:00
}
2016-11-13 00:51:48 +01:00
/**
* @return array<string, string>
*/
public function getAliasedClassesFlipped()
{
2018-11-06 03:57:36 +01:00
if ($this->source instanceof NamespaceAnalyzer ||
$this->source instanceof FileAnalyzer ||
$this->source instanceof ClassLikeAnalyzer
) {
2016-11-13 17:24:46 +01:00
return $this->source->getAliasedClassesFlipped();
}
return [];
2016-11-13 00:51:48 +01:00
}
2019-06-06 04:13:33 +02:00
/**
* @return array<string, string>
*/
public function getAliasedClassesFlippedReplaceable()
{
if ($this->source instanceof NamespaceAnalyzer ||
$this->source instanceof FileAnalyzer ||
$this->source instanceof ClassLikeAnalyzer
) {
return $this->source->getAliasedClassesFlippedReplaceable();
}
return [];
}
2016-11-02 07:29:00 +01:00
/**
2017-01-07 20:35:07 +01:00
* @return string|null
2016-11-02 07:29:00 +01:00
*/
2016-11-08 01:16:51 +01:00
public function getFQCLN()
2016-08-14 05:26:45 +02:00
{
2017-01-07 20:35:07 +01:00
return $this->source->getFQCLN();
2016-08-14 05:26:45 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return null|string
*/
2016-08-14 05:26:45 +02:00
public function getClassName()
{
2017-01-07 20:35:07 +01:00
return $this->source->getClassName();
2016-08-14 05:26:45 +02:00
}
/**
* @return array<string, array<string, array{Type\Union}>>|null
*/
public function getTemplateTypeMap()
{
if ($this->source instanceof ClassLikeAnalyzer) {
return ($this->source->getTemplateTypeMap() ?: [])
+ ($this->storage->template_types ?: []);
}
return $this->storage->template_types;
}
/**
* @return string|null
*/
2017-01-07 20:35:07 +01:00
public function getParentFQCLN()
2016-08-14 05:26:45 +02:00
{
2017-01-07 20:35:07 +01:00
return $this->source->getParentFQCLN();
2016-08-14 05:26:45 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return bool
*/
2016-08-14 05:26:45 +02:00
public function isStatic()
{
return $this->is_static;
}
2016-10-15 06:12:57 +02:00
/**
* @return StatementsSource
*/
2016-08-14 05:26:45 +02:00
public function getSource()
{
return $this->source;
}
2018-11-06 03:57:36 +01:00
public function getCodebase() : Codebase
{
return $this->codebase;
}
2017-01-07 20:35:07 +01:00
/**
* Get a list of suppressed issues
*
* @return array<string>
*/
public function getSuppressedIssues()
{
return $this->suppressed_issues;
}
/**
* @param array<int, string> $new_issues
*
* @return void
*/
public function addSuppressedIssues(array $new_issues)
{
if (isset($new_issues[0])) {
$new_issues = \array_combine($new_issues, $new_issues);
}
$this->suppressed_issues = $new_issues + $this->suppressed_issues;
}
/**
* @param array<int, string> $new_issues
*
* @return void
*/
public function removeSuppressedIssues(array $new_issues)
{
if (isset($new_issues[0])) {
$new_issues = \array_combine($new_issues, $new_issues);
}
$this->suppressed_issues = \array_diff_key($this->suppressed_issues, $new_issues);
}
2017-07-26 22:09:09 +02:00
/**
* Adds a suppressed issue, useful when creating a method checker from scratch
*
2017-07-27 05:47:29 +02:00
* @param string $issue_name
*
2017-07-26 22:09:09 +02:00
* @return void
*/
2017-07-27 05:47:29 +02:00
public function addSuppressedIssue($issue_name)
2017-07-26 22:09:09 +02:00
{
$this->suppressed_issues[] = $issue_name;
}
/**
* @return void
*/
public static function clearCache()
{
self::$no_effects_hashes = [];
}
2018-01-14 18:09:40 +01:00
/**
* @return Type\Union
*/
public function getLocalReturnType(Type\Union $storage_return_type)
{
if ($this->local_return_type) {
return $this->local_return_type;
}
2018-11-06 03:57:36 +01:00
$this->local_return_type = ExpressionAnalyzer::fleshOutType(
$this->codebase,
2018-01-14 18:09:40 +01:00
$storage_return_type,
$this->getFQCLN(),
$this->getFQCLN(),
$this->getParentFQCLN()
2018-01-14 18:09:40 +01:00
);
return $this->local_return_type;
}
2016-08-14 05:26:45 +02:00
}