Swift SIL: add a utility protocol NoReflectionChildren for better debug output with lldb po

Let's lldb's `po` command not print any "internal" properties of the conforming type.
This is useful if the `description` already contains all the information of a type instance.

Author: eeckstein

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -40,19 +40,31 @@ public func assert(_ condition: Bool, file: StaticString = #fileID, line: UInt =
   }
 }
 
+//===----------------------------------------------------------------------===//
+//                            Debugging Utilities
+//===----------------------------------------------------------------------===//
+
+/// Let's lldb's `po` command not print any "internal" properties of the conforming type.
+///
+/// This is useful if the `description` already contains all the information of a type instance.
+public protocol NoReflectionChildren : CustomReflectable { }
+
+public extension NoReflectionChildren {
+  var customMirror: Mirror { Mirror(self, children: []) }
+}
+
 
 //===----------------------------------------------------------------------===//
 //                              StringRef
 //===----------------------------------------------------------------------===//
 
-public struct StringRef : CustomStringConvertible, CustomReflectable {
+public struct StringRef : CustomStringConvertible, NoReflectionChildren {
   let _bridged: llvm.StringRef
 
   public init(bridged: llvm.StringRef) { self._bridged = bridged }
 
   public var string: String { _bridged.string }
   public var description: String { string }
-  public var customMirror: Mirror { Mirror(self, children: []) }
 
   public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
     let lhsBuffer = UnsafeBufferPointer<UInt8>(

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -46,7 +46,7 @@ import SIL
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
+struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
 
   /// The dominating begin block.
   let begin: BasicBlock
@@ -149,8 +149,6 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
       """
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     worklist.deinitialize()

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockWorklist.swift

@@ -20,7 +20,7 @@ import SIL
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct BasicBlockWorklist : CustomStringConvertible, CustomReflectable {
+struct BasicBlockWorklist : CustomStringConvertible, NoReflectionChildren {
   private var worklist: Stack<BasicBlock>
   private var pushedBlocks: BasicBlockSet
 
@@ -56,8 +56,6 @@ struct BasicBlockWorklist : CustomStringConvertible, CustomReflectable {
     """
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     pushedBlocks.deinitialize()

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -38,7 +38,7 @@ import SIL
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct InstructionRange : CustomStringConvertible, CustomReflectable {
+struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   /// The dominating begin instruction.
   let begin: Instruction
@@ -139,8 +139,6 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
       """
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     insertedInsts.deinitialize()

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -21,7 +21,7 @@ import OptimizerBridging
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct BasicBlockSet : CustomStringConvertible, CustomReflectable {
+struct BasicBlockSet : CustomStringConvertible, NoReflectionChildren {
 
   private let context: PassContext
   private let bridged: BridgedBasicBlockSet
@@ -52,7 +52,6 @@ struct BasicBlockSet : CustomStringConvertible, CustomReflectable {
     return "{" + blockNames.joined(separator: ", ") + "}"
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
@@ -68,7 +67,7 @@ struct BasicBlockSet : CustomStringConvertible, CustomReflectable {
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct ValueSet : CustomStringConvertible, CustomReflectable {
+struct ValueSet : CustomStringConvertible, NoReflectionChildren {
 
   private let context: PassContext
   private let bridged: BridgedNodeSet
@@ -113,8 +112,6 @@ struct ValueSet : CustomStringConvertible, CustomReflectable {
     return d
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     PassContext_freeNodeSet(context._bridged, bridged)
@@ -129,7 +126,7 @@ struct ValueSet : CustomStringConvertible, CustomReflectable {
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct InstructionSet : CustomStringConvertible, CustomReflectable {
+struct InstructionSet : CustomStringConvertible, NoReflectionChildren {
 
   private let context: PassContext
   private let bridged: BridgedNodeSet
@@ -165,8 +162,6 @@ struct InstructionSet : CustomStringConvertible, CustomReflectable {
     return d
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     PassContext_freeNodeSet(context._bridged, bridged)

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -13,7 +13,7 @@
 import SILBridging
 
 /// An operand of an instruction.
-public struct Operand : CustomStringConvertible, CustomReflectable {
+public struct Operand : CustomStringConvertible, NoReflectionChildren {
   fileprivate let bridged: BridgedOperand
 
   init(_ bridged: BridgedOperand) {
@@ -39,8 +39,6 @@ public struct Operand : CustomStringConvertible, CustomReflectable {
   public var isTypeDependent: Bool { Operand_isTypeDependent(bridged) != 0 }
 
   public var description: String { "operand #\(index) of \(instruction)" }
-  
-  public var customMirror: Mirror { Mirror(self, children: []) }
 }
 
 public struct OperandArray : RandomAccessCollection, CustomReflectable {

SwiftCompilerSources/Sources/SIL/SmallProjectionPath.swift

@@ -10,6 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Basic
+
 /// A small and very efficient representation of a projection path.
 ///
 /// A `SmallProjectionPath` can be parsed and printed in SIL syntax and parsed from Swift
@@ -37,7 +39,7 @@
 /// which means: it represents any number of any kind of projections.
 /// Though, it's very unlikely that the limit will be reached in real world scenarios.
 ///
-public struct SmallProjectionPath : CustomStringConvertible, CustomReflectable, Hashable {
+public struct SmallProjectionPath : Hashable, CustomStringConvertible, NoReflectionChildren {
 
   /// The physical representation of the path. The path components are stored in
   /// reverse order: the first path component is stored in the lowest bits (LSB),
@@ -403,8 +405,6 @@ public struct SmallProjectionPath : CustomStringConvertible, CustomReflectable,
     }
     return false
   }
-
-  public var customMirror: Mirror { Mirror(self, children: []) }
 }
 
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -13,7 +13,7 @@
 import Basic
 import SILBridging
 
-public struct Type : CustomStringConvertible, CustomReflectable {
+public struct Type : CustomStringConvertible, NoReflectionChildren {
   public let bridged: BridgedType
 
   public var isAddress: Bool { SILType_isAddress(bridged) != 0 }
@@ -53,8 +53,6 @@ public struct Type : CustomStringConvertible, CustomReflectable {
   public var description: String {
     String(_cxxString: SILType_debugDescription(bridged))
   }
-
-  public var customMirror: Mirror { Mirror(self, children: []) }
 }
 
 extension Type: Equatable {

SwiftCompilerSources/Sources/SIL/Utils.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Basic
 import SILBridging
 
 // Need to export "Basic" to make `Basic.assert` available in the Optimizer module.
@@ -93,9 +94,8 @@ public protocol HasShortDescription {
   var shortDescription: String { get }
 }
 
-private struct CustomMirrorChild : CustomStringConvertible, CustomReflectable {
+private struct CustomMirrorChild : CustomStringConvertible, NoReflectionChildren {
   public var description: String
-  public var customMirror: Mirror { Mirror(self, children: []) }
 
   public init(description: String) { self.description = description }
 }

SwiftCompilerSources/Sources/SIL/VTable.swift

@@ -12,12 +12,12 @@
 
 import SILBridging
 
-public struct VTable : CustomStringConvertible, CustomReflectable {
+public struct VTable : CustomStringConvertible, NoReflectionChildren {
   let bridged: BridgedVTable
 
   public init(bridged: BridgedVTable) { self.bridged = bridged }
 
-  public struct Entry : CustomStringConvertible, CustomReflectable {
+  public struct Entry : CustomStringConvertible, NoReflectionChildren {
     fileprivate let bridged: BridgedVTableEntry
 
     public var function: Function { SILVTableEntry_getFunction(bridged).function }
@@ -26,8 +26,6 @@ public struct VTable : CustomStringConvertible, CustomReflectable {
       let stdString = SILVTableEntry_debugDescription(bridged)
       return String(_cxxString: stdString)
     }
-
-    public var customMirror: Mirror { Mirror(self, children: []) }
   }
 
   public struct EntryArray : BridgedRandomAccessCollection {
@@ -50,6 +48,4 @@ public struct VTable : CustomStringConvertible, CustomReflectable {
     let stdString = SILVTable_debugDescription(bridged)
     return String(_cxxString: stdString)
   }
-
-  public var customMirror: Mirror { Mirror(self, children: []) }
 }