1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-12 09:19:40 +01:00
psalm/src/Psalm/Internal/Analyzer/ClosureAnalyzer.php

345 lines
12 KiB
PHP
Raw Normal View History

2018-11-06 03:57:36 +01:00
<?php
2018-11-06 03:57:36 +01:00
namespace Psalm\Internal\Analyzer;
use PhpParser;
2020-05-18 21:13:27 +02:00
use Psalm\CodeLocation;
use Psalm\Context;
2021-12-03 20:11:20 +01:00
use Psalm\Internal\Codebase\VariableUseGraph;
2021-06-08 04:55:21 +02:00
use Psalm\Internal\DataFlow\DataFlowNode;
2021-12-03 20:11:20 +01:00
use Psalm\Internal\PhpVisitor\ShortClosureVisitor;
2020-05-18 21:13:27 +02:00
use Psalm\Issue\DuplicateParam;
use Psalm\Issue\PossiblyUndefinedVariable;
use Psalm\Issue\UndefinedVariable;
use Psalm\IssueBuffer;
use Psalm\Type;
use Psalm\Type\Atomic\TMixed;
2020-05-18 21:13:27 +02:00
use Psalm\Type\Atomic\TNamedObject;
2021-12-13 16:28:14 +01:00
use Psalm\Type\Union;
2021-06-08 04:55:21 +02:00
use function in_array;
use function is_string;
2020-11-10 22:19:24 +01:00
use function preg_match;
2021-06-08 04:55:21 +02:00
use function strpos;
use function strtolower;
/**
* @internal
* @extends FunctionLikeAnalyzer<PhpParser\Node\Expr\Closure|PhpParser\Node\Expr\ArrowFunction>
*/
2018-11-06 03:57:36 +01:00
class ClosureAnalyzer extends FunctionLikeAnalyzer
{
/**
* @param PhpParser\Node\Expr\Closure|PhpParser\Node\Expr\ArrowFunction $function
*/
public function __construct(PhpParser\Node\FunctionLike $function, SourceAnalyzer $source)
{
$codebase = $source->getCodebase();
2021-12-03 21:07:25 +01:00
$function_id = strtolower($source->getFilePath())
. ':' . $function->getLine()
. ':' . (int)$function->getAttribute('startFilePos')
. ':-:closure';
$storage = $codebase->getClosureStorage($source->getFilePath(), $function_id);
parent::__construct($function, $source, $storage);
}
/** @psalm-mutation-free */
public function getTemplateTypeMap(): ?array
{
return $this->source->getTemplateTypeMap();
}
/**
2020-05-15 16:18:05 +02:00
* @return non-empty-lowercase-string
*/
public function getClosureId(): string
{
return strtolower($this->getFilePath())
. ':' . $this->function->getLine()
. ':' . (int)$this->function->getAttribute('startFilePos')
. ':-:closure';
}
2020-05-18 21:13:27 +02:00
/**
* @param PhpParser\Node\Expr\Closure|PhpParser\Node\Expr\ArrowFunction $stmt
*/
public static function analyzeExpression(
StatementsAnalyzer $statements_analyzer,
PhpParser\Node\FunctionLike $stmt,
Context $context
): bool {
2020-05-18 21:13:27 +02:00
$closure_analyzer = new ClosureAnalyzer($stmt, $statements_analyzer);
if ($stmt instanceof PhpParser\Node\Expr\Closure
&& self::analyzeClosureUses($statements_analyzer, $stmt, $context) === false
) {
return false;
}
$use_context = new Context($context->self);
$codebase = $statements_analyzer->getCodebase();
if (!$statements_analyzer->isStatic()) {
if ($context->collect_mutations &&
$context->self &&
$codebase->classExtends(
$context->self,
(string)$statements_analyzer->getFQCLN()
)
) {
/** @psalm-suppress PossiblyUndefinedStringArrayOffset */
$use_context->vars_in_scope['$this'] = $context->vars_in_scope['$this'];
2020-05-18 21:13:27 +02:00
} elseif ($context->self) {
2022-10-03 13:58:01 +02:00
$this_atomic = new TNamedObject($context->self, true);
2020-05-22 19:32:26 +02:00
2021-12-13 16:28:14 +01:00
$use_context->vars_in_scope['$this'] = new Union([$this_atomic]);
2020-05-18 21:13:27 +02:00
}
}
foreach ($context->vars_in_scope as $var => $type) {
if (strpos($var, '$this->') === 0) {
$use_context->vars_in_scope[$var] = $type;
2020-05-18 21:13:27 +02:00
}
}
if ($context->self) {
$self_class_storage = $codebase->classlike_storage_provider->get($context->self);
ClassAnalyzer::addContextProperties(
$statements_analyzer,
$self_class_storage,
$use_context,
$context->self,
$statements_analyzer->getParentFQCLN()
);
}
foreach ($context->vars_possibly_in_scope as $var => $_) {
if (strpos($var, '$this->') === 0) {
$use_context->vars_possibly_in_scope[$var] = true;
}
}
if ($stmt instanceof PhpParser\Node\Expr\Closure) {
foreach ($stmt->uses as $use) {
if (!is_string($use->var->name)) {
continue;
}
$use_var_id = '$' . $use->var->name;
// insert the ref into the current context if passed by ref, as whatever we're passing
// the closure to could execute it straight away.
2021-09-25 02:34:21 +02:00
if ($use->byRef && !$context->hasVariable($use_var_id)) {
$context->vars_in_scope[$use_var_id] = new Union([new TMixed()], ['by_ref' => true]);
2020-05-18 21:13:27 +02:00
}
2021-12-03 20:11:20 +01:00
if ($statements_analyzer->data_flow_graph instanceof VariableUseGraph
2021-02-21 02:15:46 +01:00
&& $context->hasVariable($use_var_id)
) {
$parent_nodes = $context->vars_in_scope[$use_var_id]->parent_nodes;
foreach ($parent_nodes as $parent_node) {
$statements_analyzer->data_flow_graph->addPath(
$parent_node,
new DataFlowNode('closure-use', 'closure use', null),
'closure-use'
);
}
}
2020-05-18 21:13:27 +02:00
$use_context->vars_in_scope[$use_var_id] =
$context->hasVariable($use_var_id) && !$use->byRef
? $context->vars_in_scope[$use_var_id]
2020-05-18 21:13:27 +02:00
: Type::getMixed();
if ($use->byRef) {
$use_context->vars_in_scope[$use_var_id] =
$use_context->vars_in_scope[$use_var_id]->setProperties(['by_ref' => true]);
$use_context->references_to_external_scope[$use_var_id] = true;
}
2020-05-18 21:13:27 +02:00
$use_context->vars_possibly_in_scope[$use_var_id] = true;
foreach ($context->vars_in_scope as $var_id => $type) {
if (preg_match('/^\$' . $use->var->name . '[\[\-]/', $var_id)) {
$use_context->vars_in_scope[$var_id] = $type;
$use_context->vars_possibly_in_scope[$var_id] = true;
}
}
2020-05-18 21:13:27 +02:00
}
} else {
$traverser = new PhpParser\NodeTraverser;
2021-12-03 20:11:20 +01:00
$short_closure_visitor = new ShortClosureVisitor();
2020-05-18 21:13:27 +02:00
$traverser->addVisitor($short_closure_visitor);
$traverser->traverse($stmt->getStmts());
foreach ($short_closure_visitor->getUsedVariables() as $use_var_id => $_) {
if ($context->hasVariable($use_var_id)) {
$use_context->vars_in_scope[$use_var_id] = $context->vars_in_scope[$use_var_id];
2021-12-03 20:11:20 +01:00
if ($statements_analyzer->data_flow_graph instanceof VariableUseGraph) {
$parent_nodes = $context->vars_in_scope[$use_var_id]->parent_nodes;
foreach ($parent_nodes as $parent_node) {
$statements_analyzer->data_flow_graph->addPath(
$parent_node,
new DataFlowNode('closure-use', 'closure use', null),
'closure-use'
);
}
}
}
2020-05-18 21:13:27 +02:00
$use_context->vars_possibly_in_scope[$use_var_id] = true;
}
}
$use_context->calling_method_id = $context->calling_method_id;
2020-11-13 19:13:29 +01:00
$closure_analyzer->analyze($use_context, $statements_analyzer->node_data, $context, false);
2020-05-18 21:13:27 +02:00
if ($closure_analyzer->inferred_impure
2021-12-03 20:11:20 +01:00
&& $statements_analyzer->getSource() instanceof FunctionLikeAnalyzer
) {
$statements_analyzer->getSource()->inferred_impure = true;
}
if ($closure_analyzer->inferred_has_mutation
2021-12-03 20:11:20 +01:00
&& $statements_analyzer->getSource() instanceof FunctionLikeAnalyzer
) {
$statements_analyzer->getSource()->inferred_has_mutation = true;
}
2020-05-18 21:13:27 +02:00
if (!$statements_analyzer->node_data->getType($stmt)) {
$statements_analyzer->node_data->setType($stmt, Type::getClosure());
}
return true;
}
/**
* @return false|null
*/
public static function analyzeClosureUses(
StatementsAnalyzer $statements_analyzer,
PhpParser\Node\Expr\Closure $stmt,
Context $context
): ?bool {
$param_names = [];
foreach ($stmt->params as $i => $param) {
if ($param->var instanceof PhpParser\Node\Expr\Variable && is_string($param->var->name)) {
$param_names[$i] = $param->var->name;
} else {
$param_names[$i] = '';
}
}
2020-05-18 21:13:27 +02:00
foreach ($stmt->uses as $use) {
if (!is_string($use->var->name)) {
continue;
}
$use_var_id = '$' . $use->var->name;
if (in_array($use->var->name, $param_names)) {
if (IssueBuffer::accepts(
new DuplicateParam(
'Closure use duplicates param name ' . $use_var_id,
new CodeLocation($statements_analyzer->getSource(), $use->var)
),
$statements_analyzer->getSuppressedIssues()
)) {
return false;
}
}
if (!$context->hasVariable($use_var_id)) {
2020-05-18 21:13:27 +02:00
if ($use_var_id === '$argv' || $use_var_id === '$argc') {
continue;
}
if ($use->byRef) {
$context->vars_in_scope[$use_var_id] = Type::getMixed();
$context->vars_possibly_in_scope[$use_var_id] = true;
if (!$statements_analyzer->hasVariable($use_var_id)) {
$statements_analyzer->registerVariable(
$use_var_id,
new CodeLocation($statements_analyzer, $use->var),
null
);
}
return null;
2020-05-18 21:13:27 +02:00
}
if (!isset($context->vars_possibly_in_scope[$use_var_id])) {
if ($context->check_variables) {
if (IssueBuffer::accepts(
new UndefinedVariable(
'Cannot find referenced variable ' . $use_var_id,
new CodeLocation($statements_analyzer->getSource(), $use->var)
),
$statements_analyzer->getSuppressedIssues()
)) {
return false;
}
return null;
}
}
$first_appearance = $statements_analyzer->getFirstAppearance($use_var_id);
if ($first_appearance) {
if (IssueBuffer::accepts(
new PossiblyUndefinedVariable(
'Possibly undefined variable ' . $use_var_id . ', first seen on line ' .
$first_appearance->getLineNumber(),
new CodeLocation($statements_analyzer->getSource(), $use->var)
),
$statements_analyzer->getSuppressedIssues()
)) {
return false;
}
continue;
}
if ($context->check_variables) {
if (IssueBuffer::accepts(
new UndefinedVariable(
'Cannot find referenced variable ' . $use_var_id,
new CodeLocation($statements_analyzer->getSource(), $use->var)
),
$statements_analyzer->getSuppressedIssues()
)) {
return false;
}
continue;
}
} elseif ($use->byRef) {
$new_type = new Union([new TMixed()], [
'parent_nodes' => $context->vars_in_scope[$use_var_id]->parent_nodes
]);
2020-05-18 21:13:27 +02:00
$context->remove($use_var_id);
$context->vars_in_scope[$use_var_id] = $new_type;
2020-05-18 21:13:27 +02:00
}
}
return null;
}
2018-11-06 03:57:36 +01:00
}