unbreak "recompile utils with stage 1"

Checking that type indexes contain no synonym family applications

RHS of a type instance must be a tau type

Overlap check for type families
- If two "type instance"s overlap, they right-hand sides must be syntactically
  equal under the overlap substitution.  (Ie, we admit limited overlap, but
  require the system to still be confluent.)

Further compileToCore improvements

Per suggestions from Simon M:

* Changed GHC.checkModule so that it doesn't call depanal.
* Changed GHC.checkModule to optionally return Core bindings
as a component of the CheckedModule that it returns (and
resulting changes to HscMain.hscFileCheck).
* As a result, simplified GHC.compileToCore and changed it
to load the given file so that the caller doesn't have to.

Fixed a documentation error

disable .type directives on Windows; they confuse mingw's assembler

Set .type @object for all global symbols in NCG

When linking against a dynamic library, the linker will emit a warning
if no type information is present within the library. We generate the
most trivial type for all externally visible labels, namely @object.

Also make proper references when not using fPIC but linking against dynamic libs

Generate RelocatableReadOnlyData as .data

The GNU linker expects read-only sections to be relocation
free. Presumably because the dynamic linker maps all read-only
sections as read-only mmaps and hence can't do relocations.

If we want text-relocation-free shared libraries we have to put all
relocations into writable sections, hence .data.  See
http://www.mail-archive.com/cvs-all@haskell.org/msg15119.html

Generalize linkDynLib for ELF platforms

To create a dynamic shared object (DSO) on ELF platforms, we invoke
"gcc -shared". This in turn invokes ld. We supply -Bsymbolic to the
linker, as "ld -Bsymbolic -shared -o <lib> <objs>" resolves all
references from <objs> to <objs> at library creation time.

See http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode

Renames functions and constructors to fit their new ability for dynamic linking
function: staticLink -> linkBinary (will link non static binaries too)
function: doMkDLL -> linkDynLib (as we can link on ELF too where DLL is an inappropriate term)
constructor: MkDLL -> LinkDynLib

PprMach.hs more accurate hack for x86-64, CmmLabelOff is not a relative reference.

CmmLabelDiffOff are generated in .text and if printed as .quad, causes
the assembler to emit a PC64 relocation. binutils prior to 2.17 don't
understand PC64 relocation properly.

pprDataItem is also used for printing SRT description tables. They are
part of the .data section and there no PC relative relocations are
emited. Hence, if we print a .long here, we get a absolute 32-bit
relocation. 32-bit relocations are problematic in dynamic libraries,
because dynamic library load addresses are loaded beyond the 32 bit
boundary, causing the dynamic linker to warn at dynamic linking
(loading the executable) that there are overflows in the
relocation. The executable still seems to work because of the small
memory model, but this is obviously wrong. Hence, remove CmmLabelOff
from the classification, causing these references to be printed as
.quad, causing correct 64-bit relocation as in the rest of the .data
section.

So, this hack now prints PC32 relocations in .text (mostly in the info
tables), and absolute 64-bit relocations in .data.

