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;
|
2018-07-06 19:35:36 +02:00
|
|
|
use Psalm\Codebase;
|
2018-01-14 18:09:40 +01:00
|
|
|
use Psalm\CodeLocation;
|
|
|
|
use Psalm\Context;
|
2018-08-10 19:25:25 +02:00
|
|
|
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
|
|
|
|
*
|
2018-02-08 02:26:26 +01:00
|
|
|
* @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()
|
|
|
|
)) {
|
2018-02-08 02:26:26 +01:00
|
|
|
// 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();
|
|
|
|
|
2018-04-17 18:16:25 +02:00
|
|
|
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()
|
|
|
|
);
|
|
|
|
|
2018-10-26 22:17:15 +02:00
|
|
|
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(
|
2018-10-26 22:17:15 +02:00
|
|
|
$statements_checker,
|
|
|
|
$fq_class_name,
|
|
|
|
new CodeLocation($statements_checker->getSource(), $stmt->class),
|
|
|
|
$statements_checker->getSuppressedIssues(),
|
|
|
|
false
|
|
|
|
) === false) {
|
|
|
|
return false;
|
|
|
|
}
|
2018-04-19 18:16:00 +02:00
|
|
|
}
|
2018-01-14 18:09:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-26 22:17:15 +02:00
|
|
|
if ($stmt->name instanceof PhpParser\Node\Identifier && $stmt->name->name === 'class') {
|
2018-04-04 04:20:00 +02:00
|
|
|
$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;
|
|
|
|
}
|
|
|
|
|
2018-10-26 22:17:15 +02:00
|
|
|
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;
|
|
|
|
|
2018-10-26 22:17:15 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-02-09 00:18:34 +01:00
|
|
|
$class_constants = $codebase->classlikes->getConstantsForClass(
|
2018-01-14 18:09:40 +01:00
|
|
|
$fq_class_name,
|
|
|
|
$class_visibility
|
|
|
|
);
|
|
|
|
|
2018-04-17 18:16:25 +02:00
|
|
|
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) {
|
2018-02-09 00:18:34 +01:00
|
|
|
$all_class_constants = $codebase->classlikes->getConstantsForClass(
|
2018-01-14 18:09:40 +01:00
|
|
|
$fq_class_name,
|
|
|
|
\ReflectionProperty::IS_PRIVATE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2018-04-17 18:16:25 +02:00
|
|
|
if ($all_class_constants && isset($all_class_constants[$stmt->name->name])) {
|
2018-05-03 19:20:42 +02:00
|
|
|
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)
|
2018-05-03 19:20:42 +02:00
|
|
|
),
|
|
|
|
$statements_checker->getSuppressedIssues()
|
|
|
|
)) {
|
|
|
|
// fall through
|
|
|
|
}
|
2018-01-14 18:09:40 +01:00
|
|
|
} else {
|
2018-05-03 19:20:42 +02:00
|
|
|
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)
|
2018-05-03 19:20:42 +02:00
|
|
|
),
|
|
|
|
$statements_checker->getSuppressedIssues()
|
|
|
|
)) {
|
|
|
|
// fall through
|
|
|
|
}
|
2018-01-14 18:09:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2018-05-12 05:14:44 +02:00
|
|
|
|
2018-09-26 00:37:24 +02:00
|
|
|
if ($context->calling_method_id) {
|
2018-09-28 22:18:45 +02:00
|
|
|
$project_checker->file_reference_provider->addReferenceToClassMethod(
|
2018-09-26 00:37:24 +02:00
|
|
|
$context->calling_method_id,
|
|
|
|
strtolower($fq_class_name) . '::' . $stmt->name->name
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2018-08-10 19:25:25 +02:00
|
|
|
$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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-12 05:14:44 +02:00
|
|
|
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;
|
|
|
|
}
|
2018-07-06 19:35:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @param Codebase $codebase
|
2018-07-06 20:14:24 +02:00
|
|
|
* @param ?string $fq_const_name
|
2018-07-06 19:35:36 +02:00
|
|
|
* @param string $const_name
|
|
|
|
*
|
|
|
|
* @return Type\Union|null
|
|
|
|
*/
|
|
|
|
public static function getGlobalConstType(
|
|
|
|
Codebase $codebase,
|
|
|
|
$fq_const_name,
|
|
|
|
$const_name
|
|
|
|
) {
|
2018-07-10 23:40:34 +02:00
|
|
|
if ($const_name === 'STDERR'
|
|
|
|
|| $const_name === 'STDOUT'
|
|
|
|
|| $const_name === 'STDIN'
|
|
|
|
) {
|
|
|
|
return Type::getResource();
|
|
|
|
}
|
|
|
|
|
2018-07-06 19:35:36 +02:00
|
|
|
$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]);
|
2018-07-06 19:35:36 +02:00
|
|
|
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
|
|
|
}
|