Merge pull request #70258 from rintaro/astgen-internal

rintaro · web-flow · commit 290d3094fa6a · 2023-12-06T09:05:25.000-08:00
[ASTGen] Small cleanups
diff --git a/lib/ASTGen/Sources/ASTGen/ASTGen.swift b/lib/ASTGen/Sources/ASTGen/ASTGen.swift
@@ -18,12 +18,6 @@ import ParseBridging
 
 import struct SwiftDiagnostics.Diagnostic
 
-extension UnsafePointer {
-  public var raw: UnsafeMutableRawPointer {
-    UnsafeMutableRawPointer(mutating: self)
-  }
-}
-
 enum ASTNode {
   case decl(BridgedDecl)
   case stmt(BridgedStmt)
@@ -102,7 +96,7 @@ struct ASTGenVisitor {
     self.legacyParse = legacyParser
   }
 
-  public func generate(sourceFile node: SourceFileSyntax) -> [BridgedDecl] {
+  func generate(sourceFile node: SourceFileSyntax) -> [BridgedDecl] {
     var out = [BridgedDecl]()
 
     for element in node.statements {
@@ -129,8 +123,6 @@ struct ASTGenVisitor {
           endLoc: loc
         )
         out.append(topLevelDecl.asDecl)
-      default:
-        fatalError("Top level nodes must be decls, stmts, or exprs.")
       }
     }
 
@@ -241,15 +233,15 @@ extension ASTGenVisitor {
 // Misc visits.
 // TODO: Some of these are called within a single file/method; we may want to move them to the respective files.
 extension ASTGenVisitor {
-  public func generate(memberBlockItem node: MemberBlockItemSyntax) -> BridgedDecl {
+  func generate(memberBlockItem node: MemberBlockItemSyntax) -> BridgedDecl {
     generate(decl: node.decl)
   }
 
-  public func generate(initializerClause node: InitializerClauseSyntax) -> BridgedExpr {
+  func generate(initializerClause node: InitializerClauseSyntax) -> BridgedExpr {
     generate(expr: node.value)
   }
 
-  public func generate(conditionElement node: ConditionElementSyntax) -> ASTNode {
+  func generate(conditionElement node: ConditionElementSyntax) -> ASTNode {
     // FIXME: returning ASTNode is wrong, non-expression conditions are not ASTNode.
     switch node.condition {
     case .availability(_):
@@ -264,7 +256,7 @@ extension ASTGenVisitor {
     fatalError("unimplemented")
   }
 
-  public func generate(codeBlockItem node: CodeBlockItemSyntax) -> ASTNode {
+  func generate(codeBlockItem node: CodeBlockItemSyntax) -> ASTNode {
     switch node.item {
     case .decl(let node):
       return .decl(self.generate(decl: node))
@@ -275,7 +267,7 @@ extension ASTGenVisitor {
     }
   }
 
-  public func generate(arrayElement node: ArrayElementSyntax) -> BridgedExpr {
+  func generate(arrayElement node: ArrayElementSyntax) -> BridgedExpr {
     generate(expr: node.expression)
   }
 
diff --git a/lib/ASTGen/Sources/ASTGen/Decls.swift b/lib/ASTGen/Sources/ASTGen/Decls.swift
@@ -72,7 +72,7 @@ extension ASTGenVisitor {
     return self.generateWithLegacy(node)
   }
 
-  public func generate(typeAliasDecl node: TypeAliasDeclSyntax) -> BridgedTypeAliasDecl {
+  func generate(typeAliasDecl node: TypeAliasDeclSyntax) -> BridgedTypeAliasDecl {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     return .createParsed(
@@ -88,7 +88,7 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(enumDecl node: EnumDeclSyntax) -> BridgedNominalTypeDecl {
+  func generate(enumDecl node: EnumDeclSyntax) -> BridgedNominalTypeDecl {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedEnumDecl.createParsed(
@@ -113,7 +113,7 @@ extension ASTGenVisitor {
     return decl
   }
 
-  public func generate(structDecl node: StructDeclSyntax) -> BridgedNominalTypeDecl {
+  func generate(structDecl node: StructDeclSyntax) -> BridgedNominalTypeDecl {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedStructDecl.createParsed(
@@ -138,7 +138,7 @@ extension ASTGenVisitor {
     return decl
   }
 
-  public func generate(classDecl node: ClassDeclSyntax) -> BridgedNominalTypeDecl {
+  func generate(classDecl node: ClassDeclSyntax) -> BridgedNominalTypeDecl {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedClassDecl.createParsed(
@@ -164,7 +164,7 @@ extension ASTGenVisitor {
     return decl
   }
 
-  public func generate(actorDecl node: ActorDeclSyntax) -> BridgedNominalTypeDecl {
+  func generate(actorDecl node: ActorDeclSyntax) -> BridgedNominalTypeDecl {
     let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedClassDecl.createParsed(
@@ -288,7 +288,7 @@ extension ASTGenVisitor {
 // MARK: - AbstractStorageDecl
 
 extension ASTGenVisitor {
-  public func generate(variableDecl node: VariableDeclSyntax) -> BridgedPatternBindingDecl {
+  func generate(variableDecl node: VariableDeclSyntax) -> BridgedPatternBindingDecl {
     let pattern = generate(pattern: node.bindings.first!.pattern)
     let initializer = generate(initializerClause: node.bindings.first!.initializer!)
 
@@ -310,7 +310,7 @@ extension ASTGenVisitor {
 // MARK: - AbstractFunctionDecl
 
 extension ASTGenVisitor {
-  public func generate(functionDecl node: FunctionDeclSyntax) -> BridgedFuncDecl {
+  func generate(functionDecl node: FunctionDeclSyntax) -> BridgedFuncDecl {
     // FIXME: Compute this location
     let staticLoc: BridgedSourceLoc = nil
 
diff --git a/lib/ASTGen/Sources/ASTGen/Exprs.swift b/lib/ASTGen/Sources/ASTGen/Exprs.swift
@@ -199,7 +199,7 @@ extension ASTGenVisitor {
     preconditionFailure("isExprMigrated() mismatch")
   }
 
-  public func generate(arrowExpr node: ArrowExprSyntax) -> BridgedArrowExpr {
+  func generate(arrowExpr node: ArrowExprSyntax) -> BridgedArrowExpr {
     let asyncLoc: BridgedSourceLoc
     let throwsLoc: BridgedSourceLoc
     let thrownTypeExpr: BridgedNullableExpr
@@ -231,15 +231,15 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(assignmentExpr node: AssignmentExprSyntax) -> BridgedAssignExpr {
+  func generate(assignmentExpr node: AssignmentExprSyntax) -> BridgedAssignExpr {
     return .createParsed(self.ctx, equalsLoc: self.generateSourceLoc(node.equal))
   }
 
-  public func generate(binaryOperatorExpr node: BinaryOperatorExprSyntax) -> BridgedUnresolvedDeclRefExpr {
+  func generate(binaryOperatorExpr node: BinaryOperatorExprSyntax) -> BridgedUnresolvedDeclRefExpr {
     return createOperatorRefExpr(token: node.operator, kind: .binaryOperator)
   }
 
-  public func generate(closureExpr node: ClosureExprSyntax) -> BridgedClosureExpr {
+  func generate(closureExpr node: ClosureExprSyntax) -> BridgedClosureExpr {
     let body = BridgedBraceStmt.createParsed(
       self.ctx,
       lBraceLoc: self.generateSourceLoc(node.leftBrace),
@@ -251,7 +251,7 @@ extension ASTGenVisitor {
     return .createParsed(self.ctx, declContext: self.declContext, body: body)
   }
 
-  public func generate(functionCallExpr node: FunctionCallExprSyntax) -> BridgedCallExpr {
+  func generate(functionCallExpr node: FunctionCallExprSyntax) -> BridgedCallExpr {
     if !node.arguments.isEmpty || node.trailingClosure == nil {
       if node.leftParen == nil {
         self.diagnose(
@@ -333,7 +333,7 @@ extension ASTGenVisitor {
     }
   }
 
-  public func generate(declReferenceExpr node: DeclReferenceExprSyntax) -> BridgedUnresolvedDeclRefExpr {
+  func generate(declReferenceExpr node: DeclReferenceExprSyntax) -> BridgedUnresolvedDeclRefExpr {
     let nameAndLoc = createDeclNameRef(declReferenceExpr: node)
     return .createParsed(
       self.ctx,
@@ -343,11 +343,11 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(discardAssignmentExpr node: DiscardAssignmentExprSyntax) -> BridgedDiscardAssignmentExpr {
+  func generate(discardAssignmentExpr node: DiscardAssignmentExprSyntax) -> BridgedDiscardAssignmentExpr {
     return .createParsed(self.ctx, loc: self.generateSourceLoc(node.wildcard))
   }
 
-  public func generate(memberAccessExpr node: MemberAccessExprSyntax) -> BridgedExpr {
+  func generate(memberAccessExpr node: MemberAccessExprSyntax) -> BridgedExpr {
     let nameAndLoc = createDeclNameRef(declReferenceExpr: node.declName)
 
     if let base = node.base {
@@ -368,7 +368,7 @@ extension ASTGenVisitor {
     }
   }
 
-  public func generate(ifExpr node: IfExprSyntax) -> BridgedSingleValueStmtExpr {
+  func generate(ifExpr node: IfExprSyntax) -> BridgedSingleValueStmtExpr {
     let stmt = makeIfStmt(node).asStmt
 
     // Wrap in a SingleValueStmtExpr to embed as an expression.
@@ -380,7 +380,7 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(postfixOperatorExpr node: PostfixOperatorExprSyntax) -> BridgedPostfixUnaryExpr {
+  func generate(postfixOperatorExpr node: PostfixOperatorExprSyntax) -> BridgedPostfixUnaryExpr {
     return .createParsed(
       self.ctx,
       operator: self.createOperatorRefExpr(
@@ -391,7 +391,7 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(prefixOperatorExpr node: PrefixOperatorExprSyntax) -> BridgedPrefixUnaryExpr {
+  func generate(prefixOperatorExpr node: PrefixOperatorExprSyntax) -> BridgedPrefixUnaryExpr {
     return .createParsed(
       self.ctx,
       operator: self.createOperatorRefExpr(
@@ -402,7 +402,7 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(sequenceExpr node: SequenceExprSyntax) -> BridgedExpr {
+  func generate(sequenceExpr node: SequenceExprSyntax) -> BridgedExpr {
     assert(
       !node.elements.count.isMultiple(of: 2),
       "SequenceExpr must have odd number of elements"
@@ -458,18 +458,18 @@ extension ASTGenVisitor {
     ).asExpr
   }
 
-  public func generate(tupleExpr node: TupleExprSyntax) -> BridgedTupleExpr {
+  func generate(tupleExpr node: TupleExprSyntax) -> BridgedTupleExpr {
     return self.generate(labeledExprList: node.elements, leftParen: node.leftParen, rightParen: node.rightParen)
   }
 
-  public func generate(typeExpr node: TypeExprSyntax) -> BridgedTypeExpr {
+  func generate(typeExpr node: TypeExprSyntax) -> BridgedTypeExpr {
     return .createParsed(
       self.ctx,
       type: self.generate(type: node.type)
     )
   }
 
-  public func generate(unresolvedAsExpr node: UnresolvedAsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedExpr {
+  func generate(unresolvedAsExpr node: UnresolvedAsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedExpr {
     let type = self.generate(type: typeNode.type)
     let asLoc = self.generateSourceLoc(node.asKeyword)
 
@@ -499,15 +499,15 @@ extension ASTGenVisitor {
     }
   }
 
-  public func generate(unresolvedIsExpr node: UnresolvedIsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedIsExpr {
+  func generate(unresolvedIsExpr node: UnresolvedIsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedIsExpr {
     return .createParsed(
       self.ctx,
       isLoc: self.generateSourceLoc(node.isKeyword),
       type: self.generate(type: typeNode.type)
     )
   }
 
-  public func generate(unresolvedTernaryExpr node: UnresolvedTernaryExprSyntax) -> BridgedTernaryExpr {
+  func generate(unresolvedTernaryExpr node: UnresolvedTernaryExprSyntax) -> BridgedTernaryExpr {
     return .createParsed(
       self.ctx,
       questionLoc: self.generateSourceLoc(node.questionMark),
diff --git a/lib/ASTGen/Sources/ASTGen/Literals.swift b/lib/ASTGen/Sources/ASTGen/Literals.swift
@@ -14,7 +14,7 @@ import ASTBridging
 import SwiftSyntax
 
 extension ASTGenVisitor {
-  public func generate(stringLiteralExpr node: StringLiteralExprSyntax) -> BridgedStringLiteralExpr {
+  func generate(stringLiteralExpr node: StringLiteralExprSyntax) -> BridgedStringLiteralExpr {
     let openDelimiterOrQuoteLoc = self.generateSourceLoc(node.openingPounds ?? node.openingQuote)
 
     // FIXME: Handle interpolated strings.
@@ -25,7 +25,7 @@ extension ASTGenVisitor {
     }
   }
 
-  public func generate(integerLiteralExpr node: IntegerLiteralExprSyntax) -> BridgedIntegerLiteralExpr {
+  func generate(integerLiteralExpr node: IntegerLiteralExprSyntax) -> BridgedIntegerLiteralExpr {
     // FIXME: Avoid 'String' instantiation
     // FIXME: Strip '_'.
     var segment = node.literal.text
@@ -38,7 +38,7 @@ extension ASTGenVisitor {
     }
   }
 
-  public func generate(booleanLiteralExpr node: BooleanLiteralExprSyntax) -> BridgedBooleanLiteralExpr {
+  func generate(booleanLiteralExpr node: BooleanLiteralExprSyntax) -> BridgedBooleanLiteralExpr {
     let value = node.literal.tokenKind == .keyword(.true)
     return .createParsed(
       ctx,
@@ -47,7 +47,7 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(arrayExpr node: ArrayExprSyntax) -> BridgedArrayExpr {
+  func generate(arrayExpr node: ArrayExprSyntax) -> BridgedArrayExpr {
     let expressions = node.elements.lazy.map(self.generate)
 
     let commaLocations = node.elements.compactMap(in: self) {
diff --git a/lib/ASTGen/Sources/ASTGen/Stmts.swift b/lib/ASTGen/Sources/ASTGen/Stmts.swift
@@ -54,7 +54,7 @@ extension ASTGenVisitor {
     return self.generateWithLegacy(node)
   }
 
-  public func generate(codeBlock node: CodeBlockSyntax) -> BridgedBraceStmt {
+  func generate(codeBlock node: CodeBlockSyntax) -> BridgedBraceStmt {
     BridgedBraceStmt.createParsed(
       self.ctx,
       lBraceLoc: self.generateSourceLoc(node.leftBrace),
@@ -86,7 +86,7 @@ extension ASTGenVisitor {
     )
   }
 
-  public func generate(expressionStmt node: ExpressionStmtSyntax) -> BridgedStmt {
+  func generate(expressionStmt node: ExpressionStmtSyntax) -> BridgedStmt {
     switch Syntax(node.expression).as(SyntaxEnum.self) {
     case .ifExpr(let e):
       return makeIfStmt(e).asStmt
@@ -95,7 +95,7 @@ extension ASTGenVisitor {
     }
   }
 
-  public func generate(returnStmt node: ReturnStmtSyntax) -> BridgedReturnStmt {
+  func generate(returnStmt node: ReturnStmtSyntax) -> BridgedReturnStmt {
     .createParsed(
       self.ctx,
       returnKeywordLoc: self.generateSourceLoc(node.returnKeyword),
diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift

Original file line number	Diff line number	Diff line change
`@@ -18,12 +18,6 @@ import ParseBridging`
`18`	`18`
`19`	`19`	`import struct SwiftDiagnostics.Diagnostic`
`20`	`20`
`21`		`-extension UnsafePointer {`
`22`		`- public var raw: UnsafeMutableRawPointer {`
`23`		`- UnsafeMutableRawPointer(mutating: self)`
`24`		`- }`
`25`		`-}`
`26`		`-`
`27`	`21`	`enum ASTNode {`
`28`	`22`	`case decl(BridgedDecl)`
`29`	`23`	`case stmt(BridgedStmt)`
`@@ -102,7 +96,7 @@ struct ASTGenVisitor {`
`102`	`96`	`self.legacyParse = legacyParser`
`103`	`97`	`}`
`104`	`98`
`105`		`- public func generate(sourceFile node: SourceFileSyntax) -> [BridgedDecl] {`
	`99`	`+ func generate(sourceFile node: SourceFileSyntax) -> [BridgedDecl] {`
`106`	`100`	`var out = [BridgedDecl]()`
`107`	`101`
`108`	`102`	`for element in node.statements {`
`@@ -129,8 +123,6 @@ struct ASTGenVisitor {`
`129`	`123`	`endLoc: loc`
`130`	`124`	`)`
`131`	`125`	`out.append(topLevelDecl.asDecl)`
`132`		`- default:`
`133`		`- fatalError("Top level nodes must be decls, stmts, or exprs.")`
`134`	`126`	`}`
`135`	`127`	`}`
`136`	`128`
`@@ -241,15 +233,15 @@ extension ASTGenVisitor {`
`241`	`233`	`// Misc visits.`
`242`	`234`	`// TODO: Some of these are called within a single file/method; we may want to move them to the respective files.`
`243`	`235`	`extension ASTGenVisitor {`
`244`		`- public func generate(memberBlockItem node: MemberBlockItemSyntax) -> BridgedDecl {`
	`236`	`+ func generate(memberBlockItem node: MemberBlockItemSyntax) -> BridgedDecl {`
`245`	`237`	`generate(decl: node.decl)`
`246`	`238`	`}`
`247`	`239`
`248`		`- public func generate(initializerClause node: InitializerClauseSyntax) -> BridgedExpr {`
	`240`	`+ func generate(initializerClause node: InitializerClauseSyntax) -> BridgedExpr {`
`249`	`241`	`generate(expr: node.value)`
`250`	`242`	`}`
`251`	`243`
`252`		`- public func generate(conditionElement node: ConditionElementSyntax) -> ASTNode {`
	`244`	`+ func generate(conditionElement node: ConditionElementSyntax) -> ASTNode {`
`253`	`245`	`// FIXME: returning ASTNode is wrong, non-expression conditions are not ASTNode.`
`254`	`246`	`switch node.condition {`
`255`	`247`	`case .availability(_):`
`@@ -264,7 +256,7 @@ extension ASTGenVisitor {`
`264`	`256`	`fatalError("unimplemented")`
`265`	`257`	`}`
`266`	`258`
`267`		`- public func generate(codeBlockItem node: CodeBlockItemSyntax) -> ASTNode {`
	`259`	`+ func generate(codeBlockItem node: CodeBlockItemSyntax) -> ASTNode {`
`268`	`260`	`switch node.item {`
`269`	`261`	`case .decl(let node):`
`270`	`262`	`return .decl(self.generate(decl: node))`
`@@ -275,7 +267,7 @@ extension ASTGenVisitor {`
`275`	`267`	`}`
`276`	`268`	`}`
`277`	`269`
`278`		`- public func generate(arrayElement node: ArrayElementSyntax) -> BridgedExpr {`
	`270`	`+ func generate(arrayElement node: ArrayElementSyntax) -> BridgedExpr {`
`279`	`271`	`generate(expr: node.expression)`
`280`	`272`	`}`
`281`	`273`
Original file line number	Diff line number	Diff line change
`@@ -199,7 +199,7 @@ extension ASTGenVisitor {`
`199`	`199`	`preconditionFailure("isExprMigrated() mismatch")`
`200`	`200`	`}`
`201`	`201`
`202`		`- public func generate(arrowExpr node: ArrowExprSyntax) -> BridgedArrowExpr {`
	`202`	`+ func generate(arrowExpr node: ArrowExprSyntax) -> BridgedArrowExpr {`
`203`	`203`	`let asyncLoc: BridgedSourceLoc`
`204`	`204`	`let throwsLoc: BridgedSourceLoc`
`205`	`205`	`let thrownTypeExpr: BridgedNullableExpr`
`@@ -231,15 +231,15 @@ extension ASTGenVisitor {`
`231`	`231`	`)`
`232`	`232`	`}`
`233`	`233`
`234`		`- public func generate(assignmentExpr node: AssignmentExprSyntax) -> BridgedAssignExpr {`
	`234`	`+ func generate(assignmentExpr node: AssignmentExprSyntax) -> BridgedAssignExpr {`
`235`	`235`	`return .createParsed(self.ctx, equalsLoc: self.generateSourceLoc(node.equal))`
`236`	`236`	`}`
`237`	`237`
`238`		`- public func generate(binaryOperatorExpr node: BinaryOperatorExprSyntax) -> BridgedUnresolvedDeclRefExpr {`
	`238`	`+ func generate(binaryOperatorExpr node: BinaryOperatorExprSyntax) -> BridgedUnresolvedDeclRefExpr {`
`239`	`239`	`return createOperatorRefExpr(token: node.operator, kind: .binaryOperator)`
`240`	`240`	`}`
`241`	`241`
`242`		`- public func generate(closureExpr node: ClosureExprSyntax) -> BridgedClosureExpr {`
	`242`	`+ func generate(closureExpr node: ClosureExprSyntax) -> BridgedClosureExpr {`
`243`	`243`	`let body = BridgedBraceStmt.createParsed(`
`244`	`244`	`self.ctx,`
`245`	`245`	`lBraceLoc: self.generateSourceLoc(node.leftBrace),`
`@@ -251,7 +251,7 @@ extension ASTGenVisitor {`
`251`	`251`	`return .createParsed(self.ctx, declContext: self.declContext, body: body)`
`252`	`252`	`}`
`253`	`253`
`254`		`- public func generate(functionCallExpr node: FunctionCallExprSyntax) -> BridgedCallExpr {`
	`254`	`+ func generate(functionCallExpr node: FunctionCallExprSyntax) -> BridgedCallExpr {`
`255`	`255`	`if !node.arguments.isEmpty \|\| node.trailingClosure == nil {`
`256`	`256`	`if node.leftParen == nil {`
`257`	`257`	`self.diagnose(`
`@@ -333,7 +333,7 @@ extension ASTGenVisitor {`
`333`	`333`	`}`
`334`	`334`	`}`
`335`	`335`
`336`		`- public func generate(declReferenceExpr node: DeclReferenceExprSyntax) -> BridgedUnresolvedDeclRefExpr {`
	`336`	`+ func generate(declReferenceExpr node: DeclReferenceExprSyntax) -> BridgedUnresolvedDeclRefExpr {`
`337`	`337`	`let nameAndLoc = createDeclNameRef(declReferenceExpr: node)`
`338`	`338`	`return .createParsed(`
`339`	`339`	`self.ctx,`
`@@ -343,11 +343,11 @@ extension ASTGenVisitor {`
`343`	`343`	`)`
`344`	`344`	`}`
`345`	`345`
`346`		`- public func generate(discardAssignmentExpr node: DiscardAssignmentExprSyntax) -> BridgedDiscardAssignmentExpr {`
	`346`	`+ func generate(discardAssignmentExpr node: DiscardAssignmentExprSyntax) -> BridgedDiscardAssignmentExpr {`
`347`	`347`	`return .createParsed(self.ctx, loc: self.generateSourceLoc(node.wildcard))`
`348`	`348`	`}`
`349`	`349`
`350`		`- public func generate(memberAccessExpr node: MemberAccessExprSyntax) -> BridgedExpr {`
	`350`	`+ func generate(memberAccessExpr node: MemberAccessExprSyntax) -> BridgedExpr {`
`351`	`351`	`let nameAndLoc = createDeclNameRef(declReferenceExpr: node.declName)`
`352`	`352`
`353`	`353`	`if let base = node.base {`
`@@ -368,7 +368,7 @@ extension ASTGenVisitor {`
`368`	`368`	`}`
`369`	`369`	`}`
`370`	`370`
`371`		`- public func generate(ifExpr node: IfExprSyntax) -> BridgedSingleValueStmtExpr {`
	`371`	`+ func generate(ifExpr node: IfExprSyntax) -> BridgedSingleValueStmtExpr {`
`372`	`372`	`let stmt = makeIfStmt(node).asStmt`
`373`	`373`
`374`	`374`	`// Wrap in a SingleValueStmtExpr to embed as an expression.`
`@@ -380,7 +380,7 @@ extension ASTGenVisitor {`
`380`	`380`	`)`
`381`	`381`	`}`
`382`	`382`
`383`		`- public func generate(postfixOperatorExpr node: PostfixOperatorExprSyntax) -> BridgedPostfixUnaryExpr {`
	`383`	`+ func generate(postfixOperatorExpr node: PostfixOperatorExprSyntax) -> BridgedPostfixUnaryExpr {`
`384`	`384`	`return .createParsed(`
`385`	`385`	`self.ctx,`
`386`	`386`	`operator: self.createOperatorRefExpr(`
`@@ -391,7 +391,7 @@ extension ASTGenVisitor {`
`391`	`391`	`)`
`392`	`392`	`}`
`393`	`393`
`394`		`- public func generate(prefixOperatorExpr node: PrefixOperatorExprSyntax) -> BridgedPrefixUnaryExpr {`
	`394`	`+ func generate(prefixOperatorExpr node: PrefixOperatorExprSyntax) -> BridgedPrefixUnaryExpr {`
`395`	`395`	`return .createParsed(`
`396`	`396`	`self.ctx,`
`397`	`397`	`operator: self.createOperatorRefExpr(`
`@@ -402,7 +402,7 @@ extension ASTGenVisitor {`
`402`	`402`	`)`
`403`	`403`	`}`
`404`	`404`
`405`		`- public func generate(sequenceExpr node: SequenceExprSyntax) -> BridgedExpr {`
	`405`	`+ func generate(sequenceExpr node: SequenceExprSyntax) -> BridgedExpr {`
`406`	`406`	`assert(`
`407`	`407`	`!node.elements.count.isMultiple(of: 2),`
`408`	`408`	`"SequenceExpr must have odd number of elements"`
`@@ -458,18 +458,18 @@ extension ASTGenVisitor {`
`458`	`458`	`).asExpr`
`459`	`459`	`}`
`460`	`460`
`461`		`- public func generate(tupleExpr node: TupleExprSyntax) -> BridgedTupleExpr {`
	`461`	`+ func generate(tupleExpr node: TupleExprSyntax) -> BridgedTupleExpr {`
`462`	`462`	`return self.generate(labeledExprList: node.elements, leftParen: node.leftParen, rightParen: node.rightParen)`
`463`	`463`	`}`
`464`	`464`
`465`		`- public func generate(typeExpr node: TypeExprSyntax) -> BridgedTypeExpr {`
	`465`	`+ func generate(typeExpr node: TypeExprSyntax) -> BridgedTypeExpr {`
`466`	`466`	`return .createParsed(`
`467`	`467`	`self.ctx,`
`468`	`468`	`type: self.generate(type: node.type)`
`469`	`469`	`)`
`470`	`470`	`}`
`471`	`471`
`472`		`- public func generate(unresolvedAsExpr node: UnresolvedAsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedExpr {`
	`472`	`+ func generate(unresolvedAsExpr node: UnresolvedAsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedExpr {`
`473`	`473`	`let type = self.generate(type: typeNode.type)`
`474`	`474`	`let asLoc = self.generateSourceLoc(node.asKeyword)`
`475`	`475`
`@@ -499,15 +499,15 @@ extension ASTGenVisitor {`
`499`	`499`	`}`
`500`	`500`	`}`
`501`	`501`
`502`		`- public func generate(unresolvedIsExpr node: UnresolvedIsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedIsExpr {`
	`502`	`+ func generate(unresolvedIsExpr node: UnresolvedIsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedIsExpr {`
`503`	`503`	`return .createParsed(`
`504`	`504`	`self.ctx,`
`505`	`505`	`isLoc: self.generateSourceLoc(node.isKeyword),`
`506`	`506`	`type: self.generate(type: typeNode.type)`
`507`	`507`	`)`
`508`	`508`	`}`
`509`	`509`
`510`		`- public func generate(unresolvedTernaryExpr node: UnresolvedTernaryExprSyntax) -> BridgedTernaryExpr {`
	`510`	`+ func generate(unresolvedTernaryExpr node: UnresolvedTernaryExprSyntax) -> BridgedTernaryExpr {`
`511`	`511`	`return .createParsed(`
`512`	`512`	`self.ctx,`
`513`	`513`	`questionLoc: self.generateSourceLoc(node.questionMark),`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ import ASTBridging`
`14`	`14`	`import SwiftSyntax`
`15`	`15`
`16`	`16`	`extension ASTGenVisitor {`
`17`		`- public func generate(stringLiteralExpr node: StringLiteralExprSyntax) -> BridgedStringLiteralExpr {`
	`17`	`+ func generate(stringLiteralExpr node: StringLiteralExprSyntax) -> BridgedStringLiteralExpr {`
`18`	`18`	`let openDelimiterOrQuoteLoc = self.generateSourceLoc(node.openingPounds ?? node.openingQuote)`
`19`	`19`
`20`	`20`	`// FIXME: Handle interpolated strings.`
`@@ -25,7 +25,7 @@ extension ASTGenVisitor {`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`- public func generate(integerLiteralExpr node: IntegerLiteralExprSyntax) -> BridgedIntegerLiteralExpr {`
	`28`	`+ func generate(integerLiteralExpr node: IntegerLiteralExprSyntax) -> BridgedIntegerLiteralExpr {`
`29`	`29`	`// FIXME: Avoid 'String' instantiation`
`30`	`30`	`// FIXME: Strip '_'.`
`31`	`31`	`var segment = node.literal.text`
`@@ -38,7 +38,7 @@ extension ASTGenVisitor {`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`		`- public func generate(booleanLiteralExpr node: BooleanLiteralExprSyntax) -> BridgedBooleanLiteralExpr {`
	`41`	`+ func generate(booleanLiteralExpr node: BooleanLiteralExprSyntax) -> BridgedBooleanLiteralExpr {`
`42`	`42`	`let value = node.literal.tokenKind == .keyword(.true)`
`43`	`43`	`return .createParsed(`
`44`	`44`	`ctx,`
`@@ -47,7 +47,7 @@ extension ASTGenVisitor {`
`47`	`47`	`)`
`48`	`48`	`}`
`49`	`49`
`50`		`- public func generate(arrayExpr node: ArrayExprSyntax) -> BridgedArrayExpr {`
	`50`	`+ func generate(arrayExpr node: ArrayExprSyntax) -> BridgedArrayExpr {`
`51`	`51`	`let expressions = node.elements.lazy.map(self.generate)`
`52`	`52`
`53`	`53`	`let commaLocations = node.elements.compactMap(in: self) {`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ extension ASTGenVisitor {`
`54`	`54`	`return self.generateWithLegacy(node)`
`55`	`55`	`}`
`56`	`56`
`57`		`- public func generate(codeBlock node: CodeBlockSyntax) -> BridgedBraceStmt {`
	`57`	`+ func generate(codeBlock node: CodeBlockSyntax) -> BridgedBraceStmt {`
`58`	`58`	`BridgedBraceStmt.createParsed(`
`59`	`59`	`self.ctx,`
`60`	`60`	`lBraceLoc: self.generateSourceLoc(node.leftBrace),`
`@@ -86,7 +86,7 @@ extension ASTGenVisitor {`
`86`	`86`	`)`
`87`	`87`	`}`
`88`	`88`
`89`		`- public func generate(expressionStmt node: ExpressionStmtSyntax) -> BridgedStmt {`
	`89`	`+ func generate(expressionStmt node: ExpressionStmtSyntax) -> BridgedStmt {`
`90`	`90`	`switch Syntax(node.expression).as(SyntaxEnum.self) {`
`91`	`91`	`case .ifExpr(let e):`
`92`	`92`	`return makeIfStmt(e).asStmt`
`@@ -95,7 +95,7 @@ extension ASTGenVisitor {`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`- public func generate(returnStmt node: ReturnStmtSyntax) -> BridgedReturnStmt {`
	`98`	`+ func generate(returnStmt node: ReturnStmtSyntax) -> BridgedReturnStmt {`
`99`	`99`	`.createParsed(`
`100`	`100`	`self.ctx,`
`101`	`101`	`returnKeywordLoc: self.generateSourceLoc(node.returnKeyword),`