Checks whether the name is fully qualified. (E.g. \Name)
public isFullyQualified ( ) : boolean | ||
리턴 | 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); }