1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-15 10:57:08 +01:00
psalm/src/Psalm/Internal/Analyzer/Statements/ExpressionAnalyzer.php

1863 lines
71 KiB
PHP
Raw Normal View History

2016-10-22 19:23:18 +02:00
<?php
2018-11-06 03:57:36 +01:00
namespace Psalm\Internal\Analyzer\Statements;
2016-10-22 19:23:18 +02:00
use PhpParser;
2018-11-06 03:57:36 +01:00
use Psalm\Codebase;
use Psalm\Internal\Analyzer\ClassLikeAnalyzer;
use Psalm\Internal\Analyzer\ClosureAnalyzer;
use Psalm\Internal\Analyzer\CommentAnalyzer;
use Psalm\Internal\Analyzer\FunctionLikeAnalyzer;
2019-02-06 21:52:43 +01:00
use Psalm\Internal\Analyzer\TraitAnalyzer;
2018-11-06 03:57:36 +01:00
use Psalm\Internal\Analyzer\Statements\Expression\ArrayAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\AssertionFinder;
use Psalm\Internal\Analyzer\Statements\Expression\AssignmentAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\BinaryOpAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\Call\FunctionCallAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\Call\MethodCallAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\Call\NewAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\Call\StaticCallAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\Fetch\ArrayFetchAnalyzer;
2019-09-14 19:12:54 +02:00
use Psalm\Internal\Analyzer\Statements\Expression\Fetch\ClassConstFetchAnalyzer;
2018-11-06 03:57:36 +01:00
use Psalm\Internal\Analyzer\Statements\Expression\Fetch\ConstFetchAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\Fetch\PropertyFetchAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\Fetch\VariableFetchAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\IncludeAnalyzer;
use Psalm\Internal\Analyzer\Statements\Expression\TernaryAnalyzer;
use Psalm\Internal\Analyzer\StatementsAnalyzer;
use Psalm\Internal\Analyzer\TypeAnalyzer;
use Psalm\CodeLocation;
2016-10-22 19:23:18 +02:00
use Psalm\Config;
use Psalm\Context;
use Psalm\Exception\DocblockParseException;
use Psalm\Internal\FileManipulation\FileManipulationBuffer;
use Psalm\FileSource;
2019-01-30 17:36:21 +01:00
use Psalm\Issue\DuplicateParam;
2016-10-22 19:23:18 +02:00
use Psalm\Issue\ForbiddenCode;
use Psalm\Issue\ImpurePropertyAssignment;
use Psalm\Issue\InvalidCast;
use Psalm\Issue\InvalidClone;
use Psalm\Issue\InvalidDocblock;
2019-04-13 16:11:25 +02:00
use Psalm\Issue\InvalidOperand;
use Psalm\Issue\PossiblyInvalidCast;
2019-04-13 16:11:25 +02:00
use Psalm\Issue\PossiblyInvalidOperand;
2016-10-22 19:23:18 +02:00
use Psalm\Issue\PossiblyUndefinedVariable;
use Psalm\Issue\UndefinedConstant;
2016-10-22 19:23:18 +02:00
use Psalm\Issue\UndefinedVariable;
use Psalm\Issue\UnnecessaryVarAnnotation;
2016-11-06 01:53:39 +01:00
use Psalm\Issue\UnrecognizedExpression;
2016-11-02 07:29:00 +01:00
use Psalm\IssueBuffer;
2016-10-22 19:23:18 +02:00
use Psalm\Type;
use Psalm\Type\Atomic\ObjectLike;
use Psalm\Type\Atomic\Scalar;
use Psalm\Type\Atomic\TArray;
use Psalm\Type\Atomic\TFloat;
2019-02-22 03:40:06 +01:00
use Psalm\Type\Atomic\TTemplateParam;
use Psalm\Type\Atomic\TInt;
use Psalm\Type\Atomic\TMixed;
use Psalm\Type\Atomic\TNamedObject;
use Psalm\Type\Atomic\TNull;
use Psalm\Type\Atomic\TObject;
use Psalm\Type\Atomic\TString;
use Psalm\Internal\Type\TypeCombination;
use function strpos;
use function is_string;
use function in_array;
use function strtolower;
use function get_class;
use function count;
use function implode;
use function is_array;
use function array_merge;
use function array_values;
use function array_map;
2016-10-22 19:23:18 +02:00
/**
* @internal
*/
2018-11-06 03:57:36 +01:00
class ExpressionAnalyzer
2016-10-22 19:23:18 +02:00
{
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Expr $stmt
* @param Context $context
* @param bool $array_assignment
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return false|null
2016-10-22 19:23:18 +02:00
*/
public static function analyze(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-10-22 19:23:18 +02:00
PhpParser\Node\Expr $stmt,
Context $context,
$array_assignment = false,
Context $global_context = null
2016-10-22 19:23:18 +02:00
) {
2018-11-11 18:01:14 +01:00
$codebase = $statements_analyzer->getCodebase();
2018-11-06 03:57:36 +01:00
2016-10-22 19:23:18 +02:00
if ($stmt instanceof PhpParser\Node\Expr\Variable) {
2018-11-06 03:57:36 +01:00
if (VariableFetchAnalyzer::analyze(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2018-01-14 18:09:40 +01:00
$stmt,
$context,
false,
null,
$array_assignment
) === false
) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Assign) {
2018-11-06 03:57:36 +01:00
$assignment_type = AssignmentAnalyzer::analyze(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2016-11-01 16:37:58 +01:00
$stmt->var,
$stmt->expr,
null,
2016-11-01 16:37:58 +01:00
$context,
$stmt->getDocComment()
2016-11-01 16:37:58 +01:00
);
if ($assignment_type === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-01 16:37:58 +01:00
$stmt->inferredType = $assignment_type;
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\AssignOp) {
2018-11-11 18:01:14 +01:00
if (AssignmentAnalyzer::analyzeAssignmentOperation($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\MethodCall) {
2018-11-11 18:01:14 +01:00
if (MethodCallAnalyzer::analyze($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\StaticCall) {
2018-11-11 18:01:14 +01:00
if (StaticCallAnalyzer::analyze($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\ConstFetch) {
2018-11-11 18:01:14 +01:00
ConstFetchAnalyzer::analyze($statements_analyzer, $stmt, $context);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Scalar\String_) {
$stmt->inferredType = Type::getString($stmt->value);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Scalar\EncapsedStringPart) {
2016-10-22 19:23:18 +02:00
// do nothing
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Scalar\MagicConst) {
if ($stmt instanceof PhpParser\Node\Scalar\MagicConst\Line) {
$stmt->inferredType = Type::getInt();
} elseif ($stmt instanceof PhpParser\Node\Scalar\MagicConst\Class_) {
if (!$context->self) {
if (IssueBuffer::accepts(
new UndefinedConstant(
'Cannot get __class__ outside a class',
new CodeLocation($statements_analyzer->getSource(), $stmt)
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
$stmt->inferredType = Type::getClassString();
} else {
if ($codebase->alter_code) {
2019-06-14 21:55:23 +02:00
$codebase->classlikes->handleClassLikeReferenceInMigration(
$codebase,
$statements_analyzer,
$stmt,
$context->self,
$context->calling_method_id
);
}
$stmt->inferredType = Type::getLiteralClassString($context->self);
}
} elseif ($stmt instanceof PhpParser\Node\Scalar\MagicConst\Namespace_) {
$namespace = $statements_analyzer->getNamespace();
if ($namespace === null
&& IssueBuffer::accepts(
2019-02-18 19:14:08 +01:00
new UndefinedConstant(
'Cannot get __namespace__ outside a namespace',
new CodeLocation($statements_analyzer->getSource(), $stmt)
),
$statements_analyzer->getSuppressedIssues()
)
) {
// fall through
}
2019-02-18 19:14:08 +01:00
$stmt->inferredType = Type::getString($namespace);
} elseif ($stmt instanceof PhpParser\Node\Scalar\MagicConst\File
|| $stmt instanceof PhpParser\Node\Scalar\MagicConst\Dir
|| $stmt instanceof PhpParser\Node\Scalar\MagicConst\Function_
|| $stmt instanceof PhpParser\Node\Scalar\MagicConst\Trait_
|| $stmt instanceof PhpParser\Node\Scalar\MagicConst\Method
) {
$stmt->inferredType = Type::getString();
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Scalar\LNumber) {
$stmt->inferredType = Type::getInt(false, $stmt->value);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Scalar\DNumber) {
$stmt->inferredType = Type::getFloat($stmt->value);
2017-01-26 04:02:19 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\UnaryMinus ||
$stmt instanceof PhpParser\Node\Expr\UnaryPlus
) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-07 21:29:47 +01:00
2017-01-26 04:02:19 +01:00
if (!isset($stmt->expr->inferredType)) {
$stmt->inferredType = new Type\Union([new TInt, new TFloat]);
} elseif ($stmt->expr->inferredType->isMixed()) {
$stmt->inferredType = Type::getMixed();
2017-01-26 04:02:19 +01:00
} else {
2017-01-26 04:23:06 +01:00
$acceptable_types = [];
foreach ($stmt->expr->inferredType->getTypes() as $type_part) {
2017-01-26 04:23:06 +01:00
if ($type_part instanceof TInt || $type_part instanceof TFloat) {
if ($type_part instanceof Type\Atomic\TLiteralInt
&& $stmt instanceof PhpParser\Node\Expr\UnaryMinus
) {
$type_part->value = -$type_part->value;
} elseif ($type_part instanceof Type\Atomic\TLiteralFloat
&& $stmt instanceof PhpParser\Node\Expr\UnaryMinus
) {
$type_part->value = -$type_part->value;
}
2017-01-26 04:23:06 +01:00
$acceptable_types[] = $type_part;
} elseif ($type_part instanceof TString) {
$acceptable_types[] = new TInt;
$acceptable_types[] = new TFloat;
} else {
$acceptable_types[] = new TInt;
2017-01-26 04:02:19 +01:00
}
2017-01-26 04:23:06 +01:00
}
$stmt->inferredType = new Type\Union($acceptable_types);
2017-01-26 04:02:19 +01:00
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Isset_) {
2018-11-11 18:01:14 +01:00
self::analyzeIsset($statements_analyzer, $stmt, $context);
$stmt->inferredType = Type::getBool();
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\ClassConstFetch) {
2019-09-14 19:12:54 +02:00
if (ClassConstFetchAnalyzer::analyze($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\PropertyFetch) {
2018-11-11 18:01:14 +01:00
if (PropertyFetchAnalyzer::analyzeInstance($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\StaticPropertyFetch) {
2018-11-11 18:01:14 +01:00
if (PropertyFetchAnalyzer::analyzeStatic($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\BitwiseNot) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2019-04-13 16:11:25 +02:00
if (!isset($stmt->expr->inferredType)) {
$stmt->inferredType = new Type\Union([new TInt(), new TString()]);
} elseif ($stmt->expr->inferredType->isMixed()) {
$stmt->inferredType = Type::getMixed();
} else {
$acceptable_types = [];
$unacceptable_type = null;
$has_valid_operand = false;
foreach ($stmt->expr->inferredType->getTypes() as $type_string => $type_part) {
if ($type_part instanceof TInt || $type_part instanceof TString) {
if ($type_part instanceof Type\Atomic\TLiteralInt) {
$type_part->value = ~$type_part->value;
} elseif ($type_part instanceof Type\Atomic\TLiteralString) {
$type_part->value = ~$type_part->value;
}
$acceptable_types[] = $type_part;
$has_valid_operand = true;
} elseif ($type_part instanceof TFloat) {
$type_part = ($type_part instanceof Type\Atomic\TLiteralFloat) ?
new Type\Atomic\TLiteralInt(~$type_part->value) :
new TInt;
$stmt->expr->inferredType->removeType($type_string);
$stmt->expr->inferredType->addType($type_part);
$acceptable_types[] = $type_part;
$has_valid_operand = true;
} elseif (!$unacceptable_type) {
$unacceptable_type = $type_part;
}
}
if ($unacceptable_type) {
$message = 'Cannot negate a non-numeric non-string type ' . $unacceptable_type;
if ($has_valid_operand) {
if (IssueBuffer::accepts(
new PossiblyInvalidOperand(
$message,
new CodeLocation($statements_analyzer, $stmt)
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
} else {
if (IssueBuffer::accepts(
new InvalidOperand(
$message,
new CodeLocation($statements_analyzer, $stmt)
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
}
$stmt->inferredType = Type::getMixed();
} else {
$stmt->inferredType = new Type\Union($acceptable_types);
}
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\BinaryOp) {
2018-11-06 03:57:36 +01:00
if (BinaryOpAnalyzer::analyze(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2017-02-13 00:06:18 +01:00
$stmt,
2017-02-13 01:07:25 +01:00
$context
2017-02-13 00:06:18 +01:00
) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-12-17 06:48:31 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\PostInc ||
$stmt instanceof PhpParser\Node\Expr\PostDec ||
$stmt instanceof PhpParser\Node\Expr\PreInc ||
$stmt instanceof PhpParser\Node\Expr\PreDec
) {
$was_inside_assignment = $context->inside_assignment;
$context->inside_assignment = true;
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->var, $context) === false) {
if (!$was_inside_assignment) {
$context->inside_assignment = false;
}
2016-10-22 19:23:18 +02:00
return false;
}
2016-12-25 00:44:11 +01:00
if (!$was_inside_assignment) {
$context->inside_assignment = false;
}
2016-12-25 00:44:11 +01:00
if (isset($stmt->var->inferredType)) {
$return_type = null;
$fake_right_expr = new PhpParser\Node\Scalar\LNumber(1, $stmt->getAttributes());
$fake_right_expr->inferredType = Type::getInt();
BinaryOpAnalyzer::analyzeNonDivArithmeticOp(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
$stmt->var,
$fake_right_expr,
$stmt,
$return_type,
$context
);
2016-12-25 00:44:11 +01:00
$stmt->inferredType = clone $stmt->var->inferredType;
$stmt->inferredType->from_calculation = true;
2018-05-08 23:42:02 +02:00
foreach ($stmt->inferredType->getTypes() as $atomic_type) {
if ($atomic_type instanceof Type\Atomic\TLiteralInt) {
$stmt->inferredType->addType(new Type\Atomic\TInt);
} elseif ($atomic_type instanceof Type\Atomic\TLiteralFloat) {
$stmt->inferredType->addType(new Type\Atomic\TFloat);
}
}
$var_id = self::getArrayVarId($stmt->var, null);
2019-08-30 18:36:35 +02:00
if ($var_id && $context->mutation_free && strpos($var_id, '->')) {
if (IssueBuffer::accepts(
new ImpurePropertyAssignment(
2019-08-30 18:36:35 +02:00
'Cannot assign to a property from a mutation-free context',
new CodeLocation($statements_analyzer, $stmt->var)
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
}
if ($var_id && isset($context->vars_in_scope[$var_id])) {
$context->vars_in_scope[$var_id] = $stmt->inferredType;
if ($context->collect_references && $stmt->var instanceof PhpParser\Node\Expr\Variable) {
2018-11-11 18:01:14 +01:00
$location = new CodeLocation($statements_analyzer, $stmt->var);
$context->assigned_var_ids[$var_id] = true;
$context->possibly_assigned_var_ids[$var_id] = true;
2018-11-11 18:01:14 +01:00
$statements_analyzer->registerVariableAssignment(
$var_id,
$location
);
$context->unreferenced_vars[$var_id] = [$location->getHash() => $location];
}
}
2016-12-25 00:44:11 +01:00
} else {
$stmt->inferredType = Type::getMixed();
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\New_) {
2018-11-11 18:01:14 +01:00
if (NewAnalyzer::analyze($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Array_) {
2018-11-11 18:01:14 +01:00
if (ArrayAnalyzer::analyze($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Scalar\Encapsed) {
2018-11-11 18:01:14 +01:00
if (self::analyzeEncapsulatedString($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\FuncCall) {
2018-11-06 03:57:36 +01:00
if (FunctionCallAnalyzer::analyze(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
$stmt,
$context
) === false
) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Ternary) {
2018-11-11 18:01:14 +01:00
if (TernaryAnalyzer::analyze($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\BooleanNot) {
2018-11-11 18:01:14 +01:00
if (self::analyzeBooleanNot($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Empty_) {
2018-11-11 18:01:14 +01:00
self::analyzeEmpty($statements_analyzer, $stmt, $context);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Closure) {
2018-11-11 18:01:14 +01:00
$closure_analyzer = new ClosureAnalyzer($stmt, $statements_analyzer);
2016-10-22 19:23:18 +02:00
2018-11-11 18:01:14 +01:00
if (self::analyzeClosureUses($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
$use_context = new Context($context->self);
$use_context->collect_references = $codebase->collect_references;
$use_context->mutation_free = $context->mutation_free;
$use_context->external_mutation_free = $context->external_mutation_free;
$use_context->pure = $context->pure;
2016-10-22 19:23:18 +02:00
2018-11-11 18:01:14 +01:00
if (!$statements_analyzer->isStatic()) {
2017-01-12 06:54:41 +01:00
if ($context->collect_mutations &&
$context->self &&
2018-02-01 06:50:01 +01:00
$codebase->classExtends(
2017-01-12 06:54:41 +01:00
$context->self,
2018-11-11 18:01:14 +01:00
(string)$statements_analyzer->getFQCLN()
)
2017-01-12 06:54:41 +01:00
) {
$use_context->vars_in_scope['$this'] = clone $context->vars_in_scope['$this'];
} elseif ($context->self) {
$use_context->vars_in_scope['$this'] = new Type\Union([new TNamedObject($context->self)]);
2016-10-22 19:23:18 +02:00
}
}
foreach ($context->vars_in_scope as $var => $type) {
if (strpos($var, '$this->') === 0) {
$use_context->vars_in_scope[$var] = clone $type;
}
}
2018-01-28 18:43:19 +01:00
foreach ($context->vars_possibly_in_scope as $var => $_) {
2016-10-22 19:23:18 +02:00
if (strpos($var, '$this->') === 0) {
$use_context->vars_possibly_in_scope[$var] = true;
}
}
$byref_uses = [];
2016-10-22 19:23:18 +02:00
foreach ($stmt->uses as $use) {
if (!is_string($use->var->name)) {
continue;
}
$use_var_id = '$' . $use->var->name;
if ($use->byRef) {
$byref_uses[$use_var_id] = true;
}
// insert the ref into the current context if passed by ref, as whatever we're passing
// the closure to could execute it straight away.
2018-11-11 18:01:14 +01:00
if (!$context->hasVariable($use_var_id, $statements_analyzer) && $use->byRef) {
$context->vars_in_scope[$use_var_id] = Type::getMixed();
}
$use_context->vars_in_scope[$use_var_id] =
2018-11-11 18:01:14 +01:00
$context->hasVariable($use_var_id, $statements_analyzer) && !$use->byRef
? clone $context->vars_in_scope[$use_var_id]
2016-11-02 07:29:00 +01:00
: Type::getMixed();
$use_context->vars_possibly_in_scope[$use_var_id] = true;
2016-10-22 19:23:18 +02:00
}
$use_context->calling_method_id = $context->calling_method_id;
$closure_analyzer->analyze($use_context, $context, false, $byref_uses);
2016-10-22 19:23:18 +02:00
2016-12-07 20:13:39 +01:00
if (!isset($stmt->inferredType)) {
$stmt->inferredType = Type::getClosure();
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\ArrayDimFetch) {
2018-11-06 03:57:36 +01:00
if (ArrayFetchAnalyzer::analyze(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2016-11-02 07:29:00 +01:00
$stmt,
$context
2016-11-02 07:29:00 +01:00
) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Cast\Int_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
$stmt->inferredType = Type::getInt();
} elseif ($stmt instanceof PhpParser\Node\Expr\Cast\Double) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
$stmt->inferredType = Type::getFloat();
} elseif ($stmt instanceof PhpParser\Node\Expr\Cast\Bool_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
$stmt->inferredType = Type::getBool();
} elseif ($stmt instanceof PhpParser\Node\Expr\Cast\String_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
if (isset($stmt->expr->inferredType)) {
self::castStringAttempt($statements_analyzer, $stmt->expr);
}
$stmt->inferredType = Type::getString();
if (isset($stmt->expr->inferredType) && $stmt->expr->inferredType->tainted) {
$stmt->inferredType->tainted = $stmt->expr->inferredType->tainted;
$stmt->inferredType->sources = $stmt->expr->inferredType->sources;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Cast\Object_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
$stmt->inferredType = new Type\Union([new TNamedObject('stdClass')]);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Cast\Array_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
$permissible_atomic_types = [];
$all_permissible = false;
if (isset($stmt->expr->inferredType)) {
$all_permissible = true;
foreach ($stmt->expr->inferredType->getTypes() as $type) {
if ($type instanceof Scalar) {
$permissible_atomic_types[] = new ObjectLike([new Type\Union([$type])]);
} elseif ($type instanceof TNull) {
$permissible_atomic_types[] = new TArray([Type::getEmpty(), Type::getEmpty()]);
} elseif ($type instanceof TArray) {
$permissible_atomic_types[] = clone $type;
} elseif ($type instanceof ObjectLike) {
$permissible_atomic_types[] = clone $type;
} else {
$all_permissible = false;
break;
}
}
}
if ($all_permissible) {
$stmt->inferredType = TypeCombination::combineTypes($permissible_atomic_types);
} else {
$stmt->inferredType = Type::getArray();
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Cast\Unset_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
$stmt->inferredType = Type::getNull();
} elseif ($stmt instanceof PhpParser\Node\Expr\Clone_) {
2018-11-11 18:01:14 +01:00
self::analyzeClone($statements_analyzer, $stmt, $context);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Instanceof_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
if ($stmt->class instanceof PhpParser\Node\Expr) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->class, $context) === false) {
return false;
}
} elseif (!in_array(strtolower($stmt->class->parts[0]), ['self', 'static', 'parent'], true)
2016-11-02 07:29:00 +01:00
) {
2016-10-22 19:23:18 +02:00
if ($context->check_classes) {
2018-11-06 03:57:36 +01:00
$fq_class_name = ClassLikeAnalyzer::getFQCLNFromNameObject(
2016-10-22 19:23:18 +02:00
$stmt->class,
2018-11-11 18:01:14 +01:00
$statements_analyzer->getAliases()
2016-10-22 19:23:18 +02:00
);
if ($codebase->store_node_types
&& $fq_class_name
&& !$context->collect_initializations
&& !$context->collect_mutations
) {
$codebase->analyzer->addNodeReference(
$statements_analyzer->getFilePath(),
$stmt->class,
$codebase->classlikes->classOrInterfaceExists($fq_class_name)
? $fq_class_name
: '*' . implode('\\', $stmt->class->parts)
);
}
2018-11-06 03:57:36 +01:00
if (ClassLikeAnalyzer::checkFullyQualifiedClassLikeName(
2018-11-11 18:01:14 +01:00
$statements_analyzer,
$fq_class_name,
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $stmt->class),
$statements_analyzer->getSuppressedIssues(),
false
2016-11-02 07:29:00 +01:00
) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2019-02-24 07:33:25 +01:00
2019-06-04 22:36:32 +02:00
if ($codebase->alter_code) {
$codebase->classlikes->handleClassLikeReferenceInMigration(
$codebase,
$statements_analyzer,
$stmt->class,
$fq_class_name,
$context->calling_method_id
);
}
2016-10-22 19:23:18 +02:00
}
}
2016-11-05 22:57:14 +01:00
$stmt->inferredType = Type::getBool();
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Exit_) {
2017-02-12 01:42:12 +01:00
if ($stmt->expr) {
$context->inside_call = true;
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2017-02-12 01:42:12 +01:00
return false;
}
$context->inside_call = false;
2017-02-12 01:42:12 +01:00
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Include_) {
2018-11-11 18:01:14 +01:00
IncludeAnalyzer::analyze($statements_analyzer, $stmt, $context, $global_context);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Eval_) {
2016-10-22 19:23:18 +02:00
$context->check_classes = false;
$context->check_variables = false;
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\AssignRef) {
2018-11-11 18:01:14 +01:00
if (AssignmentAnalyzer::analyzeAssignmentRef($statements_analyzer, $stmt, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\ErrorSuppress) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
return false;
}
$stmt->inferredType = isset($stmt->expr->inferredType) ? $stmt->expr->inferredType : null;
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\ShellExec) {
2016-10-22 19:23:18 +02:00
if (IssueBuffer::accepts(
new ForbiddenCode(
'Use of shell_exec',
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $stmt)
),
2018-11-11 18:01:14 +01:00
$statements_analyzer->getSuppressedIssues()
2016-10-22 19:23:18 +02:00
)) {
2019-03-23 15:58:26 +01:00
// continue
2016-10-22 19:23:18 +02:00
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Print_) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Yield_) {
2018-11-11 18:01:14 +01:00
self::analyzeYield($statements_analyzer, $stmt, $context);
2016-11-02 07:29:00 +01:00
} elseif ($stmt instanceof PhpParser\Node\Expr\YieldFrom) {
2018-11-11 18:01:14 +01:00
self::analyzeYieldFrom($statements_analyzer, $stmt, $context);
2018-10-07 02:11:19 +02:00
} elseif ($stmt instanceof PhpParser\Node\Expr\Error) {
// do nothing
2016-11-02 07:29:00 +01:00
} else {
2016-11-06 01:53:39 +01:00
if (IssueBuffer::accepts(
new UnrecognizedExpression(
'Psalm does not understand ' . get_class($stmt),
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $stmt)
2016-11-06 01:53:39 +01:00
),
2018-11-11 18:01:14 +01:00
$statements_analyzer->getSuppressedIssues()
2016-11-06 01:53:39 +01:00
)) {
return false;
}
2016-10-22 19:23:18 +02:00
}
if (!$context->inside_conditional
&& ($stmt instanceof PhpParser\Node\Expr\BinaryOp
|| $stmt instanceof PhpParser\Node\Expr\Instanceof_
|| $stmt instanceof PhpParser\Node\Expr\Assign
|| $stmt instanceof PhpParser\Node\Expr\BooleanNot
|| $stmt instanceof PhpParser\Node\Expr\Empty_
|| $stmt instanceof PhpParser\Node\Expr\Isset_
|| $stmt instanceof PhpParser\Node\Expr\FuncCall)
) {
AssertionFinder::scrapeAssertions(
$stmt,
$context->self,
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2018-11-06 03:57:36 +01:00
$codebase
);
}
2018-11-06 03:57:36 +01:00
$plugin_classes = $codebase->config->after_expression_checks;
if ($plugin_classes) {
$file_manipulations = [];
foreach ($plugin_classes as $plugin_fq_class_name) {
2018-11-06 03:57:36 +01:00
if ($plugin_fq_class_name::afterExpressionAnalysis(
$stmt,
$context,
2018-11-11 18:01:14 +01:00
$statements_analyzer->getSource(),
2018-11-06 03:57:36 +01:00
$codebase,
$file_manipulations
) === false) {
return false;
}
2016-10-22 19:23:18 +02:00
}
if ($file_manipulations) {
2018-11-11 18:01:14 +01:00
FileManipulationBuffer::add($statements_analyzer->getFilePath(), $file_manipulations);
}
2016-10-22 19:23:18 +02:00
}
2016-11-02 07:29:00 +01:00
return null;
2016-10-22 19:23:18 +02:00
}
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Expr $stmt
* @param Type\Union $by_ref_type
* @param Context $context
* @param bool $constrain_type
2017-05-27 02:16:18 +02:00
*
2016-10-22 19:23:18 +02:00
* @return void
*/
2016-11-02 07:29:00 +01:00
public static function assignByRefParam(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-11-02 07:29:00 +01:00
PhpParser\Node\Expr $stmt,
Type\Union $by_ref_type,
Type\Union $by_ref_out_type,
2017-10-28 21:33:29 +02:00
Context $context,
bool $constrain_type = true,
bool $prevent_null = false
2016-11-02 07:29:00 +01:00
) {
$var_id = self::getVarId(
$stmt,
2018-11-11 18:01:14 +01:00
$statements_analyzer->getFQCLN(),
$statements_analyzer
2016-11-02 07:29:00 +01:00
);
2016-10-22 19:23:18 +02:00
if ($var_id) {
if (!$by_ref_type->hasMixed() && $constrain_type) {
2018-11-06 03:57:36 +01:00
$context->byref_constraints[$var_id] = new \Psalm\Internal\ReferenceConstraint($by_ref_type);
}
2018-11-11 18:01:14 +01:00
if (!$context->hasVariable($var_id, $statements_analyzer)) {
$context->vars_possibly_in_scope[$var_id] = true;
2018-11-11 18:01:14 +01:00
if (!$statements_analyzer->hasVariable($var_id)) {
$location = new CodeLocation($statements_analyzer, $stmt);
$statements_analyzer->registerVariable($var_id, $location, null);
if ($constrain_type
&& $prevent_null
&& !$by_ref_type->isMixed()
&& !$by_ref_type->isNullable()
&& !strpos($var_id, '->')
&& !strpos($var_id, '::')
) {
if (IssueBuffer::accepts(
new \Psalm\Issue\NullReference(
'Not expecting null argument passed by reference',
new CodeLocation($statements_analyzer->getSource(), $stmt)
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
}
if ($context->collect_references) {
2018-06-17 02:01:33 +02:00
$context->unreferenced_vars[$var_id] = [$location->getHash() => $location];
}
2018-11-11 18:01:14 +01:00
$context->hasVariable($var_id, $statements_analyzer);
}
} elseif ($var_id === '$this') {
// don't allow changing $this
return;
} else {
$existing_type = $context->vars_in_scope[$var_id];
2017-04-02 23:37:56 +02:00
// removes dependent vars from $context
2017-04-02 23:37:56 +02:00
$context->removeDescendents(
$var_id,
$existing_type,
$by_ref_type,
2018-11-11 18:01:14 +01:00
$statements_analyzer
2017-04-02 23:37:56 +02:00
);
if ($existing_type->getId() !== 'array<empty, empty>') {
$context->vars_in_scope[$var_id] = clone $by_ref_out_type;
if (!isset($stmt->inferredType) || $stmt->inferredType->isEmpty()) {
$stmt->inferredType = clone $by_ref_type;
}
2017-05-25 04:07:49 +02:00
return;
}
}
$context->vars_in_scope[$var_id] = $by_ref_out_type;
2016-10-22 19:23:18 +02:00
if (!isset($stmt->inferredType) || $stmt->inferredType->isEmpty()) {
$stmt->inferredType = clone $by_ref_type;
}
}
2016-10-22 19:23:18 +02:00
}
/**
2018-01-14 18:09:40 +01:00
* @param PhpParser\Node\Expr $stmt
* @param string|null $this_class_name
* @param FileSource|null $source
2018-01-14 18:09:40 +01:00
* @param int|null &$nesting
2017-05-27 02:16:18 +02:00
*
2018-01-14 18:09:40 +01:00
* @return string|null
2016-10-22 19:23:18 +02:00
*/
2018-01-14 18:09:40 +01:00
public static function getVarId(
PhpParser\Node\Expr $stmt,
$this_class_name,
FileSource $source = null,
2018-01-14 18:09:40 +01:00
&$nesting = null
2016-10-22 19:23:18 +02:00
) {
2018-01-14 18:09:40 +01:00
if ($stmt instanceof PhpParser\Node\Expr\Variable && is_string($stmt->name)) {
return '$' . $stmt->name;
2016-10-22 19:23:18 +02:00
}
2018-01-14 18:09:40 +01:00
if ($stmt instanceof PhpParser\Node\Expr\StaticPropertyFetch
&& $stmt->name instanceof PhpParser\Node\Identifier
2018-01-14 18:09:40 +01:00
&& $stmt->class instanceof PhpParser\Node\Name
) {
if (count($stmt->class->parts) === 1
&& in_array(strtolower($stmt->class->parts[0]), ['self', 'static', 'parent'], true)
) {
if (!$this_class_name) {
$fq_class_name = $stmt->class->parts[0];
} else {
$fq_class_name = $this_class_name;
2016-10-22 19:23:18 +02:00
}
2016-11-02 07:29:00 +01:00
} else {
2018-01-14 18:09:40 +01:00
$fq_class_name = $source
2018-11-06 03:57:36 +01:00
? ClassLikeAnalyzer::getFQCLNFromNameObject(
2018-01-14 18:09:40 +01:00
$stmt->class,
$source->getAliases()
)
: implode('\\', $stmt->class->parts);
}
return $fq_class_name . '::$' . $stmt->name->name;
2018-01-14 18:09:40 +01:00
}
2016-10-22 19:23:18 +02:00
if ($stmt instanceof PhpParser\Node\Expr\PropertyFetch && $stmt->name instanceof PhpParser\Node\Identifier) {
2018-01-14 18:09:40 +01:00
$object_id = self::getVarId($stmt->var, $this_class_name, $source);
2017-03-20 07:05:58 +01:00
2018-01-14 18:09:40 +01:00
if (!$object_id) {
return null;
2016-10-22 19:23:18 +02:00
}
2018-01-14 18:09:40 +01:00
return $object_id . '->' . $stmt->name->name;
2016-10-22 19:23:18 +02:00
}
2018-01-14 18:09:40 +01:00
if ($stmt instanceof PhpParser\Node\Expr\ArrayDimFetch && $nesting !== null) {
++$nesting;
2017-05-25 04:07:49 +02:00
2018-01-14 18:09:40 +01:00
return self::getVarId($stmt->var, $this_class_name, $source, $nesting);
2016-10-22 19:23:18 +02:00
}
2016-11-02 07:29:00 +01:00
return null;
2016-10-22 19:23:18 +02:00
}
/**
2018-01-14 18:09:40 +01:00
* @param PhpParser\Node\Expr $stmt
* @param string|null $this_class_name
* @param FileSource|null $source
2017-05-27 02:16:18 +02:00
*
2018-01-14 18:09:40 +01:00
* @return string|null
2016-10-22 19:23:18 +02:00
*/
2018-01-14 18:09:40 +01:00
public static function getRootVarId(
PhpParser\Node\Expr $stmt,
$this_class_name,
FileSource $source = null
2016-10-22 19:23:18 +02:00
) {
2018-01-14 18:09:40 +01:00
if ($stmt instanceof PhpParser\Node\Expr\Variable
|| $stmt instanceof PhpParser\Node\Expr\StaticPropertyFetch
) {
2018-01-14 18:09:40 +01:00
return self::getVarId($stmt, $this_class_name, $source);
}
if ($stmt instanceof PhpParser\Node\Expr\PropertyFetch && $stmt->name instanceof PhpParser\Node\Identifier) {
2018-01-14 18:09:40 +01:00
$property_root = self::getRootVarId($stmt->var, $this_class_name, $source);
2018-01-14 18:09:40 +01:00
if ($property_root) {
return $property_root . '->' . $stmt->name->name;
2016-10-22 19:23:18 +02:00
}
2018-01-14 18:09:40 +01:00
}
2016-10-22 19:23:18 +02:00
2018-01-14 18:09:40 +01:00
if ($stmt instanceof PhpParser\Node\Expr\ArrayDimFetch) {
return self::getRootVarId($stmt->var, $this_class_name, $source);
}
2018-01-14 18:09:40 +01:00
return null;
}
2018-01-14 18:09:40 +01:00
/**
* @param PhpParser\Node\Expr $stmt
* @param string|null $this_class_name
* @param FileSource|null $source
2018-01-14 18:09:40 +01:00
*
* @return string|null
*/
public static function getArrayVarId(
PhpParser\Node\Expr $stmt,
$this_class_name,
FileSource $source = null
2018-01-14 18:09:40 +01:00
) {
if ($stmt instanceof PhpParser\Node\Expr\Assign) {
return self::getArrayVarId($stmt->var, $this_class_name, $source);
}
if ($stmt instanceof PhpParser\Node\Expr\ArrayDimFetch) {
2018-01-14 18:09:40 +01:00
$root_var_id = self::getArrayVarId($stmt->var, $this_class_name, $source);
$offset = null;
if ($root_var_id) {
if ($stmt->dim instanceof PhpParser\Node\Scalar\String_
|| $stmt->dim instanceof PhpParser\Node\Scalar\LNumber
) {
$offset = $stmt->dim instanceof PhpParser\Node\Scalar\String_
? '\'' . $stmt->dim->value . '\''
: $stmt->dim->value;
} elseif ($stmt->dim instanceof PhpParser\Node\Expr\Variable
&& is_string($stmt->dim->name)
) {
$offset = '$' . $stmt->dim->name;
} elseif ($stmt->dim instanceof PhpParser\Node\Expr\ConstFetch) {
$offset = implode('\\', $stmt->dim->name->parts);
} elseif (isset($stmt->dim->inferredType)) {
if ($stmt->dim->inferredType->isSingleStringLiteral()) {
$offset = '\'' . $stmt->dim->inferredType->getSingleStringLiteral()->value . '\'';
} elseif ($stmt->dim->inferredType->isSingleIntLiteral()) {
$offset = $stmt->dim->inferredType->getSingleIntLiteral()->value;
}
} elseif ($stmt->dim instanceof PhpParser\Node\Expr\ClassConstFetch
&& $stmt->dim->name instanceof PhpParser\Node\Identifier
) {
/** @var string|null */
$resolved_name = $stmt->dim->class->getAttribute('resolvedName');
if ($resolved_name) {
$offset = $resolved_name . '::' . $stmt->dim->name;
}
}
return $root_var_id && $offset !== null ? $root_var_id . '[' . $offset . ']' : null;
}
2018-01-14 18:09:40 +01:00
}
if ($stmt instanceof PhpParser\Node\Expr\PropertyFetch) {
$object_id = self::getArrayVarId($stmt->var, $this_class_name, $source);
if (!$object_id) {
return null;
}
if ($stmt->name instanceof PhpParser\Node\Identifier) {
return $object_id . '->' . $stmt->name;
} elseif (isset($stmt->name->inferredType) && $stmt->name->inferredType->isSingleStringLiteral()) {
return $object_id . '->' . $stmt->name->inferredType->getSingleStringLiteral()->value;
} else {
return null;
}
}
if ($stmt instanceof PhpParser\Node\Expr\ClassConstFetch
&& $stmt->name instanceof PhpParser\Node\Identifier
) {
/** @var string|null */
$resolved_name = $stmt->class->getAttribute('resolvedName');
if ($resolved_name) {
if (($resolved_name === 'self' || $resolved_name === 'static') && $this_class_name) {
$resolved_name = $this_class_name;
}
return $resolved_name . '::' . $stmt->name;
}
}
2018-04-28 19:25:44 +02:00
if ($stmt instanceof PhpParser\Node\Expr\MethodCall
&& $stmt->name instanceof PhpParser\Node\Identifier
&& !$stmt->args
) {
$config = \Psalm\Config::getInstance();
if ($config->memoize_method_calls) {
$lhs_var_name = self::getArrayVarId(
$stmt->var,
$this_class_name,
$source
);
if (!$lhs_var_name) {
return null;
}
return $lhs_var_name . '->' . strtolower($stmt->name->name) . '()';
}
}
2018-01-14 18:09:40 +01:00
return self::getVarId($stmt, $this_class_name, $source);
}
2016-10-22 19:23:18 +02:00
2018-01-14 18:09:40 +01:00
/**
* @param Type\Union $return_type
2018-01-26 19:51:00 +01:00
* @param string|null $self_class
* @param string|Type\Atomic\TNamedObject|Type\Atomic\TTemplateParam|null $static_class_type
2018-01-14 18:09:40 +01:00
*
* @return Type\Union
*/
public static function fleshOutType(
2018-11-06 03:57:36 +01:00
Codebase $codebase,
2018-01-14 18:09:40 +01:00
Type\Union $return_type,
?string $self_class,
$static_class_type,
2019-06-07 00:46:40 +02:00
?string $parent_class,
bool $evaluate = true
2018-01-14 18:09:40 +01:00
) {
$return_type = clone $return_type;
2016-10-22 19:23:18 +02:00
2018-01-14 18:09:40 +01:00
$new_return_type_parts = [];
2016-10-22 19:23:18 +02:00
foreach ($return_type->getTypes() as $return_type_part) {
$parts = self::fleshOutAtomicType(
2018-11-06 03:57:36 +01:00
$codebase,
$return_type_part,
2018-01-26 19:51:00 +01:00
$self_class,
$static_class_type,
2019-06-07 00:46:40 +02:00
$parent_class,
$evaluate
);
if (is_array($parts)) {
$new_return_type_parts = array_merge($new_return_type_parts, $parts);
} else {
$new_return_type_parts[] = $parts;
}
2016-10-22 19:23:18 +02:00
}
$fleshed_out_type = new Type\Union($new_return_type_parts);
$fleshed_out_type->from_docblock = $return_type->from_docblock;
$fleshed_out_type->ignore_nullable_issues = $return_type->ignore_nullable_issues;
$fleshed_out_type->ignore_falsable_issues = $return_type->ignore_falsable_issues;
$fleshed_out_type->possibly_undefined = $return_type->possibly_undefined;
$fleshed_out_type->by_ref = $return_type->by_ref;
$fleshed_out_type->initialized = $return_type->initialized;
$fleshed_out_type->had_template = $return_type->had_template;
$fleshed_out_type->sources = $return_type->sources;
$fleshed_out_type->tainted = $return_type->tainted;
return $fleshed_out_type;
2016-10-22 19:23:18 +02:00
}
/**
2017-03-02 04:27:52 +01:00
* @param Type\Atomic &$return_type
2018-01-26 19:51:00 +01:00
* @param string|null $self_class
* @param string|Type\Atomic\TNamedObject|Type\Atomic\TTemplateParam|null $static_class_type
2017-05-27 02:16:18 +02:00
*
* @return Type\Atomic|array<int, Type\Atomic>
2016-10-22 19:23:18 +02:00
*/
2018-01-26 19:51:00 +01:00
private static function fleshOutAtomicType(
2018-11-06 03:57:36 +01:00
Codebase $codebase,
Type\Atomic &$return_type,
?string $self_class,
$static_class_type,
2019-06-07 00:46:40 +02:00
?string $parent_class,
bool $evaluate = true
) {
if ($return_type instanceof TNamedObject
2019-02-22 03:40:06 +01:00
|| $return_type instanceof TTemplateParam
) {
if ($return_type->extra_types) {
$new_intersection_types = [];
foreach ($return_type->extra_types as &$extra_type) {
self::fleshOutAtomicType(
$codebase,
$extra_type,
$self_class,
$static_class_type,
2019-06-07 00:46:40 +02:00
$parent_class,
$evaluate
);
if ($extra_type instanceof TNamedObject && $extra_type->extra_types) {
$new_intersection_types = array_merge(
$new_intersection_types,
$extra_type->extra_types
);
$extra_type->extra_types = [];
}
}
if ($new_intersection_types) {
$return_type->extra_types = array_merge($return_type->extra_types, $new_intersection_types);
}
}
if ($return_type instanceof TNamedObject) {
$return_type_lc = strtolower($return_type->value);
if ($return_type_lc === 'static' || $return_type_lc === '$this') {
if (!$static_class_type) {
throw new \UnexpectedValueException(
'Cannot handle ' . $return_type->value . ' when $static_class is empty'
);
}
if (is_string($static_class_type)) {
$return_type->value = $static_class_type;
} else {
$return_type = clone $static_class_type;
}
} elseif ($return_type_lc === 'self') {
if (!$self_class) {
throw new \UnexpectedValueException(
'Cannot handle ' . $return_type->value . ' when $self_class is empty'
);
}
2016-10-22 19:23:18 +02:00
$return_type->value = $self_class;
} elseif ($return_type_lc === 'parent') {
if (!$parent_class) {
throw new \UnexpectedValueException(
'Cannot handle ' . $return_type->value . ' when $parent_class is empty'
);
}
$return_type->value = $parent_class;
} else {
$return_type->value = $codebase->classlikes->getUnAliasedName($return_type->value);
}
2016-10-22 19:23:18 +02:00
}
}
if ($return_type instanceof Type\Atomic\TScalarClassConstant) {
if ($return_type->fq_classlike_name === 'self' && $self_class) {
$return_type->fq_classlike_name = $self_class;
}
2019-06-07 00:46:40 +02:00
if ($evaluate && $codebase->classOrInterfaceExists($return_type->fq_classlike_name)) {
if (strtolower($return_type->const_name) === 'class') {
return new Type\Atomic\TLiteralClassString($return_type->fq_classlike_name);
}
$class_constant = $codebase->classlikes->getConstantForClass(
$return_type->fq_classlike_name,
$return_type->const_name,
\ReflectionProperty::IS_PRIVATE
);
if ($class_constant) {
if ($class_constant->isSingle()) {
$class_constant = clone $class_constant;
return array_values($class_constant->getTypes())[0];
}
}
}
return $return_type;
}
if ($return_type instanceof Type\Atomic\TKeyOfClassConstant
|| $return_type instanceof Type\Atomic\TValueOfClassConstant
) {
if ($return_type->fq_classlike_name === 'self' && $self_class) {
$return_type->fq_classlike_name = $self_class;
}
2019-06-07 00:46:40 +02:00
if ($evaluate && $codebase->classOrInterfaceExists($return_type->fq_classlike_name)) {
$class_constant_type = $codebase->classlikes->getConstantForClass(
$return_type->fq_classlike_name,
$return_type->const_name,
\ReflectionProperty::IS_PRIVATE
);
if ($class_constant_type) {
foreach ($class_constant_type->getTypes() as $const_type_atomic) {
if ($const_type_atomic instanceof Type\Atomic\ObjectLike
|| $const_type_atomic instanceof Type\Atomic\TArray
) {
if ($const_type_atomic instanceof Type\Atomic\ObjectLike) {
$const_type_atomic = $const_type_atomic->getGenericArrayType();
}
if ($return_type instanceof Type\Atomic\TKeyOfClassConstant) {
return array_values($const_type_atomic->type_params[0]->getTypes());
}
return array_values($const_type_atomic->type_params[1]->getTypes());
}
}
}
}
return $return_type;
}
if ($return_type instanceof Type\Atomic\TArray || $return_type instanceof Type\Atomic\TGenericObject) {
2016-10-22 19:23:18 +02:00
foreach ($return_type->type_params as &$type_param) {
2018-01-26 19:51:00 +01:00
$type_param = self::fleshOutType(
2018-11-06 03:57:36 +01:00
$codebase,
2018-01-26 19:51:00 +01:00
$type_param,
$self_class,
$static_class_type,
$parent_class
2018-01-26 19:51:00 +01:00
);
2016-10-22 19:23:18 +02:00
}
2018-03-07 19:54:46 +01:00
} elseif ($return_type instanceof Type\Atomic\ObjectLike) {
foreach ($return_type->properties as &$property_type) {
$property_type = self::fleshOutType(
2018-11-06 03:57:36 +01:00
$codebase,
2018-03-07 19:54:46 +01:00
$property_type,
$self_class,
$static_class_type,
$parent_class
2018-03-07 19:54:46 +01:00
);
}
2016-10-22 19:23:18 +02:00
}
2016-11-01 19:14:35 +01:00
2019-03-08 00:02:31 +01:00
if ($return_type instanceof Type\Atomic\TCallable) {
if ($return_type->params) {
foreach ($return_type->params as $param) {
if ($param->type) {
$param->type = self::fleshOutType(
$codebase,
$param->type,
$self_class,
$static_class_type,
$parent_class
2019-03-08 00:02:31 +01:00
);
}
}
}
if ($return_type->return_type) {
$return_type->return_type = self::fleshOutType(
$codebase,
$return_type->return_type,
$self_class,
$static_class_type,
$parent_class
2019-03-08 00:02:31 +01:00
);
}
}
2016-11-01 19:14:35 +01:00
return $return_type;
2016-10-22 19:23:18 +02:00
}
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Expr\Closure $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return false|null
2016-10-22 19:23:18 +02:00
*/
protected static function analyzeClosureUses(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-11-02 07:29:00 +01:00
PhpParser\Node\Expr\Closure $stmt,
Context $context
) {
2019-01-30 17:36:21 +01:00
$param_names = array_map(
function (PhpParser\Node\Param $p) : string {
if (!$p->var instanceof PhpParser\Node\Expr\Variable
|| !is_string($p->var->name)
) {
return '';
}
return $p->var->name;
},
$stmt->params
);
2016-11-01 19:14:35 +01:00
foreach ($stmt->uses as $use) {
2018-05-08 23:42:02 +02:00
if (!is_string($use->var->name)) {
continue;
}
$use_var_id = '$' . $use->var->name;
2019-01-30 17:36:21 +01:00
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;
}
}
2018-11-11 18:01:14 +01:00
if (!$context->hasVariable($use_var_id, $statements_analyzer)) {
2018-05-08 23:43:26 +02:00
if ($use_var_id === '$argv' || $use_var_id === '$argc') {
continue;
}
2016-11-01 19:14:35 +01:00
if ($use->byRef) {
$context->vars_in_scope[$use_var_id] = Type::getMixed();
$context->vars_possibly_in_scope[$use_var_id] = true;
2018-11-11 18:01:14 +01:00
if (!$statements_analyzer->hasVariable($use_var_id)) {
$statements_analyzer->registerVariable(
$use_var_id,
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer, $use->var),
null
);
}
2017-05-25 04:07:49 +02:00
2016-10-22 19:23:18 +02:00
return;
}
2018-05-08 23:43:26 +02:00
if (!isset($context->vars_possibly_in_scope[$use_var_id])) {
2016-11-01 19:14:35 +01:00
if ($context->check_variables) {
if (IssueBuffer::accepts(
2016-11-02 07:29:00 +01:00
new UndefinedVariable(
'Cannot find referenced variable ' . $use_var_id,
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $use->var)
),
2018-11-11 18:01:14 +01:00
$statements_analyzer->getSuppressedIssues()
)) {
return false;
}
2016-10-22 19:23:18 +02:00
2018-05-08 23:43:26 +02:00
return null;
}
}
2018-11-11 18:01:14 +01:00
$first_appearance = $statements_analyzer->getFirstAppearance($use_var_id);
2018-05-08 23:43:26 +02:00
if ($first_appearance) {
if (IssueBuffer::accepts(
new PossiblyUndefinedVariable(
'Possibly undefined variable ' . $use_var_id . ', first seen on line ' .
$first_appearance->getLineNumber(),
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $use->var)
2018-05-08 23:43:26 +02:00
),
2018-11-11 18:01:14 +01:00
$statements_analyzer->getSuppressedIssues()
2018-05-08 23:43:26 +02:00
)) {
return false;
}
continue;
}
if ($context->check_variables) {
if (IssueBuffer::accepts(
new UndefinedVariable(
'Cannot find referenced variable ' . $use_var_id,
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $use->var)
2018-05-08 23:43:26 +02:00
),
2018-11-11 18:01:14 +01:00
$statements_analyzer->getSuppressedIssues()
2018-05-08 23:43:26 +02:00
)) {
return false;
2016-11-01 19:14:35 +01:00
}
2018-05-08 23:43:26 +02:00
continue;
2016-11-01 19:14:35 +01:00
}
} elseif ($use->byRef) {
$context->remove($use_var_id);
$context->vars_in_scope[$use_var_id] = Type::getMixed();
2016-10-22 19:23:18 +02:00
}
}
2016-11-01 19:14:35 +01:00
2016-11-02 07:29:00 +01:00
return null;
}
2016-11-01 19:14:35 +01:00
2016-10-22 19:23:18 +02:00
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Expr\Yield_ $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return false|null
2016-10-22 19:23:18 +02:00
*/
protected static function analyzeYield(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-11-02 07:29:00 +01:00
PhpParser\Node\Expr\Yield_ $stmt,
Context $context
) {
$doc_comment = $stmt->getDocComment();
2017-03-02 04:27:52 +01:00
$var_comments = [];
$var_comment_type = null;
2018-11-11 18:01:14 +01:00
$codebase = $statements_analyzer->getCodebase();
2018-11-06 03:57:36 +01:00
if ($doc_comment) {
try {
2018-11-06 03:57:36 +01:00
$var_comments = CommentAnalyzer::getTypeFromComment(
$doc_comment,
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2019-06-01 18:25:57 +02:00
$statements_analyzer->getAliases()
);
} catch (DocblockParseException $e) {
if (IssueBuffer::accepts(
new InvalidDocblock(
(string)$e->getMessage(),
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $stmt)
)
)) {
// fall through
}
}
foreach ($var_comments as $var_comment) {
if (!$var_comment->type) {
continue;
}
2018-11-06 03:57:36 +01:00
$comment_type = ExpressionAnalyzer::fleshOutType(
$codebase,
$var_comment->type,
2018-01-26 19:51:00 +01:00
$context->self,
$context->self ? new Type\Atomic\TNamedObject($context->self) : null,
$statements_analyzer->getParentFQCLN()
);
$type_location = null;
if ($var_comment->type_start
&& $var_comment->type_end
&& $var_comment->line_number
) {
$type_location = new CodeLocation\DocblockTypeLocation(
$statements_analyzer,
$var_comment->type_start,
$var_comment->type_end,
$var_comment->line_number
);
}
if (!$var_comment->var_id) {
$var_comment_type = $comment_type;
continue;
}
if ($codebase->find_unused_variables
&& $type_location
&& isset($context->vars_in_scope[$var_comment->var_id])
&& $context->vars_in_scope[$var_comment->var_id]->getId() === $comment_type->getId()
) {
if ($codebase->alter_code
&& isset($project_analyzer->getIssuesToFix()['UnnecessaryVarAnnotation'])
) {
FileManipulationBuffer::addVarAnnotationToRemove($type_location);
} elseif (IssueBuffer::accepts(
new UnnecessaryVarAnnotation(
'The @var annotation for ' . $var_comment->var_id . ' is unnecessary',
$type_location
)
)) {
// fall through
}
}
$context->vars_in_scope[$var_comment->var_id] = $comment_type;
}
2017-03-02 04:27:52 +01:00
}
2016-10-22 19:23:18 +02:00
if ($stmt->key) {
$context->inside_call = true;
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->key, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
$context->inside_call = false;
2016-10-22 19:23:18 +02:00
}
if ($stmt->value) {
$context->inside_call = true;
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->value, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
$context->inside_call = false;
2016-10-22 19:23:18 +02:00
if ($var_comment_type) {
$stmt->inferredType = $var_comment_type;
2016-11-02 07:29:00 +01:00
} elseif (isset($stmt->value->inferredType)) {
2016-10-22 19:23:18 +02:00
$stmt->inferredType = $stmt->value->inferredType;
2016-11-02 07:29:00 +01:00
} else {
2016-10-22 19:23:18 +02:00
$stmt->inferredType = Type::getMixed();
}
2016-11-02 07:29:00 +01:00
} else {
2016-10-22 19:23:18 +02:00
$stmt->inferredType = Type::getNull();
}
2016-11-02 07:29:00 +01:00
2019-02-06 21:52:43 +01:00
$source = $statements_analyzer->getSource();
if ($source instanceof FunctionLikeAnalyzer
&& !($source->getSource() instanceof TraitAnalyzer)
) {
$source->examineParamTypes($statements_analyzer, $context, $codebase, $stmt);
2019-02-06 21:52:43 +01:00
$storage = $source->getFunctionLikeStorage($statements_analyzer);
if ($storage->return_type) {
foreach ($storage->return_type->getTypes() as $atomic_return_type) {
if ($atomic_return_type instanceof Type\Atomic\TGenericObject
&& $atomic_return_type->value === 'Generator'
) {
if (!$atomic_return_type->type_params[2]->isMixed()
&& !$atomic_return_type->type_params[2]->isVoid()
) {
$stmt->inferredType = clone $atomic_return_type->type_params[2];
}
}
}
}
}
2016-11-02 07:29:00 +01:00
return null;
2016-10-22 19:23:18 +02:00
}
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Expr\YieldFrom $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return false|null
2016-10-22 19:23:18 +02:00
*/
protected static function analyzeYieldFrom(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-11-02 07:29:00 +01:00
PhpParser\Node\Expr\YieldFrom $stmt,
Context $context
) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
if (isset($stmt->expr->inferredType)) {
$yield_from_type = null;
foreach ($stmt->expr->inferredType->getTypes() as $atomic_type) {
if ($yield_from_type === null) {
if ($atomic_type instanceof Type\Atomic\TGenericObject
&& strtolower($atomic_type->value) === 'generator'
&& isset($atomic_type->type_params[3])
) {
$yield_from_type = clone $atomic_type->type_params[3];
} elseif ($atomic_type instanceof Type\Atomic\TArray) {
$yield_from_type = clone $atomic_type->type_params[1];
} elseif ($atomic_type instanceof Type\Atomic\ObjectLike) {
$yield_from_type = $atomic_type->getGenericValueType();
}
} else {
$yield_from_type = Type::getMixed();
}
}
// this should be whatever the generator above returns, but *not* the return type
$stmt->inferredType = $yield_from_type ?: Type::getMixed();
2016-10-22 19:23:18 +02:00
}
2016-11-02 07:29:00 +01:00
return null;
2016-10-22 19:23:18 +02:00
}
2016-11-02 07:29:00 +01:00
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Expr\BooleanNot $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return false|null
*/
protected static function analyzeBooleanNot(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-11-02 07:29:00 +01:00
PhpParser\Node\Expr\BooleanNot $stmt,
Context $context
) {
$stmt->inferredType = Type::getBool();
2016-12-28 22:29:50 +01:00
2019-03-16 02:50:16 +01:00
$inside_negation = $context->inside_negation;
$context->inside_negation = !$inside_negation;
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
2016-12-28 22:29:50 +01:00
return false;
}
2019-03-16 02:50:16 +01:00
$context->inside_negation = $inside_negation;
2016-10-22 19:23:18 +02:00
}
2016-11-02 07:29:00 +01:00
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Expr\Empty_ $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
* @return void
2016-11-02 07:29:00 +01:00
*/
protected static function analyzeEmpty(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-11-02 07:29:00 +01:00
PhpParser\Node\Expr\Empty_ $stmt,
Context $context
) {
2018-11-11 18:01:14 +01:00
self::analyzeIssetVar($statements_analyzer, $stmt->expr, $context);
2018-04-09 16:19:23 +02:00
$stmt->inferredType = Type::getBool();
2016-10-22 19:23:18 +02:00
}
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2016-11-02 07:29:00 +01:00
* @param PhpParser\Node\Scalar\Encapsed $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
2016-11-02 07:29:00 +01:00
* @return false|null
2016-10-22 19:23:18 +02:00
*/
protected static function analyzeEncapsulatedString(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2016-11-02 07:29:00 +01:00
PhpParser\Node\Scalar\Encapsed $stmt,
Context $context
) {
2016-10-22 19:23:18 +02:00
foreach ($stmt->parts as $part) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $part, $context) === false) {
2016-10-22 19:23:18 +02:00
return false;
}
if (isset($part->inferredType)) {
self::castStringAttempt($statements_analyzer, $part);
}
2016-10-22 19:23:18 +02:00
}
$stmt->inferredType = Type::getString();
2017-05-25 04:07:49 +02:00
2016-11-02 07:29:00 +01:00
return null;
2016-10-22 19:23:18 +02:00
}
/**
* @return void
*/
private static function castStringAttempt(
StatementsAnalyzer $statements_analyzer,
PhpParser\Node\Expr $stmt
) {
if (!isset($stmt->inferredType)) {
return;
}
$has_valid_cast = false;
$invalid_casts = [];
foreach ($stmt->inferredType->getTypes() as $atomic_type) {
2019-07-10 07:35:57 +02:00
$atomic_type_results = new \Psalm\Internal\Analyzer\TypeComparisonResult();
if (!$atomic_type instanceof TMixed
&& !$atomic_type instanceof Type\Atomic\TResource
&& !$atomic_type instanceof TNull
&& !TypeAnalyzer::isAtomicContainedBy(
$statements_analyzer->getCodebase(),
$atomic_type,
new TString(),
false,
true,
2019-07-10 07:35:57 +02:00
$atomic_type_results
)
2019-07-10 07:35:57 +02:00
&& !$atomic_type_results->scalar_type_match_found
) {
$invalid_casts[] = $atomic_type->getId();
} else {
$has_valid_cast = true;
}
}
if ($invalid_casts) {
if ($has_valid_cast) {
if (IssueBuffer::accepts(
new PossiblyInvalidCast(
$invalid_casts[0] . ' cannot be cast to string',
new CodeLocation($statements_analyzer->getSource(), $stmt)
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
} else {
if (IssueBuffer::accepts(
new InvalidCast(
$invalid_casts[0] . ' cannot be cast to string',
new CodeLocation($statements_analyzer->getSource(), $stmt)
),
$statements_analyzer->getSuppressedIssues()
)) {
// fall through
}
}
}
}
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
* @param PhpParser\Node\Expr\Isset_ $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
* @return void
*/
protected static function analyzeIsset(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
PhpParser\Node\Expr\Isset_ $stmt,
Context $context
) {
foreach ($stmt->vars as $isset_var) {
if ($isset_var instanceof PhpParser\Node\Expr\PropertyFetch
&& $isset_var->var instanceof PhpParser\Node\Expr\Variable
&& $isset_var->var->name === 'this'
&& $isset_var->name instanceof PhpParser\Node\Identifier
) {
$var_id = '$this->' . $isset_var->name->name;
if (!isset($context->vars_in_scope[$var_id])) {
$context->vars_in_scope[$var_id] = Type::getMixed();
$context->vars_possibly_in_scope[$var_id] = true;
}
}
2018-11-11 18:01:14 +01:00
self::analyzeIssetVar($statements_analyzer, $isset_var, $context);
}
2018-04-09 16:20:13 +02:00
$stmt->inferredType = Type::getBool();
}
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
* @param PhpParser\Node\Expr $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
* @return false|null
*/
protected static function analyzeIssetVar(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
PhpParser\Node\Expr $stmt,
Context $context
) {
2018-05-01 04:13:13 +02:00
$context->inside_isset = true;
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt, $context) === false) {
return false;
}
$context->inside_isset = false;
}
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
* @param PhpParser\Node\Expr\Clone_ $stmt
* @param Context $context
2017-05-27 02:16:18 +02:00
*
* @return false|null
*/
protected static function analyzeClone(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
PhpParser\Node\Expr\Clone_ $stmt,
Context $context
) {
2018-11-11 18:01:14 +01:00
if (self::analyze($statements_analyzer, $stmt->expr, $context) === false) {
return false;
}
if (isset($stmt->expr->inferredType)) {
$clone_type = $stmt->expr->inferredType;
$immutable_cloned = false;
foreach ($clone_type->getTypes() as $clone_type_part) {
if (!$clone_type_part instanceof TNamedObject
&& !$clone_type_part instanceof TObject
&& !$clone_type_part instanceof TMixed
2019-02-22 03:40:06 +01:00
&& !$clone_type_part instanceof TTemplateParam
2017-01-19 21:00:05 +01:00
) {
if ($clone_type_part instanceof Type\Atomic\TFalse
&& $clone_type->ignore_falsable_issues
) {
continue;
}
if ($clone_type_part instanceof Type\Atomic\TNull
&& $clone_type->ignore_nullable_issues
) {
continue;
}
if (IssueBuffer::accepts(
new InvalidClone(
'Cannot clone ' . $clone_type_part,
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $stmt)
),
2018-11-11 18:01:14 +01:00
$statements_analyzer->getSuppressedIssues()
)) {
return false;
}
return;
}
$codebase = $statements_analyzer->getCodebase();
if ($clone_type_part instanceof TNamedObject
&& $codebase->classExists($clone_type_part->value)
) {
$class_storage = $codebase->classlike_storage_provider->get($clone_type_part->value);
if ($class_storage->mutation_free) {
$immutable_cloned = true;
}
}
}
$stmt->inferredType = $stmt->expr->inferredType;
if ($immutable_cloned) {
$stmt->inferredType->external_mutation_free = true;
}
}
}
2016-10-22 19:23:18 +02:00
/**
* @param string $fq_class_name
2017-05-27 02:16:18 +02:00
*
2017-05-25 04:07:49 +02:00
* @return bool
2016-10-22 19:23:18 +02:00
*/
public static function isMock($fq_class_name)
2016-10-22 19:23:18 +02:00
{
return in_array(strtolower($fq_class_name), Config::getInstance()->getMockClasses(), true);
2016-10-22 19:23:18 +02:00
}
}