243 lines
7.5 KiB
PHP
243 lines
7.5 KiB
PHP
<?php declare(strict_types=1);
|
|
|
|
namespace PhpParser\Node;
|
|
|
|
use PhpParser\NodeAbstract;
|
|
|
|
class Name extends NodeAbstract
|
|
{
|
|
/** @var string[] Parts of the name */
|
|
public $parts;
|
|
|
|
private static $specialClassNames = [
|
|
'self' => true,
|
|
'parent' => true,
|
|
'static' => true,
|
|
];
|
|
|
|
/**
|
|
* Constructs a name node.
|
|
*
|
|
* @param string|string[]|self $name Name as string, part array or Name instance (copy ctor)
|
|
* @param array $attributes Additional attributes
|
|
*/
|
|
public function __construct($name, array $attributes = []) {
|
|
$this->attributes = $attributes;
|
|
$this->parts = self::prepareName($name);
|
|
}
|
|
|
|
public function getSubNodeNames() : array {
|
|
return ['parts'];
|
|
}
|
|
|
|
/**
|
|
* Gets the first part of the name, i.e. everything before the first namespace separator.
|
|
*
|
|
* @return string First part of the name
|
|
*/
|
|
public function getFirst() : string {
|
|
return $this->parts[0];
|
|
}
|
|
|
|
/**
|
|
* Gets the last part of the name, i.e. everything after the last namespace separator.
|
|
*
|
|
* @return string Last part of the name
|
|
*/
|
|
public function getLast() : string {
|
|
return $this->parts[count($this->parts) - 1];
|
|
}
|
|
|
|
/**
|
|
* Checks whether the name is unqualified. (E.g. Name)
|
|
*
|
|
* @return bool Whether the name is unqualified
|
|
*/
|
|
public function isUnqualified() : bool {
|
|
return 1 === count($this->parts);
|
|
}
|
|
|
|
/**
|
|
* Checks whether the name is qualified. (E.g. Name\Name)
|
|
*
|
|
* @return bool Whether the name is qualified
|
|
*/
|
|
public function isQualified() : bool {
|
|
return 1 < count($this->parts);
|
|
}
|
|
|
|
/**
|
|
* Checks whether the name is fully qualified. (E.g. \Name)
|
|
*
|
|
* @return bool Whether the name is fully qualified
|
|
*/
|
|
public function isFullyQualified() : bool {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
|
|
*
|
|
* @return bool Whether the name is relative
|
|
*/
|
|
public function isRelative() : bool {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the name itself, without taking the name type into
|
|
* account (e.g., not including a leading backslash for fully qualified names).
|
|
*
|
|
* @return string String representation
|
|
*/
|
|
public function toString() : string {
|
|
return implode('\\', $this->parts);
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the name as it would occur in code (e.g., including
|
|
* leading backslash for fully qualified names.
|
|
*
|
|
* @return string String representation
|
|
*/
|
|
public function toCodeString() : string {
|
|
return $this->toString();
|
|
}
|
|
|
|
/**
|
|
* Returns lowercased string representation of the name, without taking the name type into
|
|
* account (e.g., no leading backslash for fully qualified names).
|
|
*
|
|
* @return string Lowercased string representation
|
|
*/
|
|
public function toLowerString() : string {
|
|
return strtolower(implode('\\', $this->parts));
|
|
}
|
|
|
|
/**
|
|
* Checks whether the identifier is a special class name (self, parent or static).
|
|
*
|
|
* @return bool Whether identifier is a special class name
|
|
*/
|
|
public function isSpecialClassName() : bool {
|
|
return count($this->parts) === 1
|
|
&& isset(self::$specialClassNames[strtolower($this->parts[0])]);
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the name by imploding the namespace parts with the
|
|
* namespace separator.
|
|
*
|
|
* @return string String representation
|
|
*/
|
|
public function __toString() : string {
|
|
return implode('\\', $this->parts);
|
|
}
|
|
|
|
/**
|
|
* Gets a slice of a name (similar to array_slice).
|
|
*
|
|
* This method returns a new instance of the same type as the original and with the same
|
|
* attributes.
|
|
*
|
|
* If the slice is empty, null is returned. The null value will be correctly handled in
|
|
* concatenations using concat().
|
|
*
|
|
* Offset and length have the same meaning as in array_slice().
|
|
*
|
|
* @param int $offset Offset to start the slice at (may be negative)
|
|
* @param int|null $length Length of the slice (may be negative)
|
|
*
|
|
* @return static|null Sliced name
|
|
*/
|
|
public function slice(int $offset, int $length = null) {
|
|
$numParts = count($this->parts);
|
|
|
|
$realOffset = $offset < 0 ? $offset + $numParts : $offset;
|
|
if ($realOffset < 0 || $realOffset > $numParts) {
|
|
throw new \OutOfBoundsException(sprintf('Offset %d is out of bounds', $offset));
|
|
}
|
|
|
|
if (null === $length) {
|
|
$realLength = $numParts - $realOffset;
|
|
} else {
|
|
$realLength = $length < 0 ? $length + $numParts - $realOffset : $length;
|
|
if ($realLength < 0 || $realLength > $numParts - $realOffset) {
|
|
throw new \OutOfBoundsException(sprintf('Length %d is out of bounds', $length));
|
|
}
|
|
}
|
|
|
|
if ($realLength === 0) {
|
|
// Empty slice is represented as null
|
|
return null;
|
|
}
|
|
|
|
return new static(array_slice($this->parts, $realOffset, $realLength), $this->attributes);
|
|
}
|
|
|
|
/**
|
|
* Concatenate two names, yielding a new Name instance.
|
|
*
|
|
* The type of the generated instance depends on which class this method is called on, for
|
|
* example Name\FullyQualified::concat() will yield a Name\FullyQualified instance.
|
|
*
|
|
* If one of the arguments is null, a new instance of the other name will be returned. If both
|
|
* arguments are null, null will be returned. As such, writing
|
|
* Name::concat($namespace, $shortName)
|
|
* where $namespace is a Name node or null will work as expected.
|
|
*
|
|
* @param string|string[]|self|null $name1 The first name
|
|
* @param string|string[]|self|null $name2 The second name
|
|
* @param array $attributes Attributes to assign to concatenated name
|
|
*
|
|
* @return static|null Concatenated name
|
|
*/
|
|
public static function concat($name1, $name2, array $attributes = []) {
|
|
if (null === $name1 && null === $name2) {
|
|
return null;
|
|
} elseif (null === $name1) {
|
|
return new static(self::prepareName($name2), $attributes);
|
|
} elseif (null === $name2) {
|
|
return new static(self::prepareName($name1), $attributes);
|
|
} else {
|
|
return new static(
|
|
array_merge(self::prepareName($name1), self::prepareName($name2)), $attributes
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepares a (string, array or Name node) name for use in name changing methods by converting
|
|
* it to an array.
|
|
*
|
|
* @param string|string[]|self $name Name to prepare
|
|
*
|
|
* @return string[] Prepared name
|
|
*/
|
|
private static function prepareName($name) : array {
|
|
if (\is_string($name)) {
|
|
if ('' === $name) {
|
|
throw new \InvalidArgumentException('Name cannot be empty');
|
|
}
|
|
|
|
return explode('\\', $name);
|
|
} elseif (\is_array($name)) {
|
|
if (empty($name)) {
|
|
throw new \InvalidArgumentException('Name cannot be empty');
|
|
}
|
|
|
|
return $name;
|
|
} elseif ($name instanceof self) {
|
|
return $name->parts;
|
|
}
|
|
|
|
throw new \InvalidArgumentException(
|
|
'Expected string, array of parts or Name instance'
|
|
);
|
|
}
|
|
|
|
public function getType() : string {
|
|
return 'Name';
|
|
}
|
|
}
|