protected function resolveOtherName(Name $name, $type)
{
if (!$name instanceof FullyQualified) {
$name->setAttribute('resolvedFqcn', parent::resolveOtherName($name, $type));
}
return $name;
}
/**
* Constructs an alias (use) node.
*
* @param Node\Name $name Namespace/Class to alias
* @param null|string $alias Alias
* @param array $attributes Additional attributes
*/
public function __construct(Node\Name $name, $alias = null, array $attributes = array())
{
if (null === $alias) {
$alias = $name->getLast();
}
if ('self' == $alias || 'parent' == $alias) {
throw new Error(sprintf('Cannot use %s as %s because \'%2$s\' is a special class name', $name, $alias));
}
parent::__construct(array('name' => $name, 'alias' => $alias), $attributes);
}
/**
* Constructs an alias (use) node.
*
* @param Node\Name $name Namespace/Class to alias
* @param null|string $alias Alias
* @param int $type Type of the use element (for mixed group use declarations only)
* @param array $attributes Additional attributes
*/
public function __construct(Node\Name $name, $alias = null, $type = Use_::TYPE_UNKNOWN, array $attributes = array())
{
if (null === $alias) {
$alias = $name->getLast();
}
parent::__construct($attributes);
$this->type = $type;
$this->name = $name;
$this->alias = $alias;
}
protected function resolveClassName(PhpParser\Node\Name $name)
{
if ($name->isFullyQualified()) {
return $name;
}
$old = $name->toString();
$resolved = parent::resolveClassName($name);
$this->resolvedClasses[$old] = $resolved->toString();
return $resolved;
}
/**
* {@inheritdoc}
*/
public function isValidBetween(Name $from, Name $to)
{
$this->lastResult = $this->inspector->isAllowed($from->toString(), $to->toString());
if (!is_null($this->collector) && $this->lastResult->isDenied()) {
$this->collector->major(new PolicyViolation($from, $to, $this->lastResult));
}
if (!is_null($this->collector) && $this->lastResult->isUndefined()) {
$this->collector->undefined(new PolicyViolation($from, $to, $this->lastResult));
}
return $this->lastResult->isAllowed();
}
public function leaveNode(Node $node)
{
if ($node->hasAttribute(NameResolver::TAG_NAMES_ATTRIBUTE)) {
$tags = $node->getAttribute(NameResolver::TAG_NAMES_ATTRIBUTE);
foreach ($tags as $tagName) {
$name = new Node\Name($tagName);
$name->setAttribute('isComment', true);
$this->collect($name, $node);
}
}
}
/**
* Constructs an alias (use) node.
*
* @param Node\Name $name Namespace/Class to alias
* @param null|string $alias Alias
* @param array $attributes Additional attributes
*/
public function __construct(Node\Name $name, $alias = null, array $attributes = array())
{
if (null === $alias) {
$alias = $name->getLast();
}
if ('self' == strtolower($alias) || 'parent' == strtolower($alias)) {
throw new Error(sprintf('Cannot use %s as %s because \'%2$s\' is a special class name', $name, $alias));
}
parent::__construct(null, $attributes);
$this->name = $name;
$this->alias = $alias;
}
/**
* @param SplFileInfo $file
* @param Name $name
* @throws \DomainException
*/
public function __construct(SplFileInfo $file, Name $name)
{
$attributes = $name->getAttributes();
if (!isset($attributes['startLine']) || !isset($attributes['endLine'])) {
throw new \DomainException('Values for startLine and/or endLine are not set in attributes');
}
$this->file = $file;
$this->startLine = (int) $attributes['startLine'];
$this->endline = (int) $attributes['endLine'];
if (isset($attributes['isComment'])) {
$this->isComment = (bool) $attributes['isComment'];
}
}
private function checkIfTypeIsAnInterface(Node $node, Name $type)
{
$name = (string) $type;
if ($type->isFullyQualified() === false) {
$name = $this->currentNamespace . '\\' . $name;
}
if (isset($this->types[$name])) {
$objectTypeType = $this->types[$name];
if ($objectTypeType !== ObjectType::TYPE_INTERFACE) {
$defect = new DependencyUponImplementation($node, $name, $objectTypeType, $this->currentMethod->name);
$defect->setContext($this->currentMethod);
$this->dispatch($defect);
}
}
}
private function checkFunction(Name $name, FuncCall $node)
{
// check for a function inside the class namespace as well as imported
// functions first.
$func = $this->getContext()->getClassName($name->toString());
if (!function_exists($func)) {
// get the plain function name without namespaces
$func = $name->toString();
}
// check if the function exists in the global namespace
if (!function_exists($func)) {
$this->addError($this->createUndefinedFunctionError($func, $node));
return;
}
$refl = new ReflectionFunction($func);
$params = $refl->getParameters();
// it's not possible to check for default values/optionalness etc. on
// internal functions
if (!$refl->isInternal()) {
// verify number of arguments
if (count($node->args) > count($params)) {
// cannot error on this as php functions can use func_get_args()
}
$requiredParams = 0;
foreach ($params as $param) {
if ($param->isOptional() || $param->isDefaultValueAvailable()) {
break;
}
$requiredParams++;
}
if (count($node->args) < $requiredParams) {
$this->addError($this->createNotEnoughParamsError($node, $func, $requiredParams));
}
}
// look for function parameters passed by reference
foreach ($params as $param) {
if ($param->isPassedByReference()) {
$pos = $param->getPosition();
if (isset($node->args[$pos])) {
$var = $node->args[$pos]->value;
if ($var instanceof Variable) {
$this->getContext()->setVariable($var->name, $var);
}
}
}
}
}
protected function addAlias(Stmt\UseUse $use, $type, Name $prefix = null)
{
parent::addAlias($use, $type, $prefix);
if ($type == Stmt\Use_::TYPE_NORMAL) {
// Add prefix for group uses
$name = strval($prefix ? Name::concat($prefix, $use->name) : $use->name);
$this->classAliases[$use->alias] = $name;
}
}
public function getFQCN(Name $node = null)
{
if ($node === null) {
return $node;
}
if ($node->isFullyQualified()) {
return $this->parseFQCN($node->toString());
}
$fqcn = $this->uses->find($node->getFirst());
if ($fqcn) {
return $fqcn;
}
return $this->createFQCN($node->toString());
}
/**
* @param Name|string $name
*
* @return string
*/
private function getFullClassName($name)
{
if ($name instanceof Name) {
if ($name->isFullyQualified()) {
return $name->toString();
}
}
$name = (string) $name;
if (isset($this->namespace->uses[$name])) {
return $this->namespace->uses[$name];
}
if ($this->namespace->name) {
return $this->namespace->name . '\\' . $name;
}
return $name;
}
protected function addNamespacedName(Node $node)
{
if (null !== $this->namespace) {
$node->namespacedName = Name::concat($this->namespace, $node->name);
} else {
$node->namespacedName = new Name($node->name);
}
}
protected function parseAbsoluteName(Node\Name $node)
{
return ($node->isFullyQualified() ? '\\' : '') . (string) $node;
}
/**
* @param Node\Name $expr
* @return CompiledExpression
*/
public function getNodeName(Node\Name $expr)
{
$nodeString = $expr->toString();
if ($nodeString === 'null') {
return new CompiledExpression(CompiledExpression::NULL);
}
if (in_array($nodeString, ['parent'], true)) {
/** @var ClassDefinition $scope */
$scope = $this->context->scope;
assert($scope instanceof ClassDefinition);
if ($scope->getExtendsClass()) {
$definition = $scope->getExtendsClassDefinition();
if ($definition) {
return new CompiledExpression(CompiledExpression::OBJECT, $definition);
}
} else {
$this->context->notice('language_error', 'Cannot access parent:: when current class scope has no parent', $expr);
}
}
if (in_array($nodeString, ['self', 'static'], true)) {
return CompiledExpression::fromZvalValue($this->context->scope);
}
if (defined($nodeString)) {
return CompiledExpression::fromZvalValue(constant($expr));
}
return new CompiledExpression(CompiledExpression::STRING, $expr->toString());
}
public function enterNode(Node $node)
{
if ($node instanceof UseUse) {
$node->name = Name::concat($this->prefix, $node->name);
}
}
protected function resolveOtherName(Name $name, $type)
{
// fully qualified names are already resolved
if ($name->isFullyQualified()) {
return $name;
}
// resolve aliases for qualified names
$aliasName = strtolower($name->getFirst());
if ($name->isQualified() && isset($this->aliases[Stmt\Use_::TYPE_NORMAL][$aliasName])) {
$name->setFirst($this->aliases[Stmt\Use_::TYPE_NORMAL][$aliasName]);
} elseif ($name->isUnqualified()) {
if ($type === Stmt\Use_::TYPE_CONSTANT) {
// constant aliases are case-sensitive, function aliases case-insensitive
$aliasName = $name->getFirst();
}
if (isset($this->aliases[$type][$aliasName])) {
// resolve unqualified aliases
$name->set($this->aliases[$type][$aliasName]);
} else {
// unqualified, unaliased names cannot be resolved at compile-time
return $name;
}
} elseif (null !== $this->namespace) {
// if no alias exists prepend current namespace
$name->prepend($this->namespace);
}
return new Name\FullyQualified($name->parts, $name->getAttributes());
}
/**
* @param Node\Name $namespacedString
*/
public function addNamespacedString(Node\Name $namespacedString)
{
$this->namespacedStrings[$namespacedString->toString()] = $namespacedString;
}
/**
* Utility method to fetch reflection class instance by name
*
* Supports:
* 'self' keyword
* 'parent' keyword
* not-FQN class names
*
* @param Node\Name $node Class name node
*
* @return bool|\ReflectionClass
*
* @throws ReflectionException
*/
private function fetchReflectionClass(Node\Name $node)
{
$className = $node->toString();
$isFQNClass = $node instanceof Node\Name\FullyQualified;
if ($isFQNClass) {
return new ReflectionClass($className);
}
if ('self' === $className) {
if ($this->context instanceof \ReflectionClass) {
return $this->context;
} elseif (method_exists($this->context, 'getDeclaringClass')) {
return $this->context->getDeclaringClass();
}
}
if ('parent' === $className) {
if ($this->context instanceof \ReflectionClass) {
return $this->context->getParentClass();
} elseif (method_exists($this->context, 'getDeclaringClass')) {
return $this->context->getDeclaringClass()->getParentClass();
}
}
if (method_exists($this->context, 'getFileName')) {
/** @var ReflectionFileNamespace|null $fileNamespace */
$fileName = $this->context->getFileName();
$namespaceName = $this->context->getNamespaceName();
$fileNamespace = new ReflectionFileNamespace($fileName, $namespaceName);
return $fileNamespace->getClass($className);
}
throw new ReflectionException("Can not resolve class {$className}");
}
/**
* @param Name $name
* @return string
*/
protected function resolveName(Name $name)
{
$parts = $name->parts;
if (!$name->isFullyQualified()) {
/** @var NULL|UseUse $lastMatch */
$lastMatch = NULL;
foreach ($this->uses as $use) {
foreach ($use->uses as $useuse) {
if ($useuse->alias === $parts[0]) {
$lastMatch = $useuse;
}
}
}
if (NULL !== $lastMatch) {
$parts[0] = join('\\', $lastMatch->name->parts);
} else {
if (!empty($this->namespace)) {
# No alias in 'use' matching, it's in the current namespace, if present
array_unshift($parts, $this->namespace);
}
}
}
return join('\\', $parts);
}
/**
* Prepare a name
*
* If the first argument is an instance of `PhpParser\Node\Name` its string representation
* will be returned as first element of the result array. The value retrieved via `PhpParser\Node\Name::getLine()`
* will be used as second element.
* If the first parameter is not an instance of `PhpParser\Node\Name` it will be casted to string and returned alongside
* with the value given for the second parameter as line
*
* @param \PhpParser\Node\Name|string $name
* @param int $line Only used if the $name parameter is not an instance of `PhpParser\Node\Name`
* @return array
*/
private function prepareNameAndLine($name, $line = -1)
{
if ($name instanceof Node\Name) {
$line = $name->getLine();
$name = $name->toString();
} else {
$name = (string) $name;
}
return [$name, $line];
}
/**
* @param NodeInterface\Name $trait
*/
public function addTraitUseAlias(TraitUseAliasNode $adaptation, $trait)
{
if (is_null($adaptation->trait)) {
$this->context->getReflection()->addTraitMethodAlias((string) $trait->toString(), (string) $adaptation->method, (string) $adaptation->newName);
} else {
$this->context->getReflection()->addTraitMethodAlias((string) $adaptation->trait->toString(), (string) $adaptation->method, (string) $adaptation->newName);
}
}
/**
* @param Node\Name $usedTraitNamespace
*/
public function addUsedTraitNamespace(Node\Name $usedTraitNamespace)
{
$this->usedTraitNamespaces[$usedTraitNamespace->toString()] = $usedTraitNamespace;
}
/**
* @param Name $name
* @return Vertex
*/
private function createVertexBy(Name $name)
{
$vertex = $this->getGraph()->createVertex($name->toString(), true);
if ($groupId = $this->groupGenerator->getIdFor($name)) {
$vertex->setGroup($groupId);
$vertex->setAttribute('graphviz.group', $groupId);
}
$this->bindLayoutTo($vertex, $this->layout->getVertex());
return $vertex;
}
protected function addNamespacedName(Node $node) {
$node->namespacedName = Name::concat($this->namespace, $node->name);
}
/**
* @param Node\Name $target
* @param Node $source
*/
private function exchange(Node\Name $target, Node $source)
{
$attributes = $source->getAttributes();
foreach ($attributes as $attr => $value) {
$target->setAttribute($attr, $value);
}
}
protected function parseExpr_FuncCall(Expr\FuncCall $expr)
{
$args = $this->parseExprList($expr->args, self::MODE_READ);
$name = $this->parseExprNode($expr->name);
if ($this->currentNamespace && $expr->name instanceof Node\Name && $expr->name->isUnqualified()) {
$op = new Op\Expr\NsFuncCall($name, $this->parseExprNode(Node\Name::concat($this->currentNamespace, $expr->name)), $args, $this->mapAttributes($expr));
} else {
$op = new Op\Expr\FuncCall($name, $args, $this->mapAttributes($expr));
}
if ($name instanceof Operand\Literal) {
static $assertionFunctions = ['is_array' => 'array', 'is_bool' => 'bool', 'is_callable' => 'callable', 'is_double' => 'float', 'is_float' => 'float', 'is_int' => 'int', 'is_integer' => 'int', 'is_long' => 'int', 'is_null' => 'null', 'is_numeric' => 'numeric', 'is_object' => 'object', 'is_real' => 'float', 'is_string' => 'string', 'is_resource' => 'resource'];
$lname = strtolower($name->value);
if (isset($assertionFunctions[$lname])) {
$op->result->addAssertion($args[0], new Assertion\TypeAssertion(new Operand\Literal($assertionFunctions[$lname])));
}
}
return $op;
}
protected function handleScalarTypes(Name $name)
{
$scalarTypes = ['bool' => true, 'int' => true, 'float' => true, 'string' => true];
if (!$name->isUnqualified()) {
return $name;
}
$lowerName = strtolower($name->toString());
return isset($scalarTypes[$lowerName]) ? $lowerName : $name;
}
/**
* @param \PhpParser\Node\Name $nameNode
* @param \PHPStan\Analyser\Scope|null $scope
* @return string|null
*/
public function resolveFunctionName(\PhpParser\Node\Name $nameNode, Scope $scope = null)
{
$name = (string) $nameNode;
if ($scope !== null && $scope->getNamespace() !== null && !$nameNode->isFullyQualified()) {
$namespacedName = sprintf('%s\\%s', $scope->getNamespace(), $name);
if (function_exists($namespacedName)) {
return $namespacedName;
}
}
if (function_exists($name)) {
return $name;
}
return null;
}
