Patterns parsing: fix handling of builtin identifiers and pseudo-keywords.

Bug: #50035
Change-Id: I95f2b7d59a54d0d5e1975bd8cd1dce88db03fa51
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/269580
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Jens Johansen <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -9304,7 +9304,7 @@ class Parser {
     // TODO(paulberry): Make sure OTHER_IDENTIFIER is handled
     // TODO(paulberry): Technically `dynamic` is valid for
     // `typeIdentifier`--file an issue
-    if (isValidNonRecordTypeReference(next)) {
+    if (next.isIdentifier) {
       Token beforeFirstIdentifier = token;
       Token firstIdentifier = token = next;
       next = token.next!;
@@ -9313,7 +9313,7 @@ class Parser {
       if (optional('.', next)) {
         dot = token = next;
         next = token.next!;
-        if (isValidNonRecordTypeReference(next)) {
+        if (next.isIdentifier) {
           secondIdentifier = token = next;
           // TODO(paulberry): grammar specifies
           // `typeIdentifier | qualifiedName`, but that permits `a.b.c`,

pkg/analyzer/test/generated/patterns_parser_test.dart

@@ -956,6 +956,32 @@ RecordPattern
 ''');
   }
 
+  test_constant_identifier_doublyPrefixed_builtin() {
+    _parse('''
+void f(x) {
+  const y = abstract.as.get; // verify that this works
+  switch (x) {
+    case abstract.as.get:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case abstract.as.get').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PropertyAccess
+    target: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: abstract
+      period: .
+      identifier: SimpleIdentifier
+        token: as
+    operator: .
+    propertyName: SimpleIdentifier
+      token: get
+''');
+  }
+
   test_constant_identifier_doublyPrefixed_insideCase() {
     _parse('''
 void f(x) {
@@ -1089,6 +1115,54 @@ PostfixPattern
 ''');
   }
 
+  test_constant_identifier_doublyPrefixed_pseudoKeyword() {
+    _parse('''
+void f(x) {
+  const y = show.hide.when; // verify that this works
+  switch (x) {
+    case show.hide.when:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case show.hide.when').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PropertyAccess
+    target: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: show
+      period: .
+      identifier: SimpleIdentifier
+        token: hide
+    operator: .
+    propertyName: SimpleIdentifier
+      token: when
+''');
+  }
+
+  test_constant_identifier_prefixed_builtin() {
+    _parse('''
+void f(x) {
+  const y = abstract.as; // verify that this works
+  switch (x) {
+    case abstract.as:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case abstract.as').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PrefixedIdentifier
+    prefix: SimpleIdentifier
+      token: abstract
+    period: .
+    identifier: SimpleIdentifier
+      token: as
+''');
+  }
+
   test_constant_identifier_prefixed_insideCase() {
     _parse('''
 void f(x) {
@@ -1202,6 +1276,28 @@ PostfixPattern
 ''');
   }
 
+  test_constant_identifier_prefixed_pseudoKeyword() {
+    _parse('''
+void f(x) {
+  const y = show.hide; // verify that this works
+  switch (x) {
+    case show.hide:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case show.hide').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PrefixedIdentifier
+    prefix: SimpleIdentifier
+      token: show
+    period: .
+    identifier: SimpleIdentifier
+      token: hide
+''');
+  }
+
   test_constant_identifier_prefixedWithUnderscore_insideCase() {
     // We need to make sure the `_` isn't misinterpreted as a wildcard pattern
     _parse('''
@@ -1224,6 +1320,24 @@ ConstantPattern
 ''');
   }
 
+  test_constant_identifier_unprefixed_builtin() {
+    _parse('''
+void f(x) {
+  const y = abstract; // verify that this works
+  switch (x) {
+    case abstract:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case abstract').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: SimpleIdentifier
+    token: abstract
+''');
+  }
+
   test_constant_identifier_unprefixed_insideCase() {
     _parse('''
 void f(x) {
@@ -1322,6 +1436,24 @@ PostfixPattern
 ''');
   }
 
+  test_constant_identifier_unprefixed_pseudoKeyword() {
+    _parse('''
+void f(x) {
+  const y = show; // verify that this works
+  switch (x) {
+    case show:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case show').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: SimpleIdentifier
+    token: show
+''');
+  }
+
   test_constant_list_typed_empty_insideCase() {
     _parse('''
 void f(x) {

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_builtin.dart

@@ -0,0 +1,7 @@
+void f(x) {
+  const y = abstract.as.get; // verify that this works
+  switch (x) {
+    case abstract.as.get:
+      break;
+  }
+}

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_builtin.dart.expect

@@ -0,0 +1,76 @@
+beginCompilationUnit(void)
+  beginMetadataStar(void)
+  endMetadataStar(0)
+  beginTopLevelMember(void)
+    beginTopLevelMethod(, null, null)
+      handleVoidKeyword(void)
+      handleIdentifier(f, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+        beginMetadataStar(x)
+        endMetadataStar(0)
+        beginFormalParameter(x, MemberKind.TopLevelMethod, null, null, null)
+          handleNoType(()
+          handleIdentifier(x, formalParameterDeclaration)
+          handleFormalParameterWithoutValue())
+        endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+      endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginBlockFunctionBody({)
+        beginMetadataStar(const)
+        endMetadataStar(0)
+        handleNoType(const)
+        beginVariablesDeclaration(y, null, const)
+          handleIdentifier(y, localVariableDeclaration)
+          beginInitializedIdentifier(y)
+            beginVariableInitializer(=)
+              handleIdentifier(abstract, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(abstract, .)
+              handleIdentifier(as, expressionContinuation)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(as, .)
+              handleEndingBinaryExpression(.)
+              handleIdentifier(get, expressionContinuation)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(get, ;)
+              handleEndingBinaryExpression(.)
+            endVariableInitializer(=)
+          endInitializedIdentifier(y)
+        endVariablesDeclaration(1, ;)
+        beginSwitchStatement(switch)
+          handleIdentifier(x, expression)
+          handleNoTypeArguments())
+          handleNoArguments())
+          handleSend(x, ))
+          handleParenthesizedCondition((, null, null)
+          beginSwitchBlock({)
+            beginCaseExpression(case)
+              handleIdentifier(abstract, expression)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(abstract, .)
+              handleIdentifier(as, expressionContinuation)
+              handleNoTypeArguments(.)
+              handleNoArguments(.)
+              handleSend(as, .)
+              handleEndingBinaryExpression(.)
+              handleIdentifier(get, expressionContinuation)
+              handleNoTypeArguments(:)
+              handleNoArguments(:)
+              handleSend(get, :)
+              handleEndingBinaryExpression(.)
+              handleConstantPattern(null)
+            endCaseExpression(case, null, :)
+            beginSwitchCase(0, 1, case)
+              handleBreakStatement(false, break, ;)
+            endSwitchCase(0, 1, null, null, 1, case, })
+          endSwitchBlock(1, {, })
+        endSwitchStatement(switch, })
+      endBlockFunctionBody(2, {, })
+    endTopLevelMethod(void, null, })
+  endTopLevelDeclaration()
+endCompilationUnit(1, )