nfc: std lib style tweaks

airspeedswift · airspeedswift · commit 501a4684f7c6 · 2020-05-29T08:31:04.000-07:00
diff --git a/tools/swiftdt/Sources/swiftdt/Inspector.swift b/tools/swiftdt/Sources/swiftdt/Inspector.swift
@@ -9,9 +9,8 @@ class Inspector {
   
   init?(pid: pid_t) {
     task = Self.findTask(pid, tryForkCorpse: false)
-    if task == 0 {
-      return nil
-    }
+    if task == 0 { return nil }
+
     symbolicator = CSSymbolicatorCreateWithTask(task)
     swiftCore = CSSymbolicatorGetSymbolOwnerWithNameAtTime(
       symbolicator, "libswiftCore.dylib", kCSNow)
@@ -95,7 +94,7 @@ class Inspector {
 }
 
 private func instance(_ context: UnsafeMutableRawPointer?) -> Inspector {
-  return Unmanaged.fromOpaque(context!).takeUnretainedValue()
+  Unmanaged.fromOpaque(context!).takeUnretainedValue()
 }
 
 private func QueryDataLayoutFn(context: UnsafeMutableRawPointer?,
@@ -116,25 +115,29 @@ private func ReadBytesFn(
   context: UnsafeMutableRawPointer?,
   address: swift_addr_t,
   size: UInt64,
-  outContext: UnsafeMutablePointer<UnsafeMutableRawPointer?>?) ->
-  UnsafeRawPointer? {
-  return task_peek(instance(context).task, address, size)
+  outContext: UnsafeMutablePointer<UnsafeMutableRawPointer?>?
+) -> UnsafeRawPointer? {
+  task_peek(instance(context).task, address, size)
 }
 
-private func GetStringLengthFn(context: UnsafeMutableRawPointer?,
-                               address: swift_addr_t) -> UInt64 {
+private func GetStringLengthFn(
+  context: UnsafeMutableRawPointer?,
+  address: swift_addr_t
+) -> UInt64 {
   let maybeStr = task_peek_string(instance(context).task, address)
   guard let str = maybeStr else { return 0 }
   return UInt64(strlen(str))
 }
 
-private func GetSymbolAddressFn(context: UnsafeMutableRawPointer?,
-                                name: UnsafePointer<CChar>?,
-                                length: UInt64) -> swift_addr_t {
+private func GetSymbolAddressFn(
+  context: UnsafeMutableRawPointer?,
+  name: UnsafePointer<CChar>?,
+  length: UInt64
+) -> swift_addr_t {
   let nameStr: String = name!.withMemoryRebound(to: UInt8.self,
-                                                capacity: Int(length), {
+                                                capacity: Int(length)) {
     let buffer = UnsafeBufferPointer(start: $0, count: Int(length))
     return String(decoding: buffer, as: UTF8.self)
-  })
+  }
   return instance(context).getAddr(symbolName: nameStr)
 }
diff --git a/tools/swiftdt/Sources/swiftdt/InterpolationExtensions.swift b/tools/swiftdt/Sources/swiftdt/InterpolationExtensions.swift
@@ -5,4 +5,4 @@ extension DefaultStringInterpolation {
     appendInterpolation("0x")
     appendInterpolation(String(hex, radix: 16))
   }
-}
+}
diff --git a/tools/swiftdt/Sources/swiftdt/RemoteMirrorExtensions.swift b/tools/swiftdt/Sources/swiftdt/RemoteMirrorExtensions.swift
@@ -27,31 +27,34 @@ extension SwiftReflectionContextRef {
   }
 
   func iterateConformanceCache(
-    call: (swift_reflection_ptr_t, swift_reflection_ptr_t) -> Void) throws {
-    var call = call
+    _ body: (swift_reflection_ptr_t, swift_reflection_ptr_t) -> Void
+  ) throws {
+    var body = body
     let errStr = swift_reflection_iterateConformanceCache(self, {
       let callPtr = $2!.bindMemory(to:
         ((swift_reflection_ptr_t, swift_reflection_ptr_t) -> Void).self,
         capacity: 1)
       callPtr.pointee($0, $1)
-    }, &call)
+    }, &body)
     try throwError(str: errStr)
   }
 
   func iterateMetadataAllocations(
-    call: (swift_metadata_allocation_t) -> Void) throws {
-    var call = call
+    _ body: (swift_metadata_allocation_t) -> Void
+  ) throws {
+    var body = body
     let errStr = swift_reflection_iterateMetadataAllocations(self, {
       let callPtr = $1!.bindMemory(to:
         ((swift_metadata_allocation_t) -> Void).self, capacity: 1)
       callPtr.pointee($0)
-    }, &call)
+    }, &body)
     try throwError(str: errStr)
   }
 
