1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-16 11:26:55 +01:00
psalm/src/Psalm/Checker/Statements/Block/ForeachChecker.php

250 lines
9.4 KiB
PHP
Raw Normal View History

2016-10-22 19:23:18 +02:00
<?php
namespace Psalm\Checker\Statements\Block;
use PhpParser;
use Psalm\CodeLocation;
2016-10-22 19:23:18 +02:00
use Psalm\Context;
use Psalm\IssueBuffer;
use Psalm\Checker\ClassChecker;
use Psalm\Checker\ClassLikeChecker;
use Psalm\Checker\CommentChecker;
use Psalm\Checker\MethodChecker;
use Psalm\Checker\Statements\ExpressionChecker;
use Psalm\Checker\Statements\Expression\AssignmentChecker;
2016-11-02 07:29:00 +01:00
use Psalm\Checker\StatementsChecker;
2016-10-22 19:23:18 +02:00
use Psalm\Issue\InvalidIterator;
2016-11-02 07:29:00 +01:00
use Psalm\Issue\NullReference;
2016-10-22 19:23:18 +02:00
use Psalm\Type;
class ForeachChecker
{
/**
2016-11-02 07:29:00 +01:00
* @param StatementsChecker $statements_checker
* @param PhpParser\Node\Stmt\Foreach_ $stmt
* @param Context $context
* @return false|null
2016-10-22 19:23:18 +02:00
*/
public static function analyze(
2016-11-02 07:29:00 +01:00
StatementsChecker $statements_checker,
PhpParser\Node\Stmt\Foreach_ $stmt,
Context $context
) {
if (ExpressionChecker::analyze($statements_checker, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
$foreach_context = clone $context;
2017-03-13 16:23:26 +01:00
$foreach_context->inside_loop = true;
2016-10-22 19:23:18 +02:00
$key_type = null;
$value_type = null;
$var_id = ExpressionChecker::getVarId(
$stmt->expr,
2016-11-08 01:16:51 +01:00
$statements_checker->getFQCLN(),
2017-01-07 20:35:07 +01:00
$statements_checker
2016-10-22 19:23:18 +02:00
);
if (isset($stmt->expr->inferredType)) {
/** @var Type\Union */
$iterator_type = $stmt->expr->inferredType;
} elseif ($foreach_context->hasVariable($var_id)) {
2016-10-22 19:23:18 +02:00
$iterator_type = $foreach_context->vars_in_scope[$var_id];
2016-11-02 07:29:00 +01:00
} else {
2016-10-22 19:23:18 +02:00
$iterator_type = null;
}
if ($iterator_type) {
foreach ($iterator_type->types as $iterator_type) {
2016-10-22 19:23:18 +02:00
// if it's an empty array, we cannot iterate over it
if ((string) $iterator_type === 'array<empty, empty>') {
2016-10-22 19:23:18 +02:00
continue;
}
if ($iterator_type instanceof Type\Atomic\TArray) {
2016-10-22 19:23:18 +02:00
if (!$value_type) {
$value_type = $iterator_type->type_params[1];
2016-11-02 07:29:00 +01:00
} else {
$value_type = Type::combineUnionTypes($value_type, $iterator_type->type_params[1]);
2016-10-22 19:23:18 +02:00
}
$key_type_part = $iterator_type->type_params[0];
2016-10-22 19:23:18 +02:00
if (!$key_type) {
$key_type = $key_type_part;
} else {
$key_type = Type::combineUnionTypes($key_type, $key_type_part);
2016-10-22 19:23:18 +02:00
}
continue;
}
if ($iterator_type instanceof Type\Atomic\Scalar ||
$iterator_type instanceof Type\Atomic\TNull ||
$iterator_type instanceof Type\Atomic\TVoid
) {
if (IssueBuffer::accepts(
new InvalidIterator(
'Cannot iterate over ' . $iterator_type->getKey(),
new CodeLocation($statements_checker->getSource(), $stmt->expr)
),
$statements_checker->getSuppressedIssues()
)) {
return false;
}
2016-10-22 19:23:18 +02:00
$value_type = Type::getMixed();
} elseif ($iterator_type instanceof Type\Atomic\TArray ||
$iterator_type instanceof Type\Atomic\TObject ||
$iterator_type instanceof Type\Atomic\TMixed ||
$iterator_type instanceof Type\Atomic\TEmpty
) {
$value_type = Type::getMixed();
} elseif ($iterator_type instanceof Type\Atomic\TNamedObject) {
if ($iterator_type->value !== 'Traversable' &&
$iterator_type->value !== $statements_checker->getClassName()
) {
if (ClassLikeChecker::checkFullyQualifiedClassLikeName(
$iterator_type->value,
$statements_checker->getFileChecker(),
new CodeLocation($statements_checker->getSource(), $stmt->expr),
2016-10-22 19:23:18 +02:00
$statements_checker->getSuppressedIssues()
) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
}
2016-11-02 07:29:00 +01:00
if ($iterator_type instanceof Type\Atomic\TGenericObject &&
(strtolower($iterator_type->value) === 'iterable' ||
strtolower($iterator_type->value) === 'traversable' ||
ClassChecker::classImplements(
$iterator_type->value,
'Traversable'
))
) {
$value_index = count($iterator_type->type_params) - 1;
$value_type_part = $iterator_type->type_params[$value_index];
if (!$value_type) {
$value_type = $value_type_part;
} else {
$value_type = Type::combineUnionTypes($value_type, $value_type_part);
}
if ($value_index) {
$key_type_part = $iterator_type->type_params[0];
if (!$key_type) {
$key_type = $key_type_part;
} else {
$key_type = Type::combineUnionTypes($key_type, $key_type_part);
}
}
continue;
}
if (ClassChecker::classImplements(
$iterator_type->value,
'Iterator'
)) {
$iterator_method = $iterator_type->value . '::current';
$iterator_class_type = MethodChecker::getMethodReturnType($iterator_method);
if ($iterator_class_type) {
$value_type_part = ExpressionChecker::fleshOutTypes(
clone $iterator_class_type,
$iterator_type->value,
$iterator_method
);
2017-01-09 06:56:51 +01:00
if (!$value_type) {
$value_type = $value_type_part;
2016-11-02 07:29:00 +01:00
} else {
$value_type = Type::combineUnionTypes($value_type, $value_type_part);
2016-10-22 19:23:18 +02:00
}
} else {
$value_type = Type::getMixed();
2016-10-22 19:23:18 +02:00
}
}
2016-10-22 19:23:18 +02:00
}
}
}
$before_context = clone $foreach_context;
if ($stmt->keyVar && $stmt->keyVar instanceof PhpParser\Node\Expr\Variable && is_string($stmt->keyVar->name)) {
$key_var_id = '$' . $stmt->keyVar->name;
$foreach_context->vars_in_scope[$key_var_id] = $key_type ?: Type::getMixed();
$foreach_context->vars_possibly_in_scope[$key_var_id] = true;
if (!$statements_checker->hasVariable($key_var_id)) {
$statements_checker->registerVariable(
$key_var_id,
2017-02-08 00:18:33 +01:00
new CodeLocation($statements_checker, $stmt->keyVar)
);
}
2016-10-22 19:23:18 +02:00
}
AssignmentChecker::analyze(
$statements_checker,
$stmt->valueVar,
null,
$value_type ?: Type::getMixed(),
$foreach_context,
(string)$stmt->getDocComment()
);
2016-10-22 19:23:18 +02:00
2017-03-02 04:27:52 +01:00
$doc_comment_text = (string)$stmt->getDocComment();
if ($doc_comment_text) {
CommentChecker::getTypeFromComment(
$doc_comment_text,
$foreach_context,
$statements_checker->getSource(),
null
);
}
2016-10-22 19:23:18 +02:00
$changed_vars = Context::getNewOrUpdatedVarIds($before_context, $foreach_context);
$statements_checker->analyzeLoop($stmt->stmts, $changed_vars, $foreach_context, $context);
2016-10-22 19:23:18 +02:00
foreach ($context->vars_in_scope as $var => $type) {
if ($type->isMixed()) {
continue;
}
if (!isset($foreach_context->vars_in_scope[$var])) {
2016-10-22 19:23:18 +02:00
unset($context->vars_in_scope[$var]);
continue;
}
if ($foreach_context->vars_in_scope[$var]->isMixed()) {
$context->vars_in_scope[$var] = $foreach_context->vars_in_scope[$var];
}
if ((string) $foreach_context->vars_in_scope[$var] !== (string) $type) {
2016-11-02 07:29:00 +01:00
$context->vars_in_scope[$var] = Type::combineUnionTypes(
$context->vars_in_scope[$var],
$foreach_context->vars_in_scope[$var]
);
2017-04-02 21:26:10 +02:00
$context->removeVarFromConflictingClauses($var);
2016-10-22 19:23:18 +02:00
}
}
2016-11-02 07:29:00 +01:00
$context->vars_possibly_in_scope = array_merge(
$foreach_context->vars_possibly_in_scope,
$context->vars_possibly_in_scope
);
if ($context->collect_references) {
$context->referenced_vars = array_merge(
$foreach_context->referenced_vars,
$context->referenced_vars
);
}
2016-11-02 07:29:00 +01:00
return null;
2016-10-22 19:23:18 +02:00
}
}