@flarum/cli 2.0.0-beta.9 → 3.0.0

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php

@@ -10,8 +10,20 @@ use PhpParser\Node\Name;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\Use_;
 
-class BuilderFactory
-{
+class BuilderFactory {
+    /**
+     * Creates an attribute node.
+     *
+     * @param string|Name $name Name of the attribute
+     * @param array $args Attribute named arguments
+     */
+    public function attribute($name, array $args = []): Node\Attribute {
+        return new Node\Attribute(
+            BuilderHelpers::normalizeName($name),
+            $this->args($args)
+        );
+    }
+
     /**
      * Creates a namespace builder.
      *
@@ -19,7 +31,7 @@ class BuilderFactory
      *
      * @return Builder\Namespace_ The created namespace builder
      */
-    public function namespace($name) : Builder\Namespace_ {
+    public function namespace($name): Builder\Namespace_ {
         return new Builder\Namespace_($name);
     }
 
@@ -30,7 +42,7 @@ class BuilderFactory
      *
      * @return Builder\Class_ The created class builder
      */
-    public function class(string $name) : Builder\Class_ {
+    public function class(string $name): Builder\Class_ {
         return new Builder\Class_($name);
     }
 
@@ -41,7 +53,7 @@ class BuilderFactory
      *
      * @return Builder\Interface_ The created interface builder
      */
-    public function interface(string $name) : Builder\Interface_ {
+    public function interface(string $name): Builder\Interface_ {
         return new Builder\Interface_($name);
     }
 
@@ -52,30 +64,41 @@ class BuilderFactory
      *
      * @return Builder\Trait_ The created trait builder
      */
-    public function trait(string $name) : Builder\Trait_ {
+    public function trait(string $name): Builder\Trait_ {
         return new Builder\Trait_($name);
     }
 
+    /**
+     * Creates an enum builder.
+     *
+     * @param string $name Name of the enum
+     *
+     * @return Builder\Enum_ The created enum builder
+     */
+    public function enum(string $name): Builder\Enum_ {
+        return new Builder\Enum_($name);
+    }
+
     /**
      * Creates a trait use builder.
      *
      * @param Node\Name|string ...$traits Trait names
      *
-     * @return Builder\TraitUse The create trait use builder
+     * @return Builder\TraitUse The created trait use builder
      */
-    public function useTrait(...$traits) : Builder\TraitUse {
+    public function useTrait(...$traits): Builder\TraitUse {
         return new Builder\TraitUse(...$traits);
     }
 
     /**
      * Creates a trait use adaptation builder.
      *
-     * @param Node\Name|string|null  $trait  Trait name
+     * @param Node\Name|string|null $trait Trait name
      * @param Node\Identifier|string $method Method name
      *
-     * @return Builder\TraitUseAdaptation The create trait use adaptation builder
+     * @return Builder\TraitUseAdaptation The created trait use adaptation builder
      */
-    public function traitUseAdaptation($trait, $method = null) : Builder\TraitUseAdaptation {
+    public function traitUseAdaptation($trait, $method = null): Builder\TraitUseAdaptation {
         if ($method === null) {
             $method = $trait;
             $trait = null;
@@ -91,7 +114,7 @@ class BuilderFactory
      *
      * @return Builder\Method The created method builder
      */
-    public function method(string $name) : Builder\Method {
+    public function method(string $name): Builder\Method {
         return new Builder\Method($name);
     }
 
@@ -102,7 +125,7 @@ class BuilderFactory
      *
      * @return Builder\Param The created parameter builder
      */
-    public function param(string $name) : Builder\Param {
+    public function param(string $name): Builder\Param {
         return new Builder\Param($name);
     }
 
@@ -113,7 +136,7 @@ class BuilderFactory
      *
      * @return Builder\Property The created property builder
      */
-    public function property(string $name) : Builder\Property {
+    public function property(string $name): Builder\Property {
         return new Builder\Property($name);
     }
 
@@ -124,7 +147,7 @@ class BuilderFactory
      *
      * @return Builder\Function_ The created function builder
      */
-    public function function(string $name) : Builder\Function_ {
+    public function function(string $name): Builder\Function_ {
         return new Builder\Function_($name);
     }
 
@@ -135,7 +158,7 @@ class BuilderFactory
      *
      * @return Builder\Use_ The created use builder
      */
-    public function use($name) : Builder\Use_ {
+    public function use($name): Builder\Use_ {
         return new Builder\Use_($name, Use_::TYPE_NORMAL);
     }
 
@@ -146,7 +169,7 @@ class BuilderFactory
      *
      * @return Builder\Use_ The created use function builder
      */
-    public function useFunction($name) : Builder\Use_ {
+    public function useFunction($name): Builder\Use_ {
         return new Builder\Use_($name, Use_::TYPE_FUNCTION);
     }
 
@@ -157,30 +180,39 @@ class BuilderFactory
      *
      * @return Builder\Use_ The created use const builder
      */
-    public function useConst($name) : Builder\Use_ {
+    public function useConst($name): Builder\Use_ {
         return new Builder\Use_($name, Use_::TYPE_CONSTANT);
     }
 
     /**
      * Creates a class constant builder.
      *
-     * @param string|Identifier                          $name  Name
+     * @param string|Identifier $name Name
      * @param Node\Expr|bool|null|int|float|string|array $value Value
      *
      * @return Builder\ClassConst The created use const builder
      */
-    public function classConst($name, $value) : Builder\ClassConst {
+    public function classConst($name, $value): Builder\ClassConst {
         return new Builder\ClassConst($name, $value);
     }
 
+    /**
+     * Creates an enum case builder.
+     *
+     * @param string|Identifier $name Name
+     *
+     * @return Builder\EnumCase The created use const builder
+     */
+    public function enumCase($name): Builder\EnumCase {
+        return new Builder\EnumCase($name);
+    }
+
     /**
      * Creates node a for a literal value.
      *
      * @param Expr|bool|null|int|float|string|array $value $value
-     *
-     * @return Expr
      */
-    public function val($value) : Expr {
+    public function val($value): Expr {
         return BuilderHelpers::normalizeValue($value);
     }
 
@@ -188,10 +220,8 @@ class BuilderFactory
      * Creates variable node.
      *
      * @param string|Expr $name Name
-     *
-     * @return Expr\Variable
      */
-    public function var($name) : Expr\Variable {
+    public function var($name): Expr\Variable {
         if (!\is_string($name) && !$name instanceof Expr) {
             throw new \LogicException('Variable name must be string or Expr');
         }
@@ -206,16 +236,18 @@ class BuilderFactory
      *
      * @param array $args List of arguments to normalize
      *
-     * @return Arg[]
+     * @return list<Arg>
      */
-    public function args(array $args) : array {
+    public function args(array $args): array {
         $normalizedArgs = [];
-        foreach ($args as $arg) {
-            if ($arg instanceof Arg) {
-                $normalizedArgs[] = $arg;
-            } else {
-                $normalizedArgs[] = new Arg(BuilderHelpers::normalizeValue($arg));
+        foreach ($args as $key => $arg) {
+            if (!($arg instanceof Arg)) {
+                $arg = new Arg(BuilderHelpers::normalizeValue($arg));
+            }
+            if (\is_string($key)) {
+                $arg->name = BuilderHelpers::normalizeIdentifier($key);
             }
+            $normalizedArgs[] = $arg;
         }
         return $normalizedArgs;
     }
@@ -224,11 +256,9 @@ class BuilderFactory
      * Creates a function call node.
      *
      * @param string|Name|Expr $name Function name
-     * @param array            $args Function arguments
-     *
-     * @return Expr\FuncCall
+     * @param array $args Function arguments
      */
-    public function funcCall($name, array $args = []) : Expr\FuncCall {
+    public function funcCall($name, array $args = []): Expr\FuncCall {
         return new Expr\FuncCall(
             BuilderHelpers::normalizeNameOrExpr($name),
             $this->args($args)
@@ -238,13 +268,11 @@ class BuilderFactory
     /**
      * Creates a method call node.
      *
-     * @param Expr                   $var  Variable the method is called on
+     * @param Expr $var Variable the method is called on
      * @param string|Identifier|Expr $name Method name
-     * @param array                  $args Method arguments
-     *
-     * @return Expr\MethodCall
+     * @param array $args Method arguments
      */
-    public function methodCall(Expr $var, $name, array $args = []) : Expr\MethodCall {
+    public function methodCall(Expr $var, $name, array $args = []): Expr\MethodCall {
         return new Expr\MethodCall(
             $var,
             BuilderHelpers::normalizeIdentifierOrExpr($name),
@@ -255,13 +283,11 @@ class BuilderFactory
     /**
      * Creates a static method call node.
      *
-     * @param string|Name|Expr       $class Class name
-     * @param string|Identifier|Expr $name  Method name
-     * @param array                  $args  Method arguments
-     *
-     * @return Expr\StaticCall
+     * @param string|Name|Expr $class Class name
+     * @param string|Identifier|Expr $name Method name
+     * @param array $args Method arguments
      */
-    public function staticCall($class, $name, array $args = []) : Expr\StaticCall {
+    public function staticCall($class, $name, array $args = []): Expr\StaticCall {
         return new Expr\StaticCall(
             BuilderHelpers::normalizeNameOrExpr($class),
             BuilderHelpers::normalizeIdentifierOrExpr($name),
@@ -273,11 +299,9 @@ class BuilderFactory
      * Creates an object creation node.
      *
      * @param string|Name|Expr $class Class name
-     * @param array            $args  Constructor arguments
-     *
-     * @return Expr\New_
+     * @param array $args Constructor arguments
      */
-    public function new($class, array $args = []) : Expr\New_ {
+    public function new($class, array $args = []): Expr\New_ {
         return new Expr\New_(
             BuilderHelpers::normalizeNameOrExpr($class),
             $this->args($args)
@@ -288,37 +312,31 @@ class BuilderFactory
      * Creates a constant fetch node.
      *
      * @param string|Name $name Constant name
-     *
-     * @return Expr\ConstFetch
      */
-    public function constFetch($name) : Expr\ConstFetch {
+    public function constFetch($name): Expr\ConstFetch {
         return new Expr\ConstFetch(BuilderHelpers::normalizeName($name));
     }
-    
+
     /**
      * Creates a property fetch node.
      *
-     * @param Expr                   $var  Variable holding object
+     * @param Expr $var Variable holding object
      * @param string|Identifier|Expr $name Property name
-     *
-     * @return Expr\PropertyFetch
      */
-    public function propertyFetch(Expr $var, $name) : Expr\PropertyFetch {
+    public function propertyFetch(Expr $var, $name): Expr\PropertyFetch {
         return new Expr\PropertyFetch($var, BuilderHelpers::normalizeIdentifierOrExpr($name));
     }
 
     /**
      * Creates a class constant fetch node.
      *
-     * @param string|Name|Expr  $class Class name
-     * @param string|Identifier $name  Constant name
-     *
-     * @return Expr\ClassConstFetch
+     * @param string|Name|Expr $class Class name
+     * @param string|Identifier|Expr $name Constant name
      */
     public function classConstFetch($class, $name): Expr\ClassConstFetch {
         return new Expr\ClassConstFetch(
             BuilderHelpers::normalizeNameOrExpr($class),
-            BuilderHelpers::normalizeIdentifier($name)
+            BuilderHelpers::normalizeIdentifierOrExpr($name)
         );
     }
 
@@ -326,10 +344,8 @@ class BuilderFactory
      * Creates nested Concat nodes from a list of expressions.
      *
      * @param Expr|string ...$exprs Expressions or literal strings
-     *
-     * @return Concat
      */
-    public function concat(...$exprs) : Concat {
+    public function concat(...$exprs): Concat {
         $numExprs = count($exprs);
         if ($numExprs < 2) {
             throw new \LogicException('Expected at least two expressions');
@@ -344,9 +360,8 @@ class BuilderFactory
 
     /**
      * @param string|Expr $expr
-     * @return Expr
      */
-    private function normalizeStringExpr($expr) : Expr {
+    private function normalizeStringExpr($expr): Expr {
         if ($expr instanceof Expr) {
             return $expr;
         }

package/php-subsystem/vendor/nikic/php-parser/lib/PhpParser/BuilderHelpers.php

@@ -2,21 +2,20 @@
 
 namespace PhpParser;
 
+use PhpParser\Node\ComplexType;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\Scalar;
 use PhpParser\Node\Stmt;
-use PhpParser\Node\UnionType;
 
 /**
  * This class defines helpers used in the implementation of builders. Don't use it directly.
  *
  * @internal
  */
-final class BuilderHelpers
-{
+final class BuilderHelpers {
     /**
      * Normalizes a node: Converts builder objects to nodes.
      *
@@ -24,10 +23,12 @@ final class BuilderHelpers
      *
      * @return Node The normalized node
      */
-    public static function normalizeNode($node) : Node {
+    public static function normalizeNode($node): Node {
         if ($node instanceof Builder) {
             return $node->getNode();
-        } elseif ($node instanceof Node) {
+        }
+
+        if ($node instanceof Node) {
             return $node;
         }
 
@@ -43,7 +44,7 @@ final class BuilderHelpers
      *
      * @return Stmt The normalized statement node
      */
-    public static function normalizeStmt($node) : Stmt {
+    public static function normalizeStmt($node): Stmt {
         $node = self::normalizeNode($node);
         if ($node instanceof Stmt) {
             return $node;
@@ -63,7 +64,7 @@ final class BuilderHelpers
      *
      * @return Identifier The normalized identifier
      */
-    public static function normalizeIdentifier($name) : Identifier {
+    public static function normalizeIdentifier($name): Identifier {
         if ($name instanceof Identifier) {
             return $name;
         }
@@ -101,8 +102,28 @@ final class BuilderHelpers
      *
      * @return Name The normalized name
      */
-    public static function normalizeName($name) : Name {
-        return self::normalizeNameCommon($name, false);
+    public static function normalizeName($name): Name {
+        if ($name instanceof Name) {
+            return $name;
+        }
+
+        if (is_string($name)) {
+            if (!$name) {
+                throw new \LogicException('Name cannot be empty');
+            }
+
+            if ($name[0] === '\\') {
+                return new Name\FullyQualified(substr($name, 1));
+            }
+
+            if (0 === strpos($name, 'namespace\\')) {
+                return new Name\Relative(substr($name, strlen('namespace\\')));
+            }
+
+            return new Name($name);
+        }
+
+        throw new \LogicException('Name must be a string or an instance of Node\Name');
     }
 
     /**
@@ -113,44 +134,17 @@ final class BuilderHelpers
      * @return Name|Expr The normalized name or expression
      */
     public static function normalizeNameOrExpr($name) {
-        return self::normalizeNameCommon($name, true);
-    }
-
-    /**
-     * Normalizes a name: Converts string names to Name nodes, optionally allowing expressions.
-     *
-     * @param Expr|Name|string $name      The name to normalize
-     * @param bool             $allowExpr Whether to also allow expressions
-     *
-     * @return Name|Expr The normalized name, or expression (if allowed)
-     */
-    private static function normalizeNameCommon($name, bool $allowExpr) {
-        if ($name instanceof Name) {
+        if ($name instanceof Expr) {
             return $name;
-        } elseif (is_string($name)) {
-            if (!$name) {
-                throw new \LogicException('Name cannot be empty');
-            }
-
-            if ($name[0] === '\\') {
-                return new Name\FullyQualified(substr($name, 1));
-            } elseif (0 === strpos($name, 'namespace\\')) {
-                return new Name\Relative(substr($name, strlen('namespace\\')));
-            } else {
-                return new Name($name);
-            }
         }
 
-        if ($allowExpr) {
-            if ($name instanceof Expr) {
-                return $name;
-            }
+        if (!is_string($name) && !($name instanceof Name)) {
             throw new \LogicException(
                 'Name must be a string or an instance of Node\Name or Node\Expr'
             );
-        } else {
-            throw new \LogicException('Name must be a string or an instance of Node\Name');
         }
+
+        return self::normalizeName($name);
     }
 
     /**
@@ -159,18 +153,18 @@ final class BuilderHelpers
      * In particular, builtin types become Identifiers, custom types become Names and nullables
      * are wrapped in NullableType nodes.
      *
-     * @param string|Name|Identifier|NullableType|UnionType $type The type to normalize
+     * @param string|Name|Identifier|ComplexType $type The type to normalize
      *
-     * @return Name|Identifier|NullableType|UnionType The normalized type
+     * @return Name|Identifier|ComplexType The normalized type
      */
     public static function normalizeType($type) {
         if (!is_string($type)) {
             if (
                 !$type instanceof Name && !$type instanceof Identifier &&
-                !$type instanceof NullableType && !$type instanceof UnionType
+                !$type instanceof ComplexType
             ) {
                 throw new \LogicException(
-                    'Type must be a string, or an instance of Name, Identifier, NullableType or UnionType'
+                    'Type must be a string, or an instance of Name, Identifier or ComplexType'
                 );
             }
             return $type;
@@ -183,7 +177,20 @@ final class BuilderHelpers
         }
 
         $builtinTypes = [
-            'array', 'callable', 'string', 'int', 'float', 'bool', 'iterable', 'void', 'object', 'mixed'
+            'array',
+            'callable',
+            'bool',
+            'int',
+            'float',
+            'string',
+            'iterable',
+            'void',
+            'object',
+            'null',
+            'false',
+            'mixed',
+            'never',
+            'true',
         ];
 
         $lowerType = strtolower($type);
@@ -193,12 +200,11 @@ final class BuilderHelpers
             $type = self::normalizeName($type);
         }
 
-        if ($nullable && (string) $type === 'void') {
-            throw new \LogicException('void type cannot be nullable');
-        }
-
-        if ($nullable && (string) $type === 'mixed') {
-            throw new \LogicException('mixed type cannot be nullable');
+        $notNullableTypes = [
+            'void', 'mixed', 'never',
+        ];
+        if ($nullable && in_array((string) $type, $notNullableTypes)) {
+            throw new \LogicException(sprintf('%s type cannot be nullable', $type));
         }
 
         return $nullable ? new NullableType($type) : $type;
@@ -212,35 +218,47 @@ final class BuilderHelpers
      *
      * @return Expr The normalized value
      */
-    public static function normalizeValue($value) : Expr {
+    public static function normalizeValue($value): Expr {
         if ($value instanceof Node\Expr) {
             return $value;
-        } elseif (is_null($value)) {
+        }
+
+        if (is_null($value)) {
             return new Expr\ConstFetch(
                 new Name('null')
             );
-        } elseif (is_bool($value)) {
+        }
+
+        if (is_bool($value)) {
             return new Expr\ConstFetch(
                 new Name($value ? 'true' : 'false')
             );
-        } elseif (is_int($value)) {
-            return new Scalar\LNumber($value);
-        } elseif (is_float($value)) {
-            return new Scalar\DNumber($value);
-        } elseif (is_string($value)) {
+        }
+
+        if (is_int($value)) {
+            return new Scalar\Int_($value);
+        }
+
+        if (is_float($value)) {
+            return new Scalar\Float_($value);
+        }
+
+        if (is_string($value)) {
             return new Scalar\String_($value);
-        } elseif (is_array($value)) {
+        }
+
+        if (is_array($value)) {
             $items = [];
             $lastKey = -1;
             foreach ($value as $itemKey => $itemValue) {
                 // for consecutive, numeric keys don't generate keys
                 if (null !== $lastKey && ++$lastKey === $itemKey) {
-                    $items[] = new Expr\ArrayItem(
+                    $items[] = new Node\ArrayItem(
                         self::normalizeValue($itemValue)
                     );
                 } else {
                     $lastKey = null;
-                    $items[] = new Expr\ArrayItem(
+                    $items[] = new Node\ArrayItem(
                         self::normalizeValue($itemValue),
                         self::normalizeValue($itemKey)
                     );
@@ -248,9 +266,9 @@ final class BuilderHelpers
             }
 
             return new Expr\Array_($items);
-        } else {
-            throw new \LogicException('Invalid value');
         }
+
+        throw new \LogicException('Invalid value');
     }
 
     /**
@@ -260,26 +278,56 @@ final class BuilderHelpers
      *
      * @return Comment\Doc The normalized doc comment
      */
-    public static function normalizeDocComment($docComment) : Comment\Doc {
+    public static function normalizeDocComment($docComment): Comment\Doc {
         if ($docComment instanceof Comment\Doc) {
             return $docComment;
-        } elseif (is_string($docComment)) {
+        }
+
+        if (is_string($docComment)) {
             return new Comment\Doc($docComment);
-        } else {
-            throw new \LogicException('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
         }
+
+        throw new \LogicException('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
+    }
+
+    /**
+     * Normalizes a attribute: Converts attribute to the Attribute Group if needed.
+     *
+     * @param Node\Attribute|Node\AttributeGroup $attribute
+     *
+     * @return Node\AttributeGroup The Attribute Group
+     */
+    public static function normalizeAttribute($attribute): Node\AttributeGroup {
+        if ($attribute instanceof Node\AttributeGroup) {
+            return $attribute;
+        }
+
+        if (!($attribute instanceof Node\Attribute)) {
+            throw new \LogicException('Attribute must be an instance of PhpParser\Node\Attribute or PhpParser\Node\AttributeGroup');
+        }
+
+        return new Node\AttributeGroup([$attribute]);
     }
 
     /**
      * Adds a modifier and returns new modifier bitmask.
      *
      * @param int $modifiers Existing modifiers
-     * @param int $modifier  Modifier to set
+     * @param int $modifier Modifier to set
      *
      * @return int New modifiers
      */
-    public static function addModifier(int $modifiers, int $modifier) : int {
-        Stmt\Class_::verifyModifier($modifiers, $modifier);
+    public static function addModifier(int $modifiers, int $modifier): int {
+        Modifiers::verifyModifier($modifiers, $modifier);
         return $modifiers | $modifier;
     }
+
+    /**
+     * Adds a modifier and returns new modifier bitmask.
+     * @return int New modifiers
+     */
+    public static function addClassModifier(int $existingModifiers, int $modifierToSet): int {
+        Modifiers::verifyClassModifier($existingModifiers, $modifierToSet);
+        return $existingModifiers | $modifierToSet;
+    }
 }