Support parsing PHP 7.4's arrow functions

src/Node/Expression/ArrowFunctionCreationExpression.php

@@ -0,0 +1,48 @@
+<?php
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+namespace Microsoft\PhpParser\Node\Expression;
+
+use Microsoft\PhpParser\FunctionLike;
+use Microsoft\PhpParser\Node;
+use Microsoft\PhpParser\Node\Expression;
+use Microsoft\PhpParser\Node\FunctionHeader;
+use Microsoft\PhpParser\Node\FunctionReturnType;
+use Microsoft\PhpParser\Token;
+
+class ArrowFunctionCreationExpression extends Expression implements FunctionLike {
+    /** @var Token|null */
+    public $staticModifier;
+
+    use FunctionHeader, FunctionReturnType;
+
+    /** @var Token `=>` */
+    public $arrowToken;
+
+    /** @var Node|Token */
+    public $resultExpression;
+
+    const CHILD_NAMES = [
+        'staticModifier',
+
+        // FunctionHeader
+        'functionKeyword',
+        'byRefToken',
+        'name',
+        'openParen',
+        'parameters',
+        'closeParen',
+
+        // FunctionReturnType
+        'colonToken',
+        'questionToken',
+        'returnType',
+
+        // body
+        'arrowToken',
+        'resultExpression',
+    ];
+}

src/Node/QualifiedName.php

@@ -10,6 +10,7 @@
 use Microsoft\PhpParser\NamespacedNameTrait;
 use Microsoft\PhpParser\Node;
 use Microsoft\PhpParser\Node\Expression\AnonymousFunctionCreationExpression;
+use Microsoft\PhpParser\Node\Expression\ArrowFunctionCreationExpression;
 use Microsoft\PhpParser\Node\Expression\CallExpression;
 use Microsoft\PhpParser\Node\Expression\ObjectCreationExpression;
 use Microsoft\PhpParser\ResolvedName;
@@ -180,6 +181,7 @@ private function isConstantName() : bool {
                 $this->parent instanceof Node\Expression\MemberAccessExpression || $this->parent instanceof CallExpression ||
                 $this->parent instanceof ObjectCreationExpression ||
                 $this->parent instanceof Node\Expression\ScopedPropertyAccessExpression || $this->parent instanceof AnonymousFunctionCreationExpression ||
+                $this->parent instanceof ArrowFunctionCreationExpression ||
                 ($this->parent instanceof Node\Expression\BinaryExpression && $this->parent->operator->kind === TokenKind::InstanceOfKeyword)
             );
     }

src/Parser.php

@@ -19,6 +19,7 @@
     AnonymousFunctionCreationExpression,
     ArgumentExpression,
     ArrayCreationExpression,
+    ArrowFunctionCreationExpression,
     AssignmentExpression,
     BinaryExpression,
     BracedExpression,
