Make parseDeclNameRef return a RawDeclReferenceExprSyntax

Author: ahoppen

Sources/SwiftParser/Attributes.swift

@@ -681,12 +681,7 @@ extension Parser {
       case (.target, let handle)?:
         let ident = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
-        let (targetFunction, args) = self.parseDeclNameRef([.zeroArgCompoundNames, .keywordsUsingSpecialNames, .operators])
-        let declName = RawDeclReferenceExprSyntax(
-          baseName: targetFunction,
-          argumentNames: args,
-          arena: self.arena
-        )
+        let declName = self.parseDeclReferenceExpr([.zeroArgCompoundNames, .keywordsUsingSpecialNames, .operators])
         let comma = self.consume(if: .comma)
         elements.append(
           .specializeTargetFunctionArgument(
@@ -823,15 +818,10 @@ extension Parser {
   mutating func parseImplementsAttributeArguments() -> RawImplementsAttributeArgumentsSyntax {
     let type = self.parseType()
     let (unexpectedBeforeComma, comma) = self.expect(.comma)
-    let (name, args) = self.parseDeclNameRef([
+    let declName = self.parseDeclReferenceExpr([
       .zeroArgCompoundNames,
       .operators,
     ])
-    let declName = RawDeclReferenceExprSyntax(
-      baseName: name,
-      argumentNames: args,
-      arena: self.arena
-    )
     return RawImplementsAttributeArgumentsSyntax(
       type: type,
       unexpectedBeforeComma,
@@ -1025,27 +1015,24 @@ extension Parser {
   mutating func parseDynamicReplacementAttributeArguments() -> RawDynamicReplacementAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.for))
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
-    let baseName: RawTokenSyntax
-    let argumentNames: RawDeclNameArgumentsSyntax?
+    let declName: RawDeclReferenceExprSyntax
     if label.isMissing && colon.isMissing && self.atStartOfLine {
-      baseName = RawTokenSyntax(missing: .identifier, arena: self.arena)
-      argumentNames = nil
+      declName = RawDeclReferenceExprSyntax(
+        baseName: RawTokenSyntax(missing: .identifier, arena: self.arena),
+        argumentNames: nil,
+        arena: self.arena
+      )
     } else {
-      (baseName, argumentNames) = self.parseDeclNameRef([
+      declName = self.parseDeclReferenceExpr([
         .zeroArgCompoundNames, .keywordsUsingSpecialNames, .operators,
       ])
     }
-    let method = RawDeclReferenceExprSyntax(
-      baseName: baseName,
-      argumentNames: argumentNames,
-      arena: self.arena
-    )
     return RawDynamicReplacementAttributeArgumentsSyntax(
       unexpectedBeforeLabel,
       forLabel: label,
       unexpectedBeforeColon,
       colon: colon,
-      declName: method,
+      declName: declName,
       arena: self.arena
     )
   }

Sources/SwiftParser/Expressions.swift

@@ -621,12 +621,7 @@ extension Parser {
       )
     } else {
       // Handle an arbitrary declaration name.
-      let (name, declNameArgs) = self.parseDeclNameRef([.keywords, .compoundNames])
-      declName = RawDeclReferenceExprSyntax(
-        baseName: name,
-        argumentNames: declNameArgs,
-        arena: self.arena
-      )
+      declName = self.parseDeclReferenceExpr([.keywords, .compoundNames])
     }
 
     // Parse the generic arguments, if any.
@@ -1207,12 +1202,7 @@ extension Parser {
         )
       }
 
-      let (name, args) = self.parseDeclNameRef([.keywords, .compoundNames])
-      let declName = RawDeclReferenceExprSyntax(
-        baseName: name,
-        argumentNames: args,
-        arena: self.arena
-      )
+      let declName = self.parseDeclReferenceExpr([.keywords, .compoundNames])
       return RawExprSyntax(
         RawMemberAccessExprSyntax(
           base: nil,
@@ -1256,34 +1246,23 @@ extension Parser {
 extension Parser {
   /// Parse an identifier as an expression.
   mutating func parseIdentifierExpression() -> RawExprSyntax {
-    let (baseName, argumentNames) = self.parseDeclNameRef(.compoundNames)
+    let declName = self.parseDeclReferenceExpr(.compoundNames)
     guard self.withLookahead({ $0.canParseAsGenericArgumentList() }) else {
-      if baseName.tokenText.isEditorPlaceholder && argumentNames == nil {
+      if declName.baseName.tokenText.isEditorPlaceholder && declName.argumentNames == nil {
         return RawExprSyntax(
           RawEditorPlaceholderExprSyntax(
-            placeholder: baseName,
+            placeholder: declName.baseName,
             arena: self.arena
           )
         )
       }
-      return RawExprSyntax(
-        RawDeclReferenceExprSyntax(
-          baseName: baseName,
-          argumentNames: argumentNames,
-          arena: self.arena
-        )
-      )
+      return RawExprSyntax(declName)
     }
 
-    let identifier = RawDeclReferenceExprSyntax(
-      baseName: baseName,
-      argumentNames: argumentNames,
-      arena: self.arena
-    )
     let generics = self.parseGenericArguments()
     return RawExprSyntax(
       RawGenericSpecializationExprSyntax(
-        expression: RawExprSyntax(identifier),
+        expression: RawExprSyntax(declName),
         genericArgumentClause: generics,
         arena: self.arena
       )
@@ -1907,14 +1886,7 @@ extension Parser {
       // follows a proper subexpression.
       let expr: RawExprSyntax
       if self.at(.binaryOperator) && self.peek(isAt: .comma, .rightParen, .rightSquare) {
-        let (baseName, argumentNames) = self.parseDeclNameRef(.operators)
-        expr = RawExprSyntax(
-          RawDeclReferenceExprSyntax(
-            baseName: baseName,
-            argumentNames: argumentNames,
-            arena: self.arena
-          )
-        )
+        expr = RawExprSyntax(self.parseDeclReferenceExpr(.operators))
       } else {
         expr = self.parseExpression(pattern: pattern)
       }

Sources/SwiftParser/Names.swift

@@ -63,7 +63,7 @@ extension Parser {
     static let zeroArgCompoundNames: Self = [.compoundNames, Self(rawValue: 1 << 5)]
   }
 
-  mutating func parseDeclNameRef(_ flags: DeclNameOptions = []) -> (baseName: RawTokenSyntax, argumentNames: RawDeclNameArgumentsSyntax?) {
+  mutating func parseDeclReferenceExpr(_ flags: DeclNameOptions = []) -> RawDeclReferenceExprSyntax {
     // Consume the base name.
     let base: RawTokenSyntax
     if let identOrSelf = self.consume(if: .identifier, .keyword(.self), .keyword(.Self)) ?? self.consume(if: .keyword(.`init`)) {
@@ -78,7 +78,11 @@ extension Parser {
 
     // Parse an argument list, if the flags allow it and it's present.
     let args = self.parseArgLabelList(flags)
-    return (base, args)
+    return RawDeclReferenceExprSyntax(
+      baseName: base,
+      argumentNames: args,
+      arena: self.arena
+    )
   }
 
   mutating func parseArgLabelList(_ flags: DeclNameOptions) -> RawDeclNameArgumentsSyntax? {
@@ -152,19 +156,15 @@ extension Parser {
       period = nil
     }
 
-    let (name, args) = self.parseDeclNameRef([
+    let declName = self.parseDeclReferenceExpr([
       .zeroArgCompoundNames,
       .keywordsUsingSpecialNames,
       .operators,
     ])
     return RawQualifiedDeclNameSyntax(
       baseType: type,
       period: period,
-      declName: RawDeclReferenceExprSyntax(
-        baseName: name,
-        argumentNames: args,
-        arena: self.arena
-      ),
+      declName: declName,
       arena: self.arena
     )
   }