More accurate package dependencies
The problem we want to solve here is that there is currently no distinction between compile-time package dependencies and link-time package dependencies. Often a compile-time dependency is also a link-time dependency, but there are two instances in which it might not be:
Template Haskell: some packages might be required for executing TH code at
compile-time, but the compiled code doesn't require those packages to be
Annotations: we're considering allowing arbitrary attributes to be attached
to declarations, where the attributes are compile-time Haskell expressions.
The same issue as with TH crops up again here.
Currently we figure out which packages to link by looking at the (transitive closure of the) imports. It would be better to look at the external references of the compiled code; some of the packages referred to by imports may not need to be linked.
Similarly, we should figure out the dependencies of a ``package
\ by taking the union of the link-time dependencies of its compiled modules. This means a small changes to Cabal.
None of this is particularly hard, and doesn't need any changes to the interface file format or package database: we just record fewer package dependencies than before. The only tricky bit is traversing the code to figure out what the package dependencies should be.