Merge pull request #14 from phan/fix-namespace-handling

Fix namespace handling of keywords

Author: rlerdorf

src/Parser.php

@@ -132,6 +132,7 @@ class Parser {
     private $nameOrKeywordOrReservedWordTokens;
     private $nameOrReservedWordTokens;
     private $nameOrStaticOrReservedWordTokens;
+    private $nameOrKeywordOrReservedWordTokensExceptNamespace;
     private $reservedWordTokens;
     private $keywordTokens;
     private $argumentStartTokensSet;
@@ -148,6 +149,10 @@ public function __construct() {
         $this->nameOrKeywordOrReservedWordTokens = \array_merge([TokenKind::Name], $this->keywordTokens, $this->reservedWordTokens);
         $this->nameOrReservedWordTokens = \array_merge([TokenKind::Name], $this->reservedWordTokens);
         $this->nameOrStaticOrReservedWordTokens = \array_merge([TokenKind::Name, TokenKind::StaticKeyword], $this->reservedWordTokens);
+        $this->nameOrKeywordOrReservedWordTokensExceptNamespace = \array_values(\array_diff(
+            $this->nameOrKeywordOrReservedWordTokens,
+            [TokenKind::NamespaceKeyword]
+        ));
         $this->parameterTypeDeclarationTokens =
             [TokenKind::ArrayKeyword, TokenKind::CallableKeyword, TokenKind::BoolReservedWord,
             TokenKind::FloatReservedWord, TokenKind::IntReservedWord, TokenKind::StringReservedWord,
@@ -1872,23 +1877,13 @@ private function parseQualifiedNameFn() {
                     DelimitedList\QualifiedNameParts::class,
                     TokenKind::BackslashToken,
                     function ($token) {
-                        // a\static() <- INVALID (but not checked for right now)
-                        // new a\static() <- INVALID
-                        // new static() <- VALID
-                        // a\static\b <- INVALID
-                        // a\function <- INVALID
-                        // a\true\b <-VALID
-                        // a\b\true <-VALID
-                        // a\static::b <-VALID
-                        // TODO more tests
-                        return $this->lookahead(TokenKind::BackslashToken)
-                            ? in_array($token->kind, $this->nameOrReservedWordTokens)
-                            : in_array($token->kind, $this->nameOrStaticOrReservedWordTokens);
+                        if ($token->kind === TokenKind::NamespaceKeyword) {
+                            return false;
+                        }
+                        return \in_array($token->kind, $this->nameOrKeywordOrReservedWordTokensExceptNamespace, true);
                     },
                     function ($parentNode) {
-                        $name = $this->lookahead(TokenKind::BackslashToken)
-                            ? $this->eat($this->nameOrReservedWordTokens)
-                            : $this->eat($this->nameOrStaticOrReservedWordTokens); // TODO support keyword name
+                        $name = $this->eat($this->nameOrKeywordOrReservedWordTokensExceptNamespace); // TODO support keyword name
                         $name->kind = TokenKind::Name; // bool/true/null/static should not be treated as keywords in this case
                         return $name;
                     }, $node);
@@ -3929,8 +3924,10 @@ private function parseNamespaceDefinition($parentNode) {
             $namespaceDefinition->compoundStatementOrSemicolon = $this->parseCompoundStatement($namespaceDefinition);
         } else {
             if (!$namespaceDefinition->name) {
-                // only optional with compound statement block
-                $namespaceDefinition->name = new MissingToken(TokenKind::QualifiedName, $this->token->fullStart);
+                if (!$this->checkToken(TokenKind::SemicolonToken)) {
+                    // name is only optional when followed by a semicolon (global namespace)
+                    $namespaceDefinition->name = new MissingToken(TokenKind::QualifiedName, $this->token->fullStart);
+                }
             }
             $namespaceDefinition->compoundStatementOrSemicolon = $this->eatSemicolonOrAbortStatement();
         }

tests/cases/parser/namespaceDefinition2.php.diag

@@ -1,8 +1 @@
-[
-    {
-        "kind": 0,
-        "message": "'QualifiedName' expected.",
-        "start": 64,
-        "length": 0
-    }
-]
+[]

tests/cases/parser/namespaceDefinition2.php.tree

@@ -17,11 +17,7 @@
                         "kind": "NamespaceKeyword",
                         "textLength": 9
                     },
-                    "name": {
-                        "error": "MissingToken",
-                        "kind": "QualifiedName",
-                        "textLength": 0
-                    },
+                    "name": null,
                     "compoundStatementOrSemicolon": {
                         "kind": "SemicolonToken",
                         "textLength": 1

tests/cases/parser/namespaceDefinition6.php

@@ -0,0 +1,2 @@
+<?php
+namespace global;

tests/cases/parser/namespaceDefinition6.php.diag

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

tests/cases/parser/namespaceDefinition6.php.tree

@@ -0,0 +1,44 @@
+{
+    "SourceFileNode": {
+        "statementList": [
+            {
+                "InlineHtml": {
+                    "scriptSectionEndTag": null,
+                    "text": null,
+                    "scriptSectionStartTag": {
+                        "kind": "ScriptSectionStartTag",
+                        "textLength": 6
+                    }
+                }
+            },
+            {
+                "NamespaceDefinition": {
+                    "namespaceKeyword": {
+                        "kind": "NamespaceKeyword",
+                        "textLength": 9
+                    },
+                    "name": {
+                        "QualifiedName": {
+                            "globalSpecifier": null,
+                            "relativeSpecifier": null,
+                            "nameParts": [
+                                {
+                                    "kind": "Name",
+                                    "textLength": 6
+                                }
+                            ]
+                        }
+                    },
+                    "compoundStatementOrSemicolon": {
+                        "kind": "SemicolonToken",
+                        "textLength": 1
+                    }
+                }
+            }
+        ],
+        "endOfFileToken": {
+            "kind": "EndOfFileToken",
+            "textLength": 0
+        }
+    }
+}