External Core lib: lots of cleanup

- Factor out code for applying newtypes from Check into CoreUtils
- Use this code in Prep, which allowed for some simplification
- Change Merge and ElimDeadCode to not flatten top-level binds
- Add a flag for elimDeadCode to tell it whether to keep
exported bindings or not.
- Other things.

External Core: print out more precise dependency info

Print out the same recursive/non-recursive binding groups
that existed in internal Core in an External Core file,
rather than dumping everything into one big recursive group.

Fix "make install": Put "[]" in the install package.conf

Remove redundant import; spotted by Thorkil Naur

Remove a redundant import

Detect when a C finalizer calls back to Haskell
This is illegal now, after the fix for #1364, but it turns out that
the existing check for dodgy callbacks doesn't catch finalizers
calling back, so we need another test.  This will be particularly
important for 6.10.2, because the behaviour has changed.

Fix Trac #2931

Fix the lexical analyser when it encounters 'x<EOF> and Template
Haskell is on.

Rewrite CorePrep and improve eta expansion

This patch does two main things

a) Rewrite most of CorePrep to be much easier to understand (I hope!).
   The invariants established by CorePrep are now written out, and
   the code is more perspicuous.  It is surpringly hard to get right,
   and the old code had become quite incomprehensible.

b) Rewrite the eta-expander so that it does a bit of simplifying
   on-the-fly, and thereby guarantees to maintain the CorePrep
   invariants.  This make it much easier to use from CorePrep, and
   is a generally good thing anyway.

A couple of pieces of re-structuring:

*  I moved the eta-expander and arity analysis stuff into a new
   module coreSyn/CoreArity.

   Max will find that the type CoreArity.EtaInfo looks strangely
   familiar.

*  I moved a bunch of comments from Simplify to OccurAnal; that's
   why it looks as though there's a lot of lines changed in those
   modules.

On the way I fixed various things

  - Function arguments are eta expanded
       f (map g)  ===>  let s = \x. map g x in f s

  - Trac #2368

The result is a modest performance gain, I think mainly due
to the first of these changes:

--------------------------------------------------------------------------------
        Program           Size    Allocs   Runtime   Elapsed
--------------------------------------------------------------------------------
            Min          -1.0%    -17.4%    -19.1%    -46.4%
            Max          +0.3%     +0.5%     +5.4%    +53.8%
 Geometric Mean          -0.1%     -0.3%     -7.0%    -10.2%

Rename isIdentityCoercion to isIdentityCoI; add Coercion.isIdentityCoercion

Spelling in comment only

Make the ASSERT more informative

Export mapOL from OrdList

Improve error messages slightly

Do not do SpecConstr on functions that unconditionally diverge

There is no point in specialising a function that is guaranteed to
diverge, and doing so screwed up arity stuff.

See Note [Do not specialise diverging functions].

