DebugSnapshot-like dependency return value / arg wrappers

[marcisme]

I'm curious if something similar to debug snapshots or extending it has been considered for use with Dependencies?

Some of the  frameworks that I create dependency clients for vend types that have no public initializers, or sometimes even classes with inheritance hierarchies. Historically I've created Equatable struct wrappers with a rawValue property, inspired by code like composable-core-location and composable-core-motion.

My understanding is macros can't be applied to types outside of their definition, but it could be possible to create a macro that could be used with a type that accepts a target type and key paths to the properties to generate. Something like (pseudocode):

// Defined in another module.
class ActualFooType {
  let bar: Int
  let baz: String
}

// Defined as part of a dependency implementation.
@TestableWrapper(@ActualFooType.self, [
  \.bar,
  \.baz
])
struct Foo {}

// or:
extension ActualFooType {
  @TestableWrapper(@ActualFooType.self, [
    \.bar,
    \.baz
  ])
  struct Value {}
}

// or:
@TestableWrapper([
  \.bar,
  \.baz
])
struct Foo {
  let rawValue: ActualFooType?
}

Creating the needed boilerplate for types like this is much less onerous these days, and sometimes I'd rather have generated code than a macro. I also just had some bad cglib/AspectJ flashbacks. Regardless it is a possible bug vector, and @DebugSnapshot seems to already do much of what would be needed, if viable.

[mbrandonw]

Hey @marcisme, thanks for sharing. It's a pretty interesting idea and something we hadn't considered. We're not sure exactly how it would work, but one possibility (if macros are up for the challenge) may be a kind of two step process for defining a struct with the data you want from the class, and then a step to extend the class with the snapshot functionality:

@DebugSnapshotValue(target: CLLocation.self)
struct Location {
  // All fields you want from `CLLocation`. Names and types would have to exactly match.
  var coordinate: CLLocationCoordinate2D
  var timestamp: Date
}


@DebugSnapshot(target: Location.self)
extension CLLocation { /* nothing needed here */ }

That should theoretically allow you to hold onto CLLocation objects in your domain while still being able to snapshot them for debugging and tests. It seems plausible, and we will be thinking about it more. Let us know if you uncover anything too.

[marcisme]

@mbrandonw Thanks for the feedback. I like the idea of explicitly defining the value type and primarily relying on macros for behavior. I'm not sure when I'll have time to dig into this more, but I'll give this direction a try when I do.