         parentCollectionStatus: collectionStatus,
         refsAlreadySeen: &refsAlreadySeen,
         maxItemCounter: &maxItemCounter,
-        targetStream: &targetStream)
+        target: &target)
       printedElements += 1
     }
   }
 
-  // LLDB uses this function in expressions, and if it is inlined the resulting
-  // LLVM IR is enormous.  As a result, to improve LLDB performance we are not
-  // making it @inlinable.
   public static func stringForPrintObject(_ value: Any) -> String {
     var maxItemCounter = Int.max
     var refs = Set<ObjectIdentifier>()
-    var targetStream = ""
+    var target = ""
 
     printForDebuggerImpl(
       value: value,

      indent: 0,
      maxDepth: maxItemCounter,
      isRoot: true,
      parentCollectionStatus: .NotACollection,
      refsAlreadySeen: &refs,
      maxItemCounter: &maxItemCounter,
      targetStream: &targetStream)

    return targetStream
  }
}

@inline(never)
public
func _stringForPrintObject(_ value: Any) -> String {
  return _DebuggerSupport.stringForPrintObject(value)
}

@inline(never)
public
func _debuggerTestingCheckExpect(_ checked_value: String,
                                 _ expected_value: String) {}

// Utilities to get refcount(s) of class objects.
@_silgen_name("swift_retainCount")


import SwiftShims

@_frozen // namespace
public enum _DebuggerSupport {
  private enum CollectionStatus {
    case notACollection
    case collectionOfElements
    case collectionOfPairs
    case element
    case pair
    case elementOfPair
  
    internal var isCollection: Bool {
      return self != .notACollection
    }
  
    internal func getChildStatus(child: Mirror) -> CollectionStatus {
      let disposition = child.displayStyle
    
      if disposition == .collection { return .collectionOfElements }
      if disposition == .dictionary { return .collectionOfPairs }
      if disposition == .set { return .collectionOfElements }
    
      if self == .collectionOfElements { return .element }
      if self == .collectionOfPairs { return .pair }
      if self == .pair { return .elementOfPair }
    
      return .notACollection
    }
  }

  private static func isClass(_ value: Any) -> Bool {
    return type(of: value) is AnyClass
  }
  
  private static func checkValue<T>(
    _ value: Any,
    ifClass: (AnyObject) -> T,
    otherwise: () -> T
