Add flag to dump PIR ASTs for certifier

[jaccokrijnen]

Context

For my certifier in Coq, I need to get my hands on all intermediate PIR ASTs. I've added a plugin flag dump-cert-trace, that dumps all PIR ASTs to a single text file during a compilation.

Dumping to file

To prevent keeping all intermediate ASTs in memory, I'm dumping ASTs directly after a pass has run (rather than collecting a pure list of ASTs and dumping them at the end of the pipeline). To that end, I've added a parameter dumpCert :: Text -> m () to runPass (in the pass abstraction), which can be used to append text to the dump file. It needs to be of type Text -> m () rather than Text -> IO (), since the monad stack m does not necessarily have IO in it (the pass abstraction does not require it). The concrete monad stack in Compiler.hs does have IO, so it can be lifted into m.

As a consequence, this new argument also shows up in functions like PIR.compileProgram, PIR.compileToReadable, PIR.compileReadableToPlc. This feels very clumsy, but I couldn't find a nice way to do it. Here are two ideas:

• The dump function could go in CompilationCtx as a Text -> IO (), but that requires a MonadIO constraint in Compiling type and the runPass function in order to actually run it. I'm not sure if that is desired.
• Similar to how logging works (which uses traceM), use unsafePerformIO and add a "pure" function Monad m => Text -> m () in the CompilationCtx

Any other suggestions?

Pretty printing ASTs

The dumping format is textual, and easily parseable in the proof assistant. It's almost Show, but without record syntax and uses Text instead of String for performance. I've added a new typeclass SimpleShow in module Text.SimpleShow, which has some basic instances and the possibility for deriving using GHC generics. I've also written/derived instances for all PIR AST types.

I've added the SimpleShow constraints to the Compiling type/constraint synonym, this required me turning on the following extensions in some places:

• QuantifiedConstraints (because of the constraint forall t. SimpleShow (uni t))
• ImpredicativeTypes, to add the constraint forall t. SimpleShow (uni t) to the Compiling type synonym.

Pretty printing pass information

In addition to ASTs I'm also dumping information about which pass was run. Here I've added the PassId type, which is used as an additional field for every basic Pass constructor.

[effectfully]

I don't like SimpleShow. I don't think we need field selectors in Show output, so let's just get rid of them. Which ones do we have?

If for some reason we do need field selectors, then let's use TextShow.Generic instead of rolling out our own inefficient way of doing the same. So we can always do deriving Show Blah via AsTextNoFields Blah for a custom AsTextNoFields newtype-wrapper whose Show instance uses TextShow.Generic.

[effectfully]

Could you please move these two instance to Text.SimpleShow instead? This module is intended to be as Plutus-unspecific as possible. It'll probably become its own library eventually like it happened with prettyprinter-configurable.

[effectfully]

Remove the pragma.

[effectfully]

And here. And everywhere where it's not needed.

[effectfully]

I bet Text.pack . show is more efficient than this entire machinery, because <> is linear (for both Text and String) and the regular Show is difference-list-based to account for that, unlike your approach.

But why optimize Show at all? You're gonna dump all that stuff on the disk, IO is gonna be your bottleneck, not list creation.

And if you do want to optimize Show, we have configurable pretty-printing specifically to be able to pretty-print things differently, with Doc having O(1) <>.

So SimpleShow is a lot of additional complexity for what's likely negative benefit.