[GHC] #10871: Implement "fat" interface files which can be directly compiled without source (was: Implement "buildable" interface files which can be directly compiled without source)

[GHC]

#10871: Implement "fat" interface files which can be directly compiled without
source
-------------------------------------+-------------------------------------
        Reporter:  ezyang            |                   Owner:  ezyang
            Type:  feature request   |                  Status:  new
        Priority:  normal            |               Milestone:
       Component:  Compiler          |                 Version:  7.11
      Resolution:                    |                Keywords:  backpack
Operating System:  Unknown/Multiple  |            Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |               Test Case:
      Blocked By:                    |                Blocking:
 Related Tickets:                    |  Differential Revisions:
-------------------------------------+-------------------------------------

Comment (by ezyang):

 Posting a little update about the tiresome root main function: the root
 main function is a special implicit binding that is added to Haskell
 programs during type checking and serves as the "well known" entry point
 to enter a Haskell program. Currently, it is named `:Main.main` (i.e.
 `ZCMain_main`): unusually, it is a binding in a Haskell program that can
 have a different `Module` than the module actually being compiled.

 Because of this, it has to be treated specially when we serialize it out
 to an interface file: namely, we have to know /which/ binding is the root
 main binding (so it doesn't clobber the user-written main binding), as
 interface file serialization doesn't record `Module`, only the `OccName`.

 In our last phone call, we proposed two fixes, but I don't think either of
 them will work:

 1. Move the binding to be injected during tidying, rather than
 typechecking. This is tiresome because `main` is to have type `IO a`,
 where `a` is anything we want. We'd have to extract out this type to make
 a well-formed core binding (this is marginally easier in the typechecker,
 where the current code does unification to pull it out.) We are also only
 given the `RdrName` of the function which is supposed to be main; we have
 to consult the `GlobalRdrEnv` to turn this into an actual `Name`. So we
 also have to make sure to preserve this information until the final
 tidying so that we can point to the correct main function, which means yet
 another thing to record in `ModGuts`. Finally, we can't really eliminate
 `checkMain`, since we need to give errors when appropriate.  So this is a
 large amount of work for a questionable amount of benefit.

 2. Rename the main `OccName` to something special, e.g. `$main`, so we can
 identify it in the interface file. If we do this, it means the name that
 you must refer to for a Haskell program for main, `ZCMain_main_closure`,
 has to be renamed to `ZCMain_zdmain_closure`.  This is pretty gratuitous
 and will break any C-Haskell bridges for no good reason. So I'd like not
 to do that.

 I think my current plan is to just have a flag in `IfaceBinding` which
 says if this is "main" or not, and then we just typecheck it accordingly
 one way or another. A small amount of code, no penalty for normal
 interface files, and very simple.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10871#comment:5>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler