Make ghc quieter about modules its skipping

[Donald Bruce Stewart]

When building large projects with cabal these days, ghc --make will emit 
lots of "Skipping ..." messages when recompiling. This patch adds
make-like quietness, making it much easier to see what things changed:

For example, instead of 78 lines of 'Skipping' messages, rebuilding
lambdabot without changing anything instead emits:

    $ ./Setup.hs build
    Preprocessing executables for lambdabot-4.0...
    Building lambdabot-4.0...
    Chasing modules from: Main.hs
    dist/build/lambdabot/lambdabot is up to date, linking not required.

Changing one file in the 70-odd, will print:

    Preprocessing executables for lambdabot-4.0...
    Building lambdabot-4.0...
    Chasing modules from: Main.hs
    [33 of 76] Compiling Lambdabot ( Lambdabot.hs, dist/build/lambdabot/lambdabot-tmp/Lambdabot.o )
    Linking dist/build/lambdabot/lambdabot ...

Possibly we should also disable the 'linking not required' messages as well.

-- Don
-------------- next part --------------

New patches:

[Don't emit 'Skipping' messages unless -v2 or higher is on
Don Stewart <dons at cse.unsw.edu.au>**20060610145713
 
 Following GNU make, this patch makes GHC not emit messages about modules
 its skipping. This makes builds much quieter, and its a lot easier to
 work out what effects a change had on the code.
 
 The current behaviour can be recovered with -v2
 
] {
hunk ./compiler/main/HscMain.lhs 400
-            else showMsg "Skipping  "
-
-
+            else if verbosity (hsc_dflags hsc_env) >= 2
+                    then showMsg "Skipping  "
+                    else return ()
}

Context:

