SwiftCompilerSources: don't make anything public in the Optimizer module

eeckstein · eeckstein · commit 701a7f7275cf · 2024-10-02T07:10:28.000+02:00
The Optimizer module is a leave module. No other modules depend on it. Therefore nothing must be public in this module.
diff --git a/SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift b/SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift
@@ -692,7 +692,7 @@ private struct FindBeginBorrowWalker : ValueUseDefWalker {
   let beginBorrow: BorrowIntroducingInstruction
   var walkUpCache = WalkerCache<Path>()
 
-  public mutating func walkUp(value: Value, path: SmallProjectionPath) -> WalkResult {
+  mutating func walkUp(value: Value, path: SmallProjectionPath) -> WalkResult {
     if value == beginBorrow {
       return .abortWalk
     }
diff --git a/SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift b/SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift
@@ -13,7 +13,7 @@
 import OptimizerBridging
 import SIL
 
-public struct CalleeAnalysis {
+struct CalleeAnalysis {
   let bridged: BridgedCalleeAnalysis
 
   static func register() {
@@ -31,27 +31,27 @@ public struct CalleeAnalysis {
     )
   }
 
-  public func getCallees(callee: Value) -> FunctionArray? {
+  func getCallees(callee: Value) -> FunctionArray? {
     let bridgedFuncs = bridged.getCallees(callee.bridged)
     if bridgedFuncs.isIncomplete() {
       return nil
     }
     return FunctionArray(bridged: bridgedFuncs)
   }
 
-  public func getIncompleteCallees(callee: Value) -> FunctionArray {
+  func getIncompleteCallees(callee: Value) -> FunctionArray {
     return FunctionArray(bridged: bridged.getCallees(callee.bridged))
   }
 
-  public func getDestructor(ofExactType type: Type) -> Function? {
+  func getDestructor(ofExactType type: Type) -> Function? {
     let destructors = FunctionArray(bridged: bridged.getDestructors(type.bridged, /*isExactType*/ true))
     if destructors.count == 1 {
       return destructors[0]
     }
     return nil
   }
 
-  public func getDestructors(of type: Type) -> FunctionArray? {
+  func getDestructors(of type: Type) -> FunctionArray? {
     let bridgedDtors = bridged.getDestructors(type.bridged, /*isExactType*/ false)
     if bridgedDtors.isIncomplete() {
       return nil
@@ -60,11 +60,11 @@ public struct CalleeAnalysis {
   }
 
   /// Returns the global (i.e. not argument specific) side effects of an apply.
-  public func getSideEffects(ofApply apply: FullApplySite) -> SideEffects.GlobalEffects {
+  func getSideEffects(ofApply apply: FullApplySite) -> SideEffects.GlobalEffects {
     return getSideEffects(ofCallee: apply.callee)
   }
 
-  public func getSideEffects(ofCallee callee: Value) -> SideEffects.GlobalEffects {
+  func getSideEffects(ofCallee callee: Value) -> SideEffects.GlobalEffects {
     guard let callees = getCallees(callee: callee) else {
       return .worstEffects
     }
@@ -78,7 +78,7 @@ public struct CalleeAnalysis {
   }
 
   /// Returns the argument specific side effects of an apply.
-  public func getSideEffects(of apply: FullApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
+  func getSideEffects(of apply: FullApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
     var result = SideEffects.GlobalEffects()
     guard let calleeArgIdx = apply.calleeArgumentIndex(of: operand) else {
       return result
@@ -133,7 +133,7 @@ extension Instruction {
   ///
   /// Deinitialization barriers constrain variable lifetimes. Lexical
   /// end_borrow, destroy_value, and destroy_addr cannot be hoisted above them.
-  public final func isDeinitBarrier(_ analysis: CalleeAnalysis) -> Bool {
+  final func isDeinitBarrier(_ analysis: CalleeAnalysis) -> Bool {
     if let site = self as? FullApplySite {
       return site.isBarrier(analysis)
     }
@@ -147,19 +147,19 @@ extension Instruction {
   }
 }
 
-public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {
+struct FunctionArray : RandomAccessCollection, FormattedLikeArray {
   fileprivate let bridged: BridgedCalleeAnalysis.CalleeList
 
-  public var startIndex: Int { 0 }
-  public var endIndex: Int { bridged.getCount() }
+  var startIndex: Int { 0 }
+  var endIndex: Int { bridged.getCount() }
 
-  public subscript(_ index: Int) -> Function {
+  subscript(_ index: Int) -> Function {
     return bridged.getCallee(index).function
   }
 }
 // Bridging utilities
 
 extension BridgedCalleeAnalysis {
-  public var analysis: CalleeAnalysis { .init(bridged: self) }
+  var analysis: CalleeAnalysis { .init(bridged: self) }
 }
 
diff --git a/SwiftCompilerSources/Sources/Optimizer/Analysis/DeadEndBlocksAnalysis.swift b/SwiftCompilerSources/Sources/Optimizer/Analysis/DeadEndBlocksAnalysis.swift
@@ -13,10 +13,10 @@
 import OptimizerBridging
 import SIL
 
-public struct DeadEndBlocksAnalysis {
+struct DeadEndBlocksAnalysis {
   let bridged: BridgedDeadEndBlocksAnalysis
 
-  public func isDeadEnd(_ block: BasicBlock) -> Bool {
+  func isDeadEnd(_ block: BasicBlock) -> Bool {
     return bridged.isDeadEnd(block.bridged)
   }
 }
diff --git a/SwiftCompilerSources/Sources/Optimizer/Analysis/DominatorTree.swift b/SwiftCompilerSources/Sources/Optimizer/Analysis/DominatorTree.swift
@@ -13,7 +13,7 @@
 import SIL
 import OptimizerBridging
 
-public struct DominatorTree {
+struct DominatorTree {
   let bridged: BridgedDomTree
 }
 
diff --git a/SwiftCompilerSources/Sources/Optimizer/Analysis/PostDominatorTree.swift b/SwiftCompilerSources/Sources/Optimizer/Analysis/PostDominatorTree.swift
@@ -13,7 +13,7 @@
 import SIL
 import OptimizerBridging
 
-public struct PostDominatorTree {
+struct PostDominatorTree {
   let bridged: BridgedPostDomTree
 }
 
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift
@@ -1175,31 +1175,31 @@ private struct OrderedDict<Key: Hashable, Value> {
   private var valueIndexDict: [Key: Int] = [:]
   private var entryList: [(Key, Value)] = []
 
-  public subscript(key: Key) -> Value? {
+  subscript(key: Key) -> Value? {
     if let index = valueIndexDict[key] {
       return entryList[index].1
     }
     return nil
   }
 
-  public mutating func insert(key: Key, value: Value) {
+  mutating func insert(key: Key, value: Value) {
     if valueIndexDict[key] == nil {
       valueIndexDict[key] = entryList.count
       entryList.append((key, value))
     }
   }
 
-  public mutating func update(key: Key, value: Value) {
+  mutating func update(key: Key, value: Value) {
     if let index = valueIndexDict[key] {
       entryList[index].1 = value
     }
   }
 
-  public var keys: LazyMapSequence<Array<(Key, Value)>, Key> {
+  var keys: LazyMapSequence<Array<(Key, Value)>, Key> {
     entryList.lazy.map { $0.0 }
   }
 
-  public var values: LazyMapSequence<Array<(Key, Value)>, Value> {
+  var values: LazyMapSequence<Array<(Key, Value)>, Value> {
     entryList.lazy.map { $0.1 }
   }
 }
@@ -1298,11 +1298,11 @@ private struct CallSite {
   let applySite: ApplySite
   var closureArgDescriptors: [ClosureArgDescriptor] = []
 
-  public init(applySite: ApplySite) {
+  init(applySite: ApplySite) {
     self.applySite = applySite
   }
 
-  public mutating func appendClosureArgDescriptor(_ descriptor: ClosureArgDescriptor) {
+  mutating func appendClosureArgDescriptor(_ descriptor: ClosureArgDescriptor) {
     self.closureArgDescriptors.append(descriptor)
   }
 
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift
@@ -21,7 +21,7 @@ import OptimizerBridging
 struct ModulePassContext : Context, CustomStringConvertible {
   let _bridged: BridgedPassContext
 
-  public var description: String {
+  var description: String {
     return String(taking: _bridged.getModuleDescription())
   }
 
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/Passes.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/Passes.swift
@@ -17,8 +17,7 @@ struct FunctionPass {
   let name: String
   let runFunction: (Function, FunctionPassContext) -> ()
 
-  public init(name: String,
-              _ runFunction: @escaping (Function, FunctionPassContext) -> ()) {
+  init(name: String, _ runFunction: @escaping (Function, FunctionPassContext) -> ()) {
     self.name = name
     self.runFunction = runFunction
   }
@@ -35,8 +34,7 @@ struct ModulePass {
   let name: String
   let runFunction: (ModulePassContext) -> ()
 
-  public init(name: String,
-              _ runFunction: @escaping (ModulePassContext) -> ()) {
+  init(name: String, _ runFunction: @escaping (ModulePassContext) -> ()) {
     self.name = name
     self.runFunction = runFunction
   }
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/DiagnosticEngine.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/DiagnosticEngine.swift
@@ -15,38 +15,38 @@ import ASTBridging
 import Basic
 import SIL
 
-public typealias DiagID = BridgedDiagID
+typealias DiagID = BridgedDiagID
 
-public protocol DiagnosticArgument {
+protocol DiagnosticArgument {
   func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void)
 }
 extension String: DiagnosticArgument {
-  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     _withBridgedStringRef { fn(BridgedDiagnosticArgument($0)) }
   }
 }
 extension Int: DiagnosticArgument {
-  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     fn(BridgedDiagnosticArgument(self))
   }
 }
 extension Type: DiagnosticArgument {
-  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     fn(bridged.asDiagnosticArgument())
   }
 }
 extension DeclRef: DiagnosticArgument {
-  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     fn(bridged.asDiagnosticArgument())
   }
 }
 
-public struct DiagnosticFixIt {
-  public let start: SourceLoc
-  public let byteLength: Int
-  public let text: String
+struct DiagnosticFixIt {
+  let start: SourceLoc
+  let byteLength: Int
+  let text: String
 
-  public init(start: SourceLoc, byteLength: Int, replacement text: String) {
+  init(start: SourceLoc, byteLength: Int, replacement text: String) {
     self.start = start
     self.byteLength = byteLength
     self.text = text
@@ -62,20 +62,20 @@ public struct DiagnosticFixIt {
   }
 }
 
-public struct DiagnosticEngine {
+struct DiagnosticEngine {
   private let bridged: BridgedDiagnosticEngine
 
-  public init(bridged: BridgedDiagnosticEngine) {
+  init(bridged: BridgedDiagnosticEngine) {
     self.bridged = bridged
   }
-  public init?(bridged: BridgedNullableDiagnosticEngine) {
+  init?(bridged: BridgedNullableDiagnosticEngine) {
     guard let raw = bridged.raw else {
       return nil
     }
     self.bridged = BridgedDiagnosticEngine(raw: raw)
   }
 
-  public func diagnose(_ position: SourceLoc?,
+  func diagnose(_ position: SourceLoc?,
                        _ id: DiagID,
                        _ args: [DiagnosticArgument],
                        highlight: CharSourceRange? = nil,
@@ -131,7 +131,7 @@ public struct DiagnosticEngine {
     closure()
   }
 
-  public func diagnose(_ position: SourceLoc?,
+  func diagnose(_ position: SourceLoc?,
                        _ id: DiagID,
                        _ args: DiagnosticArgument...,
                        highlight: CharSourceRange? = nil,
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift
@@ -301,7 +301,7 @@ struct LocalVariableAccessMap: Collection, CustomStringConvertible {
 
   subscript(instruction: Instruction) -> LocalVariableAccessInfo? { accessMap[instruction] }
 
-  public var description: String {
+  var description: String {
     "Access map:\n" + map({String(describing: $0)}).joined(separator: "\n")
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -692,7 +692,7 @@ private struct FindBeginBorrowWalker : ValueUseDefWalker {`
`692`	`692`	`let beginBorrow: BorrowIntroducingInstruction`
`693`	`693`	`var walkUpCache = WalkerCache<Path>()`
`694`	`694`
`695`		`- public mutating func walkUp(value: Value, path: SmallProjectionPath) -> WalkResult {`
	`695`	`+ mutating func walkUp(value: Value, path: SmallProjectionPath) -> WalkResult {`
`696`	`696`	`if value == beginBorrow {`
`697`	`697`	`return .abortWalk`
`698`	`698`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`import OptimizerBridging`
`14`	`14`	`import SIL`
`15`	`15`
`16`		`-public struct CalleeAnalysis {`
	`16`	`+struct CalleeAnalysis {`
`17`	`17`	`let bridged: BridgedCalleeAnalysis`
`18`	`18`
`19`	`19`	`static func register() {`
`@@ -31,27 +31,27 @@ public struct CalleeAnalysis {`
`31`	`31`	`)`
`32`	`32`	`}`
`33`	`33`
`34`		`- public func getCallees(callee: Value) -> FunctionArray? {`
	`34`	`+ func getCallees(callee: Value) -> FunctionArray? {`
`35`	`35`	`let bridgedFuncs = bridged.getCallees(callee.bridged)`
`36`	`36`	`if bridgedFuncs.isIncomplete() {`
`37`	`37`	`return nil`
`38`	`38`	`}`
`39`	`39`	`return FunctionArray(bridged: bridgedFuncs)`
`40`	`40`	`}`
`41`	`41`
`42`		`- public func getIncompleteCallees(callee: Value) -> FunctionArray {`
	`42`	`+ func getIncompleteCallees(callee: Value) -> FunctionArray {`
`43`	`43`	`return FunctionArray(bridged: bridged.getCallees(callee.bridged))`
`44`	`44`	`}`
`45`	`45`
`46`		`- public func getDestructor(ofExactType type: Type) -> Function? {`
	`46`	`+ func getDestructor(ofExactType type: Type) -> Function? {`
`47`	`47`	`let destructors = FunctionArray(bridged: bridged.getDestructors(type.bridged, /isExactType/ true))`
`48`	`48`	`if destructors.count == 1 {`
`49`	`49`	`return destructors[0]`
`50`	`50`	`}`
`51`	`51`	`return nil`
`52`	`52`	`}`
`53`	`53`
`54`		`- public func getDestructors(of type: Type) -> FunctionArray? {`
	`54`	`+ func getDestructors(of type: Type) -> FunctionArray? {`
`55`	`55`	`let bridgedDtors = bridged.getDestructors(type.bridged, /isExactType/ false)`
`56`	`56`	`if bridgedDtors.isIncomplete() {`
`57`	`57`	`return nil`
`@@ -60,11 +60,11 @@ public struct CalleeAnalysis {`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`/// Returns the global (i.e. not argument specific) side effects of an apply.`
`63`		`- public func getSideEffects(ofApply apply: FullApplySite) -> SideEffects.GlobalEffects {`
	`63`	`+ func getSideEffects(ofApply apply: FullApplySite) -> SideEffects.GlobalEffects {`
`64`	`64`	`return getSideEffects(ofCallee: apply.callee)`
`65`	`65`	`}`
`66`	`66`
`67`		`- public func getSideEffects(ofCallee callee: Value) -> SideEffects.GlobalEffects {`
	`67`	`+ func getSideEffects(ofCallee callee: Value) -> SideEffects.GlobalEffects {`
`68`	`68`	`guard let callees = getCallees(callee: callee) else {`
`69`	`69`	`return .worstEffects`
`70`	`70`	`}`
`@@ -78,7 +78,7 @@ public struct CalleeAnalysis {`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`/// Returns the argument specific side effects of an apply.`
`81`		`- public func getSideEffects(of apply: FullApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {`
	`81`	`+ func getSideEffects(of apply: FullApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {`
`82`	`82`	`var result = SideEffects.GlobalEffects()`
`83`	`83`	`guard let calleeArgIdx = apply.calleeArgumentIndex(of: operand) else {`
`84`	`84`	`return result`
`@@ -133,7 +133,7 @@ extension Instruction {`
`133`	`133`	`///`
`134`	`134`	`/// Deinitialization barriers constrain variable lifetimes. Lexical`
`135`	`135`	`/// end_borrow, destroy_value, and destroy_addr cannot be hoisted above them.`
`136`		`- public final func isDeinitBarrier(_ analysis: CalleeAnalysis) -> Bool {`
	`136`	`+ final func isDeinitBarrier(_ analysis: CalleeAnalysis) -> Bool {`
`137`	`137`	`if let site = self as? FullApplySite {`
`138`	`138`	`return site.isBarrier(analysis)`
`139`	`139`	`}`
`@@ -147,19 +147,19 @@ extension Instruction {`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`150`		`-public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {`
	`150`	`+struct FunctionArray : RandomAccessCollection, FormattedLikeArray {`
`151`	`151`	`fileprivate let bridged: BridgedCalleeAnalysis.CalleeList`
`152`	`152`
`153`		`- public var startIndex: Int { 0 }`
`154`		`- public var endIndex: Int { bridged.getCount() }`
	`153`	`+ var startIndex: Int { 0 }`
	`154`	`+ var endIndex: Int { bridged.getCount() }`
`155`	`155`
`156`		`- public subscript(_ index: Int) -> Function {`
	`156`	`+ subscript(_ index: Int) -> Function {`
`157`	`157`	`return bridged.getCallee(index).function`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`	`// Bridging utilities`
`161`	`161`
`162`	`162`	`extension BridgedCalleeAnalysis {`
`163`		`- public var analysis: CalleeAnalysis { .init(bridged: self) }`
	`163`	`+ var analysis: CalleeAnalysis { .init(bridged: self) }`
`164`	`164`	`}`
`165`	`165`
Original file line number	Diff line number	Diff line change
`@@ -13,10 +13,10 @@`
`13`	`13`	`import OptimizerBridging`
`14`	`14`	`import SIL`
`15`	`15`
`16`		`-public struct DeadEndBlocksAnalysis {`
	`16`	`+struct DeadEndBlocksAnalysis {`
`17`	`17`	`let bridged: BridgedDeadEndBlocksAnalysis`
`18`	`18`
`19`		`- public func isDeadEnd(_ block: BasicBlock) -> Bool {`
	`19`	`+ func isDeadEnd(_ block: BasicBlock) -> Bool {`
`20`	`20`	`return bridged.isDeadEnd(block.bridged)`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1175,31 +1175,31 @@ private struct OrderedDict<Key: Hashable, Value> {`
`1175`	`1175`	`private var valueIndexDict: [Key: Int] = [:]`
`1176`	`1176`	`private var entryList: [(Key, Value)] = []`
`1177`	`1177`
`1178`		`- public subscript(key: Key) -> Value? {`
	`1178`	`+ subscript(key: Key) -> Value? {`
`1179`	`1179`	`if let index = valueIndexDict[key] {`
`1180`	`1180`	`return entryList[index].1`
`1181`	`1181`	`}`
`1182`	`1182`	`return nil`
`1183`	`1183`	`}`
`1184`	`1184`
`1185`		`- public mutating func insert(key: Key, value: Value) {`
	`1185`	`+ mutating func insert(key: Key, value: Value) {`
`1186`	`1186`	`if valueIndexDict[key] == nil {`
`1187`	`1187`	`valueIndexDict[key] = entryList.count`
`1188`	`1188`	`entryList.append((key, value))`
`1189`	`1189`	`}`
`1190`	`1190`	`}`
`1191`	`1191`
`1192`		`- public mutating func update(key: Key, value: Value) {`
	`1192`	`+ mutating func update(key: Key, value: Value) {`
`1193`	`1193`	`if let index = valueIndexDict[key] {`
`1194`	`1194`	`entryList[index].1 = value`
`1195`	`1195`	`}`
`1196`	`1196`	`}`
`1197`	`1197`
`1198`		`- public var keys: LazyMapSequence<Array<(Key, Value)>, Key> {`
	`1198`	`+ var keys: LazyMapSequence<Array<(Key, Value)>, Key> {`
`1199`	`1199`	`entryList.lazy.map { $0.0 }`
`1200`	`1200`	`}`
`1201`	`1201`
`1202`		`- public var values: LazyMapSequence<Array<(Key, Value)>, Value> {`
	`1202`	`+ var values: LazyMapSequence<Array<(Key, Value)>, Value> {`
`1203`	`1203`	`entryList.lazy.map { $0.1 }`
`1204`	`1204`	`}`
`1205`	`1205`	`}`
`@@ -1298,11 +1298,11 @@ private struct CallSite {`
`1298`	`1298`	`let applySite: ApplySite`
`1299`	`1299`	`var closureArgDescriptors: [ClosureArgDescriptor] = []`
`1300`	`1300`
`1301`		`- public init(applySite: ApplySite) {`
	`1301`	`+ init(applySite: ApplySite) {`
`1302`	`1302`	`self.applySite = applySite`
`1303`	`1303`	`}`
`1304`	`1304`
`1305`		`- public mutating func appendClosureArgDescriptor(_ descriptor: ClosureArgDescriptor) {`
	`1305`	`+ mutating func appendClosureArgDescriptor(_ descriptor: ClosureArgDescriptor) {`
`1306`	`1306`	`self.closureArgDescriptors.append(descriptor)`
`1307`	`1307`	`}`
`1308`	`1308`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ import OptimizerBridging`
`21`	`21`	`struct ModulePassContext : Context, CustomStringConvertible {`
`22`	`22`	`let _bridged: BridgedPassContext`
`23`	`23`
`24`		`- public var description: String {`
	`24`	`+ var description: String {`
`25`	`25`	`return String(taking: _bridged.getModuleDescription())`
`26`	`26`	`}`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -15,38 +15,38 @@ import ASTBridging`
`15`	`15`	`import Basic`
`16`	`16`	`import SIL`
`17`	`17`
`18`		`-public typealias DiagID = BridgedDiagID`
	`18`	`+typealias DiagID = BridgedDiagID`
`19`	`19`
`20`		`-public protocol DiagnosticArgument {`
	`20`	`+protocol DiagnosticArgument {`
`21`	`21`	`func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void)`
`22`	`22`	`}`
`23`	`23`	`extension String: DiagnosticArgument {`
`24`		`- public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
	`24`	`+ func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
`25`	`25`	`_withBridgedStringRef { fn(BridgedDiagnosticArgument($0)) }`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`extension Int: DiagnosticArgument {`
`29`		`- public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
	`29`	`+ func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
`30`	`30`	`fn(BridgedDiagnosticArgument(self))`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`extension Type: DiagnosticArgument {`
`34`		`- public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
	`34`	`+ func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
`35`	`35`	`fn(bridged.asDiagnosticArgument())`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`extension DeclRef: DiagnosticArgument {`
`39`		`- public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
	`39`	`+ func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {`
`40`	`40`	`fn(bridged.asDiagnosticArgument())`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`		`-public struct DiagnosticFixIt {`
`45`		`- public let start: SourceLoc`
`46`		`- public let byteLength: Int`
`47`		`- public let text: String`
	`44`	`+struct DiagnosticFixIt {`
	`45`	`+ let start: SourceLoc`
	`46`	`+ let byteLength: Int`
	`47`	`+ let text: String`
`48`	`48`
`49`		`- public init(start: SourceLoc, byteLength: Int, replacement text: String) {`
	`49`	`+ init(start: SourceLoc, byteLength: Int, replacement text: String) {`
`50`	`50`	`self.start = start`
`51`	`51`	`self.byteLength = byteLength`
`52`	`52`	`self.text = text`
`@@ -62,20 +62,20 @@ public struct DiagnosticFixIt {`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`		`-public struct DiagnosticEngine {`
	`65`	`+struct DiagnosticEngine {`
`66`	`66`	`private let bridged: BridgedDiagnosticEngine`
`67`	`67`
`68`		`- public init(bridged: BridgedDiagnosticEngine) {`
	`68`	`+ init(bridged: BridgedDiagnosticEngine) {`
`69`	`69`	`self.bridged = bridged`
`70`	`70`	`}`
`71`		`- public init?(bridged: BridgedNullableDiagnosticEngine) {`
	`71`	`+ init?(bridged: BridgedNullableDiagnosticEngine) {`
`72`	`72`	`guard let raw = bridged.raw else {`
`73`	`73`	`return nil`
`74`	`74`	`}`
`75`	`75`	`self.bridged = BridgedDiagnosticEngine(raw: raw)`
`76`	`76`	`}`
`77`	`77`
`78`		`- public func diagnose(_ position: SourceLoc?,`
	`78`	`+ func diagnose(_ position: SourceLoc?,`
`79`	`79`	`_ id: DiagID,`
`80`	`80`	`_ args: [DiagnosticArgument],`
`81`	`81`	`highlight: CharSourceRange? = nil,`
`@@ -131,7 +131,7 @@ public struct DiagnosticEngine {`
`131`	`131`	`closure()`
`132`	`132`	`}`
`133`	`133`
`134`		`- public func diagnose(_ position: SourceLoc?,`
	`134`	`+ func diagnose(_ position: SourceLoc?,`
`135`	`135`	`_ id: DiagID,`
`136`	`136`	`_ args: DiagnosticArgument...,`
`137`	`137`	`highlight: CharSourceRange? = nil,`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,7 @@ struct LocalVariableAccessMap: Collection, CustomStringConvertible {`
`301`	`301`
`302`	`302`	`subscript(instruction: Instruction) -> LocalVariableAccessInfo? { accessMap[instruction] }`
`303`	`303`
`304`		`- public var description: String {`
	`304`	`+ var description: String {`
`305`	`305`	`"Access map:\n" + map({String(describing: $0)}).joined(separator: "\n")`
`306`	`306`	`}`
`307`	`307`	`}`