comparison vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/String_.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.

-<?php
+<?php declare(strict_types=1);
 
 namespace PhpParser\Node\Scalar;
 
 use PhpParser\Error;
 use PhpParser\Node\Scalar;

     const KIND_NOWDOC = 4;
 
     /** @var string String value */
     public $value;
 
-    protected static $replacements = array(
+    protected static $replacements = [
         '\\' => '\\',
         '$'  =>  '$',
         'n'  => "\n",
         'r'  => "\r",
         't'  => "\t",
         'f'  => "\f",
         'v'  => "\v",
         'e'  => "\x1B",
-    );
+    ];
 
     /**
      * Constructs a string scalar node.
      *
      * @param string $value      Value of the string
      * @param array  $attributes Additional attributes
      */
-    public function __construct($value, array $attributes = array()) {
+    public function __construct(string $value, array $attributes = []) {
         parent::__construct($attributes);
         $this->value = $value;
     }
 
-    public function getSubNodeNames() {
-        return array('value');
+    public function getSubNodeNames() : array {
+        return ['value'];
     }
 
     /**
      * @internal
      *

      * @param string $str String token content
      * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
      *
      * @return string The parsed string
      */
-    public static function parse($str, $parseUnicodeEscape = true) {
+    public static function parse(string $str, bool $parseUnicodeEscape = true) : string {
         $bLength = 0;
         if ('b' === $str[0] || 'B' === $str[0]) {
             $bLength = 1;
         }
 
         if ('\'' === $str[$bLength]) {
             return str_replace(
-                array('\\\\', '\\\''),
-                array(  '\\',   '\''),
+                ['\\\\', '\\\''],
+                ['\\', '\''],
                 substr($str, $bLength + 1, -1)
             );
         } else {
             return self::parseEscapeSequences(
                 substr($str, $bLength + 1, -1), '"', $parseUnicodeEscape

      * @param null|string $quote Quote type
      * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
      *
      * @return string String with escape sequences parsed
      */
-    public static function parseEscapeSequences($str, $quote, $parseUnicodeEscape = true) {
+    public static function parseEscapeSequences(string $str, $quote, bool $parseUnicodeEscape = true) : string {
         if (null !== $quote) {
             $str = str_replace('\\' . $quote, $quote, $str);
         }
 
         $extra = '';

             },
             $str
         );
     }
 
-    private static function codePointToUtf8($num) {
+    /**
+     * Converts a Unicode code point to its UTF-8 encoded representation.
+     *
+     * @param int $num Code point
+     *
+     * @return string UTF-8 representation of code point
+     */
+    private static function codePointToUtf8(int $num) : string {
         if ($num <= 0x7F) {
             return chr($num);
         }
         if ($num <= 0x7FF) {
             return chr(($num>>6) + 0xC0) . chr(($num&0x3F) + 0x80);

      * @param string $str        String token content
      * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
      *
      * @return string Parsed string
      */
-    public static function parseDocString($startToken, $str, $parseUnicodeEscape = true) {
+    public static function parseDocString(string $startToken, string $str, bool $parseUnicodeEscape = true) : string {
         // strip last newline (thanks tokenizer for sticking it into the string!)
         $str = preg_replace('~(\r\n|\n|\r)\z~', '', $str);
 
         // nowdoc string
         if (false !== strpos($startToken, '\'')) {
             return $str;
         }
 
         return self::parseEscapeSequences($str, null, $parseUnicodeEscape);
     }
+    
+    public function getType() : string {
+        return 'Scalar_String';
+    }
 }