= Improved dependency tracking for GHC =
Many packages these days are using Template Haskell to grab information from the filesystem at compile time. I'll use Hamlet as a motivating example, though this applies to others as well.
In Hamlet, you can specify an external file as the source for your HTML template code, with something like:
{{{
{-# LANGUAGE TemplateHaskell #-}
module M where
import X
import Y
$(renderHamlet $(hamletFile "myfile.hamlet"))
}}}
Now suppose "myfile.hamlet" is updated, but there are no changes in `M.hs`, `X.hs`, `Y.hs` (and their imports). Then `ghc --make` will think that `M` doesn't need recompiling at all and will not recompile `M` (possibly saying "Recompilation is NOT required"). Which is obviously wrong.
Even with plain module-at-a-time `ghc -c M.hs`, GHC may wrongly fail to recompile M because it thinks its unnecessary. You have to use `-fforce-recomp` to make it happen.
The situation is very similar with CPP:
{{{
{-# LANGUAGE Cpp #-}
module M where
import X
import Y
#include "myfile.h"
}}}
Again `ghc --make` will fail to see the dependency on "myfile.h" and may therefore fail to recompile `M` when it should really do so.
== Possible solution ==
The solution comes in these pieces:
1. A part (different for TH and CPP) that tells GHC what files went into compiling M
2. A way (shared) to record this "file-dependency info" in M's interface file, `M.hi`
3. A new bit of the recompilation check that makes M recompile if any of its file-dependencies are out of date.
Concering (2), GHC already has a components of M.hi that records "usages": fingerprints of the things that GHC used in compiling M. This is the `mi_usages` field of `HscTypes.ModIface`. To record the extra dependency we can just add a new constructor to `HscTypes.Usage` for `FileUsage`. (Record an absolute, not relative path!)
Then (3) is relatively easy: just check the modification date of `M.o` against the dependened-on file.
That leaves (1). We'll need:
* A new field in `TcgGblEnv` to accumulate file-dependencies.
* Some way for `#include` directives to be recorded in that list (presumably by interpreting the #line directives that CPP outputs.
* A way for Template Haskell code to express a dependency. A [http://www.reddit.com/r/haskell/comments/k4lc4/yesod_the_limitations_of_haskell/c2hipo3 possible solution] is to add a new function to the template-haskell package:
{{{addDependentFile :: FilePath -> Q ()}}}
This in turn would require the `Qusai` class to support such an operation.
'''Note''' that `ghc -M` would not spit out these dependencies. The solution proposed here simply records what dependencies where encountered ''while compiling M'', and hence when M should be re-compiled. It doesn't tell you (in advance) which files compiling M ''will'' depend on.