Make -XTypeFamilies imply -XRelaxedPolyRec (Trac #2944)

Fix Trac #2937: deserialising assoicated type definitions

The deserialiser (TcIface) for associated type definitions wasn't
taking into account that the class decl brings into scope some
type variables that scope over the data/type family declaration.

Easy to fix: the new function is TcIface.bindIfaceTyVars_AT

Always check the result of pthread_mutex_lock() and pthread_mutex_unlock().

Don't check pthread_mutex_*lock() only on Linux and/or only if DEBUG
is defined. The return values of those functions are well defined
and should be supported on all operation systems with pthreads. The
checks are cheap enough to do them even in the default build (without
-DDEBUG).

While here, recycle an unused macro ASSERT_LOCK_NOTHELD, and let
the debugBelch part enabled with -DLOCK_DEBUG work independently
of -DDEBUG.

sanity checking fixes

Keep the remembered sets local to each thread during parallel GC
This turns out to be quite vital for parallel programs:

  - The way we discover which threads to traverse is by finding
    dirty threads via the remembered sets (aka mutable lists).

  - A dirty thread will be on the remembered set of the capability
    that was running it, and we really want to traverse that thread's
    stack using the GC thread for the capability, because it is in
    that CPU's cache.  If we get this wrong, we get penalised badly by
    the memory system.

Previously we had per-capability mutable lists but they were
aggregated before GC and traversed by just one of the GC threads.
This resulted in very poor performance particularly for parallel
programs with deep stacks.

Now we keep per-capability remembered sets throughout GC, which also
removes a lock (recordMutableGen_sync).

indicate which TSOs are dirty in the printAllThreads() output

Fix Trac #2584: Pretty printing of types with HsDocTy

The pretty printing clause for HsDocTy was wrong, causing brackets to be left
out. We now print Haddock comments on types as if they were postfix type
operators.

Add "Word size" to the +RTS --info output

Check that make supports eval

Add some more fields to +RTS --info

FIX BUILD on Windows (fix for #2873 broke it)

when calling mmap() with MAP_ANON, the fd argument should be -1
might fix #2925

Fix Trac #2914: record wild cards and assoicated types

Fix #2873: should fail if a package DB desn't exist
We allowed non-existence before because the user DB is allowed to not
exist, so now we have an explicit exception for that case.

Close the races between throwTo and thread completion
Any threads we missed were being caught by the GC (possibly the idle
GC if the system was otherwise inactive), but that's not ideal.  The
fix (from Bertram Felgenhauer) is to use lockTSO to synchronise,
imposing an unconditional lockTSO on thread exit.  I couldn't measure
any performance overhead from doing this, so it seems reasonable.

add comment

Fix two more locking issues in throwTo()

maybePerformBlockedException() should handle ThreadComplete/ThreadKilled
Part of the fix for #2910

fix a race where the timer signal could remain turned off, leading to deadlock

putMVar and takeMVar: add write_barrier() to fix race with throwTo

cruft removal

wake up the blocked exception queue on ThreadFinished; fixes #2910

bump GHC's max stack size to 512M
To accomodate compiling very long static lists (#2002)

ext-core: change .cabal file so we can build with either GHC 6.8 or 6.10

ext-core: fix some Prep bugs

ext-core: use shorter names when combining modules

ext-core: twiddle primitive things

Don't pin a register for gc_thread on SPARC.

This makes the build work again.

Require HsColour by default
This should stop us ending up without HsColour'ed sources on some
platforms.

We also now tell Cabal where to find HsColour, rather than it finding
it itself.

Fix build

Add GHCi completions to :set and :show

Fix sync-all: Check for --complete/partial before --<anything>
Patch from megacz in trac #2857

Remove time from extralibs at request of maintainer

validate fix: InteractiveEval no longer needs to import  IdInfo

Fix validate: strs is no longer used in IfaceSyn

Remove trailing whitespace from HaddockUtils

Fix warnings in HaddockUtils

Remove dead code from HaddockUtils

Make record selectors into ordinary functions

This biggish patch addresses Trac #2670.  The main effect is to make
record selectors into ordinary functions, whose unfoldings appear in
interface files, in contrast to their previous existence as magic
"implicit Ids".  This means that the usual machinery of optimisation,
analysis, and inlining applies to them, which was failing before when
the selector was somewhat complicated.  (Which it can be when
strictness annotations, unboxing annotations, and GADTs are involved.)

The change involves the following points

* Changes in Var.lhs to the representation of Var.  Now a LocalId can
  have an IdDetails as well as a GlobalId.  In particular, the
  information that an Id is a record selector is kept in the
  IdDetails.  While compiling the current module, the record selector
  *must* be a LocalId, so that it participates properly in compilation
  (free variables etc).

  This led me to change the (hidden) representation of Var, so that there
  is now only one constructor for Id, not two.

* The IdDetails is persisted into interface files, so that an
  importing module can see which Ids are records selectors.

* In TcTyClDecls, we generate the record-selector bindings in renamed,
  but not typechecked form.  In this way, we can get the typechecker
  to add all the types and so on, which is jolly helpful especially
  when GADTs or type families are involved.  Just like derived
  instance declarations.

  This is the big new chunk of 180 lines of code (much of which is
  commentary).  A call to the same function, mkAuxBinds, is needed in
  TcInstDcls for associated types.

* The typechecker therefore has to pin the correct IdDetails on to
  the record selector, when it typechecks it.  There was a neat way
  to do this, by adding a new sort of signature to HsBinds.Sig, namely
  IdSig.  This contains an Id (with the correct Name, Type, and IdDetails);
  the type checker uses it as the binder for the final binding.  This
  worked out rather easily.

* Record selectors are no longer "implicit ids", which entails changes to
     IfaceSyn.ifaceDeclSubBndrs
     HscTypes.implicitTyThings
     TidyPgm.getImplicitBinds
  (These three functions must agree.)

* MkId.mkRecordSelectorId is deleted entirely, some 300+ lines (incl
  comments) of very error prone code.  Happy days.

* A TyCon no longer contains the list of record selectors:
  algTcSelIds is gone

The renamer is unaffected, including the way that import and export of
record selectors is handled.

Other small things

* IfaceSyn.ifaceDeclSubBndrs had a fragile test for whether a data
  constructor had a wrapper.  I've replaced that with an explicit flag
  in the interface file. More robust I hope.

* I renamed isIdVar to isId, which touched a few otherwise-unrelated files.

Fix Trac #2721: reject newtype deriving if the class has associated types

-XImpredicativeTypes implies -XRankNTypes, and improve error msg in TcMType

If you are going for impredicative types you almost certainly want RankN
too. The change to TcMType improves the error when you say
     T (forall a. blah)
where T is a type synonym.  This doesn't necessarily need impredicativity,
if you have LiberalTypeSynonyms.

Fix Trac #2856: make deriving work for type families

Darn, but TcDeriv is complicated, when type families get in on
the act!  This patch makes GeneralisedNewtypeDeriving work
properly for type families.  I think.

In order to do so, I found that GeneralisedNewtypeDeriving can
work for recursive newtypes too -- and since families are conservatively
marked recursive, that's a crucial part of the fix, and useful too.
See Note [Recursive newtypes] in TcDeriv.

White space and spelling in comments

Remove -XImpredicativeTypes from -fglasgow-exts

See Trac #2846: impredicative types are far from stable, so
-fglasgow-exts should not imply them.  Maybe we should merge
this into 6.10?

Improve error reporting for 'deriving'

a) Improve the extra suggested fix when there's a "no instance"
   error in a deriving clause.

b) Improve error location recording in tcInstDecl2

Many of the changes in tcInstDecl2 are simple reformatting.

Improve error message in deriving (fix Trac #2851)

Avoid nasty name clash with associated data types (fixes Trac #2888)

The main bug was in TcHsType; see Note [Avoid name clashes for
associated data types].  However I did a bit of re-factoring while
I was abouut it.

I'm still a but unhappy with the use of TyCon.setTyConArgPoss; it'd
be better to construct the TyCon correctly in the first place.  But
that means passing an extra parameter to tcTyDecl1... maybe we should
do this.

Refactor RnEnv to fix Trac #2901

This tidy-up fixes Trac #2901, and eliminates 20 lines of code.
Mainly this is done by making a version of lookupGlobalOccRn that
returns (Maybe Name); this replaces lookupSrcOccRn but does more.

Add quotes to error message

Tidy up treatment of big lambda (fixes Trac #2898)

There was a leftover big lambda in the CorePrep'd code, which confused
the bytecode generator.  Actually big lambdas are harmless.  This patch
refactors ByteCodeGen so that it systemantically used 'bcView' to eliminate
junk.  I did a little clean up in CorePrep too.

See comments in Trac #2898.

Fix warnings in ByteCodeAsm

Fix warnings in ByteCodeInstr

Fix warnings in Rules

Fix warnings in StgCmmForeign

Fix warnings in CgCallConv

Fix warnings in SMRep

Fix warnings in ClosureInfo

Fix warnings in CgTicky

Fix warnings in CgCon

Fix warnings in WorkWrap

Fix warnings in NCGMonad

Fix warnings in CmmInfo

Fix warnings in CmmCPSGen

Fix warnings in CmmProcPoint

Fix warnings in CmmCallConv

Fix warnings in CmmLive

Fix warnings in CmmCPS

Fix warnings in CmmUtils

Comment out dead function breakProc

Fix warnings in CmmBrokenBlock

Comments only.  Haddockify parts of TcRnTypes.

Comments only.  Fix typo.

Include PprTyThings in tags file.

Use DynFlags to work out if we are doing ticky ticky profiling
We used to use StaticFlags

Fix warnings in CgExpr

Fix warnings in CgBindery

Fix warnings in CgStackery

Fix warnings in CgCase

Remove some dead code from CgCase

Fix warnings in StgCmmProf

Fix warnings in CgProf

Fix warnings in CgInfoTbls

Remove dead function srtLabelAndLength from CgInfoTbls

Fix warnings in CgHeapery

Fix warnings in CgTailCall

Remove a little dead code from CgTailCall