@@ -563,7 +564,7 @@ private function parseStatementFn() {
                 // function-static-declaration
                 case TokenKind::StaticKeyword:
                     // Check that this is not an anonymous-function-creation-expression
-                    if (!$this->lookahead([TokenKind::FunctionKeyword, TokenKind::OpenParenToken, TokenKind::ColonColonToken])) {
+                    if (!$this->lookahead([TokenKind::FunctionKeyword, TokenKind::FnKeyword, TokenKind::OpenParenToken, TokenKind::ColonColonToken])) {
                         return $this->parseFunctionStaticDeclaration($parentNode);
                     }
                     break;
@@ -899,6 +900,7 @@ private function isExpressionStartFn() {
                 // anonymous-function-creation-expression
                 case TokenKind::StaticKeyword:
                 case TokenKind::FunctionKeyword:
+                case TokenKind::FnKeyword:
                     return true;
             }
             return \in_array($token->kind, $this->reservedWordTokens, true);
@@ -978,12 +980,13 @@ private function parsePrimaryExpression($parentNode) {
             case TokenKind::StaticKeyword:
                 // handle `static::`, `static(`, `new static;`, `instanceof static`
                 if (($this->lookahead([TokenKind::ColonColonToken, TokenKind::OpenParenToken])) ||
-                    (!$this->lookahead(TokenKind::FunctionKeyword))
+                    (!$this->lookahead([TokenKind::FunctionKeyword, TokenKind::FnKeyword]))
                 ) {
                     return $this->parseQualifiedName($parentNode);
                 }
                 // Could be `static function` anonymous function creation expression, so flow through
             case TokenKind::FunctionKeyword:
+            case TokenKind::FnKeyword:
                 return $this->parseAnonymousFunctionCreationExpression($parentNode);
 
             case TokenKind::TrueReservedWord:
@@ -3326,15 +3329,56 @@ private function parseCastExpressionGranular($parentNode) {
     }
 
     private function parseAnonymousFunctionCreationExpression($parentNode) {
+        $staticModifier = $this->eatOptional1(TokenKind::StaticKeyword);
+        if ($this->getCurrentToken()->kind === TokenKind::FnKeyword) {
+            return $this->parseArrowFunctionCreationExpression($parentNode, $staticModifier);
+        }
         $anonymousFunctionCreationExpression = new AnonymousFunctionCreationExpression();
         $anonymousFunctionCreationExpression->parent = $parentNode;
 
-        $anonymousFunctionCreationExpression->staticModifier = $this->eatOptional1(TokenKind::StaticKeyword);
+        $anonymousFunctionCreationExpression->staticModifier = $staticModifier;
         $this->parseFunctionType($anonymousFunctionCreationExpression, false, true);
 
         return $anonymousFunctionCreationExpression;
     }
 
+    private function parseArrowFunctionCreationExpression($parentNode, $staticModifier) : ArrowFunctionCreationExpression {
+        $arrowFunction = new ArrowFunctionCreationExpression();
+        $arrowFunction->parent = $parentNode;
+        $arrowFunction->staticModifier = $staticModifier;
+
+        $arrowFunction->functionKeyword = $this->eat1(TokenKind::FnKeyword);
+        $arrowFunction->byRefToken = $this->eatOptional1(TokenKind::AmpersandToken);
+        $arrowFunction->name = $this->eatOptional($this->nameOrKeywordOrReservedWordTokens);
+
+        if (isset($arrowFunction->name)) {
+            // Anonymous functions should not have names.
+            // This is based on the code for AnonymousFunctionCreationExpression.
+            $arrowFunction->name->kind = TokenKind::Name;
+            $arrowFunction->name = new SkippedToken($arrowFunction->name); // TODO instead handle this during post-walk
+        }
+
+        $arrowFunction->openParen = $this->eat1(TokenKind::OpenParenToken);
+        $arrowFunction->parameters = $this->parseDelimitedList(
+            DelimitedList\ParameterDeclarationList::class,
+            TokenKind::CommaToken,
+            $this->isParameterStartFn(),
+            $this->parseParameterFn(),
+            $arrowFunction);
+        $arrowFunction->closeParen = $this->eat1(TokenKind::CloseParenToken);
+
+        if ($this->checkToken(TokenKind::ColonToken)) {
+            $arrowFunction->colonToken = $this->eat1(TokenKind::ColonToken);
+            $arrowFunction->questionToken = $this->eatOptional1(TokenKind::QuestionToken);
+            $arrowFunction->returnType = $this->parseReturnTypeDeclaration($arrowFunction);
+        }
+
+        $arrowFunction->arrowToken = $this->eat1(TokenKind::DoubleArrowToken);
+        $arrowFunction->resultExpression = $this->parseExpression($arrowFunction);
+
+        return $arrowFunction;
+    }
+
     private function parseAnonymousFunctionUseClause($parentNode) {
         $anonymousFunctionUseClause = new AnonymousFunctionUseClause();
         $anonymousFunctionUseClause->parent = $parentNode;

src/PhpTokenizer.php

@@ -6,9 +6,10 @@
 
 namespace Microsoft\PhpParser;
 
-// If this predates PHP 7.4, T_COALESCE_EQUAL is unavailable.
+// If this predates PHP 7.4, T_COALESCE_EQUAL and T_FN are unavailable.
 // The replacement value is arbitrary - it just has to be different from other values of token constants.
 define(__NAMESPACE__ . '\T_COALESCE_EQUAL', defined('T_COALESCE_EQUAL') ? constant('T_COALESCE_EQUAL') : 'T_COALESCE_EQUAL');
+define(__NAMESPACE__ . '\T_FN', defined('T_FN') ? constant('T_FN') : 'T_FN');
 
 /**
  * Tokenizes content using PHP's built-in `token_get_all`, and converts to "lightweight" Token representation.
@@ -192,6 +193,7 @@ public static function getTokensArrayFromContent(
         T_FINALLY => TokenKind::FinallyKeyword,
         T_FOR => TokenKind::ForKeyword,
         T_FOREACH => TokenKind::ForeachKeyword,
+        T_FN => TokenKind::FnKeyword,
         T_FUNCTION => TokenKind::FunctionKeyword,
         T_GLOBAL => TokenKind::GlobalKeyword,
         T_GOTO => TokenKind::GotoKeyword,

src/TokenKind.php

@@ -85,6 +85,7 @@ class TokenKind {
     const XorKeyword = 165;
     const YieldKeyword = 166;
     const YieldFromKeyword = 167;
+    const FnKeyword = 168;
 
     const OpenBracketToken = 201;
     const CloseBracketToken = 202;

src/TokenStringMaps.php

@@ -43,6 +43,7 @@ class TokenStringMaps {
         "finally" => TokenKind::FinallyKeyword,
         "for" => TokenKind::ForKeyword,
         "foreach" => TokenKind::ForeachKeyword,
+        "fn" => TokenKind::FnKeyword,
         "function" => TokenKind::FunctionKeyword,
         "global" => TokenKind::GlobalKeyword,
         "goto" => TokenKind::GotoKeyword,

tests/cases/parser74/arrowFunction.php

@@ -0,0 +1,9 @@
+<?php
+$f = fn(array $x) => $x;
+fn(): int => $x;
+fn($x = 42) => yield $x;
+fn(&$x) => $x;
+fn&($x) => $x;
+fn($x, ...$rest) => $rest;
+static fn() => 1;
+$f = static fn() => 2;

tests/cases/parser74/arrowFunction.php.diag

@@ -0,0 +1 @@
+[]