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.

Handle clock_gettime failing

Change default repo root for the 6.6 branch

Tell the 6.6 branch where to find extralibs

Fix exprIsConApp_maybe (wasn't dealing properly with the EqSpec of the DataCon)

unbreak mingw-on-cygwin (/=MSYS) builds

Rename -no-recomp to -fforce-recomp, and document it

Make printing of binding results optional in GHCi, and document it
You can say :set -fno-print-bind-result in GHCi to disable this behaviour.
Addresses #887

Tell the 6.6 branch where to find extralibs

Change default repo root for the 6.6 branch

Add source code links to Haddock docs

Right now we can only manage to add a source code link for the module,
but that's better than nothing.

I had to put the list of core packages in a Makefile variable,
$(CorePackages), so we'll have to be careful to keep this up to date.
(I could have slurped it out of libraries/core-packages with $(shell),
but that's ugly and really slow on Windows).

There are a couple of new tweakables: CorePackageSourceURL and
ExtraPackageSourceURL in config.mk.in, set these to the appropriate
patterns for generating source links.

(when we merge this patch onto the HEAD we'll have to tweak these
settings).

Unfortunately it still doesn't work for all the modules, because
modules compiled without -cpp don't get any #line directives.  More
hackery required...

Fix derived instances (again); prevents infinite superclass loop

Various documentation improvements suggested by Bulat Ziganshin

Fix comment/code inconsistency spotted by Bulat Ziganshin
I'm not sure if this is the example that was intended, but it's at least
now consistent.

rejig library include/ files

Fix newtype deriving properly (un-doing Audreys patch)

The newtype-deriving mechanism generates a HsSyn case expression looking
like this
case (d `cast` co) of { ... }
That is, the case expression scrutinises a dictionary.  This is
otherwise never seen in HsSyn, and it made the desugarer
(Check.get_unused_cons) crash in tcTyConAppTyCon.

It would really be better to generate Core in TcInstDecls (the newtype
deriving part) but I'm not going to do that today.  Instead, I made
Check.get_unused_cons a bit more robust.

Audrey tried to fix this over the weekend, but her fix was, alas, utterly
bogus, which caused mysterious failures later.  I completely undid this
change.

Anyway it should work now!

Document -F in the flag reference

Added Darwinports path to DocBook XSL stylesheets to configure.

Comment-only: Fix a typo, and note that the PredTy case on SplitTyConApp_maybe was added as a kluge.

In tcSplittyConApp_maybe, add the PredTy case
such that this can compile again:

    newtype Moose = MkMoose () deriving (Eq, Ord)

Fixed DocBook XML once again, "make validate" is your friend!

Trim more imports

Fix origin for addDataConStupidTheta

Remove ASSERT from mkDataCon, and add comments to explain why

The unboxed tuple kind is (#), not (##)

Complete definition of cmPredX to take account of EqPred

Correct crucial typo in isSubKind (kc1 -> kc2)!