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

279 lines
9.2 KiB
PHP
Raw Normal View History

2018-01-14 18:09:40 +01:00
<?php
2018-11-06 03:57:36 +01:00
namespace Psalm\Internal\Analyzer\Statements\Expression;
2018-01-14 18:09:40 +01:00
use PhpParser;
2018-11-06 03:57:36 +01:00
use Psalm\Internal\Analyzer\Statements\ExpressionAnalyzer;
use \Psalm\Internal\Analyzer\Statements\Block\IfAnalyzer;
2018-11-06 03:57:36 +01:00
use Psalm\Internal\Analyzer\StatementsAnalyzer;
2018-01-14 18:09:40 +01:00
use Psalm\CodeLocation;
use Psalm\Context;
use Psalm\Type;
2018-05-07 07:26:06 +02:00
use Psalm\Type\Algebra;
2018-01-14 18:09:40 +01:00
use Psalm\Type\Reconciler;
2019-08-10 19:22:21 +02:00
use Psalm\Internal\Type\AssertionReconciler;
use function array_merge;
use function array_map;
use function array_diff_key;
use function array_filter;
use const ARRAY_FILTER_USE_KEY;
use function array_values;
use function array_keys;
use function preg_match;
use function preg_quote;
use function array_intersect_key;
2018-01-14 18:09:40 +01:00
/**
* @internal
*/
2018-11-06 03:57:36 +01:00
class TernaryAnalyzer
2018-01-14 18:09:40 +01:00
{
/**
2018-11-11 18:01:14 +01:00
* @param StatementsAnalyzer $statements_analyzer
2018-01-14 18:09:40 +01:00
* @param PhpParser\Node\Expr\Ternary $stmt
* @param Context $context
*
* @return false|null
*/
public static function analyze(
2018-11-11 18:01:14 +01:00
StatementsAnalyzer $statements_analyzer,
2018-01-14 18:09:40 +01:00
PhpParser\Node\Expr\Ternary $stmt,
Context $context
) {
$codebase = $statements_analyzer->getCodebase();
$if_scope = new \Psalm\Internal\Scope\IfScope();
try {
$if_conditional_scope = IfAnalyzer::analyzeIfConditional(
$statements_analyzer,
$stmt->cond,
$context,
$codebase,
$if_scope,
$context->branch_point ?: (int) $stmt->getAttribute('startFilePos')
);
$if_context = $if_conditional_scope->if_context;
$cond_referenced_var_ids = $if_conditional_scope->cond_referenced_var_ids;
} catch (\Psalm\Exception\ScopeAnalysisException $e) {
return false;
}
$codebase = $statements_analyzer->getCodebase();
2018-05-07 07:26:06 +02:00
$if_clauses = \Psalm\Type\Algebra::getFormula(
\spl_object_id($stmt->cond),
2018-01-14 18:09:40 +01:00
$stmt->cond,
$context->self,
2018-11-11 18:01:14 +01:00
$statements_analyzer,
2018-11-06 03:57:36 +01:00
$codebase
2018-01-14 18:09:40 +01:00
);
$mixed_var_ids = [];
2018-05-31 02:54:03 +02:00
foreach ($context->vars_in_scope as $var_id => $type) {
if ($type->hasMixed()) {
2018-05-31 02:54:03 +02:00
$mixed_var_ids[] = $var_id;
}
}
foreach ($context->vars_possibly_in_scope as $var_id => $_) {
if (!isset($context->vars_in_scope[$var_id])) {
$mixed_var_ids[] = $var_id;
}
}
$if_clauses = array_values(
array_map(
/**
2018-11-06 03:57:36 +01:00
* @return \Psalm\Internal\Clause
2018-05-31 02:54:03 +02:00
*/
2018-11-06 03:57:36 +01:00
function (\Psalm\Internal\Clause $c) use ($mixed_var_ids) {
2018-05-31 02:54:03 +02:00
$keys = array_keys($c->possibilities);
2019-11-12 16:21:27 +01:00
$mixed_var_ids = \array_diff($mixed_var_ids, $keys);
2018-05-31 02:54:03 +02:00
foreach ($keys as $key) {
foreach ($mixed_var_ids as $mixed_var_id) {
if (preg_match('/^' . preg_quote($mixed_var_id, '/') . '(\[|-)/', $key)) {
2018-11-06 03:57:36 +01:00
return new \Psalm\Internal\Clause([], true);
2018-05-31 02:54:03 +02:00
}
}
}
return $c;
},
$if_clauses
)
);
2019-12-08 06:49:34 +01:00
$ternary_clauses = array_merge($context->clauses, $if_clauses);
if ($if_context->reconciled_expression_clauses) {
$reconciled_expression_clauses = $if_context->reconciled_expression_clauses;
$ternary_clauses = array_values(
array_filter(
$ternary_clauses,
function ($c) use ($reconciled_expression_clauses) {
return !\in_array($c->getHash(), $reconciled_expression_clauses);
}
)
);
}
$ternary_clauses = Algebra::simplifyCNF($ternary_clauses);
2018-01-14 18:09:40 +01:00
2018-05-07 07:26:06 +02:00
$negated_clauses = Algebra::negateFormula($if_clauses);
2018-01-14 18:09:40 +01:00
2018-05-07 07:26:06 +02:00
$negated_if_types = Algebra::getTruthsFromFormula(
Algebra::simplifyCNF(
2018-05-06 02:52:10 +02:00
array_merge($context->clauses, $negated_clauses)
)
);
2018-01-14 18:09:40 +01:00
$active_if_types = [];
$reconcilable_if_types = Algebra::getTruthsFromFormula(
$ternary_clauses,
\spl_object_id($stmt->cond),
$cond_referenced_var_ids,
$active_if_types
);
2018-01-14 18:09:40 +01:00
$changed_var_ids = [];
if ($reconcilable_if_types) {
$if_vars_in_scope_reconciled = Reconciler::reconcileKeyedTypes(
$reconcilable_if_types,
$active_if_types,
$if_context->vars_in_scope,
$changed_var_ids,
$cond_referenced_var_ids,
$statements_analyzer,
[],
$if_context->inside_loop,
new CodeLocation($statements_analyzer->getSource(), $stmt->cond)
);
$if_context->vars_in_scope = $if_vars_in_scope_reconciled;
}
2018-01-14 18:09:40 +01:00
$t_else_context = clone $context;
if ($stmt->if) {
if (ExpressionAnalyzer::analyze($statements_analyzer, $stmt->if, $if_context) === false) {
2018-01-14 18:09:40 +01:00
return false;
}
foreach ($if_context->vars_in_scope as $var_id => $type) {
2018-01-14 18:09:40 +01:00
if (isset($context->vars_in_scope[$var_id])) {
$context->vars_in_scope[$var_id] = Type::combineUnionTypes($context->vars_in_scope[$var_id], $type);
}
}
$context->referenced_var_ids = array_merge(
$context->referenced_var_ids,
$if_context->referenced_var_ids
2018-01-14 18:09:40 +01:00
);
$context->unreferenced_vars = array_intersect_key(
$context->unreferenced_vars,
$if_context->unreferenced_vars
);
2018-01-14 18:09:40 +01:00
}
if ($negated_if_types) {
$t_else_vars_in_scope_reconciled = Reconciler::reconcileKeyedTypes(
$negated_if_types,
2018-01-14 18:09:40 +01:00
$negated_if_types,
$t_else_context->vars_in_scope,
$changed_var_ids,
$cond_referenced_var_ids,
2018-11-11 18:01:14 +01:00
$statements_analyzer,
[],
$t_else_context->inside_loop,
new CodeLocation($statements_analyzer->getSource(), $stmt->else)
2018-01-14 18:09:40 +01:00
);
$t_else_context->vars_in_scope = $t_else_vars_in_scope_reconciled;
}
2018-11-11 18:01:14 +01:00
if (ExpressionAnalyzer::analyze($statements_analyzer, $stmt->else, $t_else_context) === false) {
2018-01-14 18:09:40 +01:00
return false;
}
foreach ($t_else_context->vars_in_scope as $var_id => $type) {
if (isset($context->vars_in_scope[$var_id])) {
$context->vars_in_scope[$var_id] = Type::combineUnionTypes(
$context->vars_in_scope[$var_id],
$type
);
} elseif (isset($if_context->vars_in_scope[$var_id])
&& isset($if_context->assigned_var_ids[$var_id])
) {
$context->vars_in_scope[$var_id] = Type::combineUnionTypes(
$if_context->vars_in_scope[$var_id],
$type
);
2018-01-14 18:09:40 +01:00
}
}
$context->vars_possibly_in_scope = array_merge(
$context->vars_possibly_in_scope,
$if_context->vars_possibly_in_scope,
$t_else_context->vars_possibly_in_scope
);
2018-01-14 18:09:40 +01:00
$context->referenced_var_ids = array_merge(
$context->referenced_var_ids,
$t_else_context->referenced_var_ids
);
$context->unreferenced_vars = array_intersect_key(
$context->unreferenced_vars,
$t_else_context->unreferenced_vars
);
2019-11-13 21:06:22 +01:00
foreach ($context->unreferenced_vars as $var_id => $_) {
2019-11-13 20:32:27 +01:00
if (isset($t_else_context->unreferenced_vars[$var_id])) {
$context->unreferenced_vars[$var_id] += $t_else_context->unreferenced_vars[$var_id];
}
if (isset($if_context->unreferenced_vars[$var_id])) {
$context->unreferenced_vars[$var_id] += $if_context->unreferenced_vars[$var_id];
2019-11-13 20:32:27 +01:00
}
}
2018-01-14 18:09:40 +01:00
$lhs_type = null;
if ($stmt->if) {
if ($stmt_if_type = $statements_analyzer->node_data->getType($stmt->if)) {
$lhs_type = $stmt_if_type;
2018-01-14 18:09:40 +01:00
}
} elseif ($stmt_cond_type = $statements_analyzer->node_data->getType($stmt->cond)) {
2019-08-10 19:22:21 +02:00
$if_return_type_reconciled = AssertionReconciler::reconcile(
2018-01-14 18:09:40 +01:00
'!falsy',
clone $stmt_cond_type,
2018-01-14 18:09:40 +01:00
'',
2018-11-11 18:01:14 +01:00
$statements_analyzer,
$context->inside_loop,
[],
2018-11-11 18:01:14 +01:00
new CodeLocation($statements_analyzer->getSource(), $stmt),
$statements_analyzer->getSuppressedIssues()
2018-01-14 18:09:40 +01:00
);
$lhs_type = $if_return_type_reconciled;
}
if ($lhs_type && ($stmt_else_type = $statements_analyzer->node_data->getType($stmt->else))) {
$statements_analyzer->node_data->setType($stmt, Type::combineUnionTypes($lhs_type, $stmt_else_type));
2018-01-14 18:09:40 +01:00
} else {
$statements_analyzer->node_data->setType($stmt, Type::getMixed());
2018-01-14 18:09:40 +01:00
}
return null;
}
}