Support parsing of key path subscripts on metatypes

This is needed to support parsing eg.
https://github.com/swiftlang/swift/pull/73242/files#diff-a94f38549dc87ce27c438b255ae2f29c69cc1c2c5e5069f327c5c7fae7bc553dR667

Author: ahoppen

Sources/SwiftParser/Expressions.swift

@@ -997,18 +997,20 @@ extension Parser {
     // the token is an operator starts with '.', or the following token is '['.
     let rootType: RawTypeSyntax?
     if !self.at(prefix: ".") {
-      rootType = self.parseSimpleType(stopAtFirstPeriod: true)
+      rootType = self.parseSimpleType(allowMemberTypes: false)
     } else {
       rootType = nil
     }
 
     var components: [RawKeyPathComponentSyntax] = []
     var loopProgress = LoopProgressCondition()
     while self.hasProgressed(&loopProgress) {
-      // Check for a [] or .[] suffix. The latter is only permitted when there
-      // are no components.
+      // Check for a [] or .[] suffix. The latter is only permitted after the type name. Since we don't know what
+      // constitutes a nested type reference and what constitutes a type's member, we can only disallow it in the parser
+      // after seeing the first non-property component.
       if self.at(TokenSpec(.leftSquare, allowAtStartOfLine: false))
-        || (components.isEmpty && self.at(.period) && self.peek(isAt: .leftSquare))
+        || (components.allSatisfy({ $0.component.is(RawKeyPathPropertyComponentSyntax.self) }) && self.at(.period)
+          && self.peek(isAt: .leftSquare))
       {
         // Consume the '.', if it's allowed here.
         let period: RawTokenSyntax?
@@ -1059,11 +1061,7 @@ extension Parser {
           self.currentToken.tokenText
         )
       {
-        components.append(
-          contentsOf: self.consumeOptionalKeyPathPostfix(
-            numComponents: numComponents
-          )
-        )
+        components += self.consumeOptionalKeyPathPostfix(numComponents: numComponents)
         continue
       }
 

Sources/SwiftParser/Types.swift

@@ -190,9 +190,8 @@ extension Parser {
     return parseSimpleType(forAttributeName: true)
   }
 
-  /// Parse a "simple" type
   mutating func parseSimpleType(
-    stopAtFirstPeriod: Bool = false,
+    allowMemberTypes: Bool = true,
     forAttributeName: Bool = false
   ) -> RawTypeSyntax {
     enum TypeBaseStart: TokenSpecSet {
@@ -260,7 +259,9 @@ extension Parser {
 
     var loopProgress = LoopProgressCondition()
     while self.hasProgressed(&loopProgress) {
-      if !stopAtFirstPeriod, self.at(.period) {
+      if allowMemberTypes || (self.at(.period) && self.peek(isAt: .keyword(.Type), .keyword(.Protocol))),
+        self.at(.period)
+      {
         let (unexpectedPeriod, period, skipMemberName) = self.consumeMemberPeriod(previousNode: base)
         if skipMemberName {
           let missingIdentifier = missingToken(.identifier)

Tests/SwiftParserTest/ExpressionTests.swift

@@ -254,6 +254,66 @@ final class ExpressionTests: ParserTestCase {
     )
   }
 
+  func testKeyPathSubscriptOnType() {
+    assertParse(
+      #"\Foo.Type.[2]"#,
+      substructure: KeyPathExprSyntax(
+        root: TypeSyntax(
+          MetatypeTypeSyntax(baseType: TypeSyntax("Foo"), metatypeSpecifier: .keyword(.Type))
+        ),
+        components: KeyPathComponentListSyntax([
+          KeyPathComponentSyntax(
+            period: .periodToken(),
+            component: KeyPathComponentSyntax.Component(
+              KeyPathSubscriptComponentSyntax(
+                arguments: LabeledExprListSyntax([LabeledExprSyntax(expression: ExprSyntax("2"))])
+              )
+            )
+          )
+        ])
+      )
+    )
+
+    assertParse(
+      #"\Foo.Bar.[2]"#,
+      substructure: KeyPathExprSyntax(
+        root: TypeSyntax("Foo"),
+        components: KeyPathComponentListSyntax([
+          KeyPathComponentSyntax(
+            period: .periodToken(),
+            component: KeyPathComponentSyntax.Component(
+              KeyPathPropertyComponentSyntax(declName: DeclReferenceExprSyntax(baseName: .identifier("Bar")))
+            )
+          ),
+          KeyPathComponentSyntax(
+            period: .periodToken(),
+            component: KeyPathComponentSyntax.Component(
+              KeyPathSubscriptComponentSyntax(
+                arguments: LabeledExprListSyntax([LabeledExprSyntax(expression: ExprSyntax("2"))])
+              )
+            )
+          ),
+        ])
+      )
+    )
+
+    assertParse(
+      #"\Foo.Bar.[2].1️⃣[1]"#,
+      diagnostics: [
+        DiagnosticSpec(message: "expected identifier in key path property component", fixIts: ["insert identifier"])
+      ],
+      fixedSource: #"\Foo.Bar.[2].<#identifier#>[1]"#
+    )
+
+    assertParse(
+      #"\Foo.Bar.?.1️⃣[1]"#,
+      diagnostics: [
+        DiagnosticSpec(message: "expected identifier in key path property component", fixIts: ["insert identifier"])
+      ],
+      fixedSource: #"\Foo.Bar.?.<#identifier#>[1]"#
+    )
+  }
+
   func testKeypathExpressionWithSugaredRoot() {
     let cases: [UInt: String] = [
       // Identifiers