diff vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php @ 13:5fb285c0d0e3

Update Drupal core to 8.4.7 via Composer. Security update; I *think* we've
been lucky to get away with this so far, as we don't support self-registration
which seems to be used by the so-called "drupalgeddon 2" attack that 8.4.5
was vulnerable to.

--- a/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php	Fri Feb 23 15:52:07 2018 +0000
+++ b/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php	Mon Apr 23 09:33:26 2018 +0100
@@ -1,21 +1,16 @@
-<?php
+<?php declare(strict_types=1);
 
 namespace PhpParser;
 
-use PhpParser\Builder;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BinaryOp\Concat;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\String_;
+use PhpParser\Node\Stmt;
 use PhpParser\Node\Stmt\Use_;
 
-/**
- * The following methods use reserved keywords, so their implementation is defined with an underscore and made available
- * with the reserved name through __call() magic.
- *
- * @method Builder\Namespace_ namespace(string $name) Creates a namespace builder.
- * @method Builder\Class_     class(string $name)     Creates a class builder.
- * @method Builder\Interface_ interface(string $name) Creates an interface builder.
- * @method Builder\Trait_     trait(string $name)     Creates a trait builder.
- * @method Builder\Function_  function(string $name)  Creates a function builder.
- * @method Builder\Use_       use(string $name)       Creates a namespace/class use builder.
- */
 class BuilderFactory
 {
     /**
@@ -25,7 +20,7 @@
      *
      * @return Builder\Namespace_ The created namespace builder
      */
-    protected function _namespace($name) {
+    public function namespace($name) : Builder\Namespace_ {
         return new Builder\Namespace_($name);
     }
 
@@ -36,7 +31,7 @@
      *
      * @return Builder\Class_ The created class builder
      */
-    protected function _class($name) {
+    public function class(string $name) : Builder\Class_ {
         return new Builder\Class_($name);
     }
 
@@ -47,7 +42,7 @@
      *
      * @return Builder\Interface_ The created interface builder
      */
-    protected function _interface($name) {
+    public function interface(string $name) : Builder\Interface_ {
         return new Builder\Interface_($name);
     }
 
@@ -58,7 +53,7 @@
      *
      * @return Builder\Trait_ The created trait builder
      */
-    protected function _trait($name) {
+    public function trait(string $name) : Builder\Trait_ {
         return new Builder\Trait_($name);
     }
 
@@ -69,7 +64,7 @@
      *
      * @return Builder\Method The created method builder
      */
-    public function method($name) {
+    public function method(string $name) : Builder\Method {
         return new Builder\Method($name);
     }
 
@@ -80,7 +75,7 @@
      *
      * @return Builder\Param The created parameter builder
      */
-    public function param($name) {
+    public function param(string $name) : Builder\Param {
         return new Builder\Param($name);
     }
 
@@ -91,7 +86,7 @@
      *
      * @return Builder\Property The created property builder
      */
-    public function property($name) {
+    public function property(string $name) : Builder\Property {
         return new Builder\Property($name);
     }
 
@@ -102,7 +97,7 @@
      *
      * @return Builder\Function_ The created function builder
      */
-    protected function _function($name) {
+    public function function(string $name) : Builder\Function_ {
         return new Builder\Function_($name);
     }
 
@@ -113,15 +108,165 @@
      *
      * @return Builder\Use_ The create use builder
      */
-    protected function _use($name) {
+    public function use($name) : Builder\Use_ {
         return new Builder\Use_($name, Use_::TYPE_NORMAL);
     }
 
-    public function __call($name, array $args) {
-        if (method_exists($this, '_' . $name)) {
-            return call_user_func_array(array($this, '_' . $name), $args);
+    /**
+     * Creates node a for a literal value.
+     *
+     * @param Expr|bool|null|int|float|string|array $value $value
+     *
+     * @return Expr
+     */
+    public function val($value) : Expr {
+        return BuilderHelpers::normalizeValue($value);
+    }
+
+    /**
+     * Normalizes an argument list.
+     *
+     * Creates Arg nodes for all arguments and converts literal values to expressions.
+     *
+     * @param array $args List of arguments to normalize
+     *
+     * @return Arg[]
+     */
+    public function args(array $args) : array {
+        $normalizedArgs = [];
+        foreach ($args as $arg) {
+            if ($arg instanceof Arg) {
+                $normalizedArgs[] = $arg;
+            } else {
+                $normalizedArgs[] = new Arg(BuilderHelpers::normalizeValue($arg));
+            }
+        }
+        return $normalizedArgs;
+    }
+
+    /**
+     * Creates a function call node.
+     *
+     * @param string|Name|Expr $name Function name
+     * @param array            $args Function arguments
+     *
+     * @return Expr\FuncCall
+     */
+    public function funcCall($name, array $args = []) : Expr\FuncCall {
+        return new Expr\FuncCall(
+            BuilderHelpers::normalizeNameOrExpr($name),
+            $this->args($args)
+        );
+    }
+
+    /**
+     * Creates a method call node.
+     *
+     * @param Expr                   $var  Variable the method is called on
+     * @param string|Identifier|Expr $name Method name
+     * @param array                  $args Method arguments
+     *
+     * @return Expr\MethodCall
+     */
+    public function methodCall(Expr $var, $name, array $args = []) : Expr\MethodCall {
+        return new Expr\MethodCall(
+            $var,
+            BuilderHelpers::normalizeIdentifierOrExpr($name),
+            $this->args($args)
+        );
+    }
+
+    /**
+     * 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
+     */
+    public function staticCall($class, $name, array $args = []) : Expr\StaticCall {
+        return new Expr\StaticCall(
+            BuilderHelpers::normalizeNameOrExpr($class),
+            BuilderHelpers::normalizeIdentifierOrExpr($name),
+            $this->args($args)
+        );
+    }
+
+    /**
+     * Creates an object creation node.
+     *
+     * @param string|Name|Expr $class Class name
+     * @param array            $args  Constructor arguments
+     *
+     * @return Expr\New_
+     */
+    public function new($class, array $args = []) : Expr\New_ {
+        return new Expr\New_(
+            BuilderHelpers::normalizeNameOrExpr($class),
+            $this->args($args)
+        );
+    }
+
+    /**
+     * Creates a constant fetch node.
+     *
+     * @param string|Name $name Constant name
+     *
+     * @return Expr\ConstFetch
+     */
+    public function constFetch($name) : Expr\ConstFetch {
+        return new Expr\ConstFetch(BuilderHelpers::normalizeName($name));
+    }
+
+    /**
+     * Creates a class constant fetch node.
+     *
+     * @param string|Name|Expr  $class Class name
+     * @param string|Identifier $name  Constant name
+     *
+     * @return Expr\ClassConstFetch
+     */
+    public function classConstFetch($class, $name): Expr\ClassConstFetch {
+        return new Expr\ClassConstFetch(
+            BuilderHelpers::normalizeNameOrExpr($class),
+            BuilderHelpers::normalizeIdentifier($name)
+        );
+    }
+
+    /**
+     * Creates nested Concat nodes from a list of expressions.
+     *
+     * @param Expr|string ...$exprs Expressions or literal strings
+     *
+     * @return Concat
+     */
+    public function concat(...$exprs) : Concat {
+        $numExprs = count($exprs);
+        if ($numExprs < 2) {
+            throw new \LogicException('Expected at least two expressions');
         }
 
-        throw new \LogicException(sprintf('Method "%s" does not exist', $name));
+        $lastConcat = $this->normalizeStringExpr($exprs[0]);
+        for ($i = 1; $i < $numExprs; $i++) {
+            $lastConcat = new Concat($lastConcat, $this->normalizeStringExpr($exprs[$i]));
+        }
+        return $lastConcat;
+    }
+
+    /**
+     * @param string|Expr $expr
+     * @return Expr
+     */
+    private function normalizeStringExpr($expr) : Expr {
+        if ($expr instanceof Expr) {
+            return $expr;
+        }
+
+        if (\is_string($expr)) {
+            return new String_($expr);
+        }
+
+        throw new \LogicException('Expected string or Expr');
     }
 }