[ASTGen] NFC: Run swift-format

Author: hamishknight

lib/ASTGen/Sources/ASTGen/ASTGen.swift

@@ -171,7 +171,9 @@ extension ASTGenVisitor {
 
   /// Obtains a pair of bridged identifier and the bridged source location.
   @inline(__always)
-  func generateIdentifierAndSourceLoc(_ token: TokenSyntax) -> (identifier: BridgedIdentifier, sourceLoc: BridgedSourceLoc) {
+  func generateIdentifierAndSourceLoc(_ token: TokenSyntax) -> (
+    identifier: BridgedIdentifier, sourceLoc: BridgedSourceLoc
+  ) {
     return (
       self.generateIdentifier(token),
       self.generateSourceLoc(token)
@@ -182,7 +184,9 @@ extension ASTGenVisitor {
   /// If `token` is `nil`, returns a pair of an empty identifier and an invalid
   /// source location.
   @inline(__always)
-  func generateIdentifierAndSourceLoc(_ token: TokenSyntax?) -> (identifier: BridgedIdentifier, sourceLoc: BridgedSourceLoc) {
+  func generateIdentifierAndSourceLoc(_ token: TokenSyntax?) -> (
+    identifier: BridgedIdentifier, sourceLoc: BridgedSourceLoc
+  ) {
     token.map(generateIdentifierAndSourceLoc(_:)) ?? (nil, nil)
   }
 
@@ -454,13 +458,15 @@ private func _build<Node: SyntaxProtocol, Result>(
   endLocPtr.pointee = sourceLoc.advanced(by: node.totalLength.utf8Length)
 
   // Convert the syntax node.
-  return generator(ASTGenVisitor(
-    diagnosticEngine: diagEngine,
-    sourceBuffer: sourceFile.pointee.buffer,
-    declContext: declContext,
-    astContext: astContext,
-    legacyParser: legacyParser
-  ))(node)
+  return generator(
+    ASTGenVisitor(
+      diagnosticEngine: diagEngine,
+      sourceBuffer: sourceFile.pointee.buffer,
+      declContext: declContext,
+      astContext: astContext,
+      legacyParser: legacyParser
+    )
+  )(node)
 }
 
 @_cdecl("swift_ASTGen_buildTypeRepr")

lib/ASTGen/Sources/ASTGen/Decls.swift

@@ -399,7 +399,7 @@ extension ASTGenVisitor {
   func generate(operatorDecl node: OperatorDeclSyntax) -> BridgedOperatorDecl {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
     let (precedenceGroupName, precedenceGroupLoc) =
-        self.generateIdentifierAndSourceLoc(node.operatorPrecedenceAndTypes?.precedenceGroup)
+      self.generateIdentifierAndSourceLoc(node.operatorPrecedenceAndTypes?.precedenceGroup)
 
     let fixity: BridgedOperatorFixity
     if let value = BridgedOperatorFixity(from: node.fixitySpecifier.keywordKind) {

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -39,15 +39,15 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
   }
   while true {
     switch current.kind {
-    case // Known implemented kinds.
-        .arrayExpr, .arrowExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr,
-        .booleanLiteralExpr, .borrowExpr, .closureExpr, .consumeExpr, .copyExpr,
-        .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr,
-        .functionCallExpr, .ifExpr, .integerLiteralExpr, .memberAccessExpr,
-        .nilLiteralExpr, .packElementExpr, .packExpansionExpr,
-        .postfixOperatorExpr, .prefixOperatorExpr, .sequenceExpr,
-        .stringLiteralExpr, .tryExpr, .tupleExpr, .typeExpr,  .unresolvedAsExpr,
-        .unresolvedIsExpr, .unresolvedTernaryExpr:
+    // Known implemented kinds.
+    case .arrayExpr, .arrowExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr,
+      .booleanLiteralExpr, .borrowExpr, .closureExpr, .consumeExpr, .copyExpr,
+      .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr,
+      .functionCallExpr, .ifExpr, .integerLiteralExpr, .memberAccessExpr,
+      .nilLiteralExpr, .packElementExpr, .packExpansionExpr,
+      .postfixOperatorExpr, .prefixOperatorExpr, .sequenceExpr,
+      .stringLiteralExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr,
+      .unresolvedIsExpr, .unresolvedTernaryExpr:
 
       // `generate(stringLiteralExpr:)` doesn't support interpolations.
       if let str = current.as(StringLiteralExprSyntax.self) {
@@ -58,17 +58,19 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
       }
 
       break
-    case // Known unimplemented kinds.
-        .asExpr, .canImportExpr, .canImportVersionInfo,
-        .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr,
-        .inOutExpr, .infixOperatorExpr,  .isExpr, .keyPathExpr,
-        .macroExpansionExpr,  .optionalChainingExpr,
-        .postfixIfConfigExpr, .regexLiteralExpr, .genericSpecializationExpr,
-        .simpleStringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr,
-        .ternaryExpr, .patternExpr:
+
+    // Known unimplemented kinds.
+    case .asExpr, .canImportExpr, .canImportVersionInfo,
+      .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr,
+      .inOutExpr, .infixOperatorExpr, .isExpr, .keyPathExpr,
+      .macroExpansionExpr, .optionalChainingExpr,
+      .postfixIfConfigExpr, .regexLiteralExpr, .genericSpecializationExpr,
+      .simpleStringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr,
+      .ternaryExpr, .patternExpr:
       return false
-    case // Unknown expr kinds.
-      _ where current.is(ExprSyntax.self):
+
+    // Unknown expr kinds.
+    case _ where current.is(ExprSyntax.self):
       return false
     default:
       break
@@ -322,7 +324,9 @@ extension ASTGenVisitor {
     return .createParsed(self.ctx, fn: callee, args: argumentTuple)
   }
 
-  private func createDeclNameRef(declReferenceExpr node: DeclReferenceExprSyntax) -> (name: BridgedDeclNameRef, loc: BridgedDeclNameLoc) {
+  private func createDeclNameRef(declReferenceExpr node: DeclReferenceExprSyntax) -> (
+    name: BridgedDeclNameRef, loc: BridgedDeclNameLoc
+  ) {
     let baseName: BridgedDeclBaseName
     switch node.baseName.keywordKind {
     case .`init`:
@@ -428,7 +432,7 @@ extension ASTGenVisitor {
       patternExpr: self.generate(expr: node.repetitionPattern)
     )
   }
-  
+
   func generate(ifExpr node: IfExprSyntax) -> BridgedSingleValueStmtExpr {
     let stmt = makeIfStmt(node).asStmt
 
@@ -611,7 +615,10 @@ extension ASTGenVisitor {
 }
 
 extension ASTGenVisitor {
-  fileprivate func createOperatorRefExpr(token node: TokenSyntax, kind: BridgedDeclRefKind) -> BridgedUnresolvedDeclRefExpr {
+  fileprivate func createOperatorRefExpr(
+    token node: TokenSyntax,
+    kind: BridgedDeclRefKind
+  ) -> BridgedUnresolvedDeclRefExpr {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node)
 
     return .createParsed(
@@ -622,9 +629,12 @@ extension ASTGenVisitor {
     );
   }
 
-
   /// Generate a tuple expression from a ``LabeledExprListSyntax`` and parentheses.
-  func generate(labeledExprList node: LabeledExprListSyntax, leftParen: TokenSyntax?, rightParen: TokenSyntax?) -> BridgedTupleExpr {
+  func generate(
+    labeledExprList node: LabeledExprListSyntax,
+    leftParen: TokenSyntax?,
+    rightParen: TokenSyntax?
+  ) -> BridgedTupleExpr {
     let expressions = node.lazy.map {
       self.generate(expr: $0.expression)
     }

lib/ASTGen/Sources/ASTGen/LegacyParse.swift

@@ -12,8 +12,8 @@
 
 import ASTBridging
 import BasicBridging
-import SwiftSyntax
 import ParseBridging
+import SwiftSyntax
 
 extension ASTGenVisitor {
 
@@ -40,10 +40,10 @@ extension ASTGenVisitor {
   }
 
   func generateMatchingPatternWithLegacy(_ node: some PatternSyntaxProtocol) {
-//    legacyParse.parseMatchingPattern(self.bridgedSourceLoc(syntax: node), self.declContext)
+    //    legacyParse.parseMatchingPattern(self.bridgedSourceLoc(syntax: node), self.declContext)
   }
 
   func generateBindingPatternWithLegacy(_ node: some PatternSyntaxProtocol) {
-//    legacyParse.parseBindingPattern(self.bridgedSourceLoc(syntax: node), self.declContext)
+    //    legacyParse.parseBindingPattern(self.bridgedSourceLoc(syntax: node), self.declContext)
   }
 }

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -235,14 +235,14 @@ func checkMacroDefinition(
         // least for documentation purposes right now. Don't emit a warning for
         // them, but do fail operation.
         case "FileIDMacro",
-             "FilePathMacro",
-             "FileMacro",
-             "FunctionMacro",
-             "LineMacro",
-             "ColumnMacro",
-             "DSOHandleMacro",
-             "WarningMacro",
-             "ErrorMacro":
+          "FilePathMacro",
+          "FileMacro",
+          "FunctionMacro",
+          "LineMacro",
+          "ColumnMacro",
+          "DSOHandleMacro",
+          "WarningMacro",
+          "ErrorMacro":
           return -1
 
         default:
@@ -640,9 +640,9 @@ func findSyntaxNodeInSourceFile<Node: SyntaxProtocol>(
   // E.g. for 'foo.bar' we want the member ref expression instead of the
   // identifier expression.
   if wantOutermost {
-    while
-      let parentSyntax = currentSyntax.parent,
-      parentSyntax.position == resultSyntax.position {
+    while let parentSyntax = currentSyntax.parent,
+      parentSyntax.position == resultSyntax.position
+    {
       currentSyntax = parentSyntax
       if let typedParent = currentSyntax.as(type) {
         resultSyntax = typedParent

lib/ASTGen/Sources/ASTGen/ParameterClause.swift

@@ -74,17 +74,18 @@ extension ASTGenVisitor {
     let specifierLoc: BridgedSourceLoc = nil
 
     let (firstName, firstNameLoc) =
-        self.generateIdentifierAndSourceLoc(node.optionalFirstName)
+      self.generateIdentifierAndSourceLoc(node.optionalFirstName)
     let (secondName, secondNameLoc) =
-        self.generateIdentifierAndSourceLoc(node.secondName)
+      self.generateIdentifierAndSourceLoc(node.secondName)
 
     var type = node.optionalType.map(generate(type:))
     if let ellipsis = node.ellipsis, let base = type {
-      type = BridgedVarargTypeRepr.createParsed(
-        self.ctx,
-        base: base,
-        ellipsisLoc: self.generateSourceLoc(ellipsis)
-      ).asTypeRepr
+      type =
+        BridgedVarargTypeRepr.createParsed(
+          self.ctx,
+          base: base,
+          ellipsisLoc: self.generateSourceLoc(ellipsis)
+        ).asTypeRepr
     }
 
     return .createParsed(

lib/ASTGen/Sources/ASTGen/Patterns.swift

@@ -45,7 +45,8 @@ extension ASTGenVisitor {
   func generate(identifierPattern node: IdentifierPatternSyntax) -> BridgedNamedPattern {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.identifier)
     return .createParsed(
-      ctx, declContext: declContext,
+      ctx,
+      declContext: declContext,
       name: name,
       loc: nameLoc
     )
@@ -105,5 +106,3 @@ extension ASTGenVisitor {
     )
   }
 }
-
-

lib/ASTGen/Sources/ASTGen/Regex.swift

@@ -45,9 +45,13 @@ public func _RegexLiteralLexingFn(
 ) -> /*CompletelyErroneous*/ Bool {
   let inputPtr = curPtrPtr.pointee
 
-  guard let (resumePtr, error) = swiftCompilerLexRegexLiteral(
-    start: inputPtr, bufferEnd: bufferEndPtr, mustBeRegex: mustBeRegex
-  ) else {
+  guard
+    let (resumePtr, error) = swiftCompilerLexRegexLiteral(
+      start: inputPtr,
+      bufferEnd: bufferEndPtr,
+      mustBeRegex: mustBeRegex
+    )
+  else {
     // Not a regex literal, fallback without advancing the pointer.
     return false
   }
@@ -97,12 +101,16 @@ public func _RegexLiteralParsingFn(
 ) -> Bool {
   let str = String(bridged: input)
   let captureBuffer = UnsafeMutableRawBufferPointer(
-    start: captureStructureOut, count: Int(captureStructureSize))
+    start: captureStructureOut,
+    count: Int(captureStructureSize)
+  )
   do {
     // FIXME: We need to plumb through the 'regexToEmit' result to the caller.
     // For now, it is the same as the input.
     let (_, version) = try swiftCompilerParseRegexLiteral(
-      str, captureBufferOut: captureBuffer)
+      str,
+      captureBufferOut: captureBuffer
+    )
     versionOut.pointee = UInt(version)
     return false
   } catch let error as CompilerParseError {
@@ -126,8 +134,8 @@ public func _RegexLiteralParsingFn(
   }
 }
 
-#else // canImport(_CompilerRegexParser)
+#else  // canImport(_CompilerRegexParser)
 
 #warning("Regex parsing is disabled")
 
-#endif // canImport(_CompilerRegexParser)
+#endif  // canImport(_CompilerRegexParser)