Interface file optimisation and removal of nameParent

This large commit combines several interrelated changes:

  - IfaceSyn now contains actual Names rather than the special
    IfaceExtName type.  The binary interface file contains
    a symbol table of Names, where each entry is a (package,
    ModuleName, OccName) triple.  Names in the IfaceSyn point
    to entries in the symbol table.

    This reduces the size of interface files, which should
    hopefully improve performance (not measured yet).

    The toIfaceXXX functions now do not need to pass around
    a function from Name -> IfaceExtName, which makes that
    code simpler.

  - Names now do not point directly to their parents, and the
    nameParent operation has gone away.  It turned out to be hard to
    keep this information consistent in practice, and the parent info
    was only valid in some Names.  Instead we made the following
    changes:

    * ImportAvails contains a new field
          imp_parent :: NameEnv AvailInfo
      which gives the family info for any Name in scope, and
      is used by the renamer when renaming export lists, amongst
      other things.  This info is thrown away after renaming.

    * The mi_ver_fn field of ModIface now maps to
      (OccName,Version) instead of just Version, where the
      OccName is the parent name.  This mapping is used when
      constructing the usage info for dependent modules.
      There may be entries in mi_ver_fn for things that are not in
      scope, whereas imp_parent only deals with in-scope things.

    * The md_exports field of ModDetails now contains
      [AvailInfo] rather than NameSet.  This gives us
      family info for the exported names of a module.

Also:

   - ifaceDeclSubBinders moved to IfaceSyn (seems like the
     right place for it).

   - heavily refactored renaming of import/export lists.

   - Unfortunately external core is now broken, as it relied on
     IfaceSyn.  It requires some attention.

add extendNameEnvList_C

getMainDeclBinder should return Nothing for a binding with no variables
See test rn003

Use ":Co", not "Co" to prefix coercion TyCon names
Avoid possibility of name clash

Fix another hi-boot file

Removed unused unwrapFamInstBody from MkId

Rejig the auto-scc wrapping stuff

Do not filter the type envt after each GHCi stmt

Fixes Trac #925

A new comment in TcRnDriver in tcRnStmt reads thus:

At one stage I removed any shadowed bindings from the type_env;
they are inaccessible but might, I suppose, cause a space leak if we leave them there.
However, with Template Haskell they aren't necessarily inaccessible.  Consider this
GHCi session
 Prelude> let f n = n * 2 :: Int
 Prelude> fName <- runQ [| f |]
 Prelude> $(return $ AppE fName (LitE (IntegerL 7)))
 14
 Prelude> let f n = n * 3 :: Int
 Prelude> $(return $ AppE fName (LitE (IntegerL 7)))
In the last line we use 'fName', which resolves to the *first* 'f'
in scope. If we delete it from the type env, GHCi crashes because
it doesn't expect that.

Fail more informatively when a global isn't in the type environment

Rough matches for family instances
- Class and type family instances just got a lot more similar.
- FamInst, like Instance, now has a rough match signature.  The idea is the
  same: if the rough match doesn't match, there is no need to pull in the while
  tycon describing the instance (from a lazily read iface).
- IfaceFamInst changes in a similar way and the list of all IFaceFamInsts is
  now written into the binary iface (as for class instances), as deriving it
  from the tycon (as before) would render the whole rough matching useless.
- As a result of this, the plumbing of class instances and type instances
  through the various environments, ModIface, ModGuts, and ModDetails is now
  almost the same.  (The remaining difference are mostly because the dfun of a
  class instance is an Id, but type instance refer to a TyCon, not an Id.)

*** WARNING: The interface file format changed! ***
***      Rebuild from scratch. ***

Tweaks and missing case in disassembler

Update hi-boot files to fix building with old GHCs

STM invariants

Fix unregisterised alpha builds

Comments and an import-trim

Mention that the module sub-directory structure for .o and .hi files is created automatically by GHC

Bale out before renamer errors are duplicated

With the new Haddock patch, renamer errors can be duplicated;
so we want to bale out before doing the Haddock stuff if errors
are found.

(E.g test mod67 shows this up.)

Avoid repeatedly loading GHC.Prim

This patch changes HscTypes.lookupIfaceByModule.  The problem was that
when compiling the 'base' package, we'd repeatedly reload GHC.Prim.
This is easily fixed by looking in the PIT too. A comment with
lookupIfaceByModule explains

Print the 'skipping' messages at verbosity level 1

Fix up the typechecking of interface files during --make

This patch fixes Trac #909.  The problem was that when compiling
the base package, the handling of wired-in things wasn't right;
in TcIface.tcWiredInTyCon it repeatedly loaded GHC.Base.hi into the
PIT, even though that was the very module it was compiling.

