Fix Trac #3813: unused variables in GHCi bindings

In a GHCi stmt we don't want to report unused variables,
because we don't know the scope of the binding, eg

Prelude> x <- blah

Fixing this needed a little more info about the context of the stmt,
thus the new constructor GhciStmt in the HsStmtContext type.

Fix Trac #3823, plus warning police in TcRnDriver

The immediate reason for this patch is to fix #3823. This was
rather easy: all the work was being done but I was returning
type_env2 rather than type_env3.

An unused-veriable warning would have shown this up, so I fixed all
the other warnings in TcRnDriver.  Doing so showed up at least two
genuine lurking bugs.  Hurrah.

Change how RTS libraries get installed; fixes trac #3794

Escape some more $s in makefiles, for consistency

Escape some $s in makefiles for consistency

Allow GNU-standard --host, --build, --target configure options (#3637)
Patch contributed by asuffield@suffields.me.uk

Update some comments about how autoconf/configure works

Fix a warning message
We were printing the wrong value, so getting confusing messages like:
    Function `$wa{v s17LO} [lid]'
        has 2 call pattterns, but the limit is 3

Teach the alternative layout rule about mdo and rec

Teach the alternative layout rule about $( ... )
It thought the ) needed to close something, but the $( hadn't
opened anything.

Fix typo

Remove declaration of non-existent mark_splim

fix a comment

remove an unnecessary debug trace, duplicated by a traceSchedEvent

hide modules properly with haddock

fix for HSCOLOUR_SRCS=NO

Do some recompilation avoidance in GHC.loadModule
GHC.loadModule compiles a module after it has been parsed and
typechecked explicity. If we are compiling to object code and there is
a valid object file already on disk, then we can skip the compilation
step. This is useful in Haddock, when processing a package that uses
Template Haskell and hence needs actual compilation, and the package
has already been compiled.

As usual, the recomp avoidance can be disabled with -fforce-recomp.

Invoke Haddock directly from the build system, instead of via Cabal

Partly this is cleaner as we only have to preprocess the source files
once, but also it is necessary to avoid Haddock recompiling source
files when Template Haskell is in use, saving some time in validate
and fixing a problem whereby when HADDOCK_DOCS=YES, make always
re-haddocks the DPH packages.  This also needs an additional fix to
GHC.

HsColour support still uses Cabal, and hence preprocesses the source
files again. We could move this into the build system too, but there
is a version dependency that would mean adding extra autoconf stuff.

refactoring while I try to make sense of the hsc interface

Fix running in-place gen_contents_index; trac #3716
It was making incorrect URLs due to a shell script error.

Respect SPECIALISE pragmas even for apparently-non-overloaded things

This is an implementation matter really (the key word is "apparently"!).
See Note [Specialising in no-dict case] in DsBinds.

It showed up when compiling GHC.Float.

Comment out debug warnings; they are fine

Improve error locations

More on Trac #597

Spelling error in comment

A little refactoring, plus improve error locations

Fixes some sub-items of Trac #597

Clarify error message (Trac #3805)

Comments only

SpecConstr: Remove -fspec-inline-join-points, and add let-binding specialisation

The -fspec-inline-join-point thing was a gross hack intended to help
Roman play around, but he's not using it and it was a terribly blunt
instrument so I've nuked it.

Instead I've re-instated the let-binding specialiser.
See Note [Local let bindings]

Make SpecConstr more informative output when there are too many specialisations

It now says something like

  SpecConstr
    Function `happyDoAction'
      has 17 call pattterns, but the limit is 3
    Use -fspec-constr-count=n to set the bound
    Use -dppr-debug to see specialisations

Previously it just silently did no specialisation

Make view patterns right-associate

So that you can write

   f (v1 -> v2 -> pat)

Improve the handling of default methods

See the long Note [INLINE and default methods].

This patch changes a couple of data types, with a knock-on effect on
the format of interface files.  A lot of files get touched, but is a
relatively minor change.  The main tiresome bit is the extra plumbing
to communicate default methods between the type checker and the
desugarer.

Patch for shared libraries support on FreeBSD
From Maxime Henrion <mhenrion@gmail.com>

Following Simon M's "take newCAF() out from sm_mutex" patch

Very minor refactoring

Undo the fix for Trac #3772 and do it a new way

The main idea is that I'm now treating a single-method dictionary very
much like a multi-method dictionary.  In particular, it respond to
exprIsConApp_maybe, even though newtypes aren't *really* proper
constructors.

See long comments with Note [Single-method classes] for why
this slight hack is justified.

Fix warnings

Improve error message (idea in Trac #3805)

If we see

   foreign export ccall foo :: ...blah...

we now use the "foreign" to suggest -XForeignFunctionInterface

Comments only

Continue refactoring the core-to-core pipeline

This patch mainly concerns the plumbing for running
the passes and printing intermediate output

A bunch of stuff relating to substitutions on core

* I was debugging so I added some call-site info
  (that touches a lot of code)

* I used substExpr a bit less in Simplify, hoping to
  make the simplifier a little faster and cleaner

Refactor CoreArity a bit

I was experimenting with making coercions opaque to
arity.  I think this is ultimately the right thing to do
but I've left the functionality unchanged for now.

Wibbles to inlining for small functions

See Note [INLINE for small functions]

Print out a bit more info with the "arity decrease" waring

Move isDictTy from TcType to Type

Allow instance heads to use infix syntax

  class C a b
  instance Int `C` Bool

This was accidentally disallowed before.

Fix pretty-printer

Fix Trac #3792: check for qualified names in import items

Fix bugs in STG Lint

The Stg Lint failure reported in Trac #3789 were bogus.
This patch fixes STG Lint, which must have been unused
for ages.

Refactor PackageTarget back into StaticTarget

Follow PackageTarget changes in pprCEntity

Assume CmmLabels have dynamic linkage on non-Windows

Follow PackageTarget change in byte code generator

When compiling viac, don't need to emit prototypes for symbols in the RTS

Follow ForeignLabel changes in PPC NCG

Tag ForeignCalls with the package they correspond to

Nicer panic message

Typo in comment

Windows DLLs: use DLL aware runSparks_closure instead of base_GHCziConc_runSparks_closure directly

locateOneObj: don't look for dynamic libs in static mode
also replace picIsOn with isDynamicGhcLib, as __PIC__ is not the
correct test for whether the GHC library is dynamically linked.

Substantial improvements to coercion optimisation

The main purpose of this patch is to add a bunch of new rules
to the coercion optimiser.  They are documented in the (revised)
Appendix of the System FC paper.

Some code has moved about:

- OptCoercion is now a separate module, mainly because it
  now uses tcMatchTy, which is defined in Unify, so OptCoercion
  must live higehr up in the hierarchy

- Functions that manipulate Kinds has moved from
  Type.lhs to Coercion.lhs.  Reason: the function typeKind
  now needs to call coercionKind.  And in any case, a Kind is
  a flavour of Type, so it builds on top of Type; indeed Coercions
  and Kinds are both flavours of Type.

  This change required fiddling with a number of imports, hence
  the one-line changes to otherwise-unrelated modules

- The representation of CoTyCons in TyCon has changed.   Instead of
  an extensional representation (a kind checker) there is now an
  intensional representation (namely TyCon.CoTyConDesc).  This was
  needed for one of the new coercion optimisations.

Whitespace only

Use a shell script, rather than perl script, to make flags.xsl

Rolling back: Make FastString thread-safe.

This patch was the cause of the compile-time performance regression in
#3796.  My guess is that it is due to the use of unsafePerformIO which
traverses the stack up to the first update frame, and perhaps we have
a deep stack when reading the dictionary from a .hi file.  In any
case, since we're not relying on thread safety for FastStrings, I
think the safest thing to do is back this out until we can investigate
further.

take newCAF() out from sm_mutex; use the capability-local mut list instead

Use local mut lists in UPD_IND(), also clean up Updates.h

use local mut lists rather than global mut lists in sequential GC

Allow throwTo() to be called without a source thread
Returns false if the exception could not be thrown becuase the tartget
thread was running.  Not used yet, but might come in handy later.

If ACTIVITY_INACTIVE is set, wait for GC before resetting it
I don't think this fixes any real bugs, but there's a small
possibility that when the RTS is woken up for an idle-time GC, the IO
manager thread might be pre-empted which would prevent the idle GC
from happening; this change ensures that the idle GC happens anyway.

Fix rules/build-dependencies.mk on OS X
Also more comments on why we have the sed rules that we do.

Copying Simon M's fix for 650 to the new codegen

Better error checking and code cleanup

Add comments to darcs-all

The comments explain how darcs-all decides what repo to use

Fix Trac #3772: dict funs for single-field classes

This patch fixes a bug that meant that INLINE pragamas on
a method of a single-field class didn't work properly.

See Note [Single-method classes] in TcInstDcls, and Trac #3772

Comments only (about implementing SPECIALISE pragmas)

A bit of refactoring, plus a sanity check

Check that a bottoming rhs does indeed get exposed with bottoming strictness
Almost all the changed lines reflect some refactoring of tidyTopIdInfo.

Fix Trac #3776

An easy fix.  See Note [Usage for sub-bndrs] in RnEnv.

Move all the CoreToDo stuff into CoreMonad

This patch moves a lot of code around, but has zero functionality change.
The idea is that the types

    CoreToDo
    SimplifierSwitch
    SimplifierMode
    FloatOutSwitches

and

    the main core-to-core pipeline construction

belong in simplCore/, and *not* in DynFlags.

Always expose the unfolding of something with an InlineRule

Previously a bottoming function with a strictness wrapper
had a hidden inlining, and that was Very Bad, because in
    f x = if ... then bot_fun x else x+1
we really want to pass the *unboxed* x to bot_fun. This
happens quite a bit in error handling code, eg for array
indexing.

Comments only

Move loop-breaker info from original function to worker in work/wrap

When doing a w/w split, if the original function is a loop breaker
then the worker (not the wrapper) becomes one instead.

This isn't very important, because loop breaker information is
recalculated afresh by the occurrence analyser, but it seems more
kosher.  And Lint was bleating piteously about things with InlineRules
that were loop breakers.

Make -ddump-inlinings and -ddump-rule-firings less noisy

By default, these two now print *one line* per inlining or rule-firing.

If you want the previous (voluminous) behaviour, use -dverbose-core2core.

Make warning printing a bit less noisy

Use -dppr-debug to make it noisy again

Set fixity (left-assoc) for setIdOccInfo

Comments only

Add an extra heading in the output for count_lines

Fixes to account for the new layout of MUT_ARR_PTRS (see #650)

Partial support for Haiku (#3727)

Fix #3751, also fix some lexical error SrcLocs

kill some old GRAN/PARALLEL_HASKELL code

improve panic messages for srcLocLine, srcLocCol

Tweak the build-dependencies rule, and add comments for it

When removing $(TOP) with sed, do so case insensitively
This avoids problems on Windows, where drive letters may not be the
case we expect.

Fix a braino in a comment

Avoid a failing shell command when cleaning
It wasn't fatal, but better to avoid it anyway

Fix another sed problem on Solaris

unused named variables

missed a case in a previous fix

Here's the obscure problem:
-- However, we also want to allow an assignment to be generated
-- in the case when the types are compatible, because this allows
-- some slightly-dodgy but occasionally-useful casts to be used,
-- such as in RtClosureInspect where we cast an HValue to a MutVar#
-- so we can print out the contents of the MutVar#.  If we generate
-- code that enters the HValue, then we'll get a runtime panic, because
-- the HValue really is a MutVar#.  The types are compatible though,
-- so we can just generate an assignment.

Fix #650: use a card table to mark dirty sections of mutable arrays
The card table is an array of bytes, placed directly following the
actual array data.  This means that array reading is unaffected, but
array writing needs to read the array size from the header in order to
find the card table.

We use a bytemap rather than a bitmap, because updating the card table
must be multi-thread safe.  Each byte refers to 128 entries of the
array, but this is tunable by changing the constant
MUT_ARR_PTRS_CARD_BITS in includes/Constants.h.

Fix build with Solaris sed
Rather than trying to handle tabs with sed portably, we just use tr to
remove them before we start.

Build and install inplace the count_lines and compareSizes utils