Some renames in the parser due to renamed syntax nodes

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/BuilderInitializableTypes.swift

@@ -14,22 +14,22 @@
 /// builder. If the value is not nil, the result builder construct the value's
 /// type and synthesize all other members to form the node.
 public let BUILDER_INITIALIZABLE_TYPES: [SyntaxNodeKind: SyntaxNodeKind?] = [
+  .arrayElementList: nil,
+  .closureCaptureList: nil,
   .codeBlock: .codeBlockItemList,
-  .memberBlock: .memberBlockItemList,
   .codeBlockItemList: nil,
-  .memberBlockItemList: nil,
-  .patternBindingList: nil,
-  .switchCaseList: nil,
-  .arrayElementList: nil,
-  .tupleExprElementList: nil,
   .enumCaseElementList: nil,
+  .exprList: nil,
   .functionParameterList: nil,
+  .genericArgumentList: nil,
   .genericParameterList: nil,
   .genericRequirementList: nil,
   .inheritedTypeList: nil,
-  .closureCaptureList: nil,
+  .memberBlock: .memberBlockItemList,
+  .memberBlockItemList: nil,
+  .patternBindingList: nil,
   .switchCaseItemList: nil,
-  .genericArgumentList: nil,
+  .switchCaseList: nil,
+  .tupleExprElementList: nil,
   .tuplePatternElementList: nil,
-  .exprList: nil,
 ]

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -1511,7 +1511,7 @@ public let DECL_NODES: [Node] = [
     kind: .memberBlock,
     base: .syntax,
     nameForDiagnostics: "member block",
-    parserFunction: "parseMemberDeclList",
+    parserFunction: "parseMemberBlock",
     traits: ["Braced"],
     children: [
       Child(

Sources/SwiftParser/Attributes.swift

@@ -230,7 +230,7 @@ extension Parser {
       }
     case .backDeployed, ._backDeploy:
       return parseAttribute(argumentMode: .required) { parser in
-        return .backDeployedArguments(parser.parseBackDeployedArguments())
+        return .backDeployedArguments(parser.parseBackDeployedAttributeArguments())
       }
     case .differentiable:
       return parseAttribute(argumentMode: .required) { parser in
@@ -246,15 +246,15 @@ extension Parser {
       }
     case ._specialize:
       return parseAttribute(argumentMode: .required) { parser in
-        return .specializeArguments(parser.parseSpecializeAttributeSpecList())
+        return .specializeArguments(parser.parseSpecializeAttributeArgumentList())
       }
     case ._private:
       return parseAttribute(argumentMode: .required) { parser in
         return .underscorePrivateAttributeArguments(parser.parseUnderscorePrivateAttributeArguments())
       }
     case ._dynamicReplacement:
       return parseAttribute(argumentMode: .required) { parser in
-        return .dynamicReplacementArguments(parser.parseDynamicReplacementArguments())
+        return .dynamicReplacementArguments(parser.parseDynamicReplacementAttributeArguments())
       }
     case ._documentation:
       return parseAttribute(argumentMode: .required) { parser in
@@ -310,11 +310,11 @@ extension Parser {
       }
     case ._originallyDefinedIn:
       return parseAttribute(argumentMode: .required) { parser in
-        return .originallyDefinedInArguments(parser.parseOriginallyDefinedInArguments())
+        return .originallyDefinedInArguments(parser.parseOriginallyDefinedInAttributeArguments())
       }
     case ._unavailableFromAsync:
       return parseAttribute(argumentMode: .optional) { parser in
-        return .unavailableFromAsyncArguments(parser.parseUnavailableFromAsyncArguments())
+        return .unavailableFromAsyncArguments(parser.parseUnavailableFromAsyncAttributeArguments())
       }
     case .attached:
       return parseAttribute(argumentMode: .customAttribute) { parser in
@@ -405,7 +405,7 @@ extension Parser {
     let parameters: RawDifferentiabilityWithRespectToArgumentSyntax?
     let parametersComma: RawTokenSyntax?
     if self.at(.keyword(.wrt)) {
-      parameters = self.parseDifferentiabilityParameters()
+      parameters = self.parseDifferentiabilityWithRespectToArgument()
       parametersComma = self.consume(if: .comma)
     } else {
       parameters = nil
@@ -428,14 +428,14 @@ extension Parser {
     )
   }
 
-  mutating func parseDifferentiabilityParameters() -> RawDifferentiabilityWithRespectToArgumentSyntax {
+  mutating func parseDifferentiabilityWithRespectToArgument() -> RawDifferentiabilityWithRespectToArgumentSyntax {
     let (unexpectedBeforeWrt, wrt) = self.expect(.keyword(.wrt))
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
 
     guard let leftParen = self.consume(if: .leftParen) else {
       // If no opening '(' for parameter list, parse a single parameter.
       let param =
-        self.parseDifferentiabilityParameter()
+        self.parseDifferentiabilityArgument()
         ?? RawDifferentiabilityArgumentSyntax(
           parameter: missingToken(.identifier),
           trailingComma: nil,
@@ -454,7 +454,7 @@ extension Parser {
     var elements = [RawDifferentiabilityArgumentSyntax]()
     var loopProgress = LoopProgressCondition()
     while !self.at(.endOfFile, .rightParen) && self.hasProgressed(&loopProgress) {
-      guard let param = self.parseDifferentiabilityParameter() else {
+      guard let param = self.parseDifferentiabilityArgument() else {
         break
       }
       elements.append(param)
@@ -478,7 +478,7 @@ extension Parser {
     )
   }
 
-  mutating func parseDifferentiabilityParameter() -> RawDifferentiabilityArgumentSyntax? {
+  mutating func parseDifferentiabilityArgument() -> RawDifferentiabilityArgumentSyntax? {
     switch self.at(anyIn: DifferentiabilityArgumentSyntax.ParameterOptions.self) {
     case (.identifier, let handle)?:
       let token = self.eat(handle)
@@ -570,7 +570,7 @@ extension Parser {
     let comma = self.consume(if: .comma)
     let parameters: RawDifferentiabilityWithRespectToArgumentSyntax?
     if comma != nil {
-      parameters = self.parseDifferentiabilityParameters()
+      parameters = self.parseDifferentiabilityWithRespectToArgument()
     } else {
       parameters = nil
     }
@@ -672,7 +672,7 @@ extension Parser {
       }
     }
   }
-  mutating func parseSpecializeAttributeSpecList() -> RawSpecializeAttributeArgumentListSyntax {
+  mutating func parseSpecializeAttributeArgumentList() -> RawSpecializeAttributeArgumentListSyntax {
     var elements = [RawSpecializeAttributeArgumentListSyntax.Element]()
     // Parse optional "exported" and "kind" labeled parameters.
     var loopProgress = LoopProgressCondition()
@@ -910,13 +910,13 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseBackDeployedArguments() -> RawBackDeployedAttributeArgumentsSyntax {
+  mutating func parseBackDeployedAttributeArguments() -> RawBackDeployedAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.before))
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
     var elements: [RawPlatformVersionItemSyntax] = []
     var keepGoing: RawTokenSyntax? = nil
     repeat {
-      let versionRestriction = self.parseAvailabilityMacro()
+      let versionRestriction = self.parsePlatformVersion()
       keepGoing = self.consume(if: .comma)
       elements.append(
         RawPlatformVersionItemSyntax(
@@ -967,7 +967,7 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseOriginallyDefinedInArguments() -> RawOriginallyDefinedInAttributeArgumentsSyntax {
+  mutating func parseOriginallyDefinedInAttributeArguments() -> RawOriginallyDefinedInAttributeArgumentsSyntax {
     let (unexpectedBeforeModuleLabel, moduleLabel) = self.expect(.keyword(.module))
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
     let moduleName = self.parseStringLiteral()
@@ -976,7 +976,7 @@ extension Parser {
     var platforms: [RawPlatformVersionItemSyntax] = []
     var keepGoing: RawTokenSyntax?
     repeat {
-      let restriction = self.parseAvailabilityMacro(allowStarAsVersionNumber: true)
+      let restriction = self.parsePlatformVersion(allowStarAsVersionNumber: true)
       keepGoing = self.consume(if: .comma)
       platforms.append(
         RawPlatformVersionItemSyntax(
@@ -1018,7 +1018,7 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseDynamicReplacementArguments() -> RawDynamicReplacementAttributeArgumentsSyntax {
+  mutating func parseDynamicReplacementAttributeArguments() -> RawDynamicReplacementAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.for))
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
     let base: RawTokenSyntax
@@ -1044,7 +1044,7 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseUnavailableFromAsyncArguments() -> RawUnavailableFromAsyncAttributeArgumentsSyntax {
+  mutating func parseUnavailableFromAsyncAttributeArguments() -> RawUnavailableFromAsyncAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.message))
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
 

Sources/SwiftParser/Availability.swift

@@ -22,7 +22,7 @@ extension Parser {
       repeat {
         let argument: RawAvailabilityArgumentSyntax.Argument
         if self.at(.identifier) {
-          argument = .availabilityVersionRestriction(self.parseAvailabilityMacro())
+          argument = .availabilityVersionRestriction(self.parsePlatformVersion())
         } else {
           argument = self.parseAvailabilitySpec()
         }
@@ -183,7 +183,7 @@ extension Parser {
       return .token(star)
     }
 
-    return .availabilityVersionRestriction(self.parseAvailabilityMacro())
+    return .availabilityVersionRestriction(self.parsePlatformVersion())
   }
 
   /// Parse an availability macro.
@@ -192,7 +192,7 @@ extension Parser {
   ///
   /// If `allowStarAsVersionNumber` is `true`, versions like `* 13.0` are accepted.
   /// This is to match the behavior of `@_originallyDefinedIn` in the old parser that accepted such versions
-  mutating func parseAvailabilityMacro(allowStarAsVersionNumber: Bool = false) -> RawPlatformVersionSyntax {
+  mutating func parsePlatformVersion(allowStarAsVersionNumber: Bool = false) -> RawPlatformVersionSyntax {
     let unexpectedBeforePlatform: RawUnexpectedNodesSyntax?
     let platform: RawTokenSyntax
     if allowStarAsVersionNumber, self.atContextualPunctuator("*") {

Sources/SwiftParser/Declarations.swift

@@ -203,7 +203,7 @@ extension Parser {
 
     let attrs = DeclAttributes(
       attributes: self.parseAttributeList(),
-      modifiers: self.parseModifierList()
+      modifiers: self.parseDeclModifierList()
     )
 
     // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context)
@@ -353,7 +353,7 @@ extension Parser {
     } else {
       whereClause = nil
     }
-    let memberBlock = self.parseMemberDeclList(introducer: extensionKeyword)
+    let memberBlock = self.parseMemberBlock(introducer: extensionKeyword)
     return RawExtensionDeclSyntax(
       attributes: attrs.attributes,
       modifiers: attrs.modifiers,
@@ -534,9 +534,9 @@ extension Parser {
         case (.colon, let handle)?:
           let colon = self.eat(handle)
           // A conformance-requirement.
-          if let (layoutConstraint, handle) = self.at(anyIn: LayoutRequirementSyntax.LayoutSpecifierOptions.self) {
+          if let (layoutSpecifier, handle) = self.at(anyIn: LayoutRequirementSyntax.LayoutSpecifierOptions.self) {
             // Parse a layout constraint.
-            let constraint = self.eat(handle)
+            let specifier = self.eat(handle)
 
             let unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax?
             let leftParen: RawTokenSyntax?
@@ -547,7 +547,7 @@ extension Parser {
             let rightParen: RawTokenSyntax?
 
             var hasArguments: Bool {
-              switch layoutConstraint {
+              switch layoutSpecifier {
               case ._Trivial,
                 ._TrivialAtMost:
                 return true
@@ -563,7 +563,7 @@ extension Parser {
 
             // Unlike the other layout constraints, _Trivial's argument list
             // is optional.
-            if hasArguments && (layoutConstraint != ._Trivial || self.at(.leftParen)) {
+            if hasArguments && (layoutSpecifier != ._Trivial || self.at(.leftParen)) {
               (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
               size = self.expectWithoutRecovery(.integerLiteral)
               comma = self.consume(if: .comma)
@@ -587,7 +587,7 @@ extension Parser {
               RawLayoutRequirementSyntax(
                 type: firstType,
                 colon: colon,
-                layoutSpecifier: constraint,
+                layoutSpecifier: specifier,
                 unexpectedBeforeLeftParen,
                 leftParen: leftParen,
                 size: size,
@@ -667,7 +667,7 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseMemberDeclListItem() -> RawMemberBlockItemSyntax? {
+  mutating func parseMemberBlockItem() -> RawMemberBlockItemSyntax? {
     let startToken = self.currentToken
     if let syntax = self.loadCurrentSyntaxNodeFromCache(for: .memberDeclListItem) {
       self.registerNodeForIncrementalParse(node: syntax.raw, startToken: startToken)
@@ -715,14 +715,14 @@ extension Parser {
   /// `introducer` is the `struct`, `class`, ... keyword that is the cause that the member decl block is being parsed.
   /// If the left brace is missing, its indentation will be used to judge whether a following `}` was
   /// indented to close this code block or a surrounding context. See `expectRightBrace`.
-  mutating func parseMemberDeclList(introducer: RawTokenSyntax? = nil) -> RawMemberBlockSyntax {
+  mutating func parseMemberBlock(introducer: RawTokenSyntax? = nil) -> RawMemberBlockSyntax {
     var elements = [RawMemberBlockItemSyntax]()
     let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace)
     do {
       var loopProgress = LoopProgressCondition()
       while !self.at(.endOfFile, .rightBrace) && self.hasProgressed(&loopProgress) {
         let newItemAtStartOfLine = self.atStartOfLine
-        guard let newElement = self.parseMemberDeclListItem() else {
+        guard let newElement = self.parseMemberBlockItem() else {
           break
         }
         if let lastItem = elements.last, lastItem.semicolon == nil && !newItemAtStartOfLine {
@@ -1361,11 +1361,11 @@ extension Parser {
     // protocol, but we parse and then reject it for better QoI.
     //
     //     set-name    ::= '(' identifier ')'
-    let parameter: RawAccessorParametersSyntax?
+    let parameters: RawAccessorParametersSyntax?
     if [AccessorDeclSyntax.AccessorSpecifierOptions.set, .willSet, .didSet, .`init`].contains(introducer.kind), let lparen = self.consume(if: .leftParen) {
       let (unexpectedBeforeName, name) = self.expectIdentifier()
       let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen)
-      parameter = RawAccessorParametersSyntax(
+      parameters = RawAccessorParametersSyntax(
         leftParen: lparen,
         unexpectedBeforeName,
         name: name,
@@ -1374,7 +1374,7 @@ extension Parser {
         arena: self.arena
       )
     } else {
-      parameter = nil
+      parameters = nil
     }
 
     let effectSpecifiers = self.parseAccessorEffectSpecifiers()
@@ -1386,7 +1386,7 @@ extension Parser {
       modifier: introducer.modifier,
       introducer.unexpectedBeforeToken,
       accessorSpecifier: introducer.token,
-      parameters: parameter,
+      parameters: parameters,
       effectSpecifiers: effectSpecifiers,
       initEffects: initEffects,
       body: body,