-  func metadataPointer(allocation: swift_metadata_allocation_t)
-    -> swift_reflection_ptr_t {
-    return swift_reflection_allocationMetadataPointer(self, allocation)
+  func metadataPointer(
+    allocation: swift_metadata_allocation_t
+  ) -> swift_reflection_ptr_t {
+    swift_reflection_allocationMetadataPointer(self, allocation)
   }
 
   private func throwError(str: UnsafePointer<CChar>?) throws {
diff --git a/tools/swiftdt/Sources/swiftdt/main.swift b/tools/swiftdt/Sources/swiftdt/main.swift
@@ -8,33 +8,33 @@ func argFail(_ message: String) -> Never {
 }
 
 func machErrStr(_ kr: kern_return_t) -> String {
-    let errStr = String(cString: mach_error_string(kr))
-    let errHex = String(kr, radix: 16)
-    return "\(errStr) (0x\(errHex))"
+  let errStr = String(cString: mach_error_string(kr))
+  let errHex = String(kr, radix: 16)
+  return "\(errStr) (0x\(errHex))"
 }
 
 func dumpConformanceCache(context: SwiftReflectionContextRef) throws {
-  try context.iterateConformanceCache(call: { type, proto in
+  try context.iterateConformanceCache { type, proto in
     let typeName = context.name(metadata: type) ?? "<unknown>"
     let protoName = context.name(proto: proto) ?? "<unknown>"
     print("Conformance: \(typeName): \(protoName)")
-  })
+  }
 }
 
 func dumpMetadataAllocations(context: SwiftReflectionContextRef) throws {
   var allocations: [swift_metadata_allocation_t] = []
   var metadatas: [swift_reflection_ptr_t] = []
-  try context.iterateMetadataAllocations(call: { allocation in
+  try context.iterateMetadataAllocations { allocation in
     allocations.append(allocation)
     print("Metadata allocation at: \(hex: allocation.Ptr) " + 
           "size: \(allocation.Size) tag: \(allocation.Tag)")
     let ptr = context.metadataPointer(allocation: allocation)
     if ptr != 0 {
       metadatas.append(ptr)
     }
-  })
+  }
 
-  allocations.sort(by: { $0.Ptr < $1.Ptr })
+  allocations.sort { $0.Ptr < $1.Ptr }
   for metadata in metadatas {
     let name = context.name(metadata: metadata) ?? "<unknown>"
     print("Metadata \(hex: metadata)")
@@ -50,8 +50,9 @@ func dumpMetadataAllocations(context: SwiftReflectionContextRef) throws {
   }
 }
 
-func makeReflectionContext(nameOrPid: String)
-  -> (Inspector, SwiftReflectionContextRef) {
+func makeReflectionContext(
+  nameOrPid: String
+) -> (Inspector, SwiftReflectionContextRef) {
   guard let pid = pidFromHint(nameOrPid) else {
     argFail("Cannot find pid/process \(nameOrPid)")
   }
@@ -60,28 +61,30 @@ func makeReflectionContext(nameOrPid: String)
     argFail("Failed to inspect pid \(pid) (are you running as root?)")
   }
 
-  guard let reflectionContext
-    = swift_reflection_createReflectionContextWithDataLayout(
+  guard let reflectionContext = swift_reflection_createReflectionContextWithDataLayout(
     inspector.passContext(),
     Inspector.Callbacks.QueryDataLayout,
     Inspector.Callbacks.Free,
     Inspector.Callbacks.ReadBytes,
     Inspector.Callbacks.GetStringLength,
-    Inspector.Callbacks.GetSymbolAddress) else {
+    Inspector.Callbacks.GetSymbolAddress
+  ) else {
     argFail("Failed to create reflection context")
   }
+
   return (inspector, reflectionContext)
 }
 
 func withReflectionContext(
   nameOrPid: String,
-  call: (SwiftReflectionContextRef) throws -> Void) throws {
+  _ body: (SwiftReflectionContextRef) throws -> Void
+) throws {
   let (inspector, context) = makeReflectionContext(nameOrPid: nameOrPid)
   defer {
     swift_reflection_destroyReflectionContext(context)
     inspector.destroyContext()
   }
-  try call(context)
+  try body(context)
 }
 
 struct Swiftdt: ParsableCommand {
diff --git a/tools/swiftdt/Sources/swiftdt/symbolication.swift b/tools/swiftdt/Sources/swiftdt/symbolication.swift
@@ -60,25 +60,30 @@ func pidFromHint(_ hint: String) -> pid_t? {
 }
 
 func CSSymbolicatorCreateWithTask(_ task: task_t) -> CSTypeRef {
-  return Sym.CSSymbolicatorCreateWithTask(task)
+  Sym.CSSymbolicatorCreateWithTask(task)
 }
 
-func CSSymbolicatorGetSymbolOwnerWithNameAtTime(_ symbolicator: CSTypeRef,
-                                                _ name: String,
-                                                _ time: CSMachineTime)
-                                                -> CSTypeRef {
-  return Sym.CSSymbolicatorGetSymbolOwnerWithNameAtTime(symbolicator, name, time)
+func CSSymbolicatorGetSymbolOwnerWithNameAtTime(
+	_ symbolicator: CSTypeRef,
+  _ name: String,
+  _ time: CSMachineTime
+) -> CSTypeRef {
+  Sym.CSSymbolicatorGetSymbolOwnerWithNameAtTime(symbolicator, name, time)
 }
 
 @discardableResult
-func CSSymbolOwnerForeachSymbol(_ symbolOwner: CSTypeRef,
-                                _ iterator: (CSTypeRef) -> Void) -> UInt {
-  return Sym.CSSymbolOwnerForeachSymbol(symbolOwner, iterator)
+func CSSymbolOwnerForeachSymbol(
+  _ symbolOwner: CSTypeRef,
+  _ iterator: (CSTypeRef) -> Void
+) -> UInt {
+  Sym.CSSymbolOwnerForeachSymbol(symbolOwner, iterator)
 }
 
-func CSSymbolOwnerGetSymbolWithMangledName(_ owner: CSTypeRef, _ name: String)
-  -> CSTypeRef {
-  return Sym.CSSymbolOwnerGetSymbolWithMangledName(owner, name)
+func CSSymbolOwnerGetSymbolWithMangledName(
+  _ owner: CSTypeRef, 
+  _ name: String
+) -> CSTypeRef {
+  Sym.CSSymbolOwnerGetSymbolWithMangledName(owner, name)
 }
 
 func CSSymbolGetName(_ sym: CSTypeRef) -> String? {
@@ -92,11 +97,11 @@ func CSSymbolGetMangledName(_ sym: CSTypeRef) -> String? {
 }
 
 func CSSymbolIsFunction(_ sym: CSTypeRef) -> Bool {
-  return Sym.CSSymbolIsFunction(sym)
+  Sym.CSSymbolIsFunction(sym)
 }
 
 func CSSymbolGetRange(_ sym: CSTypeRef) -> Range {
-  return Sym.CSSymbolGetRange(sym)
+  Sym.CSSymbolGetRange(sym)
 }
 
 func task_start_peeking(_ task: task_t) -> Bool {
@@ -109,8 +114,9 @@ func task_start_peeking(_ task: task_t) -> Bool {
   return false
 }
 
-func task_peek(_ task: task_t, _ start: mach_vm_address_t, _ size: mach_vm_size_t) ->
-  UnsafeRawPointer? {
+func task_peek(
+  _ task: task_t, _ start: mach_vm_address_t, _ size: mach_vm_size_t
+) -> UnsafeRawPointer? {
   var ptr: UnsafeRawPointer? = nil
   let result = Sym.task_peek(task, start, size, &ptr)
   if result != KERN_SUCCESS {
@@ -120,9 +126,10 @@ func task_peek(_ task: task_t, _ start: mach_vm_address_t, _ size: mach_vm_size_
   return ptr
 }
 
-func task_peek_string(_ task: task_t, _ addr: mach_vm_address_t) ->
-  UnsafeMutablePointer<CChar>? {
-  return Sym.task_peek_string(task, addr)
+func task_peek_string(
+  _ task: task_t, _ addr: mach_vm_address_t
+) -> UnsafeMutablePointer<CChar>? {
+  Sym.task_peek_string(task, addr)
 }
 
 func task_stop_peeking(_ task: task_t) {

Original file line number	Diff line number	Diff line change
`@@ -5,4 +5,4 @@ extension DefaultStringInterpolation {`
`5`	`5`	`appendInterpolation("0x")`
`6`	`6`	`appendInterpolation(String(hex, radix: 16))`
`7`	`7`	`}`
`8`		`-}`
	`8`	`+}`