Feature Request: CustomDumpReflectable without a Mirror

[rjchatfield]

I really appreciate the pretty printing of customDump(). However I'm having some challenges with using Mirror in some cases and would like to suggest a new API that prints like a displayStyle: .struct but allows me to explicitly override the typeName.

(Please ignore the protocol naming. I'll trust you guys to come up with something suitable)

extension MyType: CustomDumpValueRespresentable {
  var customDumpValue: CustomDumpValue {
    .init(
      typeName: if isButton ? "Button" : "MyType",
      children: [
        "child": child,
        ...
      ]
  }
}

Thanks.

[stephencelis]

Hey @rjchatfield! I'm going to convert this to a discussion, since we try to keep the issues area focussed on bugs with the library.

I believe there are several existing ways of achieving what you want here. The two that stick out the most:

1. One would be to use the CustomDumpRepresentable protocol instead. You could use it to swap in a private struct for dumping:

   extension MyType: CustomDumpRepresentable {
     var customDumpValue: Any {
       struct Button {
         var child: ...
       }
       struct MyType {
         var child: ...
       }
       return self.isButton
         ? Button(child: self.child, ...)
         : MyType(child: self.child, ...)
     }
   }

   It's admittedly more verbose, though it avoids string interpolation, etc.

2. The CustomDumpStringConvertible protocol could be used to return the string dump, instead:

   extension MyType: CustomDumpStringRepresentable {
     var customDumpDescription: String {
       let typeName = self.isButton ? "Button" : "MyType"
       var tupleDump = ""
       customDump((child: self.child, ...), to: & tupleDump)
       return "\(typeName)(tupleDump)"
     }
   }

   This may feel a bit "magical", but should be totally safe to do, and this one could even be abstracted away in your own type/protocol.

If you come up with a reasonable, repeatable way of handling the problem, please do share in the discussion! And if this is something that comes up enough, we can share the solution or include the solution in the library proper. For some reason, we haven't encountered this issue ourselves in the libraries and apps we use CustomDump in.

We already consider the three existing protocols to be a lot, so ideally we'd want to avoid introducing a fourth one to the library if we can.

[rjchatfield]

Thank you so much for the quick yet detailed reply. I'll see if that works in my case.

For more clarity, here is the example that stumped me.

func testAny() {
  class A {}    // base class
  class B: A {} // subclass

  let b        = B()
  let a  : A   = b // cast to base class
  let any: Any = b // case to `Any`

  XCTAssertEqual("\(Mirror(b  , children: []).subjectType)", "B")
  XCTAssertEqual("\(Mirror(a  , children: []).subjectType)", "A")
  XCTAssertEqual("\(Mirror(any, children: []).subjectType)", "Any")

  // Use _openExistential() to get type of `Any`
  func makeMirror(_ any: Any) -> Mirror {
    func _m<Subject>(_ subject: Subject) -> Mirror { Mirror(subject, children: []) }
    return _openExistential(any, do: _m)
  }

  XCTAssertEqual("\(makeMirror(b  ).subjectType)", "B")
  XCTAssertEqual("\(makeMirror(a  ).subjectType)", "A") // Not B... and this is my problem
  XCTAssertEqual("\(makeMirror(any).subjectType)", "B")
}

I am building up a tree of UIViews using my own wrapper type that holds each view as an Any, and wanted to use customDump() to pretty print them out. But because of the way I build up the tree, I'm losing the type info (eg. UIButton() is always printed as UIView()). Right now the best I can do is Mirror(view, children: [("type", type(of: view))] which gives me UIView(type: UIButton.self).

Do you know any special tricks I can use to work around this?

[stephencelis]

@rjchatfield Interesting!

Strangely enough, the library seems to print the subclass. Here's a test case that passes:

  func testSubclasses() {
    class A {}
    class B: A {}
    let b: A = B()
    var dump = ""
    customDump(
      b,
      to: &dump
    )
    XCTAssertNoDifference(
      dump,
      """
      DumpTests.B()
      """
    )
  }

I wonder if you can provide a more direct repro of the problem?

[iampatbrown]

@rjchatfield Changing your makeMirror(_:) helper to use Mirror(reflecting:) might be what you need. That is what customDump is using.

swift-custom-dump/Sources/CustomDump/CustomDumpReflectable.swift

Lines 127 to 131 in 366df37

	extension Mirror {
	init(customDumpReflecting subject: Any) {
	self = (subject as? CustomDumpReflectable)?.customDumpMirror ?? Mirror(reflecting: subject)
	}
	}

edit:
Come to think of it you could probably just use Mirror(reflecting:) instead of makeMirror(_:):

XCTAssertEqual("\(Mirror(reflecting: b).subjectType)", "B")
XCTAssertEqual("\(Mirror(reflecting: a).subjectType)", "B") 
XCTAssertEqual("\(Mirror(reflecting: any).subjectType)", "B")

[rjchatfield]

@stephencelis Yes, it works in that case. The problem I'm facing is if I conform to CustomDumpReflectable and return Mirror(self.value, ...).
@iampatbrown Thanks, but I want to inject a custom set of Mirror.Children rather than reflecting all of the type's children.

Sorry for the confusion. Let me try demonstrate what I'm aiming to do:

// A wrapper around UIView to provide unique `CustomDumpReflectable` conformance
struct Wrapper: CustomDumpReflectable {
  let view: UIView
  
  var mirrorChildren: [Mirror.Child] {
    var children: [Mirror.Child] = []
    if let accessibilityIdentifier = self.view.accessibilityIdentifier {
      // Only append to `children` if non-nil
      children.append(("subviews", accessibilityIdentifier))
    }
    if !self.view.subviews.isEmpty {
      // Only append to `children` if non-empty
      children.append(("subviews", self.view.subviews.map(Wrapper.init(view:))))
    }
    // Imagine many more optional values added to `children`
    return children
  }
  
  var customDumpMirror: Mirror {
    Mirror(self.view, children: mirrorChildren, displayStyle: .struct)
  }
}

Usage:

func testWrapper() {
  let v = UIStackView(arrangedSubviews: [UIButton()])
  let w = Wrapper(view: v)
  
  _assertInlineSnapshot(matching: w, as: .customDump, with: """
  UIView(
    subviews: [
      [0]: UIView()
    ]
  )
  """)
}

(note: I've made a custom Snapshotting.customDump, which is v cool)

Here you can see I'm getting UIView everywhere. What I'd prefer is:

_assertInlineSnapshot(matching: w, as: .customDump, with: """
UIStackView(
  children: [
    [0]: UIButton()
  ]
)
""")

---

As a workaround, I've copied dump() into my own source and made a minor addition:

public protocol CustomDumpReflectable {
  var customDumpMirror: Mirror { get }
  var customDumpTypeName: String? { get } // default `nil`
}

@discardableResult
func customDump<T, TargetStream>(
    _ value: T,
  ...
) {
  ...
  func typeName(_ type: Any.Type) -> String { // shadow your implementation
    (value as? CustomDumpReflectable)?.customDumpTypeName
        ?? CustomDump.typeName(type) // your implementation
  }
  ...
}

I can now fix my Wrapper type:

struct Wrapper: CustomDumpReflectable {
  ...

  var customDumpMirror: Mirror { ... }
  var customDumpTypeName: String? { "\(type(of: self.value))" }
}

I'm not sure I recommend this addition to your library... but I don't know how else to work around this problem.

[rjchatfield]

The problem is that you don't have access to the Mirror::subject in order to print the type out (and just rely on Mirror::subjectType) . Just brainstorming here... but perhaps a more verbose API could help which deconstructs the Mirror.init API.

public protocol CustomDumpDeconstuctedReflectable: CustomDumpReflectable {
  var customDumpSubject: Any { get }
  var customDumpChildren: [Mirror.Children] { get }
  var customDumpDisplayStyle: Mirror.DisplayStyle? { get }
}

public extension CustomDumpDeconstuctedReflectable {
  var customDumpChildren: [Mirror.Children] { Array(Mirror(reflecting: customDumpSubject).children) }
  var customDumpDisplayStyle: Mirror.DisplayStyle? { Mirror(reflecting: customDumpSubject).displayStyle }

  var customDumpMirror: Mirror {
    .init(
      customDumpSubject,
      children: customDumpChildren,
      displayStyle: customDumpDisplayStyle
    )
  }
}

That would give your library access to the subject so you can call type(of: customDumpSubject) instead of typeName(mirror.subjectType).

... but I understand if that's not what you want to do.