Hi everyone,
On Friday I finished importing the prime.haskell.org Trac instance into
GitLab. For this process I had to disable mail delivery to ensure that
users weren't spammed by import messages. Unfortunately, it looks like I
neglected to reenable mail after the import had concluded.
I re-enabled mail about half an hour ago and consequently you may find
yourself facing a few more messages than usual this morning. Sorry for
the inconvenience!
Cheers,
- Ben
Dear GHC devs,
I am currently working on my own fork of GHC (
https://gitlab.haskell.org/trupill/ghc) and as part of it I need to do
some changes to the Cabal and haskeline libraries. However, since they are
in submodules, I am not sure about how I can commit those changes, share
them with others, and rebase my changes against the current HEAD for these
submodules.
Thanks in advance and kind regards,
Alejandro
Hi,
We recently did some refactoring in HscMain and DriverPipeline to generate
interfaces after final Cmms are generated (previously interfaces would be
generated after the tidying pass). It's mostly done but there's one thing that I
couldn't figure out after two full days of debugging (I also asked a few people
about it on IRC), so I wanted to ask here in case someone here knows.
Previously the interface value (ModIface) would be generated and written to disk
in `HscMain.finish`. The DynFlags we use to generate the ModIface and to write
it to disk would be the one passed to `HscMain.hscIncrementalCompile`.
In the new implementation part of the interface is still generated in
`HscMain.hscIncrementalCompile` (see mkPartialIface), using the same DynFlags as
before. But more stuff is added after the final Cmms are generated (see
mkFullIface calls in DriverPipeline) using DynFlags in `compileOne'` or
`runPhase` (called by `runPipeline`). It turns out these DynFlags are different
enough from the one passed to `HscMain.hscIncrementalCompile` that some tests
fail (I remember a backpack test, but there may be more).
("Full" interfaces are written to disk right after generation)
See [1] for the hack I added as a workaround. Basically I keep the DynFlags
passed to hscIncrementalCompile so that I can generate the final interfaces
correctly.
The question is what's changing in DynFlags that makes things go wrong. I tried
looking at the fields used by mkFullIface and hscMaybeWriteIface, but as far as
I can see none of the fields used by these functions are different from the
DynFlags passed to hscIncrementalCompile.
If anyone knows what's going on any help would be appreciated.
Thanks,
Ömer
[1]: https://gitlab.haskell.org/ghc/ghc/blob/master/compiler/main/HscTypes.hs#L2…
