When tidying a TyVar binder, we must tidy its kind if it's a coercion
variable!  I had forgotten to do this, which is a serious bug.  As a
result some more complicated programs were getting a Lint error when
reading in interface files.  Score one for Core Lint!

  ** MERGE into 6.6.1 **

	MERGE to 6.6.1

For class-ops, record selectors, data constructors, we want the ru_local
field of the Rule to be False.  We do not attach the rule to the binding
for the Id, because there simply isn't a binding until the code gen stage.

(NB: the ru_local field is different to the orphan-hood of the rule.)

This fixes a bug that meant that RULES on class ops were never exported.

	Please MERGE to 6.6.1

Consider this RULE
    forall (c::Char->Int) (x::Char). 
	f (c x) = "RULE FIRED"

Well, this should only match on arguments of the specified type
But we simply weren't checking this condition before.  Now we are.

Test is simplrun008

I realized that compiling many files is just like compiling a single file
several times. This does sound a bit stupid and I wonder why I didn't
catch it before.

When building a dynamic GHC, we obviously want to build the dynamic library
libHSghc_dyn.[so|dylib] before building the compiler executable.

MERGE TO STABLE

The official options to use for building a dylib on Mac OS X are now
-undefined dynamic_lookup -single_module -Wl,-macosx_version_min -Wl,10.3
... which should work on all arches (10.3 or later).

MERGE TO STABLE

The module that GHCi uses for its default scope should be exactly
base:Prelude, not whatever Prelude is found on the search path.

When GHCi compiles its code framgents for setting buffering, it wants
to refer to base:System.IO rather than whatever System.IO is on the
search path, unfortunately there's no way to do this in source code,
so to hack around it we set the search path to empty before compiling
these expressions (not forgetting to flush the finder cache
afterward).

Unless we're in one-shot mode, emit an error if we attempt to
demand-load interfaces for home modules.  This can only happen in one
way (that I'm aware of): typing a qualified name at the GHCi prompt
that refers to a module that isn't loaded.  Previously you got a
cryptic message about not finding an interface file, now you get:

Prelude> Foo.a

<interactive>:1:0:
    attempting to use module `Foo' (Foo.hs) which is not loaded

Of course you can still refer to package modules like this without
loading them explicitly, only home modules are affected, and the
behaviour is exactly the same as if you try to ':browse Foo' and
Foo isn't loaded.

-optdep--include-module and --optdep--exclude-directory were features
of the old mkdependHS script but weren't implemented when mkdependHS
was merged into GHC.

This fixes Trac #1065.  The fix is just to emit a decent error message
rather than crash.  The situation is this:

  f x = ... [d| $(..stuff..); 
                f x = v :: T |] ...

TH wants to rename and typecheck the bracket; but it can't run the 
nested splice yet.  That seems hard, because we know nothing about v, T,
which are, presumably bound by the splice.

The original TH paper says this isn't allowed, and now it's checked for
properly (in the parser, in fact) rather than causing a crash.  In the
fullness of time we might want to do something more flexible, but not now.

This patch adds a flag -ddump-mod-cycles to the "ghc -M" dependency analyser.

The effect of
	ghc -M -ddump-mod-cycles
is to dump a list of cycles foud in the module graph.  The display is
trimmed so that only dependencies within the cycle are shown; and the
list of modules in a cycle is itself sorted into dependency order, so that
it is easy to track the chain of dependencies.

Open question: should the flag be "-ddump-mod-cycles" or "-optdep-dump-mod-cycles"?  For this reason I have not yet added to the documentation.

Hs-boot files can contain instance declarations, but Duncan used this feature
for the first time today, and it didn't quite work.  I'm not sure whether
it worked before; anyway it does now.

The point is that the hs-boot file advertises an instance for, say, Num Int,
with the arbitrary name $fx1.  The main module declares Num Int, and gives
it the name, say, $f3.  So we need to generate a declaration
	$fx1 = $f3
to make it all line up.  And (this is the bit that was wrong) we need
to make that new binding visible to imported unfoldings that mention
$fx1.

Gcc 4 is doing more clever optimizations than earlier gccs. 
These changes let ghc compile and run on ia64 with gcc 4.0.3.

Register stack frames are enlarged so that all functions use the 
same size stack frame.
The code to mangle tail calls has been cleaned up and made more 
general.
Additional floating-point and special-purpose registers used by 
GCC are saved upon entering the STG runtime.
More general handling of NOP instructions.
Handling of functions with multiple epilogues or no epilogue.

Tail-calls now branch to the end of the function after the call.  This 
stops gcc from trying to move instructions into the space immediately 
after the call, which confuses the mangler.