Checks whether the name is fully qualified. (E.g. \Name)
| public isFullyQualified ( ) : boolean | ||
| return | boolean | Whether the name is fully qualified |
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;
}
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());
}
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);
}
}
}
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 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 parseAbsoluteName(Node\Name $node)
{
return ($node->isFullyQualified() ? '\\' : '') . (string) $node;
}
/**
* @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;
}
/**
* @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);
}
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])) {
$alias = $this->aliases[Stmt\Use_::TYPE_NORMAL][$aliasName];
return FullyQualified::concat($alias, $name->slice(1), $name->getAttributes());
}
if ($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
return new FullyQualified($this->aliases[$type][$aliasName], $name->getAttributes());
}
if (null === $this->namespace) {
// outside of a namespace unaliased unqualified is same as fully qualified
return new FullyQualified($name, $name->getAttributes());
}
// unqualified names inside a namespace cannot be resolved at compile-time
// add the namespaced version of the name as an attribute
$name->setAttribute('namespacedName', FullyQualified::concat($this->namespace, $name, $name->getAttributes()));
return $name;
}
// if no alias exists prepend current namespace
return FullyQualified::concat($this->namespace, $name, $name->getAttributes());
}
private function getQualifiedName(Name $type)
{
$parts = $type->parts;
if ($type->isFullyQualified()) {
$qualifiedName = "\\{$type->toString()}";
} else {
if (isset($this->aliases[$parts[0]])) {
$use = $this->aliases[$parts[0]];
$parts[0] = "\\" . $use->getName();
$use->markUsed();
} else {
$parts[0] = $this->namespace . "\\" . $parts[0];
}
$qualifiedName = implode("\\", $parts);
}
return $this->cannonicalize($qualifiedName);
}
