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/Fetch/ConstFetchAnalyzer.php

350 lines
12 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\Fetch;
2018-01-14 18:09:40 +01:00
use PhpParser;
2018-11-06 03:57:36 +01:00
use Psalm\Internal\Analyzer\ClassLikeAnalyzer;
use Psalm\Internal\Analyzer\Statements\ExpressionAnalyzer;
use Psalm\Internal\Analyzer\StatementsAnalyzer;
use Psalm\Internal\Analyzer\TraitAnalyzer;
use Psalm\Codebase;
2018-01-14 18:09:40 +01:00
use Psalm\CodeLocation;
use Psalm\Context;
use Psalm\Issue\DeprecatedConstant;
2018-01-14 18:09:40 +01:00
use Psalm\Issue\InaccessibleClassConstant;
use Psalm\Issue\ParentNotFound;
use Psalm\Issue\UndefinedConstant;
use Psalm\IssueBuffer;
use Psalm\Type;
2018-11-06 03:57:36 +01:00
class ConstFetchAnalyzer
2018-01-14 18:09:40 +01:00
{
/**
2018-11-06 03:57:36 +01:00
* @param StatementsAnalyzer $statements_checker
2018-01-14 18:09:40 +01:00
* @param PhpParser\Node\Expr\ConstFetch $stmt
* @param Context $context
*
* @return void
2018-01-14 18:09:40 +01:00
*/
public static function analyze(
2018-11-06 03:57:36 +01:00
StatementsAnalyzer $statements_checker,
2018-01-14 18:09:40 +01:00
PhpParser\Node\Expr\ConstFetch $stmt,
Context $context
) {
$const_name = implode('\\', $stmt->name->parts);
switch (strtolower($const_name)) {
case 'null':
$stmt->inferredType = Type::getNull();
break;
case 'false':
// false is a subtype of bool
$stmt->inferredType = Type::getFalse();
break;
case 'true':
$stmt->inferredType = Type::getTrue();
break;
case 'stdin':
$stmt->inferredType = Type::getResource();
break;
default:
$const_type = $statements_checker->getConstType(
$statements_checker,
$const_name,
$stmt->name instanceof PhpParser\Node\Name\FullyQualified,
$context
);
if ($const_type) {
$stmt->inferredType = clone $const_type;
} elseif ($context->check_consts) {
if (IssueBuffer::accepts(
new UndefinedConstant(
'Const ' . $const_name . ' is not defined',
new CodeLocation($statements_checker->getSource(), $stmt)
),
$statements_checker->getSuppressedIssues()
)) {
// fall through
2018-01-14 18:09:40 +01:00
}
}
}
}
/**
2018-11-06 03:57:36 +01:00
* @param StatementsAnalyzer $statements_checker
2018-01-14 18:09:40 +01:00
* @param PhpParser\Node\Expr\ClassConstFetch $stmt
* @param Context $context
*
* @return null|false
*/
public static function analyzeClassConst(
2018-11-06 03:57:36 +01:00
StatementsAnalyzer $statements_checker,
2018-01-14 18:09:40 +01:00
PhpParser\Node\Expr\ClassConstFetch $stmt,
Context $context
) {
2018-11-06 03:57:36 +01:00
$project_checker = $statements_checker->getFileAnalyzer()->project_checker;
$codebase = $statements_checker->getCodebase();
if ($context->check_consts
&& $stmt->class instanceof PhpParser\Node\Name
2018-01-14 18:09:40 +01:00
) {
2018-01-23 21:46:14 +01:00
$first_part_lc = strtolower($stmt->class->parts[0]);
if ($first_part_lc === 'self' || $first_part_lc === 'static') {
2018-01-14 18:09:40 +01:00
if (!$context->self) {
throw new \UnexpectedValueException('$context->self cannot be null');
}
$fq_class_name = (string)$context->self;
2018-01-23 21:46:14 +01:00
} elseif ($first_part_lc === 'parent') {
2018-01-14 18:09:40 +01:00
$fq_class_name = $statements_checker->getParentFQCLN();
if ($fq_class_name === null) {
if (IssueBuffer::accepts(
new ParentNotFound(
'Cannot check property fetch on parent as this class does not extend another',
new CodeLocation($statements_checker->getSource(), $stmt)
),
$statements_checker->getSuppressedIssues()
)) {
return false;
}
return;
}
} else {
2018-11-06 03:57:36 +01:00
$fq_class_name = ClassLikeAnalyzer::getFQCLNFromNameObject(
2018-01-14 18:09:40 +01:00
$stmt->class,
$statements_checker->getAliases()
);
if ($stmt->name instanceof PhpParser\Node\Identifier) {
if (!$context->inside_class_exists || $stmt->name->name !== 'class') {
2018-11-06 03:57:36 +01:00
if (ClassLikeAnalyzer::checkFullyQualifiedClassLikeName(
$statements_checker,
$fq_class_name,
new CodeLocation($statements_checker->getSource(), $stmt->class),
$statements_checker->getSuppressedIssues(),
false
) === false) {
return false;
}
}
2018-01-14 18:09:40 +01:00
}
}
if ($stmt->name instanceof PhpParser\Node\Identifier && $stmt->name->name === 'class') {
$stmt->inferredType = Type::getClassString($fq_class_name);
2018-01-14 18:09:40 +01:00
return null;
}
// if we're ignoring that the class doesn't exist, exit anyway
2018-02-01 06:50:01 +01:00
if (!$codebase->classOrInterfaceExists($fq_class_name)) {
2018-01-14 18:09:40 +01:00
$stmt->inferredType = Type::getMixed();
return null;
}
if ($codebase->server_mode) {
$codebase->analyzer->addNodeReference(
$statements_checker->getFilePath(),
$stmt->class,
$fq_class_name
);
}
if (!$stmt->name instanceof PhpParser\Node\Identifier) {
return null;
}
2018-01-14 18:09:40 +01:00
$const_id = $fq_class_name . '::' . $stmt->name;
if ($codebase->server_mode) {
$codebase->analyzer->addNodeReference(
$statements_checker->getFilePath(),
$stmt->name,
$const_id
);
}
2018-01-14 18:09:40 +01:00
if ($fq_class_name === $context->self
|| (
2018-11-06 03:57:36 +01:00
$statements_checker->getSource()->getSource() instanceof TraitAnalyzer &&
2018-01-14 18:09:40 +01:00
$fq_class_name === $statements_checker->getSource()->getFQCLN()
)
) {
$class_visibility = \ReflectionProperty::IS_PRIVATE;
} elseif ($context->self &&
2018-02-01 06:50:01 +01:00
$codebase->classExtends($context->self, $fq_class_name)
2018-01-14 18:09:40 +01:00
) {
$class_visibility = \ReflectionProperty::IS_PROTECTED;
} else {
$class_visibility = \ReflectionProperty::IS_PUBLIC;
}
$class_constants = $codebase->classlikes->getConstantsForClass(
2018-01-14 18:09:40 +01:00
$fq_class_name,
$class_visibility
);
if (!isset($class_constants[$stmt->name->name]) && $first_part_lc !== 'static') {
2018-01-14 18:09:40 +01:00
$all_class_constants = [];
if ($fq_class_name !== $context->self) {
$all_class_constants = $codebase->classlikes->getConstantsForClass(
2018-01-14 18:09:40 +01:00
$fq_class_name,
\ReflectionProperty::IS_PRIVATE
);
}
if ($all_class_constants && isset($all_class_constants[$stmt->name->name])) {
if (IssueBuffer::accepts(
2018-01-14 18:09:40 +01:00
new InaccessibleClassConstant(
'Constant ' . $const_id . ' is not visible in this context',
new CodeLocation($statements_checker->getSource(), $stmt)
),
$statements_checker->getSuppressedIssues()
)) {
// fall through
}
2018-01-14 18:09:40 +01:00
} else {
if (IssueBuffer::accepts(
2018-01-14 18:09:40 +01:00
new UndefinedConstant(
'Constant ' . $const_id . ' is not defined',
new CodeLocation($statements_checker->getSource(), $stmt)
),
$statements_checker->getSuppressedIssues()
)) {
// fall through
}
2018-01-14 18:09:40 +01:00
}
return false;
}
if ($context->calling_method_id) {
$project_checker->file_reference_provider->addReferenceToClassMethod(
$context->calling_method_id,
strtolower($fq_class_name) . '::' . $stmt->name->name
);
}
$class_const_storage = $codebase->classlike_storage_provider->get($fq_class_name);
if (isset($class_const_storage->deprecated_constants[$stmt->name->name])) {
if (IssueBuffer::accepts(
new DeprecatedConstant(
'Constant ' . $const_id . ' is deprecated',
new CodeLocation($statements_checker->getSource(), $stmt)
),
$statements_checker->getSuppressedIssues()
)) {
// fall through
}
}
if (isset($class_constants[$stmt->name->name]) && $first_part_lc !== 'static') {
$stmt->inferredType = clone $class_constants[$stmt->name->name];
} else {
$stmt->inferredType = Type::getMixed();
}
2018-01-14 18:09:40 +01:00
return null;
}
$stmt->inferredType = Type::getMixed();
if ($stmt->class instanceof PhpParser\Node\Expr) {
2018-11-06 03:57:36 +01:00
if (ExpressionAnalyzer::analyze($statements_checker, $stmt->class, $context) === false) {
2018-01-14 18:09:40 +01:00
return false;
}
}
return null;
}
/**
* @param Codebase $codebase
2018-07-06 20:14:24 +02:00
* @param ?string $fq_const_name
* @param string $const_name
*
* @return Type\Union|null
*/
public static function getGlobalConstType(
Codebase $codebase,
$fq_const_name,
$const_name
) {
if ($const_name === 'STDERR'
|| $const_name === 'STDOUT'
|| $const_name === 'STDIN'
) {
return Type::getResource();
}
$predefined_constants = $codebase->config->getPredefinedConstants();
if (isset($predefined_constants[$fq_const_name ?: $const_name])) {
switch ($fq_const_name ?: $const_name) {
case 'PHP_VERSION':
case 'DIRECTORY_SEPARATOR':
case 'PATH_SEPARATOR':
case 'PEAR_EXTENSION_DIR':
case 'PEAR_INSTALL_DIR':
case 'PHP_BINARY':
case 'PHP_BINDIR':
case 'PHP_CONFIG_FILE_PATH':
case 'PHP_CONFIG_FILE_SCAN_DIR':
case 'PHP_DATADIR':
case 'PHP_EOL':
case 'PHP_EXTENSION_DIR':
case 'PHP_EXTRA_VERSION':
case 'PHP_LIBDIR':
case 'PHP_LOCALSTATEDIR':
case 'PHP_MANDIR':
case 'PHP_OS':
case 'PHP_OS_FAMILY':
case 'PHP_PREFIX':
case 'PHP_SAPI':
case 'PHP_SYSCONFDIR':
return Type::getString();
case 'PHP_MAJOR_VERSION':
case 'PHP_MINOR_VERSION':
case 'PHP_RELEASE_VERSION':
case 'PHP_DEBUG':
case 'PHP_FLOAT_DIG':
case 'PHP_INT_MAX':
case 'PHP_INT_MIN':
case 'PHP_INT_SIZE':
case 'PHP_MAXPATHLEN':
case 'PHP_VERSION_ID':
case 'PHP_ZTS':
return Type::getInt();
case 'PHP_FLOAT_EPSILON':
case 'PHP_FLOAT_MAX':
case 'PHP_FLOAT_MIN':
return Type::getFloat();
}
2018-11-06 03:57:36 +01:00
$type = ClassLikeAnalyzer::getTypeFromValue($predefined_constants[$fq_const_name ?: $const_name]);
return $type;
}
$stubbed_const_type = $codebase->getStubbedConstantType(
$fq_const_name ?: $const_name
);
if ($stubbed_const_type) {
return $stubbed_const_type;
}
return null;
}
2018-01-14 18:09:40 +01:00
}