We started by calling erasure transformer and it wasn't more evident to us that post-erasure has to run as well. In retrospect it's obvious but it wasn't at the time to me or James.

To give you a background. We wanted to avoid calling erasure transformer for number of reasons:

  1. it's very complex logic and we need just a tiny bit of it
  2. there's quite a bit of indirection if you go through transformer before you get to the logic you want to run
  3. we were not sure if running the whole erasure transformer at some other phase is safe
  4. I consider those cross-phase calls (one phase calls entire other phase) an anti-pattern

When it comes to 4. I'd prefer if we had reusable, very focused components that have clear dependencies (e.g. can run at given phase) and are called from different phases. Does it make sense?

I wonder if moving `elimErasedValueType` out of posterasure phase (e.g. to `TypeAdaptingTransformer`) would make sense? This way `elimErasedValueType` would not be posterasure internal thing but a bit more first-class concept (like adapt). Let me know what you think.