@appthreat/atom 1.8.1 → 1.8.3

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AttributeEmulator.php

@@ -2,36 +2,43 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\PhpVersion;
-use PhpParser\Token;
+use PhpParser\Lexer\Emulative;
 
-final class AttributeEmulator extends TokenEmulator {
-    public function getPhpVersion(): PhpVersion {
-        return PhpVersion::fromComponents(8, 0);
+final class AttributeEmulator extends TokenEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_0;
     }
 
-    public function isEmulationNeeded(string $code): bool {
+    public function isEmulationNeeded(string $code) : bool
+    {
         return strpos($code, '#[') !== false;
     }
 
-    public function emulate(string $code, array $tokens): array {
+    public function emulate(string $code, array $tokens): array
+    {
         // We need to manually iterate and manage a count because we'll change
         // the tokens array on the way.
+        $line = 1;
         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
-            $token = $tokens[$i];
-            if ($token->text === '#' && isset($tokens[$i + 1]) && $tokens[$i + 1]->text === '[') {
+            if ($tokens[$i] === '#' && isset($tokens[$i + 1]) && $tokens[$i + 1] === '[') {
                 array_splice($tokens, $i, 2, [
-                    new Token(\T_ATTRIBUTE, '#[', $token->line, $token->pos),
+                    [\T_ATTRIBUTE, '#[', $line]
                 ]);
                 $c--;
                 continue;
             }
+            if (\is_array($tokens[$i])) {
+                $line += substr_count($tokens[$i][1], "\n");
+            }
         }
 
         return $tokens;
     }
 
-    public function reverseEmulate(string $code, array $tokens): array {
+    public function reverseEmulate(string $code, array $tokens): array
+    {
         // TODO
         return $tokens;
     }

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/CoaleseEqualTokenEmulator.php

@@ -0,0 +1,47 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class CoaleseEqualTokenEmulator extends TokenEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_7_4;
+    }
+
+    public function isEmulationNeeded(string $code): bool
+    {
+        return strpos($code, '??=') !== false;
+    }
+
+    public function emulate(string $code, array $tokens): array
+    {
+        // We need to manually iterate and manage a count because we'll change
+        // the tokens array on the way
+        $line = 1;
+        for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+            if (isset($tokens[$i + 1])) {
+                if ($tokens[$i][0] === T_COALESCE && $tokens[$i + 1] === '=') {
+                    array_splice($tokens, $i, 2, [
+                        [\T_COALESCE_EQUAL, '??=', $line]
+                    ]);
+                    $c--;
+                    continue;
+                }
+            }
+            if (\is_array($tokens[$i])) {
+                $line += substr_count($tokens[$i][1], "\n");
+            }
+        }
+
+        return $tokens;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        // ??= was not valid code previously, don't bother.
+        return $tokens;
+    }
+}

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/EnumTokenEmulator.php

@@ -2,25 +2,30 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\PhpVersion;
+use PhpParser\Lexer\Emulative;
 
-final class EnumTokenEmulator extends KeywordEmulator {
-    public function getPhpVersion(): PhpVersion {
-        return PhpVersion::fromComponents(8, 1);
+final class EnumTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_1;
     }
 
-    public function getKeywordString(): string {
+    public function getKeywordString(): string
+    {
         return 'enum';
     }
 
-    public function getKeywordToken(): int {
+    public function getKeywordToken(): int
+    {
         return \T_ENUM;
     }
 
-    protected function isKeywordContext(array $tokens, int $pos): bool {
+    protected function isKeywordContext(array $tokens, int $pos): bool
+    {
         return parent::isKeywordContext($tokens, $pos)
             && isset($tokens[$pos + 2])
-            && $tokens[$pos + 1]->id === \T_WHITESPACE
-            && $tokens[$pos + 2]->id === \T_STRING;
+            && $tokens[$pos + 1][0] === \T_WHITESPACE
+            && $tokens[$pos + 2][0] === \T_STRING;
     }
-}
+}

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ExplicitOctalEmulator.php

@@ -2,12 +2,11 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\PhpVersion;
-use PhpParser\Token;
+use PhpParser\Lexer\Emulative;
 
 class ExplicitOctalEmulator extends TokenEmulator {
-    public function getPhpVersion(): PhpVersion {
-        return PhpVersion::fromComponents(8, 1);
+    public function getPhpVersion(): string {
+        return Emulative::PHP_8_1;
     }
 
     public function isEmulationNeeded(string $code): bool {
@@ -16,14 +15,13 @@ class ExplicitOctalEmulator extends TokenEmulator {
 
     public function emulate(string $code, array $tokens): array {
         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
-            $token = $tokens[$i];
-            if ($token->id == \T_LNUMBER && $token->text === '0' &&
-                isset($tokens[$i + 1]) && $tokens[$i + 1]->id == \T_STRING &&
-                preg_match('/[oO][0-7]+(?:_[0-7]+)*/', $tokens[$i + 1]->text)
+            if ($tokens[$i][0] == \T_LNUMBER && $tokens[$i][1] === '0' &&
+                isset($tokens[$i + 1]) && $tokens[$i + 1][0] == \T_STRING &&
+                preg_match('/[oO][0-7]+(?:_[0-7]+)*/', $tokens[$i + 1][1])
             ) {
-                $tokenKind = $this->resolveIntegerOrFloatToken($tokens[$i + 1]->text);
+                $tokenKind = $this->resolveIntegerOrFloatToken($tokens[$i + 1][1]);
                 array_splice($tokens, $i, 2, [
-                    new Token($tokenKind, '0' . $tokens[$i + 1]->text, $token->line, $token->pos),
+                    [$tokenKind, '0' . $tokens[$i + 1][1], $tokens[$i][2]],
                 ]);
                 $c--;
             }
@@ -31,7 +29,8 @@ class ExplicitOctalEmulator extends TokenEmulator {
         return $tokens;
     }
 
-    private function resolveIntegerOrFloatToken(string $str): int {
+    private function resolveIntegerOrFloatToken(string $str): int
+    {
         $str = substr($str, 1);
         $str = str_replace('_', '', $str);
         $num = octdec($str);
@@ -42,4 +41,4 @@ class ExplicitOctalEmulator extends TokenEmulator {
         // Explicit octals were not legal code previously, don't bother.
         return $tokens;
     }
-}
+}

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/FlexibleDocStringEmulator.php

@@ -0,0 +1,76 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class FlexibleDocStringEmulator extends TokenEmulator
+{
+    const FLEXIBLE_DOC_STRING_REGEX = <<<'REGEX'
+/<<<[ \t]*(['"]?)([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)\1\r?\n
+(?:.*\r?\n)*?
+(?<indentation>\h*)\2(?![a-zA-Z0-9_\x80-\xff])(?<separator>(?:;?[\r\n])?)/x
+REGEX;
+
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_7_3;
+    }
+
+    public function isEmulationNeeded(string $code) : bool
+    {
+        return strpos($code, '<<<') !== false;
+    }
+
+    public function emulate(string $code, array $tokens): array
+    {
+        // Handled by preprocessing + fixup.
+        return $tokens;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        // Not supported.
+        return $tokens;
+    }
+
+    public function preprocessCode(string $code, array &$patches): string {
+        if (!preg_match_all(self::FLEXIBLE_DOC_STRING_REGEX, $code, $matches, PREG_SET_ORDER|PREG_OFFSET_CAPTURE)) {
+            // No heredoc/nowdoc found
+            return $code;
+        }
+
+        // Keep track of how much we need to adjust string offsets due to the modifications we
+        // already made
+        $posDelta = 0;
+        foreach ($matches as $match) {
+            $indentation = $match['indentation'][0];
+            $indentationStart = $match['indentation'][1];
+
+            $separator = $match['separator'][0];
+            $separatorStart = $match['separator'][1];
+
+            if ($indentation === '' && $separator !== '') {
+                // Ordinary heredoc/nowdoc
+                continue;
+            }
+
+            if ($indentation !== '') {
+                // Remove indentation
+                $indentationLen = strlen($indentation);
+                $code = substr_replace($code, '', $indentationStart + $posDelta, $indentationLen);
+                $patches[] = [$indentationStart + $posDelta, 'add', $indentation];
+                $posDelta -= $indentationLen;
+            }
+
+            if ($separator === '') {
+                // Insert newline as separator
+                $code = substr_replace($code, "\n", $separatorStart + $posDelta, 0);
+                $patches[] = [$separatorStart + $posDelta, 'remove', "\n"];
+                $posDelta += 1;
+            }
+        }
+
+        return $code;
+    }
+}

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/FnTokenEmulator.php

@@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class FnTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_7_4;
+    }
+
+    public function getKeywordString(): string
+    {
+        return 'fn';
+    }
+
+    public function getKeywordToken(): int
+    {
+        return \T_FN;
+    }
+}

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php

@@ -2,38 +2,43 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\Token;
+abstract class KeywordEmulator extends TokenEmulator
+{
+    abstract function getKeywordString(): string;
+    abstract function getKeywordToken(): int;
 
-abstract class KeywordEmulator extends TokenEmulator {
-    abstract public function getKeywordString(): string;
-    abstract public function getKeywordToken(): int;
-
-    public function isEmulationNeeded(string $code): bool {
+    public function isEmulationNeeded(string $code): bool
+    {
         return strpos(strtolower($code), $this->getKeywordString()) !== false;
     }
 
-    /** @param Token[] $tokens */
-    protected function isKeywordContext(array $tokens, int $pos): bool {
+    protected function isKeywordContext(array $tokens, int $pos): bool
+    {
         $previousNonSpaceToken = $this->getPreviousNonSpaceToken($tokens, $pos);
-        return $previousNonSpaceToken === null || $previousNonSpaceToken->id !== \T_OBJECT_OPERATOR;
+        return $previousNonSpaceToken === null || $previousNonSpaceToken[0] !== \T_OBJECT_OPERATOR;
     }
 
-    public function emulate(string $code, array $tokens): array {
+    public function emulate(string $code, array $tokens): array
+    {
         $keywordString = $this->getKeywordString();
         foreach ($tokens as $i => $token) {
-            if ($token->id === T_STRING && strtolower($token->text) === $keywordString
+            if ($token[0] === T_STRING && strtolower($token[1]) === $keywordString
                     && $this->isKeywordContext($tokens, $i)) {
-                $token->id = $this->getKeywordToken();
+                $tokens[$i][0] = $this->getKeywordToken();
             }
         }
 
         return $tokens;
     }
 
-    /** @param Token[] $tokens */
-    private function getPreviousNonSpaceToken(array $tokens, int $start): ?Token {
+    /**
+     * @param mixed[] $tokens
+     * @return array|string|null
+     */
+    private function getPreviousNonSpaceToken(array $tokens, int $start)
+    {
         for ($i = $start - 1; $i >= 0; --$i) {
-            if ($tokens[$i]->id === T_WHITESPACE) {
+            if ($tokens[$i][0] === T_WHITESPACE) {
                 continue;
             }
 
@@ -43,11 +48,12 @@ abstract class KeywordEmulator extends TokenEmulator {
         return null;
     }
 
-    public function reverseEmulate(string $code, array $tokens): array {
+    public function reverseEmulate(string $code, array $tokens): array
+    {
         $keywordToken = $this->getKeywordToken();
-        foreach ($tokens as $token) {
-            if ($token->id === $keywordToken) {
-                $token->id = \T_STRING;
+        foreach ($tokens as $i => $token) {
+            if ($token[0] === $keywordToken) {
+                $tokens[$i][0] = \T_STRING;
             }
         }
 

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php

@@ -2,18 +2,22 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\PhpVersion;
+use PhpParser\Lexer\Emulative;
 
-final class MatchTokenEmulator extends KeywordEmulator {
-    public function getPhpVersion(): PhpVersion {
-        return PhpVersion::fromComponents(8, 0);
+final class MatchTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_0;
     }
 
-    public function getKeywordString(): string {
+    public function getKeywordString(): string
+    {
         return 'match';
     }
 
-    public function getKeywordToken(): int {
+    public function getKeywordToken(): int
+    {
         return \T_MATCH;
     }
 }

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/NullsafeTokenEmulator.php

@@ -2,58 +2,65 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\PhpVersion;
-use PhpParser\Token;
+use PhpParser\Lexer\Emulative;
 
-final class NullsafeTokenEmulator extends TokenEmulator {
-    public function getPhpVersion(): PhpVersion {
-        return PhpVersion::fromComponents(8, 0);
+final class NullsafeTokenEmulator extends TokenEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_0;
     }
 
-    public function isEmulationNeeded(string $code): bool {
+    public function isEmulationNeeded(string $code): bool
+    {
         return strpos($code, '?->') !== false;
     }
 
-    public function emulate(string $code, array $tokens): array {
+    public function emulate(string $code, array $tokens): array
+    {
         // We need to manually iterate and manage a count because we'll change
         // the tokens array on the way
+        $line = 1;
         for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
-            $token = $tokens[$i];
-            if ($token->text === '?' && isset($tokens[$i + 1]) && $tokens[$i + 1]->id === \T_OBJECT_OPERATOR) {
+            if ($tokens[$i] === '?' && isset($tokens[$i + 1]) && $tokens[$i + 1][0] === \T_OBJECT_OPERATOR) {
                 array_splice($tokens, $i, 2, [
-                    new Token(\T_NULLSAFE_OBJECT_OPERATOR, '?->', $token->line, $token->pos),
+                    [\T_NULLSAFE_OBJECT_OPERATOR, '?->', $line]
                 ]);
                 $c--;
                 continue;
             }
 
             // Handle ?-> inside encapsed string.
-            if ($token->id === \T_ENCAPSED_AND_WHITESPACE && isset($tokens[$i - 1])
-                && $tokens[$i - 1]->id === \T_VARIABLE
-                && preg_match('/^\?->([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)/', $token->text, $matches)
+            if ($tokens[$i][0] === \T_ENCAPSED_AND_WHITESPACE && isset($tokens[$i - 1])
+                && $tokens[$i - 1][0] === \T_VARIABLE
+                && preg_match('/^\?->([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)/', $tokens[$i][1], $matches)
             ) {
                 $replacement = [
-                    new Token(\T_NULLSAFE_OBJECT_OPERATOR, '?->', $token->line, $token->pos),
-                    new Token(\T_STRING, $matches[1], $token->line, $token->pos + 3),
+                    [\T_NULLSAFE_OBJECT_OPERATOR, '?->', $line],
+                    [\T_STRING, $matches[1], $line],
                 ];
-                $matchLen = \strlen($matches[0]);
-                if ($matchLen !== \strlen($token->text)) {
-                    $replacement[] = new Token(
+                if (\strlen($matches[0]) !== \strlen($tokens[$i][1])) {
+                    $replacement[] = [
                         \T_ENCAPSED_AND_WHITESPACE,
-                        \substr($token->text, $matchLen),
-                        $token->line, $token->pos + $matchLen
-                    );
+                        \substr($tokens[$i][1], \strlen($matches[0])),
+                        $line
+                    ];
                 }
                 array_splice($tokens, $i, 1, $replacement);
                 $c += \count($replacement) - 1;
                 continue;
             }
+
+            if (\is_array($tokens[$i])) {
+                $line += substr_count($tokens[$i][1], "\n");
+            }
         }
 
         return $tokens;
     }
 
-    public function reverseEmulate(string $code, array $tokens): array {
+    public function reverseEmulate(string $code, array $tokens): array
+    {
         // ?-> was not valid code previously, don't bother.
         return $tokens;
     }

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/NumericLiteralSeparatorEmulator.php

@@ -0,0 +1,105 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Lexer\TokenEmulator;
+
+use PhpParser\Lexer\Emulative;
+
+final class NumericLiteralSeparatorEmulator extends TokenEmulator
+{
+    const BIN = '(?:0b[01]+(?:_[01]+)*)';
+    const HEX = '(?:0x[0-9a-f]+(?:_[0-9a-f]+)*)';
+    const DEC = '(?:[0-9]+(?:_[0-9]+)*)';
+    const SIMPLE_FLOAT = '(?:' . self::DEC . '\.' . self::DEC . '?|\.' . self::DEC . ')';
+    const EXP = '(?:e[+-]?' . self::DEC . ')';
+    const FLOAT = '(?:' . self::SIMPLE_FLOAT . self::EXP . '?|' . self::DEC . self::EXP . ')';
+    const NUMBER = '~' . self::FLOAT . '|' . self::BIN . '|' . self::HEX . '|' . self::DEC . '~iA';
+
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_7_4;
+    }
+
+    public function isEmulationNeeded(string $code) : bool
+    {
+        return preg_match('~[0-9]_[0-9]~', $code)
+            || preg_match('~0x[0-9a-f]+_[0-9a-f]~i', $code);
+    }
+
+    public function emulate(string $code, array $tokens): array
+    {
+        // We need to manually iterate and manage a count because we'll change
+        // the tokens array on the way
+        $codeOffset = 0;
+        for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+            $token = $tokens[$i];
+            $tokenLen = \strlen(\is_array($token) ? $token[1] : $token);
+
+            if ($token[0] !== T_LNUMBER && $token[0] !== T_DNUMBER) {
+                $codeOffset += $tokenLen;
+                continue;
+            }
+
+            $res = preg_match(self::NUMBER, $code, $matches, 0, $codeOffset);
+            assert($res, "No number at number token position");
+
+            $match = $matches[0];
+            $matchLen = \strlen($match);
+            if ($matchLen === $tokenLen) {
+                // Original token already holds the full number.
+                $codeOffset += $tokenLen;
+                continue;
+            }
+
+            $tokenKind = $this->resolveIntegerOrFloatToken($match);
+            $newTokens = [[$tokenKind, $match, $token[2]]];
+
+            $numTokens = 1;
+            $len = $tokenLen;
+            while ($matchLen > $len) {
+                $nextToken = $tokens[$i + $numTokens];
+                $nextTokenText = \is_array($nextToken) ? $nextToken[1] : $nextToken;
+                $nextTokenLen = \strlen($nextTokenText);
+
+                $numTokens++;
+                if ($matchLen < $len + $nextTokenLen) {
+                    // Split trailing characters into a partial token.
+                    assert(is_array($nextToken), "Partial token should be an array token");
+                    $partialText = substr($nextTokenText, $matchLen - $len);
+                    $newTokens[] = [$nextToken[0], $partialText, $nextToken[2]];
+                    break;
+                }
+
+                $len += $nextTokenLen;
+            }
+
+            array_splice($tokens, $i, $numTokens, $newTokens);
+            $c -= $numTokens - \count($newTokens);
+            $codeOffset += $matchLen;
+        }
+
+        return $tokens;
+    }
+
+    private function resolveIntegerOrFloatToken(string $str): int
+    {
+        $str = str_replace('_', '', $str);
+
+        if (stripos($str, '0b') === 0) {
+            $num = bindec($str);
+        } elseif (stripos($str, '0x') === 0) {
+            $num = hexdec($str);
+        } elseif (stripos($str, '0') === 0 && ctype_digit($str)) {
+            $num = octdec($str);
+        } else {
+            $num = +$str;
+        }
+
+        return is_float($num) ? T_DNUMBER : T_LNUMBER;
+    }
+
+    public function reverseEmulate(string $code, array $tokens): array
+    {
+        // Numeric separators were not legal code previously, don't bother.
+        return $tokens;
+    }
+}

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReadonlyFunctionTokenEmulator.php

@@ -2,7 +2,7 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\PhpVersion;
+use PhpParser\Lexer\Emulative;
 
 /*
  * In PHP 8.1, "readonly(" was special cased in the lexer in order to support functions with
@@ -20,8 +20,8 @@ class ReadonlyFunctionTokenEmulator extends KeywordEmulator {
         return \T_READONLY;
     }
 
-    public function getPhpVersion(): PhpVersion {
-        return PhpVersion::fromComponents(8, 2);
+    public function getPhpVersion(): string {
+        return Emulative::PHP_8_2;
     }
 
     public function reverseEmulate(string $code, array $tokens): array {

package/plugins/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReadonlyTokenEmulator.php

@@ -2,30 +2,35 @@
 
 namespace PhpParser\Lexer\TokenEmulator;
 
-use PhpParser\PhpVersion;
+use PhpParser\Lexer\Emulative;
 
-final class ReadonlyTokenEmulator extends KeywordEmulator {
-    public function getPhpVersion(): PhpVersion {
-        return PhpVersion::fromComponents(8, 1);
+final class ReadonlyTokenEmulator extends KeywordEmulator
+{
+    public function getPhpVersion(): string
+    {
+        return Emulative::PHP_8_1;
     }
 
-    public function getKeywordString(): string {
+    public function getKeywordString(): string
+    {
         return 'readonly';
     }
 
-    public function getKeywordToken(): int {
+    public function getKeywordToken(): int
+    {
         return \T_READONLY;
     }
 
-    protected function isKeywordContext(array $tokens, int $pos): bool {
+    protected function isKeywordContext(array $tokens, int $pos): bool
+    {
         if (!parent::isKeywordContext($tokens, $pos)) {
             return false;
         }
         // Support "function readonly("
         return !(isset($tokens[$pos + 1]) &&
-                 ($tokens[$pos + 1]->text === '(' ||
-                  ($tokens[$pos + 1]->id === \T_WHITESPACE &&
+                 ($tokens[$pos + 1][0] === '(' ||
+                  ($tokens[$pos + 1][0] === \T_WHITESPACE &&
                    isset($tokens[$pos + 2]) &&
-                   $tokens[$pos + 2]->text === '(')));
+                   $tokens[$pos + 2][0] === '(')));
     }
 }