Disallow the self/Self keyword where it’s not allowed in types

We weren’t matching the C++ parser’s behavior here. The `self` keyword is not allowed as a type name. `Self` in a nested type refers to a type named `Self` instead of the `Self` keyword.

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -301,7 +301,7 @@ public let TYPE_NODES: [Node] = [
       ),
       Child(
         name: "Name",
-        kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .keyword(text: "self"), .keyword(text: "Self")]),
+        kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .keyword(text: "self")]),
         nameForDiagnostics: "name"
       ),
       Child(
@@ -436,7 +436,6 @@ public let TYPE_NODES: [Node] = [
         name: "Name",
         kind: .token(choices: [
           .token(tokenKind: "IdentifierToken"),
-          .keyword(text: "self"),
           .keyword(text: "Self"),
           .keyword(text: "Any"),
           .token(tokenKind: "WildcardToken"),

Sources/SwiftParser/Names.swift

@@ -150,7 +150,7 @@ extension Parser {
     let period: RawTokenSyntax?
     if self.lookahead().canParseBaseTypeForQualifiedDeclName() {
       type = self.parseQualifiedTypeIdentifier()
-      period = self.consumePrefix(".", as: .period)
+      period = self.expectWithoutRecovery(prefix: ".", as: .period)
     } else {
       type = nil
       period = nil
@@ -174,52 +174,70 @@ extension Parser {
       return RawTypeSyntax(self.parseAnyType())
     }
 
-    var result: RawTypeSyntax?
-    var keepGoing: RawTokenSyntax? = nil
+    let (unexpectedBeforeName, name) = self.expect(anyIn: IdentifierTypeSyntax.NameOptions.self, default: .identifier)
+    let generics: RawGenericArgumentClauseSyntax?
+    if self.atContextualPunctuator("<") {
+      generics = self.parseGenericArguments()
+    } else {
+      generics = nil
+    }
+
+    var result = RawTypeSyntax(
+      RawIdentifierTypeSyntax(
+        unexpectedBeforeName,
+        name: name,
+        genericArgumentClause: generics,
+        arena: self.arena
+      )
+    )
+
+    // If qualified name base type cannot be parsed from the current
+    // point (i.e. the next type identifier is not followed by a '.'),
+    // then the next identifier is the final declaration name component.
+    var backtrack = self.lookahead()
+    guard
+      backtrack.consume(ifPrefix: ".", as: .period) != nil,
+      backtrack.canParseBaseTypeForQualifiedDeclName()
+    else {
+      return result
+    }
+
+    var keepGoing = self.consume(if: .period)
     var loopProgress = LoopProgressCondition()
-    repeat {
-      let (unexpectedBeforeName, name) = self.expect(.identifier, .keyword(.self), .keyword(.Self), default: .identifier)
+    while keepGoing != nil && self.hasProgressed(&loopProgress) {
+      let (unexpectedBeforeName, name) = self.expect(.identifier, .keyword(.self), TokenSpec(.Self, remapping: .identifier), default: .identifier)
       let generics: RawGenericArgumentClauseSyntax?
       if self.atContextualPunctuator("<") {
         generics = self.parseGenericArguments()
       } else {
         generics = nil
       }
-      if let keepGoing {
-        result = RawTypeSyntax(
-          RawMemberTypeSyntax(
-            baseType: result!,
-            period: keepGoing,
-            unexpectedBeforeName,
-            name: name,
-            genericArgumentClause: generics,
-            arena: self.arena
-          )
-        )
-      } else {
-        result = RawTypeSyntax(
-          RawIdentifierTypeSyntax(
-            unexpectedBeforeName,
-            name: name,
-            genericArgumentClause: generics,
-            arena: self.arena
-          )
+      result = RawTypeSyntax(
+        RawMemberTypeSyntax(
+          baseType: result,
+          period: keepGoing!,
+          unexpectedBeforeName,
+          name: name,
+          genericArgumentClause: generics,
+          arena: self.arena
         )
-      }
+      )
 
       // If qualified name base type cannot be parsed from the current
       // point (i.e. the next type identifier is not followed by a '.'),
       // then the next identifier is the final declaration name component.
       var backtrack = self.lookahead()
-      backtrack.consumePrefix(".", as: .period)
-      guard backtrack.canParseBaseTypeForQualifiedDeclName() else {
+      guard
+        backtrack.consume(ifPrefix: ".", as: .period) != nil,
+        backtrack.canParseBaseTypeForQualifiedDeclName()
+      else {
         break
       }
 
       keepGoing = self.consume(if: .period)
-    } while keepGoing != nil && self.hasProgressed(&loopProgress)
+    }
 
-    return result!
+    return result
   }
 }
 

Sources/SwiftParser/Parameters.swift

@@ -97,7 +97,11 @@ extension Parser {
 
     let type: RawTypeSyntax
 
-    if colon.presence == .missing, let secondName = names.secondName, secondName.tokenText.isStartingWithUppercase {
+    if colon.presence == .missing,
+      let secondName = names.secondName,
+      secondName.tokenKind == .identifier,
+      secondName.tokenText.isStartingWithUppercase
+    {
       // Synthesize the secondName parameter as a type node.
       type = RawTypeSyntax(
         RawIdentifierTypeSyntax(

Sources/SwiftParser/Parser.swift

@@ -502,6 +502,7 @@ extension Parser {
   ///     currently positioned at a keyword, consume that keyword and remap it
   ///     to and identifier.
   /// - Returns: The consumed token and any unexpected tokens that were skipped.
+  ///   The token is always guaranteed to be of `TokenKind.identifier`
   mutating func expectIdentifier(
     keywordRecovery: Bool = false,
     allowSelfOrCapitalSelfAsIdentifier: Bool = false,

Sources/SwiftParser/Types.swift

@@ -270,7 +270,20 @@ extension Parser {
             )
           )
         } else {
-          let (name, generics) = self.parseTypeNameWithGenerics(allowKeywordAsName: true)
+          let name: RawTokenSyntax
+          if let handle = self.at(anyIn: MemberTypeSyntax.NameOptions.self)?.handle {
+            name = self.eat(handle)
+          } else if self.currentToken.isLexerClassifiedKeyword {
+            name = self.consumeAnyToken(remapping: .identifier)
+          } else {
+            name = missingToken(.identifier)
+          }
+          let generics: RawGenericArgumentClauseSyntax?
+          if self.atContextualPunctuator("<") {
+            generics = self.parseGenericArguments()
+          } else {
+            generics = nil
+          }
           base = RawTypeSyntax(
             RawMemberTypeSyntax(
               baseType: base,
@@ -322,30 +335,23 @@ extension Parser {
     )
   }
 
-  mutating func parseTypeNameWithGenerics(allowKeywordAsName: Bool) -> (RawTokenSyntax, RawGenericArgumentClauseSyntax?) {
-    let name: RawTokenSyntax
-    if let identOrSelf = self.consume(if: .identifier, .keyword(.self), .keyword(.Self)) {
-      name = identOrSelf
-    } else if allowKeywordAsName && self.currentToken.isLexerClassifiedKeyword {
-      name = self.consumeAnyToken(remapping: .identifier)
-    } else {
-      name = missingToken(.identifier)
-    }
-    if self.atContextualPunctuator("<") {
-      return (name, self.parseGenericArguments())
-    }
-    return (name, nil)
-  }
-
   /// Parse a type identifier.
   mutating func parseTypeIdentifier() -> RawTypeSyntax {
     if self.at(.keyword(.Any)) {
       return RawTypeSyntax(self.parseAnyType())
     }
 
-    let (name, generics) = parseTypeNameWithGenerics(allowKeywordAsName: false)
+    let (unexpectedBeforeName, name) = self.expect(anyIn: IdentifierTypeSyntax.NameOptions.self, default: .identifier)
+    let generics: RawGenericArgumentClauseSyntax?
+    if self.atContextualPunctuator("<") {
+      generics = self.parseGenericArguments()
+    } else {
+      generics = nil
+    }
+
     return RawTypeSyntax(
       RawIdentifierTypeSyntax(
+        unexpectedBeforeName,
         name: name,
         genericArgumentClause: generics,
         arena: self.arena
@@ -479,6 +485,7 @@ extension Parser {
         if let first,
           second == nil,
           colon?.isMissing == true,
+          first.tokenKind == .identifier,
           first.tokenText.isStartingWithUppercase
         {
           elements.append(

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -1083,7 +1083,6 @@ extension IdentifierPatternSyntax {
 extension IdentifierTypeSyntax {
   enum NameOptions: TokenSpecSet {
     case identifier
-    case `self`
     case `Self`
     case `Any`
     case wildcard
@@ -1092,8 +1091,6 @@ extension IdentifierTypeSyntax {
       switch PrepareForKeywordMatch(lexeme) {
       case TokenSpec(.identifier):
         self = .identifier
-      case TokenSpec(.`self`):
-        self = .`self`
       case TokenSpec(.`Self`):
         self = .`Self`
       case TokenSpec(.`Any`):
@@ -1109,8 +1106,6 @@ extension IdentifierTypeSyntax {
       switch self {
       case .identifier:
         return .identifier
-      case .`self`:
-        return .keyword(.`self`)
       case .`Self`:
         return .keyword(.`Self`)
       case .`Any`:
@@ -1395,16 +1390,13 @@ extension MemberTypeSyntax {
   enum NameOptions: TokenSpecSet {
     case identifier
     case `self`
-    case `Self`
 
     init?(lexeme: Lexer.Lexeme) {
       switch PrepareForKeywordMatch(lexeme) {
       case TokenSpec(.identifier):
         self = .identifier
       case TokenSpec(.`self`):
         self = .`self`
-      case TokenSpec(.`Self`):
-        self = .`Self`
       default:
         return nil
       }
@@ -1416,8 +1408,6 @@ extension MemberTypeSyntax {
         return .identifier
       case .`self`:
         return .keyword(.`self`)
-      case .`Self`:
-        return .keyword(.`Self`)
       }
     }
   }

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -1406,7 +1406,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [
             .tokenKind(.identifier), 
-            .keyword("self"), 
             .keyword("Self"), 
             .keyword("Any"), 
             .tokenKind(.wildcard)
@@ -1797,7 +1796,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.period)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier), .keyword("self"), .keyword("Self")]))
+    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier), .keyword("self")]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 7, verify(layout[7], as: RawGenericArgumentClauseSyntax?.self))
     assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift

@@ -958,7 +958,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
 
 /// ### Children
 /// 
-///  - `name`: (`<identifier>` | `'self'` | `'Self'` | `'Any'` | `'_'`)
+///  - `name`: (`<identifier>` | `'Self'` | `'Any'` | `'_'`)
 ///  - `genericArgumentClause`: ``GenericArgumentClauseSyntax``?
 public struct IdentifierTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
@@ -1204,7 +1204,7 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH
 /// 
 ///  - `baseType`: ``TypeSyntax``
 ///  - `period`: `'.'`
-///  - `name`: (`<identifier>` | `'self'` | `'Self'`)
+///  - `name`: (`<identifier>` | `'self'`)
 ///  - `genericArgumentClause`: ``GenericArgumentClauseSyntax``?
 public struct MemberTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax

Tests/SwiftParserTest/AttributeTests.swift

@@ -208,6 +208,24 @@ final class AttributeTests: XCTestCase {
       ) {}
       """
     )
+
+    assertParse(
+      """
+      @derivitave(of: 1️⃣Self.other)
+      func foo() {}
+      """,
+      substructure: Syntax(TokenSyntax.keyword(.Self)),
+      substructureAfterMarker: "1️⃣"
+    )
+
+    assertParse(
+      """
+      @derivative(of: Foo.1️⃣Self.other)
+      func foo() {}
+      """,
+      substructure: Syntax(TokenSyntax.identifier("Self")),
+      substructureAfterMarker: "1️⃣"
+    )
   }
 
   func testTransposeAttribute() {

Tests/SwiftParserTest/TypeTests.swift

@@ -192,4 +192,42 @@ final class TypeTests: XCTestCase {
       """
     )
   }
+
+  func testLowercaseSelf() {
+    assertParse(
+      "1️⃣self2️⃣",
+      { TypeSyntax.parse(from: &$0) },
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected 'self' keyword before type"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "expected type", fixIts: ["insert type"]),
+      ],
+      fixedSource: "<#type#>self"
+    )
+  }
+
+  func testUppercaseSelf() {
+    assertParse(
+      "Self",
+      { TypeSyntax.parse(from: &$0) },
+      substructure: Syntax(TokenSyntax.keyword(.Self))
+    )
+  }
+
+  func testNestedLowercaseSelf() {
+    assertParse(
+      "Foo.1️⃣self",
+      { TypeSyntax.parse(from: &$0) },
+      substructure: Syntax(TokenSyntax.keyword(.`self`)),
+      substructureAfterMarker: "1️⃣"
+    )
+  }
+
+  func testNestedUppercaseSelf() {
+    assertParse(
+      "Foo.1️⃣Self",
+      { TypeSyntax.parse(from: &$0) },
+      substructure: Syntax(TokenSyntax.identifier("Self")),
+      substructureAfterMarker: "1️⃣"
+    )
+  }
 }