[Make rule-matching robust to lets
simonpj at microsoft.com**20060525154447
 
 Consider a RULE like
 	forall arr. splitD (joinD arr) = arr
 
 Until now, this rule would not match code of form
 	splitD (let { d = ... } in joinD (...d...))
 because the 'let' got in the way.
 
 This patch makes the rule-matcher robust to lets.  See comments with
 the Let case of Rules.match.
 
 This improvement is highly desirable in the fusion rules for NDP
 stuff that Roman is working on, where we are doing fusion of *overloaded*
 functions (which may look lazy).  The let expression that Roman tripped
 up on was a dictioary binding.
 
] 
[Improve error reporting in interface typechecking
simonpj at microsoft.com**20060525094545] 
[Fix egregious and long-standing tidying bug
simonpj at microsoft.com**20060525094300
 
 A typo in tidyAlt meant that we could get shadowing of occurrence names
 in the output of tidying.  (Specifically, of existentially bound type 
 variables.)  That in turn meant that an IfaceExpr could have shadowing, so
 when the IfaceExpr was read in, it meant something different.
 That in turn led to an obscure crash like:
 	Panic: tcIfaceTyVar
 
 Anyway, this fixes it.  MERGE into 6.4.3.
 
 
] 
[Prune imports
simonpj at microsoft.com**20060525094251] 
[performGC_(): don't use the existing Task, always grab a new one
Simon Marlow <simonmar at microsoft.com>**20060525090035] 
[Better control of the IO manager thread; improvements to deadlock checking
Simon Marlow <simonmar at microsoft.com>**20060524122839
     
 In the threaded RTS on *nix platforms:
     
  - we now start the IO manager thread eagerly at startup time
    (previously was started on demand).
 
  - we now ask the IO manager thread to stop at shutdown
     
  - In Timer.c:handle_tick, if it looks like we might be in a
    deadlock, instead of calling prodOneCapability() which was known to be
    wrong, we now send a byte down the IO manager's pipe to wake it up.
   
 This also avoids a case of double-acquisition of a mutex, which
 happened if prodOneCapability() was called while the current thread
 was holding a mutex.
] 
[TARGET_OS ==> HOST_OS
Simon Marlow <simonmar at microsoft.com>**20060524122103] 
[fix a _TARGET_ARCH that should be _HOST_ARCH
Simon Marlow <simonmar at microsoft.com>**20060524122022] 
[we don't need OutOfHeapHook(), and the version in the RTS has a better message
Simon Marlow <simonmar at microsoft.com>**20060524112007] 
[Bug-fix to patch "Run simplifier before SpecConstr"
simonpj at microsoft.com**20060523130022] 
[Run simplifier before SpecConstr
simonpj at microsoft.com**20060523085546
 
 Arrange to run the simplifier before SpecConstr, to (almost entirely) 
 eliminate shadowing.
 
 Reason: otherwise SpecConstr can generate a RULE that never
 files; and LiberateCase specifically *does* generate lots of shadowing.
 
 See Note [Shadowing] in SpecConstr.lhs
 
 
] 
[Prune imports
simonpj at microsoft.com**20060522192532] 
[Add deShadowBinds
simonpj at microsoft.com**20060522192404
 
 Add CoreSubst.deShadowBinds, which removes shadowing from 
 a Core term.  I thought we wanted it for SpecConstr, but in 
 fact decided not to use it. Nevertheless, it's a useful sort
 of function to have around, and it has a particularly simple
 definition!
 
] 
[Inline in a call argument if the caller has RULES
simonpj at microsoft.com**20060522163255
 
 This is an experimental change suggested by Roman.  Consider
 	
 	{-# INLINE f #-}
 	f x y = ...
 
 	....(g (f a b))...
 
 where g has RULES.  Then we'd like to inline f, even though the context of
 the call is otherwise 100% boring -- g is lazy and we know nothing about
 x and y. 
 
 This patch just records in the continuation that f has rules.  And does so
 somewhat recursively...e.g.
 
 	...(g (h (f a b)))...
 
 where g has rules.  
 
 
] 
[Add idHasRules
simonpj at microsoft.com**20060522163109
 
 Add Id.idHasRules :: Id -> Bool, with the obvious semantics.
 This patch makes sense by itself, but it's just a tidy-up.
 
 
] 
[Transmit inline pragmas faithfully
simonpj at microsoft.com**20060522110256
 
 *** WARNING: you will need to recompile your libraries 
 ***	     when you pull this patch (make clean; make)
 
 The inline pragma on wrapper-functions was being lost; this patch 
 makes it be transmitted faithfully.
 
 The reason is that we don't write the full inlining for a wrapper into
 an interface file, because it's generated algorithmically from its strictness
 info.  But previously the inline pragma as being written out only when we
 wrote out an unfolding, and hence it was lost for a wrapper.
 
 This makes a particular difference when a function has a NOINLINE[k] pragma.
 Then it may be w/w'd, and we must retain the pragma.  It's the only consistent
 thing to do really.
 
 The change does change the binary format of interface files, slightly.
 So you need to recompile all your libraries.
 
] 
[Improved RULE lhs typechecking; less dictionary sharing
simonpj at microsoft.com**20060519103433
 
 See long comment with Simplify.tcSimplifyRuleLhs.
 
 Here's the key example:
 
   RULE "g"  forall x y z. g (x == y) (y == z) = ...
 
 Here, the two dictionaries are *identical*, but we do NOT WANT to
 generate the rule
 
 RULE	forall x::a, y::a, z::a, d1::Eq a
 	  f ((==) d1 x y) ((>) d1 y z) = ...
 
 Instead we want
 
 RULE	forall x::a, y::a, z::a, d1::Eq a, d2:Eq a
 	  f ((==) d1 x y) ((>) d2 y z) = ...
 
] 
[Bug-fix for infix function definitions (parse/rename)
simonpj at microsoft.com**20060519095022
   
 Fix a crash provoked by
 
 	x `op` y = x
 	op       = True
 
 The trouble was that there is currently a single 'infix' flag for the
 whole group; and RnTypes.checkPrecMatch was therefore expecting the
 second eqn to have two args.
 
 This fixes the crash, and also or-s the infix flags for the various
 eqns together; previously it was just taken from the first eqn, which
 was wrong.
 
 
] 
[Remove misleading comments
simonpj at microsoft.com**20060519094936] 
[Fix a nasty continuation-duplication bug
simonpj at microsoft.com**20060518163617
 
 For a long-time mkDupableCont has had a bug that allows it to duplicate
 an arbitrary continuation, which it should not do, of course.
 
 The bug was that in the Select case of mkDupableCont we were calling
 prepareCaseCont, which did not duplicate the continuation if there is
 but a single alternative.  This is quite right in the case of the call
 in rebuildCase, but quite wrong in mkDupableCont.
 
 The bug manifest as follows. In the expression
 	f (case ... of { ..several alts.. })
 (when f is strict), we should transform to
 	f (...transformed arg...)
 The application of f should not be pushed down (see notes with the
 ArgOf case of mkDupableCont.  But that was not happening in an example
 like this (see how the call to f is pushed inwards).
 
 f (a `div` abs (b::Int))
 	--->
     case b_afT of wild_aHa { GHC.Base.I# x_aHc ->
     let {
       $j_sIe :: GHC.Prim.Int# -> GHC.Base.Int
       []
       $j_sIe =
 	\ (ds1_aHr [Nothing OneShot] :: GHC.Prim.Int#) ->
 	  Foo7.f
 	    (case ds1_aHr of ds2_aHq {
 	       __DEFAULT ->
 		 case a_afS of wild1_aHM { GHC.Base.I# x_aHO ->
 		 GHC.Base.I# (GHC.Base.divInt# x_aHO ds2_aHq)
 		 };
 	       0 -> GHC.Err.divZeroError @ GHC.Base.Int
 	     })
     } in 
       case GHC.Prim.>=# x_aHc 0 of wild1_aHe [Dead Nothing] {
 	GHC.Base.False ->
 	  let {
 	    ds1_aHr :: GHC.Prim.Int#
 	    []
 	    ds1_aHr = GHC.Prim.negateInt# x_aHc
 	  } in  $j_sIe ds1_aHr;
 	GHC.Base.True -> $j_sIe x_aHc
       }
     }
 
 
] 
[Make simplifier report which phase it is doing in -ddump output
simonpj at microsoft.com**20060518163448] 
[Comments only
simonpj at microsoft.com**20060518163425] 
[take parsec out of $(GhcBootLibs)
Simon Marlow <simonmar at microsoft.com>**20060518131506] 
[Improve documentation of INLINE pragmas
simonpj at microsoft.com**20060518113212] 
[a couple of additions
Simon Marlow <simonmar at microsoft.com>**20060518104025] 
[#define _REENTRANT 1   (needed to get the right errno on some OSs)
Simon Marlow <simonmar at microsoft.com>**20060518103715
 Partial fix for hanging problems on Solaris and possibly *BSD.
 A similar fix is also required to libraries/base/includes/HsBase.h.
] 
[Declare this file to be POSIX
Simon Marlow <simonmar at microsoft.com>**20060518102858
 This is simpler than using _POSIX_THREAD_SEMANTICS on Solaris to get
 the right version of ctime_r().
] 
[somewhere to keep track of release notes for 6.6
Simon Marlow <simonmar at microsoft.com>**20060518074415] 
[Newtype data constructors get a compulsory unfolding
simonpj at microsoft.com**20060517155009
 
 With this change, newtype data constructors get a "compulsory" unfolding,
 which means that they *must* be inlined, and no top-level definition of
 the constructor is provided at all.  Since these constructors are no-ops,
 I'm not sure why this wasn't the case all along.
 
] 
[White space only
simonpj at microsoft.com**20060517154936] 
[Retain InlinePragInfo on wrappers
simonpj at microsoft.com**20060517154725
 
 For some reason, when doing the worker/wrapper split, we transferred the
 InlinePragInfo from the original function, but expunging it from the wrapper.
 This meant, for example, that a NOINLINE function would have its wrapper
 inlined, which isn't sensible.
 
 For a change, fixing a bug involves only deleting code!
 
] 
[Spelling correction
simonpj at microsoft.com**20060517154710] 
[Retain INLINE pragma information during indirection-shorting
simonpj at microsoft.com**20060517154449
 
 During indirection-shorting, we were dropping the InlinePragInfo,
 although were were carefully retaining strictness info etc.  
 I think this is a long-standing bug.
 
] 
[Improve pretty-printing
simonpj at microsoft.com**20060517154349] 
[Comments only
simonpj at microsoft.com**20060517154304] 
[Improve pretty-printing slightly
simonpj at microsoft.com**20060517154204] 
[Let GHCi work with with Sparc32+/V8+ .o files
Duncan Coutts <duncan.coutts at worc.ox.ac.uk>**20060516090430
 Currently the GHCi linker looks exclusively for V7 ABI .o files.
 
 You can generate V8+ ABI .o files using flags to gcc such as:
  -optc-mcpu=ultrasparc -opta-mcpu=ultrasparc
 
 Note that this allows gcc to generate hardware integer division and
 hardware floating point instructions rather than using software emulation.
 All recent sparc hardware is V8+ or later. Perhaps we should check for the
 cpu generation in configure and use the later ABI if possible.
 
 Tested briefly on a SunBlade 100 (TI UltraSparc IIe) sparc-unknown-linux
] 
[match up more closely with compiler/main/DynFlags.hs:machdepCCOpts
Simon Marlow <simonmar at microsoft.com>**20060515090031
 In particular, add -fno-builtin to x86 and x86_64, which was missing.
] 
[set $(GhcVersion) and $(GhcPatchLevel) correctly when $(UseStage1)==YES
Simon Marlow <simonmar at microsoft.com>**20060510124621] 
[.raw_s and .s live in $(odir), not the source dir
Simon Marlow <simonmar at microsoft.com>**20060510121524] 
[additions from Reilly Hayes
Simon Marlow <simonmar at microsoft.com>**20060510120000] 
[some tweaks to the HC bootstrapping instructions
Simon Marlow <simonmar at microsoft.com>**20060510115236] 
[Ignore unboxed values in breakpoints.
Lemmih <lemmih at gmail.com>**20060510072722] 
[Don't read ~/.ghci on breakpoints.
Lemmih <lemmih at gmail.com>**20060509223455] 
[make it possible to define an alias for :quit
Simon Marlow <simonmar at microsoft.com>**20060509083124] 
[Do not put wired-in things in interface files
simonpj at microsoft.com**20060508142946
 
 There is no need for wired-in things to go into interface files; the compiler
 knows about them anyway.  Worse, it turns ou that if they are in an interface
 file, they may get read in with not-quite-right type info (e.g. GHC.Err.error),
 and the not-quite-right thing gets into the type envt.  Than it gets used 
 instead of the wired in thing.
 
 Best all round never to put them into interface files.  This is the way
 it used to be, but it looks as if it rotted away some time ago.
 
 (I noticed this when fixing unsafePerformIO stuff, becuase 'lazy' was getting
 an unfolding when it shouldn't.)
 
] 
[Remove NOINLINE strictness hack
simonpj at microsoft.com**20060508142834
 
 The stricteness analyser used to have a HACK which ensured that NOINLNE things
 were not strictness-analysed.  The reason was unsafePerformIO. Left to itself,
 the strictness analyser would discover this strictness for unsafePerformIO:
 	unsafePerformIO:  C(U(AV))
 But then consider this sub-expression
 	unsafePerformIO (\s -> let r = f x in 
 			       case writeIORef v r s of (# s1, _ #) ->
 			       (# s1, r #)
 The strictness analyser will now find that r is sure to be eval'd,
 and may then hoist it out.  This makes tests/lib/should_run/memo002
 deadlock.
 
 Solving this by making all NOINLINE things have no strictness info is overkill.
 In particular, it's overkill for runST, which is perfectly respectable.
 Consider
 	f x = runST (return x)
 This should be strict in x.
 
 So the new plan is to define unsafePerformIO using the 'lazy' combinator:
 
 	unsafePerformIO (IO m) = lazy (case m realWorld# of (# _, r #) -> r)
 
 Remember, 'lazy' is a wired-in identity-function Id, of type a->a, which is 
 magically NON-STRICT, and is inlined after strictness analysis.  So
 unsafePerformIO will look non-strict, and that's what we want.
 
 Now we don't need the hack in the strictness analyser.
 
] 
[Trim imports
simonpj at microsoft.com**20060508141804] 
[Trim imports
simonpj at microsoft.com**20060508141713] 
[GHC_MANGLER-->MANGLER
Simon Marlow <simonmar at microsoft.com>**20060508111206] 
[Fix bug #763: Breakpoint mechanism crashes when there's a type error.
Lemmih <lemmih at gmail.com>**20060505232158] 
[breakpointCond
Lemmih <lemmih at gmail.com>**20060502174340] 
[Preserve type variable names during type inference
simonpj at microsoft.com**20060505153753
 
 During unification we attempt to preserve the print-names of type variables,
 so that type error messages tend to mention type variables using the 
 programmer's vocabulary.  
 
 This had bit-rotted a bit when I added impredicative polymorphism; especially
 when unBoxing a boxy type variable we should not gratuitously lose its name.
 
] 
[Trim imports
simonpj at microsoft.com**20060505150506] 
[fixup for new source tree layout
Simon Marlow <simonmar at microsoft.com>**20060505114100] 
[FPTOOLS_TOP-->GHC_TOP, and remove some references to "fptools"
Simon Marlow <simonmar at microsoft.com>**20060505110520] 
[$(FPTOOLS_TOP) is now known as $(GHC_TOP)
Simon Marlow <simonmar at microsoft.com>**20060505110127
 I kept $(FPTOOLS_TOP) as an alias for $(GHC_TOP) while we switch
] 
[update the build system documentation
Simon Marlow <simonmar at microsoft.com>**20060505105843] 
[update for new source tree layout
Simon Marlow <simonmar at microsoft.com>**20060505102903] 
[partial update for new source tree layout
Simon Marlow <simonmar at microsoft.com>**20060505030218] 
[update for new source tree layout (untested)
Simon Marlow <simonmar at microsoft.com>**20060505081549] 
[Print a more helpful error for find_thing
simonpj at microsoft.com**20060504153337] 
[Fix a bug in rule matching
simonpj at microsoft.com**20060504112430
 
 The rule matcher uses a "rough-match" pre-filter, which was being too 
 aggressive.  The case looked like this:
 
 	rule:	f True
 	expr:	case e of x { True -> f x }
 
 Jues because x doesn't immediately look like True, we shouldn't say
 "can't match", but that is exactly what ruleCantMatch was doing.
 
 
] 
[Fix constructor-specialisation bug
simonpj at microsoft.com**20060504112131
 
 The constructor-specialisation optimisation was not dealing with the case
 of 
 	(letrec ... in f) a1 a2
 
 We need to apply constructor specialisation in the letrec; previously
 we were leaving it untouched on the grounds that the function part of
 an application is almost always a variable.
 
 But in fact, float-in immediately precedes SpecConstr, so we can get
 these odd-looking applications.
 
 
] 
[Fix precedence for records in derived Read
simonpj at microsoft.com**20060504111804
 
 The derived instance for Read of records wasn't quite right.
 Consider
 	data T = T1 T | T2 { x::Int }
 
 The string "T1 T2 { x=2 }" should parse correctly as 
 	T1 (T2 {x=2})
 because of Haskell's odd precedence rules (record construction binds
 even more tightly than application), but the derived Read didn't take
 account of that.
 
 drvrun020 is the regression test
 
 
] 
[Make rules available in RHS
simonpj at microsoft.com**20060504111500
 
 After some earlier re-factoring, the code that was carefully trying
 to make RULES available in a function's own RHS was plain wrong.
 
 This commit fixes it.  Some programs should go faster!
 
] 
[Pretty printing instance for Unfolding
simonpj at microsoft.com**20060504111429] 
[small clarification
Simon Marlow <simonmar at microsoft.com>**20060504103414] 
[small fix to booting instructions from #762
Simon Marlow <simonmar at microsoft.com>**20060504083104] 
[$(ProjectNameShort) => ghc
Simon Marlow <simonmar at microsoft.com>**20060503102419] 
[only pass -fno-unit-at-a-time to gcc if it is supported
Simon Marlow <simonmar at microsoft.com>**20060503093614] 
[Arrange that -fth is no longer implied by -fglasgow-exts
simonpj at microsoft.com**20060426182114
 
 Messages involving Template Haskell are deeply puzzling
 if you don't know about TH, so it seems better to make
 -fth an explicit flag.  It is no longer switched on
 by -fglasgow-exts.
 
] 
[remove code not required in the new source tree layout
Simon Marlow <simonmar at microsoft.com>**20060502114235] 
[move "compat" earlier in the build for .hc bootstrapping
Simon Marlow <simonmar at microsoft.com>**20060502112001] 
[fix ctime_r problem on Solaris (I hope)
Simon Marlow <simonmar at microsoft.com>**20060502111231] 
[fix whitespace problem that shows up on Solaris (x86)
Simon Marlow <simonmar at microsoft.com>**20060502110001] 
[libraries/time is boring
Simon Marlow <simonmar at microsoft.com>**20060502105524] 
[add time package to libraries Makefile
Ashley Yakeley <ashley at semantic.org>**20060501092241] 
[add time package to default-packages
Ashley Yakeley <ashley at semantic.org>**20060426070445] 
[fix quoting around ${FPTOOLS_TOP_ABS} (fixes #749)
Simon Marlow <simonmar at microsoft.com>**20060428085252] 
[Fix stage2 segfault on openbsd.
dons at cse.unsw.edu.au**20060428074811
 
 Somewhere along the 6.5 branch, gcc started compiling the rts such that
 it triggers the stack smash handler, causing stage2 to by kill'd
 immediately. This turns off the stack protector, which will do for now.
 
] 
[Fix bug shown in the mod77 test.
Lemmih <lemmih at gmail.com>**20060427113313] 
[Don't init root pointers if they aren't gonna be used.
Lemmih <lemmih at gmail.com>**20060426111143] 
[Fix recompilation checking.
Simon Marlow <simonmar at microsoft.com>**20060425140932
 One-shot compilation was throwing away the old iface read by
 checkOldIface, with the result that version numbers were never being
 incremented.  Fixes the recomp001 test too.
] 
[Solaris needs -lrt for the threaded RTS
Simon Marlow <simonmar at microsoft.com>**20060425082823] 
[fix problem with binary-dist docs
Simon Marlow <simonmar at microsoft.com>**20060424090159] 
[Enable breakpoint support.
Lemmih <lemmih at gmail.com>**20060421113112] 
[Fixing some lexer errors with extcore
Josef Svenningsson <josef.svenningsson at gmail.com>**20060420222625] 
[Extcore can now handle data types without constructors
Josef Svenningsson <josef.svenningsson at gmail.com>**20060420213622] 
[Comments only
Josef Svenningsson <josef.svenningsson at gmail.com>**20060420213555] 
[Resurrect ProjectName
sven.panne at aedion.de**20060421085125] 
[Remove the section on platform support, link to the wiki page
Simon Marlow <simonmar at microsoft.com>**20060420125555
 The section in the building guide was becoming out of date, a wiki
 page is much more likely to be kept fresh.
] 
[Fix workaround for a GHC 6.4 bug
rl at cse.unsw.edu.au**20060420044223] 
[hslibs is dead, Jim...
sven.panne at aedion.de**20060419144609] 
[Synched .spec file with reality
sven.panne at aedion.de**20060419143138] 
[Add .spec file to source distribution
sven.panne at aedion.de**20060419103725] 
[remove paragraph about mutable objects that doesn't apply now
Simon Marlow <simonmar at microsoft.com>**20060419082038] 
[HsBool should be HsInt, not StgBool
Simon Marlow <simonmar at microsoft.com>**20060418144214
 StgBool is mapped to C's int type.  GHC doesn't currently know the
 size of a C int on the target arch, it's easier to use StgInt instead.
 I guess nobody ever uses Bool arguments to foreign imports/exports.
] 
[handle Bool arg to foreign import "wrapper"
Simon Marlow <simonmar at microsoft.com>**20060418143936
 Fixes #746
] 
[update commentry for foreign import "wrapper" handling
Simon Marlow <simonmar at microsoft.com>**20060418143714] 
[remove vestiges of ByteArray and MutableByteArray, which are no more
Simon Marlow <simonmar at microsoft.com>**20060418143641] 
[Comment only
simonpj at microsoft.com**20060418125624] 
[Fix rank-validity testing
simonpj at microsoft.com**20060418125350
 
 GHC does not now do "hoisting" as it used to.  Instead, it allows
 foralls to the right of fuction arrows, as well as to the left.
 
 But the type-validity tester hadn't caught up.  This commit fixes 
 it. The test is tc203.
 
 Incidentally, GHC still doesn't let you write
 	forall a. Eq a => forall b. b -> b
 because we get a zillion reduce/reduce errors if we allow that.  I'm
 sure it's fixable.  But meanwhile you have to use an auxiliary type
 synonym, which is a bit stupid.
 
 
] 
[Make the initial rdr and type scope available in the ghc-api.
Lemmih <lemmih at gmail.com>**20060418023606] 
[Fix minor bug in Linker.withExtendedLinkEnv
Lemmih <lemmih at gmail.com>**20060418023518] 
[Export 'insertSymbol' and 'insertStableSymbol'.
Lemmih <lemmih at gmail.com>**20060418021806
 
 'insertStableSymbol' is used for exporting closures that are affected by the GC.
 
] 
[Allow $x, as well as $(x), at top level in TH
simonpj at microsoft.com**20060414121907
 
 Bulat pointed out that in Template Haskell
    $x
 is allowed instead of 
    $(x)
 in expressions, but not at the top level of modules.
 
 This commit fixes the omission.  Now you can say
 
 	f x = x
  	$h
 	data T = T
 
 and the $h will run Template Haskell just as you'd expect.
 
] 
[Fix TH erorr recovery (test is TH_recover)
simonpj at microsoft.com**20060414120411] 
[Comments only
simonpj at microsoft.com**20060414120359] 
[Recover gracefully from a Template Haskell programmers error
simonpj at microsoft.com**20060414115831
 
 If a TH programmer uses a type constructor as a data constructor,
 GHC simply crashed.  This commit makes it report the error in a
 graceful way.
 
] 
[Document newtype-unwrapping for IO in FFI
simonpj at microsoft.com**20060414105212] 
[Cosmetics in SpecConstr
simonpj at microsoft.com**20060412152721
 
 SpecConstr currently uses substExpr for tiresome reasons to do with
 GADTs.  Unfortunately the substExpr generates some WARNINGS (when DEBUG)
 is on, because we aren't adding all the in-scope Ids to the in-scope
 set of the substitution.
 
 When we move to FC these substExprs will go away, so I'm not going to
 worry about this now.
 
] 
[Improve pruning of case alternatives to account for GADTs
simonpj at microsoft.com**20060412152327
 
 Consider
 
   data T a where
     T1 :: T Int
     T2 :: T Bool
     T3 :: T Char
 
   f :: T Bool -> Int
   f x = case x of
 	  DEFAULT -> ...
 	  T2 -> 3
 
 Here the DEFAULT case covers multiple constructors (T1,T3), but none 
 of them can match a scrutinee of type (T Bool).  So we can prune away
 the default case altogether.
 
 In implementing this, I re-factored this bit of the simplifier, elminiating
 prepareAlts from SimplUtils, and putting all the work into simplAlts in
 Simplify
 
 The proximate cause was a program written by Manuel using PArrays
 
] 
[Fix a bug in optimising division to shift right
Simon Marlow <simonmar at microsoft.com>**20060412144247
 Division by an integral log2 can't be directly optimised to a shift
 right, because shift right behaves like a division that rounds to
 negative infinity, whereas we want one that rounds to zero.  Fix this
 by adding (divisor-1) to the dividend when it is negative before
 shifting.  We do this without jumps, generating very slightly worse
 code than gcc, which uses conditional moves on CPUs that support it.
] 
[Omit lndir on Windows, as it used to be
simonpj at microsoft.com**20060411135334] 
[remove a trace
Simon Marlow <simonmar at microsoft.com>**20060411131531] 
[Allow IO to be wrapped in a newtype in foreign import/export
simonpj at microsoft.com**20060411120441
 
 Up to now, the silent unwrapping of newtypes in foreign import/export
 has been limited to data values.  But it's useful for the IO monad
 itself:
 
 	newtype MyIO a = MIO (IO a)
 
 	foreign import foo :: Int -> MyIO Int
 
 This patch allows the IO monad to be
 wrapped too. This applies to foreign import "dynamic" and "wrapper", 
 thus
    foreign import "wrapper" foo :: MyIO () -> HisIO (FunPtr (MyIO ())) 
 
 Warning: I did on the plane, and I'm no longer sure if its 100% 
 complete, so needs more testing.  In particular the wrapper/dynamic bit.
 
] 
[Improve newtype deriving
simonpj at microsoft.com**20060402215911
 
 Ross Paterson pointed out a useful generalisation of GHC's 
 newtype-deriving mechanism.  This implements it.  The idea
 is to allow
 	newtype Wrap m a = Wrap (m a) deriving (Monad, Eq)
 where the representation type doesn't start with a type
 constructor.
 
 Actually GHC already *did* implement this, but the eta-ok
 check in TcDeriv missed a case, so there was a lurking bug.
 
 This patches fixes the documentation too.  drvrun019 tests.
 
 
] 
[add take to the list of functions deforestable
Simon Marlow <simonmar at microsoft.com>**20060411090131] 
[avoid versionitis in Numeric.showHex (should fix tcrun007)
Simon Marlow <simonmar at microsoft.com>**20060411085009] 
[add a note about full-laziness
Simon Marlow <simonmar at microsoft.com>**20060410093824] 
[robustify the test for the top of the tree a little
Simon Marlow <simonmar at microsoft.com>**20060410082224] 
[Make darcs-all work without a ghc toplevel directory
Josef Svenningsson <josef.svenningsson at gmail.com>**20060407161738] 
[Fix typo in darcsall warning
Josef Svenningsson <josef.svenningsson at gmail.com>**20060407161335] 
[fix source dists
Simon Marlow <simonmar at microsoft.com>**20060407150045] 
[add a README for binary dists
Simon Marlow <simonmar at microsoft.com>**20060407143832] 
[fix binary dists
Simon Marlow <simonmar at microsoft.com>**20060407143822] 
[remove the last bits of the ghc/ subdir
Simon Marlow <simonmar at microsoft.com>**20060407085219] 
[TAG 07.04.06
Lemmih <lemmih at gmail.com>**20060407130411] 
Patch bundle hash:
5296ba758c2a08d669b8ed561c2484d008ba1cb8