The main fix is by introducing TcIface.ifCheckWiredInThing.

But I did some minor refactoring as well.

Import trimming

Figure out where the rest of the repositories are, based on defaultrepo
This is a slight improvement over the patch sent by jamey@minilop.net,
we now do it properly if the source repo was a GHC tree on the local
filesystem too.

Merge post 6.6.

Yet another fix to mkAtomicArgs (for floating of casts)

Comment Note [Take care] explains.

mkAtomicArgs is a mess.  A substantial rewrite of Simplify is needed.

Improve comments and error tracing

Improve error message

Undo an accidentally-committed  patch by Audrey

Merge Haddock comment support from ghc.haddock -- big patch

Remove casts from lvalues to allow compilation under GCC 4.0

Correct the float-coercions-out-of-let patch

Merge changes

Improve the correlation betweens documented and existent options

Document -dfaststring-stats

Rearrange docs to have all the -ddump-* options together

Remove unused option -femit-extern-decls

Documentation updates

Fix typo

More bootstrapping updates

Teach SpecConstr about Cast

This patch teaches SpecConstr about casts; see Note [SpecConstr for casts]

Float coercions out of lets

Note [Float coercions]
~~~~~~~~~~~~~~~~~~~~~~
When we find the binding
x = e `cast` co
we'd like to transform it to
x' = e
x = x `cast` co -- A trivial binding
There's a chance that e will be a constructor application or function, or something
like that, so moving the coerion to the usage site may well cancel the coersions
and lead to further optimisation.  Example:

     data family T a :: *
     data instance T Int = T Int

     foo :: Int -> Int -> Int
     foo m n = ...
        where
          x = T m
          go 0 = 0
          go n = case x of { T m -> go (n-m) }
-- This case should optimise

Remove unused argument to mkAtomicArgs

Comments and layout

Remove unused OccInfo (simplification)

The substitution used to carry "fragile" OccInfo to call sites via the
DoneId constructor of SimplEnv.SimplSR.  This was always a tricky thing
to do, and for some time I've been removing the need for it.

Now at last I think we can nuke it altogether.  Hooray.

I did a full nonfib run, and got zero perf changes.

Take 2 on the recursive-rule fix

This is another attempt to fix the interaction between recursion and
RULES.  I just had it wrong before!  Now the significance of the
flag on IAmALoopBreaker is given in BasicTypes

  | IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers
-- in a group of recursive definitions
!RulesOnly -- True <=> This loop breaker mentions the other binders
--     in its recursive group only in its RULES, not
--     in its rhs
--  See OccurAnal Note [RulesOnly]

Take advantage of non-rec-ness in occurrence analysis (minor)

Spelling in comment

Add intersectsUFM

Made 'for' a special ID in the grammar.

Merged stand-alone deriving with FC stuff.

First documentation on stand-alone instance deriving.

Fixed source location and instance origin in stand-alone deriving error messages.

Added type signature for tcSplitSigmaTy.

New syntax for stand-alone deriving. Implemented fully.

Renamer part of stand-alone deriving extension.

Added parser and abstract syntax support for stand-alone deriving declarations.

Comments only

Fix comment in RdrName

Improve unboxing of strict fields

Note [Recursive unboxing]
~~~~~~~~~~~~~~~~~~~~~~~~~
Be careful not to try to unbox this!
data T = MkT !T Int
But it's the *argument* type that matters. This is fine:
data S = MkS S !Int
because Int is non-recursive.

Before this patch, we were only doing the unboxing if the *parent*
data type was non-recursive (eg that meant S was not unboxed), but
that is over-conservative.

This showed up with indexed data types (thanks to Roman for finding it)
because indexed data types are conservatively regarded as always recursive.

Remove redundant dump

Trim imports

Improve liberate-case to take account of coercions

Note [Scrutinee with cast]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this:
    f = \ t -> case (v `cast` co) of
         V a b -> a : f t

Exactly the same optimistaion (unrolling one call to f) will work here,
despite the cast.  See mk_alt_env in the Case branch of libCase.

This patch does the job.  For a change, it was really easy.

Remvove totally unused static flags

Remove ILX from the GHC altogether (although I left the source file IlxGen in case anyone wants to see it)

-frule-check is not a static flag

Tidy tyvar OccNames in TcTyClDecl

We want the universal and existential tyvars of a data constructor to
have distinct OccNames.  It's confusing if they don't (in error messages,
for example), and with the current way of generating IfaceSyn, it actally
generates bogus interface files.  (Which bit Roman.)

