Rename IdentifierExpr to DeclReferenceExpr

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift

@@ -562,7 +562,7 @@ public let ATTRIBUTE_NODES: [Node] = [
       Child(
         name: "DeclName",
         deprecatedName: "Declname",
-        kind: .node(kind: .identifierExpr)
+        kind: .node(kind: .declReferenceExpr)
       ),
     ]
   ),
@@ -621,7 +621,7 @@ public let ATTRIBUTE_NODES: [Node] = [
       Child(
         name: "DeclName",
         deprecatedName: "Declname",
-        kind: .node(kind: .identifierExpr),
+        kind: .node(kind: .declReferenceExpr),
         nameForDiagnostics: "declaration name",
         documentation: "The value for this argument"
       ),
@@ -837,7 +837,7 @@ public let ATTRIBUTE_NODES: [Node] = [
       Child(
         name: "DeclName",
         deprecatedName: "Declname",
-        kind: .node(kind: .identifierExpr),
+        kind: .node(kind: .declReferenceExpr),
         nameForDiagnostics: "declaration name",
         documentation: "The value for this argument"
       ),

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -837,12 +837,13 @@ public let EXPR_NODES: [Node] = [
 
   // An identifier expression.
   Node(
-    kind: .identifierExpr,
+    kind: .declReferenceExpr,
     base: .expr,
     nameForDiagnostics: nil,
     children: [
       Child(
-        name: "Identifier",
+        name: "BaseName",
+        deprecatedName: "Identifier",
         kind: .token(choices: [
           .token(tokenKind: "IdentifierToken"),
           .keyword(text: "self"),
@@ -853,7 +854,8 @@ public let EXPR_NODES: [Node] = [
         ])
       ),
       Child(
-        name: "DeclNameArguments",
+        name: "ArgumentNames",
+        deprecatedName: "DeclNameArguments",
         kind: .node(kind: .declNameArguments),
         isOptional: true
       ),

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -87,6 +87,7 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case declNameArgument
   case declNameArgumentList
   case declNameArguments
+  case declReferenceExpr
   case deferStmt
   case deinitializerDecl
   case deinitializerEffectSpecifiers
@@ -148,7 +149,6 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case genericSpecializationExpr
   case genericWhereClause
   case guardStmt
-  case identifierExpr
   case identifierPattern
   case identifierType
   case ifConfigClause
@@ -383,6 +383,7 @@ public enum SyntaxNodeKind: String, CaseIterable {
     case .closureShorthandParameterList: return "closureParamList"
     case .consumeExpr: return "moveExpr"
     case .declModifierList: return "modifierList"
+    case .declReferenceExpr: return "identifierExpr"
     case .deinitializerEffectSpecifiers: return "deinitEffectSpecifiers"
     case .derivativeAttributeArguments: return "derivativeRegistrationAttributeArguments"
     case .designatedType: return "designatedTypeElement"

CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift

@@ -131,7 +131,7 @@ public extension Child {
       preconditionChoices.append(
         ExprSyntax(
           SequenceExprSyntax {
-            IdentifierExprSyntax(identifier: .identifier(varName))
+            DeclReferenceExprSyntax(baseName: .identifier(varName))
             BinaryOperatorExprSyntax(text: "==")
             NilLiteralExprSyntax()
           }
@@ -142,7 +142,7 @@ public extension Child {
       preconditionChoices.append(
         ExprSyntax(
           SequenceExprSyntax {
-            MemberAccessExprSyntax(base: type.forceUnwrappedIfNeeded(expr: IdentifierExprSyntax(identifier: .identifier(varName))), name: "text")
+            MemberAccessExprSyntax(base: type.forceUnwrappedIfNeeded(expr: DeclReferenceExprSyntax(baseName: .identifier(varName))), name: "text")
             BinaryOperatorExprSyntax(text: "==")
             StringLiteralExprSyntax(content: textChoice)
           }

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RenamedChildrenCompatibilityFile.swift

@@ -76,7 +76,7 @@ let renamedChildrenCompatibilityFile = try! SourceFileSyntax(leadingTrivia: copy
               LabeledExprSyntax(
                 label: child.varOrCaseName,
                 colon: .colonToken(),
-                expression: IdentifierExprSyntax(identifier: child.deprecatedVarName ?? child.varOrCaseName)
+                expression: DeclReferenceExprSyntax(baseName: child.deprecatedVarName ?? child.varOrCaseName)
               )
             }
           }

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -462,7 +462,12 @@ class ValidateSyntaxNodes: XCTestCase {
         ValidationFailure(
           node: .qualifiedDeclName,
           message:
-            "child 'Arguments' is named inconsistently with 'IdentifierExprSyntax.DeclNameArguments', which has the same type ('DeclNameArgumentsSyntax')"
+            "child 'Arguments' is named inconsistently with 'KeyPathPropertyComponentSyntax.DeclNameArguments', which has the same type ('DeclNameArgumentsSyntax')"
+        ),
+        ValidationFailure(
+          node: .declReferenceExpr,
+          message:
+            "child 'ArgumentNames' is named inconsistently with 'KeyPathPropertyComponentSyntax.DeclNameArguments', which has the same type ('DeclNameArgumentsSyntax')"
         ),
         // MARK: Alternate names for InitializerClauseSyntax
         // The cases below don’t have intializers but just a syntactic element that happens to be spelled the same
@@ -628,8 +633,7 @@ class ValidateSyntaxNodes: XCTestCase {
       failures,
       expectedFailures: [
         // The identifier expr / pattern nodes do actually have a child that’s the identifier
-        ValidationFailure(node: .identifierExpr, message: "child 'Identifier' should generally not contain 'Identifier'"),
-        ValidationFailure(node: .identifierPattern, message: "child 'Identifier' should generally not contain 'Identifier'"),
+        ValidationFailure(node: .identifierPattern, message: "child 'Identifier' should generally not contain 'Identifier'")
       ]
     )
   }

Sources/SwiftParser/Attributes.swift

@@ -353,10 +353,10 @@ extension Parser {
       label: nil,
       colon: nil,
       expression: RawExprSyntax(
-        RawIdentifierExprSyntax(
+        RawDeclReferenceExprSyntax(
           unexpectedBeforeRole,
-          identifier: role,
-          declNameArguments: nil,
+          baseName: role,
+          argumentNames: nil,
           arena: self.arena
         )
       ),
@@ -682,9 +682,9 @@ extension Parser {
         let ident = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let (targetFunction, args) = self.parseDeclNameRef([.zeroArgCompoundNames, .keywordsUsingSpecialNames, .operators])
-        let declName = RawIdentifierExprSyntax(
-          identifier: targetFunction,
-          declNameArguments: args,
+        let declName = RawDeclReferenceExprSyntax(
+          baseName: targetFunction,
+          argumentNames: args,
           arena: self.arena
         )
         let comma = self.consume(if: .comma)
@@ -827,9 +827,9 @@ extension Parser {
       .zeroArgCompoundNames,
       .operators,
     ])
-    let declName = RawIdentifierExprSyntax(
-      identifier: name,
-      declNameArguments: args,
+    let declName = RawDeclReferenceExprSyntax(
+      baseName: name,
+      argumentNames: args,
       arena: self.arena
     )
     return RawImplementsAttributeArgumentsSyntax(
@@ -1025,17 +1025,21 @@ extension Parser {
   mutating func parseDynamicReplacementAttributeArguments() -> RawDynamicReplacementAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.for))
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
-    let base: RawTokenSyntax
-    let args: RawDeclNameArgumentsSyntax?
+    let baseName: RawTokenSyntax
+    let argumentNames: RawDeclNameArgumentsSyntax?
     if label.isMissing && colon.isMissing && self.atStartOfLine {
-      base = RawTokenSyntax(missing: .identifier, arena: self.arena)
-      args = nil
+      baseName = RawTokenSyntax(missing: .identifier, arena: self.arena)
+      argumentNames = nil
     } else {
-      (base, args) = self.parseDeclNameRef([
+      (baseName, argumentNames) = self.parseDeclNameRef([
         .zeroArgCompoundNames, .keywordsUsingSpecialNames, .operators,
       ])
     }
-    let method = RawIdentifierExprSyntax(identifier: base, declNameArguments: args, arena: self.arena)
+    let method = RawDeclReferenceExprSyntax(
+      baseName: baseName,
+      argumentNames: argumentNames,
+      arena: self.arena
+    )
     return RawDynamicReplacementAttributeArgumentsSyntax(
       unexpectedBeforeLabel,
       forLabel: label,

Sources/SwiftParser/Expressions.swift

@@ -1166,10 +1166,10 @@ extension Parser {
     case (.poundAvailable, _)?, (.poundUnavailable, _)?:
       let poundAvailable = self.parsePoundAvailableConditionElement()
       return RawExprSyntax(
-        RawIdentifierExprSyntax(
+        RawDeclReferenceExprSyntax(
           RawUnexpectedNodesSyntax([poundAvailable], arena: self.arena),
-          identifier: missingToken(.identifier),
-          declNameArguments: nil,
+          baseName: missingToken(.identifier),
+          argumentNames: nil,
           arena: self.arena
         )
       )
@@ -1247,28 +1247,28 @@ extension Parser {
 extension Parser {
   /// Parse an identifier as an expression.
   mutating func parseIdentifierExpression() -> RawExprSyntax {
-    let (name, args) = self.parseDeclNameRef(.compoundNames)
+    let (baseName, argumentNames) = self.parseDeclNameRef(.compoundNames)
     guard self.withLookahead({ $0.canParseAsGenericArgumentList() }) else {
-      if name.tokenText.isEditorPlaceholder && args == nil {
+      if baseName.tokenText.isEditorPlaceholder && argumentNames == nil {
         return RawExprSyntax(
           RawEditorPlaceholderExprSyntax(
-            placeholder: name,
+            placeholder: baseName,
             arena: self.arena
           )
         )
       }
       return RawExprSyntax(
-        RawIdentifierExprSyntax(
-          identifier: name,
-          declNameArguments: args,
+        RawDeclReferenceExprSyntax(
+          baseName: baseName,
+          argumentNames: argumentNames,
           arena: self.arena
         )
       )
     }
 
-    let identifier = RawIdentifierExprSyntax(
-      identifier: name,
-      declNameArguments: args,
+    let identifier = RawDeclReferenceExprSyntax(
+      baseName: baseName,
+      argumentNames: argumentNames,
       arena: self.arena
     )
     let generics = self.parseGenericArguments()
@@ -1634,12 +1634,12 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseAnonymousClosureArgument() -> RawIdentifierExprSyntax {
-    let (unexpectedBeforeIdent, ident) = self.expect(.dollarIdentifier)
-    return RawIdentifierExprSyntax(
-      unexpectedBeforeIdent,
-      identifier: ident,
-      declNameArguments: nil,
+  mutating func parseAnonymousClosureArgument() -> RawDeclReferenceExprSyntax {
+    let (unexpectedBeforeBaseName, baseName) = self.expect(.dollarIdentifier)
+    return RawDeclReferenceExprSyntax(
+      unexpectedBeforeBaseName,
+      baseName: baseName,
+      argumentNames: nil,
       arena: self.arena
     )
   }
@@ -1898,11 +1898,11 @@ extension Parser {
       // follows a proper subexpression.
       let expr: RawExprSyntax
       if self.at(.binaryOperator) && self.peek(isAt: .comma, .rightParen, .rightSquare) {
-        let (ident, args) = self.parseDeclNameRef(.operators)
+        let (baseName, argumentNames) = self.parseDeclNameRef(.operators)
         expr = RawExprSyntax(
-          RawIdentifierExprSyntax(
-            identifier: ident,
-            declNameArguments: args,
+          RawDeclReferenceExprSyntax(
+            baseName: baseName,
+            argumentNames: argumentNames,
             arena: self.arena
           )
         )

Sources/SwiftParser/Names.swift

@@ -63,7 +63,7 @@ extension Parser {
     static let zeroArgCompoundNames: Self = [.compoundNames, Self(rawValue: 1 << 5)]
   }
 
-  mutating func parseDeclNameRef(_ flags: DeclNameOptions = []) -> (RawTokenSyntax, RawDeclNameArgumentsSyntax?) {
+  mutating func parseDeclNameRef(_ flags: DeclNameOptions = []) -> (baseName: RawTokenSyntax, argumentNames: RawDeclNameArgumentsSyntax?) {
     // Consume the base name.
     let base: RawTokenSyntax
     if let identOrSelf = self.consume(if: .identifier, .keyword(.self), .keyword(.Self)) ?? self.consume(if: .keyword(.`init`)) {

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -652,6 +652,53 @@ extension DeclModifierSyntax {
   }
 }
 
+extension DeclReferenceExprSyntax {
+  enum BaseNameOptions: TokenSpecSet {
+    case identifier
+    case `self`
+    case `Self`
+    case `init`
+    case dollarIdentifier
+    case binaryOperator
+    
+    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
+      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
+      }
+    }
+  }
+}
+
 extension DerivativeAttributeArgumentsSyntax {
   enum AccessorSpecifierOptions: TokenSpecSet {
     case get
@@ -996,53 +1043,6 @@ extension FunctionParameterSyntax {
   }
 }
 
-extension IdentifierExprSyntax {
-  enum IdentifierOptions: TokenSpecSet {
-    case identifier
-    case `self`
-    case `Self`
-    case `init`
-    case dollarIdentifier
-    case binaryOperator
-    
-    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
-      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
-      }
-    }
-  }
-}
-
 extension IdentifierPatternSyntax {
   enum IdentifierOptions: TokenSpecSet {
     case identifier