Update to support shorthand if-let

Author: ahoppen

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -8234,9 +8234,6 @@ public struct OptionalBindingConditionSyntaxBuilder {
     if (layout[1] == nil) {
       layout[1] = RawSyntax.missing(SyntaxKind.pattern)
     }
-    if (layout[3] == nil) {
-      layout[3] = RawSyntax.missing(SyntaxKind.initializerClause)
-    }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .optionalBindingCondition,
       layout: layout, presence: .present))

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -3726,12 +3726,12 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return MatchingPatternConditionSyntax(data)
   }
-  public static func makeOptionalBindingCondition(letOrVarKeyword: TokenSyntax, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax) -> OptionalBindingConditionSyntax {
+  public static func makeOptionalBindingCondition(letOrVarKeyword: TokenSyntax, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax?) -> OptionalBindingConditionSyntax {
     let layout: [RawSyntax?] = [
       letOrVarKeyword.raw,
       pattern.raw,
       typeAnnotation?.raw,
-      initializer.raw,
+      initializer?.raw,
     ]
     let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.optionalBindingCondition,
       layout: layout, presence: SourcePresence.present)
@@ -3745,7 +3745,7 @@ public enum SyntaxFactory {
       RawSyntax.missingToken(TokenKind.letKeyword),
       RawSyntax.missing(SyntaxKind.pattern),
       nil,
-      RawSyntax.missing(SyntaxKind.initializerClause),
+      nil,
     ], length: .zero, presence: .present))
     return OptionalBindingConditionSyntax(data)
   }

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift

@@ -10039,10 +10039,11 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable {
     return OptionalBindingConditionSyntax(newData)
   }
 
-  public var initializer: InitializerClauseSyntax {
+  public var initializer: InitializerClauseSyntax? {
     get {
       let childData = data.child(at: Cursor.initializer,
                                  parent: Syntax(self))
+      if childData == nil { return nil }
       return InitializerClauseSyntax(childData!)
     }
     set(value) {
@@ -10055,7 +10056,7 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable {
   ///                   current `initializer`, if present.
   public func withInitializer(
     _ newChild: InitializerClauseSyntax?) -> OptionalBindingConditionSyntax {
-    let raw = newChild?.raw ?? RawSyntax.missing(SyntaxKind.initializerClause)
+    let raw = newChild?.raw
     let newData = data.replacingChild(raw, at: Cursor.initializer)
     return OptionalBindingConditionSyntax(newData)
   }
@@ -10090,8 +10091,7 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable {
       let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(TypeAnnotationSyntax.self))
     }
-    // Check child #3 child is InitializerClauseSyntax 
-    assert(rawChildren[3].raw != nil)
+    // Check child #3 child is InitializerClauseSyntax or missing
     if let raw = rawChildren[3].raw {
       let info = rawChildren[3].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
@@ -10108,7 +10108,7 @@ extension OptionalBindingConditionSyntax: CustomReflectable {
       "letOrVarKeyword": Syntax(letOrVarKeyword).asProtocol(SyntaxProtocol.self),
       "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self),
       "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
-      "initializer": Syntax(initializer).asProtocol(SyntaxProtocol.self),
+      "initializer": initializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
     ])
   }
 }

Sources/SwiftSyntaxBuilder/gyb_generated/BuildableNodes.swift

@@ -10147,7 +10147,7 @@ public struct OptionalBindingCondition: SyntaxBuildable, ExpressibleAsOptionalBi
   let letOrVarKeyword: TokenSyntax
   let pattern: PatternBuildable
   let typeAnnotation: TypeAnnotation?
-  let initializer: InitializerClause
+  let initializer: InitializerClause?
 
   /// Creates a `OptionalBindingCondition` using the provided parameters.
   /// - Parameters:
@@ -10159,13 +10159,13 @@ public struct OptionalBindingCondition: SyntaxBuildable, ExpressibleAsOptionalBi
     letOrVarKeyword: TokenSyntax,
     pattern: ExpressibleAsPatternBuildable,
     typeAnnotation: ExpressibleAsTypeAnnotation? = nil,
-    initializer: ExpressibleAsInitializerClause
+    initializer: ExpressibleAsInitializerClause? = nil
   ) {
     self.letOrVarKeyword = letOrVarKeyword
     assert(letOrVarKeyword.text == "let" || letOrVarKeyword.text == "var")
     self.pattern = pattern.createPatternBuildable()
     self.typeAnnotation = typeAnnotation?.createTypeAnnotation()
-    self.initializer = initializer.createInitializerClause()
+    self.initializer = initializer?.createInitializerClause()
   }
 
 
@@ -10174,7 +10174,7 @@ public struct OptionalBindingCondition: SyntaxBuildable, ExpressibleAsOptionalBi
       letOrVarKeyword: letOrVarKeyword,
       pattern: pattern.buildPattern(format: format, leadingTrivia: nil),
       typeAnnotation: typeAnnotation?.buildTypeAnnotation(format: format, leadingTrivia: nil),
-      initializer: initializer.buildInitializerClause(format: format, leadingTrivia: nil)
+      initializer: initializer?.buildInitializerClause(format: format, leadingTrivia: nil)
     )
     if let leadingTrivia = leadingTrivia {
       return result.withLeadingTrivia(leadingTrivia + (result.leadingTrivia ?? []))

Sources/SwiftSyntaxParser/gyb_generated/NodeDeclarationHash.swift

@@ -17,6 +17,6 @@
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "2ec3f7586996f875c3cb1e71ed98e0551f0ec8e7"
+      "02005359b9e133d40bc189a32fb0fee13480b5a1"
   }
 }