Add nullsafe operator support (#429)

Author: VincentLanglet

src/Cache/Manager/FileCacheManager.php

@@ -42,7 +42,7 @@ public function __destruct()
     /**
      * This class is not intended to be serialized, and cannot be deserialized.
      */
-    public function __sleep(): array
+    public function __serialize(): array
     {
         throw new \BadMethodCallException(\sprintf('Cannot serialize %s.', self::class));
     }
@@ -51,8 +51,10 @@ public function __sleep(): array
      * Prevent attacker executing code by leveraging the __destruct method.
      *
      * @see https://owasp.org/www-community/vulnerabilities/PHP_Object_Injection
+     *
+     * @param array<mixed> $data
      */
-    public function __wakeup(): void
+    public function __unserialize(array $data): void
     {
         throw new \BadMethodCallException(\sprintf('Cannot unserialize %s.', self::class));
     }

src/Rules/Operator/OperatorSpacingRule.php

@@ -25,7 +25,7 @@ protected function getSpaceBefore(int $tokenIndex, Tokens $tokens): ?int
             return $this->isUnary($tokenIndex, $tokens) ? null : 1;
         }
 
-        if ($token->isMatching(Token::OPERATOR_TYPE, '..')) {
+        if ($token->isMatching(Token::OPERATOR_TYPE, ['..', '?.'])) {
             return 0;
         }
 
@@ -49,7 +49,7 @@ protected function getSpaceAfter(int $tokenIndex, Tokens $tokens): ?int
             return $this->isUnary($tokenIndex, $tokens) ? 0 : 1;
         }
 
-        if ($token->isMatching(Token::OPERATOR_TYPE, '..')) {
+        if ($token->isMatching(Token::OPERATOR_TYPE, ['..', '?.'])) {
             return 0;
         }
 

src/Token/Tokenizer.php

@@ -43,6 +43,8 @@ final class Tokenizer implements TokenizerInterface
     private const REGEX_DQ_STRING_PART = '/'.self::DQ_STRING_PATTERN.'/As';
     private const REGEX_DQ_STRING_DELIM = '/"/A';
 
+    private const PUNCTUATIONS = ['(', ')', '[', ']', '{', '}', ':', '.', ',', '|'];
+
     /**
      * @var non-empty-string
      */
@@ -331,16 +333,19 @@ private function lexExpression(): void
         } elseif (1 === preg_match("/^\r\n?|^\n/", $currentCode.$nextToken, $match)) {
             $this->lexEOL($match[0]);
         } elseif ('.' === $currentCode && '.' === $nextToken && '.' === $next2Token) {
+            // NEXT_MAJOR: Should be an OPERATOR_TYPE like in Twig 3.21+
             $this->lexSpread();
         } elseif ('=' === $currentCode && '>' === $nextToken) {
+            // NEXT_MAJOR: Should be an OPERATOR_TYPE like in Twig 3.21+
             $this->lexArrowFunction();
         } elseif (1 === preg_match($this->operatorRegex, $this->code, $match, 0, $this->cursor)) {
             $this->lexOperator($match[0]);
         } elseif (1 === preg_match(self::REGEX_NAME, $this->code, $match, 0, $this->cursor)) {
             $this->lexName($match[0]);
         } elseif (1 === preg_match(self::REGEX_NUMBER, $this->code, $match, 0, $this->cursor)) {
             $this->lexNumber($match[0]);
-        } elseif (\in_array($currentCode, ['(', ')', '[', ']', '{', '}', ':', '.', ',', '|'], true)) {
+        } elseif (\in_array($currentCode, self::PUNCTUATIONS, true)) {
+            // NEXT_MAJOR: `.` and `|` should be operator instead like in Twig 3.21+
             $this->lexPunctuation();
         } elseif (1 === preg_match(self::REGEX_STRING, $this->code, $match, 0, $this->cursor)) {
             $this->lexString($match[0]);
@@ -783,15 +788,13 @@ private function getOperatorRegex(Environment $env): string
             $expressionParsers = [];
             // @phpstan-ignore-next-line method.internal
             foreach ($env->getExpressionParsers() as $expressionParser) {
-                $operator = $expressionParser->getName();
-                // Avoid conflict with ARROW_TYPE and PUNCTUATION_TYPE
-                if (\in_array($operator, ['=>', '(', '[', '|', '.'], true)) {
-                    continue;
-                }
+                foreach ([$expressionParser->getName(), ...$expressionParser->getAliases()] as $name) {
+                    // Avoid conflict with PUNCTUATION_TYPE
+                    if (\in_array($name, self::PUNCTUATIONS, true)) {
+                        continue;
+                    }
 
-                $expressionParsers[] = $operator;
-                foreach ($expressionParser->getAliases() as $alias) {
-                    $expressionParsers[] = $alias;
+                    $expressionParsers[] = $name;
                 }
             }
         } else {
@@ -805,7 +808,7 @@ private function getOperatorRegex(Environment $env): string
         }
 
         /** @var string[] $operators */
-        $operators = ['=', '?', '?:', ...$expressionParsers];
+        $operators = ['=', '?', '?:', '?.', ...$expressionParsers];
         $lengthByOperator = [];
         foreach ($operators as $operator) {
             $lengthByOperator[$operator] = \strlen($operator);

tests/Rules/Operator/OperatorSpacing/OperatorSpacingRuleTest.fixed.twig

@@ -53,3 +53,5 @@ Untouch +-/*%==:
          not array or b is foo }}
 
 {% types {foo: 'int', bar?: 'string'} %}
+
+{{ foo?.bar }}

tests/Rules/Operator/OperatorSpacing/OperatorSpacingRuleTest.twig

@@ -53,3 +53,5 @@ Untouch +-/*%==:
          not  array or b  is  foo }}
 
 {% types {foo: 'int', bar?: 'string'} %}
+
+{{ foo?.bar }}

tests/Token/Tokenizer/Fixtures/test19.twig

@@ -0,0 +1 @@
+{{ user?.address?.city }}

tests/Token/Tokenizer/TokenizerTest.php

@@ -870,6 +870,23 @@ public static function tokenizeDataProvider(): iterable
                 8 => Token::EOF_TYPE,
             ],
         ];
+
+        yield [
+            __DIR__.'/Fixtures/test19.twig',
+            [
+                0 => Token::VAR_START_TYPE,
+                1 => Token::WHITESPACE_TYPE,
+                2 => Token::NAME_TYPE,
+                3 => Token::OPERATOR_TYPE,
+                4 => Token::NAME_TYPE,
+                5 => Token::OPERATOR_TYPE,
+                6 => Token::NAME_TYPE,
+                7 => Token::WHITESPACE_TYPE,
+                8 => Token::VAR_END_TYPE,
+                9 => Token::EOL_TYPE,
+                10 => Token::EOF_TYPE,
+            ],
+        ];
     }
 
     /**