2016-01-08 00:28:27 +01:00
|
|
|
<?php
|
2016-08-13 20:20:46 +02:00
|
|
|
namespace Psalm\Checker;
|
2016-01-08 00:28:27 +01:00
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
use PhpParser;
|
2016-08-13 20:20:46 +02:00
|
|
|
use Psalm\Config;
|
|
|
|
use Psalm\Context;
|
2017-05-19 06:48:26 +02:00
|
|
|
use Psalm\IssueBuffer;
|
2016-11-02 07:29:00 +01:00
|
|
|
use Psalm\StatementsSource;
|
2017-01-02 21:31:18 +01:00
|
|
|
use Psalm\Type;
|
2016-08-13 20:20:46 +02:00
|
|
|
|
2016-11-21 03:49:06 +01:00
|
|
|
class FileChecker extends SourceChecker implements StatementsSource
|
2016-01-08 00:28:27 +01:00
|
|
|
{
|
2017-01-07 20:35:07 +01:00
|
|
|
use CanAlias;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
|
|
|
protected $file_name;
|
|
|
|
|
2016-10-14 06:53:43 +02:00
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2016-12-04 01:11:30 +01:00
|
|
|
protected $file_path;
|
2016-10-14 06:53:43 +02:00
|
|
|
|
2017-01-07 20:35:07 +01:00
|
|
|
/**
|
|
|
|
* @var string|null
|
|
|
|
*/
|
2017-01-08 01:33:33 +01:00
|
|
|
protected $actual_file_name;
|
2017-01-07 20:35:07 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var string|null
|
|
|
|
*/
|
2017-01-08 01:33:33 +01:00
|
|
|
protected $actual_file_path;
|
2017-01-07 20:35:07 +01:00
|
|
|
|
|
|
|
/**
|
2017-10-27 00:19:19 +02:00
|
|
|
* @var array<int, string>
|
2017-01-07 20:35:07 +01:00
|
|
|
*/
|
|
|
|
protected $suppressed_issues = [];
|
|
|
|
|
2016-11-13 00:51:48 +01:00
|
|
|
/**
|
|
|
|
* @var array<string, array<string, string>>
|
2016-10-31 20:42:20 +01:00
|
|
|
*/
|
2016-08-14 00:54:49 +02:00
|
|
|
protected $namespace_aliased_classes = [];
|
2016-02-18 21:05:13 +01:00
|
|
|
|
2016-11-13 00:51:48 +01:00
|
|
|
/**
|
|
|
|
* @var array<string, array<string, string>>
|
|
|
|
*/
|
|
|
|
protected $namespace_aliased_classes_flipped = [];
|
|
|
|
|
2016-10-31 20:42:20 +01:00
|
|
|
/**
|
2017-02-02 00:11:00 +01:00
|
|
|
* @var array<int, \PhpParser\Node\Stmt>
|
2016-10-31 20:42:20 +01:00
|
|
|
*/
|
2016-08-14 00:54:49 +02:00
|
|
|
protected $preloaded_statements = [];
|
2016-04-04 01:41:54 +02:00
|
|
|
|
2016-11-01 05:39:41 +01:00
|
|
|
/**
|
|
|
|
* @var bool
|
|
|
|
*/
|
2016-01-11 17:05:24 +01:00
|
|
|
public static $show_notices = true;
|
2016-01-08 00:28:27 +01:00
|
|
|
|
2017-01-02 21:31:18 +01:00
|
|
|
/**
|
|
|
|
* @var array<string, ClassLikeChecker>
|
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
protected $interface_checkers_to_analyze = [];
|
2017-01-02 21:31:18 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, ClassLikeChecker>
|
|
|
|
*/
|
2017-02-02 00:11:00 +01:00
|
|
|
protected $class_checkers_to_analyze = [];
|
2017-01-02 21:31:18 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<string, FunctionChecker>
|
|
|
|
*/
|
|
|
|
protected $function_checkers = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array<int, NamespaceChecker>
|
|
|
|
*/
|
|
|
|
protected $namespace_checkers = [];
|
|
|
|
|
2017-06-06 16:11:34 +02:00
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
|
|
|
private $included_file_paths = [];
|
|
|
|
|
2017-01-02 21:31:18 +01:00
|
|
|
/**
|
2017-07-25 22:11:02 +02:00
|
|
|
* @var ?Context
|
2017-01-02 21:31:18 +01:00
|
|
|
*/
|
2017-01-12 06:54:41 +01:00
|
|
|
public $context;
|
2017-01-02 21:31:18 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var ProjectChecker
|
|
|
|
*/
|
|
|
|
public $project_checker;
|
|
|
|
|
2016-12-31 00:08:07 +01:00
|
|
|
/**
|
2017-02-02 00:11:00 +01:00
|
|
|
* @var bool
|
2016-10-14 06:53:43 +02:00
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
public $will_analyze;
|
2017-02-02 00:11:00 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $file_path
|
|
|
|
* @param ProjectChecker $project_checker
|
|
|
|
* @param bool $will_analyze
|
|
|
|
*/
|
|
|
|
public function __construct(
|
|
|
|
$file_path,
|
|
|
|
ProjectChecker $project_checker,
|
2017-11-09 05:27:51 +01:00
|
|
|
$will_analyze = true
|
2017-02-02 00:11:00 +01:00
|
|
|
) {
|
2016-12-31 00:08:07 +01:00
|
|
|
$this->file_path = $file_path;
|
2016-12-08 04:38:57 +01:00
|
|
|
$this->file_name = Config::getInstance()->shortenFileName($this->file_path);
|
2017-01-02 21:31:18 +01:00
|
|
|
$this->project_checker = $project_checker;
|
2017-02-02 00:11:00 +01:00
|
|
|
$this->will_analyze = $will_analyze;
|
2016-01-08 00:28:27 +01:00
|
|
|
}
|
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
/**
|
2017-01-02 21:31:18 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
public function scan()
|
2017-01-02 21:31:18 +01:00
|
|
|
{
|
2016-06-18 20:45:55 +02:00
|
|
|
$stmts = $this->getStatements();
|
2016-01-08 00:28:27 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$traverser = new PhpParser\NodeTraverser();
|
|
|
|
$traverser->addVisitor(new \Psalm\Visitor\DependencyFinderVisitor($this->project_checker, $this));
|
|
|
|
$traverser->traverse($stmts);
|
|
|
|
}
|
2016-12-28 18:59:51 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
/**
|
|
|
|
* @param bool $preserve_checkers
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
2017-09-16 18:45:11 +02:00
|
|
|
public function analyze(Context $file_context = null, $preserve_checkers = false)
|
2017-07-25 22:11:02 +02:00
|
|
|
{
|
|
|
|
if ($file_context) {
|
|
|
|
$this->context = $file_context;
|
|
|
|
}
|
2017-02-01 01:21:33 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
if (!$this->context) {
|
|
|
|
$this->context = new Context();
|
|
|
|
$this->context->collect_references = $this->project_checker->collect_references;
|
|
|
|
$this->context->vars_in_scope['$argc'] = Type::getInt();
|
|
|
|
$this->context->vars_in_scope['$argv'] = new Type\Union([
|
|
|
|
new Type\Atomic\TArray([
|
|
|
|
Type::getInt(),
|
|
|
|
Type::getString(),
|
|
|
|
]),
|
|
|
|
]);
|
|
|
|
}
|
2016-11-02 07:29:00 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$config = Config::getInstance();
|
2017-01-02 21:31:18 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$stmts = $this->getStatements();
|
2016-11-02 07:29:00 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$statements_checker = new StatementsChecker($this);
|
2017-01-02 21:31:18 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$leftover_stmts = $this->populateCheckers($stmts);
|
2016-07-24 23:06:54 +02:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$function_stmts = [];
|
|
|
|
$function_checkers = [];
|
2017-01-02 21:31:18 +01:00
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
foreach ($stmts as $stmt) {
|
|
|
|
if ($stmt instanceof PhpParser\Node\Stmt\Function_) {
|
2017-01-02 21:31:18 +01:00
|
|
|
$function_stmts[] = $stmt;
|
2016-01-08 00:28:27 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-02 21:31:18 +01:00
|
|
|
// hoist functions to the top
|
|
|
|
foreach ($function_stmts as $stmt) {
|
2017-01-06 07:07:11 +01:00
|
|
|
$function_checkers[$stmt->name] = new FunctionChecker($stmt, $this);
|
2017-02-24 01:36:51 +01:00
|
|
|
$function_id = (string)$function_checkers[$stmt->name]->getMethodId();
|
2017-01-02 21:31:18 +01:00
|
|
|
$this->function_checkers[$function_id] = $function_checkers[$stmt->name];
|
|
|
|
}
|
|
|
|
|
|
|
|
// if there are any leftover statements, evaluate them,
|
|
|
|
// in turn causing the classes/interfaces be evaluated
|
|
|
|
if ($leftover_stmts) {
|
2017-01-07 21:09:47 +01:00
|
|
|
$statements_checker->analyze($leftover_stmts, $this->context);
|
2016-12-28 18:59:51 +01:00
|
|
|
}
|
|
|
|
|
2017-01-02 21:31:18 +01:00
|
|
|
// check any leftover interfaces not already evaluated
|
2017-07-25 22:11:02 +02:00
|
|
|
foreach ($this->interface_checkers_to_analyze as $interface_checker) {
|
|
|
|
$interface_checker->analyze();
|
2016-12-28 18:59:51 +01:00
|
|
|
}
|
|
|
|
|
2017-01-02 21:31:18 +01:00
|
|
|
// check any leftover classes not already evaluated
|
2017-02-02 00:11:00 +01:00
|
|
|
foreach ($this->class_checkers_to_analyze as $class_checker) {
|
2017-09-16 18:45:11 +02:00
|
|
|
$class_checker->analyze(null, $this->context);
|
2016-08-05 21:11:20 +02:00
|
|
|
}
|
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$config = Config::getInstance();
|
|
|
|
|
2017-01-02 21:31:18 +01:00
|
|
|
foreach ($this->function_checkers as $function_checker) {
|
2017-01-17 00:33:04 +01:00
|
|
|
$function_context = new Context($this->context->self);
|
2017-02-27 05:09:18 +01:00
|
|
|
$function_context->collect_references = $this->project_checker->collect_references;
|
2017-01-07 21:09:47 +01:00
|
|
|
$function_checker->analyze($function_context, $this->context);
|
2017-01-02 21:31:18 +01:00
|
|
|
|
2017-03-24 23:34:46 +01:00
|
|
|
if ($config->reportIssueInFile('InvalidReturnType', $this->file_path)) {
|
2017-01-02 21:31:18 +01:00
|
|
|
/** @var string */
|
|
|
|
$method_id = $function_checker->getMethodId();
|
|
|
|
|
2017-07-29 21:05:06 +02:00
|
|
|
$function_storage = FunctionChecker::getStorage(
|
2017-08-15 01:30:11 +02:00
|
|
|
$statements_checker,
|
|
|
|
$method_id
|
2017-07-29 21:05:06 +02:00
|
|
|
);
|
2017-02-10 04:54:06 +01:00
|
|
|
|
|
|
|
if (!$function_storage->has_template_return_type) {
|
|
|
|
$return_type = $function_storage->return_type;
|
|
|
|
|
|
|
|
$return_type_location = $function_storage->return_type_location;
|
|
|
|
|
|
|
|
$function_checker->verifyReturnType(
|
2017-09-16 18:45:11 +02:00
|
|
|
$statements_checker->getFileChecker()->project_checker,
|
2017-02-10 04:54:06 +01:00
|
|
|
$return_type,
|
|
|
|
null,
|
|
|
|
$return_type_location
|
|
|
|
);
|
|
|
|
}
|
2017-01-02 21:31:18 +01:00
|
|
|
}
|
2016-08-05 21:11:20 +02:00
|
|
|
}
|
|
|
|
|
2017-01-12 03:37:53 +01:00
|
|
|
if (!$preserve_checkers) {
|
2017-02-02 00:11:00 +01:00
|
|
|
$this->class_checkers_to_analyze = [];
|
2017-01-12 03:37:53 +01:00
|
|
|
$this->function_checkers = [];
|
|
|
|
}
|
2016-01-08 00:28:27 +01:00
|
|
|
}
|
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
/**
|
|
|
|
* @param array<int, PhpParser\Node\Expr|PhpParser\Node\Stmt> $stmts
|
|
|
|
*
|
|
|
|
* @return array<int, PhpParser\Node\Expr|PhpParser\Node\Stmt>
|
|
|
|
*/
|
|
|
|
public function populateCheckers(array $stmts)
|
|
|
|
{
|
|
|
|
/** @var array<int, PhpParser\Node\Expr|PhpParser\Node\Stmt> */
|
|
|
|
$leftover_stmts = [];
|
|
|
|
|
|
|
|
foreach ($stmts as $stmt) {
|
2017-10-20 01:19:29 +02:00
|
|
|
if ($stmt instanceof PhpParser\Node\Stmt\ClassLike) {
|
|
|
|
$this->populateClassLikeCheckers($stmt);
|
2017-07-25 22:11:02 +02:00
|
|
|
} elseif ($stmt instanceof PhpParser\Node\Stmt\Namespace_) {
|
|
|
|
$namespace_name = $stmt->name ? implode('\\', $stmt->name->parts) : '';
|
|
|
|
|
|
|
|
$namespace_checker = new NamespaceChecker($stmt, $this);
|
|
|
|
$namespace_checker->collectAnalyzableInformation();
|
|
|
|
|
|
|
|
$this->namespace_aliased_classes[$namespace_name] = $namespace_checker->getAliases()->uses;
|
|
|
|
$this->namespace_aliased_classes_flipped[$namespace_name] =
|
|
|
|
$namespace_checker->getAliasedClassesFlipped();
|
|
|
|
} elseif ($stmt instanceof PhpParser\Node\Stmt\Use_) {
|
|
|
|
$this->visitUse($stmt);
|
|
|
|
} elseif ($stmt instanceof PhpParser\Node\Stmt\GroupUse) {
|
|
|
|
$this->visitGroupUse($stmt);
|
|
|
|
} elseif (!($stmt instanceof PhpParser\Node\Stmt\Function_)) {
|
2017-10-20 01:19:29 +02:00
|
|
|
if ($stmt instanceof PhpParser\Node\Stmt\If_) {
|
|
|
|
foreach ($stmt->stmts as $if_stmt) {
|
|
|
|
if ($if_stmt instanceof PhpParser\Node\Stmt\ClassLike) {
|
|
|
|
$this->populateClassLikeCheckers($if_stmt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
$leftover_stmts[] = $stmt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $leftover_stmts;
|
|
|
|
}
|
|
|
|
|
2017-10-20 01:19:29 +02:00
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
private function populateClassLikeCheckers(PhpParser\Node\Stmt\ClassLike $stmt)
|
|
|
|
{
|
|
|
|
if (!$stmt->name) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($stmt instanceof PhpParser\Node\Stmt\Class_) {
|
|
|
|
$class_checker = new ClassChecker($stmt, $this, $stmt->name);
|
|
|
|
|
|
|
|
$fq_class_name = $class_checker->getFQCLN();
|
|
|
|
|
|
|
|
$this->class_checkers_to_analyze[strtolower($fq_class_name)] = $class_checker;
|
|
|
|
} elseif ($stmt instanceof PhpParser\Node\Stmt\Interface_) {
|
|
|
|
$class_checker = new InterfaceChecker($stmt, $this, $stmt->name);
|
|
|
|
|
|
|
|
$fq_class_name = $class_checker->getFQCLN();
|
|
|
|
|
|
|
|
$this->interface_checkers_to_analyze[$fq_class_name] = $class_checker;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-02 00:11:00 +01:00
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param ClassChecker $class_checker
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-02-02 00:11:00 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addNamespacedClassChecker($fq_class_name, ClassChecker $class_checker)
|
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
$this->class_checkers_to_analyze[strtolower($fq_class_name)] = $class_checker;
|
2017-02-02 00:11:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $fq_class_name
|
|
|
|
* @param InterfaceChecker $interface_checker
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-02-02 00:11:00 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addNamespacedInterfaceChecker($fq_class_name, InterfaceChecker $interface_checker)
|
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
$this->interface_checkers_to_analyze[strtolower($fq_class_name)] = $interface_checker;
|
2017-02-02 00:11:00 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 20:37:07 +01:00
|
|
|
/**
|
|
|
|
* @param string $function_id
|
|
|
|
* @param FunctionChecker $function_checker
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-03-19 20:37:07 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addNamespacedFunctionChecker($function_id, FunctionChecker $function_checker)
|
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
$this->function_checkers[strtolower($function_id)] = $function_checker;
|
2017-03-19 20:37:07 +01:00
|
|
|
}
|
|
|
|
|
2017-01-12 03:37:53 +01:00
|
|
|
/**
|
2017-01-12 06:54:41 +01:00
|
|
|
* @param string $method_id
|
2017-01-12 03:37:53 +01:00
|
|
|
* @param Context $this_context
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-01-12 03:37:53 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
public function getMethodMutations($method_id, Context $this_context)
|
2017-01-12 03:37:53 +01:00
|
|
|
{
|
2017-01-12 06:54:41 +01:00
|
|
|
list($fq_class_name, $method_name) = explode('::', $method_id);
|
2017-06-30 07:24:45 +02:00
|
|
|
|
|
|
|
$class_checker_to_examine = null;
|
|
|
|
|
2017-07-25 22:11:02 +02:00
|
|
|
if (isset($this->class_checkers_to_analyze[strtolower($fq_class_name)])) {
|
|
|
|
$class_checker_to_examine = $this->class_checkers_to_analyze[strtolower($fq_class_name)];
|
|
|
|
} else {
|
2017-06-30 07:24:45 +02:00
|
|
|
$this->project_checker->getMethodMutations($method_id, $this_context);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
$call_context = new Context($this_context->self);
|
2017-01-12 03:37:53 +01:00
|
|
|
$call_context->collect_mutations = true;
|
2017-06-30 07:24:45 +02:00
|
|
|
$call_context->include_location = $this_context->include_location;
|
2017-01-12 03:37:53 +01:00
|
|
|
|
|
|
|
foreach ($this_context->vars_possibly_in_scope as $var => $type) {
|
|
|
|
if (strpos($var, '$this->') === 0) {
|
|
|
|
$call_context->vars_possibly_in_scope[$var] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($this_context->vars_in_scope as $var => $type) {
|
|
|
|
if (strpos($var, '$this->') === 0) {
|
|
|
|
$call_context->vars_in_scope[$var] = $type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$call_context->vars_in_scope['$this'] = $this_context->vars_in_scope['$this'];
|
|
|
|
|
2017-06-30 07:24:45 +02:00
|
|
|
$class_checker_to_examine->getMethodMutations($method_name, $call_context);
|
2017-01-12 06:54:41 +01:00
|
|
|
|
2017-01-19 05:19:36 +01:00
|
|
|
foreach ($call_context->vars_possibly_in_scope as $var => $_) {
|
2017-01-12 03:37:53 +01:00
|
|
|
$this_context->vars_possibly_in_scope[$var] = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($call_context->vars_in_scope as $var => $type) {
|
|
|
|
$this_context->vars_in_scope[$var] = $type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-14 06:53:43 +02:00
|
|
|
/**
|
2017-01-02 21:31:18 +01:00
|
|
|
* @param Context|null $file_context
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-01-02 21:31:18 +01:00
|
|
|
* @return void
|
2016-10-14 06:53:43 +02:00
|
|
|
*/
|
2017-09-16 18:45:11 +02:00
|
|
|
public function visitAndAnalyzeMethods(Context $file_context = null)
|
2016-01-11 20:21:29 +01:00
|
|
|
{
|
2017-03-24 23:34:46 +01:00
|
|
|
$this->project_checker->registerAnalyzableFile($this->file_path);
|
2017-07-25 22:11:02 +02:00
|
|
|
$this->project_checker->scanFiles();
|
2017-09-16 18:45:11 +02:00
|
|
|
$this->analyze($file_context);
|
2016-06-20 06:38:13 +02:00
|
|
|
}
|
2016-02-04 22:05:36 +01:00
|
|
|
|
2017-01-07 23:24:43 +01:00
|
|
|
/**
|
|
|
|
* Used when checking single files with multiple classlike declarations
|
|
|
|
*
|
|
|
|
* @param string $fq_class_name
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-01-07 23:24:43 +01:00
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function containsUnEvaluatedClassLike($fq_class_name)
|
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
return false;
|
2016-01-08 00:28:27 +01:00
|
|
|
}
|
2016-01-08 04:52:26 +01:00
|
|
|
|
2016-04-27 00:42:48 +02:00
|
|
|
/**
|
2017-02-02 00:11:00 +01:00
|
|
|
* @return array<int, \PhpParser\Node\Stmt>
|
2016-04-27 00:42:48 +02:00
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
public function getStatements()
|
2017-01-08 01:07:58 +01:00
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
return $this->project_checker->getStatementsForFile($this->file_path);
|
2017-01-08 01:07:58 +01:00
|
|
|
}
|
|
|
|
|
2016-04-27 00:42:48 +02:00
|
|
|
/**
|
2017-11-26 22:03:17 +01:00
|
|
|
* @return ?string
|
2016-04-27 00:42:48 +02:00
|
|
|
*/
|
2016-01-20 00:27:06 +01:00
|
|
|
public function getNamespace()
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2016-11-13 00:51:48 +01:00
|
|
|
/**
|
|
|
|
* @param string|null $namespace_name
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2016-11-13 00:51:48 +01:00
|
|
|
* @return array<string, string>
|
|
|
|
*/
|
|
|
|
public function getAliasedClassesFlipped($namespace_name = null)
|
|
|
|
{
|
|
|
|
if ($namespace_name && isset($this->namespace_aliased_classes_flipped[$namespace_name])) {
|
|
|
|
return $this->namespace_aliased_classes_flipped[$namespace_name];
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this->aliased_classes_flipped;
|
|
|
|
}
|
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
2016-08-10 07:09:47 +02:00
|
|
|
public static function clearCache()
|
2016-03-23 18:05:25 +01:00
|
|
|
{
|
2016-08-15 17:01:50 +02:00
|
|
|
ClassLikeChecker::clearCache();
|
2016-10-21 00:12:13 +02:00
|
|
|
FunctionChecker::clearCache();
|
2016-10-21 00:16:17 +02:00
|
|
|
StatementsChecker::clearCache();
|
2016-12-08 21:57:18 +01:00
|
|
|
IssueBuffer::clearCache();
|
2017-01-27 07:23:12 +01:00
|
|
|
FunctionLikeChecker::clearCache();
|
2016-05-10 20:00:44 +02:00
|
|
|
}
|
2016-11-06 05:59:29 +01:00
|
|
|
|
2017-01-07 20:35:07 +01:00
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getFileName()
|
|
|
|
{
|
|
|
|
return $this->file_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getFilePath()
|
|
|
|
{
|
|
|
|
return $this->file_path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-01-08 01:33:33 +01:00
|
|
|
* @param string $file_name
|
|
|
|
* @param string $file_path
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-01-07 20:35:07 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
2017-01-08 01:33:33 +01:00
|
|
|
public function setFileName($file_name, $file_path)
|
2017-01-07 20:35:07 +01:00
|
|
|
{
|
2017-01-08 01:33:33 +01:00
|
|
|
$this->actual_file_name = $this->file_name;
|
|
|
|
$this->actual_file_path = $this->file_path;
|
|
|
|
|
|
|
|
$this->file_name = $file_name;
|
|
|
|
$this->file_path = $file_path;
|
2017-01-07 20:35:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getCheckedFileName()
|
|
|
|
{
|
2017-01-08 01:33:33 +01:00
|
|
|
return $this->actual_file_name ?: $this->file_name;
|
2017-01-07 20:35:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getCheckedFilePath()
|
|
|
|
{
|
2017-01-08 01:33:33 +01:00
|
|
|
return $this->actual_file_path ?: $this->file_path;
|
2017-01-07 20:35:07 +01:00
|
|
|
}
|
|
|
|
|
2017-11-26 22:03:17 +01:00
|
|
|
/**
|
|
|
|
* @return array<int, string>
|
|
|
|
*/
|
2017-01-07 20:35:07 +01:00
|
|
|
public function getSuppressedIssues()
|
|
|
|
{
|
|
|
|
return $this->suppressed_issues;
|
|
|
|
}
|
|
|
|
|
2017-10-27 00:19:19 +02:00
|
|
|
/**
|
|
|
|
* @param array<int, string> $new_issues
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function addSuppressedIssues(array $new_issues)
|
|
|
|
{
|
|
|
|
$this->suppressed_issues = array_merge($new_issues, $this->suppressed_issues);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param array<int, string> $new_issues
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function removeSuppressedIssues(array $new_issues)
|
|
|
|
{
|
|
|
|
$this->suppressed_issues = array_diff($this->suppressed_issues, $new_issues);
|
|
|
|
}
|
|
|
|
|
2017-11-26 22:03:17 +01:00
|
|
|
/**
|
|
|
|
* @return ?string
|
|
|
|
*/
|
2017-01-07 20:35:07 +01:00
|
|
|
public function getFQCLN()
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2017-11-26 22:03:17 +01:00
|
|
|
/**
|
|
|
|
* @return ?string
|
|
|
|
*/
|
2017-01-09 06:26:40 +01:00
|
|
|
public function getClassName()
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2017-11-26 22:03:17 +01:00
|
|
|
/**
|
|
|
|
* @return bool
|
|
|
|
*/
|
2017-01-07 20:35:07 +01:00
|
|
|
public function isStatic()
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2017-03-20 04:30:20 +01:00
|
|
|
|
2017-11-26 22:03:17 +01:00
|
|
|
/**
|
|
|
|
* @return FileChecker
|
|
|
|
*/
|
2017-03-20 04:30:20 +01:00
|
|
|
public function getFileChecker()
|
|
|
|
{
|
|
|
|
return $this;
|
|
|
|
}
|
2016-01-08 00:28:27 +01:00
|
|
|
}
|