Use DeclReferenceExprSyntax in MemberAccessExprSyntax and KeyPathPropertyComponentSyntax

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -851,6 +851,7 @@ public let EXPR_NODES: [Node] = [
           .keyword(text: "init"),
           .token(tokenKind: "DollarIdentifierToken"),
           .token(tokenKind: "BinaryOperatorToken"),
+          .token(tokenKind: "IntegerLiteralToken"),
         ])
       ),
       Child(
@@ -1091,22 +1092,9 @@ public let EXPR_NODES: [Node] = [
     nameForDiagnostics: "key path property component",
     children: [
       Child(
-        name: "Property",
+        name: "DeclName",
         deprecatedName: "Identifier",
-        kind: .token(choices: [
-          .token(tokenKind: "IdentifierToken"),
-          .keyword(text: "self"),
-          .keyword(text: "Self"),
-          .keyword(text: "init"),
-          .token(tokenKind: "DollarIdentifierToken"),
-          .token(tokenKind: "BinaryOperatorToken"),
-          .token(tokenKind: "IntegerLiteralToken"),
-        ])
-      ),
-      Child(
-        name: "DeclNameArguments",
-        kind: .node(kind: .declNameArguments),
-        isOptional: true
+        kind: .node(kind: .declReferenceExpr)
       ),
       Child(
         name: "GenericArgumentClause",
@@ -1213,15 +1201,10 @@ public let EXPR_NODES: [Node] = [
         kind: .token(choices: [.token(tokenKind: "PeriodToken")])
       ),
       Child(
-        name: "Name",
-        kind: .node(kind: .token),
+        name: "DeclName",
+        kind: .node(kind: .declReferenceExpr),
         nameForDiagnostics: "name"
       ),
-      Child(
-        name: "DeclNameArguments",
-        kind: .node(kind: .declNameArguments),
-        isOptional: true
-      ),
     ]
   ),
 

Sources/SwiftParser/Expressions.swift

@@ -595,31 +595,38 @@ extension Parser {
   mutating func parseDottedExpressionSuffix(previousNode: (some RawSyntaxNodeProtocol)?) -> (
     unexpectedPeriod: RawUnexpectedNodesSyntax?,
     period: RawTokenSyntax,
-    name: RawTokenSyntax,
-    declNameArgs: RawDeclNameArgumentsSyntax?,
+    declName: RawDeclReferenceExprSyntax,
     generics: RawGenericArgumentClauseSyntax?
   ) {
     precondition(self.at(.period))
     let (unexpectedPeriod, period, skipMemberName) = self.consumeMemberPeriod(previousNode: previousNode)
     if skipMemberName {
       let missingIdentifier = missingToken(.identifier)
-      return (unexpectedPeriod, period, missingIdentifier, nil, nil)
+      let declName = RawDeclReferenceExprSyntax(
+        baseName: missingIdentifier,
+        argumentNames: nil,
+        arena: self.arena
+      )
+      return (unexpectedPeriod, period, declName, nil)
     }
 
     // Parse the name portion.
-    let name: RawTokenSyntax
-    let declNameArgs: RawDeclNameArgumentsSyntax?
-    if let index = self.consume(if: .integerLiteral) {
+    let declName: RawDeclReferenceExprSyntax
+    if let indexOrSelf = self.consume(if: .integerLiteral, .keyword(.self)) {
       // Handle "x.42" - a tuple index.
-      name = index
-      declNameArgs = nil
-    } else if let selfKeyword = self.consume(if: .keyword(.self)) {
-      // Handle "x.self" expr.
-      name = selfKeyword
-      declNameArgs = nil
+      declName = RawDeclReferenceExprSyntax(
+        baseName: indexOrSelf,
+        argumentNames: nil,
+        arena: self.arena
+      )
     } else {
       // Handle an arbitrary declaration name.
-      (name, declNameArgs) = self.parseDeclNameRef([.keywords, .compoundNames])
+      let (name, declNameArgs) = self.parseDeclNameRef([.keywords, .compoundNames])
+      declName = RawDeclReferenceExprSyntax(
+        baseName: name,
+        argumentNames: declNameArgs,
+        arena: self.arena
+      )
     }
 
     // Parse the generic arguments, if any.
@@ -630,18 +637,17 @@ extension Parser {
       generics = nil
     }
 
-    return (unexpectedPeriod, period, name, declNameArgs, generics)
+    return (unexpectedPeriod, period, declName, generics)
   }
 
   mutating func parseDottedExpressionSuffix(_ start: RawExprSyntax?) -> RawExprSyntax {
-    let (unexpectedPeriod, period, name, declNameArgs, generics) = parseDottedExpressionSuffix(previousNode: start)
+    let (unexpectedPeriod, period, declName, generics) = parseDottedExpressionSuffix(previousNode: start)
 
     let memberAccess = RawMemberAccessExprSyntax(
       base: start,
       unexpectedPeriod,
       period: period,
-      name: name,
-      declNameArguments: declNameArgs,
+      declName: declName,
       arena: self.arena
     )
 
@@ -1036,7 +1042,7 @@ extension Parser {
 
       // Check for a .name or .1 suffix.
       if self.at(.period) {
-        let (unexpectedPeriod, period, name, declNameArgs, generics) = parseDottedExpressionSuffix(
+        let (unexpectedPeriod, period, declName, generics) = parseDottedExpressionSuffix(
           previousNode: components.last?.raw ?? rootType?.raw ?? backslash.raw
         )
         components.append(
@@ -1045,8 +1051,7 @@ extension Parser {
             period: period,
             component: .property(
               RawKeyPathPropertyComponentSyntax(
-                property: name,
-                declNameArguments: declNameArgs,
+                declName: declName,
                 genericArgumentClause: generics,
                 arena: self.arena
               )
@@ -1203,12 +1208,16 @@ extension Parser {
       }
 
       let (name, args) = self.parseDeclNameRef([.keywords, .compoundNames])
+      let declName = RawDeclReferenceExprSyntax(
+        baseName: name,
+        argumentNames: args,
+        arena: self.arena
+      )
       return RawExprSyntax(
         RawMemberAccessExprSyntax(
           base: nil,
           period: period,
-          name: name,
-          declNameArguments: args,
+          declName: declName,
           arena: self.arena
         )
       )

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -660,6 +660,7 @@ extension DeclReferenceExprSyntax {
     case `init`
     case dollarIdentifier
     case binaryOperator
+    case integerLiteral
 
     init?(lexeme: Lexer.Lexeme) {
       switch PrepareForKeywordMatch(lexeme) {
@@ -675,6 +676,8 @@ extension DeclReferenceExprSyntax {
         self = .dollarIdentifier
       case TokenSpec(.binaryOperator):
         self = .binaryOperator
+      case TokenSpec(.integerLiteral):
+        self = .integerLiteral
       default:
         return nil
       }
@@ -694,6 +697,8 @@ extension DeclReferenceExprSyntax {
         return .dollarIdentifier
       case .binaryOperator:
         return .binaryOperator
+      case .integerLiteral:
+        return .integerLiteral
       }
     }
   }
@@ -1307,58 +1312,6 @@ extension KeyPathOptionalComponentSyntax {
   }
 }
 
-extension KeyPathPropertyComponentSyntax {
-  enum PropertyOptions: TokenSpecSet {
-    case identifier
-    case `self`
-    case `Self`
-    case `init`
-    case dollarIdentifier
-    case binaryOperator
-    case integerLiteral
-    
-    init?(lexeme: Lexer.Lexeme) {
-      switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(.identifier):
-        self = .identifier
-      case TokenSpec(.`self`):
-        self = .`self`
-      case TokenSpec(.`Self`):
-        self = .`Self`
-      case TokenSpec(.`init`):
-        self = .`init`
-      case TokenSpec(.dollarIdentifier):
-        self = .dollarIdentifier
-      case TokenSpec(.binaryOperator):
-        self = .binaryOperator
-      case TokenSpec(.integerLiteral):
-        self = .integerLiteral
-      default:
-        return nil
-      }
-    }
-    
-    var spec: TokenSpec {
-      switch self {
-      case .identifier:
-        return .identifier
-      case .`self`:
-        return .keyword(.`self`)
-      case .`Self`:
-        return .keyword(.`Self`)
-      case .`init`:
-        return .keyword(.`init`)
-      case .dollarIdentifier:
-        return .dollarIdentifier
-      case .binaryOperator:
-        return .binaryOperator
-      case .integerLiteral:
-        return .integerLiteral
-      }
-    }
-  }
-}
-
 extension LabeledExprSyntax {
   enum LabelOptions: TokenSpecSet {
     case identifier

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -236,7 +236,7 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "modifiers"
   case \MemberAccessExprSyntax.base:
     return "base"
-  case \MemberAccessExprSyntax.name:
+  case \MemberAccessExprSyntax.declName:
     return "name"
   case \MemberTypeSyntax.baseType:
     return "base type"

Sources/SwiftSyntax/CMakeLists.txt

@@ -11,6 +11,7 @@ add_swift_host_library(SwiftSyntax
   Assert.swift
   BumpPtrAllocator.swift
   CommonAncestor.swift
+  Convenience.swift
   MemoryLayout.swift
   MissingNodeInitializers.swift
   Trivia.swift

Sources/SwiftSyntax/Convenience.swift

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+extension MemberAccessExprSyntax {
+  /// Creates a new ``MemberAccessExprSyntax`` where the accessed member is represented by
+  /// an identifier without specifying argument labels.
+  ///
+  /// A member access can specify function argument labels, which is required
+  /// when the name would be ambiguous otherwise. For example, given multiple overloads
+  /// ```swift
+  /// struct Person {
+  ///   func consume(drink: Drink) {}
+  ///   func consume(food: Food) {}
+  /// }
+  /// ```
+  ///
+  /// `consume(drink:)` is required to explicitly reference the consume function
+  /// that takes a drink.
+  ///
+  /// Given how common it is to not need the argument names, this initializer is
+  /// provided as a convenience to avoid having to create a ``DeclReferenceExpr``
+  /// for the member name.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    base: (some ExprSyntaxProtocol)? = ExprSyntax?.none,
+    period: TokenSyntax = .periodToken(),
+    name: TokenSyntax,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      base: base,
+      period: period,
+      declName: DeclReferenceExprSyntax(baseName: name),
+      trailingTrivia: trailingTrivia
+    )
+  }
+}

Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift

@@ -77,6 +77,51 @@ extension IdentifiedDeclSyntax where Self: NamedDeclSyntax {
   }
 }
 
+extension MemberAccessExprSyntax {
+  @available(*, deprecated, renamed: "declName.baseName")
+  public var name: TokenSyntax {
+    return declName.baseName
+  }
+
+  @available(*, deprecated, renamed: "declName.argumentNames")
+  public var declNameArguments: DeclNameArgumentsSyntax? {
+    return declName.argumentNames
+  }
+
+  @available(*, deprecated, message: "Use initializer taking `DeclReferenceExprSyntax` instead")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil,
+    base: (some ExprSyntaxProtocol)? = ExprSyntax?.none,
+    _ unexpectedBetweenBaseAndPeriod: UnexpectedNodesSyntax? = nil,
+    dot: TokenSyntax = .periodToken(),
+    _ unexpectedBetweenPeriodAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    _ unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil,
+    declNameArguments: DeclNameArgumentsSyntax? = nil,
+    _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    let declName = DeclReferenceExprSyntax(
+      baseName: name,
+      unexpectedBetweenNameAndDeclNameArguments,
+      argumentNames: declNameArguments
+    )
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeBase,
+      base: base,
+      unexpectedBetweenBaseAndPeriod,
+      period: dot,
+      unexpectedBetweenPeriodAndName,
+      declName: declName,
+      unexpectedAfterDeclNameArguments,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
 public extension SyntaxProtocol {
   @available(*, deprecated, message: "Use detached computed property instead.")
   func detach() -> Self {