Merge pull request #1517 from stevapple/fix-for-in

Address default parameter regressions and add tests for `ForInStmtSyntax`

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -96,7 +96,7 @@ public let KEYWORDS: [KeywordSpec] = [
   KeywordSpec("autoclosure"),
   KeywordSpec("availability"),
   KeywordSpec("available"),
-  KeywordSpec("await"),
+  KeywordSpec("await", requiresTrailingSpace: true),
   KeywordSpec("backDeployed"),
   KeywordSpec("before"),
   KeywordSpec("block"),

CodeGeneration/Sources/SyntaxSupport/StmtNodes.swift

@@ -290,18 +290,17 @@ public let STMT_NODES: [Node] = [
       ),
       Child(
         name: "TryKeyword",
-        kind: .node(kind: "TryToken"),
+        kind: .token(choices: [.keyword(text: "try")]),
         isOptional: true
       ),
       Child(
         name: "AwaitKeyword",
         kind: .token(choices: [.keyword(text: "await")]),
-        isOptional: true,
-        classification: "Keyword"
+        isOptional: true
       ),
       Child(
         name: "CaseKeyword",
-        kind: .node(kind: "CaseToken"),
+        kind: .token(choices: [.keyword(text: "case")]),
         isOptional: true
       ),
       Child(

CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift

@@ -45,21 +45,34 @@ public extension Child {
     flattened(indentedDocumentation: description ?? "")
   }
 
-  var defaultInitialization: ExprSyntax? {
-    switch kind {
-    case .token(choices: let choices, requiresLeadingSpace: _, requiresTrailingSpace: _):
-      if choices.count == 1, case .keyword(text: let text) = choices.first {
-        var textChoice = text
-        if textChoice == "init" {
-          textChoice = "`init`"
-        }
-        return ExprSyntax(".keyword(.\(raw: textChoice))")
-      } else {
-        return type.defaultInitialization
-      }
-    default:
-      return type.defaultInitialization
+  /// If the child node has a default value, return an expression of the form
+  /// ` = default_value` that can be used as the default value to for a
+  /// function parameter. Otherwise, return `nil`.
+  var defaultInitialization: InitializerClauseSyntax? {
+    if isOptional || isUnexpectedNodes {
+      return InitializerClauseSyntax(value: NilLiteralExprSyntax())
+    }
+    guard let token = token, isToken else {
+      return type.defaultValue.map { InitializerClauseSyntax(value: $0) }
+    }
+    if token.isKeyword {
+      return InitializerClauseSyntax(value: ExprSyntax(".\(raw: token.swiftKind)()"))
+    }
+    if token.text != nil {
+      return InitializerClauseSyntax(value: ExprSyntax(".\(raw: token.swiftKind)Token()"))
+    }
+    guard case .token(let choices, _, _) = kind, choices.count == 1, token.associatedValueClass != nil else {
+      return nil
+    }
+    var textChoice: String
+    switch choices[0] {
+    case .keyword(let text), .token(let text):
+      textChoice = text
+    }
+    if textChoice == "init" {
+      textChoice = "`init`"
     }
+    return InitializerClauseSyntax(value: ExprSyntax(".\(raw: token.swiftKind)(.\(raw: textChoice))"))
   }
 
   /// If this node is a token that can't contain arbitrary text, generate a Swift

CodeGeneration/Sources/Utils/SyntaxBuildableNode.swift

@@ -50,7 +50,7 @@ public extension Node {
 
   /// Assuming this node has a single child without a default value, that child.
   var singleNonDefaultedChild: Child {
-    let nonDefaultedParams = children.filter { $0.type.defaultInitialization == nil }
+    let nonDefaultedParams = children.filter { $0.defaultInitialization == nil }
     precondition(nonDefaultedParams.count == 1)
     return nonDefaultedParams[0]
   }

CodeGeneration/Sources/Utils/SyntaxBuildableType.swift

@@ -50,10 +50,9 @@ public struct SyntaxBuildableType: Hashable {
   }
 
   /// If the type has a default value (because it is optional or a token
-  /// with fixed test), return an expression of the form ` = defaultValue`
-  /// that can be used as the default value for a function parameter.
-  /// Otherwise, return the empty string.
-  public var defaultInitialization: ExprSyntax? {
+  /// with fixed test), return an expression that can be used as the
+  /// default value for a function parameter. Otherwise, return `nil`.
+  public var defaultValue: ExprSyntax? {
     if isOptional {
       return ExprSyntax(NilLiteralExprSyntax())
     } else if let token = token {

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

@@ -197,7 +197,7 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
               secondName: .identifier(child.swiftName),
               colon: .colonToken(),
               type: child.rawParameterType,
-              defaultArgument: child.isUnexpectedNodes ? child.defaultInitialization.map { InitializerClauseSyntax(value: $0) } : nil
+              defaultArgument: child.isUnexpectedNodes ? child.defaultInitialization : nil
             )
           }
 

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

@@ -438,57 +438,3 @@ fileprivate extension Node {
     }
   }
 }
-
-fileprivate extension Child {
-  /// If the type has a default value, return an expression of the form
-  /// ` = default_value` that can be used as the default value to for a
-  /// function parameter. Otherwise, return an empty string.
-  var defaultInitialization: InitializerClauseSyntax? {
-    // Note that this should be Optional<BaseType>.none for defaulted generic,
-    // but that doesn't work in Swift 5.6. To keep source compatibility with
-    // previous SwiftSyntax, we instead create a second initializer that uses
-    // `Missing<Node>` and defaults that to `nil` instead (and `Missing` is
-    // used so that they can't be implicitly converted from a literal).
-
-    if isOptional || isUnexpectedNodes {
-      return InitializerClauseSyntax(value: NilLiteralExprSyntax())
-    }
-
-    guard let token = token, isToken else {
-      return nil
-    }
-
-    if token.isKeyword {
-      return InitializerClauseSyntax(value: ExprSyntax(".\(raw: token.swiftKind)()"))
-    }
-
-    if token.text != nil {
-      return InitializerClauseSyntax(value: ExprSyntax(".\(raw: token.swiftKind)Token()"))
-    }
-
-    guard case .token(let choices, _, _) = kind else {
-      return nil
-    }
-
-    guard choices.count == 1 else {
-      return nil
-    }
-
-    var textChoice: String
-
-    switch choices[0] {
-    case .keyword(let text),
-      .token(let text):
-      textChoice = text
-    }
-
-    if token.associatedValueClass != nil {
-      if textChoice == "init" {
-        textChoice = "`init`"
-      }
-      return InitializerClauseSyntax(value: ExprSyntax(".\(raw: token.swiftKind)(.\(raw: textChoice))"))
-    } else {
-      return InitializerClauseSyntax(value: ExprSyntax(#".\#(raw: token.swiftKind)("\#(raw: textChoice)")"#))
-    }
-  }
-}

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift

@@ -83,7 +83,7 @@ private func createConvenienceInitializer(node: Node) throws -> InitializerDeclS
           firstName: .identifier(child.swiftName),
           colon: .colonToken(),
           type: child.parameterType,
-          defaultArgument: child.defaultInitialization.map { InitializerClauseSyntax(value: $0) }
+          defaultArgument: child.defaultInitialization
         )
       )
     }

Sources/IDEUtils/generated/SyntaxClassification.swift

@@ -79,8 +79,6 @@ extension SyntaxClassification {
       return (.stringInterpolationAnchor, true)
     case \ExpressionSegmentSyntax.rightParen:
       return (.stringInterpolationAnchor, true)
-    case \ForInStmtSyntax.awaitKeyword:
-      return (.keyword, false)
     case \IfConfigClauseSyntax.poundKeyword:
       return (.buildConfigId, false)
     case \IfConfigClauseSyntax.condition:

Sources/SwiftBasicFormat/generated/BasicFormat.swift

@@ -285,6 +285,8 @@ open class BasicFormat: SyntaxRewriter {
       return true
     case .keyword(.async):
       return true
+    case .keyword(.await):
+      return true
     case .keyword(.`break`):
       return true
     case .keyword(.`case`):