Fix typechecking bug with implicit parameters (Trac #1445)

tcSplitFunTy_maybe wasn't dealing with types like
(?x::Bool) => Int
Here, tcSplitFunTy_maybe should fail (as it would if there
was a for-all), because the type is a quantified type.

See Trac #1445, and test tc230.

White space only

Improve error message when there is instance overlap

Modify compileToCore to take just a filename

Modified compileToCore to take just a session and a
filename, rather than a module name as well, since the module
name can be computed from the filename.

making hpc live

+RTS -xbXXXXX sets the "heap base" to 0xXXXXXX
When debugging the GC and storage manager we often want repeated runs
of the program to allocate memory at the same addresses, so that we
can set watch points.  Unfortunately the OS doesn't always give us
memory at predictable addresses.  This flag gives the OS a hint as to
where we would like our memory allocated.  Previously I did this by
changing the HEAP_BASE setting in MBlock.h and recompiling, this patch
just adds a flag so I don't have to recompile.

+RTS -V0 disables the interval timer completely (for repeatable debugging)

FIX BUILD (on Windows): follow changes to make threaded RTS compile with -fasm

Fix names of coercions in newtype instances
- Thanks to Roman for spotting the problem.

Cleaning up Hpc.c; adding support for reflection into Hpc.

Fixing Makefile hpc to use compat

Adding Tix to compat library, so that hpc in utils can use it

fixing creation of directory for html output; fixing html markup for 0% bars.

Fixing -fhpc flag to allow -fno-hpc

Fixed deriving of associated data types
- We forgot to pull the data declarations nested in class instances out of
  the instances when collecting all the predicates that we need derive.
  Thanks to Roman for spotting this.

add missing case for compiling 64-bit operations on x86

Make the threaded RTS compilable using -fasm
We needed to turn some inline C functions and C macros into either
real C functions or C-- macros.

x86_64: fix a few bugs in the >8 floating point args case

make inplace scripts less sensitive to /bin/sh quoting by avoiding \

excluding Trace.Hpc.* when using the compat library

Making -fhpc work with a stage1 build, via the compat 'package'.

Adding hpc lib as part of the compat 'package'

Cleanup Hpc sub-system, remove hpc-tracer implementation.

Add a compileToCore function to the GHC API

Added a compileToCore function to the GHC API that takes a
  session, module, and filename, and returns a list of Core
  bindings if successful. This is just a first try and could
  probably be improved (for example, there's probably a way to
  get the filename from the module so that it doesn't have to
  be passed in, I just don't see it offhand.)

Define SUBDIRS in Makefile (needed for clean; fixes trac #1440)

Tweak the configuration and installation slightly
Make it so that the documentation ends up where Cabal expects it to be
on Windows (prep-bin-dist-mingw used to move it).

withExtendedLinkerState: don't revert the whole state
Fixes test failures print017 and print024

Print infix type constructors in an infix way

Fixes Trac #1425.  The printer for types doesn't know about fixities.
(It could be educated to know, but it doesn't at the moment.)  So it
treats all infix tycons as of precedence less than application and function
arrrow.

I took a slight shortcut and reused function-arrow prededence, so I think
you may get
T -> T :% T
meaning
T -> (T :% T)

If that becomes a problem we can fix it.

Clamp -O flag to beween 0 and 2

Fixes Trac #1272

Adding hpc tools, as a single program.

Update version numbering policy in the users guide

Fix an error message
`y' in the error message
    `x' is not a (visible) method of class `y'
had gone missing.

turning off -fhpc in stage1 built ghc

removing -fhpc-tracer from ghc, is subsumed by the GHC debugger

Stage2 now used the package hpc to get the hpc datastructures
Stage1 no longer supports hpc (-fhpc is ignored)

Fix typo in Makefile

Adding hpc package to ghc core libraries

Change how the libraries Makefile adds --configure-option= flags; fixes #1431
We now assume that each configure option is quoted with '', and thus
replace " '" with " --configure-option='".

update with new libraries

FIX BUILD on Windows: horrible hack to work around make(?) bug

FIX BUILD (on Windows): Cabal must invoke compiler/stage1/ghc-inplace
not compiler/ghc-inplace, which is a symlink.

remove unnecessary cruft

FIX BUILD: all builds need --template, not just Windows

ignore all but the last --template option

Unbreak the stage-2 compiler (record-type changes)

-fglasgow-exts implies -X=GADTs

FIX read040: patterns with type sig on LHS of do-binding

f () = do { x :: Bool <- return True; ... }

For some reason the production for 'pat' required 'infixexp' on the
LHS of a do-notation binding.  This patch makes it an 'exp', which
thereby allows an expression with a type sig.

Happily, there are no new shift-reduce errors, so I don't think this
will break anything else.

Another wibble to the head-exploded error message (suggested by David Roundy)

Use the correct flag for controlling scoped type variables in an instance decl

Improve 'my head exploded' error message

FIX BUILD: add missing prime!

FIX BUILD on Windows: horrible hack to work around make(?) bug

yet more fixes: Cygwin broke this time

fix bugs with hsc2hs-inplace

mk/build.mk is optional

further fixes to the inplace scripts

use a binary for hsc2hs-inplace too

Fix problems with new inplace stuff on Cygwin

FIX BUILD: can't build the makefiles during make boot

clean up lib/{GNUmakefile,Makefile.local}

default_target should be "all", not "build"

add comment

Fix a problem with package.mk being included too early

Use setup makefile + make by default to build libraries

The advantages of this are
  (a) it's a step closer to getting -j working again (make -j works in
      an individual library, but not in libraries/ yet).
  (b) it's easier to hack on libraries: make dist/build/Foo.o
  (c) it's a step closer to getting HC bootstrapping again

The build system creates <lib>/GNUmakefile as part of 'make boot'.
This was chosen so as not to interfere with existing Makefiles, but
it's a bit of a hack.  (previously I used CabalMakefile, but that
means adding -f CabalMakefile each time you run make, and that's a
pain).

Use a real binary instead of scripts for ghc-inplace
Fixes various problems with getting the scripts right on Windows.
Binaries are universally executable by /bin/sh, cmd.exe and rawSystem,
so this allows us to remove some platform-specific hacks.

Add several new record features

1. Record disambiguation (-fdisambiguate-record-fields)

In record construction and pattern matching (although not
in record updates) it is clear which field name is intended
even if there are several in scope.  This extension uses
the constructor to disambiguate.  Thus
C { x=3 }
uses the 'x' field from constructor C (assuming there is one)
even if there are many x's in scope.

2. Record punning (-frecord-puns)

In a record construction or pattern match or update you can
omit the "=" part, thus
C { x, y }
This is just syntactic sugar for
C { x=x, y=y }

3.  Dot-dot notation for records (-frecord-dot-dot)

In record construction or pattern match (but not update)
you can use ".." to mean "all the remaining fields".  So

C { x=v, .. }

means to fill in the remaining fields to give

C { x=v, y=y }

(assuming C has fields x and y).  This might reasonably
considered very dodgy stuff.  For pattern-matching it brings
into scope a bunch of things that are not explictly mentioned;
and in record construction it just picks whatver 'y' is in
scope for the 'y' field.   Still, Lennart Augustsson really
wants it, and it's a feature that is extremely easy to explain.

Implementation
~~~~~~~~~~~~~~
I thought of using the "parent" field in the GlobalRdrEnv, but
that's really used for import/export and just isn't right for this.
For example, for import/export a field is a subordinate of the *type
constructor* whereas here we need to know what fields belong to a
particular *data* constructor.

The main thing is that we need to map a data constructor to its
fields, and we need to do so in the renamer.   For imported modules
it's easy: just look in the imported TypeEnv.  For the module being
compiled, we make a new field tcg_field_env in the TcGblEnv.
The important functions are
RnEnv.lookupRecordBndr
RnEnv.lookupConstructorFields

There is still a significant infelicity in the way the renamer
works on patterns, which I'll tackle next.

I also did quite a bit of refactoring in the representation of
record fields (mainly in HsPat).***END OF DESCRIPTION***

Place the long patch description above the ***END OF DESCRIPTION*** marker.
The first line of this file will be the patch name.

This patch contains the following changes:

M ./compiler/deSugar/Check.lhs -3 +5
M ./compiler/deSugar/Coverage.lhs -6 +7
M ./compiler/deSugar/DsExpr.lhs -6 +13
M ./compiler/deSugar/DsMeta.hs -8 +8
M ./compiler/deSugar/DsUtils.lhs -1 +1
M ./compiler/deSugar/MatchCon.lhs -2 +2
M ./compiler/hsSyn/Convert.lhs -3 +3
M ./compiler/hsSyn/HsDecls.lhs -9 +25
M ./compiler/hsSyn/HsExpr.lhs -13 +3
M ./compiler/hsSyn/HsPat.lhs -25 +63
M ./compiler/hsSyn/HsUtils.lhs -3 +3
M ./compiler/main/DynFlags.hs +6
M ./compiler/parser/Parser.y.pp -13 +17
M ./compiler/parser/RdrHsSyn.lhs -16 +18
M ./compiler/rename/RnBinds.lhs -2 +2
M ./compiler/rename/RnEnv.lhs -22 +82
M ./compiler/rename/RnExpr.lhs -34 +12
M ./compiler/rename/RnHsSyn.lhs -3 +2
M ./compiler/rename/RnSource.lhs -50 +78
M ./compiler/rename/RnTypes.lhs -50 +84
M ./compiler/typecheck/TcExpr.lhs -18 +18
M ./compiler/typecheck/TcHsSyn.lhs -20 +21
M ./compiler/typecheck/TcPat.lhs -8 +6
M ./compiler/typecheck/TcRnMonad.lhs -6 +15
M ./compiler/typecheck/TcRnTypes.lhs -2 +11
M ./compiler/typecheck/TcTyClsDecls.lhs -3 +4
M ./docs/users_guide/flags.xml +7
M ./docs/users_guide/glasgow_exts.xml +42

Remove the unused HsExpr constructor DictPat

Fix a bug in MatchCon, and clarify what dataConInstOrigArgTys does

There was an outright bug in MatchCon.matchOneCon, in the construction
of arg_tys.  Easily fixed.  It never showed up becuase the arg_tys are
only used in WildPats, and they in turn seldom have their types looked
(except by hsPatType).  So I can't make a test case for htis.

While I was investigating, I added a bit of clarifation and
invariant-checking to dataConInstOrigArgTys and dataConInstArgTys

Do not perform a worker/wrapper split for a NOINLINE function

This came up in an email exchange with Duncan Coutts in May 2007.
If a function is marked NOINLINE there is really no point in
doing a worker/wrapper split, because the wrapper will never
be inlined.

Fix Trac #1402: typo in specialiser

This patch fixes a plain bug in the specialiser (rhs_bndrs instead
of rhs_ids) which made GHC crash in obscure cases.

It exposed a case in which we might not do all possible specialisation;
see Note [Specialisation shape].  It's not an important case, but I've
added a warning in DEBUG mode.

Trac #1402.  Test is spec003.hs

Wibble: make -fno-implicit-prelude work

Remove an incorrect claim that [t| ... |] isn't implemented yet

Make building haddock docs opt-in rather than opt-out

Don't assume that the main repo is called "ghc" in darcs-all
Fixes working in branches where that isn't true.

Trivial fix to clear Trac #1386

Wibbles in flaggery, concerning backward compatibility with -f flags

Implement -X=GADTs and -X=RelaxedPolyRec

Two new -X flags, one for GADTs and one for relaxed polymorphic recursion

This also fixes a rather confusing error message that the Darcs folk
tripped over.

Use -X for language extensions

We've often talked about having a separate flag for language extensions,
and now we have one. You can say

-XImplicitParams
-X=ImplicitParams
-Ximplicit-params

as you like.  These replace the "-f" flags with similar names (though
the -f prefix will serve as a synonym for -X for a while).

There's an optional "=", and the flag is normalised by removing hyphens
and lower-casing, so all the above variants mean the same thing.

The nomenclature is intended to match the LANGUAGE pramgas, which are
defined by Cabal.  So you can also say

{-# LANGUAGE ImplicitParams #-}

But Cabal doesn't have as many language options as GHC does, so the -X
things are a superset of the LANGUAGE things.

The optional "=" applies to all flags that take an argument, so you can,
for example, say

-pgmL=/etc/foo

I hope that's ok.  (It's an unforced change; just fitted in.)

I hope we'll add more -X flags, to replace the portmanteau -fglasgow-exts
which does everything!

I have updated the manual, but doubtless missed something.

Unused import

turning back on case liberation when using hpc

remove debugging code accidentally left in

Use .NOTPARALLEL for the libraries Makefile

Improve the handling of deriving, in error cases

I'd been too ambitious with error handling for 'deriving', and got it
entirely wrong.  This fixes it.  See extensive
Note [Exotic derived instance contexts]
in TcSimplify.  (Most of the extra lines are comments!)

More refactoring in TcSimplify

This re-jig tides up the top-level simplification, and combines in one
well-commented function, approximateImplications, the rather ad-hoc
way of simplifying implication constraints during type inference.

Error messages get a bit better too.

Fix egregious sharing bug in LiberateCase

Andy Gill writes: consider the following code

       f = g (case v of
                V a b -> a : t f)

where g is expensive. Liberate case will turn this into

       f = g (case v of
               V a b -> a : t (letrec f = g (case v of
                                             V a b -> a : f t)
                                in f)
             )
Yikes! We evaluate g twice. This leads to a O(2^n) explosion
if g calls back to the same code recursively.

This may be the same as Trac #1366.

Turning off case liberation when using the hpc option, for now

Consider the following code

     f = g (case v of
              V a b -> a : t f)

where g is expensive. Liberate case will turn this into

     f = g (case v of
             V a b -> a : t (letrec f = g (case v of
                                           V a b -> a : f t)
                              in f)
           )

Yikes! We evaluate g twice. This leads to a O(2^n) explosion
if g calls back to the same code recursively.

This happen sometimes in HPC, because every tick is a liberate-able case,
but is a general problem to case liberation (I think).

Add --core-only flag to push-all