resolved conflicts

2026-09-13 03:31:31 +00:00 · 2025-03-31 03:46:05 +03:00
parent b0a69145d7 c7fdd2968a
commit 2dc2287379
6454 changed files with 1520539 additions and 9 deletions
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr;
+
+require __DIR__ . '/../ArrayItem.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class ArrayItem extends \PhpParser\Node\ArrayItem {
+    }
+}
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Expr;
+
+require __DIR__ . '/../ClosureUse.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class ClosureUse extends \PhpParser\Node\ClosureUse {
+    }
+}
@@ -0,0 +1,85 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\NodeAbstract;
+
+/**
+ * Represents a non-namespaced name. Namespaced names are represented using Name nodes.
+ */
+class Identifier extends NodeAbstract {
+    /**
+     * @psalm-var non-empty-string
+     * @var string Identifier as string
+     */
+    public string $name;
+
+    /** @var array<string, bool> */
+    private static array $specialClassNames = [
+        'self'   => true,
+        'parent' => true,
+        'static' => true,
+    ];
+
+    /**
+     * Constructs an identifier node.
+     *
+     * @param string $name Identifier as string
+     * @param array<string, mixed> $attributes Additional attributes
+     */
+    public function __construct(string $name, array $attributes = []) {
+        if ($name === '') {
+            throw new \InvalidArgumentException('Identifier name cannot be empty');
+        }
+
+        $this->attributes = $attributes;
+        $this->name = $name;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['name'];
+    }
+
+    /**
+     * Get identifier as string.
+     *
+     * @psalm-return non-empty-string
+     * @return string Identifier as string.
+     */
+    public function toString(): string {
+        return $this->name;
+    }
+
+    /**
+     * Get lowercased identifier as string.
+     *
+     * @psalm-return non-empty-string&lowercase-string
+     * @return string Lowercased identifier as string
+     */
+    public function toLowerString(): string {
+        return strtolower($this->name);
+    }
+
+    /**
+     * 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 isset(self::$specialClassNames[strtolower($this->name)]);
+    }
+
+    /**
+     * Get identifier as string.
+     *
+     * @psalm-return non-empty-string
+     * @return string Identifier as string
+     */
+    public function __toString(): string {
+        return $this->name;
+    }
+
+    public function getType(): string {
+        return 'Identifier';
+    }
+}
@@ -0,0 +1,278 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\NodeAbstract;
+
+class Name extends NodeAbstract {
+    /**
+     * @psalm-var non-empty-string
+     * @var string Name as string
+     */
+    public string $name;
+
+    /** @var array<string, bool> */
+    private static array $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<string, mixed> $attributes Additional attributes
+     */
+    final public function __construct($name, array $attributes = []) {
+        $this->attributes = $attributes;
+        $this->name = self::prepareName($name);
+    }
+
+    public function getSubNodeNames(): array {
+        return ['name'];
+    }
+
+    /**
+     * Get parts of name (split by the namespace separator).
+     *
+     * @psalm-return non-empty-list<string>
+     * @return string[] Parts of name
+     */
+    public function getParts(): array {
+        return \explode('\\', $this->name);
+    }
+
+    /**
+     * 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 {
+        if (false !== $pos = \strpos($this->name, '\\')) {
+            return \substr($this->name, 0, $pos);
+        }
+        return $this->name;
+    }
+
+    /**
+     * 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 {
+        if (false !== $pos = \strrpos($this->name, '\\')) {
+            return \substr($this->name, $pos + 1);
+        }
+        return $this->name;
+    }
+
+    /**
+     * Checks whether the name is unqualified. (E.g. Name)
+     *
+     * @return bool Whether the name is unqualified
+     */
+    public function isUnqualified(): bool {
+        return false === \strpos($this->name, '\\');
+    }
+
+    /**
+     * Checks whether the name is qualified. (E.g. Name\Name)
+     *
+     * @return bool Whether the name is qualified
+     */
+    public function isQualified(): bool {
+        return false !== \strpos($this->name, '\\');
+    }
+
+    /**
+     * 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).
+     *
+     * @psalm-return non-empty-string
+     * @return string String representation
+     */
+    public function toString(): string {
+        return $this->name;
+    }
+
+    /**
+     * Returns a string representation of the name as it would occur in code (e.g., including
+     * leading backslash for fully qualified names.
+     *
+     * @psalm-return non-empty-string
+     * @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).
+     *
+     * @psalm-return non-empty-string&lowercase-string
+     * @return string Lowercased string representation
+     */
+    public function toLowerString(): string {
+        return strtolower($this->name);
+    }
+
+    /**
+     * 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 isset(self::$specialClassNames[strtolower($this->name)]);
+    }
+
+    /**
+     * Returns a string representation of the name by imploding the namespace parts with the
+     * namespace separator.
+     *
+     * @psalm-return non-empty-string
+     * @return string String representation
+     */
+    public function __toString(): string {
+        return $this->name;
+    }
+
+    /**
+     * 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) {
+        if ($offset === 1 && $length === null) {
+            // Short-circuit the common case.
+            if (false !== $pos = \strpos($this->name, '\\')) {
+                return new static(\substr($this->name, $pos + 1));
+            }
+            return null;
+        }
+
+        $parts = \explode('\\', $this->name);
+        $numParts = \count($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($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<string, mixed> $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;
+        }
+        if (null === $name1) {
+            return new static($name2, $attributes);
+        }
+        if (null === $name2) {
+            return new static($name1, $attributes);
+        } else {
+            return new static(
+                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 a string.
+     *
+     * @param string|string[]|self $name Name to prepare
+     *
+     * @psalm-return non-empty-string
+     * @return string Prepared name
+     */
+    private static function prepareName($name): string {
+        if (\is_string($name)) {
+            if ('' === $name) {
+                throw new \InvalidArgumentException('Name cannot be empty');
+            }
+
+            return $name;
+        }
+        if (\is_array($name)) {
+            if (empty($name)) {
+                throw new \InvalidArgumentException('Name cannot be empty');
+            }
+
+            return implode('\\', $name);
+        }
+        if ($name instanceof self) {
+            return $name->name;
+        }
+
+        throw new \InvalidArgumentException(
+            'Expected string, array of parts or Name instance'
+        );
+    }
+
+    public function getType(): string {
+        return 'Name';
+    }
+}
@@ -0,0 +1,119 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\Modifiers;
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+
+class Param extends NodeAbstract {
+    /** @var null|Identifier|Name|ComplexType Type declaration */
+    public ?Node $type;
+    /** @var bool Whether parameter is passed by reference */
+    public bool $byRef;
+    /** @var bool Whether this is a variadic argument */
+    public bool $variadic;
+    /** @var Expr\Variable|Expr\Error Parameter variable */
+    public Expr $var;
+    /** @var null|Expr Default value */
+    public ?Expr $default;
+    /** @var int Optional visibility flags */
+    public int $flags;
+    /** @var AttributeGroup[] PHP attribute groups */
+    public array $attrGroups;
+    /** @var PropertyHook[] Property hooks for promoted properties */
+    public array $hooks;
+
+    /**
+     * Constructs a parameter node.
+     *
+     * @param Expr\Variable|Expr\Error $var Parameter variable
+     * @param null|Expr $default Default value
+     * @param null|Identifier|Name|ComplexType $type Type declaration
+     * @param bool $byRef Whether is passed by reference
+     * @param bool $variadic Whether this is a variadic argument
+     * @param array<string, mixed> $attributes Additional attributes
+     * @param int $flags Optional visibility flags
+     * @param list<AttributeGroup> $attrGroups PHP attribute groups
+     * @param PropertyHook[] $hooks Property hooks for promoted properties
+     */
+    public function __construct(
+        Expr $var, ?Expr $default = null, ?Node $type = null,
+        bool $byRef = false, bool $variadic = false,
+        array $attributes = [],
+        int $flags = 0,
+        array $attrGroups = [],
+        array $hooks = []
+    ) {
+        $this->attributes = $attributes;
+        $this->type = $type;
+        $this->byRef = $byRef;
+        $this->variadic = $variadic;
+        $this->var = $var;
+        $this->default = $default;
+        $this->flags = $flags;
+        $this->attrGroups = $attrGroups;
+        $this->hooks = $hooks;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['attrGroups', 'flags', 'type', 'byRef', 'variadic', 'var', 'default', 'hooks'];
+    }
+
+    public function getType(): string {
+        return 'Param';
+    }
+
+    /**
+     * Whether this parameter uses constructor property promotion.
+     */
+    public function isPromoted(): bool {
+        return $this->flags !== 0 || $this->hooks !== [];
+    }
+
+    public function isPublic(): bool {
+        $public = (bool) ($this->flags & Modifiers::PUBLIC);
+        if ($public) {
+            return true;
+        }
+
+        if ($this->hooks === []) {
+            return false;
+        }
+
+        return ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+    }
+
+    public function isProtected(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED);
+    }
+
+    public function isPrivate(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE);
+    }
+
+    public function isReadonly(): bool {
+        return (bool) ($this->flags & Modifiers::READONLY);
+    }
+
+    /**
+     * Whether the promoted property has explicit public(set) visibility.
+     */
+    public function isPublicSet(): bool {
+        return (bool) ($this->flags & Modifiers::PUBLIC_SET);
+    }
+
+    /**
+     * Whether the promoted property has explicit protected(set) visibility.
+     */
+    public function isProtectedSet(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED_SET);
+    }
+
+    /**
+     * Whether the promoted property has explicit private(set) visibility.
+     */
+    public function isPrivateSet(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE_SET);
+    }
+}
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar;
+
+require __DIR__ . '/Float_.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class DNumber extends Float_ {
+    }
+}
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar;
+
+require __DIR__ . '/InterpolatedString.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class Encapsed extends InterpolatedString {
+    }
+}
@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar;
+
+use PhpParser\Node\InterpolatedStringPart;
+
+require __DIR__ . '/../InterpolatedStringPart.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class EncapsedStringPart extends InterpolatedStringPart {
+    }
+}
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Scalar;
+
+require __DIR__ . '/Int_.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class LNumber extends Int_ {
+    }
+}
@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\DeclareItem;
+
+require __DIR__ . '/../DeclareItem.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class DeclareDeclare extends DeclareItem {
+    }
+}
@@ -0,0 +1,121 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Modifiers;
+use PhpParser\Node;
+use PhpParser\Node\ComplexType;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\PropertyItem;
+
+class Property extends Node\Stmt {
+    /** @var int Modifiers */
+    public int $flags;
+    /** @var PropertyItem[] Properties */
+    public array $props;
+    /** @var null|Identifier|Name|ComplexType Type declaration */
+    public ?Node $type;
+    /** @var Node\AttributeGroup[] PHP attribute groups */
+    public array $attrGroups;
+    /** @var Node\PropertyHook[] Property hooks */
+    public array $hooks;
+
+    /**
+     * Constructs a class property list node.
+     *
+     * @param int $flags Modifiers
+     * @param PropertyItem[] $props Properties
+     * @param array<string, mixed> $attributes Additional attributes
+     * @param null|Identifier|Name|ComplexType $type Type declaration
+     * @param Node\AttributeGroup[] $attrGroups PHP attribute groups
+     * @param Node\PropertyHook[] $hooks Property hooks
+     */
+    public function __construct(int $flags, array $props, array $attributes = [], ?Node $type = null, array $attrGroups = [], array $hooks = []) {
+        $this->attributes = $attributes;
+        $this->flags = $flags;
+        $this->props = $props;
+        $this->type = $type;
+        $this->attrGroups = $attrGroups;
+        $this->hooks = $hooks;
+    }
+
+    public function getSubNodeNames(): array {
+        return ['attrGroups', 'flags', 'type', 'props', 'hooks'];
+    }
+
+    /**
+     * Whether the property is explicitly or implicitly public.
+     */
+    public function isPublic(): bool {
+        return ($this->flags & Modifiers::PUBLIC) !== 0
+            || ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+    }
+
+    /**
+     * Whether the property is protected.
+     */
+    public function isProtected(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED);
+    }
+
+    /**
+     * Whether the property is private.
+     */
+    public function isPrivate(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE);
+    }
+
+    /**
+     * Whether the property is static.
+     */
+    public function isStatic(): bool {
+        return (bool) ($this->flags & Modifiers::STATIC);
+    }
+
+    /**
+     * Whether the property is readonly.
+     */
+    public function isReadonly(): bool {
+        return (bool) ($this->flags & Modifiers::READONLY);
+    }
+
+    /**
+     * Whether the property is abstract.
+     */
+    public function isAbstract(): bool {
+        return (bool) ($this->flags & Modifiers::ABSTRACT);
+    }
+
+    /**
+     * Whether the property is final.
+     */
+    public function isFinal(): bool {
+        return (bool) ($this->flags & Modifiers::FINAL);
+    }
+
+    /**
+     * Whether the property has explicit public(set) visibility.
+     */
+    public function isPublicSet(): bool {
+        return (bool) ($this->flags & Modifiers::PUBLIC_SET);
+    }
+
+    /**
+     * Whether the property has explicit protected(set) visibility.
+     */
+    public function isProtectedSet(): bool {
+        return (bool) ($this->flags & Modifiers::PROTECTED_SET);
+    }
+
+    /**
+     * Whether the property has explicit private(set) visibility.
+     */
+    public function isPrivateSet(): bool {
+        return (bool) ($this->flags & Modifiers::PRIVATE_SET);
+    }
+
+    public function getType(): string {
+        return 'Stmt_Property';
+    }
+}
@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\PropertyItem;
+
+require __DIR__ . '/../PropertyItem.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class PropertyProperty extends PropertyItem {
+    }
+}
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+require __DIR__ . '/../StaticVar.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class StaticVar extends \PhpParser\Node\StaticVar {
+    }
+}
@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node\Stmt;
+
+use PhpParser\Node\UseItem;
+
+require __DIR__ . '/../UseItem.php';
+
+if (false) {
+    // For classmap-authoritative support.
+    class UseUse extends UseItem {
+    }
+}