When IfaceSyn is full of Names, this won't matter so much, but it still
seems cleaner.

This patch adds a 'tidy' step to the generation of DataCon type
variables in TcTyClDecls.tcResultType

Improve pretty printing slightly

Second bite at the rules-only idea

This is part 2 of the patch that improved the interaction of RULES and
recursion.  It's vital that all Ids that may be referred to from later in
the module are marked 'IAmALoopBreaker' because otherwise we may do
postInlineUnconditionally, and lose the binding altogether.

So I've added a boolean rules-only flag to IAmALoopBreaker.  Now we can
do inlining for rules-only loop-breakers.

Eliminate case-of-cast

Note [Case of cast]
~~~~~~~~~~~~~~~~~~~
Consider  case (v `cast` co) of x { I# ->
... (case (v `cast` co) of {...}) ...
We'd like to eliminate the inner case.  We can get this neatly by
arranging that inside the outer case we add the unfolding
v |-> x `cast` (sym co)
to v.  Then we should inline v at the inner case, cancel the casts,
and away we go

This patch does the job, fixing a performance hole reported by Roman.

Fixes for the porting process for 6.6

Make recursion and RULES interact better

See Trac #683

This patch improves the interaction of recursion and RULES; at least I
hope it does.   The problem was that a RULE was being treated uniformly like
an "extra RHS". This worked badly when you have a non-recursive definition
that is made recursive only by RULE.

This patch maeks the occurrence analyser know whether a binder is referred to
only from RULES (the RulesOnly constructor in OccInfo).  Then we can ignore
such edges when deciding on the order of bindings in a letrec, and when
setting the LoopBreaker flag.

The remaining potential problem is this:
rec{ f = ...g...
   ; g = ...f...
     RULE g True = ...
   }

The RULE for g may not be visible in f's rhs.  This is fixable, but not
today.

Warning police only

Fix scoped type variables for expression type signatures

I had forgotten to bring scoped type variables into scope at an expression
type signature, such as
e :: forall s. <type>
where 's' should scope over the expression e.

Like everything to do with scoped type variables, fixing this took an
unreasonable amount of work.  I'm sure there must be a better way to
achitect this!

I updated the user manual too.

A test is tc213.

It would be good to push this into 6.6.1

Trim imports

Add error check for operators in types

Fixes Trac #919

Add a C++ phase. Fixes bug #800

Latin-1-to-UTF8 pre-processor example for docs from Christian Maeder

add :edit to the release notes, and improve the docs a bit

Simplify the way in which the coKindFun in CoercionTyCon is handled

Before the coKindFun could be applied to too many arguments;
now it expects exactly the right number of arguments.  That
makes it easier to write the coKindFuns, and localises the work.

Match let before lambda in rule-matching (see comment with Lam case of Rules.match)

Fix bug in SCRIPT_SHELL patch (| should be ||)

Add missing case for EqPred

Amplify scoped tyvar changes

Update release notes

Remove Linear Implicit Parameters, and all their works

Linear implicit parameters have been in GHC quite a while,
but we decided they were a mis-feature and scheduled them for
removal.  This patch does the job.

Global renamings in HsSyn

Improve pretty-printing of Core

Another correction to the (subtle) exprIsConApp_maybe

Spelling correction

Improve pretty printing of IfaceSyn

Improve unification error messages (again) (push to 6.6 branch)

:edit runs notepad by default on Windows

unbreak :edit patch on Windows

Fix #906, and do #914 while I'm in here (it wasn't too hard)

Add basic :edit support
Without jumping to line numbers or %-expansion, we could add that later.

tiny fix in porting docs I just spotted

only make stdin/stdout unbuffered in GHCi, not runghc or ghc -e.

testsuite *is* boring

fix typo in comment

remove non-boring directories

Modify toArgs to parse quotes/escapes like /bin/sh
Addresses ticket #197, which asks for escape sequences to be supported directly (i.e.
not only in dquoted strings) on :load commands in GHCI.  Fix modifies the toArgs
function to parse its input like /bin/sh does, i.e. recognizing escapes anywhere
and treating quoted strings as atomic chunks.  Thus:
  :load a\ b c\"d e" "f
would parse with three arguments, namely 'a b', 'c"d', and 'e f'.

toArgs is used to parse arguments for both :load and :main, but doesn't appear to
be used elsewhere.  I see no harm in modifying both to be consistent -- in fact,
the functionality is probably more useful for :main than for :load.

Fix mulIntMayOflo on 64-bit arches; fixes trac #867
We were assuming we could multiply 2 32-bit numbers without overflowing
a 64-bit number, but we can't as the top bit is the sign bit.